| blob | ada8e8aa9016d0e93448f6befe97ef2560e3f016 |
1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2015 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/>. */
20 #define GCC_C_COMMON_C
70 /* Mode used to build pointers (VOIDmode means ptr_mode). */
74 /* The following symbols are subsumed in the c_global_trees array, and
75 listed here individually for documentation purposes.
77 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
79 tree short_integer_type_node;
80 tree long_integer_type_node;
81 tree long_long_integer_type_node;
83 tree short_unsigned_type_node;
84 tree long_unsigned_type_node;
85 tree long_long_unsigned_type_node;
87 tree truthvalue_type_node;
88 tree truthvalue_false_node;
89 tree truthvalue_true_node;
91 tree ptrdiff_type_node;
93 tree unsigned_char_type_node;
94 tree signed_char_type_node;
95 tree wchar_type_node;
97 tree char16_type_node;
98 tree char32_type_node;
100 tree float_type_node;
101 tree double_type_node;
102 tree long_double_type_node;
104 tree complex_integer_type_node;
105 tree complex_float_type_node;
106 tree complex_double_type_node;
107 tree complex_long_double_type_node;
109 tree dfloat32_type_node;
110 tree dfloat64_type_node;
111 tree_dfloat128_type_node;
113 tree intQI_type_node;
114 tree intHI_type_node;
115 tree intSI_type_node;
116 tree intDI_type_node;
117 tree intTI_type_node;
119 tree unsigned_intQI_type_node;
120 tree unsigned_intHI_type_node;
121 tree unsigned_intSI_type_node;
122 tree unsigned_intDI_type_node;
123 tree unsigned_intTI_type_node;
125 tree widest_integer_literal_type_node;
126 tree widest_unsigned_literal_type_node;
128 Nodes for types `void *' and `const void *'.
130 tree ptr_type_node, const_ptr_type_node;
132 Nodes for types `char *' and `const char *'.
134 tree string_type_node, const_string_type_node;
136 Type `char[SOMENUMBER]'.
137 Used when an array of char is needed and the size is irrelevant.
139 tree char_array_type_node;
141 Type `wchar_t[SOMENUMBER]' or something like it.
142 Used when a wide string literal is created.
144 tree wchar_array_type_node;
146 Type `char16_t[SOMENUMBER]' or something like it.
147 Used when a UTF-16 string literal is created.
149 tree char16_array_type_node;
151 Type `char32_t[SOMENUMBER]' or something like it.
152 Used when a UTF-32 string literal is created.
154 tree char32_array_type_node;
156 Type `int ()' -- used for implicit declaration of functions.
158 tree default_function_type;
160 A VOID_TYPE node, packaged in a TREE_LIST.
162 tree void_list_node;
164 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
165 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
166 VAR_DECLS, but C++ does.)
168 tree function_name_decl_node;
169 tree pretty_function_name_decl_node;
170 tree c99_function_name_decl_node;
172 Stack of nested function name VAR_DECLs.
174 tree saved_function_name_decls;
176 */
179 \f
180 /* Switches common to the C front ends. */
182 /* Nonzero means don't output line number information. */
186 /* Nonzero causes -E output not to be done, but directives such as
187 #define that have side effects are still obeyed. */
191 /* Nonzero means dump macros in some fashion. */
195 /* Nonzero means pass #include lines through to the output. */
199 /* Nonzero means process PCH files while preprocessing. */
203 /* The file name to which we should write a precompiled header, or
204 NULL if no header will be written in this compile. */
208 /* Nonzero if an ISO standard was selected. It rejects macros in the
209 user's namespace. */
212 /* C/ObjC language option variables. */
215 /* Nonzero means allow type mismatches in conditional expressions;
216 just make their values `void'. */
220 /* Nonzero means enable C89 Amendment 1 features. */
224 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
228 /* Nonzero means use the ISO C11 dialect of C. */
232 /* Nonzero means that we have builtin functions, and main is an int. */
237 /* ObjC language option variables. */
240 /* Tells the compiler that this is a special run. Do not perform any
241 compiling, instead we are to test some platform dependent features
242 and output a C header file with appropriate definitions. */
246 /* Tells the compiler what is the constant string class for ObjC. */
251 /* C++ language option variables. */
254 /* Nonzero means generate separate instantiation control files and
255 juggle them at link time. */
259 /* The C++ dialect being used. C++98 is the default. */
263 /* Maximum template instantiation depth. This limit exists to limit the
264 time it takes to notice excessively recursive template instantiations.
266 The default is lower than the 1024 recommended by the C++0x standard
267 because G++ runs out of stack before 1024 with highly recursive template
268 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
272 /* The elements of `ridpointers' are identifier nodes for the reserved
273 type names and storage classes. It is indexed by a RID_... value. */
278 /* Nonzero means don't warn about problems that occur when the code is
279 executed. */
282 /* Whether we are building a boolean conversion inside
283 convert_for_assignment, or some other late binary operation. If
284 build_binary_op is called for C (from code shared by C and C++) in
285 this case, then the operands have already been folded and the
286 result will not be folded again, so C_MAYBE_CONST_EXPR should not
287 be generated. */
290 /* Whether lexing has been completed, so subsequent preprocessor
291 errors should use the compiler's input_location. */
294 /* Information about how a function name is generated. */
295 struct fname_var_t
296 {
300 };
302 /* The three ways of getting then name of the current function. */
305 {
306 /* C99 compliant __func__, must be first. */
308 /* GCC __FUNCTION__ compliant. */
310 /* GCC __PRETTY_FUNCTION__ compliant. */
313 };
315 /* Global visibility options. */
414 /* Reserved words. The third field is a mask: keywords are disabled
415 if they match the mask.
417 Masks for languages:
418 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
419 C --std=c99: D_CXXONLY | D_OBJC
420 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
421 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
422 C++ --std=c0x: D_CONLY | D_OBJC
423 ObjC++ is like C++ except that D_OBJC is not set
425 If -fno-asm is used, D_ASM is added to the mask. If
426 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
427 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
428 In C with -Wc++-compat, we warn if D_CXXWARN is set.
430 Note the complication of the D_CXX_OBJC keywords. These are
431 reserved words such as 'class'. In C++, 'class' is a reserved
432 word. In Objective-C++ it is too. In Objective-C, it is a
433 reserved word too, but only if it follows an '@' sign.
434 */
436 {
601 /* These Objective-C keywords are recognized only immediately after
602 an '@'. */
619 /* These are recognized only in protocol-qualifier context
620 (see above) */
627 /* These are recognized inside a property attribute list */
636 };
641 /* Table of machine-independent attributes common to all C-like languages.
643 All attributes referencing arguments should be additionally processed
644 in chkp_copy_function_type_adding_bounds for correct instrumentation
645 by Pointer Bounds Checker.
646 Current list of processed common attributes: nonnull. */
648 {
649 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
650 affects_type_identity } */
657 /* FIXME: logically, noreturn attributes should be listed as
658 "false, true, true" and apply to function types. But implementing this
659 would require all the places in the compiler that use TREE_THIS_VOLATILE
660 on a decl to identify non-returning functions to be located and fixed
661 to check the function type instead. */
692 /* The same comments as for noreturn attributes apply to const ones. */
716 handle_no_instrument_function_attribute,
734 /* ??? These two attributes didn't make the transition from the
735 Intel language document to the multi-vendor language document. */
740 /* For internal use (marking of builtins) only. The name contains space
741 to prevent its usage in source code. */
763 /* For internal use (marking of builtins) only. The name contains space
764 to prevent its usage in source code. */
775 handle_no_address_safety_analysis_attribute,
778 handle_no_sanitize_address_attribute,
781 handle_no_sanitize_address_attribute,
784 handle_no_sanitize_undefined_attribute,
794 /* For internal use only. The leading '*' both prevents its usage in
795 source code and signals that it may be overridden by machine tables. */
800 /* For internal use (marking of builtins and runtime functions) only.
801 The name contains space to prevent its usage in source code. */
827 };
829 /* Give the specifications for the format attributes, used by C and all
830 descendants.
832 All attributes referencing arguments should be additionally processed
833 in chkp_copy_function_type_adding_bounds for correct instrumentation
834 by Pointer Bounds Checker.
835 Current list of processed format attributes: format, format_arg. */
837 {
838 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
839 affects_type_identity } */
845 };
847 /* Return identifier for address space AS. */
851 {
855 }
857 /* Push current bindings for the function name VAR_DECLS. */
859 void
861 {
866 {
870 {
872 saved);
874 }
875 }
877 /* Normally they'll have been NULL, so only push if we've got a
878 stack, or they are non-NULL. */
880 saved_function_name_decls);
881 }
883 /* Finish up the current bindings, adding them into the current function's
884 statement tree. This must be done _before_ finish_stmt_tree is called.
885 If there is no current function, we must be at file scope and no statements
886 are involved. Pop the previous bindings. */
888 void
890 {
899 {
907 }
913 {
914 /* We had saved values, restore them. */
915 tree saved;
918 {
923 }
925 }
927 }
929 /* Return the text name of the current function, suitably prettified
930 by PRETTY_P. Return string must be freed by caller. */
934 {
941 {
944 }
957 {
960 }
963 }
965 /* Return the VAR_DECL for a const char array naming the current
966 function. If the VAR_DECL has not yet been created, create it
967 now. RID indicates how it should be formatted and IDENTIFIER_NODE
968 ID is its name (unfortunately C and C++ hold the RID values of
969 keywords in different places, so we can't derive RID from ID in
970 this language independent code. LOC is the location of the
971 function. */
973 tree
975 {
985 {
986 /* If a tree is built here, it would normally have the lineno of
987 the current statement. Later this tree will be moved to the
988 beginning of the function and this line number will be wrong.
989 To avoid this problem set the lineno to 0 here; that prevents
990 it from appearing in the RTL. */
991 tree stmts;
999 saved_function_name_decls
1003 }
1008 }
1010 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1012 tree
1014 {
1019 /* Compute the number of elements, for the array type. */
1021 {
1024 }
1026 {
1029 }
1031 {
1034 }
1035 else
1036 {
1039 }
1041 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1042 limit in C++98 Annex B is very large (65536) and is not normative,
1043 so we do not diagnose it (warn_overlength_strings is forced off
1044 in c_common_post_options). */
1046 {
1050 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1051 separate the %d from the 'C'. 'ISO' should not be
1052 translated, but it may be moved after 'C%d' in languages
1053 where modifiers follow nouns. */
1055 "string length %qd is greater than the length %qd "
1058 }
1060 /* Create the array type for the string constant. The ISO C++
1061 standard says that a string literal has type `const char[N]' or
1062 `const wchar_t[N]'. We use the same logic when invoked as a C
1063 front-end with -Wwrite-strings.
1064 ??? We should change the type of an expression depending on the
1065 state of a warning flag. We should just be warning -- see how
1066 this is handled in the C++ front-end for the deprecated implicit
1067 conversion from string literals to `char*' or `wchar_t*'.
1069 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1070 array type being the unqualified version of that type.
1071 Therefore, if we are constructing an array of const char, we must
1072 construct the matching unqualified array type first. The C front
1073 end does not require this, but it does no harm, so we do it
1074 unconditionally. */
1085 }
1086 \f
1087 /* If DISABLE is true, stop issuing warnings. This is used when
1088 parsing code that we know will not be executed. This function may
1089 be called multiple times, and works as a stack. */
1091 static void
1093 {
1095 {
1098 }
1099 }
1101 /* If ENABLE is true, reenable issuing warnings. */
1103 static void
1105 {
1107 {
1110 }
1111 }
1113 /* Fully fold EXPR, an expression that was not folded (beyond integer
1114 constant expressions and null pointer constants) when being built
1115 up. If IN_INIT, this is in a static initializer and certain
1116 changes are made to the folding done. Clear *MAYBE_CONST if
1117 MAYBE_CONST is not NULL and EXPR is definitely not a constant
1118 expression because it contains an evaluated operator (in C99) or an
1119 operator outside of sizeof returning an integer constant (in C90)
1120 not permitted in constant expressions, or because it contains an
1121 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
1122 set to true by callers before calling this function.) Return the
1123 folded expression. Function arguments have already been folded
1124 before calling this function, as have the contents of SAVE_EXPR,
1125 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1126 C_MAYBE_CONST_EXPR. */
1128 tree
1130 {
1131 tree ret;
1137 /* This function is not relevant to C++ because C++ folds while
1138 parsing, and may need changes to be correct for C++ when C++
1139 stops folding while parsing. */
1146 {
1149 }
1156 }
1158 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1159 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1160 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1161 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1162 both evaluated and unevaluated subexpressions while
1163 *MAYBE_CONST_ITSELF is carried from only evaluated
1164 subexpressions). */
1166 static tree
1169 {
1181 /* This function is not relevant to C++ because C++ folds while
1182 parsing, and may need changes to be correct for C++ when C++
1183 stops folding while parsing. */
1187 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1188 anything else not counted as an expression cannot usefully be
1189 folded further at this point. */
1195 /* Operands of variable-length expressions (function calls) have
1196 already been folded, as have __builtin_* function calls, and such
1197 expressions cannot occur in constant expressions. */
1199 {
1203 }
1206 {
1215 else
1218 }
1220 /* Assignment, increment, decrement, function call and comma
1221 operators, and statement expressions, cannot occur in constant
1222 expressions if evaluated / outside of sizeof. (Function calls
1223 were handled above, though VA_ARG_EXPR is treated like a function
1224 call here, and statement expressions are handled through
1225 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1227 {
1247 }
1249 /* Fold individual tree codes as appropriate. */
1251 {
1253 /* Any non-constancy will have been marked in a containing
1254 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1262 maybe_const_itself);
1267 {
1270 }
1279 maybe_const_itself);
1282 maybe_const_itself);
1288 {
1292 }
1334 /* Binary operations evaluating both arguments (increment and
1335 decrement are binary internally in GCC). */
1339 maybe_const_itself);
1347 /* The RHS of a MODIFY_EXPR was fully folded when building that
1348 expression for the sake of conversion warnings. */
1351 maybe_const_itself);
1355 ret = in_init
1358 else
1371 {
1384 }
1401 CASE_CONVERT:
1412 /* Unary operations. */
1415 maybe_const_itself);
1419 /* ??? Cope with user tricks that amount to offsetof. The middle-end is
1420 not prepared to deal with them if they occur in initializers. */
1428 ret = in_init
1431 else
1436 {
1440 }
1442 {
1445 CASE_CONVERT:
1446 /* Don't warn about explicit conversions. We will already
1447 have warned about suspect implicit conversions. */
1454 }
1459 /* Binary operations not necessarily evaluating both
1460 arguments. */
1467 ? truthvalue_false_node
1475 ret = in_init
1478 else
1483 && op0_const
1484 && op0_const_self
1490 && op0_const_self
1516 else
1521 && op0_const
1522 && op0_const_self
1526 && op0_const_self
1530 && op0_const
1531 && op0_const_self
1535 && op0_const_self
1541 /* Each case where an operand with excess precision may be
1542 encountered must remove the EXCESS_PRECISION_EXPR around
1543 inner operands and possibly put one around the whole
1544 expression or possibly convert to the semantic type (which
1545 c_fully_fold does); we cannot tell at this stage which is
1546 appropriate in any particular case. */
1550 /* Various codes may appear through folding built-in functions
1551 and their arguments. */
1553 }
1555 out:
1556 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1557 have been done by this point, so remove them again. */
1561 {
1565 }
1569 }
1571 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1572 return EXP. Otherwise, return either EXP or its known constant
1573 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1574 Is the BLKmode test appropriate? */
1576 tree
1578 {
1579 tree ret;
1581 /* This function is only used by C, for c_fully_fold and other
1582 optimization, and may not be correct for C++. */
1593 /* Avoid unwanted tree sharing between the initializer and current
1594 function's body where the tree can be modified e.g. by the
1595 gimplifier. */
1599 }
1601 /* Print a warning if a constant expression had overflow in folding.
1602 Invoke this function on every expression that the language
1603 requires to be a constant expression.
1604 Note the ANSI C standard says it is erroneous for a
1605 constant expression to overflow. */
1607 void
1609 {
1617 }
1619 /* The same as above but print an unconditional error. */
1620 void
1622 {
1629 }
1631 /* Print a warning if an expression had overflow in folding and its
1632 operands hadn't.
1634 Invoke this function on every expression that
1635 (1) appears in the source code, and
1636 (2) is a constant expression that overflowed, and
1637 (3) is not already checked by convert_and_check;
1638 however, do not invoke this function on operands of explicit casts
1639 or when the expression is the result of an operator and any operand
1640 already overflowed. */
1642 void
1644 {
1649 {
1678 }
1679 }
1681 /* Warn about uses of logical || / && operator in a context where it
1682 is likely that the bitwise equivalent was intended by the
1683 programmer. We have seen an expression in which CODE is a binary
1684 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1685 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1686 void
1690 {
1702 /* We don't want to warn if either operand comes from a macro
1703 expansion. ??? This doesn't work with e.g. NEGATE_EXPR yet;
1704 see PR61534. */
1709 /* Warn if &&/|| are being used in a context where it is
1710 likely that the bitwise equivalent was intended by the
1711 programmer. That is, an expression such as op && MASK
1712 where op should not be any boolean expression, nor a
1713 constant, and mask seems to be a non-boolean integer constant. */
1721 {
1725 else
1730 }
1732 /* We do not warn for constants because they are typical of macro
1733 expansions that test for features. */
1737 /* This warning only makes sense with logical operands. */
1744 /* The range computations only work with scalars. */
1749 /* We first test whether either side separately is trivially true
1750 (with OR) or trivially false (with AND). If so, do not warn.
1751 This is a common idiom for testing ranges of data types in
1752 portable code. */
1759 /* If this is an OR operation, invert both sides; now, the result
1760 should be always false to get a warning. */
1774 /* If this is an OR operation, invert both sides; now, the result
1775 should be always false to get a warning. */
1783 /* If both expressions have the same operand, if we can merge the
1784 ranges, ... */
1788 {
1790 /* ... and if the range test is always false, then warn. */
1792 {
1795 "logical %<or%> of collectively exhaustive tests is "
1797 else
1799 "logical %<and%> of mutually exclusive tests is "
1801 }
1802 /* Or warn if the operands have exactly the same range, e.g.
1803 A > 0 && A > 0. */
1805 {
1809 else
1812 }
1813 }
1814 }
1816 /* Warn about logical not used on the left hand side operand of a comparison.
1817 This function assumes that the LHS is inside of TRUTH_NOT_EXPR.
1818 Do not warn if RHS is of a boolean type. */
1820 void
1822 tree rhs)
1823 {
1829 /* Don't warn for !x == 0 or !y != 0, those are equivalent to
1830 !(x == 0) or !(y != 0). */
1836 "logical not is only applied to the left hand side of "
1838 }
1840 /* Warn if EXP contains any computations whose results are not used.
1841 Return true if a warning is printed; false otherwise. LOCUS is the
1842 (potential) location of the expression. */
1844 bool
1846 {
1847 restart:
1851 /* Don't warn about void constructs. This includes casting to void,
1852 void function calls, and statement expressions with a final cast
1853 to void. */
1861 {
1877 /* For a binding, warn if no side effect within it. */
1889 /* In && or ||, warn if 2nd operand has no side effect. */
1896 /* Let people do `(foo (), 0)' without a warning. */
1903 /* If this is an expression with side effects, don't warn; this
1904 case commonly appears in macro expansions. */
1910 /* Don't warn about automatic dereferencing of references, since
1911 the user cannot control it. */
1913 {
1916 }
1917 /* Fall through. */
1920 /* Referencing a volatile value is a side effect, so don't warn. */
1925 /* If this is an expression which has no operands, there is no value
1926 to be unused. There are no such language-independent codes,
1927 but front ends may define such. */
1931 warn:
1933 }
1934 }
1937 /* Print a warning about casts that might indicate violation
1938 of strict aliasing rules if -Wstrict-aliasing is used and
1939 strict aliasing mode is in effect. OTYPE is the original
1940 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1942 bool
1944 {
1945 /* Strip pointer conversion chains and get to the correct original type. */
1953 /* If the type we are casting to is a ref-all pointer
1954 dereferencing it is always valid. */
1961 {
1962 /* Casting the address of an object to non void pointer. Warn
1963 if the cast breaks type based aliasing. */
1965 {
1969 }
1970 else
1971 {
1972 /* warn_strict_aliasing >= 3. This includes the default (3).
1973 Only warn if the cast is dereferenced immediately. */
1974 alias_set_type set1 =
1980 {
1984 }
1987 {
1991 }
1992 }
1993 }
1994 else
1996 {
1997 /* At this level, warn for any conversions, even if an address is
1998 not taken in the same statement. This will likely produce many
1999 false positives, but could be useful to pinpoint problems that
2000 are not revealed at higher levels. */
2005 {
2009 }
2010 }
2013 }
2015 /* Warn about memset (&a, 0, sizeof (&a)); and similar mistakes with
2016 sizeof as last operand of certain builtins. */
2018 void
2022 {
2026 location_t loc;
2034 {
2038 /* FALLTHRU */
2046 /* FALLTHRU */
2105 }
2133 {
2137 {
2140 "argument to %<sizeof%> in %qD call is the same "
2141 "expression as the destination; did you mean to "
2147 "argument to %<sizeof%> in %qD call is the same "
2148 "expression as the destination; did you mean to "
2150 else
2152 "argument to %<sizeof%> in %qD call is the same "
2153 "expression as the destination; did you mean to "
2156 }
2159 && !strop
2162 {
2164 "argument to %<sizeof%> in %qD call is the same "
2165 "pointer type %qT as the destination; expected %qT "
2169 }
2170 }
2173 {
2177 {
2180 "argument to %<sizeof%> in %qD call is the same "
2181 "expression as the source; did you mean to "
2187 "argument to %<sizeof%> in %qD call is the same "
2188 "expression as the source; did you mean to "
2190 else
2192 "argument to %<sizeof%> in %qD call is the same "
2193 "expression as the source; did you mean to "
2196 }
2199 && !strop
2202 {
2204 "argument to %<sizeof%> in %qD call is the same "
2205 "pointer type %qT as the source; expected %qT "
2209 }
2210 }
2213 {
2217 {
2220 "argument to %<sizeof%> in %qD call is the same "
2221 "expression as the first source; did you mean to "
2227 "argument to %<sizeof%> in %qD call is the same "
2228 "expression as the first source; did you mean to "
2230 else
2232 "argument to %<sizeof%> in %qD call is the same "
2233 "expression as the first source; did you mean to "
2236 }
2239 && !strop
2242 {
2244 "argument to %<sizeof%> in %qD call is the same "
2245 "pointer type %qT as the first source; expected %qT "
2249 }
2250 }
2253 {
2257 {
2260 "argument to %<sizeof%> in %qD call is the same "
2261 "expression as the second source; did you mean to "
2267 "argument to %<sizeof%> in %qD call is the same "
2268 "expression as the second source; did you mean to "
2270 else
2272 "argument to %<sizeof%> in %qD call is the same "
2273 "expression as the second source; did you mean to "
2276 }
2279 && !strop
2282 {
2284 "argument to %<sizeof%> in %qD call is the same "
2285 "pointer type %qT as the second source; expected %qT "
2289 }
2290 }
2292 }
2294 /* Warn for unlikely, improbable, or stupid DECL declarations
2295 of `main'. */
2297 void
2299 {
2300 function_args_iterator iter;
2301 tree type;
2305 {
2306 /* XXX void_type_node belies the abstraction. */
2316 {
2322 }
2326 {
2348 "third argument of %q+D should probably be "
2351 }
2352 }
2354 /* It is intentional that this message does not mention the third
2355 argument because it's only mentioned in an appendix of the
2356 standard. */
2364 }
2366 /* vector_targets_convertible_p is used for vector pointer types. The
2367 callers perform various checks that the qualifiers are satisfactory,
2368 while OTOH vector_targets_convertible_p ignores the number of elements
2369 in the vectors. That's fine with vector pointers as we can consider,
2370 say, a vector of 8 elements as two consecutive vectors of 4 elements,
2371 and that does not require and conversion of the pointer values.
2372 In contrast, vector_types_convertible_p and
2373 vector_types_compatible_elements_p are used for vector value types. */
2374 /* True if pointers to distinct types T1 and T2 can be converted to
2375 each other without an explicit cast. Only returns true for opaque
2376 vector types. */
2377 bool
2379 {
2386 }
2388 /* vector_types_convertible_p is used for vector value types.
2389 It could in principle call vector_targets_convertible_p as a subroutine,
2390 but then the check for vector type would be duplicated with its callers,
2391 and also the purpose of vector_targets_convertible_p would become
2392 muddled.
2393 Where vector_types_convertible_p returns true, a conversion might still be
2394 needed to make the types match.
2395 In contrast, vector_targets_convertible_p is used for vector pointer
2396 values, and vector_types_compatible_elements_p is used specifically
2397 in the context for binary operators, as a check if use is possible without
2398 conversion. */
2399 /* True if vector types T1 and T2 can be converted to each other
2400 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
2401 can only be converted with -flax-vector-conversions yet that is not
2402 in effect, emit a note telling the user about that option if such
2403 a note has not previously been emitted. */
2404 bool
2406 {
2414 convertible_lax =
2429 {
2432 "conversions between vectors with differing "
2434 }
2437 }
2439 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
2440 and have vector types, V0 has the same type as V1, and the number of
2441 elements of V0, V1, MASK is the same.
2443 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2444 called with two arguments. In this case implementation passes the
2445 first argument twice in order to share the same tree code. This fact
2446 could enable the mask-values being twice the vector length. This is
2447 an implementation accident and this semantics is not guaranteed to
2448 the user. */
2449 tree
2452 {
2453 tree ret;
2459 {
2462 }
2470 {
2475 }
2479 {
2483 }
2486 {
2491 }
2497 {
2500 "argument vector(s) and the mask vector should "
2503 }
2507 {
2512 }
2515 {
2516 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
2522 else
2523 {
2526 }
2530 }
2540 }
2542 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
2543 to integral type. */
2545 static tree
2547 {
2552 {
2553 /* C++0x scoped enumerations don't implicitly convert to integral
2554 type; if we stripped an explicit conversion to a larger type we
2555 need to replace it so common_type will still work. */
2559 }
2561 }
2563 /* This is a helper function of build_binary_op.
2565 For certain operations if both args were extended from the same
2566 smaller type, do the arithmetic in that type and then extend.
2568 BITWISE indicates a bitwise operation.
2569 For them, this optimization is safe only if
2570 both args are zero-extended or both are sign-extended.
2571 Otherwise, we might change the result.
2572 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2573 but calculated in (unsigned short) it would be (unsigned short)-1.
2574 */
2575 tree
2577 {
2581 tree type;
2583 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
2584 excessive narrowing when we call get_narrower below. For
2585 example, suppose that OP0 is of unsigned int extended
2586 from signed char and that RESULT_TYPE is long long int.
2587 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
2588 like
2590 (long long int) (unsigned int) signed_char
2592 which get_narrower would narrow down to
2594 (unsigned int) signed char
2596 If we do not cast OP0 first, get_narrower would return
2597 signed_char, which is inconsistent with the case of the
2598 explicit cast. */
2605 /* UNS is 1 if the operation to be done is an unsigned one. */
2608 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2609 but it *requires* conversion to FINAL_TYPE. */
2620 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2622 /* For bitwise operations, signedness of nominal type
2623 does not matter. Consider only how operands were extended. */
2627 /* Note that in all three cases below we refrain from optimizing
2628 an unsigned operation on sign-extended args.
2629 That would not be valid. */
2631 /* Both args variable: if both extended in same way
2632 from same width, do it in that width.
2633 Do it unsigned if args were zero-extended. */
2640 return c_common_signed_or_unsigned_type
2647 && (type
2658 && (type
2666 }
2668 /* Checks if expression EXPR of real/integer type cannot be converted
2669 to the real/integer type TYPE. Function returns non-zero when:
2670 * EXPR is a constant which cannot be exactly converted to TYPE.
2671 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
2672 for EXPR type and TYPE being both integers or both real.
2673 * EXPR is not a constant of real type and TYPE is an integer.
2674 * EXPR is not a constant of integer type which cannot be
2675 exactly converted to real type.
2676 Function allows conversions between types of different signedness and
2677 can return SAFE_CONVERSION (zero) in that case. Function can produce
2678 signedness warnings if PRODUCE_WARNS is true. */
2680 enum conversion_safety
2682 {
2688 {
2689 /* Warn for real constant that is not an exact integer converted
2690 to integer type. */
2693 {
2696 }
2697 /* Warn for an integer constant that does not fit into integer type. */
2701 {
2704 {
2708 }
2710 {
2714 }
2715 else
2717 }
2719 {
2720 /* Warn for an integer constant that does not fit into real type. */
2722 {
2726 }
2727 /* Warn for a real constant that does not fit into a smaller
2728 real type. */
2731 {
2735 }
2736 }
2737 }
2738 else
2739 {
2740 /* Warn for real types converted to integer types. */
2747 {
2748 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2752 /* Don't warn for short y; short x = ((int)y & 0xff); */
2756 {
2757 /* If both args were extended from a shortest type,
2758 use that type if that is safe. */
2765 {
2771 /* If one of the operands is a non-negative constant
2772 that fits in the target type, then the type of the
2773 other operand does not matter. */
2782 /* If constant is unsigned and fits in the target
2783 type, then the result will also fit. */
2785 && unsigned0
2788 && unsigned1
2791 }
2792 }
2793 /* Warn for integer types converted to smaller integer types. */
2797 /* When they are the same width but different signedness,
2798 then the value may change. */
2801 /* Even when converted to a bigger type, if the type is
2802 unsigned but expr is signed, then negative values
2803 will be changed. */
2809 }
2811 /* Warn for integer types converted to real types if and only if
2812 all the range of values of the integer type cannot be
2813 represented by the real type. */
2816 {
2820 /* Don't warn about char y = 0xff; float x = (int) y; */
2832 }
2834 /* Warn for real types converted to smaller real types. */
2839 }
2842 }
2844 /* Warns if the conversion of EXPR to TYPE may alter a value.
2845 This is a helper function for warnings_for_convert_and_check. */
2847 static void
2849 {
2856 /* This may happen, because for LHS op= RHS we preevaluate
2857 RHS and create C_MAYBE_CONST_EXPR <SAVE_EXPR <RHS>>, which
2858 means we could no longer see the code of the EXPR. */
2865 {
2878 /* Conversion from boolean to a signed:1 bit-field (which only
2879 can hold the values 0 and -1) doesn't lose information - but
2880 it does change the value. */
2900 {
2901 /* In case of COND_EXPR, we do not care about the type of
2902 COND_EXPR, only about the conversion of each operand. */
2909 }
2921 }
2922 }
2924 /* Produce warnings after a conversion. RESULT is the result of
2925 converting EXPR to TYPE. This is a helper function for
2926 convert_and_check and cp_convert_and_check. */
2928 void
2930 tree result)
2931 {
2938 {
2939 /* Do not diagnose overflow in a constant expression merely
2940 because a conversion overflowed. */
2945 {
2946 /* This detects cases like converting -129 or 256 to
2947 unsigned char. */
2951 else
2953 }
2957 /* No warning for converting 0x80000000 to int. */
2965 else
2967 }
2972 else
2974 }
2977 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2978 Invoke this function on every expression that is converted implicitly,
2979 i.e. because of language rules and not because of an explicit cast. */
2981 tree
2983 {
2984 tree result;
2985 tree expr_for_warning;
2987 /* Convert from a value with possible excess precision rather than
2988 via the semantic type, but do not warn about values not fitting
2989 exactly in the semantic type. */
2991 {
2997 }
2998 else
3012 }
3013 \f
3014 /* A node in a list that describes references to variables (EXPR), which are
3015 either read accesses if WRITER is zero, or write accesses, in which case
3016 WRITER is the parent of EXPR. */
3017 struct tlist
3018 {
3021 };
3023 /* Used to implement a cache the results of a call to verify_tree. We only
3024 use this for SAVE_EXPRs. */
3025 struct tlist_cache
3026 {
3030 tree expr;
3031 };
3033 /* Obstack to use when allocating tlist structures, and corresponding
3034 firstobj. */
3038 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
3039 warnings. */
3041 /* SAVE_EXPRs need special treatment. We process them only once and then
3042 cache the results. */
3054 /* Create a new struct tlist and fill in its fields. */
3057 {
3064 }
3066 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
3067 is nonnull, we ignore any node we find which has a writer equal to it. */
3069 static void
3071 {
3073 {
3080 }
3081 }
3083 /* Merge the nodes of ADD into TO. This merging process is done so that for
3084 each variable that already exists in TO, no new node is added; however if
3085 there is a write access recorded in ADD, and an occurrence on TO is only
3086 a read access, then the occurrence in TO will be modified to record the
3087 write. */
3089 static void
3091 {
3098 {
3105 {
3109 }
3111 {
3115 }
3117 }
3118 }
3120 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
3121 references in list LIST conflict with it, excluding reads if ONLY writers
3122 is nonzero. */
3124 static void
3127 {
3130 /* Avoid duplicate warnings. */
3136 {
3140 {
3145 }
3147 }
3148 }
3150 /* Given a list LIST of references to variables, find whether any of these
3151 can cause conflicts due to missing sequence points. */
3153 static void
3155 {
3159 {
3162 }
3163 }
3165 /* Return nonzero if X is a tree that can be verified by the sequence point
3166 warnings. */
3167 static int
3169 {
3176 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
3177 (lvalue_p) crash on TRY/CATCH. */
3184 /* No point to track non-const calls, they will never satisfy
3185 operand_equal_p. */
3193 }
3195 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
3196 static bool
3198 {
3200 }
3202 /* Walk the tree X, and record accesses to variables. If X is written by the
3203 parent tree, WRITER is the parent.
3204 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
3205 expression or its only operand forces a sequence point, then everything up
3206 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
3207 in PNO_SP.
3208 Once we return, we will have emitted warnings if any subexpression before
3209 such a sequence point could be undefined. On a higher level, however, the
3210 sequence point may not be relevant, and we'll merge the two lists.
3212 Example: (b++, a) + b;
3213 The call that processes the COMPOUND_EXPR will store the increment of B
3214 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
3215 processes the PLUS_EXPR will need to merge the two lists so that
3216 eventually, all accesses end up on the same list (and we'll warn about the
3217 unordered subexpressions b++ and b.
3219 A note on merging. If we modify the former example so that our expression
3220 becomes
3221 (b++, b) + a
3222 care must be taken not simply to add all three expressions into the final
3223 PNO_SP list. The function merge_tlist takes care of that by merging the
3224 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
3225 way, so that no more than one access to B is recorded. */
3227 static void
3229 tree writer)
3230 {
3235 /* X may be NULL if it is the operand of an empty statement expression
3236 ({ }). */
3240 restart:
3248 {
3281 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
3282 two first, to avoid warning for (a ? b++ : b++). */
3298 /* Expressions inside the LHS are not ordered wrt. the sequence points
3299 in the RHS. Example:
3300 *a = (a++, 2)
3301 Despite the fact that the modification of "a" is in the before_sp
3302 list (tmp_before), it conflicts with the use of "a" in the LHS.
3303 We can handle this by adding the contents of tmp_list3
3304 to those of tmp_before, and redoing the collision warnings for that
3305 list. */
3308 /* Exclude the LHS itself here; we first have to merge it into the
3309 tmp_nosp list. This is done to avoid warning for "a = a"; if we
3310 didn't exclude the LHS, we'd get it twice, once as a read and once
3311 as a write. */
3322 /* We need to warn about conflicts among arguments and conflicts between
3323 args and the function address. Side effects of the function address,
3324 however, are not ordered by the sequence point of the call. */
3325 {
3326 call_expr_arg_iterator iter;
3327 tree arg;
3331 {
3336 }
3341 }
3344 /* Scan all the list, e.g. indices of multi dimensional array. */
3346 {
3352 }
3356 {
3363 {
3377 }
3381 }
3391 /* For other expressions, simply recurse on their operands.
3392 Manual tail recursion for unary expressions.
3393 Other non-expressions need not be processed. */
3395 {
3399 }
3401 {
3405 {
3410 }
3411 }
3413 }
3414 }
3416 /* Try to warn for undefined behavior in EXPR due to missing sequence
3417 points. */
3419 DEBUG_FUNCTION void
3421 {
3427 {
3430 }
3435 }
3436 \f
3437 /* Validate the expression after `case' and apply default promotions. */
3439 static tree
3441 {
3446 /* Promote char or short to int. */
3449 {
3452 }
3457 }
3458 \f
3459 /* See if the case values LOW and HIGH are in the range of the original
3460 type (i.e. before the default conversion to int) of the switch testing
3461 expression.
3462 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
3463 the type before promoting it. CASE_LOW_P is a pointer to the lower
3464 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
3465 if the case is not a case range.
3466 The caller has to make sure that we are not called with NULL for
3467 CASE_LOW_P (i.e. the default case).
3468 Returns true if the case label is in range of ORIG_TYPE (saturated or
3469 untouched) or false if the label is out of range. */
3471 static bool
3474 {
3479 /* If there was a problem with the original type, do nothing. */
3486 /* Case label is less than minimum for type. */
3489 {
3493 }
3495 /* Case value is greater than maximum for type. */
3498 {
3501 }
3503 /* Saturate lower case label value to minimum. */
3506 {
3510 }
3512 /* Saturate upper case label value to maximum. */
3515 {
3519 }
3527 }
3528 \f
3529 /* Return an integer type with BITS bits of precision,
3530 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
3532 tree
3534 {
3576 }
3578 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
3579 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
3580 and saturating if SATP is nonzero, otherwise not saturating. */
3582 tree
3585 {
3586 machine_mode mode;
3589 else
3597 {
3599 "fixed-point types that have too many integral and "
3602 }
3605 }
3607 /* Used for communication between c_common_type_for_mode and
3608 c_register_builtin_type. */
3609 tree registered_builtin_types;
3611 /* Return a data type that has machine mode MODE.
3612 If the mode is an integer,
3613 then UNSIGNEDP selects between signed and unsigned types.
3614 If the mode is a fixed-point mode,
3615 then UNSIGNEDP selects between saturating and nonsaturating types. */
3617 tree
3619 {
3620 tree t;
3660 #if HOST_BITS_PER_WIDE_INT >= 64
3663 #endif
3688 {
3689 machine_mode inner_mode;
3690 tree inner_type;
3706 }
3708 {
3713 }
3723 {
3809 }
3817 }
3819 tree
3821 {
3823 }
3825 /* Return a signed type the same as TYPE in other respects. */
3827 tree
3829 {
3831 }
3833 /* Return a type the same as TYPE except unsigned or
3834 signed according to UNSIGNEDP. */
3836 tree
3838 {
3839 tree type1;
3842 /* This block of code emulates the behavior of the old
3843 c_common_unsigned_type. In particular, it returns
3844 long_unsigned_type_node if passed a long, even when a int would
3845 have the same size. This is necessary for warnings to work
3846 correctly in archs where sizeof(int) == sizeof(long) */
3849 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3869 #if HOST_BITS_PER_WIDE_INT >= 64
3872 #endif
3882 #define C_COMMON_FIXED_TYPES(NAME) \
3883 if (type1 == short_ ## NAME ## _type_node \
3884 || type1 == unsigned_short_ ## NAME ## _type_node) \
3885 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3886 : short_ ## NAME ## _type_node; \
3887 if (type1 == NAME ## _type_node \
3888 || type1 == unsigned_ ## NAME ## _type_node) \
3889 return unsignedp ? unsigned_ ## NAME ## _type_node \
3890 : NAME ## _type_node; \
3891 if (type1 == long_ ## NAME ## _type_node \
3892 || type1 == unsigned_long_ ## NAME ## _type_node) \
3893 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3894 : long_ ## NAME ## _type_node; \
3895 if (type1 == long_long_ ## NAME ## _type_node \
3896 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3897 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3898 : long_long_ ## NAME ## _type_node;
3900 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3901 if (type1 == NAME ## _type_node \
3902 || type1 == u ## NAME ## _type_node) \
3903 return unsignedp ? u ## NAME ## _type_node \
3904 : NAME ## _type_node;
3906 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3907 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3908 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3909 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3910 : sat_ ## short_ ## NAME ## _type_node; \
3911 if (type1 == sat_ ## NAME ## _type_node \
3912 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3913 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3914 : sat_ ## NAME ## _type_node; \
3915 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3916 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3917 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3918 : sat_ ## long_ ## NAME ## _type_node; \
3919 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3920 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3921 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3922 : sat_ ## long_long_ ## NAME ## _type_node;
3924 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3925 if (type1 == sat_ ## NAME ## _type_node \
3926 || type1 == sat_ ## u ## NAME ## _type_node) \
3927 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3928 : sat_ ## NAME ## _type_node;
3954 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3955 the precision; they have precision set to match their range, but
3956 may use a wider mode to match an ABI. If we change modes, we may
3957 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3958 the precision as well, so as to yield correct results for
3959 bit-field types. C++ does not have these separate bit-field
3960 types, and producing a signed or unsigned variant of an
3961 ENUMERAL_TYPE may cause other problems as well. */
3967 #define TYPE_OK(node) \
3968 (TYPE_MODE (type) == TYPE_MODE (node) \
3969 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3993 #if HOST_BITS_PER_WIDE_INT >= 64
3996 #endif
4005 #undef TYPE_OK
4008 }
4010 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
4012 tree
4014 {
4017 /* Extended integer types of the same width as a standard type have
4018 lesser rank, so those of the same width as int promote to int or
4019 unsigned int and are valid for printf formats expecting int or
4020 unsigned int. To avoid such special cases, avoid creating
4021 extended integer types for bit-fields if a standard integer type
4022 is available. */
4040 }
4042 /* The C version of the register_builtin_type langhook. */
4044 void
4046 {
4047 tree decl;
4057 }
4058 \f
4059 /* Print an error message for invalid operands to arith operation
4060 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
4061 LOCATION is the location of the message. */
4063 void
4066 {
4070 {
4115 }
4119 }
4120 \f
4121 /* Given an expression as a tree, return its original type. Do this
4122 by stripping any conversion that preserves the sign and precision. */
4123 static tree
4125 {
4128 }
4130 /* Subroutine of build_binary_op, used for comparison operations.
4131 See if the operands have both been converted from subword integer types
4132 and, if so, perhaps change them both back to their original type.
4133 This function is also responsible for converting the two operands
4134 to the proper common type for comparison.
4136 The arguments of this function are all pointers to local variables
4137 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
4138 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
4140 LOC is the location of the comparison.
4142 If this function returns nonzero, it means that the comparison has
4143 a constant value. What this function returns is an expression for
4144 that value. */
4146 tree
4149 {
4150 tree type;
4158 /* Throw away any conversions to wider types
4159 already present in the operands. */
4164 /* If primopN is first sign-extended from primopN's precision to opN's
4165 precision, then zero-extended from opN's precision to
4166 *restype_ptr precision, shortenings might be invalid. */
4169 && !unsignedp0
4174 && !unsignedp1
4178 /* Handle the case that OP0 does not *contain* a conversion
4179 but it *requires* conversion to FINAL_TYPE. */
4186 /* If one of the operands must be floated, we cannot optimize. */
4190 /* If first arg is constant, swap the args (changing operation
4191 so value is preserved), for canonicalization. Don't do this if
4192 the second arg is 0. */
4197 {
4214 {
4229 }
4231 }
4233 /* If comparing an integer against a constant more bits wide,
4234 maybe we can deduce a value of 1 or 0 independent of the data.
4235 Or else truncate the constant now
4236 rather than extend the variable at run time.
4238 This is only interesting if the constant is the wider arg.
4239 Also, it is not safe if the constant is unsigned and the
4240 variable arg is signed, since in this case the variable
4241 would be sign-extended and then regarded as unsigned.
4242 Our technique fails in this case because the lowest/highest
4243 possible unsigned results don't follow naturally from the
4244 lowest/highest possible values of the variable operand.
4245 For just EQ_EXPR and NE_EXPR there is another technique that
4246 could be used: see if the constant can be faithfully represented
4247 in the other operand's type, by truncating it and reextending it
4248 and see if that preserves the constant's value. */
4254 {
4257 /* 1 if comparison is nominally unsigned. */
4259 tree val;
4271 {
4272 /* Convert primop1 to target type, but do not introduce
4273 additional overflow. We know primop1 is an int_cst. */
4280 }
4282 {
4285 }
4293 /* This used to be a switch, but Genix compiler can't handle that. */
4295 {
4298 }
4300 {
4303 }
4305 {
4310 }
4312 {
4317 }
4319 {
4324 }
4326 {
4331 }
4333 /* If primop0 was sign-extended and unsigned comparison specd,
4334 we did a signed comparison above using the signed type bounds.
4335 But the comparison we output must be unsigned.
4337 Also, for inequalities, VAL is no good; but if the signed
4338 comparison had *any* fixed result, it follows that the
4339 unsigned comparison just tests the sign in reverse
4340 (positive values are LE, negative ones GE).
4341 So we can generate an unsigned comparison
4342 against an extreme value of the signed type. */
4345 {
4348 {
4363 }
4365 }
4368 {
4375 }
4378 {
4379 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4383 }
4385 /* Value is not predetermined, but do the comparison
4386 in the type of the operand that is not constant.
4387 TYPE is already properly set. */
4388 }
4390 /* If either arg is decimal float and the other is float, find the
4391 proper common type to use for comparison. */
4397 /* If either arg is decimal float and the other is float, fail. */
4408 /* If args' natural types are both narrower than nominal type
4409 and both extend in the same manner, compare them
4410 in the type of the wider arg.
4411 Otherwise must actually extend both to the nominal
4412 common type lest different ways of extending
4413 alter the result.
4414 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
4419 {
4423 type);
4424 /* Make sure shorter operand is extended the right way
4425 to match the longer operand. */
4426 primop0
4429 primop0);
4430 primop1
4433 primop1);
4434 }
4435 else
4436 {
4437 /* Here we must do the comparison on the nominal type
4438 using the args exactly as we received them. */
4445 {
4447 /* All unsigned values are >= 0, so we warn. However,
4448 if OP0 is a constant that is >= 0, the signedness of
4449 the comparison isn't an issue, so suppress the
4450 warning. */
4455 primop0)))
4456 /* Do not warn for enumeration types. */
4460 {
4477 }
4480 {
4481 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4486 }
4487 }
4488 }
4496 }
4497 \f
4498 /* Return a tree for the sum or difference (RESULTCODE says which)
4499 of pointer PTROP and integer INTOP. */
4501 tree
4504 {
4507 /* The result is a pointer of the same type that is being added. */
4511 {
4518 }
4520 {
4527 }
4528 else
4531 /* We are manipulating pointer values, so we don't need to warn
4532 about relying on undefined signed overflow. We disable the
4533 warning here because we use integer types so fold won't know that
4534 they are really pointers. */
4537 /* If what we are about to multiply by the size of the elements
4538 contains a constant term, apply distributive law
4539 and multiply that constant term separately.
4540 This helps produce common subexpressions. */
4545 /* If the constant comes from pointer subtraction,
4546 skip this optimization--it would cause an error. */
4548 /* If the constant is unsigned, and smaller than the pointer size,
4549 then we must skip this optimization. This is because it could cause
4550 an overflow error if the constant is negative but INTOP is not. */
4554 {
4559 /* Convert both subexpression types to the type of intop,
4560 because weird cases involving pointer arithmetic
4561 can result in a sum or difference with different type args. */
4566 }
4568 /* Convert the integer argument to a type the same size as sizetype
4569 so the multiply won't overflow spuriously. */
4575 /* Replace the integer argument with a suitable product by the object size.
4576 Do this multiplication as signed, then convert to the appropriate type
4577 for the pointer operation and disregard an overflow that occurred only
4578 because of the sign-extension change in the latter conversion. */
4579 {
4586 }
4588 /* Create the sum or difference. */
4597 }
4598 \f
4599 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
4600 and if NON_CONST is known not to be permitted in an evaluated part
4601 of a constant expression. */
4603 tree
4605 {
4609 /* This should never be called for C++. */
4613 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
4622 }
4624 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
4625 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
4626 around the SAVE_EXPR if needed so that c_fully_fold does not need
4627 to look inside SAVE_EXPRs. */
4629 tree
4631 {
4640 }
4642 /* Return whether EXPR is a declaration whose address can never be
4643 NULL. */
4645 bool
4647 {
4652 }
4654 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4655 or for an `if' or `while' statement or ?..: exp. It should already
4656 have been validated to be of suitable type; otherwise, a bad
4657 diagnostic may result.
4659 The EXPR is located at LOCATION.
4661 This preparation consists of taking the ordinary
4662 representation of an expression expr and producing a valid tree
4663 boolean expression describing whether expr is nonzero. We could
4664 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
4665 but we optimize comparisons, &&, ||, and !.
4667 The resulting type should always be `truthvalue_type_node'. */
4669 tree
4671 {
4673 {
4715 ? truthvalue_true_node
4721 ? truthvalue_true_node
4726 /* Fall through. */
4729 {
4732 {
4733 /* Common Ada/Pascal programmer's mistake. */
4735 OPT_Waddress,
4737 inner);
4739 }
4741 }
4758 /* These don't change whether an object is nonzero or zero. */
4763 /* These don't change whether an object is zero or nonzero, but
4764 we can't ignore them if their second arg has side-effects. */
4766 {
4769 c_common_truthvalue_conversion
4772 }
4773 else
4778 /* Distribute the conversion into the arms of a COND_EXPR. */
4780 {
4783 /* In C++ one of the arms might have void type if it is throw. */
4791 }
4792 else
4793 {
4794 /* Folding will happen later for C. */
4802 }
4804 CASE_CONVERT:
4805 {
4809 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4810 since that affects how `default_conversion' will behave. */
4814 /* Don't strip a conversion from C++0x scoped enum, since they
4815 don't implicitly convert to other types. */
4819 /* If this isn't narrowing the argument, we can ignore it. */
4823 }
4829 {
4833 }
4838 }
4841 {
4843 expr = (build_binary_op
4847 c_common_truthvalue_conversion
4850 c_common_truthvalue_conversion
4855 }
4858 {
4863 }
4864 else
4867 ret:
4870 }
4871 \f
4880 /* Apply the TYPE_QUALS to the new DECL. */
4882 void
4884 {
4892 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
4893 constructor can produce constant init, so rely on cp_finish_decl to
4894 clear TREE_READONLY if the variable has non-constant init. */
4897 {
4900 }
4902 {
4904 /* Allow 'restrict' on arrays of pointers.
4905 FIXME currently we just ignore it. */
4911 }
4912 }
4915 {
4918 };
4920 /* Hash function for the problem of multiple type definitions in
4921 different files. This must hash all types that will compare
4922 equal via comptypes to the same value. In practice it hashes
4923 on some of the simple stuff and leaves the details to comptypes. */
4925 hashval_t
4927 {
4930 tree t2;
4932 {
4933 /* For pointers, hash on pointee type plus some swizzling. */
4936 /* Hash on number of elements and total size. */
4955 }
4956 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4957 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4959 /* We might have a VLA here. */
4962 else
4965 }
4967 bool
4969 {
4971 }
4975 /* Return the typed-based alias set for T, which may be an expression
4976 or a type. Return -1 if we don't do anything special. */
4978 alias_set_type
4980 {
4981 tree u;
4983 /* For VLAs, use the alias set of the element type rather than the
4984 default of alias set 0 for types compared structurally. */
4986 {
4990 }
4992 /* Permit type-punning when accessing a union, provided the access
4993 is directly through the union. For example, this code does not
4994 permit taking the address of a union member and then storing
4995 through it. Even the type-punning allowed here is a GCC
4996 extension, albeit a common and useful one; the C standard says
4997 that such accesses have implementation-defined behavior. */
5005 /* That's all the expressions we handle specially. */
5009 /* The C standard guarantees that any object may be accessed via an
5010 lvalue that has character type. */
5016 /* The C standard specifically allows aliasing between signed and
5017 unsigned variants of the same type. We treat the signed
5018 variant as canonical. */
5020 {
5023 /* t1 == t can happen for boolean nodes which are always unsigned. */
5026 }
5028 /* Handle the case of multiple type nodes referring to "the same" type,
5029 which occurs with IMA. These share an alias set. FIXME: Currently only
5030 C90 is handled. (In C99 type compatibility is not transitive, which
5031 complicates things mightily. The alias set splay trees can theoretically
5032 represent this, but insertion is tricky when you consider all the
5033 different orders things might arrive in.) */
5038 /* Save time if there's only one input file. */
5042 /* Pointers need special handling if they point to any type that
5043 needs special handling (below). */
5045 {
5046 tree t2;
5047 /* Find bottom type under any nested POINTERs. */
5051 ;
5059 }
5060 /* These are the only cases that need special handling. */
5067 /* Undefined? */
5071 /* Look up t in hash table. Only one of the compatible types within each
5072 alias set is recorded in the table. */
5077 {
5080 }
5081 else
5082 /* Our caller will assign and record (in t) a new alias set; all we need
5083 to do is remember t in the hash table. */
5087 }
5088 \f
5089 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
5090 the IS_SIZEOF parameter indicates which operator is being applied.
5091 The COMPLAIN flag controls whether we should diagnose possibly
5092 ill-formed constructs or not. LOC is the location of the SIZEOF or
5093 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
5094 a type in any context should be returned, rather than the normal
5095 alignment for that type. */
5097 tree
5101 {
5109 {
5111 {
5118 }
5119 else
5120 {
5122 {
5126 else
5129 }
5131 }
5132 }
5134 {
5142 }
5145 {
5150 }
5153 {
5158 }
5159 else
5160 {
5162 /* Convert in case a char is more than one unit. */
5168 else
5170 }
5172 /* VALUE will have the middle-end integer type sizetype.
5173 However, we should really return a value of type `size_t',
5174 which is just a typedef for an ordinary integer type. */
5178 }
5180 /* Implement the __alignof keyword: Return the minimum required
5181 alignment of EXPR, measured in bytes. For VAR_DECLs,
5182 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
5183 from an "aligned" __attribute__ specification). LOC is the
5184 location of the ALIGNOF operator. */
5186 tree
5188 {
5189 tree t;
5196 {
5199 }
5205 {
5212 {
5219 }
5221 }
5222 else
5226 }
5227 \f
5228 /* Handle C and C++ default attributes. */
5230 enum built_in_attribute
5231 {
5232 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5233 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5234 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5235 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5236 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5238 #undef DEF_ATTR_NULL_TREE
5239 #undef DEF_ATTR_INT
5240 #undef DEF_ATTR_STRING
5241 #undef DEF_ATTR_IDENT
5242 #undef DEF_ATTR_TREE_LIST
5243 ATTR_LAST
5244 };
5250 enum c_builtin_type
5251 {
5252 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5253 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5254 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5255 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5256 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5257 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5258 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5259 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5260 ARG6) NAME,
5261 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5262 ARG6, ARG7) NAME,
5263 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5264 ARG6, ARG7, ARG8) NAME,
5265 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5266 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5267 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5268 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5269 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5270 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5271 NAME,
5272 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5273 ARG6, ARG7) NAME,
5274 #define DEF_FUNCTION_TYPE_VAR_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5275 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
5276 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5278 #undef DEF_PRIMITIVE_TYPE
5279 #undef DEF_FUNCTION_TYPE_0
5280 #undef DEF_FUNCTION_TYPE_1
5281 #undef DEF_FUNCTION_TYPE_2
5282 #undef DEF_FUNCTION_TYPE_3
5283 #undef DEF_FUNCTION_TYPE_4
5284 #undef DEF_FUNCTION_TYPE_5
5285 #undef DEF_FUNCTION_TYPE_6
5286 #undef DEF_FUNCTION_TYPE_7
5287 #undef DEF_FUNCTION_TYPE_8
5288 #undef DEF_FUNCTION_TYPE_VAR_0
5289 #undef DEF_FUNCTION_TYPE_VAR_1
5290 #undef DEF_FUNCTION_TYPE_VAR_2
5291 #undef DEF_FUNCTION_TYPE_VAR_3
5292 #undef DEF_FUNCTION_TYPE_VAR_4
5293 #undef DEF_FUNCTION_TYPE_VAR_5
5294 #undef DEF_FUNCTION_TYPE_VAR_7
5295 #undef DEF_FUNCTION_TYPE_VAR_11
5296 #undef DEF_POINTER_TYPE
5297 BT_LAST
5298 };
5302 /* A temporary array for c_common_nodes_and_builtins. Used in
5303 communication with def_fn_type. */
5306 /* A helper function for c_common_nodes_and_builtins. Build function type
5307 for DEF with return type RET and N arguments. If VAR is true, then the
5308 function should be variadic after those N arguments.
5310 Takes special care not to ICE if any of the types involved are
5311 error_mark_node, which indicates that said type is not in fact available
5312 (see builtin_type_for_size). In which case the function type as a whole
5313 should be error_mark_node. */
5315 static void
5317 {
5318 tree t;
5325 {
5331 }
5338 else
5341 egress:
5344 }
5346 /* Build builtin functions common to both C and C++ language
5347 frontends. */
5349 static void
5351 {
5352 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5353 builtin_types[ENUM] = VALUE;
5354 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5355 def_fn_type (ENUM, RETURN, 0, 0);
5356 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5357 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5358 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5359 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5360 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5361 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5362 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5363 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5364 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5365 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5366 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5367 ARG6) \
5368 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5369 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5370 ARG6, ARG7) \
5371 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5372 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5373 ARG6, ARG7, ARG8) \
5374 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5375 ARG7, ARG8);
5376 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5377 def_fn_type (ENUM, RETURN, 1, 0);
5378 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5379 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5380 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5381 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5382 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5383 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5384 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5385 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5386 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5387 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5388 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5389 ARG6, ARG7) \
5390 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5391 #define DEF_FUNCTION_TYPE_VAR_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5392 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
5393 def_fn_type (ENUM, RETURN, 1, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5394 ARG7, ARG8, ARG9, ARG10, ARG11);
5395 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5396 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5400 #undef DEF_PRIMITIVE_TYPE
5401 #undef DEF_FUNCTION_TYPE_0
5402 #undef DEF_FUNCTION_TYPE_1
5403 #undef DEF_FUNCTION_TYPE_2
5404 #undef DEF_FUNCTION_TYPE_3
5405 #undef DEF_FUNCTION_TYPE_4
5406 #undef DEF_FUNCTION_TYPE_5
5407 #undef DEF_FUNCTION_TYPE_6
5408 #undef DEF_FUNCTION_TYPE_7
5409 #undef DEF_FUNCTION_TYPE_8
5410 #undef DEF_FUNCTION_TYPE_VAR_0
5411 #undef DEF_FUNCTION_TYPE_VAR_1
5412 #undef DEF_FUNCTION_TYPE_VAR_2
5413 #undef DEF_FUNCTION_TYPE_VAR_3
5414 #undef DEF_FUNCTION_TYPE_VAR_4
5415 #undef DEF_FUNCTION_TYPE_VAR_5
5416 #undef DEF_FUNCTION_TYPE_VAR_7
5417 #undef DEF_FUNCTION_TYPE_VAR_11
5418 #undef DEF_POINTER_TYPE
5423 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5424 NONANSI_P, ATTRS, IMPLICIT, COND) \
5425 if (NAME && COND) \
5426 def_builtin_1 (ENUM, NAME, CLASS, \
5427 builtin_types[(int) TYPE], \
5428 builtin_types[(int) LIBTYPE], \
5429 BOTH_P, FALLBACK_P, NONANSI_P, \
5430 built_in_attributes[(int) ATTRS], IMPLICIT);
5432 #undef DEF_BUILTIN
5440 }
5442 /* Like get_identifier, but avoid warnings about null arguments when
5443 the argument may be NULL for targets where GCC lacks stdint.h type
5444 information. */
5448 {
5450 }
5452 /* Build tree nodes and builtin functions common to both C and C++ language
5453 frontends. */
5455 void
5457 {
5461 tree array_domain_type;
5462 tree va_list_ref_type_node;
5463 tree va_list_arg_type_node;
5468 /* Define `int' and `char' first so that dbx will output them first. */
5472 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
5473 "unsigned long", "long long unsigned" and "unsigned short" were in C++
5474 but not C. Are the conditionals here needed? */
5480 long_unsigned_type_node);
5483 {
5491 }
5496 long_long_integer_type_node);
5498 long_long_unsigned_type_node);
5501 long_long_unsigned_type_node);
5504 short_unsigned_type_node);
5507 short_unsigned_type_node);
5509 /* Define both `signed char' and `unsigned char'. */
5513 /* These are types that c_common_type_for_size and
5514 c_common_type_for_mode use. */
5517 intQI_type_node));
5520 intHI_type_node));
5523 intSI_type_node));
5526 intDI_type_node));
5527 #if HOST_BITS_PER_WIDE_INT >= 64
5528 /* Note that this is different than the __int128 type that's part of
5529 the generic __intN support. */
5532 TYPE_DECL,
5534 intTI_type_node));
5535 #endif
5538 unsigned_intQI_type_node));
5541 unsigned_intHI_type_node));
5544 unsigned_intSI_type_node));
5547 unsigned_intDI_type_node));
5548 #if HOST_BITS_PER_WIDE_INT >= 64
5551 TYPE_DECL,
5553 unsigned_intTI_type_node));
5554 #endif
5556 /* Create the widest literal types. */
5557 widest_integer_literal_type_node
5561 widest_integer_literal_type_node));
5563 widest_unsigned_literal_type_node
5567 widest_unsigned_literal_type_node));
5571 pid_type_node =
5578 /* Only supported decimal floating point extension if the target
5579 actually supports underlying modes. */
5583 {
5587 }
5590 {
5595 long_long_fract_type_node);
5597 unsigned_short_fract_type_node);
5599 unsigned_fract_type_node);
5601 unsigned_long_fract_type_node);
5603 unsigned_long_long_fract_type_node);
5605 sat_short_fract_type_node);
5608 sat_long_fract_type_node);
5610 sat_long_long_fract_type_node);
5612 sat_unsigned_short_fract_type_node);
5614 sat_unsigned_fract_type_node);
5616 sat_unsigned_long_fract_type_node);
5618 sat_unsigned_long_long_fract_type_node);
5623 long_long_accum_type_node);
5625 unsigned_short_accum_type_node);
5627 unsigned_accum_type_node);
5629 unsigned_long_accum_type_node);
5631 unsigned_long_long_accum_type_node);
5633 sat_short_accum_type_node);
5636 sat_long_accum_type_node);
5638 sat_long_long_accum_type_node);
5640 sat_unsigned_short_accum_type_node);
5642 sat_unsigned_accum_type_node);
5644 sat_unsigned_long_accum_type_node);
5646 sat_unsigned_long_long_accum_type_node);
5648 }
5651 TYPE_DECL,
5653 complex_integer_type_node));
5655 TYPE_DECL,
5657 complex_float_type_node));
5659 TYPE_DECL,
5661 complex_double_type_node));
5665 complex_long_double_type_node));
5668 /* For C++, make fileptr_type_node a distinct void * type until
5669 FILE type is defined. */
5674 /* Set the TYPE_NAME for any variants that were built before
5675 record_builtin_type gave names to the built-in types. */
5676 {
5682 }
5686 /* Make a type to be the domain of a few array types
5687 whose domains don't really matter.
5688 200 is small enough that it always fits in size_t
5689 and large enough that it can hold most function names for the
5690 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5693 /* Make a type for arrays of characters.
5694 With luck nothing will ever really depend on the length of this
5695 array type. */
5696 char_array_type_node
5700 const_string_type_node
5704 /* This is special for C++ so functions can be overloaded. */
5710 {
5713 else
5716 }
5718 /* This is for wide string constants. */
5719 wchar_array_type_node
5722 /* Define 'char16_t'. */
5727 {
5732 }
5734 /* This is for UTF-16 string constants. */
5735 char16_array_type_node
5738 /* Define 'char32_t'. */
5743 {
5748 }
5750 /* This is for UTF-32 string constants. */
5751 char32_array_type_node
5754 wint_type_node =
5757 intmax_type_node =
5759 uintmax_type_node =
5763 sig_atomic_type_node =
5766 int8_type_node =
5769 int16_type_node =
5772 int32_type_node =
5775 int64_type_node =
5778 uint8_type_node =
5790 int_least8_type_node =
5793 int_least16_type_node =
5796 int_least32_type_node =
5799 int_least64_type_node =
5802 uint_least8_type_node =
5805 uint_least16_type_node =
5808 uint_least32_type_node =
5811 uint_least64_type_node =
5814 int_fast8_type_node =
5817 int_fast16_type_node =
5820 int_fast32_type_node =
5823 int_fast64_type_node =
5826 uint_fast8_type_node =
5829 uint_fast16_type_node =
5832 uint_fast32_type_node =
5835 uint_fast64_type_node =
5838 intptr_type_node =
5841 uintptr_type_node =
5844 default_function_type
5846 ptrdiff_type_node
5853 va_list_type_node));
5855 {
5858 tree ptype;
5861 {
5865 ptype));
5867 }
5868 }
5871 {
5874 }
5875 else
5876 {
5879 }
5886 /* Create the built-in __null node. It is important that this is
5887 not shared. */
5891 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5893 }
5895 /* The number of named compound-literals generated thus far. */
5898 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5900 void
5902 {
5905 compound_literal_number);
5906 compound_literal_number++;
5908 }
5910 tree
5912 {
5913 /* In gimplify_va_arg_expr we take the address of the ap argument, mark it
5914 addressable now. */
5920 }
5923 /* Linked list of disabled built-in functions. */
5926 {
5934 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5935 begins with "__builtin_", give an error. */
5937 void
5939 {
5942 else
5943 {
5948 }
5949 }
5952 /* Return true if the built-in function NAME has been disabled, false
5953 otherwise. */
5955 static bool
5957 {
5960 {
5963 }
5965 }
5968 /* Worker for DEF_BUILTIN.
5969 Possibly define a builtin function with one or two names.
5970 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5971 nonansi_p and flag_no_nonansi_builtin. */
5973 static void
5980 {
5981 tree decl;
5994 fnattrs);
6003 }
6004 \f
6005 /* Nonzero if the type T promotes to int. This is (nearly) the
6006 integral promotions defined in ISO C99 6.3.1.1/2. */
6008 bool
6010 {
6012 {
6022 /* ??? Technically all enumerations not larger than an int
6023 promote to an int. But this is used along code paths
6024 that only want to notice a size change. */
6032 }
6033 }
6035 /* Return 1 if PARMS specifies a fixed number of parameters
6036 and none of their types is affected by default promotions. */
6038 int
6040 {
6041 const_tree t;
6043 {
6060 }
6062 }
6064 /* Recursively remove any '*' or '&' operator from TYPE. */
6065 tree
6067 {
6071 }
6073 /* Recursively remove pointer or array type from TYPE. */
6074 tree
6076 {
6080 }
6082 /* Used to compare case labels. K1 and K2 are actually tree nodes
6083 representing case labels, or NULL_TREE for a `default' label.
6084 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
6085 K2, and 0 if K1 and K2 are equal. */
6087 int
6089 {
6090 /* Consider a NULL key (such as arises with a `default' label) to be
6091 smaller than anything else. */
6098 }
6100 /* Process a case label, located at LOC, for the range LOW_VALUE
6101 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
6102 then this case label is actually a `default' label. If only
6103 HIGH_VALUE is NULL_TREE, then case label was declared using the
6104 usual C/C++ syntax, rather than the GNU case range extension.
6105 CASES is a tree containing all the case ranges processed so far;
6106 COND is the condition for the switch-statement itself. Returns the
6107 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
6108 is created. */
6110 tree
6113 {
6114 tree type;
6115 tree label;
6116 tree case_label;
6117 splay_tree_node node;
6119 /* Create the LABEL_DECL itself. */
6122 /* If there was an error processing the switch condition, bail now
6123 before we get more confused. */
6131 {
6134 }
6136 /* Case ranges are a GNU extension. */
6143 {
6148 }
6150 {
6155 }
6158 {
6159 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
6160 really a case range, even though it was written that way.
6161 Remove the HIGH_VALUE to simplify later processing. */
6166 }
6168 /* See if the case is in range of the type of the original testing
6169 expression. If both low_value and high_value are out of range,
6170 don't insert the case label and return NULL_TREE. */
6176 /* Look up the LOW_VALUE in the table of case labels we already
6177 have. */
6179 /* If there was not an exact match, check for overlapping ranges.
6180 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
6181 that's a `default' label and the only overlap is an exact match. */
6183 {
6184 splay_tree_node low_bound;
6185 splay_tree_node high_bound;
6187 /* Even though there wasn't an exact match, there might be an
6188 overlap between this case range and another case range.
6189 Since we've (inductively) not allowed any overlapping case
6190 ranges, we simply need to find the greatest low case label
6191 that is smaller that LOW_VALUE, and the smallest low case
6192 label that is greater than LOW_VALUE. If there is an overlap
6193 it will occur in one of these two ranges. */
6199 /* Check to see if the LOW_BOUND overlaps. It is smaller than
6200 the LOW_VALUE, so there is no need to check unless the
6201 LOW_BOUND is in fact itself a case range. */
6207 /* Check to see if the HIGH_BOUND overlaps. The low end of that
6208 range is bigger than the low end of the current range, so we
6209 are only interested if the current range is a real range, and
6210 not an ordinary case label. */
6212 && high_value
6214 high_value)
6217 }
6218 /* If there was an overlap, issue an error. */
6220 {
6224 {
6228 }
6230 {
6233 }
6234 else
6235 {
6239 }
6241 }
6243 /* Add a CASE_LABEL to the statement-tree. */
6245 /* Register this case label in the splay tree. */
6252 error_out:
6253 /* Add a label so that the back-end doesn't think that the beginning of
6254 the switch is unreachable. Note that we do not add a case label, as
6255 that just leads to duplicates and thence to failure later on. */
6257 {
6260 }
6262 }
6264 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
6265 Used to verify that case values match up with enumerator values. */
6267 static void
6269 {
6276 else
6283 buf);
6284 else
6289 }
6291 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
6292 Used to verify that case values match up with enumerator values. */
6294 static int
6296 {
6300 /* Skip default case. */
6304 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
6305 when we did our enum->case scan. Reset our scratch bit after. */
6308 else
6311 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
6312 not set, that means that CASE_HIGH did not appear when we did our
6313 enum->case scan. Reset our scratch bit after. */
6315 {
6318 else
6320 }
6323 }
6325 /* Handle -Wswitch*. Called from the front end after parsing the
6326 switch construct. */
6327 /* ??? Should probably be somewhere generic, since other languages
6328 besides C and C++ would want this. At the moment, however, C/C++
6329 are the only tree-ssa languages that support enumerations at all,
6330 so the point is moot. */
6332 void
6335 {
6336 splay_tree_node default_node;
6337 splay_tree_node node;
6338 tree chain;
6348 /* From here on, we only care about about enumerated types. */
6352 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
6356 /* Check the cases. Warn about case values which are not members of
6357 the enumerated type. For -Wswitch-enum, or for -Wswitch when
6358 there is no default case, check that exactly all enumeration
6359 literals are covered by the cases. */
6361 /* Clearing COND if it is not an integer constant simplifies
6362 the tests inside the loop below. */
6366 /* The time complexity here is O(N*lg(N)) worst case, but for the
6367 common case of monotonically increasing enumerators, it is
6368 O(N), since the nature of the splay tree will keep the next
6369 element adjacent to the root at all times. */
6372 {
6378 {
6379 /* Mark the CASE_LOW part of the case entry as seen. */
6383 }
6385 /* Even though there wasn't an exact match, there might be a
6386 case range which includes the enumerator's value. */
6389 {
6393 {
6394 /* If we match the upper bound exactly, mark the CASE_HIGH
6395 part of the case entry as seen. */
6399 }
6400 }
6402 /* We've now determined that this enumerated literal isn't
6403 handled by the case labels of the switch statement. */
6405 /* If the switch expression is a constant, we only really care
6406 about whether that constant is handled by the switch. */
6410 /* If there is a default_node, the only relevant option is
6411 Wswitch-enum. Otherwise, if both are enabled then we prefer
6412 to warn using -Wswitch because -Wswitch is enabled by -Wall
6413 while -Wswitch-enum is explicit. */
6416 ? OPT_Wswitch_enum
6420 }
6422 /* Warn if there are case expressions that don't correspond to
6423 enumerators. This can occur since C and C++ don't enforce
6424 type-checking of assignments to enumeration variables.
6426 The time complexity here is now always O(N) worst case, since
6427 we should have marked both the lower bound and upper bound of
6428 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
6429 above. This scan also resets those fields. */
6432 }
6434 /* Finish an expression taking the address of LABEL (an
6435 IDENTIFIER_NODE). Returns an expression for the address.
6437 LOC is the location for the expression returned. */
6439 tree
6441 {
6442 tree result;
6452 else
6453 {
6456 /* The current function is not necessarily uninlinable.
6457 Computed gotos are incompatible with inlining, but the value
6458 here could be used only in a diagnostic, for example. */
6460 }
6463 }
6464 \f
6466 /* Given a boolean expression ARG, return a tree representing an increment
6467 or decrement (as indicated by CODE) of ARG. The front end must check for
6468 invalid cases (e.g., decrement in C++). */
6469 tree
6471 {
6472 tree val;
6477 {
6500 }
6503 }
6504 \f
6505 /* Built-in macros for stddef.h and stdint.h, that require macros
6506 defined in this file. */
6507 void
6509 {
6572 }
6574 static void
6576 {
6577 /* Fill in the built_in_attributes array. */
6578 #define DEF_ATTR_NULL_TREE(ENUM) \
6579 built_in_attributes[(int) ENUM] = NULL_TREE;
6580 #define DEF_ATTR_INT(ENUM, VALUE) \
6581 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
6582 #define DEF_ATTR_STRING(ENUM, VALUE) \
6583 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
6584 #define DEF_ATTR_IDENT(ENUM, STRING) \
6585 built_in_attributes[(int) ENUM] = get_identifier (STRING);
6586 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
6587 built_in_attributes[(int) ENUM] \
6588 = tree_cons (built_in_attributes[(int) PURPOSE], \
6589 built_in_attributes[(int) VALUE], \
6590 built_in_attributes[(int) CHAIN]);
6592 #undef DEF_ATTR_NULL_TREE
6593 #undef DEF_ATTR_INT
6594 #undef DEF_ATTR_IDENT
6595 #undef DEF_ATTR_TREE_LIST
6596 }
6598 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
6599 identifier as an argument, so the front end shouldn't look it up. */
6601 bool
6603 {
6606 /* Unknown attribute that we'll end up ignoring, return true so we
6607 don't complain about an identifier argument. */
6613 else
6615 }
6617 /* Attribute handlers common to C front ends. */
6619 /* Handle a "packed" attribute; arguments as in
6620 struct attribute_spec.handler. */
6622 static tree
6625 {
6627 {
6631 }
6633 {
6635 /* Still pack bitfields. */
6640 else
6642 }
6643 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
6644 used for DECL_REGISTER. It wouldn't mean anything anyway.
6645 We can't set DECL_PACKED on the type of a TYPE_DECL, because
6646 that changes what the typedef is typing. */
6647 else
6648 {
6651 }
6654 }
6656 /* Handle a "nocommon" attribute; arguments as in
6657 struct attribute_spec.handler. */
6659 static tree
6663 {
6666 else
6667 {
6670 }
6673 }
6675 /* Handle a "common" attribute; arguments as in
6676 struct attribute_spec.handler. */
6678 static tree
6681 {
6684 else
6685 {
6688 }
6691 }
6693 /* Handle a "noreturn" attribute; arguments as in
6694 struct attribute_spec.handler. */
6696 static tree
6699 {
6702 /* See FIXME comment in c_common_attribute_table. */
6709 = (build_qualified_type
6710 (build_pointer_type
6714 else
6715 {
6718 }
6721 }
6723 /* Handle a "hot" and attribute; arguments as in
6724 struct attribute_spec.handler. */
6726 static tree
6729 {
6732 {
6734 {
6738 }
6739 /* Most of the rest of the hot processing is done later with
6740 lookup_attribute. */
6741 }
6742 else
6743 {
6746 }
6749 }
6751 /* Handle a "cold" and attribute; arguments as in
6752 struct attribute_spec.handler. */
6754 static tree
6757 {
6760 {
6762 {
6766 }
6767 /* Most of the rest of the cold processing is done later with
6768 lookup_attribute. */
6769 }
6770 else
6771 {
6774 }
6777 }
6779 /* Handle a "no_sanitize_address" attribute; arguments as in
6780 struct attribute_spec.handler. */
6782 static tree
6785 {
6787 {
6790 }
6793 }
6795 /* Handle a "no_address_safety_analysis" attribute; arguments as in
6796 struct attribute_spec.handler. */
6798 static tree
6801 {
6810 }
6812 /* Handle a "no_sanitize_undefined" attribute; arguments as in
6813 struct attribute_spec.handler. */
6815 static tree
6818 {
6820 {
6823 }
6826 }
6828 /* Handle a "stack_protect" attribute; arguments as in
6829 struct attribute_spec.handler. */
6830 static tree
6833 {
6835 {
6838 }
6839 else
6845 }
6847 /* Handle a "noinline" attribute; arguments as in
6848 struct attribute_spec.handler. */
6850 static tree
6854 {
6856 {
6858 {
6862 }
6863 else
6865 }
6866 else
6867 {
6870 }
6873 }
6875 /* Handle a "noclone" attribute; arguments as in
6876 struct attribute_spec.handler. */
6878 static tree
6882 {
6884 {
6887 }
6890 }
6892 /* Handle a "no_icf" attribute; arguments as in
6893 struct attribute_spec.handler. */
6895 static tree
6899 {
6901 {
6904 }
6907 }
6910 /* Handle a "always_inline" attribute; arguments as in
6911 struct attribute_spec.handler. */
6913 static tree
6918 {
6920 {
6922 {
6926 }
6927 else
6928 /* Set the attribute and mark it for disregarding inline
6929 limits. */
6931 }
6932 else
6933 {
6936 }
6939 }
6941 /* Handle a "gnu_inline" attribute; arguments as in
6942 struct attribute_spec.handler. */
6944 static tree
6949 {
6951 {
6952 /* Do nothing else, just set the attribute. We'll get at
6953 it later with lookup_attribute. */
6954 }
6955 else
6956 {
6959 }
6962 }
6964 /* Handle a "leaf" attribute; arguments as in
6965 struct attribute_spec.handler. */
6967 static tree
6971 {
6973 {
6976 }
6978 {
6981 }
6984 }
6986 /* Handle an "artificial" attribute; arguments as in
6987 struct attribute_spec.handler. */
6989 static tree
6994 {
6996 {
6997 /* Do nothing else, just set the attribute. We'll get at
6998 it later with lookup_attribute. */
6999 }
7000 else
7001 {
7004 }
7007 }
7009 /* Handle a "flatten" attribute; arguments as in
7010 struct attribute_spec.handler. */
7012 static tree
7014 tree args ATTRIBUTE_UNUSED,
7016 {
7018 /* Do nothing else, just set the attribute. We'll get at
7019 it later with lookup_attribute. */
7020 ;
7021 else
7022 {
7025 }
7028 }
7030 /* Handle a "warning" or "error" attribute; arguments as in
7031 struct attribute_spec.handler. */
7033 static tree
7036 {
7039 /* Do nothing else, just set the attribute. We'll get at
7040 it later with lookup_attribute. */
7041 ;
7042 else
7043 {
7046 }
7049 }
7051 /* Handle a "used" attribute; arguments as in
7052 struct attribute_spec.handler. */
7054 static tree
7057 {
7063 {
7068 }
7069 else
7070 {
7073 }
7076 }
7078 /* Handle a "unused" attribute; arguments as in
7079 struct attribute_spec.handler. */
7081 static tree
7084 {
7086 {
7094 {
7099 }
7100 else
7101 {
7104 }
7105 }
7106 else
7107 {
7111 }
7114 }
7116 /* Handle a "externally_visible" attribute; arguments as in
7117 struct attribute_spec.handler. */
7119 static tree
7124 {
7128 {
7131 {
7135 }
7136 }
7137 else
7138 {
7141 }
7144 }
7146 /* Handle the "no_reorder" attribute. Arguments as in
7147 struct attribute_spec.handler. */
7149 static tree
7151 tree name,
7152 tree,
7155 {
7160 {
7163 name);
7165 }
7168 }
7170 /* Handle a "const" attribute; arguments as in
7171 struct attribute_spec.handler. */
7173 static tree
7176 {
7179 /* See FIXME comment on noreturn in c_common_attribute_table. */
7185 = (build_qualified_type
7186 (build_pointer_type
7190 else
7191 {
7194 }
7197 }
7199 /* Handle a "transparent_union" attribute; arguments as in
7200 struct attribute_spec.handler. */
7202 static tree
7206 {
7207 tree type;
7218 {
7219 /* Make sure that the first field will work for a transparent union.
7220 If the type isn't complete yet, leave the check to the code in
7221 finish_struct. */
7223 {
7229 }
7232 {
7233 /* If the type isn't complete yet, setting the flag
7234 on a variant wouldn't ever be checked. */
7238 /* build_duplicate_type doesn't work for C++. */
7242 /* A type variant isn't good enough, since we don't a cast
7243 to such a type removed as a no-op. */
7245 }
7249 }
7251 ignored:
7254 }
7256 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
7257 get the requested priority for a constructor or destructor,
7258 possibly issuing diagnostics for invalid or reserved
7259 priorities. */
7261 static priority_type
7263 {
7264 HOST_WIDE_INT pri;
7265 tree arg;
7271 {
7274 else
7277 }
7294 {
7297 "destructor priorities from 0 to %d are reserved "
7299 MAX_RESERVED_INIT_PRIORITY);
7300 else
7302 "constructor priorities from 0 to %d are reserved "
7304 MAX_RESERVED_INIT_PRIORITY);
7305 }
7308 invalid:
7311 MAX_INIT_PRIORITY);
7312 else
7314 MAX_INIT_PRIORITY);
7316 }
7318 /* Handle a "constructor" attribute; arguments as in
7319 struct attribute_spec.handler. */
7321 static tree
7325 {
7332 {
7333 priority_type priority;
7338 }
7339 else
7340 {
7343 }
7346 }
7348 /* Handle a "destructor" attribute; arguments as in
7349 struct attribute_spec.handler. */
7351 static tree
7355 {
7362 {
7363 priority_type priority;
7368 }
7369 else
7370 {
7373 }
7376 }
7378 /* Nonzero if the mode is a valid vector mode for this architecture.
7379 This returns nonzero even if there is no hardware support for the
7380 vector mode, but we can emulate with narrower modes. */
7382 static int
7384 {
7386 machine_mode innermode;
7388 /* Doh! What's going on? */
7397 /* Hardware support. Woo hoo! */
7403 /* We should probably return 1 if requesting V4DI and we have no DI,
7404 but we have V2DI, but this is probably very unlikely. */
7406 /* If we have support for the inner mode, we can safely emulate it.
7407 We may not have V2DI, but me can emulate with a pair of DIs. */
7409 }
7412 /* Handle a "mode" attribute; arguments as in
7413 struct attribute_spec.handler. */
7415 static tree
7418 {
7426 else
7427 {
7432 tree typefm;
7437 {
7443 }
7445 /* Change this type to have a type with the specified mode.
7446 First check for the special modes. */
7459 else
7462 {
7465 }
7468 {
7471 }
7475 {
7507 }
7509 {
7512 }
7515 {
7520 {
7523 }
7527 else
7530 }
7531 else
7532 {
7533 /* For fixed-point modes, we need to test if the signness of type
7534 and the machine mode are consistent. */
7537 {
7540 }
7541 /* For fixed-point modes, we need to pass saturating info. */
7545 }
7548 {
7551 }
7553 {
7554 /* For enumeral types, copy the precision from the integer
7555 type returned above. If not an INTEGER_TYPE, we can't use
7556 this mode for this type. */
7558 {
7561 }
7564 {
7567 }
7568 else
7569 {
7570 /* We cannot build a type variant, as there's code that assumes
7571 that TYPE_MAIN_VARIANT has the same mode. This includes the
7572 debug generators. Instead, create a subrange type. This
7573 results in all of the enumeral values being emitted only once
7574 in the original, and the subtype gets them by reference. */
7577 else
7580 }
7581 }
7585 {
7588 }
7591 }
7594 }
7596 /* Handle a "section" attribute; arguments as in
7597 struct attribute_spec.handler. */
7599 static tree
7602 {
7606 {
7610 }
7615 {
7618 }
7621 {
7624 }
7629 {
7633 }
7635 /* The decl may have already been given a section attribute
7636 from a previous declaration. Ensure they match. */
7640 {
7643 }
7648 {
7651 }
7656 fail:
7659 }
7661 /* Check whether ALIGN is a valid user-specified alignment. If so,
7662 return its base-2 log; if not, output an error and return -1. If
7663 ALLOW_ZERO then 0 is valid and should result in a return of -1 with
7664 no error. */
7665 int
7667 {
7674 {
7677 }
7682 {
7685 }
7687 {
7690 }
7692 }
7694 /*
7695 If in c++-11, check if the c++-11 alignment constraint with respect
7696 to fundamental alignment (in [dcl.align]) are satisfied. If not in
7697 c++-11 mode, does nothing.
7699 [dcl.align]2/ says:
7701 [* if the constant expression evaluates to a fundamental alignment,
7702 the alignment requirement of the declared entity shall be the
7703 specified fundamental alignment.
7705 * if the constant expression evaluates to an extended alignment
7706 and the implementation supports that alignment in the context
7707 of the declaration, the alignment of the declared entity shall
7708 be that alignment
7710 * if the constant expression evaluates to an extended alignment
7711 and the implementation does not support that alignment in the
7712 context of the declaration, the program is ill-formed]. */
7714 static bool
7718 {
7731 {
7733 {
7734 /* For file scope variables and static members, the target
7735 supports alignments that are at most
7736 MAX_OFILE_ALIGNMENT. */
7739 }
7740 else
7741 {
7742 #ifdef BIGGEST_FIELD_ALIGNMENT
7743 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_FIELD_ALIGNMENT
7744 #else
7745 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_ALIGNMENT
7746 #endif
7747 /* For non-static members, the target supports either
7748 alignments that at most either BIGGEST_FIELD_ALIGNMENT
7749 if it is defined or BIGGEST_ALIGNMENT. */
7754 #undef MAX_TARGET_FIELD_ALIGNMENT
7755 /* For stack variables, the target supports at most
7756 MAX_STACK_ALIGNMENT. */
7760 }
7761 }
7763 {
7764 /* Let's be liberal for types. */
7767 }
7775 }
7777 /* Handle a "aligned" attribute; arguments as in
7778 struct attribute_spec.handler. */
7780 static tree
7783 {
7787 tree align_expr;
7791 {
7796 }
7797 else
7801 {
7805 }
7813 {
7816 /* If we have a TYPE_DECL, then copy the type, so that we
7817 don't accidentally modify a builtin type. See pushdecl. */
7820 {
7827 }
7828 else
7833 }
7836 {
7839 }
7842 /* C++-11 [dcl.align/4]:
7844 When multiple alignment-specifiers are specified for an
7845 entity, the alignment requirement shall be set to the
7846 strictest specified alignment.
7848 This formally comes from the c++11 specification but we are
7849 doing it for the GNU attribute syntax as well. */
7853 {
7858 else
7862 }
7863 else
7864 {
7867 }
7870 }
7872 /* Handle a "weak" attribute; arguments as in
7873 struct attribute_spec.handler. */
7875 static tree
7880 {
7883 {
7886 }
7888 {
7892 }
7895 {
7900 }
7901 else
7905 }
7907 /* Handle an "alias" or "ifunc" attribute; arguments as in
7908 struct attribute_spec.handler, except that IS_ALIAS tells us
7909 whether this is an alias as opposed to ifunc attribute. */
7911 static tree
7914 {
7919 {
7922 }
7926 /* A static variable declaration is always a tentative definition,
7927 but the alias is a non-tentative definition which overrides. */
7930 {
7934 }
7938 {
7942 }
7944 /* Note that the very first time we process a nested declaration,
7945 decl_function_context will not be set. Indeed, *would* never
7946 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
7947 we do below. After such frobbery, pushdecl would set the context.
7948 In any case, this is never what we want. */
7950 {
7951 tree id;
7955 {
7959 }
7961 /* This counts as a use of the object pointed to. */
7966 else
7970 /* ifuncs are also aliases, so set that attribute too. */
7973 }
7974 else
7975 {
7978 }
7981 {
7984 {
7987 else
7989 }
7990 }
7994 }
7996 /* Handle an "alias" or "ifunc" attribute; arguments as in
7997 struct attribute_spec.handler. */
7999 static tree
8002 {
8004 }
8006 /* Handle an "alias" or "ifunc" attribute; arguments as in
8007 struct attribute_spec.handler. */
8009 static tree
8012 {
8014 }
8016 /* Handle a "weakref" attribute; arguments as in struct
8017 attribute_spec.handler. */
8019 static tree
8022 {
8025 /* We must ignore the attribute when it is associated with
8026 local-scoped decls, since attribute alias is ignored and many
8027 such symbols do not even have a DECL_WEAK field. */
8029 || current_function_decl
8031 {
8035 }
8038 {
8042 }
8044 /* The idea here is that `weakref("name")' mutates into `weakref,
8045 alias("name")', and weakref without arguments, in turn,
8046 implicitly adds weak. */
8049 {
8056 }
8057 else
8058 {
8063 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
8064 and that isn't supported; and because it wants to add it to
8065 the list of weak decls, which isn't helpful. */
8067 }
8070 {
8074 }
8077 }
8079 /* Handle an "visibility" attribute; arguments as in
8080 struct attribute_spec.handler. */
8082 static tree
8086 {
8092 {
8096 {
8098 name);
8100 }
8102 {
8106 }
8107 }
8109 {
8112 }
8115 {
8118 }
8120 /* If this is a type, set the visibility on the type decl. */
8122 {
8127 {
8129 name);
8131 }
8132 }
8142 else
8143 {
8144 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
8146 }
8150 {
8164 }
8169 /* Go ahead and attach the attribute to the node as well. This is needed
8170 so we can determine whether we have VISIBILITY_DEFAULT because the
8171 visibility was not specified, or because it was explicitly overridden
8172 from the containing scope. */
8175 }
8177 /* Determine the ELF symbol visibility for DECL, which is either a
8178 variable or a function. It is an error to use this function if a
8179 definition of DECL is not available in this translation unit.
8180 Returns true if the final visibility has been determined by this
8181 function; false if the caller is free to make additional
8182 modifications. */
8184 bool
8186 {
8190 /* If the user explicitly specified the visibility with an
8191 attribute, honor that. DECL_VISIBILITY will have been set during
8192 the processing of the attribute. We check for an explicit
8193 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
8194 to distinguish the use of an attribute from the use of a "#pragma
8195 GCC visibility push(...)"; in the latter case we still want other
8196 considerations to be able to overrule the #pragma. */
8198 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
8203 /* Set default visibility to whatever the user supplied with
8204 visibility_specified depending on #pragma GCC visibility. */
8206 {
8209 {
8212 /* If visibility changed and DECL already has DECL_RTL, ensure
8213 symbol flags are updated. */
8218 }
8219 }
8221 }
8223 /* Handle an "tls_model" attribute; arguments as in
8224 struct attribute_spec.handler. */
8226 static tree
8229 {
8230 tree id;
8237 {
8240 }
8245 {
8248 }
8258 else
8259 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
8263 }
8265 /* Handle a "no_instrument_function" attribute; arguments as in
8266 struct attribute_spec.handler. */
8268 static tree
8273 {
8277 {
8281 }
8282 else
8286 }
8288 /* Handle a "malloc" attribute; arguments as in
8289 struct attribute_spec.handler. */
8291 static tree
8294 {
8298 else
8299 {
8302 }
8305 }
8307 /* Handle a "alloc_size" attribute; arguments as in
8308 struct attribute_spec.handler. */
8310 static tree
8313 {
8316 {
8323 || !arg_count
8325 {
8330 }
8331 }
8333 }
8335 /* Handle a "alloc_align" attribute; arguments as in
8336 struct attribute_spec.handler. */
8338 static tree
8341 {
8348 || !arg_count
8350 {
8355 }
8357 }
8359 /* Handle a "assume_aligned" attribute; arguments as in
8360 struct attribute_spec.handler. */
8362 static tree
8365 {
8367 {
8374 {
8379 }
8380 }
8382 }
8384 /* Handle a "fn spec" attribute; arguments as in
8385 struct attribute_spec.handler. */
8387 static tree
8391 {
8396 }
8398 /* Handle a "bnd_variable_size" attribute; arguments as in
8399 struct attribute_spec.handler. */
8401 static tree
8404 {
8406 {
8409 }
8412 }
8414 /* Handle a "bnd_legacy" attribute; arguments as in
8415 struct attribute_spec.handler. */
8417 static tree
8420 {
8422 {
8425 }
8428 }
8430 /* Handle a "bnd_instrument" attribute; arguments as in
8431 struct attribute_spec.handler. */
8433 static tree
8436 {
8438 {
8441 }
8444 }
8446 /* Handle a "warn_unused" attribute; arguments as in
8447 struct attribute_spec.handler. */
8449 static tree
8451 tree args ATTRIBUTE_UNUSED,
8453 {
8455 /* Do nothing else, just set the attribute. We'll get at
8456 it later with lookup_attribute. */
8457 ;
8458 else
8459 {
8462 }
8465 }
8467 /* Handle an "omp declare simd" attribute; arguments as in
8468 struct attribute_spec.handler. */
8470 static tree
8472 {
8474 }
8476 /* Handle an "omp declare target" attribute; arguments as in
8477 struct attribute_spec.handler. */
8479 static tree
8481 {
8483 }
8485 /* Handle a "returns_twice" attribute; arguments as in
8486 struct attribute_spec.handler. */
8488 static tree
8491 {
8494 else
8495 {
8498 }
8501 }
8503 /* Handle a "no_limit_stack" attribute; arguments as in
8504 struct attribute_spec.handler. */
8506 static tree
8511 {
8515 {
8519 }
8521 {
8525 }
8526 else
8530 }
8532 /* Handle a "pure" attribute; arguments as in
8533 struct attribute_spec.handler. */
8535 static tree
8538 {
8541 /* ??? TODO: Support types. */
8542 else
8543 {
8546 }
8549 }
8551 /* Digest an attribute list destined for a transactional memory statement.
8552 ALLOWED is the set of attributes that are allowed for this statement;
8553 return the attribute we parsed. Multiple attributes are never allowed. */
8555 int
8557 {
8562 {
8570 {
8573 }
8576 {
8579 }
8582 else
8584 }
8587 }
8589 /* Transform a TM attribute name into a maskable integer and back.
8590 Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
8591 to how the lack of an attribute is treated. */
8593 int
8595 {
8609 }
8611 tree
8613 {
8616 {
8634 }
8636 }
8638 /* Return the first TM attribute seen in LIST. */
8640 tree
8642 {
8644 {
8648 }
8650 }
8652 /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
8653 Here we accept only function types, and verify that none of the other
8654 function TM attributes are also applied. */
8655 /* ??? We need to accept class types for C++, but not C. This greatly
8656 complicates this function, since we can no longer rely on the extra
8657 processing given by function_type_required. */
8659 static tree
8662 {
8663 /* Only one path adds the attribute; others don't. */
8667 {
8670 /* Only tm_callable and tm_safe apply to classes. */
8673 /* FALLTHRU */
8677 {
8680 ;
8683 else
8685 }
8689 {
8692 {
8697 }
8698 }
8699 /* FALLTHRU */
8702 /* If a function is next, pass it on to be tried next. */
8706 ignored:
8709 }
8712 }
8714 /* Handle the TM_WRAP attribute; arguments as in
8715 struct attribute_spec.handler. */
8717 static tree
8720 {
8723 /* We don't need the attribute even on success, since we
8724 record the entry in an external table. */
8729 else
8730 {
8733 ;
8738 else
8739 {
8743 {
8747 else
8749 }
8750 else
8752 }
8753 }
8756 }
8758 /* Ignore the given attribute. Used when this attribute may be usefully
8759 overridden by the target, but is not used generically. */
8761 static tree
8765 {
8768 }
8770 /* Handle a "no vops" attribute; arguments as in
8771 struct attribute_spec.handler. */
8773 static tree
8777 {
8781 }
8783 /* Handle a "deprecated" attribute; arguments as in
8784 struct attribute_spec.handler. */
8786 static tree
8790 {
8798 {
8801 }
8804 {
8815 else
8817 }
8819 {
8824 }
8825 else
8829 {
8832 {
8838 }
8841 else
8843 }
8846 }
8848 /* Handle a "vector_size" attribute; arguments as in
8849 struct attribute_spec.handler. */
8851 static tree
8855 {
8857 machine_mode orig_mode;
8868 {
8871 }
8873 /* Get the vector size (in bytes). */
8876 /* We need to provide for vector pointers, vector arrays, and
8877 functions returning vectors. For example:
8879 __attribute__((vector_size(16))) short *foo;
8881 In this case, the mode is SI, but the type being modified is
8882 HI, so we need to look further. */
8891 /* Get the mode of the type being modified. */
8902 {
8905 }
8908 {
8911 }
8914 {
8917 }
8919 /* Calculate how many units fit in the vector. */
8922 {
8925 }
8929 /* Build back pointers if needed. */
8933 }
8935 /* Handle the "nonnull" attribute. */
8936 static tree
8940 {
8944 /* If no arguments are specified, all pointer arguments should be
8945 non-null. Verify a full prototype is given so that the arguments
8946 will have the correct types when we actually check them later. */
8948 {
8950 {
8953 }
8955 }
8957 /* Argument list specified. Verify that each argument number references
8958 a pointer argument. */
8960 {
8969 {
8974 }
8977 {
8978 function_args_iterator iter;
8979 tree argument;
8983 {
8987 }
8991 {
8996 }
8999 {
9004 }
9005 }
9006 }
9009 }
9011 /* Check the argument list of a function call for null in argument slots
9012 that are marked as requiring a non-null pointer argument. The NARGS
9013 arguments are passed in the array ARGARRAY.
9014 */
9016 static void
9018 {
9019 tree a;
9027 /* See if any of the nonnull attributes has no arguments. If so,
9028 then every pointer argument is checked (in which case the check
9029 for pointer type is done in check_nonnull_arg). */
9031 do
9039 else
9040 {
9041 /* Walk the argument list. If we encounter an argument number we
9042 should check for non-null, do it. */
9044 {
9046 {
9050 }
9055 }
9056 }
9057 }
9059 /* Check that the Nth argument of a function call (counting backwards
9060 from the end) is a (pointer)0. The NARGS arguments are passed in the
9061 array ARGARRAY. */
9063 static void
9065 {
9069 {
9072 tree sentinel;
9073 function_args_iterator iter;
9074 tree t;
9076 /* Skip over the named arguments. */
9078 {
9081 len++;
9082 }
9085 {
9088 }
9090 /* The sentinel must be one of the varargs, i.e.
9091 in position >= the number of fixed arguments. */
9093 {
9097 }
9099 /* Validate the sentinel. */
9103 /* Although __null (in C++) is only an integer we allow it
9104 nevertheless, as we are guaranteed that it's exactly
9105 as wide as a pointer, and we don't want to force
9106 users to cast the NULL they have written there.
9107 We warn with -Wstrict-null-sentinel, though. */
9110 }
9111 }
9113 /* Helper for check_function_nonnull; given a list of operands which
9114 must be non-null in ARGS, determine if operand PARAM_NUM should be
9115 checked. */
9117 static bool
9119 {
9123 {
9130 }
9132 }
9134 /* Check that the function argument PARAM (which is operand number
9135 PARAM_NUM) is non-null. This is called by check_function_nonnull
9136 via check_function_arguments_recurse. */
9138 static void
9141 {
9142 /* Just skip checking the argument if it's not a pointer. This can
9143 happen if the "nonnull" attribute was given without an operand
9144 list (which means to check every pointer argument). */
9152 }
9154 /* Helper for nonnull attribute handling; fetch the operand number
9155 from the attribute argument list. */
9157 static bool
9159 {
9160 /* Verify the arg number is a small constant. */
9162 {
9165 }
9166 else
9168 }
9170 /* Handle a "nothrow" attribute; arguments as in
9171 struct attribute_spec.handler. */
9173 static tree
9176 {
9179 /* ??? TODO: Support types. */
9180 else
9181 {
9184 }
9187 }
9189 /* Handle a "cleanup" attribute; arguments as in
9190 struct attribute_spec.handler. */
9192 static tree
9195 {
9199 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
9200 for global destructors in C++. This requires infrastructure that
9201 we don't have generically at the moment. It's also not a feature
9202 we'd be missing too much, since we do have attribute constructor. */
9204 {
9208 }
9210 /* Verify that the argument is a function in scope. */
9211 /* ??? We could support pointers to functions here as well, if
9212 that was considered desirable. */
9215 {
9219 }
9222 {
9226 }
9228 /* That the function has proper type is checked with the
9229 eventual call to build_function_call. */
9232 }
9234 /* Handle a "warn_unused_result" attribute. No special handling. */
9236 static tree
9240 {
9241 /* Ignore the attribute for functions not returning any value. */
9243 {
9246 }
9249 }
9251 /* Handle a "sentinel" attribute. */
9253 static tree
9256 {
9258 {
9262 }
9263 else
9264 {
9266 {
9270 }
9271 }
9274 {
9282 {
9286 }
9287 else
9288 {
9290 {
9294 }
9295 }
9296 }
9299 }
9301 /* Handle a "type_generic" attribute. */
9303 static tree
9307 {
9308 /* Ensure we have a function type. */
9311 /* Ensure we have a variadic function. */
9315 }
9317 /* Handle a "target" attribute. */
9319 static tree
9322 {
9323 /* Ensure we have a function type. */
9325 {
9328 }
9330 flags))
9334 }
9336 /* Arguments being collected for optimization. */
9341 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
9342 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
9343 false for #pragma GCC optimize. */
9345 bool
9347 {
9355 tree ap;
9357 /* Build up argv vector. Just in case the string is stored away, use garbage
9358 collected strings. */
9363 {
9367 {
9371 }
9374 {
9375 /* Split string into multiple substrings. */
9383 {
9390 {
9394 }
9395 else
9396 {
9399 }
9403 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
9404 options. */
9406 {
9411 else
9415 }
9418 {
9421 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
9422 itself is -Os, and any other switch begins with a -f. */
9428 }
9433 }
9435 }
9436 }
9446 /* Now parse the options. */
9456 /* Don't allow changing -fstrict-aliasing. */
9461 }
9463 /* For handling "optimize" attribute. arguments as in
9464 struct attribute_spec.handler. */
9466 static tree
9469 {
9470 /* Ensure we have a function type. */
9472 {
9475 }
9476 else
9477 {
9481 /* Save current options. */
9484 /* If we previously had some optimization options, use them as the
9485 default. */
9490 /* Parse options, and update the vector. */
9495 /* Restore current options. */
9497 }
9500 }
9502 /* Handle a "no_split_stack" attribute. */
9504 static tree
9509 {
9513 {
9517 }
9519 {
9523 }
9526 }
9528 /* Handle a "returns_nonnull" attribute; arguments as in
9529 struct attribute_spec.handler. */
9531 static tree
9534 {
9535 // Even without a prototype we still have a return type we can check.
9537 {
9540 }
9542 }
9544 /* Handle a "designated_init" attribute; arguments as in
9545 struct attribute_spec.handler. */
9547 static tree
9550 {
9552 {
9555 }
9557 }
9559 \f
9560 /* Check for valid arguments being passed to a function with FNTYPE.
9561 There are NARGS arguments in the array ARGARRAY. */
9562 void
9564 {
9565 /* Check for null being passed in a pointer argument that must be
9566 non-null. We also need to do this if format checking is enabled. */
9571 /* Check for errors in format strings. */
9578 }
9580 /* Generic argument checking recursion routine. PARAM is the argument to
9581 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
9582 once the argument is resolved. CTX is context for the callback. */
9583 void
9588 {
9592 {
9593 /* Strip coercion. */
9597 }
9600 {
9602 tree attrs;
9605 /* See if this is a call to a known internationalization function
9606 that modifies a format arg. Such a function may have multiple
9607 format_arg attributes (for example, ngettext). */
9610 attrs;
9613 {
9614 tree inner_arg;
9615 tree format_num_expr;
9618 call_expr_arg_iterator iter;
9620 /* Extract the argument number, which was previously checked
9621 to be valid. */
9630 {
9635 }
9636 }
9638 /* If we found a format_arg attribute and did a recursive check,
9639 we are done with checking this argument. Otherwise, we continue
9640 and this will be considered a non-literal. */
9643 }
9646 {
9647 /* Check both halves of the conditional expression. */
9653 }
9656 }
9658 /* Checks for a builtin function FNDECL that the number of arguments
9659 NARGS against the required number REQUIRED and issues an error if
9660 there is a mismatch. Returns true if the number of arguments is
9661 correct, otherwise false. */
9663 static bool
9665 {
9667 {
9671 }
9673 {
9677 }
9679 }
9681 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
9682 Returns false if there was an error, otherwise true. */
9684 bool
9686 {
9692 {
9702 {
9704 {
9708 }
9710 }
9720 {
9727 {
9731 }
9733 }
9738 {
9743 {
9747 }
9750 {
9752 fndecl);
9754 }
9756 }
9761 {
9763 {
9766 }
9768 }
9775 {
9779 {
9783 }
9786 {
9790 }
9792 }
9797 }
9798 }
9800 /* Function to help qsort sort FIELD_DECLs by name order. */
9802 int
9804 {
9809 /* A nontype is "greater" than a type. */
9818 }
9821 gt_pointer_operator new_value;
9825 /* This routine compares two fields like field_decl_cmp but using the
9826 pointer operator in resort_data. */
9828 static int
9830 {
9835 /* A nontype is "greater" than a type. */
9841 {
9848 }
9850 }
9852 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
9854 void
9857 gt_pointer_operator new_value,
9859 {
9864 resort_field_decl_cmp);
9865 }
9867 /* Subroutine of c_parse_error.
9868 Return the result of concatenating LHS and RHS. RHS is really
9869 a string literal, its first character is indicated by RHS_START and
9870 RHS_SIZE is its length (including the terminating NUL character).
9872 The caller is responsible for deleting the returned pointer. */
9876 {
9882 }
9884 /* Issue the error given by GMSGID, indicating that it occurred before
9885 TOKEN, which had the associated VALUE. */
9887 void
9890 {
9891 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
9901 {
9906 {
9919 }
9923 else
9929 }
9951 {
9956 }
9964 {
9969 }
9970 else
9974 {
9977 }
9978 #undef catenate_messages
9979 }
9981 /* Return the gcc option code associated with the reason for a cpp
9982 message, or 0 if none. */
9984 static int
9986 {
9990 {
9993 }
9995 }
9997 /* Callback from cpp_error for PFILE to print diagnostics from the
9998 preprocessor. The diagnostic is of type LEVEL, with REASON set
9999 to the reason code if LEVEL is represents a warning, at location
10000 LOCATION unless this is after lexing and the compiler's location
10001 should be used instead, with column number possibly overridden by
10002 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
10003 the arguments. Returns true if a diagnostic was emitted, false
10004 otherwise. */
10006 bool
10010 {
10011 diagnostic_info diagnostic;
10012 diagnostic_t dlevel;
10017 {
10022 /* Fall through. */
10047 }
10060 }
10062 /* Convert a character from the host to the target execution character
10063 set. cpplib handles this, mostly. */
10065 HOST_WIDE_INT
10067 {
10068 /* Character constants in GCC proper are sign-extended under -fsigned-char,
10069 zero-extended under -fno-signed-char. cpplib insists that characters
10070 and character constants are always unsigned. Hence we must convert
10071 back and forth. */
10079 else
10081 }
10083 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
10084 references with an INDIRECT_REF of a constant at the bottom; much like the
10085 traditional rendering of offsetof as a macro. Return the folded result. */
10087 tree
10089 {
10093 {
10109 {
10112 }
10122 {
10126 }
10139 /* Check if the offset goes beyond the upper bound of the array. */
10141 {
10147 {
10151 {
10152 tree v;
10159 {
10167 }
10168 /* Don't warn if the array might be considered a poor
10169 man's flexible array member with a very permissive
10170 definition thereof. */
10174 "index %E denotes an offset "
10177 }
10178 }
10179 }
10186 /* Handle static members of volatile structs. */
10193 }
10196 }
10198 /* Likewise, but convert it to the return type of offsetof. */
10200 tree
10202 {
10204 }
10206 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
10207 expression, because B will always be true. */
10209 void
10211 {
10214 "the omitted middle operand in ?: will always be %<true%>, "
10216 }
10218 /* Give an error for storing into ARG, which is 'const'. USE indicates
10219 how ARG was being used. */
10221 void
10223 {
10226 /* Using this macro rather than (for example) arrays of messages
10227 ensures that all the format strings are checked at compile
10228 time. */
10229 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
10230 : (use == lv_increment ? (I) \
10231 : (use == lv_decrement ? (D) : (AS))))
10233 {
10244 else
10250 }
10256 arg);
10262 arg);
10264 {
10274 arg);
10275 }
10281 arg);
10282 else
10287 arg);
10288 }
10290 /* Print an error message for an invalid lvalue. USE says
10291 how the lvalue is being used and so selects the error message. LOC
10292 is the location for the error. */
10294 void
10296 {
10298 {
10316 }
10317 }
10319 /* Print an error message for an invalid indirection of type TYPE.
10320 ERRSTRING is the name of the operator for the indirection. */
10322 void
10324 {
10326 {
10334 type);
10339 type);
10344 type);
10349 type);
10354 type);
10358 }
10359 }
10360 \f
10361 /* *PTYPE is an incomplete array. Complete it with a domain based on
10362 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
10363 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10364 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
10366 int
10368 {
10376 {
10378 {
10379 int eltsize
10382 }
10384 {
10388 {
10392 }
10393 else
10394 {
10395 tree curindex;
10406 {
10410 else
10411 {
10413 {
10414 /* Since we treat size types now as ordinary
10415 unsigned types, we need an explicit overflow
10416 check. */
10420 }
10422 size_one_node);
10423 }
10426 }
10428 {
10432 }
10433 }
10434 }
10435 else
10436 {
10437 /* Make an error message unless that happened already. */
10440 }
10441 }
10442 else
10443 {
10447 }
10454 else
10457 /* Using build_distinct_type_copy and modifying things afterward instead
10458 of using build_array_type to create a new type preserves all of the
10459 TYPE_LANG_FLAG_? bits that the front end may have set. */
10467 /* Make sure we have the canonical MAIN_TYPE. */
10470 hashcode);
10473 /* Fix the canonical type. */
10483 else
10488 else
10494 {
10496 /* If we proceed with the array type as it is, we'll eventually
10497 crash in tree_to_[su]hwi(). */
10499 }
10503 }
10505 /* Like c_mark_addressable but don't check register qualifier. */
10506 void
10508 {
10514 }
10517 \f
10518 /* Used to help initialize the builtin-types.def table. When a type of
10519 the correct size doesn't exist, use error_mark_node instead of NULL.
10520 The later results in segfaults even when a decl using the type doesn't
10521 get invoked. */
10523 tree
10525 {
10528 }
10530 /* A helper function for resolve_overloaded_builtin in resolving the
10531 overloaded __sync_ builtins. Returns a positive power of 2 if the
10532 first operand of PARAMS is a pointer to a supported data type.
10533 Returns 0 if an error is encountered. */
10535 static int
10537 {
10538 tree type;
10542 {
10545 }
10549 {
10550 /* Force array-to-pointer decay for C++. */
10554 }
10566 incompatible:
10569 }
10571 /* A helper function for resolve_overloaded_builtin. Adds casts to
10572 PARAMS to make arguments match up with those of FUNCTION. Drops
10573 the variadic arguments at the end. Returns false if some error
10574 was encountered; true on success. */
10576 static bool
10579 {
10580 function_args_iterator iter;
10581 tree ptype;
10585 /* We've declared the implementation functions to use "volatile void *"
10586 as the pointer parameter, so we shouldn't get any complaints from the
10587 call to check_function_arguments what ever type the user used. */
10592 /* For the rest of the values, we need to cast these to FTYPE, so that we
10593 don't get warnings for passing pointer types, etc. */
10596 {
10600 /* XXX void_type_node belies the abstraction. */
10606 {
10609 }
10611 /* Only convert parameters if arg_type is unsigned integer type with
10612 new format sync routines, i.e. don't attempt to convert pointer
10613 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
10614 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
10615 kinds). */
10617 {
10618 /* Ideally for the first conversion we'd use convert_for_assignment
10619 so that we get warnings for anything that doesn't match the pointer
10620 type. This isn't portable across the C and C++ front ends atm. */
10625 }
10628 }
10630 /* __atomic routines are not variadic. */
10632 {
10635 }
10637 /* The definition of these primitives is variadic, with the remaining
10638 being "an optional list of variables protected by the memory barrier".
10639 No clue what that's supposed to mean, precisely, but we consider all
10640 call-clobbered variables to be protected so we're safe. */
10644 }
10646 /* A helper function for resolve_overloaded_builtin. Adds a cast to
10647 RESULT to make it match the type of the first pointer argument in
10648 PARAMS. */
10650 static tree
10652 {
10657 /* New format doesn't require casting unless the types are the same size. */
10660 else
10662 }
10664 /* This function verifies the PARAMS to generic atomic FUNCTION.
10665 It returns the size if all the parameters are the same size, otherwise
10666 0 is returned if the parameters are invalid. */
10668 static int
10671 {
10676 tree type_0;
10678 /* Determine the parameter makeup. */
10680 {
10696 }
10699 {
10702 }
10704 /* Get type of first parameter, and determine its size. */
10707 {
10708 /* Force array-to-pointer decay for C++. */
10712 }
10714 {
10716 function);
10718 }
10720 /* Types must be compile time constant sizes. */
10722 {
10725 function);
10727 }
10731 /* Zero size objects are not allowed. */
10733 {
10736 function);
10738 }
10740 /* Check each other parameter is a pointer and the same size. */
10742 {
10745 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
10749 {
10751 function);
10753 }
10757 {
10759 function);
10761 }
10762 }
10764 /* Check memory model parameters for validity. */
10766 {
10769 {
10772 {
10775 function);
10776 }
10777 }
10778 else
10780 {
10782 function);
10784 }
10785 }
10788 }
10791 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
10792 at the beginning of the parameter list PARAMS representing the size of the
10793 objects. This is to match the library ABI requirement. LOC is the location
10794 of the function call.
10795 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
10796 returned to allow the external call to be constructed. */
10798 static tree
10801 {
10802 tree size_node;
10804 /* Insert a SIZE_T parameter as the first param. If there isn't
10805 enough space, allocate a new vector and recursively re-build with that. */
10807 {
10810 tree f;
10820 }
10822 /* Add the size parameter and leave as a function call for processing. */
10826 }
10829 /* Return whether atomic operations for naturally aligned N-byte
10830 arguments are supported, whether inline or through libatomic. */
10831 static bool
10833 {
10835 {
10847 }
10848 }
10850 /* This will process an __atomic_exchange function call, determine whether it
10851 needs to be mapped to the _N variation, or turned into a library call.
10852 LOC is the location of the builtin call.
10853 FUNCTION is the DECL that has been invoked;
10854 PARAMS is the argument list for the call. The return value is non-null
10855 TRUE is returned if it is translated into the proper format for a call to the
10856 external library, and NEW_RETURN is set the tree for that function.
10857 FALSE is returned if processing for the _N variation is required, and
10858 NEW_RETURN is set to the the return value the result is copied into. */
10859 static bool
10862 {
10867 /* Size of 0 is an error condition. */
10869 {
10872 }
10874 /* If not a lock-free size, change to the library generic format. */
10876 {
10879 }
10881 /* Otherwise there is a lockfree match, transform the call from:
10882 void fn(T* mem, T* desired, T* return, model)
10883 into
10884 *return = (T) (fn (In* mem, (In) *desired, model)) */
10891 /* Create pointer to appropriate size. */
10895 /* Convert object pointer to required type. */
10898 /* Convert new value to required type, and dereference it. */
10903 /* Move memory model to the 3rd position, and end param list. */
10907 /* Convert return pointer and dereference it for later assignment. */
10911 }
10914 /* This will process an __atomic_compare_exchange function call, determine
10915 whether it needs to be mapped to the _N variation, or turned into a lib call.
10916 LOC is the location of the builtin call.
10917 FUNCTION is the DECL that has been invoked;
10918 PARAMS is the argument list for the call. The return value is non-null
10919 TRUE is returned if it is translated into the proper format for a call to the
10920 external library, and NEW_RETURN is set the tree for that function.
10921 FALSE is returned if processing for the _N variation is required. */
10923 static bool
10927 {
10932 /* Size of 0 is an error condition. */
10934 {
10937 }
10939 /* If not a lock-free size, change to the library generic format. */
10941 {
10942 /* The library generic format does not have the weak parameter, so
10943 remove it from the param list. Since a parameter has been removed,
10944 we can be sure that there is room for the SIZE_T parameter, meaning
10945 there will not be a recursive rebuilding of the parameter list, so
10946 there is no danger this will be done twice. */
10948 {
10952 }
10955 }
10957 /* Otherwise, there is a match, so the call needs to be transformed from:
10958 bool fn(T* mem, T* desired, T* return, weak, success, failure)
10959 into
10960 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
10966 /* Create pointer to appropriate size. */
10970 /* Convert object pointer to required type. */
10974 /* Convert expected pointer to required type. */
10978 /* Convert desired value to required type, and dereference it. */
10983 /* The rest of the parameters are fine. NULL means no special return value
10984 processing.*/
10987 }
10990 /* This will process an __atomic_load function call, determine whether it
10991 needs to be mapped to the _N variation, or turned into a library call.
10992 LOC is the location of the builtin call.
10993 FUNCTION is the DECL that has been invoked;
10994 PARAMS is the argument list for the call. The return value is non-null
10995 TRUE is returned if it is translated into the proper format for a call to the
10996 external library, and NEW_RETURN is set the tree for that function.
10997 FALSE is returned if processing for the _N variation is required, and
10998 NEW_RETURN is set to the the return value the result is copied into. */
11000 static bool
11003 {
11008 /* Size of 0 is an error condition. */
11010 {
11013 }
11015 /* If not a lock-free size, change to the library generic format. */
11017 {
11020 }
11022 /* Otherwise, there is a match, so the call needs to be transformed from:
11023 void fn(T* mem, T* return, model)
11024 into
11025 *return = (T) (fn ((In *) mem, model)) */
11031 /* Create pointer to appropriate size. */
11035 /* Convert object pointer to required type. */
11039 /* Move memory model to the 2nd position, and end param list. */
11043 /* Convert return pointer and dereference it for later assignment. */
11047 }
11050 /* This will process an __atomic_store function call, determine whether it
11051 needs to be mapped to the _N variation, or turned into a library call.
11052 LOC is the location of the builtin call.
11053 FUNCTION is the DECL that has been invoked;
11054 PARAMS is the argument list for the call. The return value is non-null
11055 TRUE is returned if it is translated into the proper format for a call to the
11056 external library, and NEW_RETURN is set the tree for that function.
11057 FALSE is returned if processing for the _N variation is required, and
11058 NEW_RETURN is set to the the return value the result is copied into. */
11060 static bool
11063 {
11068 /* Size of 0 is an error condition. */
11070 {
11073 }
11075 /* If not a lock-free size, change to the library generic format. */
11077 {
11080 }
11082 /* Otherwise, there is a match, so the call needs to be transformed from:
11083 void fn(T* mem, T* value, model)
11084 into
11085 fn ((In *) mem, (In) *value, model) */
11090 /* Create pointer to appropriate size. */
11094 /* Convert object pointer to required type. */
11098 /* Convert new value to required type, and dereference it. */
11103 /* The memory model is in the right spot already. Return is void. */
11107 }
11110 /* Some builtin functions are placeholders for other expressions. This
11111 function should be called immediately after parsing the call expression
11112 before surrounding code has committed to the type of the expression.
11114 LOC is the location of the builtin call.
11116 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
11117 PARAMS is the argument list for the call. The return value is non-null
11118 when expansion is complete, and null if normal processing should
11119 continue. */
11121 tree
11124 {
11130 {
11136 else
11140 }
11142 /* Handle BUILT_IN_NORMAL here. */
11144 {
11149 {
11150 /* Handle these 4 together so that they can fall through to the next
11151 case if the call is transformed to an _N variant. */
11153 {
11155 {
11159 /* Change to the _N variant. */
11162 }
11165 {
11167 params,
11170 /* Change to the _N variant. */
11173 }
11175 {
11179 /* Change to the _N variant. */
11182 }
11184 {
11188 /* Change to the _N variant. */
11191 }
11194 }
11195 /* Fallthrough to the normal processing. */
11196 }
11213 {
11215 /* Fallthru for parameter processing. */
11216 }
11233 {
11244 orig_format))
11249 NULL);
11257 /* If new_return is set, assign function to that expr and cast the
11258 result to void since the generic interface returned void. */
11260 {
11261 /* Cast function result from I{1,2,4,8,16} to the required type. */
11264 result);
11268 }
11270 }
11274 }
11275 }
11277 /* vector_types_compatible_elements_p is used in type checks of vectors
11278 values used as operands of binary operators. Where it returns true, and
11279 the other checks of the caller succeed (being vector types in he first
11280 place, and matching number of elements), we can just treat the types
11281 as essentially the same.
11282 Contrast with vector_targets_convertible_p, which is used for vector
11283 pointer types, and vector_types_convertible_p, which will allow
11284 language-specific matches under the control of flag_lax_vector_conversions,
11285 and might still require a conversion. */
11286 /* True if vector types T1 and T2 can be inputs to the same binary
11287 operator without conversion.
11288 We don't check the overall vector size here because some of our callers
11289 want to give different error messages when the vectors are compatible
11290 except for the element count. */
11292 bool
11294 {
11307 /* Equality works here because c_common_signed_type uses
11308 TYPE_MAIN_VARIANT. */
11316 }
11318 /* Check for missing format attributes on function pointers. LTYPE is
11319 the new type or left-hand side type. RTYPE is the old type or
11320 right-hand side type. Returns TRUE if LTYPE is missing the desired
11321 attribute. */
11323 bool
11325 {
11327 tree ra;
11333 {
11334 tree la;
11339 }
11340 else
11342 }
11344 /* Subscripting with type char is likely to lose on a machine where
11345 chars are signed. So warn on any machine, but optionally. Don't
11346 warn for unsigned char since that type is safe. Don't warn for
11347 signed char because anyone who uses that must have done so
11348 deliberately. Furthermore, we reduce the false positive load by
11349 warning only for non-constant value of type char. */
11351 void
11353 {
11358 }
11360 /* Implement -Wparentheses for the unexpected C precedence rules, to
11361 cover cases like x + y << z which readers are likely to
11362 misinterpret. We have seen an expression in which CODE is a binary
11363 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
11364 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
11365 CODE_RIGHT may be ERROR_MARK, which means that that side of the
11366 expression was not formed using a binary or unary operator, or it
11367 was enclosed in parentheses. */
11369 void
11373 {
11377 /* This macro tests that the expression ARG with original tree code
11378 CODE appears to be a boolean expression. or the result of folding a
11379 boolean expression. */
11380 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
11381 (truth_value_p (TREE_CODE (ARG)) \
11382 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
11384 || ((CODE) != INTEGER_CST \
11385 && (integer_onep (ARG) || integer_zerop (ARG))))
11388 {
11437 /* Check cases like x|y==z */
11444 /* Check cases like !x | y */
11448 "suggest parentheses around operand of "
11461 /* Check cases like x^y==z */
11483 /* Check cases like x&y==z */
11490 /* Check cases like !x & y */
11494 "suggest parentheses around operand of "
11517 {
11522 "comparisons like %<X<=Y<=Z%> do not "
11528 "comparisons like %<X<=Y<=Z%> do not "
11530 }
11532 }
11533 #undef NOT_A_BOOLEAN_EXPR_P
11534 }
11536 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
11538 void
11540 {
11542 {
11545 else
11547 }
11548 }
11550 /* Warn for division by zero according to the value of DIVISOR. LOC
11551 is the location of the division operator. */
11553 void
11555 {
11556 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
11557 about division by zero. Do not issue a warning if DIVISOR has a
11558 floating-point type, since we consider 0.0/0.0 a valid way of
11559 generating a NaN. */
11563 }
11565 /* Subroutine of build_binary_op. Give warnings for comparisons
11566 between signed and unsigned quantities that may fail. Do the
11567 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
11568 so that casts will be considered, but default promotions won't
11569 be.
11571 LOCATION is the location of the comparison operator.
11573 The arguments of this function map directly to local variables
11574 of build_binary_op. */
11576 void
11581 {
11586 /* In C++, check for comparison of different enum types. */
11592 {
11596 }
11598 /* Do not warn if the comparison is being done in a signed type,
11599 since the signed type will only be chosen if it can represent
11600 all the values of the unsigned type. */
11603 /* Do not warn if both operands are unsigned. */
11606 else
11607 {
11613 else
11621 /* Do not warn if the signed quantity is an unsuffixed integer
11622 literal (or some static constant expression involving such
11623 literals or a conditional expression involving such literals)
11624 and it is non-negative. */
11627 /* Do not warn if the comparison is an equality operation, the
11628 unsigned quantity is an integral constant, and it would fit
11629 in the result if the result were signed. */
11634 /* In C, do not warn if the unsigned quantity is an enumeration
11635 constant and its maximum value would fit in the result if the
11636 result were signed. */
11642 else
11644 OPT_Wsign_compare,
11646 }
11648 /* Warn if two unsigned values are being compared in a size larger
11649 than their original size, and one (and only one) is the result of
11650 a `~' operator. This comparison will always fail.
11652 Also warn if one operand is a constant, and the constant does not
11653 have all bits set that are set in the ~ operand when it is
11654 extended. */
11661 {
11668 {
11669 tree primop;
11675 {
11679 }
11680 else
11681 {
11685 }
11690 {
11693 {
11697 else
11700 }
11701 }
11702 }
11710 }
11711 }
11713 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
11714 type via c_common_type. If -Wdouble-promotion is in use, and the
11715 conditions for warning have been met, issue a warning. GMSGID is
11716 the warning message. It must have two %T specifiers for the type
11717 that was converted (generally "float") and the type to which it was
11718 converted (generally "double), respectively. LOC is the location
11719 to which the awrning should refer. */
11721 void
11724 {
11725 tree source_type;
11729 /* If the conversion will not occur at run-time, there is no need to
11730 warn about it. */
11742 else
11745 }
11747 /* Setup a TYPE_DECL node as a typedef representation.
11749 X is a TYPE_DECL for a typedef statement. Create a brand new
11750 ..._TYPE node (which will be just a variant of the existing
11751 ..._TYPE node with identical properties) and then install X
11752 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
11754 The whole point here is to end up with a situation where each
11755 and every ..._TYPE node the compiler creates will be uniquely
11756 associated with AT MOST one node representing a typedef name.
11757 This way, even though the compiler substitutes corresponding
11758 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
11759 early on, later parts of the compiler can always do the reverse
11760 translation and get back the corresponding typedef name. For
11761 example, given:
11763 typedef struct S MY_TYPE;
11764 MY_TYPE object;
11766 Later parts of the compiler might only know that `object' was of
11767 type `struct S' if it were not for code just below. With this
11768 code however, later parts of the compiler see something like:
11770 struct S' == struct S
11771 typedef struct S' MY_TYPE;
11772 struct S' object;
11774 And they can then deduce (from the node for type struct S') that
11775 the original object declaration was:
11777 MY_TYPE object;
11779 Being able to do this is important for proper support of protoize,
11780 and also for generating precise symbolic debugging information
11781 which takes full account of the programmer's (typedef) vocabulary.
11783 Obviously, we don't want to generate a duplicate ..._TYPE node if
11784 the TYPE_DECL node that we are now processing really represents a
11785 standard built-in type. */
11787 void
11789 {
11793 {
11796 }
11799 {
11807 }
11808 }
11810 /* Record the types used by the current global variable declaration
11811 being parsed, so that we can decide later to emit their debug info.
11812 Those types are in types_used_by_cur_var_decl, and we are going to
11813 store them in the types_used_by_vars_hash hash table.
11814 DECL is the declaration of the global variable that has been parsed. */
11816 void
11818 {
11822 {
11825 }
11826 }
11828 /* If DECL is a typedef that is declared in the current function,
11829 record it for the purpose of -Wunused-local-typedefs. */
11831 void
11833 {
11838 /* if this is not a locally defined typedef then we are not
11839 interested. */
11846 }
11848 /* If T is a TYPE_DECL declared locally, mark it as used. */
11850 void
11852 {
11857 }
11859 /* Warn if there are some unused locally defined typedefs in the
11860 current function. */
11862 void
11864 {
11866 tree decl;
11867 /* The number of times we have emitted -Wunused-local-typedefs
11868 warnings. If this is different from errorcount, that means some
11869 unrelated errors have been issued. In which case, we'll avoid
11870 emitting "unused-local-typedefs" warnings. */
11882 {
11886 OPT_Wunused_local_typedefs,
11889 }
11892 }
11894 /* Warn about boolean expression compared with an integer value different
11895 from true/false. Warns also e.g. about "(i1 == i2) == 2".
11896 LOC is the location of the comparison, CODE is its code, OP0 and OP1
11897 are the operands of the comparison. The caller must ensure that
11898 either operand is a boolean expression. */
11900 void
11902 tree op1)
11903 {
11913 {
11921 else
11924 }
11926 {
11927 /* If the non-constant operand isn't of a boolean type, we
11928 don't want to warn here. */
11930 /* Handle booleans promoted to integers. */
11938 /* Do some magic to get the right diagnostics. */
11947 }
11948 }
11950 /* The C and C++ parsers both use vectors to hold function arguments.
11951 For efficiency, we keep a cache of unused vectors. This is the
11952 cache. */
11957 /* Return a new vector from the cache. If the cache is empty,
11958 allocate a new vector. These vectors are GC'ed, so it is OK if the
11959 pointer is not released.. */
11963 {
11966 else
11967 {
11968 /* Passing 0 to vec::alloc returns NULL, and our callers require
11969 that we always return a non-NULL value. The vector code uses
11970 4 when growing a NULL vector, so we do too. */
11974 }
11975 }
11977 /* Release a vector of trees back to the cache. */
11979 void
11981 {
11983 {
11986 }
11987 }
11989 /* Get a new tree vector holding a single tree. */
11993 {
11997 }
11999 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
12003 {
12008 }
12010 /* Get a new tree vector which is a copy of an existing one. */
12014 {
12017 tree t;
12024 }
12026 /* Return true if KEYWORD starts a type specifier. */
12028 bool
12030 {
12032 {
12066 }
12067 }
12069 /* Return true if KEYWORD names a type qualifier. */
12071 bool
12073 {
12075 {
12083 }
12084 }
12086 /* Return true if KEYWORD names a storage class specifier.
12088 RID_TYPEDEF is not included in this list despite `typedef' being
12089 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
12090 such for syntactic convenience only. */
12092 bool
12094 {
12096 {
12106 }
12107 }
12109 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
12111 static bool
12113 {
12115 {
12123 }
12124 }
12126 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
12127 declaration-specifier (C99 6.7). */
12129 bool
12131 {
12138 {
12145 }
12146 }
12148 /* Initialize language-specific-bits of tree_contains_struct. */
12150 void
12152 {
12156 }
12158 /* Build a user-defined numeric literal out of an integer constant type VALUE
12159 with identifier SUFFIX. */
12161 tree
12164 {
12171 }
12173 /* For vector[index], convert the vector to a
12174 pointer of the underlying type. Return true if the resulting
12175 ARRAY_REF should not be an lvalue. */
12177 bool
12180 {
12183 {
12185 tree type1;
12194 {
12199 {
12202 *vecp
12205 non_const);
12206 }
12207 else
12212 }
12213 else
12220 {
12221 /* If the original vector isn't declared may_alias and it
12222 isn't a bare vector look if the subscripting would
12223 alias the vector we subscript, and if not, force ref-all. */
12229 }
12233 }
12235 }
12237 /* Determine which of the operands, if any, is a scalar that needs to be
12238 converted to a vector, for the range of operations. */
12239 enum stv_conv
12242 {
12251 {
12252 /* Most GENERIC binary expressions require homogeneous arguments.
12253 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
12254 argument that is a vector and a second one that is a scalar, so
12255 we never return stv_secondarg for them. */
12260 {
12262 {
12267 }
12268 else
12270 }
12277 /* ... fall through ... */
12298 /* What about UNLT_EXPR? */
12300 {
12301 tree tmp;
12303 /* Swap TYPE0 with TYPE1 and OP0 with OP1 */
12306 }
12310 {
12312 {
12317 }
12319 }
12321 /* Allow integer --> real conversion if safe. */
12325 {
12327 {
12332 }
12334 }
12337 }
12340 }
12342 /* Return true iff ALIGN is an integral constant that is a fundamental
12343 alignment, as defined by [basic.align] in the c++-11
12344 specifications.
12346 That is:
12348 [A fundamental alignment is represented by an alignment less than or
12349 equal to the greatest alignment supported by the implementation
12350 in all contexts, which is equal to
12351 alignof(max_align_t)]. */
12353 bool
12355 {
12358 }
12360 /* Return true if T is a pointer to a zero-sized aggregate. */
12362 bool
12364 {
12369 }