| blob | 569f000150f277b2356318ac199ad7a2769578a2 |
1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2016 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
52 /* Mode used to build pointers (VOIDmode means ptr_mode). */
56 /* The following symbols are subsumed in the c_global_trees array, and
57 listed here individually for documentation purposes.
59 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
61 tree short_integer_type_node;
62 tree long_integer_type_node;
63 tree long_long_integer_type_node;
65 tree short_unsigned_type_node;
66 tree long_unsigned_type_node;
67 tree long_long_unsigned_type_node;
69 tree truthvalue_type_node;
70 tree truthvalue_false_node;
71 tree truthvalue_true_node;
73 tree ptrdiff_type_node;
75 tree unsigned_char_type_node;
76 tree signed_char_type_node;
77 tree wchar_type_node;
79 tree char16_type_node;
80 tree char32_type_node;
82 tree float_type_node;
83 tree double_type_node;
84 tree long_double_type_node;
86 tree complex_integer_type_node;
87 tree complex_float_type_node;
88 tree complex_double_type_node;
89 tree complex_long_double_type_node;
91 tree dfloat32_type_node;
92 tree dfloat64_type_node;
93 tree_dfloat128_type_node;
95 tree intQI_type_node;
96 tree intHI_type_node;
97 tree intSI_type_node;
98 tree intDI_type_node;
99 tree intTI_type_node;
101 tree unsigned_intQI_type_node;
102 tree unsigned_intHI_type_node;
103 tree unsigned_intSI_type_node;
104 tree unsigned_intDI_type_node;
105 tree unsigned_intTI_type_node;
107 tree widest_integer_literal_type_node;
108 tree widest_unsigned_literal_type_node;
110 Nodes for types `void *' and `const void *'.
112 tree ptr_type_node, const_ptr_type_node;
114 Nodes for types `char *' and `const char *'.
116 tree string_type_node, const_string_type_node;
118 Type `char[SOMENUMBER]'.
119 Used when an array of char is needed and the size is irrelevant.
121 tree char_array_type_node;
123 Type `wchar_t[SOMENUMBER]' or something like it.
124 Used when a wide string literal is created.
126 tree wchar_array_type_node;
128 Type `char16_t[SOMENUMBER]' or something like it.
129 Used when a UTF-16 string literal is created.
131 tree char16_array_type_node;
133 Type `char32_t[SOMENUMBER]' or something like it.
134 Used when a UTF-32 string literal is created.
136 tree char32_array_type_node;
138 Type `int ()' -- used for implicit declaration of functions.
140 tree default_function_type;
142 A VOID_TYPE node, packaged in a TREE_LIST.
144 tree void_list_node;
146 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
147 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
148 VAR_DECLS, but C++ does.)
150 tree function_name_decl_node;
151 tree pretty_function_name_decl_node;
152 tree c99_function_name_decl_node;
154 Stack of nested function name VAR_DECLs.
156 tree saved_function_name_decls;
158 */
161 \f
162 /* Switches common to the C front ends. */
164 /* Nonzero means don't output line number information. */
168 /* Nonzero causes -E output not to be done, but directives such as
169 #define that have side effects are still obeyed. */
173 /* Nonzero means dump macros in some fashion. */
177 /* Nonzero means pass #include lines through to the output. */
181 /* Nonzero means process PCH files while preprocessing. */
185 /* The file name to which we should write a precompiled header, or
186 NULL if no header will be written in this compile. */
190 /* Nonzero if an ISO standard was selected. It rejects macros in the
191 user's namespace. */
194 /* C/ObjC language option variables. */
197 /* Nonzero means allow type mismatches in conditional expressions;
198 just make their values `void'. */
202 /* Nonzero means enable C89 Amendment 1 features. */
206 /* Nonzero means use the ISO C99 (or C11) dialect of C. */
210 /* Nonzero means use the ISO C11 dialect of C. */
214 /* Nonzero means that we have builtin functions, and main is an int. */
219 /* ObjC language option variables. */
222 /* Tells the compiler that this is a special run. Do not perform any
223 compiling, instead we are to test some platform dependent features
224 and output a C header file with appropriate definitions. */
228 /* Tells the compiler what is the constant string class for ObjC. */
233 /* C++ language option variables. */
235 /* The reference version of the ABI for -Wabi. */
239 /* Nonzero means generate separate instantiation control files and
240 juggle them at link time. */
244 /* The C++ dialect being used. Default set in c_common_post_options. */
248 /* Maximum template instantiation depth. This limit exists to limit the
249 time it takes to notice excessively recursive template instantiations.
251 The default is lower than the 1024 recommended by the C++0x standard
252 because G++ runs out of stack before 1024 with highly recursive template
253 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
257 /* The elements of `ridpointers' are identifier nodes for the reserved
258 type names and storage classes. It is indexed by a RID_... value. */
263 /* Nonzero means don't warn about problems that occur when the code is
264 executed. */
267 /* Whether we are building a boolean conversion inside
268 convert_for_assignment, or some other late binary operation. If
269 build_binary_op is called for C (from code shared by C and C++) in
270 this case, then the operands have already been folded and the
271 result will not be folded again, so C_MAYBE_CONST_EXPR should not
272 be generated. */
275 /* Whether lexing has been completed, so subsequent preprocessor
276 errors should use the compiler's input_location. */
279 /* Information about how a function name is generated. */
280 struct fname_var_t
281 {
285 };
287 /* The three ways of getting then name of the current function. */
290 {
291 /* C99 compliant __func__, must be first. */
293 /* GCC __FUNCTION__ compliant. */
295 /* GCC __PRETTY_FUNCTION__ compliant. */
298 };
300 /* Global visibility options. */
404 /* Reserved words. The third field is a mask: keywords are disabled
405 if they match the mask.
407 Masks for languages:
408 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
409 C --std=c99: D_CXXONLY | D_OBJC
410 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
411 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
412 C++ --std=c0x: D_CONLY | D_OBJC
413 ObjC++ is like C++ except that D_OBJC is not set
415 If -fno-asm is used, D_ASM is added to the mask. If
416 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
417 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
418 In C with -Wc++-compat, we warn if D_CXXWARN is set.
420 Note the complication of the D_CXX_OBJC keywords. These are
421 reserved words such as 'class'. In C++, 'class' is a reserved
422 word. In Objective-C++ it is too. In Objective-C, it is a
423 reserved word too, but only if it follows an '@' sign.
424 */
426 {
593 /* C++ transactional memory. */
599 /* Concepts-related keywords */
603 /* These Objective-C keywords are recognized only immediately after
604 an '@'. */
620 /* These are recognized only in protocol-qualifier context
621 (see above) */
628 /* These are recognized inside a property attribute list */
637 };
642 /* Table of machine-independent attributes common to all C-like languages.
644 All attributes referencing arguments should be additionally processed
645 in chkp_copy_function_type_adding_bounds for correct instrumentation
646 by Pointer Bounds Checker.
647 Current list of processed common attributes: nonnull. */
649 {
650 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
651 affects_type_identity } */
658 /* FIXME: logically, noreturn attributes should be listed as
659 "false, true, true" and apply to function types. But implementing this
660 would require all the places in the compiler that use TREE_THIS_VOLATILE
661 on a decl to identify non-returning functions to be located and fixed
662 to check the function type instead. */
693 /* The same comments as for noreturn attributes apply to const ones. */
721 handle_no_instrument_function_attribute,
724 handle_no_profile_instrument_function_attribute,
744 /* ??? These two attributes didn't make the transition from the
745 Intel language document to the multi-vendor language document. */
750 /* For internal use (marking of builtins) only. The name contains space
751 to prevent its usage in source code. */
773 /* For internal use (marking of builtins) only. The name contains space
774 to prevent its usage in source code. */
785 handle_no_address_safety_analysis_attribute,
788 handle_no_sanitize_address_attribute,
791 handle_no_sanitize_address_attribute,
794 handle_no_sanitize_undefined_attribute,
806 /* For internal use only. The leading '*' both prevents its usage in
807 source code and signals that it may be overridden by machine tables. */
812 /* For internal use (marking of builtins and runtime functions) only.
813 The name contains space to prevent its usage in source code. */
843 };
845 /* Give the specifications for the format attributes, used by C and all
846 descendants.
848 All attributes referencing arguments should be additionally processed
849 in chkp_copy_function_type_adding_bounds for correct instrumentation
850 by Pointer Bounds Checker.
851 Current list of processed format attributes: format, format_arg. */
853 {
854 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
855 affects_type_identity } */
861 };
863 /* Return identifier for address space AS. */
867 {
871 }
873 /* Push current bindings for the function name VAR_DECLS. */
875 void
877 {
882 {
886 {
888 saved);
890 }
891 }
893 /* Normally they'll have been NULL, so only push if we've got a
894 stack, or they are non-NULL. */
896 saved_function_name_decls);
897 }
899 /* Finish up the current bindings, adding them into the current function's
900 statement tree. This must be done _before_ finish_stmt_tree is called.
901 If there is no current function, we must be at file scope and no statements
902 are involved. Pop the previous bindings. */
904 void
906 {
915 {
923 }
929 {
930 /* We had saved values, restore them. */
931 tree saved;
934 {
939 }
941 }
943 }
945 /* Return the text name of the current function, suitably prettified
946 by PRETTY_P. Return string must be freed by caller. */
950 {
957 {
960 }
973 {
976 }
979 }
981 /* Return the VAR_DECL for a const char array naming the current
982 function. If the VAR_DECL has not yet been created, create it
983 now. RID indicates how it should be formatted and IDENTIFIER_NODE
984 ID is its name (unfortunately C and C++ hold the RID values of
985 keywords in different places, so we can't derive RID from ID in
986 this language independent code. LOC is the location of the
987 function. */
989 tree
991 {
1001 {
1002 /* If a tree is built here, it would normally have the lineno of
1003 the current statement. Later this tree will be moved to the
1004 beginning of the function and this line number will be wrong.
1005 To avoid this problem set the lineno to 0 here; that prevents
1006 it from appearing in the RTL. */
1007 tree stmts;
1015 saved_function_name_decls
1019 }
1024 }
1026 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
1028 tree
1030 {
1035 /* Compute the number of elements, for the array type. */
1037 {
1040 }
1042 {
1045 }
1047 {
1050 }
1051 else
1052 {
1055 }
1057 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
1058 limit in C++98 Annex B is very large (65536) and is not normative,
1059 so we do not diagnose it (warn_overlength_strings is forced off
1060 in c_common_post_options). */
1062 {
1066 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
1067 separate the %d from the 'C'. 'ISO' should not be
1068 translated, but it may be moved after 'C%d' in languages
1069 where modifiers follow nouns. */
1071 "string length %qd is greater than the length %qd "
1074 }
1076 /* Create the array type for the string constant. The ISO C++
1077 standard says that a string literal has type `const char[N]' or
1078 `const wchar_t[N]'. We use the same logic when invoked as a C
1079 front-end with -Wwrite-strings.
1080 ??? We should change the type of an expression depending on the
1081 state of a warning flag. We should just be warning -- see how
1082 this is handled in the C++ front-end for the deprecated implicit
1083 conversion from string literals to `char*' or `wchar_t*'.
1085 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1086 array type being the unqualified version of that type.
1087 Therefore, if we are constructing an array of const char, we must
1088 construct the matching unqualified array type first. The C front
1089 end does not require this, but it does no harm, so we do it
1090 unconditionally. */
1101 }
1103 /* Given a string of type STRING_TYPE, determine what kind of string
1104 token would give an equivalent execution encoding: CPP_STRING,
1105 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error.
1106 This may not be exactly the string token type that initially created
1107 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit
1108 string type at this point.
1110 This effectively reverses part of the logic in lex_string and
1111 fix_string_type. */
1113 static enum cpp_ttype
1115 {
1126 {
1133 }
1136 }
1138 /* The global record of string concatentations, for use in
1139 extracting locations within string literals. */
1143 /* Attempt to determine the source range of the substring.
1144 If successful, return NULL and write the source range to *OUT_RANGE.
1145 Otherwise return an error message. Error messages are intended
1146 for GCC developers (to help debugging) rather than for end-users. */
1150 {
1160 out_range);
1161 }
1163 \f
1164 /* Fold X for consideration by one of the warning functions when checking
1165 whether an expression has a constant value. */
1167 static tree
1169 {
1172 else
1173 /* The C front-end has already folded X appropriately. */
1175 }
1177 /* Print a warning if a constant expression had overflow in folding.
1178 Invoke this function on every expression that the language
1179 requires to be a constant expression.
1180 Note the ANSI C standard says it is erroneous for a
1181 constant expression to overflow. */
1183 void
1185 {
1193 }
1195 /* The same as above but print an unconditional error. */
1196 void
1198 {
1205 }
1207 /* Print a warning if an expression had overflow in folding and its
1208 operands hadn't.
1210 Invoke this function on every expression that
1211 (1) appears in the source code, and
1212 (2) is a constant expression that overflowed, and
1213 (3) is not already checked by convert_and_check;
1214 however, do not invoke this function on operands of explicit casts
1215 or when the expression is the result of an operator and any operand
1216 already overflowed. */
1218 void
1220 {
1225 {
1254 }
1255 }
1257 /* Warn about uses of logical || / && operator in a context where it
1258 is likely that the bitwise equivalent was intended by the
1259 programmer. We have seen an expression in which CODE is a binary
1260 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1261 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1262 void
1266 {
1278 /* We don't want to warn if either operand comes from a macro
1279 expansion. ??? This doesn't work with e.g. NEGATE_EXPR yet;
1280 see PR61534. */
1285 /* Warn if &&/|| are being used in a context where it is
1286 likely that the bitwise equivalent was intended by the
1287 programmer. That is, an expression such as op && MASK
1288 where op should not be any boolean expression, nor a
1289 constant, and mask seems to be a non-boolean integer constant. */
1291 /* An enumerator counts as a constant. */
1300 {
1304 else
1309 }
1311 /* We do not warn for constants because they are typical of macro
1312 expansions that test for features. */
1317 /* This warning only makes sense with logical operands. */
1324 /* The range computations only work with scalars. */
1329 /* We first test whether either side separately is trivially true
1330 (with OR) or trivially false (with AND). If so, do not warn.
1331 This is a common idiom for testing ranges of data types in
1332 portable code. */
1339 /* If this is an OR operation, invert both sides; now, the result
1340 should be always false to get a warning. */
1354 /* If this is an OR operation, invert both sides; now, the result
1355 should be always false to get a warning. */
1363 /* If both expressions have the same operand, if we can merge the
1364 ranges, ... */
1368 {
1370 /* ... and if the range test is always false, then warn. */
1372 {
1375 "logical %<or%> of collectively exhaustive tests is "
1377 else
1379 "logical %<and%> of mutually exclusive tests is "
1381 }
1382 /* Or warn if the operands have exactly the same range, e.g.
1383 A > 0 && A > 0. */
1386 {
1390 else
1393 }
1394 }
1395 }
1397 /* Helper function for warn_tautological_cmp. Look for ARRAY_REFs
1398 with constant indices. */
1400 static tree
1402 {
1408 {
1411 }
1414 }
1416 /* Warn if a self-comparison always evaluates to true or false. LOC
1417 is the location of the comparison with code CODE, LHS and RHS are
1418 operands of the comparison. */
1420 void
1422 {
1426 /* Don't warn for various macro expansions. */
1432 /* We do not warn for constants because they are typical of macro
1433 expansions that test for features, sizeof, and similar. */
1438 /* Don't warn for e.g.
1439 HOST_WIDE_INT n;
1440 ...
1441 if (n == (long) n) ...
1442 */
1447 /* Don't warn if either LHS or RHS has an IEEE floating-point type.
1448 It could be a NaN, and NaN never compares equal to anything, even
1449 itself. */
1454 {
1455 /* Don't warn about array references with constant indices;
1456 these are likely to come from a macro. */
1468 else
1471 }
1472 }
1474 /* Warn about logical not used on the left hand side operand of a comparison.
1475 This function assumes that the LHS is inside of TRUTH_NOT_EXPR.
1476 Do not warn if RHS is of a boolean type. */
1478 void
1480 tree rhs)
1481 {
1487 /* Don't warn for !x == 0 or !y != 0, those are equivalent to
1488 !(x == 0) or !(y != 0). */
1494 "logical not is only applied to the left hand side of "
1496 }
1498 /* Warn if EXP contains any computations whose results are not used.
1499 Return true if a warning is printed; false otherwise. LOCUS is the
1500 (potential) location of the expression. */
1502 bool
1504 {
1505 restart:
1509 /* Don't warn about void constructs. This includes casting to void,
1510 void function calls, and statement expressions with a final cast
1511 to void. */
1519 {
1535 /* For a binding, warn if no side effect within it. */
1547 /* In && or ||, warn if 2nd operand has no side effect. */
1554 /* Let people do `(foo (), 0)' without a warning. */
1561 /* If this is an expression with side effects, don't warn; this
1562 case commonly appears in macro expansions. */
1568 /* Don't warn about automatic dereferencing of references, since
1569 the user cannot control it. */
1571 {
1574 }
1575 /* Fall through. */
1578 /* Referencing a volatile value is a side effect, so don't warn. */
1583 /* If this is an expression which has no operands, there is no value
1584 to be unused. There are no such language-independent codes,
1585 but front ends may define such. */
1589 warn:
1591 }
1592 }
1595 /* Print a warning about casts that might indicate violation
1596 of strict aliasing rules if -Wstrict-aliasing is used and
1597 strict aliasing mode is in effect. OTYPE is the original
1598 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1600 bool
1602 {
1603 /* Strip pointer conversion chains and get to the correct original type. */
1611 /* If the type we are casting to is a ref-all pointer
1612 dereferencing it is always valid. */
1619 {
1620 /* Casting the address of an object to non void pointer. Warn
1621 if the cast breaks type based aliasing. */
1623 {
1627 }
1628 else
1629 {
1630 /* warn_strict_aliasing >= 3. This includes the default (3).
1631 Only warn if the cast is dereferenced immediately. */
1632 alias_set_type set1 =
1640 {
1644 }
1647 {
1651 }
1652 }
1653 }
1654 else
1656 {
1657 /* At this level, warn for any conversions, even if an address is
1658 not taken in the same statement. This will likely produce many
1659 false positives, but could be useful to pinpoint problems that
1660 are not revealed at higher levels. */
1665 {
1669 }
1670 }
1673 }
1675 /* Warn about memset (&a, 0, sizeof (&a)); and similar mistakes with
1676 sizeof as last operand of certain builtins. */
1678 void
1682 {
1686 location_t loc;
1694 {
1698 /* FALLTHRU */
1706 /* FALLTHRU */
1765 }
1793 {
1797 {
1800 "argument to %<sizeof%> in %qD call is the same "
1801 "expression as the destination; did you mean to "
1807 "argument to %<sizeof%> in %qD call is the same "
1808 "expression as the destination; did you mean to "
1810 else
1812 "argument to %<sizeof%> in %qD call is the same "
1813 "expression as the destination; did you mean to "
1816 }
1819 && !strop
1822 {
1824 "argument to %<sizeof%> in %qD call is the same "
1825 "pointer type %qT as the destination; expected %qT "
1829 }
1830 }
1833 {
1837 {
1840 "argument to %<sizeof%> in %qD call is the same "
1841 "expression as the source; did you mean to "
1847 "argument to %<sizeof%> in %qD call is the same "
1848 "expression as the source; did you mean to "
1850 else
1852 "argument to %<sizeof%> in %qD call is the same "
1853 "expression as the source; did you mean to "
1856 }
1859 && !strop
1862 {
1864 "argument to %<sizeof%> in %qD call is the same "
1865 "pointer type %qT as the source; expected %qT "
1869 }
1870 }
1873 {
1877 {
1880 "argument to %<sizeof%> in %qD call is the same "
1881 "expression as the first source; did you mean to "
1887 "argument to %<sizeof%> in %qD call is the same "
1888 "expression as the first source; did you mean to "
1890 else
1892 "argument to %<sizeof%> in %qD call is the same "
1893 "expression as the first source; did you mean to "
1896 }
1899 && !strop
1902 {
1904 "argument to %<sizeof%> in %qD call is the same "
1905 "pointer type %qT as the first source; expected %qT "
1909 }
1910 }
1913 {
1917 {
1920 "argument to %<sizeof%> in %qD call is the same "
1921 "expression as the second source; did you mean to "
1927 "argument to %<sizeof%> in %qD call is the same "
1928 "expression as the second source; did you mean to "
1930 else
1932 "argument to %<sizeof%> in %qD call is the same "
1933 "expression as the second source; did you mean to "
1936 }
1939 && !strop
1942 {
1944 "argument to %<sizeof%> in %qD call is the same "
1945 "pointer type %qT as the second source; expected %qT "
1949 }
1950 }
1952 }
1954 /* Warn for unlikely, improbable, or stupid DECL declarations
1955 of `main'. */
1957 void
1959 {
1960 function_args_iterator iter;
1961 tree type;
1965 {
1966 /* XXX void_type_node belies the abstraction. */
1976 {
1982 }
1986 {
2008 "third argument of %q+D should probably be "
2011 }
2012 }
2014 /* It is intentional that this message does not mention the third
2015 argument because it's only mentioned in an appendix of the
2016 standard. */
2024 }
2026 /* vector_targets_convertible_p is used for vector pointer types. The
2027 callers perform various checks that the qualifiers are satisfactory,
2028 while OTOH vector_targets_convertible_p ignores the number of elements
2029 in the vectors. That's fine with vector pointers as we can consider,
2030 say, a vector of 8 elements as two consecutive vectors of 4 elements,
2031 and that does not require and conversion of the pointer values.
2032 In contrast, vector_types_convertible_p and
2033 vector_types_compatible_elements_p are used for vector value types. */
2034 /* True if pointers to distinct types T1 and T2 can be converted to
2035 each other without an explicit cast. Only returns true for opaque
2036 vector types. */
2037 bool
2039 {
2046 }
2048 /* vector_types_convertible_p is used for vector value types.
2049 It could in principle call vector_targets_convertible_p as a subroutine,
2050 but then the check for vector type would be duplicated with its callers,
2051 and also the purpose of vector_targets_convertible_p would become
2052 muddled.
2053 Where vector_types_convertible_p returns true, a conversion might still be
2054 needed to make the types match.
2055 In contrast, vector_targets_convertible_p is used for vector pointer
2056 values, and vector_types_compatible_elements_p is used specifically
2057 in the context for binary operators, as a check if use is possible without
2058 conversion. */
2059 /* True if vector types T1 and T2 can be converted to each other
2060 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
2061 can only be converted with -flax-vector-conversions yet that is not
2062 in effect, emit a note telling the user about that option if such
2063 a note has not previously been emitted. */
2064 bool
2066 {
2074 convertible_lax =
2089 {
2092 "conversions between vectors with differing "
2094 }
2097 }
2099 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
2100 and have vector types, V0 has the same type as V1, and the number of
2101 elements of V0, V1, MASK is the same.
2103 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2104 called with two arguments. In this case implementation passes the
2105 first argument twice in order to share the same tree code. This fact
2106 could enable the mask-values being twice the vector length. This is
2107 an implementation accident and this semantics is not guaranteed to
2108 the user. */
2109 tree
2112 {
2113 tree ret;
2119 {
2122 }
2129 {
2134 }
2138 {
2142 }
2145 {
2150 }
2156 {
2159 "argument vector(s) and the mask vector should "
2162 }
2166 {
2171 }
2174 {
2175 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
2181 else
2182 {
2185 }
2189 }
2199 }
2201 /* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum
2202 to integral type. */
2204 static tree
2206 {
2211 {
2212 /* C++0x scoped enumerations don't implicitly convert to integral
2213 type; if we stripped an explicit conversion to a larger type we
2214 need to replace it so common_type will still work. */
2218 }
2220 }
2222 /* This is a helper function of build_binary_op.
2224 For certain operations if both args were extended from the same
2225 smaller type, do the arithmetic in that type and then extend.
2227 BITWISE indicates a bitwise operation.
2228 For them, this optimization is safe only if
2229 both args are zero-extended or both are sign-extended.
2230 Otherwise, we might change the result.
2231 Eg, (short)-1 | (unsigned short)-1 is (int)-1
2232 but calculated in (unsigned short) it would be (unsigned short)-1.
2233 */
2234 tree
2236 {
2240 tree type;
2242 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
2243 excessive narrowing when we call get_narrower below. For
2244 example, suppose that OP0 is of unsigned int extended
2245 from signed char and that RESULT_TYPE is long long int.
2246 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
2247 like
2249 (long long int) (unsigned int) signed_char
2251 which get_narrower would narrow down to
2253 (unsigned int) signed char
2255 If we do not cast OP0 first, get_narrower would return
2256 signed_char, which is inconsistent with the case of the
2257 explicit cast. */
2264 /* UNS is 1 if the operation to be done is an unsigned one. */
2267 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
2268 but it *requires* conversion to FINAL_TYPE. */
2279 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
2281 /* For bitwise operations, signedness of nominal type
2282 does not matter. Consider only how operands were extended. */
2286 /* Note that in all three cases below we refrain from optimizing
2287 an unsigned operation on sign-extended args.
2288 That would not be valid. */
2290 /* Both args variable: if both extended in same way
2291 from same width, do it in that width.
2292 Do it unsigned if args were zero-extended. */
2299 return c_common_signed_or_unsigned_type
2306 && (type
2317 && (type
2325 }
2327 /* Returns true iff any integer value of type FROM_TYPE can be represented as
2328 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */
2330 static bool
2332 {
2335 REAL_VALUE_TYPE real_low_bound =
2337 REAL_VALUE_TYPE real_high_bound =
2342 }
2344 /* Checks if expression EXPR of complex/real/integer type cannot be converted
2345 to the complex/real/integer type TYPE. Function returns non-zero when:
2346 * EXPR is a constant which cannot be exactly converted to TYPE.
2347 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
2348 for EXPR type and TYPE being both integers or both real, or both
2349 complex.
2350 * EXPR is not a constant of complex type and TYPE is a real or
2351 an integer.
2352 * EXPR is not a constant of real type and TYPE is an integer.
2353 * EXPR is not a constant of integer type which cannot be
2354 exactly converted to real type.
2356 Function allows conversions between types of different signedness and
2357 can return SAFE_CONVERSION (zero) in that case. Function can produce
2358 signedness warnings if PRODUCE_WARNS is true.
2360 Function allows conversions from complex constants to non-complex types,
2361 provided that imaginary part is zero and real part can be safely converted
2362 to TYPE. */
2364 enum conversion_safety
2366 {
2372 {
2373 /* If type is complex, we are interested in compatibility with
2374 underlying type. */
2378 /* Warn for real constant that is not an exact integer converted
2379 to integer type. */
2382 {
2385 }
2386 /* Warn for an integer constant that does not fit into integer type. */
2390 {
2393 {
2397 }
2399 {
2403 }
2404 else
2406 }
2408 {
2409 /* Warn for an integer constant that does not fit into real type. */
2411 {
2415 }
2416 /* Warn for a real constant that does not fit into a smaller
2417 real type. */
2420 {
2424 }
2425 }
2426 }
2429 {
2431 /* Conversion from complex constant with zero imaginary part,
2432 perform check for conversion of real part. */
2437 /* Note: in this branch we use recursive call to unsafe_conversion_p
2438 with different type of EXPR, but it is still safe, because when EXPR
2439 is a constant, it's type is not used in text of generated warnings
2440 (otherwise they could sound misleading). */
2442 produce_warns);
2443 /* Conversion from complex constant with non-zero imaginary part. */
2444 else
2445 {
2446 /* Conversion to complex type.
2447 Perform checks for both real and imaginary parts. */
2449 {
2450 /* Unfortunately, produce_warns must be false in two subsequent
2451 calls of unsafe_conversion_p, because otherwise we could
2452 produce strange "double" warnings, if both real and imaginary
2453 parts have conversion problems related to signedness.
2455 For example:
2456 int32_t _Complex a = 0x80000000 + 0x80000000i;
2458 Possible solution: add a separate function for checking
2459 constants and combine result of two calls appropriately. */
2465 /* Merge the results into appropriate single warning. */
2467 /* Note: this case includes SAFE_CONVERSION, i.e. success. */
2474 else
2476 }
2477 /* Warn about conversion from complex to real or integer type. */
2478 else
2480 }
2481 }
2483 /* Checks for remaining case: EXPR is not constant. */
2484 else
2485 {
2486 /* Warn for real types converted to integer types. */
2493 {
2494 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2498 /* Don't warn for short y; short x = ((int)y & 0xff); */
2502 {
2503 /* If both args were extended from a shortest type,
2504 use that type if that is safe. */
2511 {
2517 /* If one of the operands is a non-negative constant
2518 that fits in the target type, then the type of the
2519 other operand does not matter. */
2528 /* If constant is unsigned and fits in the target
2529 type, then the result will also fit. */
2531 && unsigned0
2534 && unsigned1
2537 }
2538 }
2539 /* Warn for integer types converted to smaller integer types. */
2543 /* When they are the same width but different signedness,
2544 then the value may change. */
2547 /* Even when converted to a bigger type, if the type is
2548 unsigned but expr is signed, then negative values
2549 will be changed. */
2555 }
2557 /* Warn for integer types converted to real types if and only if
2558 all the range of values of the integer type cannot be
2559 represented by the real type. */
2562 {
2563 /* Don't warn about char y = 0xff; float x = (int) y; */
2569 }
2571 /* Warn for real types converted to smaller real types. */
2577 /* Check conversion between two complex types. */
2580 {
2581 /* Extract underlying types (i.e., type of real and imaginary
2582 parts) of expr_type and type. */
2586 /* Warn for real types converted to integer types. */
2591 /* Warn for real types converted to smaller real types. */
2597 /* Check conversion for complex integer types. Here implementation
2598 is simpler than for real-domain integers because it does not
2599 involve sophisticated cases, such as bitmasks, casts, etc. */
2602 {
2603 /* Warn for integer types converted to smaller integer types. */
2607 /* Check for different signedness, see case for real-domain
2608 integers (above) for a more detailed comment. */
2614 "conversion to %qT from %qT "
2617 }
2622 }
2624 /* Warn for complex types converted to real or integer types. */
2628 }
2631 }
2633 /* Warns if the conversion of EXPR to TYPE may alter a value.
2634 This is a helper function for warnings_for_convert_and_check. */
2636 static void
2638 {
2645 /* This may happen, because for LHS op= RHS we preevaluate
2646 RHS and create C_MAYBE_CONST_EXPR <SAVE_EXPR <RHS>>, which
2647 means we could no longer see the code of the EXPR. */
2654 {
2667 /* Conversion from boolean to a signed:1 bit-field (which only
2668 can hold the values 0 and -1) doesn't lose information - but
2669 it does change the value. */
2690 {
2691 /* In case of COND_EXPR, we do not care about the type of
2692 COND_EXPR, only about the conversion of each operand. */
2699 }
2715 }
2716 }
2718 /* Produce warnings after a conversion. RESULT is the result of
2719 converting EXPR to TYPE. This is a helper function for
2720 convert_and_check and cp_convert_and_check. */
2722 void
2724 tree result)
2725 {
2732 {
2733 /* Do not diagnose overflow in a constant expression merely
2734 because a conversion overflowed. */
2739 {
2740 /* This detects cases like converting -129 or 256 to
2741 unsigned char. */
2745 else
2747 }
2751 /* No warning for converting 0x80000000 to int. */
2759 else
2761 }
2766 else
2768 }
2771 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2772 Invoke this function on every expression that is converted implicitly,
2773 i.e. because of language rules and not because of an explicit cast. */
2775 tree
2777 {
2778 tree result;
2779 tree expr_for_warning;
2781 /* Convert from a value with possible excess precision rather than
2782 via the semantic type, but do not warn about values not fitting
2783 exactly in the semantic type. */
2785 {
2791 }
2792 else
2806 }
2807 \f
2808 /* A node in a list that describes references to variables (EXPR), which are
2809 either read accesses if WRITER is zero, or write accesses, in which case
2810 WRITER is the parent of EXPR. */
2811 struct tlist
2812 {
2815 };
2817 /* Used to implement a cache the results of a call to verify_tree. We only
2818 use this for SAVE_EXPRs. */
2819 struct tlist_cache
2820 {
2824 tree expr;
2825 };
2827 /* Obstack to use when allocating tlist structures, and corresponding
2828 firstobj. */
2832 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2833 warnings. */
2835 /* SAVE_EXPRs need special treatment. We process them only once and then
2836 cache the results. */
2848 /* Create a new struct tlist and fill in its fields. */
2851 {
2858 }
2860 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2861 is nonnull, we ignore any node we find which has a writer equal to it. */
2863 static void
2865 {
2867 {
2874 }
2875 }
2877 /* Merge the nodes of ADD into TO. This merging process is done so that for
2878 each variable that already exists in TO, no new node is added; however if
2879 there is a write access recorded in ADD, and an occurrence on TO is only
2880 a read access, then the occurrence in TO will be modified to record the
2881 write. */
2883 static void
2885 {
2892 {
2899 {
2903 }
2905 {
2909 }
2911 }
2912 }
2914 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2915 references in list LIST conflict with it, excluding reads if ONLY writers
2916 is nonzero. */
2918 static void
2921 {
2924 /* Avoid duplicate warnings. */
2930 {
2934 {
2939 }
2941 }
2942 }
2944 /* Given a list LIST of references to variables, find whether any of these
2945 can cause conflicts due to missing sequence points. */
2947 static void
2949 {
2953 {
2956 }
2957 }
2959 /* Return nonzero if X is a tree that can be verified by the sequence point
2960 warnings. */
2961 static int
2963 {
2970 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2971 (lvalue_p) crash on TRY/CATCH. */
2978 /* No point to track non-const calls, they will never satisfy
2979 operand_equal_p. */
2987 }
2989 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2990 static bool
2992 {
2994 }
2996 /* Walk the tree X, and record accesses to variables. If X is written by the
2997 parent tree, WRITER is the parent.
2998 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2999 expression or its only operand forces a sequence point, then everything up
3000 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
3001 in PNO_SP.
3002 Once we return, we will have emitted warnings if any subexpression before
3003 such a sequence point could be undefined. On a higher level, however, the
3004 sequence point may not be relevant, and we'll merge the two lists.
3006 Example: (b++, a) + b;
3007 The call that processes the COMPOUND_EXPR will store the increment of B
3008 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
3009 processes the PLUS_EXPR will need to merge the two lists so that
3010 eventually, all accesses end up on the same list (and we'll warn about the
3011 unordered subexpressions b++ and b.
3013 A note on merging. If we modify the former example so that our expression
3014 becomes
3015 (b++, b) + a
3016 care must be taken not simply to add all three expressions into the final
3017 PNO_SP list. The function merge_tlist takes care of that by merging the
3018 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
3019 way, so that no more than one access to B is recorded. */
3021 static void
3023 tree writer)
3024 {
3029 /* X may be NULL if it is the operand of an empty statement expression
3030 ({ }). */
3034 restart:
3042 {
3077 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
3078 two first, to avoid warning for (a ? b++ : b++). */
3094 /* Expressions inside the LHS are not ordered wrt. the sequence points
3095 in the RHS. Example:
3096 *a = (a++, 2)
3097 Despite the fact that the modification of "a" is in the before_sp
3098 list (tmp_before), it conflicts with the use of "a" in the LHS.
3099 We can handle this by adding the contents of tmp_list3
3100 to those of tmp_before, and redoing the collision warnings for that
3101 list. */
3104 /* Exclude the LHS itself here; we first have to merge it into the
3105 tmp_nosp list. This is done to avoid warning for "a = a"; if we
3106 didn't exclude the LHS, we'd get it twice, once as a read and once
3107 as a write. */
3118 /* We need to warn about conflicts among arguments and conflicts between
3119 args and the function address. Side effects of the function address,
3120 however, are not ordered by the sequence point of the call. */
3121 {
3122 call_expr_arg_iterator iter;
3123 tree arg;
3127 {
3132 }
3137 }
3140 /* Scan all the list, e.g. indices of multi dimensional array. */
3142 {
3148 }
3152 {
3159 {
3173 }
3177 }
3187 /* For other expressions, simply recurse on their operands.
3188 Manual tail recursion for unary expressions.
3189 Other non-expressions need not be processed. */
3191 {
3195 }
3197 {
3201 {
3206 }
3207 }
3209 }
3210 }
3212 /* Try to warn for undefined behavior in EXPR due to missing sequence
3213 points. */
3215 DEBUG_FUNCTION void
3217 {
3223 {
3226 }
3231 }
3232 \f
3233 /* Validate the expression after `case' and apply default promotions. */
3235 static tree
3237 {
3242 /* Promote char or short to int. */
3245 {
3248 }
3253 }
3254 \f
3255 /* See if the case values LOW and HIGH are in the range of the original
3256 type (i.e. before the default conversion to int) of the switch testing
3257 expression.
3258 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
3259 the type before promoting it. CASE_LOW_P is a pointer to the lower
3260 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
3261 if the case is not a case range.
3262 The caller has to make sure that we are not called with NULL for
3263 CASE_LOW_P (i.e. the default case). OUTSIDE_RANGE_P says whether there
3264 was a case value that doesn't fit into the range of the ORIG_TYPE.
3265 Returns true if the case label is in range of ORIG_TYPE (saturated or
3266 untouched) or false if the label is out of range. */
3268 static bool
3272 {
3277 /* If there was a problem with the original type, do nothing. */
3284 /* We'll really need integer constants here. */
3288 /* Case label is less than minimum for type. */
3291 {
3296 }
3298 /* Case value is greater than maximum for type. */
3301 {
3305 }
3307 /* Saturate lower case label value to minimum. */
3310 {
3315 }
3317 /* Saturate upper case label value to maximum. */
3320 {
3325 }
3333 }
3334 \f
3335 /* Return an integer type with BITS bits of precision,
3336 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
3338 tree
3340 {
3382 }
3384 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
3385 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
3386 and saturating if SATP is nonzero, otherwise not saturating. */
3388 tree
3391 {
3392 machine_mode mode;
3395 else
3403 {
3405 "fixed-point types that have too many integral and "
3408 }
3411 }
3413 /* Used for communication between c_common_type_for_mode and
3414 c_register_builtin_type. */
3415 tree registered_builtin_types;
3417 /* Return a data type that has machine mode MODE.
3418 If the mode is an integer,
3419 then UNSIGNEDP selects between signed and unsigned types.
3420 If the mode is a fixed-point mode,
3421 then UNSIGNEDP selects between saturating and nonsaturating types. */
3423 tree
3425 {
3426 tree t;
3466 #if HOST_BITS_PER_WIDE_INT >= 64
3469 #endif
3494 {
3495 machine_mode inner_mode;
3496 tree inner_type;
3512 }
3514 {
3519 }
3529 {
3615 }
3623 }
3625 tree
3627 {
3629 }
3631 /* Return a signed type the same as TYPE in other respects. */
3633 tree
3635 {
3637 }
3639 /* Return a type the same as TYPE except unsigned or
3640 signed according to UNSIGNEDP. */
3642 tree
3644 {
3645 tree type1;
3648 /* This block of code emulates the behavior of the old
3649 c_common_unsigned_type. In particular, it returns
3650 long_unsigned_type_node if passed a long, even when a int would
3651 have the same size. This is necessary for warnings to work
3652 correctly in archs where sizeof(int) == sizeof(long) */
3655 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3675 #if HOST_BITS_PER_WIDE_INT >= 64
3678 #endif
3688 #define C_COMMON_FIXED_TYPES(NAME) \
3689 if (type1 == short_ ## NAME ## _type_node \
3690 || type1 == unsigned_short_ ## NAME ## _type_node) \
3691 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3692 : short_ ## NAME ## _type_node; \
3693 if (type1 == NAME ## _type_node \
3694 || type1 == unsigned_ ## NAME ## _type_node) \
3695 return unsignedp ? unsigned_ ## NAME ## _type_node \
3696 : NAME ## _type_node; \
3697 if (type1 == long_ ## NAME ## _type_node \
3698 || type1 == unsigned_long_ ## NAME ## _type_node) \
3699 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3700 : long_ ## NAME ## _type_node; \
3701 if (type1 == long_long_ ## NAME ## _type_node \
3702 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3703 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3704 : long_long_ ## NAME ## _type_node;
3706 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3707 if (type1 == NAME ## _type_node \
3708 || type1 == u ## NAME ## _type_node) \
3709 return unsignedp ? u ## NAME ## _type_node \
3710 : NAME ## _type_node;
3712 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3713 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3714 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3715 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3716 : sat_ ## short_ ## NAME ## _type_node; \
3717 if (type1 == sat_ ## NAME ## _type_node \
3718 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3719 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3720 : sat_ ## NAME ## _type_node; \
3721 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3722 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3723 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3724 : sat_ ## long_ ## NAME ## _type_node; \
3725 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3726 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3727 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3728 : sat_ ## long_long_ ## NAME ## _type_node;
3730 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3731 if (type1 == sat_ ## NAME ## _type_node \
3732 || type1 == sat_ ## u ## NAME ## _type_node) \
3733 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3734 : sat_ ## NAME ## _type_node;
3760 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3761 the precision; they have precision set to match their range, but
3762 may use a wider mode to match an ABI. If we change modes, we may
3763 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3764 the precision as well, so as to yield correct results for
3765 bit-field types. C++ does not have these separate bit-field
3766 types, and producing a signed or unsigned variant of an
3767 ENUMERAL_TYPE may cause other problems as well. */
3773 #define TYPE_OK(node) \
3774 (TYPE_MODE (type) == TYPE_MODE (node) \
3775 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3799 #if HOST_BITS_PER_WIDE_INT >= 64
3802 #endif
3811 #undef TYPE_OK
3814 }
3816 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3818 tree
3820 {
3823 /* Extended integer types of the same width as a standard type have
3824 lesser rank, so those of the same width as int promote to int or
3825 unsigned int and are valid for printf formats expecting int or
3826 unsigned int. To avoid such special cases, avoid creating
3827 extended integer types for bit-fields if a standard integer type
3828 is available. */
3846 }
3848 /* The C version of the register_builtin_type langhook. */
3850 void
3852 {
3853 tree decl;
3863 }
3864 \f
3865 /* Print an error message for invalid operands to arith operation
3866 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3867 RICHLOC is a rich location for the message, containing either
3868 three separate locations for each of the operator and operands
3870 lhs op rhs
3871 ~~~ ^~ ~~~
3873 (C FE), or one location ranging over all over them
3875 lhs op rhs
3876 ~~~~^~~~~~
3878 (C++ FE). */
3880 void
3883 {
3887 {
3932 }
3936 }
3937 \f
3938 /* Given an expression as a tree, return its original type. Do this
3939 by stripping any conversion that preserves the sign and precision. */
3940 static tree
3942 {
3945 }
3947 /* Subroutine of build_binary_op, used for comparison operations.
3948 See if the operands have both been converted from subword integer types
3949 and, if so, perhaps change them both back to their original type.
3950 This function is also responsible for converting the two operands
3951 to the proper common type for comparison.
3953 The arguments of this function are all pointers to local variables
3954 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3955 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3957 LOC is the location of the comparison.
3959 If this function returns nonzero, it means that the comparison has
3960 a constant value. What this function returns is an expression for
3961 that value. */
3963 tree
3966 {
3967 tree type;
3975 /* Throw away any conversions to wider types
3976 already present in the operands. */
3981 /* If primopN is first sign-extended from primopN's precision to opN's
3982 precision, then zero-extended from opN's precision to
3983 *restype_ptr precision, shortenings might be invalid. */
3986 && !unsignedp0
3991 && !unsignedp1
3995 /* Handle the case that OP0 does not *contain* a conversion
3996 but it *requires* conversion to FINAL_TYPE. */
4003 /* If one of the operands must be floated, we cannot optimize. */
4007 /* If first arg is constant, swap the args (changing operation
4008 so value is preserved), for canonicalization. Don't do this if
4009 the second arg is 0. */
4014 {
4023 {
4038 }
4040 }
4042 /* If comparing an integer against a constant more bits wide,
4043 maybe we can deduce a value of 1 or 0 independent of the data.
4044 Or else truncate the constant now
4045 rather than extend the variable at run time.
4047 This is only interesting if the constant is the wider arg.
4048 Also, it is not safe if the constant is unsigned and the
4049 variable arg is signed, since in this case the variable
4050 would be sign-extended and then regarded as unsigned.
4051 Our technique fails in this case because the lowest/highest
4052 possible unsigned results don't follow naturally from the
4053 lowest/highest possible values of the variable operand.
4054 For just EQ_EXPR and NE_EXPR there is another technique that
4055 could be used: see if the constant can be faithfully represented
4056 in the other operand's type, by truncating it and reextending it
4057 and see if that preserves the constant's value. */
4063 {
4066 /* 1 if comparison is nominally unsigned. */
4068 tree val;
4080 {
4081 /* Convert primop1 to target type, but do not introduce
4082 additional overflow. We know primop1 is an int_cst. */
4088 }
4090 {
4093 }
4101 /* This used to be a switch, but Genix compiler can't handle that. */
4103 {
4106 }
4108 {
4111 }
4113 {
4118 }
4120 {
4125 }
4127 {
4132 }
4134 {
4139 }
4141 /* If primop0 was sign-extended and unsigned comparison specd,
4142 we did a signed comparison above using the signed type bounds.
4143 But the comparison we output must be unsigned.
4145 Also, for inequalities, VAL is no good; but if the signed
4146 comparison had *any* fixed result, it follows that the
4147 unsigned comparison just tests the sign in reverse
4148 (positive values are LE, negative ones GE).
4149 So we can generate an unsigned comparison
4150 against an extreme value of the signed type. */
4153 {
4156 {
4171 }
4173 }
4176 /* Don't warn if it's from a (non-system) macro. */
4177 && !(from_macro_expansion_at
4178 (expansion_point_location_if_in_system_header
4180 {
4187 }
4190 {
4191 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4195 }
4197 /* Value is not predetermined, but do the comparison
4198 in the type of the operand that is not constant.
4199 TYPE is already properly set. */
4200 }
4202 /* If either arg is decimal float and the other is float, find the
4203 proper common type to use for comparison. */
4209 /* If either arg is decimal float and the other is float, fail. */
4220 /* If args' natural types are both narrower than nominal type
4221 and both extend in the same manner, compare them
4222 in the type of the wider arg.
4223 Otherwise must actually extend both to the nominal
4224 common type lest different ways of extending
4225 alter the result.
4226 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
4231 {
4235 type);
4236 /* Make sure shorter operand is extended the right way
4237 to match the longer operand. */
4238 primop0
4241 primop0);
4242 primop1
4245 primop1);
4246 }
4247 else
4248 {
4249 /* Here we must do the comparison on the nominal type
4250 using the args exactly as we received them. */
4257 {
4259 /* All unsigned values are >= 0, so we warn. However,
4260 if OP0 is a constant that is >= 0, the signedness of
4261 the comparison isn't an issue, so suppress the
4262 warning. */
4267 primop0)))
4268 /* Do not warn for enumeration types. */
4272 {
4289 }
4292 {
4293 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
4298 }
4299 }
4300 }
4308 }
4309 \f
4310 /* Return a tree for the sum or difference (RESULTCODE says which)
4311 of pointer PTROP and integer INTOP. */
4313 tree
4316 {
4319 /* The result is a pointer of the same type that is being added. */
4323 {
4330 }
4332 {
4339 }
4340 else
4343 /* We are manipulating pointer values, so we don't need to warn
4344 about relying on undefined signed overflow. We disable the
4345 warning here because we use integer types so fold won't know that
4346 they are really pointers. */
4349 /* If what we are about to multiply by the size of the elements
4350 contains a constant term, apply distributive law
4351 and multiply that constant term separately.
4352 This helps produce common subexpressions. */
4357 /* If the constant comes from pointer subtraction,
4358 skip this optimization--it would cause an error. */
4360 /* If the constant is unsigned, and smaller than the pointer size,
4361 then we must skip this optimization. This is because it could cause
4362 an overflow error if the constant is negative but INTOP is not. */
4366 {
4371 /* Convert both subexpression types to the type of intop,
4372 because weird cases involving pointer arithmetic
4373 can result in a sum or difference with different type args. */
4378 }
4380 /* Convert the integer argument to a type the same size as sizetype
4381 so the multiply won't overflow spuriously. */
4387 /* Replace the integer argument with a suitable product by the object size.
4388 Do this multiplication as signed, then convert to the appropriate type
4389 for the pointer operation and disregard an overflow that occurred only
4390 because of the sign-extension change in the latter conversion. */
4391 {
4397 }
4399 /* Create the sum or difference. */
4408 }
4409 \f
4410 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
4411 and if NON_CONST is known not to be permitted in an evaluated part
4412 of a constant expression. */
4414 tree
4416 {
4420 /* This should never be called for C++. */
4424 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
4433 }
4435 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
4436 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
4437 around the SAVE_EXPR if needed so that c_fully_fold does not need
4438 to look inside SAVE_EXPRs. */
4440 tree
4442 {
4451 }
4453 /* Return whether EXPR is a declaration whose address can never be
4454 NULL. */
4456 bool
4458 {
4463 }
4465 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4466 or for an `if' or `while' statement or ?..: exp. It should already
4467 have been validated to be of suitable type; otherwise, a bad
4468 diagnostic may result.
4470 The EXPR is located at LOCATION.
4472 This preparation consists of taking the ordinary
4473 representation of an expression expr and producing a valid tree
4474 boolean expression describing whether expr is nonzero. We could
4475 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
4476 but we optimize comparisons, &&, ||, and !.
4478 The resulting type should always be `truthvalue_type_node'. */
4480 tree
4482 {
4484 {
4526 ? truthvalue_true_node
4532 ? truthvalue_true_node
4537 /* Fall through. */
4540 {
4543 {
4544 /* Common Ada/Pascal programmer's mistake. */
4546 OPT_Waddress,
4548 inner);
4550 }
4552 }
4569 /* These don't change whether an object is nonzero or zero. */
4574 /* These don't change whether an object is zero or nonzero, but
4575 we can't ignore them if their second arg has side-effects. */
4577 {
4580 c_common_truthvalue_conversion
4583 }
4584 else
4589 /* Distribute the conversion into the arms of a COND_EXPR. */
4591 {
4594 /* In C++ one of the arms might have void type if it is throw. */
4602 }
4603 else
4604 {
4605 /* Folding will happen later for C. */
4613 }
4615 CASE_CONVERT:
4616 {
4621 && !c_inhibit_evaluation_warnings
4623 {
4629 OPT_Waddress,
4630 "the compiler can assume that the address of "
4632 inner);
4633 }
4635 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4636 since that affects how `default_conversion' will behave. */
4640 /* Don't strip a conversion from C++0x scoped enum, since they
4641 don't implicitly convert to other types. */
4645 /* If this isn't narrowing the argument, we can ignore it. */
4649 }
4655 {
4657 "suggest parentheses around assignment used as "
4660 }
4665 }
4668 {
4670 expr = (build_binary_op
4674 c_common_truthvalue_conversion
4677 c_common_truthvalue_conversion
4682 }
4685 {
4690 }
4691 else
4694 ret:
4697 }
4698 \f
4707 /* Apply the TYPE_QUALS to the new DECL. */
4709 void
4711 {
4719 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
4720 constructor can produce constant init, so rely on cp_finish_decl to
4721 clear TREE_READONLY if the variable has non-constant init. */
4724 {
4727 }
4729 {
4731 /* Allow 'restrict' on arrays of pointers.
4732 FIXME currently we just ignore it. */
4738 }
4739 }
4742 {
4745 };
4747 /* Hash function for the problem of multiple type definitions in
4748 different files. This must hash all types that will compare
4749 equal via comptypes to the same value. In practice it hashes
4750 on some of the simple stuff and leaves the details to comptypes. */
4752 hashval_t
4754 {
4757 tree t2;
4759 {
4760 /* For pointers, hash on pointee type plus some swizzling. */
4763 /* Hash on number of elements and total size. */
4782 }
4783 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4784 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4786 /* We might have a VLA here. */
4789 else
4792 }
4794 bool
4796 {
4798 }
4802 /* Return the typed-based alias set for T, which may be an expression
4803 or a type. Return -1 if we don't do anything special. */
4805 alias_set_type
4807 {
4808 /* For VLAs, use the alias set of the element type rather than the
4809 default of alias set 0 for types compared structurally. */
4811 {
4815 }
4817 /* That's all the expressions we handle specially. */
4821 /* The C standard guarantees that any object may be accessed via an
4822 lvalue that has character type. */
4828 /* The C standard specifically allows aliasing between signed and
4829 unsigned variants of the same type. We treat the signed
4830 variant as canonical. */
4832 {
4835 /* t1 == t can happen for boolean nodes which are always unsigned. */
4838 }
4840 /* Handle the case of multiple type nodes referring to "the same" type,
4841 which occurs with IMA. These share an alias set. FIXME: Currently only
4842 C90 is handled. (In C99 type compatibility is not transitive, which
4843 complicates things mightily. The alias set splay trees can theoretically
4844 represent this, but insertion is tricky when you consider all the
4845 different orders things might arrive in.) */
4850 /* Save time if there's only one input file. */
4854 /* Pointers need special handling if they point to any type that
4855 needs special handling (below). */
4857 {
4858 tree t2;
4859 /* Find bottom type under any nested POINTERs. */
4863 ;
4869 }
4870 /* These are the only cases that need special handling. */
4875 /* Undefined? */
4879 /* Look up t in hash table. Only one of the compatible types within each
4880 alias set is recorded in the table. */
4885 {
4888 }
4889 else
4890 /* Our caller will assign and record (in t) a new alias set; all we need
4891 to do is remember t in the hash table. */
4895 }
4896 \f
4897 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4898 the IS_SIZEOF parameter indicates which operator is being applied.
4899 The COMPLAIN flag controls whether we should diagnose possibly
4900 ill-formed constructs or not. LOC is the location of the SIZEOF or
4901 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
4902 a type in any context should be returned, rather than the normal
4903 alignment for that type. */
4905 tree
4909 {
4917 {
4919 {
4926 }
4927 else
4928 {
4930 {
4934 else
4937 }
4939 }
4940 }
4942 {
4950 }
4953 {
4958 }
4961 {
4966 }
4967 else
4968 {
4970 /* Convert in case a char is more than one unit. */
4976 else
4978 }
4980 /* VALUE will have the middle-end integer type sizetype.
4981 However, we should really return a value of type `size_t',
4982 which is just a typedef for an ordinary integer type. */
4986 }
4988 /* Implement the __alignof keyword: Return the minimum required
4989 alignment of EXPR, measured in bytes. For VAR_DECLs,
4990 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4991 from an "aligned" __attribute__ specification). LOC is the
4992 location of the ALIGNOF operator. */
4994 tree
4996 {
4997 tree t;
5004 {
5007 }
5013 {
5020 {
5027 }
5029 }
5030 else
5034 }
5035 \f
5036 /* Handle C and C++ default attributes. */
5038 enum built_in_attribute
5039 {
5040 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
5041 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
5042 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
5043 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
5044 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
5046 #undef DEF_ATTR_NULL_TREE
5047 #undef DEF_ATTR_INT
5048 #undef DEF_ATTR_STRING
5049 #undef DEF_ATTR_IDENT
5050 #undef DEF_ATTR_TREE_LIST
5051 ATTR_LAST
5052 };
5058 enum c_builtin_type
5059 {
5060 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
5061 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
5062 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
5063 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
5064 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5065 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5066 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
5067 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5068 ARG6) NAME,
5069 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5070 ARG6, ARG7) NAME,
5071 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5072 ARG6, ARG7, ARG8) NAME,
5073 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5074 ARG6, ARG7, ARG8, ARG9) NAME,
5075 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5076 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
5077 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5078 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
5079 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
5080 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
5081 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
5082 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
5083 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
5084 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5085 NAME,
5086 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5087 ARG6) NAME,
5088 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5089 ARG6, ARG7) NAME,
5090 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
5092 #undef DEF_PRIMITIVE_TYPE
5093 #undef DEF_FUNCTION_TYPE_0
5094 #undef DEF_FUNCTION_TYPE_1
5095 #undef DEF_FUNCTION_TYPE_2
5096 #undef DEF_FUNCTION_TYPE_3
5097 #undef DEF_FUNCTION_TYPE_4
5098 #undef DEF_FUNCTION_TYPE_5
5099 #undef DEF_FUNCTION_TYPE_6
5100 #undef DEF_FUNCTION_TYPE_7
5101 #undef DEF_FUNCTION_TYPE_8
5102 #undef DEF_FUNCTION_TYPE_9
5103 #undef DEF_FUNCTION_TYPE_10
5104 #undef DEF_FUNCTION_TYPE_11
5105 #undef DEF_FUNCTION_TYPE_VAR_0
5106 #undef DEF_FUNCTION_TYPE_VAR_1
5107 #undef DEF_FUNCTION_TYPE_VAR_2
5108 #undef DEF_FUNCTION_TYPE_VAR_3
5109 #undef DEF_FUNCTION_TYPE_VAR_4
5110 #undef DEF_FUNCTION_TYPE_VAR_5
5111 #undef DEF_FUNCTION_TYPE_VAR_6
5112 #undef DEF_FUNCTION_TYPE_VAR_7
5113 #undef DEF_POINTER_TYPE
5114 BT_LAST
5115 };
5119 /* A temporary array for c_common_nodes_and_builtins. Used in
5120 communication with def_fn_type. */
5123 /* A helper function for c_common_nodes_and_builtins. Build function type
5124 for DEF with return type RET and N arguments. If VAR is true, then the
5125 function should be variadic after those N arguments.
5127 Takes special care not to ICE if any of the types involved are
5128 error_mark_node, which indicates that said type is not in fact available
5129 (see builtin_type_for_size). In which case the function type as a whole
5130 should be error_mark_node. */
5132 static void
5134 {
5135 tree t;
5142 {
5148 }
5155 else
5158 egress:
5161 }
5163 /* Build builtin functions common to both C and C++ language
5164 frontends. */
5166 static void
5168 {
5169 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
5170 builtin_types[ENUM] = VALUE;
5171 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
5172 def_fn_type (ENUM, RETURN, 0, 0);
5173 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
5174 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
5175 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
5176 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
5177 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5178 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
5179 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5180 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
5181 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5182 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5183 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5184 ARG6) \
5185 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5186 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5187 ARG6, ARG7) \
5188 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5189 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5190 ARG6, ARG7, ARG8) \
5191 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5192 ARG7, ARG8);
5193 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5194 ARG6, ARG7, ARG8, ARG9) \
5195 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5196 ARG7, ARG8, ARG9);
5197 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5198 ARG6, ARG7, ARG8, ARG9, ARG10) \
5199 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5200 ARG7, ARG8, ARG9, ARG10);
5201 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5202 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
5203 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
5204 ARG7, ARG8, ARG9, ARG10, ARG11);
5205 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
5206 def_fn_type (ENUM, RETURN, 1, 0);
5207 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
5208 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
5209 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
5210 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
5211 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
5212 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
5213 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
5214 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
5215 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
5216 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
5217 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5218 ARG6) \
5219 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
5220 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
5221 ARG6, ARG7) \
5222 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
5223 #define DEF_POINTER_TYPE(ENUM, TYPE) \
5224 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
5228 #undef DEF_PRIMITIVE_TYPE
5229 #undef DEF_FUNCTION_TYPE_0
5230 #undef DEF_FUNCTION_TYPE_1
5231 #undef DEF_FUNCTION_TYPE_2
5232 #undef DEF_FUNCTION_TYPE_3
5233 #undef DEF_FUNCTION_TYPE_4
5234 #undef DEF_FUNCTION_TYPE_5
5235 #undef DEF_FUNCTION_TYPE_6
5236 #undef DEF_FUNCTION_TYPE_7
5237 #undef DEF_FUNCTION_TYPE_8
5238 #undef DEF_FUNCTION_TYPE_9
5239 #undef DEF_FUNCTION_TYPE_10
5240 #undef DEF_FUNCTION_TYPE_11
5241 #undef DEF_FUNCTION_TYPE_VAR_0
5242 #undef DEF_FUNCTION_TYPE_VAR_1
5243 #undef DEF_FUNCTION_TYPE_VAR_2
5244 #undef DEF_FUNCTION_TYPE_VAR_3
5245 #undef DEF_FUNCTION_TYPE_VAR_4
5246 #undef DEF_FUNCTION_TYPE_VAR_5
5247 #undef DEF_FUNCTION_TYPE_VAR_6
5248 #undef DEF_FUNCTION_TYPE_VAR_7
5249 #undef DEF_POINTER_TYPE
5254 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
5255 NONANSI_P, ATTRS, IMPLICIT, COND) \
5256 if (NAME && COND) \
5257 def_builtin_1 (ENUM, NAME, CLASS, \
5258 builtin_types[(int) TYPE], \
5259 builtin_types[(int) LIBTYPE], \
5260 BOTH_P, FALLBACK_P, NONANSI_P, \
5261 built_in_attributes[(int) ATTRS], IMPLICIT);
5270 }
5272 /* Like get_identifier, but avoid warnings about null arguments when
5273 the argument may be NULL for targets where GCC lacks stdint.h type
5274 information. */
5278 {
5280 }
5282 /* Build tree nodes and builtin functions common to both C and C++ language
5283 frontends. */
5285 void
5287 {
5291 tree array_domain_type;
5292 tree va_list_ref_type_node;
5293 tree va_list_arg_type_node;
5298 /* Define `int' and `char' first so that dbx will output them first. */
5302 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
5303 "unsigned long", "long long unsigned" and "unsigned short" were in C++
5304 but not C. Are the conditionals here needed? */
5310 long_unsigned_type_node);
5313 {
5321 }
5326 long_long_integer_type_node);
5328 long_long_unsigned_type_node);
5331 long_long_unsigned_type_node);
5334 short_unsigned_type_node);
5337 short_unsigned_type_node);
5339 /* Define both `signed char' and `unsigned char'. */
5343 /* These are types that c_common_type_for_size and
5344 c_common_type_for_mode use. */
5347 intQI_type_node));
5350 intHI_type_node));
5353 intSI_type_node));
5356 intDI_type_node));
5357 #if HOST_BITS_PER_WIDE_INT >= 64
5358 /* Note that this is different than the __int128 type that's part of
5359 the generic __intN support. */
5362 TYPE_DECL,
5364 intTI_type_node));
5365 #endif
5368 unsigned_intQI_type_node));
5371 unsigned_intHI_type_node));
5374 unsigned_intSI_type_node));
5377 unsigned_intDI_type_node));
5378 #if HOST_BITS_PER_WIDE_INT >= 64
5381 TYPE_DECL,
5383 unsigned_intTI_type_node));
5384 #endif
5386 /* Create the widest literal types. */
5387 widest_integer_literal_type_node
5391 widest_integer_literal_type_node));
5393 widest_unsigned_literal_type_node
5397 widest_unsigned_literal_type_node));
5401 pid_type_node =
5408 /* Only supported decimal floating point extension if the target
5409 actually supports underlying modes. */
5413 {
5417 }
5420 {
5425 long_long_fract_type_node);
5427 unsigned_short_fract_type_node);
5429 unsigned_fract_type_node);
5431 unsigned_long_fract_type_node);
5433 unsigned_long_long_fract_type_node);
5435 sat_short_fract_type_node);
5438 sat_long_fract_type_node);
5440 sat_long_long_fract_type_node);
5442 sat_unsigned_short_fract_type_node);
5444 sat_unsigned_fract_type_node);
5446 sat_unsigned_long_fract_type_node);
5448 sat_unsigned_long_long_fract_type_node);
5453 long_long_accum_type_node);
5455 unsigned_short_accum_type_node);
5457 unsigned_accum_type_node);
5459 unsigned_long_accum_type_node);
5461 unsigned_long_long_accum_type_node);
5463 sat_short_accum_type_node);
5466 sat_long_accum_type_node);
5468 sat_long_long_accum_type_node);
5470 sat_unsigned_short_accum_type_node);
5472 sat_unsigned_accum_type_node);
5474 sat_unsigned_long_accum_type_node);
5476 sat_unsigned_long_long_accum_type_node);
5478 }
5481 TYPE_DECL,
5483 complex_integer_type_node));
5485 TYPE_DECL,
5487 complex_float_type_node));
5489 TYPE_DECL,
5491 complex_double_type_node));
5495 complex_long_double_type_node));
5498 /* For C++, make fileptr_type_node a distinct void * type until
5499 FILE type is defined. */
5504 /* Set the TYPE_NAME for any variants that were built before
5505 record_builtin_type gave names to the built-in types. */
5506 {
5512 }
5516 /* Make a type to be the domain of a few array types
5517 whose domains don't really matter.
5518 200 is small enough that it always fits in size_t
5519 and large enough that it can hold most function names for the
5520 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
5523 /* Make a type for arrays of characters.
5524 With luck nothing will ever really depend on the length of this
5525 array type. */
5526 char_array_type_node
5530 const_string_type_node
5534 /* This is special for C++ so functions can be overloaded. */
5540 {
5543 else
5546 }
5548 /* This is for wide string constants. */
5549 wchar_array_type_node
5552 /* Define 'char16_t'. */
5557 {
5562 }
5564 /* This is for UTF-16 string constants. */
5565 char16_array_type_node
5568 /* Define 'char32_t'. */
5573 {
5578 }
5580 /* This is for UTF-32 string constants. */
5581 char32_array_type_node
5584 wint_type_node =
5587 intmax_type_node =
5589 uintmax_type_node =
5593 sig_atomic_type_node =
5596 int8_type_node =
5599 int16_type_node =
5602 int32_type_node =
5605 int64_type_node =
5608 uint8_type_node =
5620 int_least8_type_node =
5623 int_least16_type_node =
5626 int_least32_type_node =
5629 int_least64_type_node =
5632 uint_least8_type_node =
5635 uint_least16_type_node =
5638 uint_least32_type_node =
5641 uint_least64_type_node =
5644 int_fast8_type_node =
5647 int_fast16_type_node =
5650 int_fast32_type_node =
5653 int_fast64_type_node =
5656 uint_fast8_type_node =
5659 uint_fast16_type_node =
5662 uint_fast32_type_node =
5665 uint_fast64_type_node =
5668 intptr_type_node =
5671 uintptr_type_node =
5674 default_function_type
5676 ptrdiff_type_node
5683 va_list_type_node));
5685 {
5688 tree ptype;
5691 {
5695 ptype));
5697 }
5698 }
5701 {
5704 }
5705 else
5706 {
5709 }
5716 /* Create the built-in __null node. It is important that this is
5717 not shared. */
5721 /* Since builtin_types isn't gc'ed, don't export these nodes. */
5723 }
5725 /* The number of named compound-literals generated thus far. */
5728 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
5730 void
5732 {
5735 compound_literal_number);
5736 compound_literal_number++;
5738 }
5740 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type
5741 TYPE and operand OP. */
5743 static tree
5745 {
5749 }
5751 /* Return a VA_ARG_EXPR corresponding to a source-level expression
5752 va_arg (EXPR, TYPE) at source location LOC. */
5754 tree
5756 {
5759 ? NULL_TREE
5764 {
5765 /* Let's handle things neutrallly, if expr:
5766 - has undeclared type, or
5767 - is not an va_list type. */
5769 }
5772 {
5773 /* Case 1: Not an array type. */
5775 /* Take the address, to get '&ap'. */
5779 /* Verify that &ap is still recognized as having va_list type. */
5780 tree canon_expr_type
5783 {
5787 }
5790 }
5792 /* Case 2: Array type.
5794 Background:
5796 For contrast, let's start with the simple case (case 1). If
5797 canon_va_type is not an array type, but say a char *, then when
5798 passing-by-value a va_list, the type of the va_list param decl is
5799 the same as for another va_list decl (all ap's are char *):
5801 f2_1 (char * ap)
5802 D.1815 = VA_ARG (&ap, 0B, 1);
5803 return D.1815;
5805 f2 (int i)
5806 char * ap.0;
5807 char * ap;
5808 __builtin_va_start (&ap, 0);
5809 ap.0 = ap;
5810 res = f2_1 (ap.0);
5811 __builtin_va_end (&ap);
5812 D.1812 = res;
5813 return D.1812;
5815 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a
5816 va_list the type of the va_list param decl (case 2b, struct * ap) is not
5817 the same as for another va_list decl (case 2a, struct ap[1]).
5819 f2_1 (struct * ap)
5820 D.1844 = VA_ARG (ap, 0B, 0);
5821 return D.1844;
5823 f2 (int i)
5824 struct ap[1];
5825 __builtin_va_start (&ap, 0);
5826 res = f2_1 (&ap);
5827 __builtin_va_end (&ap);
5828 D.1841 = res;
5829 return D.1841;
5831 Case 2b is different because:
5832 - on the callee side, the parm decl has declared type va_list, but
5833 grokdeclarator changes the type of the parm decl to a pointer to the
5834 array elem type.
5835 - on the caller side, the pass-by-value uses &ap.
5837 We unify these two cases (case 2a: va_list is array type,
5838 case 2b: va_list is pointer to array elem type), by adding '&' for the
5839 array type case, such that we have a pointer to array elem in both
5840 cases. */
5843 {
5844 /* Case 2a: va_list is array type. */
5846 /* Take the address, to get '&ap'. Make sure it's a pointer to array
5847 elem type. */
5850 expr);
5852 /* Verify that &ap is still recognized as having va_list type. */
5853 tree canon_expr_type
5856 {
5860 }
5861 }
5862 else
5863 {
5864 /* Case 2b: va_list is pointer to array elem type. */
5868 /* Don't take the address. We've already got '&ap'. */
5869 ;
5870 }
5873 }
5876 /* Linked list of disabled built-in functions. */
5878 struct disabled_builtin
5879 {
5882 };
5887 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5888 begins with "__builtin_", give an error. */
5890 void
5892 {
5895 else
5896 {
5901 }
5902 }
5905 /* Return true if the built-in function NAME has been disabled, false
5906 otherwise. */
5908 static bool
5910 {
5913 {
5916 }
5918 }
5921 /* Worker for DEF_BUILTIN.
5922 Possibly define a builtin function with one or two names.
5923 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5924 nonansi_p and flag_no_nonansi_builtin. */
5926 static void
5933 {
5934 tree decl;
5947 fnattrs);
5956 }
5957 \f
5958 /* Nonzero if the type T promotes to int. This is (nearly) the
5959 integral promotions defined in ISO C99 6.3.1.1/2. */
5961 bool
5963 {
5965 {
5975 /* ??? Technically all enumerations not larger than an int
5976 promote to an int. But this is used along code paths
5977 that only want to notice a size change. */
5985 }
5986 }
5988 /* Return 1 if PARMS specifies a fixed number of parameters
5989 and none of their types is affected by default promotions. */
5991 int
5993 {
5994 const_tree t;
5996 {
6013 }
6015 }
6017 /* Recursively remove any '*' or '&' operator from TYPE. */
6018 tree
6020 {
6024 }
6026 /* Recursively remove pointer or array type from TYPE. */
6027 tree
6029 {
6033 }
6035 /* Used to compare case labels. K1 and K2 are actually tree nodes
6036 representing case labels, or NULL_TREE for a `default' label.
6037 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
6038 K2, and 0 if K1 and K2 are equal. */
6040 int
6042 {
6043 /* Consider a NULL key (such as arises with a `default' label) to be
6044 smaller than anything else. */
6051 }
6053 /* Process a case label, located at LOC, for the range LOW_VALUE
6054 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
6055 then this case label is actually a `default' label. If only
6056 HIGH_VALUE is NULL_TREE, then case label was declared using the
6057 usual C/C++ syntax, rather than the GNU case range extension.
6058 CASES is a tree containing all the case ranges processed so far;
6059 COND is the condition for the switch-statement itself.
6060 OUTSIDE_RANGE_P says whether there was a case value that doesn't
6061 fit into the range of the ORIG_TYPE. Returns the CASE_LABEL_EXPR
6062 created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
6064 tree
6067 {
6068 tree type;
6069 tree label;
6070 tree case_label;
6071 splay_tree_node node;
6073 /* Create the LABEL_DECL itself. */
6076 /* If there was an error processing the switch condition, bail now
6077 before we get more confused. */
6085 {
6088 }
6090 /* Case ranges are a GNU extension. */
6097 {
6102 }
6104 {
6109 }
6112 {
6113 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
6114 really a case range, even though it was written that way.
6115 Remove the HIGH_VALUE to simplify later processing. */
6120 }
6122 /* See if the case is in range of the type of the original testing
6123 expression. If both low_value and high_value are out of range,
6124 don't insert the case label and return NULL_TREE. */
6128 outside_range_p))
6131 /* Look up the LOW_VALUE in the table of case labels we already
6132 have. */
6134 /* If there was not an exact match, check for overlapping ranges.
6135 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
6136 that's a `default' label and the only overlap is an exact match. */
6138 {
6139 splay_tree_node low_bound;
6140 splay_tree_node high_bound;
6142 /* Even though there wasn't an exact match, there might be an
6143 overlap between this case range and another case range.
6144 Since we've (inductively) not allowed any overlapping case
6145 ranges, we simply need to find the greatest low case label
6146 that is smaller that LOW_VALUE, and the smallest low case
6147 label that is greater than LOW_VALUE. If there is an overlap
6148 it will occur in one of these two ranges. */
6154 /* Check to see if the LOW_BOUND overlaps. It is smaller than
6155 the LOW_VALUE, so there is no need to check unless the
6156 LOW_BOUND is in fact itself a case range. */
6162 /* Check to see if the HIGH_BOUND overlaps. The low end of that
6163 range is bigger than the low end of the current range, so we
6164 are only interested if the current range is a real range, and
6165 not an ordinary case label. */
6167 && high_value
6169 high_value)
6172 }
6173 /* If there was an overlap, issue an error. */
6175 {
6179 {
6183 }
6185 {
6188 }
6189 else
6190 {
6194 }
6196 }
6198 /* Add a CASE_LABEL to the statement-tree. */
6200 /* Register this case label in the splay tree. */
6207 error_out:
6208 /* Add a label so that the back-end doesn't think that the beginning of
6209 the switch is unreachable. Note that we do not add a case label, as
6210 that just leads to duplicates and thence to failure later on. */
6212 {
6215 }
6217 }
6219 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
6220 Used to verify that case values match up with enumerator values. */
6222 static void
6224 {
6231 else
6238 buf);
6239 else
6244 }
6246 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
6247 Used to verify that case values match up with enumerator values. */
6249 static int
6251 {
6255 /* Skip default case. */
6259 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
6260 when we did our enum->case scan. Reset our scratch bit after. */
6263 else
6266 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
6267 not set, that means that CASE_HIGH did not appear when we did our
6268 enum->case scan. Reset our scratch bit after. */
6270 {
6273 else
6275 }
6278 }
6280 /* Handle -Wswitch*. Called from the front end after parsing the
6281 switch construct. */
6282 /* ??? Should probably be somewhere generic, since other languages
6283 besides C and C++ would want this. At the moment, however, C/C++
6284 are the only tree-ssa languages that support enumerations at all,
6285 so the point is moot. */
6287 void
6291 {
6292 splay_tree_node default_node;
6293 splay_tree_node node;
6294 tree chain;
6305 /* There are certain cases where -Wswitch-bool warnings aren't
6306 desirable, such as
6307 switch (boolean)
6308 {
6309 case true: ...
6310 case false: ...
6311 }
6312 so be careful here. */
6314 {
6315 splay_tree_node min_node;
6316 /* If there's a default node, it's also the value with the minimal
6317 key. So look at the penultimate key (if any). */
6320 else
6325 /* This might be a case range, so look at the value with the
6326 maximal key and then check CASE_HIGH. */
6331 /* If there's a case value > 1 or < 0, that is outside bool
6332 range, warn. */
6336 /* And handle the
6337 switch (boolean)
6338 {
6339 case true: ...
6340 case false: ...
6341 default: ...
6342 }
6343 case, where we want to warn. */
6344 || (default_node
6349 }
6351 /* From here on, we only care about enumerated types. */
6355 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
6359 /* Check the cases. Warn about case values which are not members of
6360 the enumerated type. For -Wswitch-enum, or for -Wswitch when
6361 there is no default case, check that exactly all enumeration
6362 literals are covered by the cases. */
6364 /* Clearing COND if it is not an integer constant simplifies
6365 the tests inside the loop below. */
6369 /* The time complexity here is O(N*lg(N)) worst case, but for the
6370 common case of monotonically increasing enumerators, it is
6371 O(N), since the nature of the splay tree will keep the next
6372 element adjacent to the root at all times. */
6375 {
6381 {
6382 /* Mark the CASE_LOW part of the case entry as seen. */
6386 }
6388 /* Even though there wasn't an exact match, there might be a
6389 case range which includes the enumerator's value. */
6392 {
6396 {
6397 /* If we match the upper bound exactly, mark the CASE_HIGH
6398 part of the case entry as seen. */
6402 }
6403 }
6405 /* We've now determined that this enumerated literal isn't
6406 handled by the case labels of the switch statement. */
6408 /* If the switch expression is a constant, we only really care
6409 about whether that constant is handled by the switch. */
6413 /* If there is a default_node, the only relevant option is
6414 Wswitch-enum. Otherwise, if both are enabled then we prefer
6415 to warn using -Wswitch because -Wswitch is enabled by -Wall
6416 while -Wswitch-enum is explicit. */
6419 ? OPT_Wswitch_enum
6423 }
6425 /* Warn if there are case expressions that don't correspond to
6426 enumerators. This can occur since C and C++ don't enforce
6427 type-checking of assignments to enumeration variables.
6429 The time complexity here is now always O(N) worst case, since
6430 we should have marked both the lower bound and upper bound of
6431 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
6432 above. This scan also resets those fields. */
6435 }
6437 /* Finish an expression taking the address of LABEL (an
6438 IDENTIFIER_NODE). Returns an expression for the address.
6440 LOC is the location for the expression returned. */
6442 tree
6444 {
6445 tree result;
6455 else
6456 {
6459 /* The current function is not necessarily uninlinable.
6460 Computed gotos are incompatible with inlining, but the value
6461 here could be used only in a diagnostic, for example. */
6463 }
6466 }
6467 \f
6469 /* Given a boolean expression ARG, return a tree representing an increment
6470 or decrement (as indicated by CODE) of ARG. The front end must check for
6471 invalid cases (e.g., decrement in C++). */
6472 tree
6474 {
6475 tree val;
6480 {
6503 }
6506 }
6507 \f
6508 /* Built-in macros for stddef.h and stdint.h, that require macros
6509 defined in this file. */
6510 void
6512 {
6575 }
6577 static void
6579 {
6580 /* Fill in the built_in_attributes array. */
6581 #define DEF_ATTR_NULL_TREE(ENUM) \
6582 built_in_attributes[(int) ENUM] = NULL_TREE;
6583 #define DEF_ATTR_INT(ENUM, VALUE) \
6584 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
6585 #define DEF_ATTR_STRING(ENUM, VALUE) \
6586 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
6587 #define DEF_ATTR_IDENT(ENUM, STRING) \
6588 built_in_attributes[(int) ENUM] = get_identifier (STRING);
6589 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
6590 built_in_attributes[(int) ENUM] \
6591 = tree_cons (built_in_attributes[(int) PURPOSE], \
6592 built_in_attributes[(int) VALUE], \
6593 built_in_attributes[(int) CHAIN]);
6595 #undef DEF_ATTR_NULL_TREE
6596 #undef DEF_ATTR_INT
6597 #undef DEF_ATTR_IDENT
6598 #undef DEF_ATTR_TREE_LIST
6599 }
6601 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
6602 identifier as an argument, so the front end shouldn't look it up. */
6604 bool
6606 {
6609 /* Unknown attribute that we'll end up ignoring, return true so we
6610 don't complain about an identifier argument. */
6616 else
6618 }
6620 /* Attribute handlers common to C front ends. */
6622 /* Handle a "packed" attribute; arguments as in
6623 struct attribute_spec.handler. */
6625 static tree
6628 {
6630 {
6634 }
6636 {
6638 /* Still pack bitfields. */
6643 else
6645 }
6646 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
6647 used for DECL_REGISTER. It wouldn't mean anything anyway.
6648 We can't set DECL_PACKED on the type of a TYPE_DECL, because
6649 that changes what the typedef is typing. */
6650 else
6651 {
6654 }
6657 }
6659 /* Handle a "nocommon" attribute; arguments as in
6660 struct attribute_spec.handler. */
6662 static tree
6666 {
6669 else
6670 {
6673 }
6676 }
6678 /* Handle a "common" attribute; arguments as in
6679 struct attribute_spec.handler. */
6681 static tree
6684 {
6687 else
6688 {
6691 }
6694 }
6696 /* Handle a "noreturn" attribute; arguments as in
6697 struct attribute_spec.handler. */
6699 static tree
6702 {
6705 /* See FIXME comment in c_common_attribute_table. */
6712 = (build_qualified_type
6713 (build_pointer_type
6717 else
6718 {
6721 }
6724 }
6726 /* Handle a "hot" and attribute; arguments as in
6727 struct attribute_spec.handler. */
6729 static tree
6732 {
6735 {
6737 {
6741 }
6742 /* Most of the rest of the hot processing is done later with
6743 lookup_attribute. */
6744 }
6745 else
6746 {
6749 }
6752 }
6754 /* Handle a "cold" and attribute; arguments as in
6755 struct attribute_spec.handler. */
6757 static tree
6760 {
6763 {
6765 {
6769 }
6770 /* Most of the rest of the cold processing is done later with
6771 lookup_attribute. */
6772 }
6773 else
6774 {
6777 }
6780 }
6782 /* Handle a "no_sanitize_address" attribute; arguments as in
6783 struct attribute_spec.handler. */
6785 static tree
6788 {
6790 {
6793 }
6796 }
6798 /* Handle a "no_address_safety_analysis" attribute; arguments as in
6799 struct attribute_spec.handler. */
6801 static tree
6804 {
6813 }
6815 /* Handle a "no_sanitize_undefined" attribute; arguments as in
6816 struct attribute_spec.handler. */
6818 static tree
6821 {
6823 {
6826 }
6829 }
6831 /* Handle a "stack_protect" attribute; arguments as in
6832 struct attribute_spec.handler. */
6833 static tree
6836 {
6838 {
6841 }
6842 else
6848 }
6850 /* Handle a "noinline" attribute; arguments as in
6851 struct attribute_spec.handler. */
6853 static tree
6857 {
6859 {
6861 {
6865 }
6866 else
6868 }
6869 else
6870 {
6873 }
6876 }
6878 /* Handle a "noclone" attribute; arguments as in
6879 struct attribute_spec.handler. */
6881 static tree
6885 {
6887 {
6890 }
6893 }
6895 /* Handle a "no_icf" attribute; arguments as in
6896 struct attribute_spec.handler. */
6898 static tree
6902 {
6904 {
6907 }
6910 }
6913 /* Handle a "always_inline" attribute; arguments as in
6914 struct attribute_spec.handler. */
6916 static tree
6921 {
6923 {
6925 {
6929 }
6931 {
6935 }
6936 else
6937 /* Set the attribute and mark it for disregarding inline
6938 limits. */
6940 }
6941 else
6942 {
6945 }
6948 }
6950 /* Handle a "gnu_inline" attribute; arguments as in
6951 struct attribute_spec.handler. */
6953 static tree
6958 {
6960 {
6961 /* Do nothing else, just set the attribute. We'll get at
6962 it later with lookup_attribute. */
6963 }
6964 else
6965 {
6968 }
6971 }
6973 /* Handle a "leaf" attribute; arguments as in
6974 struct attribute_spec.handler. */
6976 static tree
6980 {
6982 {
6985 }
6987 {
6990 }
6993 }
6995 /* Handle an "artificial" attribute; arguments as in
6996 struct attribute_spec.handler. */
6998 static tree
7003 {
7005 {
7006 /* Do nothing else, just set the attribute. We'll get at
7007 it later with lookup_attribute. */
7008 }
7009 else
7010 {
7013 }
7016 }
7018 /* Handle a "flatten" attribute; arguments as in
7019 struct attribute_spec.handler. */
7021 static tree
7023 tree args ATTRIBUTE_UNUSED,
7025 {
7027 /* Do nothing else, just set the attribute. We'll get at
7028 it later with lookup_attribute. */
7029 ;
7030 else
7031 {
7034 }
7037 }
7039 /* Handle a "warning" or "error" attribute; arguments as in
7040 struct attribute_spec.handler. */
7042 static tree
7045 {
7048 /* Do nothing else, just set the attribute. We'll get at
7049 it later with lookup_attribute. */
7050 ;
7051 else
7052 {
7055 }
7058 }
7060 /* Handle a "used" attribute; arguments as in
7061 struct attribute_spec.handler. */
7063 static tree
7066 {
7072 {
7077 }
7078 else
7079 {
7082 }
7085 }
7087 /* Handle a "unused" attribute; arguments as in
7088 struct attribute_spec.handler. */
7090 tree
7093 {
7095 {
7103 {
7107 }
7108 else
7109 {
7112 }
7113 }
7114 else
7115 {
7119 }
7122 }
7124 /* Handle a "externally_visible" attribute; arguments as in
7125 struct attribute_spec.handler. */
7127 static tree
7132 {
7136 {
7139 {
7143 }
7144 }
7145 else
7146 {
7149 }
7152 }
7154 /* Handle the "no_reorder" attribute. Arguments as in
7155 struct attribute_spec.handler. */
7157 static tree
7159 tree name,
7160 tree,
7163 {
7168 {
7171 name);
7173 }
7176 }
7178 /* Handle a "const" attribute; arguments as in
7179 struct attribute_spec.handler. */
7181 static tree
7184 {
7187 /* See FIXME comment on noreturn in c_common_attribute_table. */
7193 = (build_qualified_type
7194 (build_pointer_type
7198 else
7199 {
7202 }
7205 }
7207 /* Handle a "scalar_storage_order" attribute; arguments as in
7208 struct attribute_spec.handler. */
7210 static tree
7213 {
7215 tree type;
7223 {
7227 }
7230 {
7239 else
7240 {
7244 }
7247 {
7249 /* A type variant isn't good enough, since we don't want a cast
7250 to such a type to be removed as a no-op. */
7252 }
7256 }
7261 }
7263 /* Handle a "transparent_union" attribute; arguments as in
7264 struct attribute_spec.handler. */
7266 static tree
7270 {
7271 tree type;
7281 {
7282 /* Make sure that the first field will work for a transparent union.
7283 If the type isn't complete yet, leave the check to the code in
7284 finish_struct. */
7286 {
7292 }
7295 {
7296 /* If the type isn't complete yet, setting the flag
7297 on a variant wouldn't ever be checked. */
7301 /* build_duplicate_type doesn't work for C++. */
7305 /* A type variant isn't good enough, since we don't want a cast
7306 to such a type to be removed as a no-op. */
7308 }
7313 }
7315 ignored:
7318 }
7320 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
7321 get the requested priority for a constructor or destructor,
7322 possibly issuing diagnostics for invalid or reserved
7323 priorities. */
7325 static priority_type
7327 {
7328 HOST_WIDE_INT pri;
7329 tree arg;
7335 {
7338 else
7341 }
7358 {
7361 "destructor priorities from 0 to %d are reserved "
7363 MAX_RESERVED_INIT_PRIORITY);
7364 else
7366 "constructor priorities from 0 to %d are reserved "
7368 MAX_RESERVED_INIT_PRIORITY);
7369 }
7372 invalid:
7375 MAX_INIT_PRIORITY);
7376 else
7378 MAX_INIT_PRIORITY);
7380 }
7382 /* Handle a "constructor" attribute; arguments as in
7383 struct attribute_spec.handler. */
7385 static tree
7389 {
7396 {
7397 priority_type priority;
7402 }
7403 else
7404 {
7407 }
7410 }
7412 /* Handle a "destructor" attribute; arguments as in
7413 struct attribute_spec.handler. */
7415 static tree
7419 {
7426 {
7427 priority_type priority;
7432 }
7433 else
7434 {
7437 }
7440 }
7442 /* Nonzero if the mode is a valid vector mode for this architecture.
7443 This returns nonzero even if there is no hardware support for the
7444 vector mode, but we can emulate with narrower modes. */
7446 static int
7448 {
7450 machine_mode innermode;
7452 /* Doh! What's going on? */
7461 /* Hardware support. Woo hoo! */
7467 /* We should probably return 1 if requesting V4DI and we have no DI,
7468 but we have V2DI, but this is probably very unlikely. */
7470 /* If we have support for the inner mode, we can safely emulate it.
7471 We may not have V2DI, but me can emulate with a pair of DIs. */
7473 }
7476 /* Handle a "mode" attribute; arguments as in
7477 struct attribute_spec.handler. */
7479 static tree
7482 {
7490 else
7491 {
7496 tree typefm;
7501 {
7507 }
7509 /* Change this type to have a type with the specified mode.
7510 First check for the special modes. */
7523 else
7526 {
7529 }
7532 {
7535 }
7539 {
7571 }
7573 {
7576 }
7579 {
7584 {
7587 }
7591 else
7594 }
7595 else
7596 {
7597 /* For fixed-point modes, we need to test if the signness of type
7598 and the machine mode are consistent. */
7601 {
7604 }
7605 /* For fixed-point modes, we need to pass saturating info. */
7609 }
7612 {
7615 }
7617 {
7618 /* For enumeral types, copy the precision from the integer
7619 type returned above. If not an INTEGER_TYPE, we can't use
7620 this mode for this type. */
7622 {
7625 }
7628 {
7631 }
7632 else
7633 {
7634 /* We cannot build a type variant, as there's code that assumes
7635 that TYPE_MAIN_VARIANT has the same mode. This includes the
7636 debug generators. Instead, create a subrange type. This
7637 results in all of the enumeral values being emitted only once
7638 in the original, and the subtype gets them by reference. */
7641 else
7644 }
7645 }
7649 {
7652 }
7655 }
7658 }
7660 /* Handle a "section" attribute; arguments as in
7661 struct attribute_spec.handler. */
7663 static tree
7666 {
7670 {
7674 }
7679 {
7682 }
7685 {
7688 }
7693 {
7697 }
7699 /* The decl may have already been given a section attribute
7700 from a previous declaration. Ensure they match. */
7704 {
7707 }
7712 {
7715 }
7720 fail:
7723 }
7725 /* Check whether ALIGN is a valid user-specified alignment. If so,
7726 return its base-2 log; if not, output an error and return -1. If
7727 ALLOW_ZERO then 0 is valid and should result in a return of -1 with
7728 no error. */
7729 int
7731 {
7738 {
7741 }
7746 {
7749 }
7751 {
7754 }
7756 }
7758 /*
7759 If in c++-11, check if the c++-11 alignment constraint with respect
7760 to fundamental alignment (in [dcl.align]) are satisfied. If not in
7761 c++-11 mode, does nothing.
7763 [dcl.align]2/ says:
7765 [* if the constant expression evaluates to a fundamental alignment,
7766 the alignment requirement of the declared entity shall be the
7767 specified fundamental alignment.
7769 * if the constant expression evaluates to an extended alignment
7770 and the implementation supports that alignment in the context
7771 of the declaration, the alignment of the declared entity shall
7772 be that alignment
7774 * if the constant expression evaluates to an extended alignment
7775 and the implementation does not support that alignment in the
7776 context of the declaration, the program is ill-formed]. */
7778 static bool
7782 {
7795 {
7797 {
7798 /* For file scope variables and static members, the target
7799 supports alignments that are at most
7800 MAX_OFILE_ALIGNMENT. */
7803 }
7804 else
7805 {
7806 #ifdef BIGGEST_FIELD_ALIGNMENT
7807 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_FIELD_ALIGNMENT
7808 #else
7809 #define MAX_TARGET_FIELD_ALIGNMENT BIGGEST_ALIGNMENT
7810 #endif
7811 /* For non-static members, the target supports either
7812 alignments that at most either BIGGEST_FIELD_ALIGNMENT
7813 if it is defined or BIGGEST_ALIGNMENT. */
7818 #undef MAX_TARGET_FIELD_ALIGNMENT
7819 /* For stack variables, the target supports at most
7820 MAX_STACK_ALIGNMENT. */
7824 }
7825 }
7827 {
7828 /* Let's be liberal for types. */
7831 }
7839 }
7841 /* Handle a "aligned" attribute; arguments as in
7842 struct attribute_spec.handler. */
7844 static tree
7847 {
7851 tree align_expr;
7855 {
7860 }
7861 else
7865 {
7869 }
7877 {
7880 /* If we have a TYPE_DECL, then copy the type, so that we
7881 don't accidentally modify a builtin type. See pushdecl. */
7884 {
7891 }
7892 else
7897 }
7900 {
7903 }
7906 /* C++-11 [dcl.align/4]:
7908 When multiple alignment-specifiers are specified for an
7909 entity, the alignment requirement shall be set to the
7910 strictest specified alignment.
7912 This formally comes from the c++11 specification but we are
7913 doing it for the GNU attribute syntax as well. */
7917 {
7922 else
7926 }
7927 else
7928 {
7931 }
7934 }
7936 /* Handle a "weak" attribute; arguments as in
7937 struct attribute_spec.handler. */
7939 static tree
7944 {
7947 {
7950 }
7952 {
7956 }
7959 else
7963 }
7965 /* Handle a "noplt" attribute; arguments as in
7966 struct attribute_spec.handler. */
7968 static tree
7973 {
7975 {
7980 }
7982 }
7984 /* Handle an "alias" or "ifunc" attribute; arguments as in
7985 struct attribute_spec.handler, except that IS_ALIAS tells us
7986 whether this is an alias as opposed to ifunc attribute. */
7988 static tree
7991 {
7996 {
7999 }
8003 /* A static variable declaration is always a tentative definition,
8004 but the alias is a non-tentative definition which overrides. */
8007 {
8011 }
8015 {
8019 }
8021 /* Note that the very first time we process a nested declaration,
8022 decl_function_context will not be set. Indeed, *would* never
8023 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
8024 we do below. After such frobbery, pushdecl would set the context.
8025 In any case, this is never what we want. */
8027 {
8028 tree id;
8032 {
8036 }
8038 /* This counts as a use of the object pointed to. */
8043 else
8047 /* ifuncs are also aliases, so set that attribute too. */
8050 }
8051 else
8052 {
8055 }
8058 {
8061 {
8064 else
8066 }
8067 }
8071 }
8073 /* Handle an "alias" or "ifunc" attribute; arguments as in
8074 struct attribute_spec.handler. */
8076 static tree
8079 {
8081 }
8083 /* Handle an "alias" or "ifunc" attribute; arguments as in
8084 struct attribute_spec.handler. */
8086 static tree
8089 {
8091 }
8093 /* Handle a "weakref" attribute; arguments as in struct
8094 attribute_spec.handler. */
8096 static tree
8099 {
8102 /* We must ignore the attribute when it is associated with
8103 local-scoped decls, since attribute alias is ignored and many
8104 such symbols do not even have a DECL_WEAK field. */
8106 || current_function_decl
8108 {
8112 }
8115 {
8119 }
8121 /* The idea here is that `weakref("name")' mutates into `weakref,
8122 alias("name")', and weakref without arguments, in turn,
8123 implicitly adds weak. */
8126 {
8133 }
8134 else
8135 {
8140 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
8141 and that isn't supported; and because it wants to add it to
8142 the list of weak decls, which isn't helpful. */
8144 }
8147 {
8151 }
8154 }
8156 /* Handle an "visibility" attribute; arguments as in
8157 struct attribute_spec.handler. */
8159 static tree
8163 {
8169 {
8173 {
8175 name);
8177 }
8179 {
8183 }
8184 }
8186 {
8189 }
8192 {
8195 }
8197 /* If this is a type, set the visibility on the type decl. */
8199 {
8204 {
8206 name);
8208 }
8209 }
8219 else
8220 {
8221 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
8223 }
8227 {
8241 }
8246 /* Go ahead and attach the attribute to the node as well. This is needed
8247 so we can determine whether we have VISIBILITY_DEFAULT because the
8248 visibility was not specified, or because it was explicitly overridden
8249 from the containing scope. */
8252 }
8254 /* Determine the ELF symbol visibility for DECL, which is either a
8255 variable or a function. It is an error to use this function if a
8256 definition of DECL is not available in this translation unit.
8257 Returns true if the final visibility has been determined by this
8258 function; false if the caller is free to make additional
8259 modifications. */
8261 bool
8263 {
8266 /* If the user explicitly specified the visibility with an
8267 attribute, honor that. DECL_VISIBILITY will have been set during
8268 the processing of the attribute. We check for an explicit
8269 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
8270 to distinguish the use of an attribute from the use of a "#pragma
8271 GCC visibility push(...)"; in the latter case we still want other
8272 considerations to be able to overrule the #pragma. */
8274 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
8279 /* Set default visibility to whatever the user supplied with
8280 visibility_specified depending on #pragma GCC visibility. */
8282 {
8285 {
8288 /* If visibility changed and DECL already has DECL_RTL, ensure
8289 symbol flags are updated. */
8294 }
8295 }
8297 }
8299 /* Handle an "tls_model" attribute; arguments as in
8300 struct attribute_spec.handler. */
8302 static tree
8305 {
8306 tree id;
8313 {
8316 }
8321 {
8324 }
8334 else
8335 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
8339 }
8341 /* Handle a "no_instrument_function" attribute; arguments as in
8342 struct attribute_spec.handler. */
8344 static tree
8349 {
8353 {
8357 }
8358 else
8362 }
8364 /* Handle a "no_profile_instrument_function" attribute; arguments as in
8365 struct attribute_spec.handler. */
8367 static tree
8370 {
8372 {
8375 }
8378 }
8380 /* Handle a "malloc" attribute; arguments as in
8381 struct attribute_spec.handler. */
8383 static tree
8386 {
8390 else
8391 {
8394 }
8397 }
8399 /* Handle a "alloc_size" attribute; arguments as in
8400 struct attribute_spec.handler. */
8402 static tree
8405 {
8408 {
8415 || !arg_count
8417 {
8422 }
8423 }
8425 }
8427 /* Handle a "alloc_align" attribute; arguments as in
8428 struct attribute_spec.handler. */
8430 static tree
8433 {
8441 || !arg_count
8443 {
8448 }
8450 }
8452 /* Handle a "assume_aligned" attribute; arguments as in
8453 struct attribute_spec.handler. */
8455 static tree
8458 {
8460 {
8467 {
8472 }
8473 }
8475 }
8477 /* Handle a "fn spec" attribute; arguments as in
8478 struct attribute_spec.handler. */
8480 static tree
8484 {
8489 }
8491 /* Handle a "bnd_variable_size" attribute; arguments as in
8492 struct attribute_spec.handler. */
8494 static tree
8497 {
8499 {
8502 }
8505 }
8507 /* Handle a "bnd_legacy" attribute; arguments as in
8508 struct attribute_spec.handler. */
8510 static tree
8513 {
8515 {
8518 }
8521 }
8523 /* Handle a "bnd_instrument" attribute; arguments as in
8524 struct attribute_spec.handler. */
8526 static tree
8529 {
8531 {
8534 }
8537 }
8539 /* Handle a "warn_unused" attribute; arguments as in
8540 struct attribute_spec.handler. */
8542 static tree
8544 tree args ATTRIBUTE_UNUSED,
8546 {
8548 /* Do nothing else, just set the attribute. We'll get at
8549 it later with lookup_attribute. */
8550 ;
8551 else
8552 {
8555 }
8558 }
8560 /* Handle an "omp declare simd" attribute; arguments as in
8561 struct attribute_spec.handler. */
8563 static tree
8565 {
8567 }
8569 /* Handle a "simd" attribute. */
8571 static tree
8573 {
8575 {
8578 {
8580 "%<__simd__%> attribute cannot be used in the same "
8583 }
8584 else
8585 {
8589 {
8593 {
8597 }
8601 OMP_CLAUSE_NOTINBRANCH);
8602 else
8605 OMP_CLAUSE_INBRANCH);
8606 else
8607 {
8612 }
8613 }
8617 attr),
8619 }
8620 }
8621 else
8622 {
8625 }
8628 }
8630 /* Handle an "omp declare target" attribute; arguments as in
8631 struct attribute_spec.handler. */
8633 static tree
8635 {
8637 }
8639 /* Handle a "returns_twice" attribute; arguments as in
8640 struct attribute_spec.handler. */
8642 static tree
8645 {
8648 else
8649 {
8652 }
8655 }
8657 /* Handle a "no_limit_stack" attribute; arguments as in
8658 struct attribute_spec.handler. */
8660 static tree
8665 {
8669 {
8673 }
8675 {
8679 }
8680 else
8684 }
8686 /* Handle a "pure" attribute; arguments as in
8687 struct attribute_spec.handler. */
8689 static tree
8692 {
8695 /* ??? TODO: Support types. */
8696 else
8697 {
8700 }
8703 }
8705 /* Digest an attribute list destined for a transactional memory statement.
8706 ALLOWED is the set of attributes that are allowed for this statement;
8707 return the attribute we parsed. Multiple attributes are never allowed. */
8709 int
8711 {
8716 {
8724 {
8727 }
8730 {
8733 }
8736 else
8738 }
8741 }
8743 /* Transform a TM attribute name into a maskable integer and back.
8744 Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
8745 to how the lack of an attribute is treated. */
8747 int
8749 {
8763 }
8765 tree
8767 {
8770 {
8788 }
8790 }
8792 /* Return the first TM attribute seen in LIST. */
8794 tree
8796 {
8798 {
8802 }
8804 }
8806 /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
8807 Here we accept only function types, and verify that none of the other
8808 function TM attributes are also applied. */
8809 /* ??? We need to accept class types for C++, but not C. This greatly
8810 complicates this function, since we can no longer rely on the extra
8811 processing given by function_type_required. */
8813 static tree
8816 {
8817 /* Only one path adds the attribute; others don't. */
8821 {
8824 /* Only tm_callable and tm_safe apply to classes. */
8827 /* FALLTHRU */
8831 {
8834 ;
8837 else
8839 }
8843 {
8844 /* transaction_safe_dynamic goes on the FUNCTION_DECL, but we also
8845 want to set transaction_safe on the type. */
8849 "%<transaction_safe_dynamic%> may only be specified for "
8854 NULL_TREE),
8857 }
8860 {
8863 {
8868 }
8869 }
8870 /* FALLTHRU */
8873 /* If a function is next, pass it on to be tried next. */
8877 ignored:
8880 }
8883 }
8885 /* Handle the TM_WRAP attribute; arguments as in
8886 struct attribute_spec.handler. */
8888 static tree
8891 {
8894 /* We don't need the attribute even on success, since we
8895 record the entry in an external table. */
8900 else
8901 {
8904 ;
8908 else
8909 {
8913 {
8917 else
8919 }
8920 else
8922 }
8923 }
8926 }
8928 /* Ignore the given attribute. Used when this attribute may be usefully
8929 overridden by the target, but is not used generically. */
8931 static tree
8935 {
8938 }
8940 /* Handle a "no vops" attribute; arguments as in
8941 struct attribute_spec.handler. */
8943 static tree
8947 {
8951 }
8953 /* Handle a "deprecated" attribute; arguments as in
8954 struct attribute_spec.handler. */
8956 static tree
8960 {
8968 {
8971 }
8974 {
8985 else
8987 }
8989 {
8994 }
8995 else
8999 {
9002 {
9008 }
9011 else
9013 }
9016 }
9018 /* Handle a "vector_size" attribute; arguments as in
9019 struct attribute_spec.handler. */
9021 static tree
9025 {
9027 machine_mode orig_mode;
9038 {
9041 }
9043 /* Get the vector size (in bytes). */
9046 /* We need to provide for vector pointers, vector arrays, and
9047 functions returning vectors. For example:
9049 __attribute__((vector_size(16))) short *foo;
9051 In this case, the mode is SI, but the type being modified is
9052 HI, so we need to look further. */
9061 /* Get the mode of the type being modified. */
9072 {
9075 }
9078 {
9081 }
9084 {
9087 }
9089 /* Calculate how many units fit in the vector. */
9092 {
9095 }
9099 /* Build back pointers if needed. */
9103 }
9105 /* Handle the "nonnull" attribute. */
9106 static tree
9110 {
9114 /* If no arguments are specified, all pointer arguments should be
9115 non-null. Verify a full prototype is given so that the arguments
9116 will have the correct types when we actually check them later.
9117 Avoid diagnosing type-generic built-ins since those have no
9118 prototype. */
9120 {
9124 {
9127 }
9129 }
9131 /* Argument list specified. Verify that each argument number references
9132 a pointer argument. */
9134 {
9143 {
9148 }
9151 {
9152 function_args_iterator iter;
9153 tree argument;
9157 {
9161 }
9165 {
9170 }
9173 {
9178 }
9179 }
9180 }
9183 }
9185 /* Check the argument list of a function call for null in argument slots
9186 that are marked as requiring a non-null pointer argument. The NARGS
9187 arguments are passed in the array ARGARRAY. */
9189 static void
9191 {
9192 tree a;
9200 /* See if any of the nonnull attributes has no arguments. If so,
9201 then every pointer argument is checked (in which case the check
9202 for pointer type is done in check_nonnull_arg). */
9204 do
9212 else
9213 {
9214 /* Walk the argument list. If we encounter an argument number we
9215 should check for non-null, do it. */
9217 {
9219 {
9223 }
9228 }
9229 }
9230 }
9232 /* Check that the Nth argument of a function call (counting backwards
9233 from the end) is a (pointer)0. The NARGS arguments are passed in the
9234 array ARGARRAY. */
9236 static void
9238 {
9242 {
9245 tree sentinel;
9246 function_args_iterator iter;
9247 tree t;
9249 /* Skip over the named arguments. */
9251 {
9254 len++;
9255 }
9258 {
9261 }
9263 /* The sentinel must be one of the varargs, i.e.
9264 in position >= the number of fixed arguments. */
9266 {
9270 }
9272 /* Validate the sentinel. */
9276 /* Although __null (in C++) is only an integer we allow it
9277 nevertheless, as we are guaranteed that it's exactly
9278 as wide as a pointer, and we don't want to force
9279 users to cast the NULL they have written there.
9280 We warn with -Wstrict-null-sentinel, though. */
9283 }
9284 }
9286 /* Helper for check_function_nonnull; given a list of operands which
9287 must be non-null in ARGS, determine if operand PARAM_NUM should be
9288 checked. */
9290 static bool
9292 {
9296 {
9303 }
9305 }
9307 /* Check that the function argument PARAM (which is operand number
9308 PARAM_NUM) is non-null. This is called by check_function_nonnull
9309 via check_function_arguments_recurse. */
9311 static void
9313 {
9316 /* Just skip checking the argument if it's not a pointer. This can
9317 happen if the "nonnull" attribute was given without an operand
9318 list (which means to check every pointer argument). */
9326 }
9328 /* Helper for nonnull attribute handling; fetch the operand number
9329 from the attribute argument list. */
9331 static bool
9333 {
9334 /* Verify the arg number is a small constant. */
9336 {
9339 }
9340 else
9342 }
9344 /* Handle a "nothrow" attribute; arguments as in
9345 struct attribute_spec.handler. */
9347 static tree
9350 {
9353 /* ??? TODO: Support types. */
9354 else
9355 {
9358 }
9361 }
9363 /* Handle a "cleanup" attribute; arguments as in
9364 struct attribute_spec.handler. */
9366 static tree
9369 {
9373 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
9374 for global destructors in C++. This requires infrastructure that
9375 we don't have generically at the moment. It's also not a feature
9376 we'd be missing too much, since we do have attribute constructor. */
9378 {
9382 }
9384 /* Verify that the argument is a function in scope. */
9385 /* ??? We could support pointers to functions here as well, if
9386 that was considered desirable. */
9389 {
9393 }
9396 {
9400 }
9402 /* That the function has proper type is checked with the
9403 eventual call to build_function_call. */
9406 }
9408 /* Handle a "warn_unused_result" attribute. No special handling. */
9410 static tree
9414 {
9415 /* Ignore the attribute for functions not returning any value. */
9417 {
9420 }
9423 }
9425 /* Handle a "sentinel" attribute. */
9427 static tree
9430 {
9432 {
9436 }
9437 else
9438 {
9440 {
9444 }
9445 }
9448 {
9456 {
9460 }
9461 else
9462 {
9464 {
9468 }
9469 }
9470 }
9473 }
9475 /* Handle a "type_generic" attribute. */
9477 static tree
9481 {
9482 /* Ensure we have a function type. */
9485 /* Ensure we have a variadic function. */
9489 }
9491 /* Handle a "target" attribute. */
9493 static tree
9496 {
9497 /* Ensure we have a function type. */
9499 {
9502 }
9504 {
9508 }
9510 flags))
9514 }
9516 /* Handle a "target_clones" attribute. */
9518 static tree
9521 {
9522 /* Ensure we have a function type. */
9524 {
9526 {
9530 }
9532 {
9536 }
9537 else
9538 /* Do not inline functions with multiple clone targets. */
9540 }
9541 else
9542 {
9545 }
9547 }
9549 /* Arguments being collected for optimization. */
9554 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
9555 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
9556 false for #pragma GCC optimize. */
9558 bool
9560 {
9567 tree ap;
9569 /* Build up argv vector. Just in case the string is stored away, use garbage
9570 collected strings. */
9575 {
9579 {
9583 }
9586 {
9587 /* Split string into multiple substrings. */
9595 {
9602 {
9606 }
9607 else
9608 {
9611 }
9615 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
9616 options. */
9618 {
9623 else
9627 }
9630 {
9633 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
9634 itself is -Os, and any other switch begins with a -f. */
9640 }
9645 }
9647 }
9648 }
9656 /* Now parse the options. */
9660 /* Drop non-Optimization options. */
9663 {
9665 {
9671 else
9676 }
9679 j++;
9680 }
9682 /* And apply them. */
9691 }
9693 /* For handling "optimize" attribute. arguments as in
9694 struct attribute_spec.handler. */
9696 static tree
9699 {
9700 /* Ensure we have a function type. */
9702 {
9705 }
9706 else
9707 {
9711 /* Save current options. */
9714 /* If we previously had some optimization options, use them as the
9715 default. */
9720 /* Parse options, and update the vector. */
9725 /* Restore current options. */
9727 }
9730 }
9732 /* Handle a "no_split_stack" attribute. */
9734 static tree
9739 {
9743 {
9747 }
9749 {
9753 }
9756 }
9758 /* Handle a "returns_nonnull" attribute; arguments as in
9759 struct attribute_spec.handler. */
9761 static tree
9764 {
9765 // Even without a prototype we still have a return type we can check.
9767 {
9770 }
9772 }
9774 /* Handle a "designated_init" attribute; arguments as in
9775 struct attribute_spec.handler. */
9777 static tree
9780 {
9782 {
9785 }
9787 }
9789 \f
9790 /* Check for valid arguments being passed to a function with FNTYPE.
9791 There are NARGS arguments in the array ARGARRAY. LOC should be used for
9792 diagnostics. */
9793 void
9796 {
9797 /* Check for null being passed in a pointer argument that must be
9798 non-null. We also need to do this if format checking is enabled. */
9803 /* Check for errors in format strings. */
9810 }
9812 /* Generic argument checking recursion routine. PARAM is the argument to
9813 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
9814 once the argument is resolved. CTX is context for the callback. */
9815 void
9820 {
9824 {
9825 /* Strip coercion. */
9829 }
9832 {
9834 tree attrs;
9837 /* See if this is a call to a known internationalization function
9838 that modifies a format arg. Such a function may have multiple
9839 format_arg attributes (for example, ngettext). */
9842 attrs;
9845 {
9846 tree inner_arg;
9847 tree format_num_expr;
9850 call_expr_arg_iterator iter;
9852 /* Extract the argument number, which was previously checked
9853 to be valid. */
9862 {
9867 }
9868 }
9870 /* If we found a format_arg attribute and did a recursive check,
9871 we are done with checking this argument. Otherwise, we continue
9872 and this will be considered a non-literal. */
9875 }
9878 {
9879 /* Simplify to avoid warning for an impossible case. */
9882 {
9883 /* Check both halves of the conditional expression. */
9886 param_num);
9889 param_num);
9891 }
9892 }
9895 }
9897 /* Checks for a builtin function FNDECL that the number of arguments
9898 NARGS against the required number REQUIRED and issues an error if
9899 there is a mismatch. Returns true if the number of arguments is
9900 correct, otherwise false. LOC is the location of FNDECL. */
9902 static bool
9905 {
9907 {
9910 }
9912 {
9915 }
9917 }
9919 /* Helper macro for check_builtin_function_arguments. */
9920 #define ARG_LOCATION(N) \
9921 (arg_loc.is_empty () \
9922 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \
9923 : expansion_point_location (arg_loc[(N)]))
9925 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
9926 Returns false if there was an error, otherwise true. LOC is the
9927 location of the function; ARG_LOC is a vector of locations of the
9928 arguments. */
9930 bool
9933 {
9939 {
9941 {
9942 /* Get the requested alignment (in bits) if it's a constant
9943 integer expression. */
9944 unsigned HOST_WIDE_INT align
9947 /* Determine if the requested alignment is a power of 2. */
9951 /* The maximum alignment in bits corresponding to the same
9952 maximum in bytes enforced in check_user_alignment(). */
9955 /* Reject invalid alignments. */
9957 {
9959 "second argument to function %qE must be a constant "
9963 }
9965 }
9977 {
9979 {
9983 }
9985 }
9995 {
10002 {
10006 }
10008 }
10013 {
10016 {
10020 }
10023 {
10027 }
10029 }
10034 {
10036 {
10040 }
10042 }
10049 {
10053 {
10057 }
10060 {
10064 }
10066 {
10070 }
10072 {
10076 }
10078 }
10085 {
10089 {
10093 }
10095 {
10099 }
10101 {
10105 }
10107 }
10112 }
10113 }
10115 /* Function to help qsort sort FIELD_DECLs by name order. */
10117 int
10119 {
10124 /* A nontype is "greater" than a type. */
10133 }
10136 gt_pointer_operator new_value;
10140 /* This routine compares two fields like field_decl_cmp but using the
10141 pointer operator in resort_data. */
10143 static int
10145 {
10150 /* A nontype is "greater" than a type. */
10156 {
10163 }
10165 }
10167 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
10169 void
10172 gt_pointer_operator new_value,
10174 {
10179 resort_field_decl_cmp);
10180 }
10182 /* Subroutine of c_parse_error.
10183 Return the result of concatenating LHS and RHS. RHS is really
10184 a string literal, its first character is indicated by RHS_START and
10185 RHS_SIZE is its length (including the terminating NUL character).
10187 The caller is responsible for deleting the returned pointer. */
10191 {
10197 }
10199 /* Issue the error given by GMSGID, indicating that it occurred before
10200 TOKEN, which had the associated VALUE. */
10202 void
10205 {
10206 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
10217 {
10222 {
10238 }
10242 else
10248 }
10271 {
10276 }
10284 {
10289 }
10290 else
10294 {
10297 }
10298 #undef catenate_messages
10299 }
10301 /* Return the gcc option code associated with the reason for a cpp
10302 message, or 0 if none. */
10304 static int
10306 {
10310 {
10313 }
10315 }
10317 /* Callback from cpp_error for PFILE to print diagnostics from the
10318 preprocessor. The diagnostic is of type LEVEL, with REASON set
10319 to the reason code if LEVEL is represents a warning, at location
10320 RICHLOC unless this is after lexing and the compiler's location
10321 should be used instead; MSG is the translated message and AP
10322 the arguments. Returns true if a diagnostic was emitted, false
10323 otherwise. */
10325 bool
10329 {
10330 diagnostic_info diagnostic;
10331 diagnostic_t dlevel;
10336 {
10341 /* Fall through. */
10366 }
10377 }
10379 /* Convert a character from the host to the target execution character
10380 set. cpplib handles this, mostly. */
10382 HOST_WIDE_INT
10384 {
10385 /* Character constants in GCC proper are sign-extended under -fsigned-char,
10386 zero-extended under -fno-signed-char. cpplib insists that characters
10387 and character constants are always unsigned. Hence we must convert
10388 back and forth. */
10396 else
10398 }
10400 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
10401 references with an INDIRECT_REF of a constant at the bottom; much like the
10402 traditional rendering of offsetof as a macro. Return the folded result. */
10404 tree
10406 {
10410 {
10426 {
10429 }
10439 {
10443 }
10456 /* Check if the offset goes beyond the upper bound of the array. */
10458 {
10464 {
10469 {
10470 tree v;
10477 {
10485 }
10486 /* Don't warn if the array might be considered a poor
10487 man's flexible array member with a very permissive
10488 definition thereof. */
10492 "index %E denotes an offset "
10495 }
10496 }
10497 }
10504 /* Handle static members of volatile structs. */
10511 }
10514 }
10516 /* Likewise, but convert it to the return type of offsetof. */
10518 tree
10520 {
10522 }
10524 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
10525 expression, because B will always be true. */
10527 void
10529 {
10532 "the omitted middle operand in ?: will always be %<true%>, "
10534 }
10536 /* Give an error for storing into ARG, which is 'const'. USE indicates
10537 how ARG was being used. */
10539 void
10541 {
10544 /* Using this macro rather than (for example) arrays of messages
10545 ensures that all the format strings are checked at compile
10546 time. */
10547 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
10548 : (use == lv_increment ? (I) \
10549 : (use == lv_decrement ? (D) : (AS))))
10551 {
10562 else
10568 }
10574 arg);
10580 arg);
10582 {
10592 arg);
10593 }
10599 arg);
10600 else
10605 arg);
10606 }
10608 /* Print an error message for an invalid lvalue. USE says
10609 how the lvalue is being used and so selects the error message. LOC
10610 is the location for the error. */
10612 void
10614 {
10616 {
10634 }
10635 }
10637 /* Print an error message for an invalid indirection of type TYPE.
10638 ERRSTRING is the name of the operator for the indirection. */
10640 void
10642 {
10644 {
10652 type);
10657 type);
10662 type);
10667 type);
10672 type);
10676 }
10677 }
10678 \f
10679 /* *PTYPE is an incomplete array. Complete it with a domain based on
10680 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
10681 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10682 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
10684 int
10686 {
10694 {
10696 {
10697 int eltsize
10700 }
10702 {
10706 {
10710 }
10711 else
10712 {
10713 tree curindex;
10724 {
10728 else
10729 {
10731 {
10732 /* Since we treat size types now as ordinary
10733 unsigned types, we need an explicit overflow
10734 check. */
10738 }
10740 size_one_node);
10741 }
10744 }
10746 {
10750 }
10751 }
10752 }
10753 else
10754 {
10755 /* Make an error message unless that happened already. */
10758 }
10759 }
10760 else
10761 {
10765 }
10772 else
10775 /* Using build_distinct_type_copy and modifying things afterward instead
10776 of using build_array_type to create a new type preserves all of the
10777 TYPE_LANG_FLAG_? bits that the front end may have set. */
10785 /* Make sure we have the canonical MAIN_TYPE. */
10788 hashcode);
10791 /* Fix the canonical type. */
10801 else
10806 else
10812 {
10814 /* If we proceed with the array type as it is, we'll eventually
10815 crash in tree_to_[su]hwi(). */
10817 }
10821 }
10823 /* Like c_mark_addressable but don't check register qualifier. */
10824 void
10826 {
10832 }
10835 \f
10836 /* Used to help initialize the builtin-types.def table. When a type of
10837 the correct size doesn't exist, use error_mark_node instead of NULL.
10838 The later results in segfaults even when a decl using the type doesn't
10839 get invoked. */
10841 tree
10843 {
10846 }
10848 /* A helper function for resolve_overloaded_builtin in resolving the
10849 overloaded __sync_ builtins. Returns a positive power of 2 if the
10850 first operand of PARAMS is a pointer to a supported data type.
10851 Returns 0 if an error is encountered.
10852 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_
10853 built-ins. */
10855 static int
10857 {
10858 /* Type of the argument. */
10859 tree argtype;
10860 /* Type the argument points to. */
10861 tree type;
10865 {
10868 }
10872 {
10873 /* Force array-to-pointer decay for C++. */
10877 }
10892 incompatible:
10893 /* Issue the diagnostic only if the argument is valid, otherwise
10894 it would be redundant at best and could be misleading. */
10899 }
10901 /* A helper function for resolve_overloaded_builtin. Adds casts to
10902 PARAMS to make arguments match up with those of FUNCTION. Drops
10903 the variadic arguments at the end. Returns false if some error
10904 was encountered; true on success. */
10906 static bool
10909 {
10910 function_args_iterator iter;
10911 tree ptype;
10915 /* We've declared the implementation functions to use "volatile void *"
10916 as the pointer parameter, so we shouldn't get any complaints from the
10917 call to check_function_arguments what ever type the user used. */
10922 /* For the rest of the values, we need to cast these to FTYPE, so that we
10923 don't get warnings for passing pointer types, etc. */
10926 {
10930 /* XXX void_type_node belies the abstraction. */
10936 {
10939 }
10941 /* Only convert parameters if arg_type is unsigned integer type with
10942 new format sync routines, i.e. don't attempt to convert pointer
10943 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
10944 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
10945 kinds). */
10947 {
10948 /* Ideally for the first conversion we'd use convert_for_assignment
10949 so that we get warnings for anything that doesn't match the pointer
10950 type. This isn't portable across the C and C++ front ends atm. */
10955 }
10958 }
10960 /* __atomic routines are not variadic. */
10962 {
10965 }
10967 /* The definition of these primitives is variadic, with the remaining
10968 being "an optional list of variables protected by the memory barrier".
10969 No clue what that's supposed to mean, precisely, but we consider all
10970 call-clobbered variables to be protected so we're safe. */
10974 }
10976 /* A helper function for resolve_overloaded_builtin. Adds a cast to
10977 RESULT to make it match the type of the first pointer argument in
10978 PARAMS. */
10980 static tree
10982 {
10987 /* New format doesn't require casting unless the types are the same size. */
10990 else
10992 }
10994 /* This function verifies the PARAMS to generic atomic FUNCTION.
10995 It returns the size if all the parameters are the same size, otherwise
10996 0 is returned if the parameters are invalid. */
10998 static int
11001 {
11006 tree type_0;
11008 /* Determine the parameter makeup. */
11010 {
11026 }
11029 {
11032 }
11034 /* Get type of first parameter, and determine its size. */
11037 {
11038 /* Force array-to-pointer decay for C++. */
11042 }
11044 {
11046 function);
11048 }
11050 /* Types must be compile time constant sizes. */
11052 {
11055 function);
11057 }
11061 /* Zero size objects are not allowed. */
11063 {
11066 function);
11068 }
11070 /* Check each other parameter is a pointer and the same size. */
11072 {
11075 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
11079 {
11081 function);
11083 }
11087 {
11089 function);
11091 }
11092 }
11094 /* Check memory model parameters for validity. */
11096 {
11099 {
11102 {
11105 function);
11106 }
11107 }
11108 else
11110 {
11112 function);
11114 }
11115 }
11118 }
11121 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
11122 at the beginning of the parameter list PARAMS representing the size of the
11123 objects. This is to match the library ABI requirement. LOC is the location
11124 of the function call.
11125 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
11126 returned to allow the external call to be constructed. */
11128 static tree
11131 {
11132 tree size_node;
11134 /* Insert a SIZE_T parameter as the first param. If there isn't
11135 enough space, allocate a new vector and recursively re-build with that. */
11137 {
11140 tree f;
11150 }
11152 /* Add the size parameter and leave as a function call for processing. */
11156 }
11159 /* Return whether atomic operations for naturally aligned N-byte
11160 arguments are supported, whether inline or through libatomic. */
11161 static bool
11163 {
11165 {
11177 }
11178 }
11180 /* This will process an __atomic_exchange function call, determine whether it
11181 needs to be mapped to the _N variation, or turned into a library call.
11182 LOC is the location of the builtin call.
11183 FUNCTION is the DECL that has been invoked;
11184 PARAMS is the argument list for the call. The return value is non-null
11185 TRUE is returned if it is translated into the proper format for a call to the
11186 external library, and NEW_RETURN is set the tree for that function.
11187 FALSE is returned if processing for the _N variation is required, and
11188 NEW_RETURN is set to the return value the result is copied into. */
11189 static bool
11192 {
11197 /* Size of 0 is an error condition. */
11199 {
11202 }
11204 /* If not a lock-free size, change to the library generic format. */
11206 {
11209 }
11211 /* Otherwise there is a lockfree match, transform the call from:
11212 void fn(T* mem, T* desired, T* return, model)
11213 into
11214 *return = (T) (fn (In* mem, (In) *desired, model)) */
11221 /* Create pointer to appropriate size. */
11225 /* Convert object pointer to required type. */
11228 /* Convert new value to required type, and dereference it. */
11233 /* Move memory model to the 3rd position, and end param list. */
11237 /* Convert return pointer and dereference it for later assignment. */
11241 }
11244 /* This will process an __atomic_compare_exchange function call, determine
11245 whether it needs to be mapped to the _N variation, or turned into a lib call.
11246 LOC is the location of the builtin call.
11247 FUNCTION is the DECL that has been invoked;
11248 PARAMS is the argument list for the call. The return value is non-null
11249 TRUE is returned if it is translated into the proper format for a call to the
11250 external library, and NEW_RETURN is set the tree for that function.
11251 FALSE is returned if processing for the _N variation is required. */
11253 static bool
11257 {
11262 /* Size of 0 is an error condition. */
11264 {
11267 }
11269 /* If not a lock-free size, change to the library generic format. */
11271 {
11272 /* The library generic format does not have the weak parameter, so
11273 remove it from the param list. Since a parameter has been removed,
11274 we can be sure that there is room for the SIZE_T parameter, meaning
11275 there will not be a recursive rebuilding of the parameter list, so
11276 there is no danger this will be done twice. */
11278 {
11282 }
11285 }
11287 /* Otherwise, there is a match, so the call needs to be transformed from:
11288 bool fn(T* mem, T* desired, T* return, weak, success, failure)
11289 into
11290 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
11296 /* Create pointer to appropriate size. */
11300 /* Convert object pointer to required type. */
11304 /* Convert expected pointer to required type. */
11308 /* Convert desired value to required type, and dereference it. */
11313 /* The rest of the parameters are fine. NULL means no special return value
11314 processing.*/
11317 }
11320 /* This will process an __atomic_load function call, determine whether it
11321 needs to be mapped to the _N variation, or turned into a library call.
11322 LOC is the location of the builtin call.
11323 FUNCTION is the DECL that has been invoked;
11324 PARAMS is the argument list for the call. The return value is non-null
11325 TRUE is returned if it is translated into the proper format for a call to the
11326 external library, and NEW_RETURN is set the tree for that function.
11327 FALSE is returned if processing for the _N variation is required, and
11328 NEW_RETURN is set to the return value the result is copied into. */
11330 static bool
11333 {
11338 /* Size of 0 is an error condition. */
11340 {
11343 }
11345 /* If not a lock-free size, change to the library generic format. */
11347 {
11350 }
11352 /* Otherwise, there is a match, so the call needs to be transformed from:
11353 void fn(T* mem, T* return, model)
11354 into
11355 *return = (T) (fn ((In *) mem, model)) */
11361 /* Create pointer to appropriate size. */
11365 /* Convert object pointer to required type. */
11369 /* Move memory model to the 2nd position, and end param list. */
11373 /* Convert return pointer and dereference it for later assignment. */
11377 }
11380 /* This will process an __atomic_store function call, determine whether it
11381 needs to be mapped to the _N variation, or turned into a library call.
11382 LOC is the location of the builtin call.
11383 FUNCTION is the DECL that has been invoked;
11384 PARAMS is the argument list for the call. The return value is non-null
11385 TRUE is returned if it is translated into the proper format for a call to the
11386 external library, and NEW_RETURN is set the tree for that function.
11387 FALSE is returned if processing for the _N variation is required, and
11388 NEW_RETURN is set to the return value the result is copied into. */
11390 static bool
11393 {
11398 /* Size of 0 is an error condition. */
11400 {
11403 }
11405 /* If not a lock-free size, change to the library generic format. */
11407 {
11410 }
11412 /* Otherwise, there is a match, so the call needs to be transformed from:
11413 void fn(T* mem, T* value, model)
11414 into
11415 fn ((In *) mem, (In) *value, model) */
11420 /* Create pointer to appropriate size. */
11424 /* Convert object pointer to required type. */
11428 /* Convert new value to required type, and dereference it. */
11433 /* The memory model is in the right spot already. Return is void. */
11437 }
11440 /* Some builtin functions are placeholders for other expressions. This
11441 function should be called immediately after parsing the call expression
11442 before surrounding code has committed to the type of the expression.
11444 LOC is the location of the builtin call.
11446 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
11447 PARAMS is the argument list for the call. The return value is non-null
11448 when expansion is complete, and null if normal processing should
11449 continue. */
11451 tree
11454 {
11457 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
11458 Those are not valid to call with a pointer to _Bool (or C++ bool)
11459 and so must be rejected. */
11465 {
11471 else
11475 }
11477 /* Handle BUILT_IN_NORMAL here. */
11479 {
11484 {
11485 /* Handle these 4 together so that they can fall through to the next
11486 case if the call is transformed to an _N variant. */
11488 {
11490 {
11494 /* Change to the _N variant. */
11497 }
11500 {
11502 params,
11505 /* Change to the _N variant. */
11508 }
11510 {
11514 /* Change to the _N variant. */
11517 }
11519 {
11523 /* Change to the _N variant. */
11526 }
11529 }
11530 /* Fallthrough to the normal processing. */
11531 }
11536 {
11538 /* Fallthrough to further processing. */
11539 }
11552 {
11554 /* Fallthru for parameter processing. */
11555 }
11572 {
11573 /* The following are not _FETCH_OPs and must be accepted with
11574 pointers to _Bool (or C++ bool). */
11576 fetch_op =
11592 orig_format))
11597 NULL);
11607 /* Prevent -Wunused-value warning. */
11610 /* If new_return is set, assign function to that expr and cast the
11611 result to void since the generic interface returned void. */
11613 {
11614 /* Cast function result from I{1,2,4,8,16} to the required type. */
11617 result);
11621 }
11623 }
11627 }
11628 }
11630 /* vector_types_compatible_elements_p is used in type checks of vectors
11631 values used as operands of binary operators. Where it returns true, and
11632 the other checks of the caller succeed (being vector types in he first
11633 place, and matching number of elements), we can just treat the types
11634 as essentially the same.
11635 Contrast with vector_targets_convertible_p, which is used for vector
11636 pointer types, and vector_types_convertible_p, which will allow
11637 language-specific matches under the control of flag_lax_vector_conversions,
11638 and might still require a conversion. */
11639 /* True if vector types T1 and T2 can be inputs to the same binary
11640 operator without conversion.
11641 We don't check the overall vector size here because some of our callers
11642 want to give different error messages when the vectors are compatible
11643 except for the element count. */
11645 bool
11647 {
11660 /* Equality works here because c_common_signed_type uses
11661 TYPE_MAIN_VARIANT. */
11669 }
11671 /* Check for missing format attributes on function pointers. LTYPE is
11672 the new type or left-hand side type. RTYPE is the old type or
11673 right-hand side type. Returns TRUE if LTYPE is missing the desired
11674 attribute. */
11676 bool
11678 {
11680 tree ra;
11686 {
11687 tree la;
11692 }
11693 else
11695 }
11697 /* Subscripting with type char is likely to lose on a machine where
11698 chars are signed. So warn on any machine, but optionally. Don't
11699 warn for unsigned char since that type is safe. Don't warn for
11700 signed char because anyone who uses that must have done so
11701 deliberately. Furthermore, we reduce the false positive load by
11702 warning only for non-constant value of type char. */
11704 void
11706 {
11711 }
11713 /* Implement -Wparentheses for the unexpected C precedence rules, to
11714 cover cases like x + y << z which readers are likely to
11715 misinterpret. We have seen an expression in which CODE is a binary
11716 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
11717 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
11718 CODE_RIGHT may be ERROR_MARK, which means that that side of the
11719 expression was not formed using a binary or unary operator, or it
11720 was enclosed in parentheses. */
11722 void
11726 {
11730 /* This macro tests that the expression ARG with original tree code
11731 CODE appears to be a boolean expression. or the result of folding a
11732 boolean expression. */
11733 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
11734 (truth_value_p (TREE_CODE (ARG)) \
11735 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
11737 || ((CODE) != INTEGER_CST \
11738 && (integer_onep (ARG) || integer_zerop (ARG))))
11741 {
11790 /* Check cases like x|y==z */
11797 /* Check cases like !x | y */
11801 "suggest parentheses around operand of "
11814 /* Check cases like x^y==z */
11836 /* Check cases like x&y==z */
11843 /* Check cases like !x & y */
11847 "suggest parentheses around operand of "
11870 {
11875 "comparisons like %<X<=Y<=Z%> do not "
11881 "comparisons like %<X<=Y<=Z%> do not "
11883 }
11885 }
11886 #undef NOT_A_BOOLEAN_EXPR_P
11887 }
11889 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
11891 void
11893 {
11895 {
11898 else
11900 }
11901 }
11903 /* Warn for division by zero according to the value of DIVISOR. LOC
11904 is the location of the division operator. */
11906 void
11908 {
11909 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
11910 about division by zero. Do not issue a warning if DIVISOR has a
11911 floating-point type, since we consider 0.0/0.0 a valid way of
11912 generating a NaN. */
11916 }
11918 /* Warn for patterns where memset appears to be used incorrectly. The
11919 warning location should be LOC. ARG0, and ARG2 are the first and
11920 last arguments to the call, while LITERAL_ZERO_MASK has a 1 bit for
11921 each argument that was a literal zero. */
11923 void
11926 {
11932 "%<memset%> used with constant zero length "
11933 "parameter; this could be due to transposed "
11937 {
11943 {
11952 arg2,
11955 "%<memset%> used with length equal to "
11956 "number of elements without multiplication "
11958 }
11959 }
11960 }
11962 /* Subroutine of build_binary_op. Give warnings for comparisons
11963 between signed and unsigned quantities that may fail. Do the
11964 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
11965 so that casts will be considered, but default promotions won't
11966 be.
11968 LOCATION is the location of the comparison operator.
11970 The arguments of this function map directly to local variables
11971 of build_binary_op. */
11973 void
11978 {
11983 /* In C++, check for comparison of different enum types. */
11989 {
11993 }
11995 /* Do not warn if the comparison is being done in a signed type,
11996 since the signed type will only be chosen if it can represent
11997 all the values of the unsigned type. */
12000 /* Do not warn if both operands are unsigned. */
12003 else
12004 {
12010 else
12018 /* Do not warn if the signed quantity is an unsuffixed integer
12019 literal (or some static constant expression involving such
12020 literals or a conditional expression involving such literals)
12021 and it is non-negative. */
12024 /* Do not warn if the comparison is an equality operation, the
12025 unsigned quantity is an integral constant, and it would fit
12026 in the result if the result were signed. */
12031 /* In C, do not warn if the unsigned quantity is an enumeration
12032 constant and its maximum value would fit in the result if the
12033 result were signed. */
12039 else
12041 OPT_Wsign_compare,
12043 }
12045 /* Warn if two unsigned values are being compared in a size larger
12046 than their original size, and one (and only one) is the result of
12047 a `~' operator. This comparison will always fail.
12049 Also warn if one operand is a constant, and the constant does not
12050 have all bits set that are set in the ~ operand when it is
12051 extended. */
12058 {
12065 {
12066 tree primop;
12072 {
12076 }
12077 else
12078 {
12082 }
12087 {
12090 {
12094 else
12097 }
12098 }
12099 }
12107 }
12108 }
12110 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
12111 type via c_common_type. If -Wdouble-promotion is in use, and the
12112 conditions for warning have been met, issue a warning. GMSGID is
12113 the warning message. It must have two %T specifiers for the type
12114 that was converted (generally "float") and the type to which it was
12115 converted (generally "double), respectively. LOC is the location
12116 to which the awrning should refer. */
12118 void
12121 {
12122 tree source_type;
12126 /* If the conversion will not occur at run-time, there is no need to
12127 warn about it. */
12139 else
12142 }
12144 /* Possibly warn about unused parameters. */
12146 void
12148 {
12149 tree decl;
12158 }
12161 /* Setup a TYPE_DECL node as a typedef representation.
12163 X is a TYPE_DECL for a typedef statement. Create a brand new
12164 ..._TYPE node (which will be just a variant of the existing
12165 ..._TYPE node with identical properties) and then install X
12166 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
12168 The whole point here is to end up with a situation where each
12169 and every ..._TYPE node the compiler creates will be uniquely
12170 associated with AT MOST one node representing a typedef name.
12171 This way, even though the compiler substitutes corresponding
12172 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
12173 early on, later parts of the compiler can always do the reverse
12174 translation and get back the corresponding typedef name. For
12175 example, given:
12177 typedef struct S MY_TYPE;
12178 MY_TYPE object;
12180 Later parts of the compiler might only know that `object' was of
12181 type `struct S' if it were not for code just below. With this
12182 code however, later parts of the compiler see something like:
12184 struct S' == struct S
12185 typedef struct S' MY_TYPE;
12186 struct S' object;
12188 And they can then deduce (from the node for type struct S') that
12189 the original object declaration was:
12191 MY_TYPE object;
12193 Being able to do this is important for proper support of protoize,
12194 and also for generating precise symbolic debugging information
12195 which takes full account of the programmer's (typedef) vocabulary.
12197 Obviously, we don't want to generate a duplicate ..._TYPE node if
12198 the TYPE_DECL node that we are now processing really represents a
12199 standard built-in type. */
12201 void
12203 {
12207 {
12210 }
12213 {
12221 }
12222 }
12224 /* Record the types used by the current global variable declaration
12225 being parsed, so that we can decide later to emit their debug info.
12226 Those types are in types_used_by_cur_var_decl, and we are going to
12227 store them in the types_used_by_vars_hash hash table.
12228 DECL is the declaration of the global variable that has been parsed. */
12230 void
12232 {
12236 {
12239 }
12240 }
12242 /* If DECL is a typedef that is declared in the current function,
12243 record it for the purpose of -Wunused-local-typedefs. */
12245 void
12247 {
12252 /* if this is not a locally defined typedef then we are not
12253 interested. */
12260 }
12262 /* If T is a TYPE_DECL declared locally, mark it as used. */
12264 void
12266 {
12271 }
12273 /* Warn if there are some unused locally defined typedefs in the
12274 current function. */
12276 void
12278 {
12280 tree decl;
12281 /* The number of times we have emitted -Wunused-local-typedefs
12282 warnings. If this is different from errorcount, that means some
12283 unrelated errors have been issued. In which case, we'll avoid
12284 emitting "unused-local-typedefs" warnings. */
12296 {
12300 OPT_Wunused_local_typedefs,
12303 }
12306 }
12308 /* Warn about boolean expression compared with an integer value different
12309 from true/false. Warns also e.g. about "(i1 == i2) == 2".
12310 LOC is the location of the comparison, CODE is its code, OP0 and OP1
12311 are the operands of the comparison. The caller must ensure that
12312 either operand is a boolean expression. */
12314 void
12316 tree op1)
12317 {
12328 else
12332 {
12340 else
12343 }
12345 {
12346 /* If the non-constant operand isn't of a boolean type, we
12347 don't want to warn here. */
12349 /* Handle booleans promoted to integers. */
12357 /* Do some magic to get the right diagnostics. */
12366 }
12367 }
12369 /* Warn if signed left shift overflows. We don't warn
12370 about left-shifting 1 into the sign bit in C++14; cf.
12371 <http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3367.html#1457>
12372 LOC is a location of the shift; OP0 and OP1 are the operands.
12373 Return true if an overflow is detected, false otherwise. */
12375 bool
12377 {
12385 /* Left-hand operand must be signed. */
12391 /* Handle the case of left-shifting 1 into the sign bit.
12392 * However, shifting 1 _out_ of the sign bit, as in
12393 * INT_MIN << 1, is considered an overflow.
12394 */
12396 {
12397 /* Never warn for C++14 onwards. */
12400 /* Otherwise only if -Wshift-overflow=2. But return
12401 true to signal an overflow for the sake of integer
12402 constant expressions. */
12405 }
12410 "result of %qE requires %u bits to represent, "
12416 }
12418 /* The C and C++ parsers both use vectors to hold function arguments.
12419 For efficiency, we keep a cache of unused vectors. This is the
12420 cache. */
12425 /* Return a new vector from the cache. If the cache is empty,
12426 allocate a new vector. These vectors are GC'ed, so it is OK if the
12427 pointer is not released.. */
12431 {
12434 else
12435 {
12436 /* Passing 0 to vec::alloc returns NULL, and our callers require
12437 that we always return a non-NULL value. The vector code uses
12438 4 when growing a NULL vector, so we do too. */
12442 }
12443 }
12445 /* Release a vector of trees back to the cache. */
12447 void
12449 {
12451 {
12454 }
12455 }
12457 /* Get a new tree vector holding a single tree. */
12461 {
12465 }
12467 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
12471 {
12476 }
12478 /* Get a new tree vector which is a copy of an existing one. */
12482 {
12485 tree t;
12492 }
12494 /* Return true if KEYWORD starts a type specifier. */
12496 bool
12498 {
12500 {
12534 }
12535 }
12537 /* Return true if KEYWORD names a type qualifier. */
12539 bool
12541 {
12543 {
12551 }
12552 }
12554 /* Return true if KEYWORD names a storage class specifier.
12556 RID_TYPEDEF is not included in this list despite `typedef' being
12557 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
12558 such for syntactic convenience only. */
12560 bool
12562 {
12564 {
12574 }
12575 }
12577 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
12579 static bool
12581 {
12583 {
12591 }
12592 }
12594 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
12595 declaration-specifier (C99 6.7). */
12597 bool
12599 {
12606 {
12613 }
12614 }
12616 /* Initialize language-specific-bits of tree_contains_struct. */
12618 void
12620 {
12624 }
12626 /* Build a user-defined numeric literal out of an integer constant type VALUE
12627 with identifier SUFFIX. */
12629 tree
12632 {
12639 }
12641 /* For vector[index], convert the vector to an array of the underlying type.
12642 Return true if the resulting ARRAY_REF should not be an lvalue. */
12644 bool
12647 {
12650 {
12660 /* We are building an ARRAY_REF so mark the vector as addressable
12661 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P
12662 for function parameters. */
12669 }
12671 }
12673 /* Determine which of the operands, if any, is a scalar that needs to be
12674 converted to a vector, for the range of operations. */
12675 enum stv_conv
12678 {
12686 {
12687 /* Most GENERIC binary expressions require homogeneous arguments.
12688 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
12689 argument that is a vector and a second one that is a scalar, so
12690 we never return stv_secondarg for them. */
12695 {
12697 {
12702 }
12703 else
12705 }
12712 /* ... fall through ... */
12733 /* What about UNLT_EXPR? */
12735 {
12739 }
12743 {
12745 {
12750 }
12752 }
12754 /* Allow integer --> real conversion if safe. */
12758 {
12760 {
12765 }
12767 }
12770 }
12773 }
12775 /* Return true iff ALIGN is an integral constant that is a fundamental
12776 alignment, as defined by [basic.align] in the c++-11
12777 specifications.
12779 That is:
12781 [A fundamental alignment is represented by an alignment less than or
12782 equal to the greatest alignment supported by the implementation
12783 in all contexts, which is equal to
12784 alignof(max_align_t)]. */
12786 bool
12788 {
12791 }
12793 /* Return true if T is a pointer to a zero-sized aggregate. */
12795 bool
12797 {
12802 }
12804 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
12805 with no library fallback or for an ADDR_EXPR whose operand is such type
12806 issues an error pointing to the location LOC.
12807 Returns true when the expression has been diagnosed and false
12808 otherwise. */
12809 bool
12811 {
12818 /* The intersection of DECL_BUILT_IN and DECL_IS_BUILTIN avoids
12819 false positives for user-declared built-ins such as abs or
12820 strlen, and for C++ operators new and delete.
12821 The c_decl_implicit() test avoids false positives for implicitly
12822 declared built-ins with library fallbacks (such as abs). */
12827 {
12831 /* Reject arguments that are built-in functions with
12832 no library fallback. */
12836 }
12839 }
12841 /* If we're creating an if-else-if condition chain, first see if we
12842 already have this COND in the CHAIN. If so, warn and don't add COND
12843 into the vector, otherwise add the COND there. LOC is the location
12844 of COND. */
12846 void
12848 {
12849 /* No chain has been created yet. Do nothing. */
12854 {
12855 /* Uh-oh! This condition has a side-effect, thus invalidates
12856 the whole chain. */
12860 }
12863 tree t;
12867 {
12873 }
12877 /* Don't infinitely grow the chain. */
12880 }
12882 /* Check if array size calculations overflow or if the array covers more
12883 than half of the address space. Return true if the size of the array
12884 is valid, false otherwise. TYPE is the type of the array and NAME is
12885 the name of the array, or NULL_TREE for unnamed arrays. */
12887 bool
12889 {
12894 {
12897 else
12900 }
12902 }
12904 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
12905 timestamp to replace embedded current dates to get reproducible
12906 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
12908 time_t
12910 {
12920 #if defined(INT64_T_IS_LONG)
12922 #else
12924 #endif
12927 {
12930 MAX_SOURCE_DATE_EPOCH);
12932 }
12935 }
12937 /* Check and possibly warn if two declarations have contradictory
12938 attributes, such as always_inline vs. noinline. */
12940 bool
12942 {
12947 /* An optimization attribute applied on a declaration after the
12948 definition is likely not what the user wanted. */
12953 "optimization attribute on %qD follows "
12955 newdecl);
12957 /* Diagnose inline __attribute__ ((noinline)) which is silly. */
12989 }