| blob | 7e348d3da2b09f90c713132530bc392930daa19b |
1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
66 /* The following symbols are subsumed in the c_global_trees array, and
67 listed here individually for documentation purposes.
69 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
71 tree short_integer_type_node;
72 tree long_integer_type_node;
73 tree long_long_integer_type_node;
75 tree short_unsigned_type_node;
76 tree long_unsigned_type_node;
77 tree long_long_unsigned_type_node;
79 tree truthvalue_type_node;
80 tree truthvalue_false_node;
81 tree truthvalue_true_node;
83 tree ptrdiff_type_node;
85 tree unsigned_char_type_node;
86 tree signed_char_type_node;
87 tree wchar_type_node;
89 tree char16_type_node;
90 tree char32_type_node;
92 tree float_type_node;
93 tree double_type_node;
94 tree long_double_type_node;
96 tree complex_integer_type_node;
97 tree complex_float_type_node;
98 tree complex_double_type_node;
99 tree complex_long_double_type_node;
101 tree dfloat32_type_node;
102 tree dfloat64_type_node;
103 tree_dfloat128_type_node;
105 tree intQI_type_node;
106 tree intHI_type_node;
107 tree intSI_type_node;
108 tree intDI_type_node;
109 tree intTI_type_node;
111 tree unsigned_intQI_type_node;
112 tree unsigned_intHI_type_node;
113 tree unsigned_intSI_type_node;
114 tree unsigned_intDI_type_node;
115 tree unsigned_intTI_type_node;
117 tree widest_integer_literal_type_node;
118 tree widest_unsigned_literal_type_node;
120 Nodes for types `void *' and `const void *'.
122 tree ptr_type_node, const_ptr_type_node;
124 Nodes for types `char *' and `const char *'.
126 tree string_type_node, const_string_type_node;
128 Type `char[SOMENUMBER]'.
129 Used when an array of char is needed and the size is irrelevant.
131 tree char_array_type_node;
133 Type `wchar_t[SOMENUMBER]' or something like it.
134 Used when a wide string literal is created.
136 tree wchar_array_type_node;
138 Type `char16_t[SOMENUMBER]' or something like it.
139 Used when a UTF-16 string literal is created.
141 tree char16_array_type_node;
143 Type `char32_t[SOMENUMBER]' or something like it.
144 Used when a UTF-32 string literal is created.
146 tree char32_array_type_node;
148 Type `int ()' -- used for implicit declaration of functions.
150 tree default_function_type;
152 A VOID_TYPE node, packaged in a TREE_LIST.
154 tree void_list_node;
156 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
157 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
158 VAR_DECLS, but C++ does.)
160 tree function_name_decl_node;
161 tree pretty_function_name_decl_node;
162 tree c99_function_name_decl_node;
164 Stack of nested function name VAR_DECLs.
166 tree saved_function_name_decls;
168 */
171 \f
172 /* Switches common to the C front ends. */
174 /* Nonzero means don't output line number information. */
178 /* Nonzero causes -E output not to be done, but directives such as
179 #define that have side effects are still obeyed. */
183 /* Nonzero means dump macros in some fashion. */
187 /* Nonzero means pass #include lines through to the output. */
191 /* Nonzero means process PCH files while preprocessing. */
195 /* The file name to which we should write a precompiled header, or
196 NULL if no header will be written in this compile. */
200 /* Nonzero if an ISO standard was selected. It rejects macros in the
201 user's namespace. */
204 /* C/ObjC language option variables. */
207 /* Nonzero means allow type mismatches in conditional expressions;
208 just make their values `void'. */
212 /* Nonzero means enable C89 Amendment 1 features. */
216 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
220 /* Nonzero means use the ISO C11 dialect of C. */
224 /* Nonzero means that we have builtin functions, and main is an int. */
229 /* ObjC language option variables. */
232 /* Tells the compiler that this is a special run. Do not perform any
233 compiling, instead we are to test some platform dependent features
234 and output a C header file with appropriate definitions. */
238 /* Tells the compiler what is the constant string class for ObjC. */
243 /* C++ language option variables. */
246 /* Nonzero means generate separate instantiation control files and
247 juggle them at link time. */
251 /* The C++ dialect being used. C++98 is the default. */
255 /* Maximum template instantiation depth. This limit exists to limit the
256 time it takes to notice excessively recursive template instantiations.
258 The default is lower than the 1024 recommended by the C++0x standard
259 because G++ runs out of stack before 1024 with highly recursive template
260 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
264 /* The elements of `ridpointers' are identifier nodes for the reserved
265 type names and storage classes. It is indexed by a RID_... value. */
270 /* Nonzero means don't warn about problems that occur when the code is
271 executed. */
274 /* Whether we are building a boolean conversion inside
275 convert_for_assignment, or some other late binary operation. If
276 build_binary_op is called for C (from code shared by C and C++) in
277 this case, then the operands have already been folded and the
278 result will not be folded again, so C_MAYBE_CONST_EXPR should not
279 be generated. */
282 /* Whether lexing has been completed, so subsequent preprocessor
283 errors should use the compiler's input_location. */
286 /* Information about how a function name is generated. */
287 struct fname_var_t
288 {
292 };
294 /* The three ways of getting then name of the current function. */
297 {
298 /* C99 compliant __func__, must be first. */
300 /* GCC __FUNCTION__ compliant. */
302 /* GCC __PRETTY_FUNCTION__ compliant. */
305 };
307 /* Global visibility options. */
405 /* Reserved words. The third field is a mask: keywords are disabled
406 if they match the mask.
408 Masks for languages:
409 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
410 C --std=c99: D_CXXONLY | D_OBJC
411 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
412 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
413 C++ --std=c0x: D_CONLY | D_OBJC
414 ObjC++ is like C++ except that D_OBJC is not set
416 If -fno-asm is used, D_ASM is added to the mask. If
417 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
418 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
419 In C with -Wc++-compat, we warn if D_CXXWARN is set.
421 Note the complication of the D_CXX_OBJC keywords. These are
422 reserved words such as 'class'. In C++, 'class' is a reserved
423 word. In Objective-C++ it is too. In Objective-C, it is a
424 reserved word too, but only if it follows an '@' sign.
425 */
427 {
590 /* These Objective-C keywords are recognized only immediately after
591 an '@'. */
608 /* These are recognized only in protocol-qualifier context
609 (see above) */
616 /* These are recognized inside a property attribute list */
625 };
630 /* Table of machine-independent attributes common to all C-like languages.
632 All attributes referencing arguments should be additionally processed
633 in chkp_copy_function_type_adding_bounds for correct instrumentation
634 by Pointer Bounds Checker.
635 Current list of processed common attributes: nonnull. */
637 {
638 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
639 affects_type_identity } */
646 /* FIXME: logically, noreturn attributes should be listed as
647 "false, true, true" and apply to function types. But implementing this
648 would require all the places in the compiler that use TREE_THIS_VOLATILE
649 on a decl to identify non-returning functions to be located and fixed
650 to check the function type instead. */
681 /* The same comments as for noreturn attributes apply to const ones. */
705 handle_no_instrument_function_attribute,
723 /* ??? These two attributes didn't make the transition from the
724 Intel language document to the multi-vendor language document. */
729 /* For internal use (marking of builtins) only. The name contains space
730 to prevent its usage in source code. */
752 /* For internal use (marking of builtins) only. The name contains space
753 to prevent its usage in source code. */
764 handle_no_address_safety_analysis_attribute,
767 handle_no_sanitize_address_attribute,
770 handle_no_sanitize_undefined_attribute,
780 /* For internal use only. The leading '*' both prevents its usage in
781 source code and signals that it may be overridden by machine tables. */
786 /* For internal use (marking of builtins and runtime functions) only.
787 The name contains space to prevent its usage in source code. */
813 };
815 /* Give the specifications for the format attributes, used by C and all
816 descendants.
818 All attributes referencing arguments should be additionally processed
819 in chkp_copy_function_type_adding_bounds for correct instrumentation
820 by Pointer Bounds Checker.
821 Current list of processed format attributes: format, format_arg. */
823 {
824 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
825 affects_type_identity } */
831 };
833 /* Return identifier for address space AS. */
837 {
841 }
843 /* Push current bindings for the function name VAR_DECLS. */
845 void
847 {
852 {
856 {
858 saved);
860 }
861 }
863 /* Normally they'll have been NULL, so only push if we've got a
864 stack, or they are non-NULL. */
866 saved_function_name_decls);
867 }
869 /* Finish up the current bindings, adding them into the current function's
870 statement tree. This must be done _before_ finish_stmt_tree is called.
871 If there is no current function, we must be at file scope and no statements
872 are involved. Pop the previous bindings. */
874 void
876 {
885 {
893 }
899 {
900 /* We had saved values, restore them. */
901 tree saved;
904 {
909 }
911 }
913 }
915 /* Return the text name of the current function, suitably prettified
916 by PRETTY_P. Return string must be freed by caller. */
920 {
927 {
930 }
943 {
946 }
949 }
951 /* Return the VAR_DECL for a const char array naming the current
952 function. If the VAR_DECL has not yet been created, create it
953 now. RID indicates how it should be formatted and IDENTIFIER_NODE
954 ID is its name (unfortunately C and C++ hold the RID values of
955 keywords in different places, so we can't derive RID from ID in
956 this language independent code. LOC is the location of the
957 function. */
959 tree
961 {
971 {
972 /* If a tree is built here, it would normally have the lineno of
973 the current statement. Later this tree will be moved to the
974 beginning of the function and this line number will be wrong.
975 To avoid this problem set the lineno to 0 here; that prevents
976 it from appearing in the RTL. */
977 tree stmts;
985 saved_function_name_decls
989 }
994 }
996 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
998 tree
1000 {
1005 /* Compute the number of elements, for the array type. */
1007 {
1010 }
1012 {
1015 }
1017 {
1020 }
1021 else
1022 {
1025 }
1027 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1028 limit in C++98 Annex B is very large (65536) and is not normative,
1029 so we do not diagnose it (warn_overlength_strings is forced off
1030 in c_common_post_options). */
1032 {
1036 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1037 separate the %d from the 'C'. 'ISO' should not be
1038 translated, but it may be moved after 'C%d' in languages
1039 where modifiers follow nouns. */
1041 "string length %qd is greater than the length %qd "
1044 }
1046 /* Create the array type for the string constant. The ISO C++
1047 standard says that a string literal has type `const char[N]' or
1048 `const wchar_t[N]'. We use the same logic when invoked as a C
1049 front-end with -Wwrite-strings.
1050 ??? We should change the type of an expression depending on the
1051 state of a warning flag. We should just be warning -- see how
1052 this is handled in the C++ front-end for the deprecated implicit
1053 conversion from string literals to `char*' or `wchar_t*'.
1055 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1056 array type being the unqualified version of that type.
1057 Therefore, if we are constructing an array of const char, we must
1058 construct the matching unqualified array type first. The C front
1059 end does not require this, but it does no harm, so we do it
1060 unconditionally. */
1071 }
1072 \f
1073 /* If DISABLE is true, stop issuing warnings. This is used when
1074 parsing code that we know will not be executed. This function may
1075 be called multiple times, and works as a stack. */
1077 static void
1079 {
1081 {
1084 }
1085 }
1087 /* If ENABLE is true, reenable issuing warnings. */
1089 static void
1091 {
1093 {
1096 }
1097 }
1099 /* Fully fold EXPR, an expression that was not folded (beyond integer
1100 constant expressions and null pointer constants) when being built
1101 up. If IN_INIT, this is in a static initializer and certain
1102 changes are made to the folding done. Clear *MAYBE_CONST if
1103 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1104 expression because it contains an evaluated operator (in C99) or an
1105 operator outside of sizeof returning an integer constant (in C90)
1106 not permitted in constant expressions, or because it contains an
1107 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1108 set to true by callers before calling this function.) Return the
1109 folded expression. Function arguments have already been folded
1110 before calling this function, as have the contents of SAVE_EXPR,
1111 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1112 C_MAYBE_CONST_EXPR. */
1114 tree
1116 {
1117 tree ret;
1123 /* This function is not relevant to C++ because C++ folds while
1124 parsing, and may need changes to be correct for C++ when C++
1125 stops folding while parsing. */
1132 {
1135 }
1142 }
1144 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1145 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1146 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1147 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1148 both evaluated and unevaluated subexpressions while
1149 *MAYBE_CONST_ITSELF is carried from only evaluated
1150 subexpressions). */
1152 static tree
1155 {
1167 /* This function is not relevant to C++ because C++ folds while
1168 parsing, and may need changes to be correct for C++ when C++
1169 stops folding while parsing. */
1173 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1174 anything else not counted as an expression cannot usefully be
1175 folded further at this point. */
1181 /* Operands of variable-length expressions (function calls) have
1182 already been folded, as have __builtin_* function calls, and such
1183 expressions cannot occur in constant expressions. */
1185 {
1189 }
1192 {
1201 else
1204 }
1206 /* Assignment, increment, decrement, function call and comma
1207 operators, and statement expressions, cannot occur in constant
1208 expressions if evaluated / outside of sizeof. (Function calls
1209 were handled above, though VA_ARG_EXPR is treated like a function
1210 call here, and statement expressions are handled through
1211 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1213 {
1233 }
1235 /* Fold individual tree codes as appropriate. */
1237 {
1239 /* Any non-constancy will have been marked in a containing
1240 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1248 maybe_const_itself);
1253 {
1256 }
1265 maybe_const_itself);
1268 maybe_const_itself);
1274 {
1278 }
1320 /* Binary operations evaluating both arguments (increment and
1321 decrement are binary internally in GCC). */
1325 maybe_const_itself);
1333 /* The RHS of a MODIFY_EXPR was fully folded when building that
1334 expression for the sake of conversion warnings. */
1337 maybe_const_itself);
1341 ret = in_init
1344 else
1357 {
1368 }
1374 CASE_CONVERT:
1385 /* Unary operations. */
1388 maybe_const_itself);
1392 /* ??? Cope with user tricks that amount to offsetof. The middle-end is
1393 not prepared to deal with them if they occur in initializers. */
1401 ret = in_init
1404 else
1409 {
1413 }
1415 {
1418 CASE_CONVERT:
1419 /* Don't warn about explicit conversions. We will already
1420 have warned about suspect implicit conversions. */
1427 }
1432 /* Binary operations not necessarily evaluating both
1433 arguments. */
1440 ? truthvalue_false_node
1448 ret = in_init
1451 else
1456 && op0_const
1457 && op0_const_self
1463 && op0_const_self
1489 else
1494 && op0_const
1495 && op0_const_self
1499 && op0_const_self
1503 && op0_const
1504 && op0_const_self
1508 && op0_const_self
1514 /* Each case where an operand with excess precision may be
1515 encountered must remove the EXCESS_PRECISION_EXPR around
1516 inner operands and possibly put one around the whole
1517 expression or possibly convert to the semantic type (which
1518 c_fully_fold does); we cannot tell at this stage which is
1519 appropriate in any particular case. */
1523 /* Various codes may appear through folding built-in functions
1524 and their arguments. */
1526 }
1528 out:
1529 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1530 have been done by this point, so remove them again. */
1534 {
1538 }
1542 }
1544 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1545 return EXP. Otherwise, return either EXP or its known constant
1546 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1547 Is the BLKmode test appropriate? */
1549 tree
1551 {
1552 tree ret;
1554 /* This function is only used by C, for c_fully_fold and other
1555 optimization, and may not be correct for C++. */
1566 /* Avoid unwanted tree sharing between the initializer and current
1567 function's body where the tree can be modified e.g. by the
1568 gimplifier. */
1572 }
1574 /* Print a warning if a constant expression had overflow in folding.
1575 Invoke this function on every expression that the language
1576 requires to be a constant expression.
1577 Note the ANSI C standard says it is erroneous for a
1578 constant expression to overflow. */
1580 void
1582 {
1590 }
1592 /* The same as above but print an unconditional error. */
1593 void
1595 {
1602 }
1604 /* Print a warning if an expression had overflow in folding and its
1605 operands hadn't.
1607 Invoke this function on every expression that
1608 (1) appears in the source code, and
1609 (2) is a constant expression that overflowed, and
1610 (3) is not already checked by convert_and_check;
1611 however, do not invoke this function on operands of explicit casts
1612 or when the expression is the result of an operator and any operand
1613 already overflowed. */
1615 void
1617 {
1622 {
1651 }
1652 }
1654 /* Warn about uses of logical || / && operator in a context where it
1655 is likely that the bitwise equivalent was intended by the
1656 programmer. We have seen an expression in which CODE is a binary
1657 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1658 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1659 void
1663 {
1675 /* Warn if &&/|| are being used in a context where it is
1676 likely that the bitwise equivalent was intended by the
1677 programmer. That is, an expression such as op && MASK
1678 where op should not be any boolean expression, nor a
1679 constant, and mask seems to be a non-boolean integer constant. */
1687 {
1691 else
1696 }
1698 /* We do not warn for constants because they are typical of macro
1699 expansions that test for features. */
1703 /* This warning only makes sense with logical operands. */
1710 /* The range computations only work with scalars. */
1715 /* We first test whether either side separately is trivially true
1716 (with OR) or trivially false (with AND). If so, do not warn.
1717 This is a common idiom for testing ranges of data types in
1718 portable code. */
1725 /* If this is an OR operation, invert both sides; now, the result
1726 should be always false to get a warning. */
1740 /* If this is an OR operation, invert both sides; now, the result
1741 should be always false to get a warning. */
1749 /* If both expressions have the same operand, if we can merge the
1750 ranges, and if the range test is always false, then warn. */
1757 {
1760 "logical %<or%> "
1762 else
1764 "logical %<and%> "
1766 }
1767 }
1769 /* Warn about logical not used on the left hand side operand of a comparison.
1770 This function assumes that the LHS is inside of TRUTH_NOT_EXPR.
1771 Do not warn if RHS is of a boolean type. */
1773 void
1775 tree rhs)
1776 {
1783 "logical not is only applied to the left hand side of "
1785 }
1787 /* Warn if EXP contains any computations whose results are not used.
1788 Return true if a warning is printed; false otherwise. LOCUS is the
1789 (potential) location of the expression. */
1791 bool
1793 {
1794 restart:
1798 /* Don't warn about void constructs. This includes casting to void,
1799 void function calls, and statement expressions with a final cast
1800 to void. */
1808 {
1824 /* For a binding, warn if no side effect within it. */
1836 /* In && or ||, warn if 2nd operand has no side effect. */
1843 /* Let people do `(foo (), 0)' without a warning. */
1850 /* If this is an expression with side effects, don't warn; this
1851 case commonly appears in macro expansions. */
1857 /* Don't warn about automatic dereferencing of references, since
1858 the user cannot control it. */
1860 {
1863 }
1864 /* Fall through. */
1867 /* Referencing a volatile value is a side effect, so don't warn. */
1872 /* If this is an expression which has no operands, there is no value
1873 to be unused. There are no such language-independent codes,
1874 but front ends may define such. */
1878 warn:
1880 }
1881 }
1884 /* Print a warning about casts that might indicate violation
1885 of strict aliasing rules if -Wstrict-aliasing is used and
1886 strict aliasing mode is in effect. OTYPE is the original
1887 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1889 bool
1891 {
1892 /* Strip pointer conversion chains and get to the correct original type. */
1900 /* If the type we are casting to is a ref-all pointer
1901 dereferencing it is always valid. */
1908 {
1909 /* Casting the address of an object to non void pointer. Warn
1910 if the cast breaks type based aliasing. */
1912 {
1916 }
1917 else
1918 {
1919 /* warn_strict_aliasing >= 3. This includes the default (3).
1920 Only warn if the cast is dereferenced immediately. */
1921 alias_set_type set1 =
1927 {
1931 }
1934 {
1938 }
1939 }
1940 }
1941 else
1943 {
1944 /* At this level, warn for any conversions, even if an address is
1945 not taken in the same statement. This will likely produce many
1946 false positives, but could be useful to pinpoint problems that
1947 are not revealed at higher levels. */
1952 {
1956 }
1957 }
1960 }
1962 /* Warn about memset (&a, 0, sizeof (&a)); and similar mistakes with
1963 sizeof as last operand of certain builtins. */
1965 void
1969 {
1973 location_t loc;
1981 {
1985 /* FALLTHRU */
1993 /* FALLTHRU */
2052 }
2080 {
2084 {
2087 "argument to %<sizeof%> in %qD call is the same "
2088 "expression as the destination; did you mean to "
2094 "argument to %<sizeof%> in %qD call is the same "
2095 "expression as the destination; did you mean to "
2097 else
2099 "argument to %<sizeof%> in %qD call is the same "
2100 "expression as the destination; did you mean to "
2103 }
2106 && !strop
2109 {
2111 "argument to %<sizeof%> in %qD call is the same "
2112 "pointer type %qT as the destination; expected %qT "
2116 }
2117 }
2120 {
2124 {
2127 "argument to %<sizeof%> in %qD call is the same "
2128 "expression as the source; did you mean to "
2134 "argument to %<sizeof%> in %qD call is the same "
2135 "expression as the source; did you mean to "
2137 else
2139 "argument to %<sizeof%> in %qD call is the same "
2140 "expression as the source; did you mean to "
2143 }
2146 && !strop
2149 {
2151 "argument to %<sizeof%> in %qD call is the same "
2152 "pointer type %qT as the source; expected %qT "
2156 }
2157 }
2160 {
2164 {
2167 "argument to %<sizeof%> in %qD call is the same "
2168 "expression as the first source; did you mean to "
2174 "argument to %<sizeof%> in %qD call is the same "
2175 "expression as the first source; did you mean to "
2177 else
2179 "argument to %<sizeof%> in %qD call is the same "
2180 "expression as the first source; did you mean to "
2183 }
2186 && !strop
2189 {
2191 "argument to %<sizeof%> in %qD call is the same "
2192 "pointer type %qT as the first source; expected %qT "
2196 }
2197 }
2200 {
2204 {
2207 "argument to %<sizeof%> in %qD call is the same "
2208 "expression as the second source; did you mean to "
2214 "argument to %<sizeof%> in %qD call is the same "
2215 "expression as the second source; did you mean to "
2217 else
2219 "argument to %<sizeof%> in %qD call is the same "
2220 "expression as the second source; did you mean to "
2223 }
2226 && !strop
2229 {
2231 "argument to %<sizeof%> in %qD call is the same "
2232 "pointer type %qT as the second source; expected %qT "
2236 }
2237 }
2239 }
2241 /* Warn for unlikely, improbable, or stupid DECL declarations
2242 of `main'. */
2244 void
2246 {
2247 function_args_iterator iter;
2248 tree type;
2252 {
2253 /* XXX void_type_node belies the abstraction. */
2263 {
2269 }
2273 {
2295 "third argument of %q+D should probably be "
2298 }
2299 }
2301 /* It is intentional that this message does not mention the third
2302 argument because it's only mentioned in an appendix of the
2303 standard. */
2311 }
2313 /* vector_targets_convertible_p is used for vector pointer types. The
2314 callers perform various checks that the qualifiers are satisfactory,
2315 while OTOH vector_targets_convertible_p ignores the number of elements
2316 in the vectors. That's fine with vector pointers as we can consider,
2317 say, a vector of 8 elements as two consecutive vectors of 4 elements,
2318 and that does not require and conversion of the pointer values.
2319 In contrast, vector_types_convertible_p and
2320 vector_types_compatible_elements_p are used for vector value types. */
2321 /* True if pointers to distinct types T1 and T2 can be converted to
2322 each other without an explicit cast. Only returns true for opaque
2323 vector types. */
2324 bool
2326 {
2333 }
2335 /* vector_types_convertible_p is used for vector value types.
2336 It could in principle call vector_targets_convertible_p as a subroutine,
2337 but then the check for vector type would be duplicated with its callers,
2338 and also the purpose of vector_targets_convertible_p would become
2339 muddled.
2340 Where vector_types_convertible_p returns true, a conversion might still be
2341 needed to make the types match.
2342 In contrast, vector_targets_convertible_p is used for vector pointer
2343 values, and vector_types_compatible_elements_p is used specifically
2344 in the context for binary operators, as a check if use is possible without
2345 conversion. */
2346 /* True if vector types T1 and T2 can be converted to each other
2347 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
2348 can only be converted with -flax-vector-conversions yet that is not
2349 in effect, emit a note telling the user about that option if such
2350 a note has not previously been emitted. */
2351 bool
2353 {
2361 convertible_lax =
2376 {
2379 "conversions between vectors with differing "
2381 }
2384 }
2386 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
2387 and have vector types, V0 has the same type as V1, and the number of
2388 elements of V0, V1, MASK is the same.
2390 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2391 called with two arguments. In this case implementation passes the
2392 first argument twice in order to share the same tree code. This fact
2393 could enable the mask-values being twice the vector length. This is
2394 an implementation accident and this semantics is not guaranteed to
2395 the user. */
2396 tree
2399 {
2400 tree ret;
2406 {
2409 }
2417 {
2422 }
2426 {
2430 }
2433 {
2438 }
2444 {
2447 "argument vector(s) and the mask vector should "
2450 }
2454 {
2459 }
2462 {
2463 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
2469 else
2470 {
2473 }
2477 }
2487 }
2489 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
2490 to integral type. */
2492 static tree
2494 {
2499 {
2500 /* C++0x scoped enumerations don't implicitly convert to integral
2501 type; if we stripped an explicit conversion to a larger type we
2502 need to replace it so common_type will still work. */
2506 }
2508 }
2510 /* This is a helper function of build_binary_op.
2512 For certain operations if both args were extended from the same
2513 smaller type, do the arithmetic in that type and then extend.
2515 BITWISE indicates a bitwise operation.
2516 For them, this optimization is safe only if
2517 both args are zero-extended or both are sign-extended.
2518 Otherwise, we might change the result.
2519 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2520 but calculated in (unsigned short) it would be (unsigned short)-1.
2521 */
2522 tree
2524 {
2528 tree type;
2530 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
2531 excessive narrowing when we call get_narrower below. For
2532 example, suppose that OP0 is of unsigned int extended
2533 from signed char and that RESULT_TYPE is long long int.
2534 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
2535 like
2537 (long long int) (unsigned int) signed_char
2539 which get_narrower would narrow down to
2541 (unsigned int) signed char
2543 If we do not cast OP0 first, get_narrower would return
2544 signed_char, which is inconsistent with the case of the
2545 explicit cast. */
2552 /* UNS is 1 if the operation to be done is an unsigned one. */
2555 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2556 but it *requires* conversion to FINAL_TYPE. */
2567 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2569 /* For bitwise operations, signedness of nominal type
2570 does not matter. Consider only how operands were extended. */
2574 /* Note that in all three cases below we refrain from optimizing
2575 an unsigned operation on sign-extended args.
2576 That would not be valid. */
2578 /* Both args variable: if both extended in same way
2579 from same width, do it in that width.
2580 Do it unsigned if args were zero-extended. */
2587 return c_common_signed_or_unsigned_type
2594 && (type
2605 && (type
2613 }
2615 /* Checks if expression EXPR of real/integer type cannot be converted
2616 to the real/integer type TYPE. Function returns non-zero when:
2617 * EXPR is a constant which cannot be exactly converted to TYPE.
2618 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
2619 for EXPR type and TYPE being both integers or both real.
2620 * EXPR is not a constant of real type and TYPE is an integer.
2621 * EXPR is not a constant of integer type which cannot be
2622 exactly converted to real type.
2623 Function allows conversions between types of different signedness and
2624 can return SAFE_CONVERSION (zero) in that case. Function can produce
2625 signedness warnings if PRODUCE_WARNS is true. */
2627 enum conversion_safety
2629 {
2635 {
2636 /* Warn for real constant that is not an exact integer converted
2637 to integer type. */
2640 {
2643 }
2644 /* Warn for an integer constant that does not fit into integer type. */
2648 {
2651 {
2655 }
2657 {
2661 }
2662 else
2664 }
2666 {
2667 /* Warn for an integer constant that does not fit into real type. */
2669 {
2673 }
2674 /* Warn for a real constant that does not fit into a smaller
2675 real type. */
2678 {
2682 }
2683 }
2684 }
2685 else
2686 {
2687 /* Warn for real types converted to integer types. */
2694 {
2695 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2699 /* Don't warn for short y; short x = ((int)y & 0xff); */
2703 {
2704 /* If both args were extended from a shortest type,
2705 use that type if that is safe. */
2712 {
2718 /* If one of the operands is a non-negative constant
2719 that fits in the target type, then the type of the
2720 other operand does not matter. */
2729 /* If constant is unsigned and fits in the target
2730 type, then the result will also fit. */
2732 && unsigned0
2735 && unsigned1
2738 }
2739 }
2740 /* Warn for integer types converted to smaller integer types. */
2744 /* When they are the same width but different signedness,
2745 then the value may change. */
2748 /* Even when converted to a bigger type, if the type is
2749 unsigned but expr is signed, then negative values
2750 will be changed. */
2756 }
2758 /* Warn for integer types converted to real types if and only if
2759 all the range of values of the integer type cannot be
2760 represented by the real type. */
2763 {
2767 /* Don't warn about char y = 0xff; float x = (int) y; */
2779 }
2781 /* Warn for real types converted to smaller real types. */
2786 }
2789 }
2791 /* Warns if the conversion of EXPR to TYPE may alter a value.
2792 This is a helper function for warnings_for_convert_and_check. */
2794 static void
2796 {
2803 /* This may happen, because for LHS op= RHS we preevaluate
2804 RHS and create C_MAYBE_CONST_EXPR <SAVE_EXPR <RHS>>, which
2805 means we could no longer see the code of the EXPR. */
2812 {
2825 /* Conversion from boolean to a signed:1 bit-field (which only
2826 can hold the values 0 and -1) doesn't lose information - but
2827 it does change the value. */
2847 {
2848 /* In case of COND_EXPR, we do not care about the type of
2849 COND_EXPR, only about the conversion of each operand. */
2856 }
2868 }
2869 }
2871 /* Produce warnings after a conversion. RESULT is the result of
2872 converting EXPR to TYPE. This is a helper function for
2873 convert_and_check and cp_convert_and_check. */
2875 void
2877 tree result)
2878 {
2885 {
2886 /* Do not diagnose overflow in a constant expression merely
2887 because a conversion overflowed. */
2892 {
2893 /* This detects cases like converting -129 or 256 to
2894 unsigned char. */
2898 else
2900 }
2904 /* No warning for converting 0x80000000 to int. */
2912 else
2914 }
2919 else
2921 }
2924 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2925 Invoke this function on every expression that is converted implicitly,
2926 i.e. because of language rules and not because of an explicit cast. */
2928 tree
2930 {
2931 tree result;
2932 tree expr_for_warning;
2934 /* Convert from a value with possible excess precision rather than
2935 via the semantic type, but do not warn about values not fitting
2936 exactly in the semantic type. */
2938 {
2944 }
2945 else
2959 }
2960 \f
2961 /* A node in a list that describes references to variables (EXPR), which are
2962 either read accesses if WRITER is zero, or write accesses, in which case
2963 WRITER is the parent of EXPR. */
2964 struct tlist
2965 {
2968 };
2970 /* Used to implement a cache the results of a call to verify_tree. We only
2971 use this for SAVE_EXPRs. */
2972 struct tlist_cache
2973 {
2977 tree expr;
2978 };
2980 /* Obstack to use when allocating tlist structures, and corresponding
2981 firstobj. */
2985 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2986 warnings. */
2988 /* SAVE_EXPRs need special treatment. We process them only once and then
2989 cache the results. */
3001 /* Create a new struct tlist and fill in its fields. */
3004 {
3011 }
3013 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
3014 is nonnull, we ignore any node we find which has a writer equal to it. */
3016 static void
3018 {
3020 {
3027 }
3028 }
3030 /* Merge the nodes of ADD into TO. This merging process is done so that for
3031 each variable that already exists in TO, no new node is added; however if
3032 there is a write access recorded in ADD, and an occurrence on TO is only
3033 a read access, then the occurrence in TO will be modified to record the
3034 write. */
3036 static void
3038 {
3045 {
3052 {
3056 }
3058 {
3062 }
3064 }
3065 }
3067 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
3068 references in list LIST conflict with it, excluding reads if ONLY writers
3069 is nonzero. */
3071 static void
3074 {
3077 /* Avoid duplicate warnings. */
3083 {
3087 {
3092 }
3094 }
3095 }
3097 /* Given a list LIST of references to variables, find whether any of these
3098 can cause conflicts due to missing sequence points. */
3100 static void
3102 {
3106 {
3109 }
3110 }
3112 /* Return nonzero if X is a tree that can be verified by the sequence point
3113 warnings. */
3114 static int
3116 {
3123 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
3124 (lvalue_p) crash on TRY/CATCH. */
3131 /* No point to track non-const calls, they will never satisfy
3132 operand_equal_p. */
3140 }
3142 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
3143 static bool
3145 {
3147 }
3149 /* Walk the tree X, and record accesses to variables. If X is written by the
3150 parent tree, WRITER is the parent.
3151 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
3152 expression or its only operand forces a sequence point, then everything up
3153 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
3154 in PNO_SP.
3155 Once we return, we will have emitted warnings if any subexpression before
3156 such a sequence point could be undefined. On a higher level, however, the
3157 sequence point may not be relevant, and we'll merge the two lists.
3159 Example: (b++, a) + b;
3160 The call that processes the COMPOUND_EXPR will store the increment of B
3161 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
3162 processes the PLUS_EXPR will need to merge the two lists so that
3163 eventually, all accesses end up on the same list (and we'll warn about the
3164 unordered subexpressions b++ and b.
3166 A note on merging. If we modify the former example so that our expression
3167 becomes
3168 (b++, b) + a
3169 care must be taken not simply to add all three expressions into the final
3170 PNO_SP list. The function merge_tlist takes care of that by merging the
3171 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
3172 way, so that no more than one access to B is recorded. */
3174 static void
3176 tree writer)
3177 {
3182 /* X may be NULL if it is the operand of an empty statement expression
3183 ({ }). */
3187 restart:
3195 {
3228 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
3229 two first, to avoid warning for (a ? b++ : b++). */
3245 /* Expressions inside the LHS are not ordered wrt. the sequence points
3246 in the RHS. Example:
3247 *a = (a++, 2)
3248 Despite the fact that the modification of "a" is in the before_sp
3249 list (tmp_before), it conflicts with the use of "a" in the LHS.
3250 We can handle this by adding the contents of tmp_list3
3251 to those of tmp_before, and redoing the collision warnings for that
3252 list. */
3255 /* Exclude the LHS itself here; we first have to merge it into the
3256 tmp_nosp list. This is done to avoid warning for "a = a"; if we
3257 didn't exclude the LHS, we'd get it twice, once as a read and once
3258 as a write. */
3269 /* We need to warn about conflicts among arguments and conflicts between
3270 args and the function address. Side effects of the function address,
3271 however, are not ordered by the sequence point of the call. */
3272 {
3273 call_expr_arg_iterator iter;
3274 tree arg;
3278 {
3283 }
3288 }
3291 /* Scan all the list, e.g. indices of multi dimensional array. */
3293 {
3299 }
3303 {
3310 {
3324 }
3328 }
3338 /* For other expressions, simply recurse on their operands.
3339 Manual tail recursion for unary expressions.
3340 Other non-expressions need not be processed. */
3342 {
3346 }
3348 {
3352 {
3357 }
3358 }
3360 }
3361 }
3363 /* Try to warn for undefined behavior in EXPR due to missing sequence
3364 points. */
3366 DEBUG_FUNCTION void
3368 {
3374 {
3377 }
3382 }
3383 \f
3384 /* Validate the expression after `case' and apply default promotions. */
3386 static tree
3388 {
3393 /* Promote char or short to int. */
3396 {
3399 }
3404 }
3405 \f
3406 /* See if the case values LOW and HIGH are in the range of the original
3407 type (i.e. before the default conversion to int) of the switch testing
3408 expression.
3409 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
3410 the type before promoting it. CASE_LOW_P is a pointer to the lower
3411 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
3412 if the case is not a case range.
3413 The caller has to make sure that we are not called with NULL for
3414 CASE_LOW_P (i.e. the default case).
3415 Returns true if the case label is in range of ORIG_TYPE (saturated or
3416 untouched) or false if the label is out of range. */
3418 static bool
3421 {
3426 /* If there was a problem with the original type, do nothing. */
3433 /* Case label is less than minimum for type. */
3436 {
3440 }
3442 /* Case value is greater than maximum for type. */
3445 {
3448 }
3450 /* Saturate lower case label value to minimum. */
3453 {
3457 }
3459 /* Saturate upper case label value to maximum. */
3462 {
3466 }
3474 }
3475 \f
3476 /* Return an integer type with BITS bits of precision,
3477 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
3479 tree
3481 {
3523 }
3525 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
3526 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
3527 and saturating if SATP is nonzero, otherwise not saturating. */
3529 tree
3532 {
3533 machine_mode mode;
3536 else
3544 {
3546 "fixed-point types that have too many integral and "
3549 }
3552 }
3554 /* Used for communication between c_common_type_for_mode and
3555 c_register_builtin_type. */
3556 tree registered_builtin_types;
3558 /* Return a data type that has machine mode MODE.
3559 If the mode is an integer,
3560 then UNSIGNEDP selects between signed and unsigned types.
3561 If the mode is a fixed-point mode,
3562 then UNSIGNEDP selects between saturating and nonsaturating types. */
3564 tree
3566 {
3567 tree t;
3607 #if HOST_BITS_PER_WIDE_INT >= 64
3610 #endif
3635 {
3636 machine_mode inner_mode;
3637 tree inner_type;
3653 }
3655 {
3660 }
3670 {
3756 }
3764 }
3766 tree
3768 {
3770 }
3772 /* Return a signed type the same as TYPE in other respects. */
3774 tree
3776 {
3778 }
3780 /* Return a type the same as TYPE except unsigned or
3781 signed according to UNSIGNEDP. */
3783 tree
3785 {
3786 tree type1;
3789 /* This block of code emulates the behavior of the old
3790 c_common_unsigned_type. In particular, it returns
3791 long_unsigned_type_node if passed a long, even when a int would
3792 have the same size. This is necessary for warnings to work
3793 correctly in archs where sizeof(int) == sizeof(long) */
3796 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3816 #if HOST_BITS_PER_WIDE_INT >= 64
3819 #endif
3829 #define C_COMMON_FIXED_TYPES(NAME) \
3830 if (type1 == short_ ## NAME ## _type_node \
3831 || type1 == unsigned_short_ ## NAME ## _type_node) \
3832 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3833 : short_ ## NAME ## _type_node; \
3834 if (type1 == NAME ## _type_node \
3835 || type1 == unsigned_ ## NAME ## _type_node) \
3836 return unsignedp ? unsigned_ ## NAME ## _type_node \
3837 : NAME ## _type_node; \
3838 if (type1 == long_ ## NAME ## _type_node \
3839 || type1 == unsigned_long_ ## NAME ## _type_node) \
3840 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3841 : long_ ## NAME ## _type_node; \
3842 if (type1 == long_long_ ## NAME ## _type_node \
3843 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3844 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3845 : long_long_ ## NAME ## _type_node;
3847 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3848 if (type1 == NAME ## _type_node \
3849 || type1 == u ## NAME ## _type_node) \
3850 return unsignedp ? u ## NAME ## _type_node \
3851 : NAME ## _type_node;
3853 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3854 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3855 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3856 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3857 : sat_ ## short_ ## NAME ## _type_node; \
3858 if (type1 == sat_ ## NAME ## _type_node \
3859 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3860 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3861 : sat_ ## NAME ## _type_node; \
3862 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3863 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3864 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3865 : sat_ ## long_ ## NAME ## _type_node; \
3866 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3867 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3868 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3869 : sat_ ## long_long_ ## NAME ## _type_node;
3871 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3872 if (type1 == sat_ ## NAME ## _type_node \
3873 || type1 == sat_ ## u ## NAME ## _type_node) \
3874 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3875 : sat_ ## NAME ## _type_node;
3901 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3902 the precision; they have precision set to match their range, but
3903 may use a wider mode to match an ABI. If we change modes, we may
3904 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3905 the precision as well, so as to yield correct results for
3906 bit-field types. C++ does not have these separate bit-field
3907 types, and producing a signed or unsigned variant of an
3908 ENUMERAL_TYPE may cause other problems as well. */
3914 #define TYPE_OK(node) \
3915 (TYPE_MODE (type) == TYPE_MODE (node) \
3916 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3940 #if HOST_BITS_PER_WIDE_INT >= 64
3943 #endif
3952 #undef TYPE_OK
3955 }
3957 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3959 tree
3961 {
3964 /* Extended integer types of the same width as a standard type have
3965 lesser rank, so those of the same width as int promote to int or
3966 unsigned int and are valid for printf formats expecting int or
3967 unsigned int. To avoid such special cases, avoid creating
3968 extended integer types for bit-fields if a standard integer type
3969 is available. */
3987 }
3989 /* The C version of the register_builtin_type langhook. */
3991 void
3993 {
3994 tree decl;
4004 }
4005 \f
4006 /* Print an error message for invalid operands to arith operation
4007 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
4008 LOCATION is the location of the message. */
4010 void
4013 {
4017 {
4062 }
4066 }
4067 \f
4068 /* Given an expression as a tree, return its original type. Do this
4069 by stripping any conversion that preserves the sign and precision. */
4070 static tree
4072 {
4075 }
4077 /* Subroutine of build_binary_op, used for comparison operations.
4078 See if the operands have both been converted from subword integer types
4079 and, if so, perhaps change them both back to their original type.
4080 This function is also responsible for converting the two operands
4081 to the proper common type for comparison.
4083 The arguments of this function are all pointers to local variables
4084 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
4085 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
4087 LOC is the location of the comparison.
4089 If this function returns nonzero, it means that the comparison has
4090 a constant value. What this function returns is an expression for
4091 that value. */
4093 tree
4096 {
4097 tree type;
4105 /* Throw away any conversions to wider types
4106 already present in the operands. */
4111 /* If primopN is first sign-extended from primopN's precision to opN's
4112 precision, then zero-extended from opN's precision to
4113 *restype_ptr precision, shortenings might be invalid. */
4116 && !unsignedp0
4121 && !unsignedp1
4125 /* Handle the case that OP0 does not *contain* a conversion
4126 but it *requires* conversion to FINAL_TYPE. */
4133 /* If one of the operands must be floated, we cannot optimize. */
4137 /* If first arg is constant, swap the args (changing operation
4138 so value is preserved), for canonicalization. Don't do this if
4139 the second arg is 0. */
4144 {
4161 {
4176 }
4178 }
4180 /* If comparing an integer against a constant more bits wide,
4181 maybe we can deduce a value of 1 or 0 independent of the data.
4182 Or else truncate the constant now
4183 rather than extend the variable at run time.
4185 This is only interesting if the constant is the wider arg.
4186 Also, it is not safe if the constant is unsigned and the
4187 variable arg is signed, since in this case the variable
4188 would be sign-extended and then regarded as unsigned.
4189 Our technique fails in this case because the lowest/highest
4190 possible unsigned results don't follow naturally from the
4191 lowest/highest possible values of the variable operand.
4192 For just EQ_EXPR and NE_EXPR there is another technique that
4193 could be used: see if the constant can be faithfully represented
4194 in the other operand's type, by truncating it and reextending it
4195 and see if that preserves the constant's value. */
4201 {
4204 /* 1 if comparison is nominally unsigned. */
4206 tree val;
4218 {
4219 /* Convert primop1 to target type, but do not introduce
4220 additional overflow. We know primop1 is an int_cst. */
4227 }
4229 {
4232 }
4240 /* This used to be a switch, but Genix compiler can't handle that. */
4242 {
4245 }
4247 {
4250 }
4252 {
4257 }
4259 {
4264 }
4266 {
4271 }
4273 {
4278 }
4280 /* If primop0 was sign-extended and unsigned comparison specd,
4281 we did a signed comparison above using the signed type bounds.
4282 But the comparison we output must be unsigned.
4284 Also, for inequalities, VAL is no good; but if the signed
4285 comparison had *any* fixed result, it follows that the
4286 unsigned comparison just tests the sign in reverse
4287 (positive values are LE, negative ones GE).
4288 So we can generate an unsigned comparison
4289 against an extreme value of the signed type. */
4292 {
4295 {
4310 }
4312 }
4315 {
4322 }
4325 {
4326 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4330 }
4332 /* Value is not predetermined, but do the comparison
4333 in the type of the operand that is not constant.
4334 TYPE is already properly set. */
4335 }
4337 /* If either arg is decimal float and the other is float, find the
4338 proper common type to use for comparison. */
4344 /* If either arg is decimal float and the other is float, fail. */
4355 /* If args' natural types are both narrower than nominal type
4356 and both extend in the same manner, compare them
4357 in the type of the wider arg.
4358 Otherwise must actually extend both to the nominal
4359 common type lest different ways of extending
4360 alter the result.
4361 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
4366 {
4370 type);
4371 /* Make sure shorter operand is extended the right way
4372 to match the longer operand. */
4373 primop0
4376 primop0);
4377 primop1
4380 primop1);
4381 }
4382 else
4383 {
4384 /* Here we must do the comparison on the nominal type
4385 using the args exactly as we received them. */
4392 {
4394 /* All unsigned values are >= 0, so we warn. However,
4395 if OP0 is a constant that is >= 0, the signedness of
4396 the comparison isn't an issue, so suppress the
4397 warning. */
4402 primop0)))
4403 /* Do not warn for enumeration types. */
4407 {
4424 }
4427 {
4428 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4433 }
4434 }
4435 }
4443 }
4444 \f
4445 /* Return a tree for the sum or difference (RESULTCODE says which)
4446 of pointer PTROP and integer INTOP. */
4448 tree
4451 {
4454 /* The result is a pointer of the same type that is being added. */
4458 {
4465 }
4467 {
4474 }
4475 else
4478 /* We are manipulating pointer values, so we don't need to warn
4479 about relying on undefined signed overflow. We disable the
4480 warning here because we use integer types so fold won't know that
4481 they are really pointers. */
4484 /* If what we are about to multiply by the size of the elements
4485 contains a constant term, apply distributive law
4486 and multiply that constant term separately.
4487 This helps produce common subexpressions. */
4492 /* If the constant comes from pointer subtraction,
4493 skip this optimization--it would cause an error. */
4495 /* If the constant is unsigned, and smaller than the pointer size,
4496 then we must skip this optimization. This is because it could cause
4497 an overflow error if the constant is negative but INTOP is not. */
4501 {
4506 /* Convert both subexpression types to the type of intop,
4507 because weird cases involving pointer arithmetic
4508 can result in a sum or difference with different type args. */
4513 }
4515 /* Convert the integer argument to a type the same size as sizetype
4516 so the multiply won't overflow spuriously. */
4522 /* Replace the integer argument with a suitable product by the object size.
4523 Do this multiplication as signed, then convert to the appropriate type
4524 for the pointer operation and disregard an overflow that occurred only
4525 because of the sign-extension change in the latter conversion. */
4526 {
4533 }
4535 /* Create the sum or difference. */
4544 }
4545 \f
4546 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
4547 and if NON_CONST is known not to be permitted in an evaluated part
4548 of a constant expression. */
4550 tree
4552 {
4556 /* This should never be called for C++. */
4560 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
4569 }
4571 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
4572 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
4573 around the SAVE_EXPR if needed so that c_fully_fold does not need
4574 to look inside SAVE_EXPRs. */
4576 tree
4578 {
4587 }
4589 /* Return whether EXPR is a declaration whose address can never be
4590 NULL. */
4592 bool
4594 {
4599 }
4601 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4602 or for an `if' or `while' statement or ?..: exp. It should already
4603 have been validated to be of suitable type; otherwise, a bad
4604 diagnostic may result.
4606 The EXPR is located at LOCATION.
4608 This preparation consists of taking the ordinary
4609 representation of an expression expr and producing a valid tree
4610 boolean expression describing whether expr is nonzero. We could
4611 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
4612 but we optimize comparisons, &&, ||, and !.
4614 The resulting type should always be `truthvalue_type_node'. */
4616 tree
4618 {
4620 {
4662 ? truthvalue_true_node
4668 ? truthvalue_true_node
4673 /* Fall through. */
4676 {
4679 {
4680 /* Common Ada/Pascal programmer's mistake. */
4682 OPT_Waddress,
4684 inner);
4686 }
4688 }
4705 /* These don't change whether an object is nonzero or zero. */
4710 /* These don't change whether an object is zero or nonzero, but
4711 we can't ignore them if their second arg has side-effects. */
4713 {
4716 c_common_truthvalue_conversion
4719 }
4720 else
4725 /* Distribute the conversion into the arms of a COND_EXPR. */
4727 {
4730 /* In C++ one of the arms might have void type if it is throw. */
4738 }
4739 else
4740 {
4741 /* Folding will happen later for C. */
4749 }
4751 CASE_CONVERT:
4752 {
4756 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4757 since that affects how `default_conversion' will behave. */
4761 /* Don't strip a conversion from C++0x scoped enum, since they
4762 don't implicitly convert to other types. */
4766 /* If this isn't narrowing the argument, we can ignore it. */
4770 }
4776 {
4780 }
4785 }
4788 {
4790 expr = (build_binary_op
4794 c_common_truthvalue_conversion
4797 c_common_truthvalue_conversion
4802 }
4805 {
4810 }
4811 else
4814 ret:
4817 }
4818 \f
4827 /* Apply the TYPE_QUALS to the new DECL. */
4829 void
4831 {
4839 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
4840 constructor can produce constant init, so rely on cp_finish_decl to
4841 clear TREE_READONLY if the variable has non-constant init. */
4844 {
4847 }
4849 {
4851 /* Allow 'restrict' on arrays of pointers.
4852 FIXME currently we just ignore it. */
4858 }
4859 }
4862 {
4865 };
4867 /* Hash function for the problem of multiple type definitions in
4868 different files. This must hash all types that will compare
4869 equal via comptypes to the same value. In practice it hashes
4870 on some of the simple stuff and leaves the details to comptypes. */
4872 hashval_t
4874 {
4877 tree t2;
4879 {
4880 /* For pointers, hash on pointee type plus some swizzling. */
4883 /* Hash on number of elements and total size. */
4902 }
4903 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4904 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4906 /* We might have a VLA here. */
4909 else
4912 }
4914 bool
4916 {
4918 }
4922 /* Return the typed-based alias set for T, which may be an expression
4923 or a type. Return -1 if we don't do anything special. */
4925 alias_set_type
4927 {
4928 tree u;
4930 /* For VLAs, use the alias set of the element type rather than the
4931 default of alias set 0 for types compared structurally. */
4933 {
4937 }
4939 /* Permit type-punning when accessing a union, provided the access
4940 is directly through the union. For example, this code does not
4941 permit taking the address of a union member and then storing
4942 through it. Even the type-punning allowed here is a GCC
4943 extension, albeit a common and useful one; the C standard says
4944 that such accesses have implementation-defined behavior. */
4952 /* That's all the expressions we handle specially. */
4956 /* The C standard guarantees that any object may be accessed via an
4957 lvalue that has character type. */
4963 /* The C standard specifically allows aliasing between signed and
4964 unsigned variants of the same type. We treat the signed
4965 variant as canonical. */
4967 {
4970 /* t1 == t can happen for boolean nodes which are always unsigned. */
4973 }
4975 /* Handle the case of multiple type nodes referring to "the same" type,
4976 which occurs with IMA. These share an alias set. FIXME: Currently only
4977 C90 is handled. (In C99 type compatibility is not transitive, which
4978 complicates things mightily. The alias set splay trees can theoretically
4979 represent this, but insertion is tricky when you consider all the
4980 different orders things might arrive in.) */
4985 /* Save time if there's only one input file. */
4989 /* Pointers need special handling if they point to any type that
4990 needs special handling (below). */
4992 {
4993 tree t2;
4994 /* Find bottom type under any nested POINTERs. */
4998 ;
5006 }
5007 /* These are the only cases that need special handling. */
5014 /* Undefined? */
5018 /* Look up t in hash table. Only one of the compatible types within each
5019 alias set is recorded in the table. */
5024 {
5027 }
5028 else
5029 /* Our caller will assign and record (in t) a new alias set; all we need
5030 to do is remember t in the hash table. */
5034 }
5035 \f
5036 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
5037 the IS_SIZEOF parameter indicates which operator is being applied.
5038 The COMPLAIN flag controls whether we should diagnose possibly
5039 ill-formed constructs or not. LOC is the location of the SIZEOF or
5040 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
5041 a type in any context should be returned, rather than the normal
5042 alignment for that type. */
5044 tree
5048 {
5056 {
5058 {
5065 }
5066 else
5067 {
5069 {
5073 else
5076 }
5078 }
5079 }
5081 {
5089 }
5092 {
5097 }
5100 {
5105 }
5106 else
5107 {
5109 /* Convert in case a char is more than one unit. */
5115 else
5117 }
5119 /* VALUE will have the middle-end integer type sizetype.
5120 However, we should really return a value of type `size_t',
5121 which is just a typedef for an ordinary integer type. */
5125 }
5127 /* Implement the __alignof keyword: Return the minimum required
5128 alignment of EXPR, measured in bytes. For VAR_DECLs,
5129 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
5130 from an "aligned" __attribute__ specification). LOC is the
5131 location of the ALIGNOF operator. */
5133 tree
5135 {
5136 tree t;
5143 {
5146 }
5152 {
5159 {
5166 }
5168 }
5169 else
5173 }
5174 \f
5175 /* Handle C and C++ default attributes. */
5177 enum built_in_attribute
5178 {
5179 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5180 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5181 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5182 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5183 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5185 #undef DEF_ATTR_NULL_TREE
5186 #undef DEF_ATTR_INT
5187 #undef DEF_ATTR_STRING
5188 #undef DEF_ATTR_IDENT
5189 #undef DEF_ATTR_TREE_LIST
5190 ATTR_LAST
5191 };
5197 enum c_builtin_type
5198 {
5199 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5200 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5201 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5202 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5203 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5204 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5205 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5206 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5207 ARG6) NAME,
5208 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5209 ARG6, ARG7) NAME,
5210 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5211 ARG6, ARG7, ARG8) NAME,
5212 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5213 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5214 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5215 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5216 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5217 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5218 NAME,
5219 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5221 #undef DEF_PRIMITIVE_TYPE
5222 #undef DEF_FUNCTION_TYPE_0
5223 #undef DEF_FUNCTION_TYPE_1
5224 #undef DEF_FUNCTION_TYPE_2
5225 #undef DEF_FUNCTION_TYPE_3
5226 #undef DEF_FUNCTION_TYPE_4
5227 #undef DEF_FUNCTION_TYPE_5
5228 #undef DEF_FUNCTION_TYPE_6
5229 #undef DEF_FUNCTION_TYPE_7
5230 #undef DEF_FUNCTION_TYPE_8
5231 #undef DEF_FUNCTION_TYPE_VAR_0
5232 #undef DEF_FUNCTION_TYPE_VAR_1
5233 #undef DEF_FUNCTION_TYPE_VAR_2
5234 #undef DEF_FUNCTION_TYPE_VAR_3
5235 #undef DEF_FUNCTION_TYPE_VAR_4
5236 #undef DEF_FUNCTION_TYPE_VAR_5
5237 #undef DEF_POINTER_TYPE
5238 BT_LAST
5239 };
5243 /* A temporary array for c_common_nodes_and_builtins. Used in
5244 communication with def_fn_type. */
5247 /* A helper function for c_common_nodes_and_builtins. Build function type
5248 for DEF with return type RET and N arguments. If VAR is true, then the
5249 function should be variadic after those N arguments.
5251 Takes special care not to ICE if any of the types involved are
5252 error_mark_node, which indicates that said type is not in fact available
5253 (see builtin_type_for_size). In which case the function type as a whole
5254 should be error_mark_node. */
5256 static void
5258 {
5259 tree t;
5266 {
5272 }
5279 else
5282 egress:
5285 }
5287 /* Build builtin functions common to both C and C++ language
5288 frontends. */
5290 static void
5292 {
5293 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5294 builtin_types[ENUM] = VALUE;
5295 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5296 def_fn_type (ENUM, RETURN, 0, 0);
5297 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5298 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5299 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5300 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5301 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5302 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5303 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5304 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5305 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5306 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5307 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5308 ARG6) \
5309 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5310 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5311 ARG6, ARG7) \
5312 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5313 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5314 ARG6, ARG7, ARG8) \
5315 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5316 ARG7, ARG8);
5317 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5318 def_fn_type (ENUM, RETURN, 1, 0);
5319 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5320 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5321 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5322 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5323 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5324 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5325 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5326 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5327 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5328 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5329 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5330 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5334 #undef DEF_PRIMITIVE_TYPE
5335 #undef DEF_FUNCTION_TYPE_0
5336 #undef DEF_FUNCTION_TYPE_1
5337 #undef DEF_FUNCTION_TYPE_2
5338 #undef DEF_FUNCTION_TYPE_3
5339 #undef DEF_FUNCTION_TYPE_4
5340 #undef DEF_FUNCTION_TYPE_5
5341 #undef DEF_FUNCTION_TYPE_6
5342 #undef DEF_FUNCTION_TYPE_7
5343 #undef DEF_FUNCTION_TYPE_8
5344 #undef DEF_FUNCTION_TYPE_VAR_0
5345 #undef DEF_FUNCTION_TYPE_VAR_1
5346 #undef DEF_FUNCTION_TYPE_VAR_2
5347 #undef DEF_FUNCTION_TYPE_VAR_3
5348 #undef DEF_FUNCTION_TYPE_VAR_4
5349 #undef DEF_FUNCTION_TYPE_VAR_5
5350 #undef DEF_POINTER_TYPE
5355 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5356 NONANSI_P, ATTRS, IMPLICIT, COND) \
5357 if (NAME && COND) \
5358 def_builtin_1 (ENUM, NAME, CLASS, \
5359 builtin_types[(int) TYPE], \
5360 builtin_types[(int) LIBTYPE], \
5361 BOTH_P, FALLBACK_P, NONANSI_P, \
5362 built_in_attributes[(int) ATTRS], IMPLICIT);
5364 #undef DEF_BUILTIN
5372 }
5374 /* Like get_identifier, but avoid warnings about null arguments when
5375 the argument may be NULL for targets where GCC lacks stdint.h type
5376 information. */
5380 {
5382 }
5384 /* Build tree nodes and builtin functions common to both C and C++ language
5385 frontends. */
5387 void
5389 {
5393 tree array_domain_type;
5394 tree va_list_ref_type_node;
5395 tree va_list_arg_type_node;
5400 /* Define `int' and `char' first so that dbx will output them first. */
5404 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
5405 "unsigned long", "long long unsigned" and "unsigned short" were in C++
5406 but not C. Are the conditionals here needed? */
5412 long_unsigned_type_node);
5415 {
5424 }
5429 long_long_integer_type_node);
5431 long_long_unsigned_type_node);
5434 long_long_unsigned_type_node);
5437 short_unsigned_type_node);
5440 short_unsigned_type_node);
5442 /* Define both `signed char' and `unsigned char'. */
5446 /* These are types that c_common_type_for_size and
5447 c_common_type_for_mode use. */
5450 intQI_type_node));
5453 intHI_type_node));
5456 intSI_type_node));
5459 intDI_type_node));
5460 #if HOST_BITS_PER_WIDE_INT >= 64
5461 /* Note that this is different than the __int128 type that's part of
5462 the generic __intN support. */
5465 TYPE_DECL,
5467 intTI_type_node));
5468 #endif
5471 unsigned_intQI_type_node));
5474 unsigned_intHI_type_node));
5477 unsigned_intSI_type_node));
5480 unsigned_intDI_type_node));
5481 #if HOST_BITS_PER_WIDE_INT >= 64
5484 TYPE_DECL,
5486 unsigned_intTI_type_node));
5487 #endif
5489 /* Create the widest literal types. */
5490 widest_integer_literal_type_node
5494 widest_integer_literal_type_node));
5496 widest_unsigned_literal_type_node
5500 widest_unsigned_literal_type_node));
5504 pid_type_node =
5511 /* Only supported decimal floating point extension if the target
5512 actually supports underlying modes. */
5516 {
5520 }
5523 {
5528 long_long_fract_type_node);
5530 unsigned_short_fract_type_node);
5532 unsigned_fract_type_node);
5534 unsigned_long_fract_type_node);
5536 unsigned_long_long_fract_type_node);
5538 sat_short_fract_type_node);
5541 sat_long_fract_type_node);
5543 sat_long_long_fract_type_node);
5545 sat_unsigned_short_fract_type_node);
5547 sat_unsigned_fract_type_node);
5549 sat_unsigned_long_fract_type_node);
5551 sat_unsigned_long_long_fract_type_node);
5556 long_long_accum_type_node);
5558 unsigned_short_accum_type_node);
5560 unsigned_accum_type_node);
5562 unsigned_long_accum_type_node);
5564 unsigned_long_long_accum_type_node);
5566 sat_short_accum_type_node);
5569 sat_long_accum_type_node);
5571 sat_long_long_accum_type_node);
5573 sat_unsigned_short_accum_type_node);
5575 sat_unsigned_accum_type_node);
5577 sat_unsigned_long_accum_type_node);
5579 sat_unsigned_long_long_accum_type_node);
5581 }
5584 TYPE_DECL,
5586 complex_integer_type_node));
5588 TYPE_DECL,
5590 complex_float_type_node));
5592 TYPE_DECL,
5594 complex_double_type_node));
5598 complex_long_double_type_node));
5601 /* For C++, make fileptr_type_node a distinct void * type until
5602 FILE type is defined. */
5607 /* Set the TYPE_NAME for any variants that were built before
5608 record_builtin_type gave names to the built-in types. */
5609 {
5615 }
5619 /* Make a type to be the domain of a few array types
5620 whose domains don't really matter.
5621 200 is small enough that it always fits in size_t
5622 and large enough that it can hold most function names for the
5623 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5626 /* Make a type for arrays of characters.
5627 With luck nothing will ever really depend on the length of this
5628 array type. */
5629 char_array_type_node
5633 const_string_type_node
5637 /* This is special for C++ so functions can be overloaded. */
5643 {
5646 else
5649 }
5651 /* This is for wide string constants. */
5652 wchar_array_type_node
5655 /* Define 'char16_t'. */
5660 {
5665 }
5667 /* This is for UTF-16 string constants. */
5668 char16_array_type_node
5671 /* Define 'char32_t'. */
5676 {
5681 }
5683 /* This is for UTF-32 string constants. */
5684 char32_array_type_node
5687 wint_type_node =
5690 intmax_type_node =
5692 uintmax_type_node =
5696 sig_atomic_type_node =
5699 int8_type_node =
5702 int16_type_node =
5705 int32_type_node =
5708 int64_type_node =
5711 uint8_type_node =
5723 int_least8_type_node =
5726 int_least16_type_node =
5729 int_least32_type_node =
5732 int_least64_type_node =
5735 uint_least8_type_node =
5738 uint_least16_type_node =
5741 uint_least32_type_node =
5744 uint_least64_type_node =
5747 int_fast8_type_node =
5750 int_fast16_type_node =
5753 int_fast32_type_node =
5756 int_fast64_type_node =
5759 uint_fast8_type_node =
5762 uint_fast16_type_node =
5765 uint_fast32_type_node =
5768 uint_fast64_type_node =
5771 intptr_type_node =
5774 uintptr_type_node =
5777 default_function_type
5779 ptrdiff_type_node
5786 va_list_type_node));
5788 {
5791 tree ptype;
5794 {
5798 ptype));
5800 }
5801 }
5804 {
5807 }
5808 else
5809 {
5812 }
5819 /* Create the built-in __null node. It is important that this is
5820 not shared. */
5824 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5826 }
5828 /* The number of named compound-literals generated thus far. */
5831 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5833 void
5835 {
5838 compound_literal_number);
5839 compound_literal_number++;
5841 }
5843 tree
5845 {
5849 }
5852 /* Linked list of disabled built-in functions. */
5855 {
5863 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5864 begins with "__builtin_", give an error. */
5866 void
5868 {
5871 else
5872 {
5877 }
5878 }
5881 /* Return true if the built-in function NAME has been disabled, false
5882 otherwise. */
5884 static bool
5886 {
5889 {
5892 }
5894 }
5897 /* Worker for DEF_BUILTIN.
5898 Possibly define a builtin function with one or two names.
5899 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5900 nonansi_p and flag_no_nonansi_builtin. */
5902 static void
5909 {
5910 tree decl;
5923 fnattrs);
5932 }
5933 \f
5934 /* Nonzero if the type T promotes to int. This is (nearly) the
5935 integral promotions defined in ISO C99 6.3.1.1/2. */
5937 bool
5939 {
5941 {
5951 /* ??? Technically all enumerations not larger than an int
5952 promote to an int. But this is used along code paths
5953 that only want to notice a size change. */
5961 }
5962 }
5964 /* Return 1 if PARMS specifies a fixed number of parameters
5965 and none of their types is affected by default promotions. */
5967 int
5969 {
5970 const_tree t;
5972 {
5989 }
5991 }
5993 /* Recursively remove any '*' or '&' operator from TYPE. */
5994 tree
5996 {
6000 }
6002 /* Recursively remove pointer or array type from TYPE. */
6003 tree
6005 {
6009 }
6011 /* Used to compare case labels. K1 and K2 are actually tree nodes
6012 representing case labels, or NULL_TREE for a `default' label.
6013 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
6014 K2, and 0 if K1 and K2 are equal. */
6016 int
6018 {
6019 /* Consider a NULL key (such as arises with a `default' label) to be
6020 smaller than anything else. */
6027 }
6029 /* Process a case label, located at LOC, for the range LOW_VALUE
6030 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
6031 then this case label is actually a `default' label. If only
6032 HIGH_VALUE is NULL_TREE, then case label was declared using the
6033 usual C/C++ syntax, rather than the GNU case range extension.
6034 CASES is a tree containing all the case ranges processed so far;
6035 COND is the condition for the switch-statement itself. Returns the
6036 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
6037 is created. */
6039 tree
6042 {
6043 tree type;
6044 tree label;
6045 tree case_label;
6046 splay_tree_node node;
6048 /* Create the LABEL_DECL itself. */
6051 /* If there was an error processing the switch condition, bail now
6052 before we get more confused. */
6060 {
6063 }
6065 /* Case ranges are a GNU extension. */
6072 {
6077 }
6079 {
6084 }
6087 {
6088 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
6089 really a case range, even though it was written that way.
6090 Remove the HIGH_VALUE to simplify later processing. */
6095 }
6097 /* See if the case is in range of the type of the original testing
6098 expression. If both low_value and high_value are out of range,
6099 don't insert the case label and return NULL_TREE. */
6105 /* Look up the LOW_VALUE in the table of case labels we already
6106 have. */
6108 /* If there was not an exact match, check for overlapping ranges.
6109 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
6110 that's a `default' label and the only overlap is an exact match. */
6112 {
6113 splay_tree_node low_bound;
6114 splay_tree_node high_bound;
6116 /* Even though there wasn't an exact match, there might be an
6117 overlap between this case range and another case range.
6118 Since we've (inductively) not allowed any overlapping case
6119 ranges, we simply need to find the greatest low case label
6120 that is smaller that LOW_VALUE, and the smallest low case
6121 label that is greater than LOW_VALUE. If there is an overlap
6122 it will occur in one of these two ranges. */
6128 /* Check to see if the LOW_BOUND overlaps. It is smaller than
6129 the LOW_VALUE, so there is no need to check unless the
6130 LOW_BOUND is in fact itself a case range. */
6136 /* Check to see if the HIGH_BOUND overlaps. The low end of that
6137 range is bigger than the low end of the current range, so we
6138 are only interested if the current range is a real range, and
6139 not an ordinary case label. */
6141 && high_value
6143 high_value)
6146 }
6147 /* If there was an overlap, issue an error. */
6149 {
6153 {
6157 }
6159 {
6162 }
6163 else
6164 {
6168 }
6170 }
6172 /* Add a CASE_LABEL to the statement-tree. */
6174 /* Register this case label in the splay tree. */
6181 error_out:
6182 /* Add a label so that the back-end doesn't think that the beginning of
6183 the switch is unreachable. Note that we do not add a case label, as
6184 that just leads to duplicates and thence to failure later on. */
6186 {
6189 }
6191 }
6193 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
6194 Used to verify that case values match up with enumerator values. */
6196 static void
6198 {
6205 else
6212 buf);
6213 else
6218 }
6220 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
6221 Used to verify that case values match up with enumerator values. */
6223 static int
6225 {
6229 /* Skip default case. */
6233 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
6234 when we did our enum->case scan. Reset our scratch bit after. */
6237 else
6240 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
6241 not set, that means that CASE_HIGH did not appear when we did our
6242 enum->case scan. Reset our scratch bit after. */
6244 {
6247 else
6249 }
6252 }
6254 /* Handle -Wswitch*. Called from the front end after parsing the
6255 switch construct. */
6256 /* ??? Should probably be somewhere generic, since other languages
6257 besides C and C++ would want this. At the moment, however, C/C++
6258 are the only tree-ssa languages that support enumerations at all,
6259 so the point is moot. */
6261 void
6264 {
6265 splay_tree_node default_node;
6266 splay_tree_node node;
6267 tree chain;
6277 /* From here on, we only care about about enumerated types. */
6281 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
6285 /* Check the cases. Warn about case values which are not members of
6286 the enumerated type. For -Wswitch-enum, or for -Wswitch when
6287 there is no default case, check that exactly all enumeration
6288 literals are covered by the cases. */
6290 /* Clearing COND if it is not an integer constant simplifies
6291 the tests inside the loop below. */
6295 /* The time complexity here is O(N*lg(N)) worst case, but for the
6296 common case of monotonically increasing enumerators, it is
6297 O(N), since the nature of the splay tree will keep the next
6298 element adjacent to the root at all times. */
6301 {
6307 {
6308 /* Mark the CASE_LOW part of the case entry as seen. */
6312 }
6314 /* Even though there wasn't an exact match, there might be a
6315 case range which includes the enumerator's value. */
6318 {
6322 {
6323 /* If we match the upper bound exactly, mark the CASE_HIGH
6324 part of the case entry as seen. */
6328 }
6329 }
6331 /* We've now determined that this enumerated literal isn't
6332 handled by the case labels of the switch statement. */
6334 /* If the switch expression is a constant, we only really care
6335 about whether that constant is handled by the switch. */
6339 /* If there is a default_node, the only relevant option is
6340 Wswitch-enum. Otherwise, if both are enabled then we prefer
6341 to warn using -Wswitch because -Wswitch is enabled by -Wall
6342 while -Wswitch-enum is explicit. */
6345 ? OPT_Wswitch_enum
6349 }
6351 /* Warn if there are case expressions that don't correspond to
6352 enumerators. This can occur since C and C++ don't enforce
6353 type-checking of assignments to enumeration variables.
6355 The time complexity here is now always O(N) worst case, since
6356 we should have marked both the lower bound and upper bound of
6357 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
6358 above. This scan also resets those fields. */
6361 }
6363 /* Finish an expression taking the address of LABEL (an
6364 IDENTIFIER_NODE). Returns an expression for the address.
6366 LOC is the location for the expression returned. */
6368 tree
6370 {
6371 tree result;
6381 else
6382 {
6385 /* The current function is not necessarily uninlinable.
6386 Computed gotos are incompatible with inlining, but the value
6387 here could be used only in a diagnostic, for example. */
6389 }
6392 }
6393 \f
6395 /* Given a boolean expression ARG, return a tree representing an increment
6396 or decrement (as indicated by CODE) of ARG. The front end must check for
6397 invalid cases (e.g., decrement in C++). */
6398 tree
6400 {
6401 tree val;
6406 {
6429 }
6432 }
6433 \f
6434 /* Built-in macros for stddef.h and stdint.h, that require macros
6435 defined in this file. */
6436 void
6438 {
6501 }
6503 static void
6505 {
6506 /* Fill in the built_in_attributes array. */
6507 #define DEF_ATTR_NULL_TREE(ENUM) \
6508 built_in_attributes[(int) ENUM] = NULL_TREE;
6509 #define DEF_ATTR_INT(ENUM, VALUE) \
6510 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
6511 #define DEF_ATTR_STRING(ENUM, VALUE) \
6512 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
6513 #define DEF_ATTR_IDENT(ENUM, STRING) \
6514 built_in_attributes[(int) ENUM] = get_identifier (STRING);
6515 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
6516 built_in_attributes[(int) ENUM] \
6517 = tree_cons (built_in_attributes[(int) PURPOSE], \
6518 built_in_attributes[(int) VALUE], \
6519 built_in_attributes[(int) CHAIN]);
6521 #undef DEF_ATTR_NULL_TREE
6522 #undef DEF_ATTR_INT
6523 #undef DEF_ATTR_IDENT
6524 #undef DEF_ATTR_TREE_LIST
6525 }
6527 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
6528 identifier as an argument, so the front end shouldn't look it up. */
6530 bool
6532 {
6535 /* Unknown attribute that we'll end up ignoring, return true so we
6536 don't complain about an identifier argument. */
6542 else
6544 }
6546 /* Attribute handlers common to C front ends. */
6548 /* Handle a "packed" attribute; arguments as in
6549 struct attribute_spec.handler. */
6551 static tree
6554 {
6556 {
6560 }
6562 {
6564 /* Still pack bitfields. */
6569 else
6571 }
6572 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
6573 used for DECL_REGISTER. It wouldn't mean anything anyway.
6574 We can't set DECL_PACKED on the type of a TYPE_DECL, because
6575 that changes what the typedef is typing. */
6576 else
6577 {
6580 }
6583 }
6585 /* Handle a "nocommon" attribute; arguments as in
6586 struct attribute_spec.handler. */
6588 static tree
6592 {
6595 else
6596 {
6599 }
6602 }
6604 /* Handle a "common" attribute; arguments as in
6605 struct attribute_spec.handler. */
6607 static tree
6610 {
6613 else
6614 {
6617 }
6620 }
6622 /* Handle a "noreturn" attribute; arguments as in
6623 struct attribute_spec.handler. */
6625 static tree
6628 {
6631 /* See FIXME comment in c_common_attribute_table. */
6638 = (build_qualified_type
6639 (build_pointer_type
6643 else
6644 {
6647 }
6650 }
6652 /* Handle a "hot" and attribute; arguments as in
6653 struct attribute_spec.handler. */
6655 static tree
6658 {
6661 {
6663 {
6667 }
6668 /* Most of the rest of the hot processing is done later with
6669 lookup_attribute. */
6670 }
6671 else
6672 {
6675 }
6678 }
6680 /* Handle a "cold" and attribute; arguments as in
6681 struct attribute_spec.handler. */
6683 static tree
6686 {
6689 {
6691 {
6695 }
6696 /* Most of the rest of the cold processing is done later with
6697 lookup_attribute. */
6698 }
6699 else
6700 {
6703 }
6706 }
6708 /* Handle a "no_sanitize_address" attribute; arguments as in
6709 struct attribute_spec.handler. */
6711 static tree
6714 {
6716 {
6719 }
6722 }
6724 /* Handle a "no_address_safety_analysis" attribute; arguments as in
6725 struct attribute_spec.handler. */
6727 static tree
6730 {
6739 }
6741 /* Handle a "no_sanitize_undefined" attribute; arguments as in
6742 struct attribute_spec.handler. */
6744 static tree
6747 {
6749 {
6752 }
6755 }
6757 /* Handle a "noinline" attribute; arguments as in
6758 struct attribute_spec.handler. */
6760 static tree
6764 {
6766 {
6768 {
6772 }
6773 else
6775 }
6776 else
6777 {
6780 }
6783 }
6785 /* Handle a "noclone" attribute; arguments as in
6786 struct attribute_spec.handler. */
6788 static tree
6792 {
6794 {
6797 }
6800 }
6802 /* Handle a "hsa" attribute; arguments as in
6803 struct attribute_spec.handler. */
6805 static tree
6809 {
6811 {
6815 }
6826 }
6828 /* Handle a "always_inline" attribute; arguments as in
6829 struct attribute_spec.handler. */
6831 static tree
6836 {
6838 {
6840 {
6844 }
6845 else
6846 /* Set the attribute and mark it for disregarding inline
6847 limits. */
6849 }
6850 else
6851 {
6854 }
6857 }
6859 /* Handle a "gnu_inline" attribute; arguments as in
6860 struct attribute_spec.handler. */
6862 static tree
6867 {
6869 {
6870 /* Do nothing else, just set the attribute. We'll get at
6871 it later with lookup_attribute. */
6872 }
6873 else
6874 {
6877 }
6880 }
6882 /* Handle a "leaf" attribute; arguments as in
6883 struct attribute_spec.handler. */
6885 static tree
6889 {
6891 {
6894 }
6896 {
6899 }
6902 }
6904 /* Handle an "artificial" attribute; arguments as in
6905 struct attribute_spec.handler. */
6907 static tree
6912 {
6914 {
6915 /* Do nothing else, just set the attribute. We'll get at
6916 it later with lookup_attribute. */
6917 }
6918 else
6919 {
6922 }
6925 }
6927 /* Handle a "flatten" attribute; arguments as in
6928 struct attribute_spec.handler. */
6930 static tree
6932 tree args ATTRIBUTE_UNUSED,
6934 {
6936 /* Do nothing else, just set the attribute. We'll get at
6937 it later with lookup_attribute. */
6938 ;
6939 else
6940 {
6943 }
6946 }
6948 /* Handle a "warning" or "error" attribute; arguments as in
6949 struct attribute_spec.handler. */
6951 static tree
6954 {
6957 /* Do nothing else, just set the attribute. We'll get at
6958 it later with lookup_attribute. */
6959 ;
6960 else
6961 {
6964 }
6967 }
6969 /* Handle a "used" attribute; arguments as in
6970 struct attribute_spec.handler. */
6972 static tree
6975 {
6981 {
6986 }
6987 else
6988 {
6991 }
6994 }
6996 /* Handle a "unused" attribute; arguments as in
6997 struct attribute_spec.handler. */
6999 static tree
7002 {
7004 {
7012 {
7017 }
7018 else
7019 {
7022 }
7023 }
7024 else
7025 {
7029 }
7032 }
7034 /* Handle a "externally_visible" attribute; arguments as in
7035 struct attribute_spec.handler. */
7037 static tree
7042 {
7046 {
7049 {
7053 }
7054 }
7055 else
7056 {
7059 }
7062 }
7064 /* Handle the "no_reorder" attribute. Arguments as in
7065 struct attribute_spec.handler. */
7067 static tree
7069 tree name,
7070 tree,
7073 {
7078 {
7081 name);
7083 }
7086 }
7088 /* Handle a "const" attribute; arguments as in
7089 struct attribute_spec.handler. */
7091 static tree
7094 {
7097 /* See FIXME comment on noreturn in c_common_attribute_table. */
7103 = (build_qualified_type
7104 (build_pointer_type
7108 else
7109 {
7112 }
7115 }
7117 /* Handle a "transparent_union" attribute; arguments as in
7118 struct attribute_spec.handler. */
7120 static tree
7124 {
7125 tree type;
7136 {
7137 /* Make sure that the first field will work for a transparent union.
7138 If the type isn't complete yet, leave the check to the code in
7139 finish_struct. */
7141 {
7147 }
7150 {
7151 /* If the type isn't complete yet, setting the flag
7152 on a variant wouldn't ever be checked. */
7156 /* build_duplicate_type doesn't work for C++. */
7160 /* A type variant isn't good enough, since we don't a cast
7161 to such a type removed as a no-op. */
7163 }
7167 }
7169 ignored:
7172 }
7174 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
7175 get the requested priority for a constructor or destructor,
7176 possibly issuing diagnostics for invalid or reserved
7177 priorities. */
7179 static priority_type
7181 {
7182 HOST_WIDE_INT pri;
7183 tree arg;
7189 {
7192 else
7195 }
7212 {
7215 "destructor priorities from 0 to %d are reserved "
7217 MAX_RESERVED_INIT_PRIORITY);
7218 else
7220 "constructor priorities from 0 to %d are reserved "
7222 MAX_RESERVED_INIT_PRIORITY);
7223 }
7226 invalid:
7229 MAX_INIT_PRIORITY);
7230 else
7232 MAX_INIT_PRIORITY);
7234 }
7236 /* Handle a "constructor" attribute; arguments as in
7237 struct attribute_spec.handler. */
7239 static tree
7243 {
7250 {
7251 priority_type priority;
7256 }
7257 else
7258 {
7261 }
7264 }
7266 /* Handle a "destructor" attribute; arguments as in
7267 struct attribute_spec.handler. */
7269 static tree
7273 {
7280 {
7281 priority_type priority;
7286 }
7287 else
7288 {
7291 }
7294 }
7296 /* Nonzero if the mode is a valid vector mode for this architecture.
7297 This returns nonzero even if there is no hardware support for the
7298 vector mode, but we can emulate with narrower modes. */
7300 static int
7302 {
7304 machine_mode innermode;
7306 /* Doh! What's going on? */
7315 /* Hardware support. Woo hoo! */
7321 /* We should probably return 1 if requesting V4DI and we have no DI,
7322 but we have V2DI, but this is probably very unlikely. */
7324 /* If we have support for the inner mode, we can safely emulate it.
7325 We may not have V2DI, but me can emulate with a pair of DIs. */
7327 }
7330 /* Handle a "mode" attribute; arguments as in
7331 struct attribute_spec.handler. */
7333 static tree
7336 {
7344 else
7345 {
7350 tree typefm;
7355 {
7361 }
7363 /* Change this type to have a type with the specified mode.
7364 First check for the special modes. */
7377 else
7380 {
7383 }
7386 {
7389 }
7393 {
7425 }
7427 {
7430 }
7433 {
7438 {
7441 }
7445 else
7448 }
7449 else
7450 {
7451 /* For fixed-point modes, we need to test if the signness of type
7452 and the machine mode are consistent. */
7455 {
7458 }
7459 /* For fixed-point modes, we need to pass saturating info. */
7463 }
7466 {
7469 }
7471 {
7472 /* For enumeral types, copy the precision from the integer
7473 type returned above. If not an INTEGER_TYPE, we can't use
7474 this mode for this type. */
7476 {
7479 }
7482 {
7485 }
7486 else
7487 {
7488 /* We cannot build a type variant, as there's code that assumes
7489 that TYPE_MAIN_VARIANT has the same mode. This includes the
7490 debug generators. Instead, create a subrange type. This
7491 results in all of the enumeral values being emitted only once
7492 in the original, and the subtype gets them by reference. */
7495 else
7498 }
7499 }
7503 {
7506 }
7509 }
7512 }
7514 /* Handle a "section" attribute; arguments as in
7515 struct attribute_spec.handler. */
7517 static tree
7520 {
7524 {
7530 {
7534 {
7536 "section attribute cannot be specified for "
7539 }
7541 /* The decl may have already been given a section attribute
7542 from a previous declaration. Ensure they match. */
7546 {
7550 }
7554 {
7557 }
7558 else
7561 }
7562 else
7563 {
7566 }
7567 }
7568 else
7569 {
7573 }
7576 }
7578 /* Check whether ALIGN is a valid user-specified alignment. If so,
7579 return its base-2 log; if not, output an error and return -1. If
7580 ALLOW_ZERO then 0 is valid and should result in a return of -1 with
7581 no error. */
7582 int
7584 {
7591 {
7594 }
7599 {
7602 }
7604 {
7607 }
7609 }
7611 /*
7612 If in c++-11, check if the c++-11 alignment constraint with respect
7613 to fundamental alignment (in [dcl.align]) are satisfied. If not in
7614 c++-11 mode, does nothing.
7616 [dcl.align]2/ says:
7618 [* if the constant expression evaluates to a fundamental alignment,
7619 the alignment requirement of the declared entity shall be the
7620 specified fundamental alignment.
7622 * if the constant expression evaluates to an extended alignment
7623 and the implementation supports that alignment in the context
7624 of the declaration, the alignment of the declared entity shall
7625 be that alignment
7627 * if the constant expression evaluates to an extended alignment
7628 and the implementation does not support that alignment in the
7629 context of the declaration, the program is ill-formed]. */
7631 static bool
7635 {
7648 {
7650 {
7651 /* For file scope variables and static members, the target
7652 supports alignments that are at most
7653 MAX_OFILE_ALIGNMENT. */
7656 }
7657 else
7658 {
7659 #ifdef BIGGEST_FIELD_ALIGNMENT
7660 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_FIELD_ALIGNMENT
7661 #else
7662 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_ALIGNMENT
7663 #endif
7664 /* For non-static members, the target supports either
7665 alignments that at most either BIGGEST_FIELD_ALIGNMENT
7666 if it is defined or BIGGEST_ALIGNMENT. */
7671 #undef MAX_TARGET_FIELD_ALIGNMENT
7672 /* For stack variables, the target supports at most
7673 MAX_STACK_ALIGNMENT. */
7677 }
7678 }
7680 {
7681 /* Let's be liberal for types. */
7684 }
7692 }
7694 /* Handle a "aligned" attribute; arguments as in
7695 struct attribute_spec.handler. */
7697 static tree
7700 {
7704 tree align_expr;
7708 {
7713 }
7714 else
7718 {
7722 }
7730 {
7733 /* If we have a TYPE_DECL, then copy the type, so that we
7734 don't accidentally modify a builtin type. See pushdecl. */
7737 {
7744 }
7745 else
7750 }
7753 {
7756 }
7759 /* C++-11 [dcl.align/4]:
7761 When multiple alignment-specifiers are specified for an
7762 entity, the alignment requirement shall be set to the
7763 strictest specified alignment.
7765 This formally comes from the c++11 specification but we are
7766 doing it for the GNU attribute syntax as well. */
7770 {
7775 else
7779 }
7780 else
7781 {
7784 }
7787 }
7789 /* Handle a "weak" attribute; arguments as in
7790 struct attribute_spec.handler. */
7792 static tree
7797 {
7800 {
7803 }
7805 {
7809 }
7813 else
7817 }
7819 /* Handle an "alias" or "ifunc" attribute; arguments as in
7820 struct attribute_spec.handler, except that IS_ALIAS tells us
7821 whether this is an alias as opposed to ifunc attribute. */
7823 static tree
7826 {
7831 {
7834 }
7838 /* A static variable declaration is always a tentative definition,
7839 but the alias is a non-tentative definition which overrides. */
7842 {
7846 }
7850 {
7854 }
7856 /* Note that the very first time we process a nested declaration,
7857 decl_function_context will not be set. Indeed, *would* never
7858 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
7859 we do below. After such frobbery, pushdecl would set the context.
7860 In any case, this is never what we want. */
7862 {
7863 tree id;
7867 {
7871 }
7873 /* This counts as a use of the object pointed to. */
7878 else
7882 /* ifuncs are also aliases, so set that attribute too. */
7885 }
7886 else
7887 {
7890 }
7893 {
7896 {
7899 else
7901 }
7902 }
7906 }
7908 /* Handle an "alias" or "ifunc" attribute; arguments as in
7909 struct attribute_spec.handler. */
7911 static tree
7914 {
7916 }
7918 /* Handle an "alias" or "ifunc" attribute; arguments as in
7919 struct attribute_spec.handler. */
7921 static tree
7924 {
7926 }
7928 /* Handle a "weakref" attribute; arguments as in struct
7929 attribute_spec.handler. */
7931 static tree
7934 {
7937 /* We must ignore the attribute when it is associated with
7938 local-scoped decls, since attribute alias is ignored and many
7939 such symbols do not even have a DECL_WEAK field. */
7941 || current_function_decl
7943 {
7947 }
7950 {
7954 }
7956 /* The idea here is that `weakref("name")' mutates into `weakref,
7957 alias("name")', and weakref without arguments, in turn,
7958 implicitly adds weak. */
7961 {
7968 }
7969 else
7970 {
7975 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
7976 and that isn't supported; and because it wants to add it to
7977 the list of weak decls, which isn't helpful. */
7979 }
7982 {
7986 }
7989 }
7991 /* Handle an "visibility" attribute; arguments as in
7992 struct attribute_spec.handler. */
7994 static tree
7998 {
8004 {
8008 {
8010 name);
8012 }
8014 {
8018 }
8019 }
8021 {
8024 }
8027 {
8030 }
8032 /* If this is a type, set the visibility on the type decl. */
8034 {
8039 {
8041 name);
8043 }
8044 }
8054 else
8055 {
8056 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
8058 }
8062 {
8076 }
8081 /* Go ahead and attach the attribute to the node as well. This is needed
8082 so we can determine whether we have VISIBILITY_DEFAULT because the
8083 visibility was not specified, or because it was explicitly overridden
8084 from the containing scope. */
8087 }
8089 /* Determine the ELF symbol visibility for DECL, which is either a
8090 variable or a function. It is an error to use this function if a
8091 definition of DECL is not available in this translation unit.
8092 Returns true if the final visibility has been determined by this
8093 function; false if the caller is free to make additional
8094 modifications. */
8096 bool
8098 {
8102 /* If the user explicitly specified the visibility with an
8103 attribute, honor that. DECL_VISIBILITY will have been set during
8104 the processing of the attribute. We check for an explicit
8105 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
8106 to distinguish the use of an attribute from the use of a "#pragma
8107 GCC visibility push(...)"; in the latter case we still want other
8108 considerations to be able to overrule the #pragma. */
8110 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
8115 /* Set default visibility to whatever the user supplied with
8116 visibility_specified depending on #pragma GCC visibility. */
8118 {
8121 {
8124 /* If visibility changed and DECL already has DECL_RTL, ensure
8125 symbol flags are updated. */
8130 }
8131 }
8133 }
8135 /* Handle an "tls_model" attribute; arguments as in
8136 struct attribute_spec.handler. */
8138 static tree
8141 {
8142 tree id;
8149 {
8152 }
8157 {
8160 }
8170 else
8171 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
8175 }
8177 /* Handle a "no_instrument_function" attribute; arguments as in
8178 struct attribute_spec.handler. */
8180 static tree
8185 {
8189 {
8193 }
8194 else
8198 }
8200 /* Handle a "malloc" attribute; arguments as in
8201 struct attribute_spec.handler. */
8203 static tree
8206 {
8210 else
8211 {
8214 }
8217 }
8219 /* Handle a "alloc_size" attribute; arguments as in
8220 struct attribute_spec.handler. */
8222 static tree
8225 {
8228 {
8235 || !arg_count
8237 {
8242 }
8243 }
8245 }
8247 /* Handle a "alloc_align" attribute; arguments as in
8248 struct attribute_spec.handler. */
8250 static tree
8253 {
8260 || !arg_count
8262 {
8267 }
8269 }
8271 /* Handle a "assume_aligned" attribute; arguments as in
8272 struct attribute_spec.handler. */
8274 static tree
8277 {
8279 {
8286 {
8291 }
8292 }
8294 }
8296 /* Handle a "fn spec" attribute; arguments as in
8297 struct attribute_spec.handler. */
8299 static tree
8303 {
8308 }
8310 /* Handle a "bnd_variable_size" attribute; arguments as in
8311 struct attribute_spec.handler. */
8313 static tree
8316 {
8318 {
8321 }
8324 }
8326 /* Handle a "bnd_legacy" attribute; arguments as in
8327 struct attribute_spec.handler. */
8329 static tree
8332 {
8334 {
8337 }
8340 }
8342 /* Handle a "bnd_instrument" attribute; arguments as in
8343 struct attribute_spec.handler. */
8345 static tree
8348 {
8350 {
8353 }
8356 }
8358 /* Handle a "warn_unused" attribute; arguments as in
8359 struct attribute_spec.handler. */
8361 static tree
8363 tree args ATTRIBUTE_UNUSED,
8365 {
8367 /* Do nothing else, just set the attribute. We'll get at
8368 it later with lookup_attribute. */
8369 ;
8370 else
8371 {
8374 }
8377 }
8379 /* Handle an "omp declare simd" attribute; arguments as in
8380 struct attribute_spec.handler. */
8382 static tree
8384 {
8386 }
8388 /* Handle an "omp declare target" attribute; arguments as in
8389 struct attribute_spec.handler. */
8391 static tree
8393 {
8395 }
8397 /* Handle a "returns_twice" attribute; arguments as in
8398 struct attribute_spec.handler. */
8400 static tree
8403 {
8406 else
8407 {
8410 }
8413 }
8415 /* Handle a "no_limit_stack" attribute; arguments as in
8416 struct attribute_spec.handler. */
8418 static tree
8423 {
8427 {
8431 }
8433 {
8437 }
8438 else
8442 }
8444 /* Handle a "pure" attribute; arguments as in
8445 struct attribute_spec.handler. */
8447 static tree
8450 {
8453 /* ??? TODO: Support types. */
8454 else
8455 {
8458 }
8461 }
8463 /* Digest an attribute list destined for a transactional memory statement.
8464 ALLOWED is the set of attributes that are allowed for this statement;
8465 return the attribute we parsed. Multiple attributes are never allowed. */
8467 int
8469 {
8474 {
8482 {
8485 }
8488 {
8491 }
8494 else
8496 }
8499 }
8501 /* Transform a TM attribute name into a maskable integer and back.
8502 Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
8503 to how the lack of an attribute is treated. */
8505 int
8507 {
8521 }
8523 tree
8525 {
8528 {
8546 }
8548 }
8550 /* Return the first TM attribute seen in LIST. */
8552 tree
8554 {
8556 {
8560 }
8562 }
8564 /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
8565 Here we accept only function types, and verify that none of the other
8566 function TM attributes are also applied. */
8567 /* ??? We need to accept class types for C++, but not C. This greatly
8568 complicates this function, since we can no longer rely on the extra
8569 processing given by function_type_required. */
8571 static tree
8574 {
8575 /* Only one path adds the attribute; others don't. */
8579 {
8582 /* Only tm_callable and tm_safe apply to classes. */
8585 /* FALLTHRU */
8589 {
8592 ;
8595 else
8597 }
8601 {
8604 {
8609 }
8610 }
8611 /* FALLTHRU */
8614 /* If a function is next, pass it on to be tried next. */
8618 ignored:
8621 }
8624 }
8626 /* Handle the TM_WRAP attribute; arguments as in
8627 struct attribute_spec.handler. */
8629 static tree
8632 {
8635 /* We don't need the attribute even on success, since we
8636 record the entry in an external table. */
8641 else
8642 {
8645 ;
8650 else
8651 {
8655 {
8659 else
8661 }
8662 else
8664 }
8665 }
8668 }
8670 /* Ignore the given attribute. Used when this attribute may be usefully
8671 overridden by the target, but is not used generically. */
8673 static tree
8677 {
8680 }
8682 /* Handle a "no vops" attribute; arguments as in
8683 struct attribute_spec.handler. */
8685 static tree
8689 {
8693 }
8695 /* Handle a "deprecated" attribute; arguments as in
8696 struct attribute_spec.handler. */
8698 static tree
8702 {
8710 {
8713 }
8716 {
8727 else
8729 }
8731 {
8736 }
8737 else
8741 {
8744 {
8750 }
8753 else
8755 }
8758 }
8760 /* Handle a "vector_size" attribute; arguments as in
8761 struct attribute_spec.handler. */
8763 static tree
8767 {
8769 machine_mode orig_mode;
8780 {
8783 }
8785 /* Get the vector size (in bytes). */
8788 /* We need to provide for vector pointers, vector arrays, and
8789 functions returning vectors. For example:
8791 __attribute__((vector_size(16))) short *foo;
8793 In this case, the mode is SI, but the type being modified is
8794 HI, so we need to look further. */
8803 /* Get the mode of the type being modified. */
8814 {
8817 }
8820 {
8823 }
8826 {
8829 }
8831 /* Calculate how many units fit in the vector. */
8834 {
8837 }
8841 /* Build back pointers if needed. */
8845 }
8847 /* Handle the "nonnull" attribute. */
8848 static tree
8852 {
8856 /* If no arguments are specified, all pointer arguments should be
8857 non-null. Verify a full prototype is given so that the arguments
8858 will have the correct types when we actually check them later. */
8860 {
8862 {
8865 }
8867 }
8869 /* Argument list specified. Verify that each argument number references
8870 a pointer argument. */
8872 {
8881 {
8886 }
8889 {
8890 function_args_iterator iter;
8891 tree argument;
8895 {
8899 }
8903 {
8908 }
8911 {
8916 }
8917 }
8918 }
8921 }
8923 /* Check the argument list of a function call for null in argument slots
8924 that are marked as requiring a non-null pointer argument. The NARGS
8925 arguments are passed in the array ARGARRAY.
8926 */
8928 static void
8930 {
8931 tree a;
8939 /* See if any of the nonnull attributes has no arguments. If so,
8940 then every pointer argument is checked (in which case the check
8941 for pointer type is done in check_nonnull_arg). */
8943 do
8951 else
8952 {
8953 /* Walk the argument list. If we encounter an argument number we
8954 should check for non-null, do it. */
8956 {
8958 {
8962 }
8967 }
8968 }
8969 }
8971 /* Check that the Nth argument of a function call (counting backwards
8972 from the end) is a (pointer)0. The NARGS arguments are passed in the
8973 array ARGARRAY. */
8975 static void
8977 {
8981 {
8984 tree sentinel;
8985 function_args_iterator iter;
8986 tree t;
8988 /* Skip over the named arguments. */
8990 {
8993 len++;
8994 }
8997 {
9000 }
9002 /* The sentinel must be one of the varargs, i.e.
9003 in position >= the number of fixed arguments. */
9005 {
9009 }
9011 /* Validate the sentinel. */
9015 /* Although __null (in C++) is only an integer we allow it
9016 nevertheless, as we are guaranteed that it's exactly
9017 as wide as a pointer, and we don't want to force
9018 users to cast the NULL they have written there.
9019 We warn with -Wstrict-null-sentinel, though. */
9022 }
9023 }
9025 /* Helper for check_function_nonnull; given a list of operands which
9026 must be non-null in ARGS, determine if operand PARAM_NUM should be
9027 checked. */
9029 static bool
9031 {
9035 {
9042 }
9044 }
9046 /* Check that the function argument PARAM (which is operand number
9047 PARAM_NUM) is non-null. This is called by check_function_nonnull
9048 via check_function_arguments_recurse. */
9050 static void
9053 {
9054 /* Just skip checking the argument if it's not a pointer. This can
9055 happen if the "nonnull" attribute was given without an operand
9056 list (which means to check every pointer argument). */
9064 }
9066 /* Helper for nonnull attribute handling; fetch the operand number
9067 from the attribute argument list. */
9069 static bool
9071 {
9072 /* Verify the arg number is a small constant. */
9074 {
9077 }
9078 else
9080 }
9082 /* Handle a "nothrow" attribute; arguments as in
9083 struct attribute_spec.handler. */
9085 static tree
9088 {
9091 /* ??? TODO: Support types. */
9092 else
9093 {
9096 }
9099 }
9101 /* Handle a "cleanup" attribute; arguments as in
9102 struct attribute_spec.handler. */
9104 static tree
9107 {
9111 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
9112 for global destructors in C++. This requires infrastructure that
9113 we don't have generically at the moment. It's also not a feature
9114 we'd be missing too much, since we do have attribute constructor. */
9116 {
9120 }
9122 /* Verify that the argument is a function in scope. */
9123 /* ??? We could support pointers to functions here as well, if
9124 that was considered desirable. */
9127 {
9131 }
9134 {
9138 }
9140 /* That the function has proper type is checked with the
9141 eventual call to build_function_call. */
9144 }
9146 /* Handle a "warn_unused_result" attribute. No special handling. */
9148 static tree
9152 {
9153 /* Ignore the attribute for functions not returning any value. */
9155 {
9158 }
9161 }
9163 /* Handle a "sentinel" attribute. */
9165 static tree
9168 {
9170 {
9174 }
9175 else
9176 {
9178 {
9182 }
9183 }
9186 {
9194 {
9198 }
9199 else
9200 {
9202 {
9206 }
9207 }
9208 }
9211 }
9213 /* Handle a "type_generic" attribute. */
9215 static tree
9219 {
9220 /* Ensure we have a function type. */
9223 /* Ensure we have a variadic function. */
9227 }
9229 /* Handle a "target" attribute. */
9231 static tree
9234 {
9235 /* Ensure we have a function type. */
9237 {
9240 }
9242 flags))
9246 }
9248 /* Arguments being collected for optimization. */
9253 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
9254 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
9255 false for #pragma GCC optimize. */
9257 bool
9259 {
9267 tree ap;
9269 /* Build up argv vector. Just in case the string is stored away, use garbage
9270 collected strings. */
9275 {
9279 {
9283 }
9286 {
9287 /* Split string into multiple substrings. */
9295 {
9302 {
9306 }
9307 else
9308 {
9311 }
9315 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
9316 options. */
9318 {
9323 else
9327 }
9330 {
9333 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
9334 itself is -Os, and any other switch begins with a -f. */
9340 }
9345 }
9347 }
9348 }
9358 /* Now parse the options. */
9368 /* Don't allow changing -fstrict-aliasing. */
9373 }
9375 /* For handling "optimize" attribute. arguments as in
9376 struct attribute_spec.handler. */
9378 static tree
9381 {
9382 /* Ensure we have a function type. */
9384 {
9387 }
9388 else
9389 {
9393 /* Save current options. */
9396 /* If we previously had some optimization options, use them as the
9397 default. */
9402 /* Parse options, and update the vector. */
9407 /* Restore current options. */
9409 }
9412 }
9414 /* Handle a "no_split_stack" attribute. */
9416 static tree
9421 {
9425 {
9429 }
9431 {
9435 }
9438 }
9440 /* Handle a "returns_nonnull" attribute; arguments as in
9441 struct attribute_spec.handler. */
9443 static tree
9446 {
9447 // Even without a prototype we still have a return type we can check.
9449 {
9452 }
9454 }
9456 /* Handle a "designated_init" attribute; arguments as in
9457 struct attribute_spec.handler. */
9459 static tree
9462 {
9464 {
9467 }
9469 }
9471 \f
9472 /* Check for valid arguments being passed to a function with FNTYPE.
9473 There are NARGS arguments in the array ARGARRAY. */
9474 void
9476 {
9477 /* Check for null being passed in a pointer argument that must be
9478 non-null. We also need to do this if format checking is enabled. */
9483 /* Check for errors in format strings. */
9490 }
9492 /* Generic argument checking recursion routine. PARAM is the argument to
9493 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
9494 once the argument is resolved. CTX is context for the callback. */
9495 void
9500 {
9504 {
9505 /* Strip coercion. */
9509 }
9512 {
9514 tree attrs;
9517 /* See if this is a call to a known internationalization function
9518 that modifies a format arg. Such a function may have multiple
9519 format_arg attributes (for example, ngettext). */
9522 attrs;
9525 {
9526 tree inner_arg;
9527 tree format_num_expr;
9530 call_expr_arg_iterator iter;
9532 /* Extract the argument number, which was previously checked
9533 to be valid. */
9542 {
9547 }
9548 }
9550 /* If we found a format_arg attribute and did a recursive check,
9551 we are done with checking this argument. Otherwise, we continue
9552 and this will be considered a non-literal. */
9555 }
9558 {
9559 /* Check both halves of the conditional expression. */
9565 }
9568 }
9570 /* Checks for a builtin function FNDECL that the number of arguments
9571 NARGS against the required number REQUIRED and issues an error if
9572 there is a mismatch. Returns true if the number of arguments is
9573 correct, otherwise false. */
9575 static bool
9577 {
9579 {
9583 }
9585 {
9589 }
9591 }
9593 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
9594 Returns false if there was an error, otherwise true. */
9596 bool
9598 {
9604 {
9614 {
9616 {
9620 }
9622 }
9632 {
9639 {
9643 }
9645 }
9650 {
9655 {
9659 }
9662 {
9664 fndecl);
9666 }
9668 }
9673 {
9675 {
9678 }
9680 }
9687 {
9691 {
9695 }
9698 {
9702 }
9704 }
9709 }
9710 }
9712 /* Function to help qsort sort FIELD_DECLs by name order. */
9714 int
9716 {
9721 /* A nontype is "greater" than a type. */
9730 }
9733 gt_pointer_operator new_value;
9737 /* This routine compares two fields like field_decl_cmp but using the
9738 pointer operator in resort_data. */
9740 static int
9742 {
9747 /* A nontype is "greater" than a type. */
9753 {
9760 }
9762 }
9764 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
9766 void
9769 gt_pointer_operator new_value,
9771 {
9776 resort_field_decl_cmp);
9777 }
9779 /* Subroutine of c_parse_error.
9780 Return the result of concatenating LHS and RHS. RHS is really
9781 a string literal, its first character is indicated by RHS_START and
9782 RHS_SIZE is its length (including the terminating NUL character).
9784 The caller is responsible for deleting the returned pointer. */
9788 {
9794 }
9796 /* Issue the error given by GMSGID, indicating that it occurred before
9797 TOKEN, which had the associated VALUE. */
9799 void
9802 {
9803 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
9813 {
9818 {
9831 }
9835 else
9841 }
9863 {
9868 }
9876 {
9881 }
9882 else
9886 {
9889 }
9890 #undef catenate_messages
9891 }
9893 /* Return the gcc option code associated with the reason for a cpp
9894 message, or 0 if none. */
9896 static int
9898 {
9902 {
9905 }
9907 }
9909 /* Callback from cpp_error for PFILE to print diagnostics from the
9910 preprocessor. The diagnostic is of type LEVEL, with REASON set
9911 to the reason code if LEVEL is represents a warning, at location
9912 LOCATION unless this is after lexing and the compiler's location
9913 should be used instead, with column number possibly overridden by
9914 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
9915 the arguments. Returns true if a diagnostic was emitted, false
9916 otherwise. */
9918 bool
9922 {
9923 diagnostic_info diagnostic;
9924 diagnostic_t dlevel;
9929 {
9934 /* Fall through. */
9959 }
9972 }
9974 /* Convert a character from the host to the target execution character
9975 set. cpplib handles this, mostly. */
9977 HOST_WIDE_INT
9979 {
9980 /* Character constants in GCC proper are sign-extended under -fsigned-char,
9981 zero-extended under -fno-signed-char. cpplib insists that characters
9982 and character constants are always unsigned. Hence we must convert
9983 back and forth. */
9991 else
9993 }
9995 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
9996 references with an INDIRECT_REF of a constant at the bottom; much like the
9997 traditional rendering of offsetof as a macro. Return the folded result. */
9999 tree
10001 {
10005 {
10021 {
10024 }
10034 {
10038 }
10051 /* Check if the offset goes beyond the upper bound of the array. */
10053 {
10059 {
10063 {
10064 tree v;
10071 {
10079 }
10080 /* Don't warn if the array might be considered a poor
10081 man's flexible array member with a very permissive
10082 definition thereof. */
10086 "index %E denotes an offset "
10089 }
10090 }
10091 }
10098 /* Handle static members of volatile structs. */
10105 }
10108 }
10110 /* Likewise, but convert it to the return type of offsetof. */
10112 tree
10114 {
10116 }
10118 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
10119 expression, because B will always be true. */
10121 void
10123 {
10126 "the omitted middle operand in ?: will always be %<true%>, "
10128 }
10130 /* Give an error for storing into ARG, which is 'const'. USE indicates
10131 how ARG was being used. */
10133 void
10135 {
10138 /* Using this macro rather than (for example) arrays of messages
10139 ensures that all the format strings are checked at compile
10140 time. */
10141 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
10142 : (use == lv_increment ? (I) \
10143 : (use == lv_decrement ? (D) : (AS))))
10145 {
10156 else
10162 }
10168 arg);
10174 arg);
10176 {
10186 arg);
10187 }
10193 arg);
10194 else
10199 arg);
10200 }
10202 /* Print an error message for an invalid lvalue. USE says
10203 how the lvalue is being used and so selects the error message. LOC
10204 is the location for the error. */
10206 void
10208 {
10210 {
10228 }
10229 }
10231 /* Print an error message for an invalid indirection of type TYPE.
10232 ERRSTRING is the name of the operator for the indirection. */
10234 void
10236 {
10238 {
10246 type);
10251 type);
10256 type);
10261 type);
10266 type);
10270 }
10271 }
10272 \f
10273 /* *PTYPE is an incomplete array. Complete it with a domain based on
10274 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
10275 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10276 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
10278 int
10280 {
10288 {
10290 {
10291 int eltsize
10294 }
10296 {
10300 {
10304 }
10305 else
10306 {
10307 tree curindex;
10318 {
10322 else
10323 {
10325 {
10326 /* Since we treat size types now as ordinary
10327 unsigned types, we need an explicit overflow
10328 check. */
10332 }
10334 size_one_node);
10335 }
10338 }
10340 {
10344 }
10345 }
10346 }
10347 else
10348 {
10349 /* Make an error message unless that happened already. */
10352 }
10353 }
10354 else
10355 {
10359 }
10366 else
10369 /* Using build_distinct_type_copy and modifying things afterward instead
10370 of using build_array_type to create a new type preserves all of the
10371 TYPE_LANG_FLAG_? bits that the front end may have set. */
10379 /* Make sure we have the canonical MAIN_TYPE. */
10382 hashcode);
10385 /* Fix the canonical type. */
10395 else
10400 else
10406 {
10408 /* If we proceed with the array type as it is, we'll eventually
10409 crash in tree_to_[su]hwi(). */
10411 }
10415 }
10417 /* Like c_mark_addressable but don't check register qualifier. */
10418 void
10420 {
10426 }
10429 \f
10430 /* Used to help initialize the builtin-types.def table. When a type of
10431 the correct size doesn't exist, use error_mark_node instead of NULL.
10432 The later results in segfaults even when a decl using the type doesn't
10433 get invoked. */
10435 tree
10437 {
10440 }
10442 /* A helper function for resolve_overloaded_builtin in resolving the
10443 overloaded __sync_ builtins. Returns a positive power of 2 if the
10444 first operand of PARAMS is a pointer to a supported data type.
10445 Returns 0 if an error is encountered. */
10447 static int
10449 {
10450 tree type;
10454 {
10457 }
10461 {
10462 /* Force array-to-pointer decay for C++. */
10466 }
10478 incompatible:
10481 }
10483 /* A helper function for resolve_overloaded_builtin. Adds casts to
10484 PARAMS to make arguments match up with those of FUNCTION. Drops
10485 the variadic arguments at the end. Returns false if some error
10486 was encountered; true on success. */
10488 static bool
10491 {
10492 function_args_iterator iter;
10493 tree ptype;
10497 /* We've declared the implementation functions to use "volatile void *"
10498 as the pointer parameter, so we shouldn't get any complaints from the
10499 call to check_function_arguments what ever type the user used. */
10504 /* For the rest of the values, we need to cast these to FTYPE, so that we
10505 don't get warnings for passing pointer types, etc. */
10508 {
10512 /* XXX void_type_node belies the abstraction. */
10518 {
10521 }
10523 /* Only convert parameters if arg_type is unsigned integer type with
10524 new format sync routines, i.e. don't attempt to convert pointer
10525 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
10526 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
10527 kinds). */
10529 {
10530 /* Ideally for the first conversion we'd use convert_for_assignment
10531 so that we get warnings for anything that doesn't match the pointer
10532 type. This isn't portable across the C and C++ front ends atm. */
10537 }
10540 }
10542 /* __atomic routines are not variadic. */
10544 {
10547 }
10549 /* The definition of these primitives is variadic, with the remaining
10550 being "an optional list of variables protected by the memory barrier".
10551 No clue what that's supposed to mean, precisely, but we consider all
10552 call-clobbered variables to be protected so we're safe. */
10556 }
10558 /* A helper function for resolve_overloaded_builtin. Adds a cast to
10559 RESULT to make it match the type of the first pointer argument in
10560 PARAMS. */
10562 static tree
10564 {
10569 /* New format doesn't require casting unless the types are the same size. */
10572 else
10574 }
10576 /* This function verifies the PARAMS to generic atomic FUNCTION.
10577 It returns the size if all the parameters are the same size, otherwise
10578 0 is returned if the parameters are invalid. */
10580 static int
10583 {
10588 tree type_0;
10590 /* Determine the parameter makeup. */
10592 {
10608 }
10611 {
10614 }
10616 /* Get type of first parameter, and determine its size. */
10619 {
10620 /* Force array-to-pointer decay for C++. */
10624 }
10626 {
10628 function);
10630 }
10632 /* Types must be compile time constant sizes. */
10634 {
10637 function);
10639 }
10643 /* Zero size objects are not allowed. */
10645 {
10648 function);
10650 }
10652 /* Check each other parameter is a pointer and the same size. */
10654 {
10657 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
10661 {
10663 function);
10665 }
10669 {
10671 function);
10673 }
10674 }
10676 /* Check memory model parameters for validity. */
10678 {
10681 {
10684 {
10687 function);
10688 }
10689 }
10690 else
10692 {
10694 function);
10696 }
10697 }
10700 }
10703 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
10704 at the beginning of the parameter list PARAMS representing the size of the
10705 objects. This is to match the library ABI requirement. LOC is the location
10706 of the function call.
10707 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
10708 returned to allow the external call to be constructed. */
10710 static tree
10713 {
10714 tree size_node;
10716 /* Insert a SIZE_T parameter as the first param. If there isn't
10717 enough space, allocate a new vector and recursively re-build with that. */
10719 {
10722 tree f;
10732 }
10734 /* Add the size parameter and leave as a function call for processing. */
10738 }
10741 /* Return whether atomic operations for naturally aligned N-byte
10742 arguments are supported, whether inline or through libatomic. */
10743 static bool
10745 {
10747 {
10759 }
10760 }
10762 /* This will process an __atomic_exchange function call, determine whether it
10763 needs to be mapped to the _N variation, or turned into a library call.
10764 LOC is the location of the builtin call.
10765 FUNCTION is the DECL that has been invoked;
10766 PARAMS is the argument list for the call. The return value is non-null
10767 TRUE is returned if it is translated into the proper format for a call to the
10768 external library, and NEW_RETURN is set the tree for that function.
10769 FALSE is returned if processing for the _N variation is required, and
10770 NEW_RETURN is set to the the return value the result is copied into. */
10771 static bool
10774 {
10779 /* Size of 0 is an error condition. */
10781 {
10784 }
10786 /* If not a lock-free size, change to the library generic format. */
10788 {
10791 }
10793 /* Otherwise there is a lockfree match, transform the call from:
10794 void fn(T* mem, T* desired, T* return, model)
10795 into
10796 *return = (T) (fn (In* mem, (In) *desired, model)) */
10803 /* Create pointer to appropriate size. */
10807 /* Convert object pointer to required type. */
10810 /* Convert new value to required type, and dereference it. */
10815 /* Move memory model to the 3rd position, and end param list. */
10819 /* Convert return pointer and dereference it for later assignment. */
10823 }
10826 /* This will process an __atomic_compare_exchange function call, determine
10827 whether it needs to be mapped to the _N variation, or turned into a lib call.
10828 LOC is the location of the builtin call.
10829 FUNCTION is the DECL that has been invoked;
10830 PARAMS is the argument list for the call. The return value is non-null
10831 TRUE is returned if it is translated into the proper format for a call to the
10832 external library, and NEW_RETURN is set the tree for that function.
10833 FALSE is returned if processing for the _N variation is required. */
10835 static bool
10839 {
10844 /* Size of 0 is an error condition. */
10846 {
10849 }
10851 /* If not a lock-free size, change to the library generic format. */
10853 {
10854 /* The library generic format does not have the weak parameter, so
10855 remove it from the param list. Since a parameter has been removed,
10856 we can be sure that there is room for the SIZE_T parameter, meaning
10857 there will not be a recursive rebuilding of the parameter list, so
10858 there is no danger this will be done twice. */
10860 {
10864 }
10867 }
10869 /* Otherwise, there is a match, so the call needs to be transformed from:
10870 bool fn(T* mem, T* desired, T* return, weak, success, failure)
10871 into
10872 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
10878 /* Create pointer to appropriate size. */
10882 /* Convert object pointer to required type. */
10886 /* Convert expected pointer to required type. */
10890 /* Convert desired value to required type, and dereference it. */
10895 /* The rest of the parameters are fine. NULL means no special return value
10896 processing.*/
10899 }
10902 /* This will process an __atomic_load function call, determine whether it
10903 needs to be mapped to the _N variation, or turned into a library call.
10904 LOC is the location of the builtin call.
10905 FUNCTION is the DECL that has been invoked;
10906 PARAMS is the argument list for the call. The return value is non-null
10907 TRUE is returned if it is translated into the proper format for a call to the
10908 external library, and NEW_RETURN is set the tree for that function.
10909 FALSE is returned if processing for the _N variation is required, and
10910 NEW_RETURN is set to the the return value the result is copied into. */
10912 static bool
10915 {
10920 /* Size of 0 is an error condition. */
10922 {
10925 }
10927 /* If not a lock-free size, change to the library generic format. */
10929 {
10932 }
10934 /* Otherwise, there is a match, so the call needs to be transformed from:
10935 void fn(T* mem, T* return, model)
10936 into
10937 *return = (T) (fn ((In *) mem, model)) */
10943 /* Create pointer to appropriate size. */
10947 /* Convert object pointer to required type. */
10951 /* Move memory model to the 2nd position, and end param list. */
10955 /* Convert return pointer and dereference it for later assignment. */
10959 }
10962 /* This will process an __atomic_store function call, determine whether it
10963 needs to be mapped to the _N variation, or turned into a library call.
10964 LOC is the location of the builtin call.
10965 FUNCTION is the DECL that has been invoked;
10966 PARAMS is the argument list for the call. The return value is non-null
10967 TRUE is returned if it is translated into the proper format for a call to the
10968 external library, and NEW_RETURN is set the tree for that function.
10969 FALSE is returned if processing for the _N variation is required, and
10970 NEW_RETURN is set to the the return value the result is copied into. */
10972 static bool
10975 {
10980 /* Size of 0 is an error condition. */
10982 {
10985 }
10987 /* If not a lock-free size, change to the library generic format. */
10989 {
10992 }
10994 /* Otherwise, there is a match, so the call needs to be transformed from:
10995 void fn(T* mem, T* value, model)
10996 into
10997 fn ((In *) mem, (In) *value, model) */
11002 /* Create pointer to appropriate size. */
11006 /* Convert object pointer to required type. */
11010 /* Convert new value to required type, and dereference it. */
11015 /* The memory model is in the right spot already. Return is void. */
11019 }
11022 /* Some builtin functions are placeholders for other expressions. This
11023 function should be called immediately after parsing the call expression
11024 before surrounding code has committed to the type of the expression.
11026 LOC is the location of the builtin call.
11028 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
11029 PARAMS is the argument list for the call. The return value is non-null
11030 when expansion is complete, and null if normal processing should
11031 continue. */
11033 tree
11036 {
11042 {
11048 else
11052 }
11054 /* Handle BUILT_IN_NORMAL here. */
11056 {
11061 {
11062 /* Handle these 4 together so that they can fall through to the next
11063 case if the call is transformed to an _N variant. */
11065 {
11067 {
11071 /* Change to the _N variant. */
11074 }
11077 {
11079 params,
11082 /* Change to the _N variant. */
11085 }
11087 {
11091 /* Change to the _N variant. */
11094 }
11096 {
11100 /* Change to the _N variant. */
11103 }
11106 }
11107 /* Fallthrough to the normal processing. */
11108 }
11125 {
11127 /* Fallthru for parameter processing. */
11128 }
11145 {
11156 orig_format))
11161 NULL);
11169 /* If new_return is set, assign function to that expr and cast the
11170 result to void since the generic interface returned void. */
11172 {
11173 /* Cast function result from I{1,2,4,8,16} to the required type. */
11176 result);
11180 }
11182 }
11186 }
11187 }
11189 /* vector_types_compatible_elements_p is used in type checks of vectors
11190 values used as operands of binary operators. Where it returns true, and
11191 the other checks of the caller succeed (being vector types in he first
11192 place, and matching number of elements), we can just treat the types
11193 as essentially the same.
11194 Contrast with vector_targets_convertible_p, which is used for vector
11195 pointer types, and vector_types_convertible_p, which will allow
11196 language-specific matches under the control of flag_lax_vector_conversions,
11197 and might still require a conversion. */
11198 /* True if vector types T1 and T2 can be inputs to the same binary
11199 operator without conversion.
11200 We don't check the overall vector size here because some of our callers
11201 want to give different error messages when the vectors are compatible
11202 except for the element count. */
11204 bool
11206 {
11219 /* Equality works here because c_common_signed_type uses
11220 TYPE_MAIN_VARIANT. */
11228 }
11230 /* Check for missing format attributes on function pointers. LTYPE is
11231 the new type or left-hand side type. RTYPE is the old type or
11232 right-hand side type. Returns TRUE if LTYPE is missing the desired
11233 attribute. */
11235 bool
11237 {
11239 tree ra;
11245 {
11246 tree la;
11251 }
11252 else
11254 }
11256 /* Subscripting with type char is likely to lose on a machine where
11257 chars are signed. So warn on any machine, but optionally. Don't
11258 warn for unsigned char since that type is safe. Don't warn for
11259 signed char because anyone who uses that must have done so
11260 deliberately. Furthermore, we reduce the false positive load by
11261 warning only for non-constant value of type char. */
11263 void
11265 {
11269 }
11271 /* Implement -Wparentheses for the unexpected C precedence rules, to
11272 cover cases like x + y << z which readers are likely to
11273 misinterpret. We have seen an expression in which CODE is a binary
11274 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
11275 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
11276 CODE_RIGHT may be ERROR_MARK, which means that that side of the
11277 expression was not formed using a binary or unary operator, or it
11278 was enclosed in parentheses. */
11280 void
11284 {
11288 /* This macro tests that the expression ARG with original tree code
11289 CODE appears to be a boolean expression. or the result of folding a
11290 boolean expression. */
11291 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
11292 (truth_value_p (TREE_CODE (ARG)) \
11293 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
11295 || ((CODE) != INTEGER_CST \
11296 && (integer_onep (ARG) || integer_zerop (ARG))))
11299 {
11348 /* Check cases like x|y==z */
11355 /* Check cases like !x | y */
11359 "suggest parentheses around operand of "
11372 /* Check cases like x^y==z */
11394 /* Check cases like x&y==z */
11401 /* Check cases like !x & y */
11405 "suggest parentheses around operand of "
11428 {
11433 "comparisons like %<X<=Y<=Z%> do not "
11439 "comparisons like %<X<=Y<=Z%> do not "
11441 }
11443 }
11444 #undef NOT_A_BOOLEAN_EXPR_P
11445 }
11447 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
11449 void
11451 {
11453 {
11456 else
11458 }
11459 }
11461 /* Warn for division by zero according to the value of DIVISOR. LOC
11462 is the location of the division operator. */
11464 void
11466 {
11467 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
11468 about division by zero. Do not issue a warning if DIVISOR has a
11469 floating-point type, since we consider 0.0/0.0 a valid way of
11470 generating a NaN. */
11474 }
11476 /* Subroutine of build_binary_op. Give warnings for comparisons
11477 between signed and unsigned quantities that may fail. Do the
11478 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
11479 so that casts will be considered, but default promotions won't
11480 be.
11482 LOCATION is the location of the comparison operator.
11484 The arguments of this function map directly to local variables
11485 of build_binary_op. */
11487 void
11492 {
11497 /* In C++, check for comparison of different enum types. */
11503 {
11507 }
11509 /* Do not warn if the comparison is being done in a signed type,
11510 since the signed type will only be chosen if it can represent
11511 all the values of the unsigned type. */
11514 /* Do not warn if both operands are unsigned. */
11517 else
11518 {
11524 else
11532 /* Do not warn if the signed quantity is an unsuffixed integer
11533 literal (or some static constant expression involving such
11534 literals or a conditional expression involving such literals)
11535 and it is non-negative. */
11538 /* Do not warn if the comparison is an equality operation, the
11539 unsigned quantity is an integral constant, and it would fit
11540 in the result if the result were signed. */
11545 /* In C, do not warn if the unsigned quantity is an enumeration
11546 constant and its maximum value would fit in the result if the
11547 result were signed. */
11553 else
11555 OPT_Wsign_compare,
11557 }
11559 /* Warn if two unsigned values are being compared in a size larger
11560 than their original size, and one (and only one) is the result of
11561 a `~' operator. This comparison will always fail.
11563 Also warn if one operand is a constant, and the constant does not
11564 have all bits set that are set in the ~ operand when it is
11565 extended. */
11572 {
11579 {
11580 tree primop;
11586 {
11590 }
11591 else
11592 {
11596 }
11601 {
11604 {
11608 else
11611 }
11612 }
11613 }
11621 }
11622 }
11624 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
11625 type via c_common_type. If -Wdouble-promotion is in use, and the
11626 conditions for warning have been met, issue a warning. GMSGID is
11627 the warning message. It must have two %T specifiers for the type
11628 that was converted (generally "float") and the type to which it was
11629 converted (generally "double), respectively. LOC is the location
11630 to which the awrning should refer. */
11632 void
11635 {
11636 tree source_type;
11640 /* If the conversion will not occur at run-time, there is no need to
11641 warn about it. */
11653 else
11656 }
11658 /* Setup a TYPE_DECL node as a typedef representation.
11660 X is a TYPE_DECL for a typedef statement. Create a brand new
11661 ..._TYPE node (which will be just a variant of the existing
11662 ..._TYPE node with identical properties) and then install X
11663 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
11665 The whole point here is to end up with a situation where each
11666 and every ..._TYPE node the compiler creates will be uniquely
11667 associated with AT MOST one node representing a typedef name.
11668 This way, even though the compiler substitutes corresponding
11669 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
11670 early on, later parts of the compiler can always do the reverse
11671 translation and get back the corresponding typedef name. For
11672 example, given:
11674 typedef struct S MY_TYPE;
11675 MY_TYPE object;
11677 Later parts of the compiler might only know that `object' was of
11678 type `struct S' if it were not for code just below. With this
11679 code however, later parts of the compiler see something like:
11681 struct S' == struct S
11682 typedef struct S' MY_TYPE;
11683 struct S' object;
11685 And they can then deduce (from the node for type struct S') that
11686 the original object declaration was:
11688 MY_TYPE object;
11690 Being able to do this is important for proper support of protoize,
11691 and also for generating precise symbolic debugging information
11692 which takes full account of the programmer's (typedef) vocabulary.
11694 Obviously, we don't want to generate a duplicate ..._TYPE node if
11695 the TYPE_DECL node that we are now processing really represents a
11696 standard built-in type. */
11698 void
11700 {
11704 {
11707 }
11710 {
11718 }
11719 }
11721 /* Record the types used by the current global variable declaration
11722 being parsed, so that we can decide later to emit their debug info.
11723 Those types are in types_used_by_cur_var_decl, and we are going to
11724 store them in the types_used_by_vars_hash hash table.
11725 DECL is the declaration of the global variable that has been parsed. */
11727 void
11729 {
11733 {
11736 }
11737 }
11739 /* If DECL is a typedef that is declared in the current function,
11740 record it for the purpose of -Wunused-local-typedefs. */
11742 void
11744 {
11749 /* if this is not a locally defined typedef then we are not
11750 interested. */
11757 }
11759 /* If T is a TYPE_DECL declared locally, mark it as used. */
11761 void
11763 {
11768 }
11770 /* Warn if there are some unused locally defined typedefs in the
11771 current function. */
11773 void
11775 {
11777 tree decl;
11778 /* The number of times we have emitted -Wunused-local-typedefs
11779 warnings. If this is different from errorcount, that means some
11780 unrelated errors have been issued. In which case, we'll avoid
11781 emitting "unused-local-typedefs" warnings. */
11793 {
11797 OPT_Wunused_local_typedefs,
11800 }
11803 }
11805 /* Warn about boolean expression compared with an integer value different
11806 from true/false. Warns also e.g. about "(i1 == i2) == 2".
11807 LOC is the location of the comparison, CODE is its code, OP0 and OP1
11808 are the operands of the comparison. The caller must ensure that
11809 either operand is a boolean expression. */
11811 void
11813 tree op1)
11814 {
11824 {
11832 else
11835 }
11836 }
11838 /* The C and C++ parsers both use vectors to hold function arguments.
11839 For efficiency, we keep a cache of unused vectors. This is the
11840 cache. */
11845 /* Return a new vector from the cache. If the cache is empty,
11846 allocate a new vector. These vectors are GC'ed, so it is OK if the
11847 pointer is not released.. */
11851 {
11854 else
11855 {
11856 /* Passing 0 to vec::alloc returns NULL, and our callers require
11857 that we always return a non-NULL value. The vector code uses
11858 4 when growing a NULL vector, so we do too. */
11862 }
11863 }
11865 /* Release a vector of trees back to the cache. */
11867 void
11869 {
11871 {
11874 }
11875 }
11877 /* Get a new tree vector holding a single tree. */
11881 {
11885 }
11887 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
11891 {
11896 }
11898 /* Get a new tree vector which is a copy of an existing one. */
11902 {
11905 tree t;
11912 }
11914 /* Return true if KEYWORD starts a type specifier. */
11916 bool
11918 {
11920 {
11954 }
11955 }
11957 /* Return true if KEYWORD names a type qualifier. */
11959 bool
11961 {
11963 {
11971 }
11972 }
11974 /* Return true if KEYWORD names a storage class specifier.
11976 RID_TYPEDEF is not included in this list despite `typedef' being
11977 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
11978 such for syntactic convenience only. */
11980 bool
11982 {
11984 {
11994 }
11995 }
11997 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
11999 static bool
12001 {
12003 {
12011 }
12012 }
12014 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
12015 declaration-specifier (C99 6.7). */
12017 bool
12019 {
12026 {
12033 }
12034 }
12036 /* Initialize language-specific-bits of tree_contains_struct. */
12038 void
12040 {
12044 }
12046 /* Build a user-defined numeric literal out of an integer constant type VALUE
12047 with identifier SUFFIX. */
12049 tree
12052 {
12059 }
12061 /* For vector[index], convert the vector to a
12062 pointer of the underlying type. */
12063 void
12066 {
12068 {
12070 tree type1;
12083 {
12084 /* If the original vector isn't declared may_alias and it
12085 isn't a bare vector look if the subscripting would
12086 alias the vector we subscript, and if not, force ref-all. */
12092 }
12096 }
12097 }
12099 /* Determine which of the operands, if any, is a scalar that needs to be
12100 converted to a vector, for the range of operations. */
12101 enum stv_conv
12104 {
12113 {
12114 /* Most GENERIC binary expressions require homogeneous arguments.
12115 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
12116 argument that is a vector and a second one that is a scalar, so
12117 we never return stv_secondarg for them. */
12122 {
12124 {
12129 }
12130 else
12132 }
12139 /* ... fall through ... */
12160 /* What about UNLT_EXPR? */
12162 {
12163 tree tmp;
12165 /* Swap TYPE0 with TYPE1 and OP0 with OP1 */
12168 }
12172 {
12174 {
12179 }
12181 }
12183 /* Allow integer --> real conversion if safe. */
12187 {
12189 {
12194 }
12196 }
12199 }
12202 }
12204 /* Return true iff ALIGN is an integral constant that is a fundamental
12205 alignment, as defined by [basic.align] in the c++-11
12206 specifications.
12208 That is:
12210 [A fundamental alignment is represented by an alignment less than or
12211 equal to the greatest alignment supported by the implementation
12212 in all contexts, which is equal to
12213 alignof(max_align_t)]. */
12215 bool
12217 {
12220 }
12222 /* Return true if T is a pointer to a zero-sized aggregate. */
12224 bool
12226 {
12231 }