| blob | b7586312537bcd539d99337e0ddc8944b5787ad7 |
1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992-2024 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
22 #define INCLUDE_MEMORY
61 /* Mode used to build pointers (VOIDmode means ptr_mode). */
65 /* The following symbols are subsumed in the c_global_trees array, and
66 listed here individually for documentation purposes.
68 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
70 tree short_integer_type_node;
71 tree long_integer_type_node;
72 tree long_long_integer_type_node;
74 tree short_unsigned_type_node;
75 tree long_unsigned_type_node;
76 tree long_long_unsigned_type_node;
78 tree truthvalue_type_node;
79 tree truthvalue_false_node;
80 tree truthvalue_true_node;
82 tree ptrdiff_type_node;
84 tree unsigned_char_type_node;
85 tree signed_char_type_node;
86 tree wchar_type_node;
88 tree char8_type_node;
89 tree char16_type_node;
90 tree char32_type_node;
92 tree float_type_node;
93 tree double_type_node;
94 tree long_double_type_node;
96 tree complex_integer_type_node;
97 tree complex_float_type_node;
98 tree complex_double_type_node;
99 tree complex_long_double_type_node;
101 tree dfloat32_type_node;
102 tree dfloat64_type_node;
103 tree dfloat128_type_node;
104 tree dfloat64x_type_node;
106 tree intQI_type_node;
107 tree intHI_type_node;
108 tree intSI_type_node;
109 tree intDI_type_node;
110 tree intTI_type_node;
112 tree unsigned_intQI_type_node;
113 tree unsigned_intHI_type_node;
114 tree unsigned_intSI_type_node;
115 tree unsigned_intDI_type_node;
116 tree unsigned_intTI_type_node;
118 tree widest_integer_literal_type_node;
119 tree widest_unsigned_literal_type_node;
121 Nodes for types `void *' and `const void *'.
123 tree ptr_type_node, const_ptr_type_node;
125 Nodes for types `char *' and `const char *'.
127 tree string_type_node, const_string_type_node;
129 Type `char[SOMENUMBER]'.
130 Used when an array of char is needed and the size is irrelevant.
132 tree char_array_type_node;
134 Type `wchar_t[SOMENUMBER]' or something like it.
135 Used when a wide string literal is created.
137 tree wchar_array_type_node;
139 Type `char8_t[SOMENUMBER]' or something like it.
140 Used when a UTF-8 string literal is created.
142 tree char8_array_type_node;
144 Type `char16_t[SOMENUMBER]' or something like it.
145 Used when a UTF-16 string literal is created.
147 tree char16_array_type_node;
149 Type `char32_t[SOMENUMBER]' or something like it.
150 Used when a UTF-32 string literal is created.
152 tree char32_array_type_node;
154 Type `int ()' -- used for implicit declaration of functions.
156 tree default_function_type;
158 A VOID_TYPE node, packaged in a TREE_LIST.
160 tree void_list_node;
162 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
163 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
164 VAR_DECLS, but C++ does.)
166 tree function_name_decl_node;
167 tree pretty_function_name_decl_node;
168 tree c99_function_name_decl_node;
170 Stack of nested function name VAR_DECLs.
172 tree saved_function_name_decls;
174 */
177 \f
178 /* Switches common to the C front ends. */
180 /* Nonzero means don't output line number information. */
184 /* Nonzero causes -E output not to be done, but directives such as
185 #define that have side effects are still obeyed. */
189 /* Nonzero means dump macros in some fashion. */
193 /* Nonzero means pass #include lines through to the output. */
197 /* Nonzero means process PCH files while preprocessing. */
201 /* The file name to which we should write a precompiled header, or
202 NULL if no header will be written in this compile. */
206 /* Nonzero if an ISO standard was selected. It rejects macros in the
207 user's namespace. */
210 /* C/ObjC language option variables. */
213 /* Nonzero means allow type mismatches in conditional expressions;
214 just make their values `void'. */
218 /* Nonzero means enable C89 Amendment 1 features. */
222 /* Nonzero means use the ISO C99 (or later) dialect of C. */
226 /* Nonzero means use the ISO C11 (or later) dialect of C. */
230 /* Nonzero means use the ISO C23 (or later) dialect of C. */
234 /* Nonzero means use the ISO C2Y (or later) dialect of C. */
238 /* Nonzero means that we have builtin functions, and main is an int. */
243 /* ObjC language option variables. */
246 /* Tells the compiler that this is a special run. Do not perform any
247 compiling, instead we are to test some platform dependent features
248 and output a C header file with appropriate definitions. */
252 /* Tells the compiler what is the constant string class for ObjC. */
257 /* C++ language option variables. */
259 /* The reference version of the ABI for -Wabi. */
263 /* The C++ dialect being used. Default set in c_common_post_options. */
267 /* Maximum template instantiation depth. This limit exists to limit the
268 time it takes to notice excessively recursive template instantiations.
270 The default is lower than the 1024 recommended by the C++0x standard
271 because G++ runs out of stack before 1024 with highly recursive template
272 argument deduction substitution (g++.dg/cpp0x/enum11.C). */
276 /* The elements of `ridpointers' are identifier nodes for the reserved
277 type names and storage classes. It is indexed by a RID_... value. */
282 /* Nonzero means don't warn about problems that occur when the code is
283 executed. */
286 /* Whether we are building a boolean conversion inside
287 convert_for_assignment, or some other late binary operation. If
288 build_binary_op is called for C (from code shared by C and C++) in
289 this case, then the operands have already been folded and the
290 result will not be folded again, so C_MAYBE_CONST_EXPR should not
291 be generated. */
294 /* Depending on which phase of processing we are in, we may need
295 to prefer input_location to libcpp's locations. (Specifically,
296 after the C++ lexer is done lexing tokens, but prior to calling
297 cpp_finish (), we need to do so. */
300 /* Information about how a function name is generated. */
301 struct fname_var_t
302 {
306 };
308 /* The three ways of getting then name of the current function. */
311 {
312 /* C99 compliant __func__, must be first. */
314 /* GCC __FUNCTION__ compliant. */
316 /* GCC __PRETTY_FUNCTION__ compliant. */
319 };
321 /* Flags to restrict availability of generic features that
322 are known to __has_{feature,extension}. */
324 enum
325 {
329 };
331 /* Info for generic features which can be queried through
332 __has_{feature,extension}. */
334 struct hf_feature_info
335 {
339 };
341 /* Table of generic features which can be queried through
342 __has_{feature,extension}. */
345 {
357 };
359 /* Global visibility options. */
368 /* Reserved words. The third field is a mask: keywords are disabled
369 if they match the mask.
371 Masks for languages:
372 C --std=c89: D_C99 | D_C23 | D_CXXONLY | D_OBJC | D_CXX_OBJC
373 C --std=c99: D_C23 | D_CXXONLY | D_OBJC
374 C --std=c17: D_C23 | D_CXXONLY | D_OBJC
375 C --std=c23: D_CXXONLY | D_OBJC
376 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
377 C++ --std=c++98: D_CONLY | D_CXX11 | D_CXX20 | D_OBJC
378 C++ --std=c++11: D_CONLY | D_CXX20 | D_OBJC
379 C++ --std=c++20: D_CONLY | D_OBJC
380 ObjC++ is like C++ except that D_OBJC is not set
382 If -fno-asm is used, D_ASM is added to the mask. If
383 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
384 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
385 In C with -Wc++-compat, we warn if D_CXXWARN is set.
387 Note the complication of the D_CXX_OBJC keywords. These are
388 reserved words such as 'class'. In C++, 'class' is a reserved
389 word. In Objective-C++ it is too. In Objective-C, it is a
390 reserved word too, but only if it follows an '@' sign.
391 */
393 {
576 /* C++ transactional memory. */
582 /* Concepts-related keywords */
586 /* Modules-related keywords, these are internal unspellable tokens,
587 created by the preprocessor. */
592 /* Coroutines-related keywords */
597 /* These Objective-C keywords are recognized only immediately after
598 an '@'. */
614 /* These are recognized only in protocol-qualifier context
615 (see above) */
622 /* These are recognized inside a property attribute list */
632 /* These are Objective C implementation of nullability, accepted only in
633 specific contexts. */
638 };
642 /* Return identifier for address space AS. */
646 {
650 }
652 /* Push current bindings for the function name VAR_DECLS. */
654 void
656 {
661 {
665 {
667 saved);
669 }
670 }
672 /* Normally they'll have been NULL, so only push if we've got a
673 stack, or they are non-NULL. */
675 saved_function_name_decls);
676 }
678 /* Finish up the current bindings, adding them into the current function's
679 statement tree. This must be done _before_ finish_stmt_tree is called.
680 If there is no current function, we must be at file scope and no statements
681 are involved. Pop the previous bindings. */
683 void
685 {
694 {
702 }
708 {
709 /* We had saved values, restore them. */
710 tree saved;
713 {
718 }
720 }
722 }
724 /* Return the text name of the current function, suitably prettified
725 by PRETTY_P. Return string must be freed by caller. */
729 {
736 {
739 }
752 {
755 }
758 }
760 /* Return the VAR_DECL for a const char array naming the current
761 function. If the VAR_DECL has not yet been created, create it
762 now. RID indicates how it should be formatted and IDENTIFIER_NODE
763 ID is its name (unfortunately C and C++ hold the RID values of
764 keywords in different places, so we can't derive RID from ID in
765 this language independent code. LOC is the location of the
766 function. */
768 tree
770 {
780 {
781 /* If a tree is built here, it would normally have the lineno of
782 the current statement. Later this tree will be moved to the
783 beginning of the function and this line number will be wrong.
784 To avoid this problem set the lineno to 0 here; that prevents
785 it from appearing in the RTL. */
786 tree stmts;
794 saved_function_name_decls
798 }
803 }
805 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
807 tree
809 {
814 /* Compute the number of elements, for the array type. */
816 {
819 }
821 {
824 }
826 {
829 }
831 {
834 }
835 else
836 {
839 }
841 /* This matters only for targets where ssizetype has smaller precision
842 than 32 bits. */
844 {
851 }
854 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
855 limit in C++98 Annex B is very large (65536) and is not normative,
856 so we do not diagnose it (warn_overlength_strings is forced off
857 in c_common_post_options). */
859 {
863 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
864 separate the %d from the 'C'. 'ISO' should not be
865 translated, but it may be moved after 'C%d' in languages
866 where modifiers follow nouns. */
868 "string length %qd is greater than the length %qd "
871 }
873 /* Create the array type for the string constant. The ISO C++
874 standard says that a string literal has type `const char[N]' or
875 `const wchar_t[N]'. We use the same logic when invoked as a C
876 front-end with -Wwrite-strings.
877 ??? We should change the type of an expression depending on the
878 state of a warning flag. We should just be warning -- see how
879 this is handled in the C++ front-end for the deprecated implicit
880 conversion from string literals to `char*' or `wchar_t*'.
882 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
883 array type being the unqualified version of that type.
884 Therefore, if we are constructing an array of const char, we must
885 construct the matching unqualified array type first. The C front
886 end does not require this, but it does no harm, so we do it
887 unconditionally. */
898 }
900 /* Given a string of type STRING_TYPE, determine what kind of string
901 token would give an equivalent execution encoding: CPP_STRING,
902 CPP_STRING16, or CPP_STRING32. Return CPP_OTHER in case of error.
903 This may not be exactly the string token type that initially created
904 the string, since CPP_WSTRING is indistinguishable from the 16/32 bit
905 string type, and CPP_UTF8STRING is indistinguishable from CPP_STRING
906 at this point.
908 This effectively reverses part of the logic in lex_string and
909 fix_string_type. */
911 static enum cpp_ttype
913 {
927 {
934 }
937 }
939 /* The global record of string concatentations, for use in
940 extracting locations within string literals. */
944 /* Implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */
949 {
950 enum cpp_ttype tok_type
957 g_string_concat_db,
959 tok_type,
963 out_loc);
964 }
966 \f
967 /* Return true iff T is a boolean promoted to int. */
969 bool
971 {
975 }
977 /* vector_targets_convertible_p is used for vector pointer types. The
978 callers perform various checks that the qualifiers are satisfactory,
979 while OTOH vector_targets_convertible_p ignores the number of elements
980 in the vectors. That's fine with vector pointers as we can consider,
981 say, a vector of 8 elements as two consecutive vectors of 4 elements,
982 and that does not require and conversion of the pointer values.
983 In contrast, vector_types_convertible_p and
984 vector_types_compatible_elements_p are used for vector value types. */
985 /* True if pointers to distinct types T1 and T2 can be converted to
986 each other without an explicit cast. Only returns true for opaque
987 vector types. */
988 bool
990 {
997 }
999 /* vector_types_convertible_p is used for vector value types.
1000 It could in principle call vector_targets_convertible_p as a subroutine,
1001 but then the check for vector type would be duplicated with its callers,
1002 and also the purpose of vector_targets_convertible_p would become
1003 muddled.
1004 Where vector_types_convertible_p returns true, a conversion might still be
1005 needed to make the types match.
1006 In contrast, vector_targets_convertible_p is used for vector pointer
1007 values, and vector_types_compatible_elements_p is used specifically
1008 in the context for binary operators, as a check if use is possible without
1009 conversion. */
1010 /* True if vector types T1 and T2 can be converted to each other
1011 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1012 can only be converted with -flax-vector-conversions yet that is not
1013 in effect, emit a note telling the user about that option if such
1014 a note has not previously been emitted. */
1015 bool
1017 {
1025 convertible_lax =
1041 {
1044 "conversions between vectors with differing "
1046 }
1049 }
1051 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
1052 and have vector types, V0 has the same type as V1, and the number of
1053 elements of V0, V1, MASK is the same.
1055 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
1056 called with two arguments. In this case implementation passes the
1057 first argument twice in order to share the same tree code. This fact
1058 could enable the mask-values being twice the vector length. This is
1059 an implementation accident and this semantics is not guaranteed to
1060 the user. */
1061 tree
1064 {
1065 tree ret;
1071 {
1074 }
1082 {
1087 }
1091 {
1095 }
1098 {
1103 }
1109 {
1112 "argument vector(s) and the mask vector should "
1115 }
1119 {
1124 }
1127 {
1128 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1134 else
1135 {
1138 }
1142 }
1152 }
1154 /* Build a VEC_PERM_EXPR if V0, V1 are not error_mark_nodes
1155 and have vector types, V0 has the same element type as V1, and the
1156 number of elements the result is that of MASK. */
1157 tree
1160 {
1161 tree ret;
1170 {
1174 }
1176 /* ??? In principle one could select a constant part of a variable size
1177 vector but things get a bit awkward with trying to support this here. */
1181 {
1186 }
1190 {
1195 }
1198 {
1203 }
1206 {
1207 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR. */
1213 }
1220 {
1223 {
1228 }
1233 {
1238 }
1239 /* ??? Our VEC_PERM_EXPR does not allow for -1 yet. */
1242 /* ??? Our VEC_PERM_EXPR does not allow different sized inputs,
1243 so pad out a smaller v0. */
1247 }
1248 /* ??? VEC_PERM_EXPR does not support a result that is smaller than
1249 the inputs, so we have to pad id out. */
1258 maskl);
1259 /* Pad out arguments to the common vector size. */
1261 {
1266 }
1268 {
1273 }
1276 /* Get the lowpart we are interested in. */
1278 {
1282 /* Wrap the lowpart operation in a TARGET_EXPR so it gets a separate
1283 temporary during gimplification. See PR101530 for cases where
1284 we'd otherwise end up with non-toplevel BIT_FIELD_REFs. */
1289 }
1295 }
1297 /* Build a VEC_CONVERT ifn for __builtin_convertvector builtin. */
1299 tree
1302 {
1311 {
1316 }
1320 {
1325 }
1329 {
1332 "of the first argument vector and the second argument "
1335 }
1347 tree ret;
1349 {
1350 /* Avoid C_MAYBE_CONST_EXPRs inside of VEC_CONVERT argument. */
1353 }
1361 }
1363 /* Like tree.cc:get_narrower, but retain conversion from C++0x scoped enum
1364 to integral type. */
1366 tree
1368 {
1373 {
1374 /* C++0x scoped enumerations don't implicitly convert to integral
1375 type; if we stripped an explicit conversion to a larger type we
1376 need to replace it so common_type will still work. */
1380 }
1382 }
1384 /* This is a helper function of build_binary_op.
1386 For certain operations if both args were extended from the same
1387 smaller type, do the arithmetic in that type and then extend.
1389 BITWISE indicates a bitwise operation.
1390 For them, this optimization is safe only if
1391 both args are zero-extended or both are sign-extended.
1392 Otherwise, we might change the result.
1393 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1394 but calculated in (unsigned short) it would be (unsigned short)-1.
1395 */
1396 tree
1398 {
1402 tree type;
1404 /* Do not shorten vector operations. */
1408 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1409 excessive narrowing when we call get_narrower below. For
1410 example, suppose that OP0 is of unsigned int extended
1411 from signed char and that RESULT_TYPE is long long int.
1412 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1413 like
1415 (long long int) (unsigned int) signed_char
1417 which get_narrower would narrow down to
1419 (unsigned int) signed char
1421 If we do not cast OP0 first, get_narrower would return
1422 signed_char, which is inconsistent with the case of the
1423 explicit cast. */
1430 /* UNS is 1 if the operation to be done is an unsigned one. */
1433 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1434 but it *requires* conversion to FINAL_TYPE. */
1445 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1447 /* For bitwise operations, signedness of nominal type
1448 does not matter. Consider only how operands were extended. */
1452 /* Note that in all three cases below we refrain from optimizing
1453 an unsigned operation on sign-extended args.
1454 That would not be valid. */
1456 /* Both args variable: if both extended in same way
1457 from same width, do it in that width.
1458 Do it unsigned if args were zero-extended. */
1465 {
1469 }
1475 && (type
1486 && (type
1494 }
1496 /* Returns true iff any integer value of type FROM_TYPE can be represented as
1497 real of type TO_TYPE. This is a helper function for unsafe_conversion_p. */
1499 static bool
1501 {
1504 REAL_VALUE_TYPE real_low_bound =
1506 REAL_VALUE_TYPE real_high_bound =
1511 }
1513 /* Checks if expression EXPR of complex/real/integer type cannot be converted
1514 to the complex/real/integer type TYPE. Function returns non-zero when:
1515 * EXPR is a constant which cannot be exactly converted to TYPE.
1516 * EXPR is not a constant and size of EXPR's type > than size of TYPE,
1517 for EXPR type and TYPE being both integers or both real, or both
1518 complex.
1519 * EXPR is not a constant of complex type and TYPE is a real or
1520 an integer.
1521 * EXPR is not a constant of real type and TYPE is an integer.
1522 * EXPR is not a constant of integer type which cannot be
1523 exactly converted to real type.
1525 Function allows conversions between types of different signedness if
1526 CHECK_SIGN is false and can return SAFE_CONVERSION (zero) in that
1527 case. Function can return UNSAFE_SIGN if CHECK_SIGN is true.
1529 RESULT, when non-null is the result of the conversion. When constant
1530 it is included in the text of diagnostics.
1532 Function allows conversions from complex constants to non-complex types,
1533 provided that imaginary part is zero and real part can be safely converted
1534 to TYPE. */
1536 enum conversion_safety
1538 {
1545 {
1546 /* If type is complex, we are interested in compatibility with
1547 underlying type. */
1551 /* Warn for real constant that is not an exact integer converted
1552 to integer type. */
1556 {
1559 }
1560 /* Warn for an integer constant that does not fit into integer type. */
1566 {
1569 {
1572 }
1574 {
1577 }
1578 else
1580 }
1582 {
1583 /* Warn for an integer constant that does not fit into real type. */
1586 {
1590 }
1591 /* Warn for a real constant that does not fit into a smaller
1592 real type. */
1595 {
1599 }
1600 }
1601 }
1604 {
1606 /* Conversion from complex constant with zero imaginary part,
1607 perform check for conversion of real part. */
1612 /* Note: in this branch we use recursive call to unsafe_conversion_p
1613 with different type of EXPR, but it is still safe, because when EXPR
1614 is a constant, it's type is not used in text of generated warnings
1615 (otherwise they could sound misleading). */
1617 check_sign);
1618 /* Conversion from complex constant with non-zero imaginary part. */
1619 else
1620 {
1621 /* Conversion to complex type.
1622 Perform checks for both real and imaginary parts. */
1624 {
1631 /* Merge the results into appropriate single warning. */
1633 /* Note: this case includes SAFE_CONVERSION, i.e. success. */
1640 else
1642 }
1643 /* Warn about conversion from complex to real or integer type. */
1644 else
1646 }
1647 }
1649 /* Checks for remaining case: EXPR is not constant. */
1650 else
1651 {
1652 /* Warn for real types converted to integer types. */
1662 {
1663 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
1667 /* Don't warn for short y; short x = ((int)y & 0xff); */
1671 {
1672 /* If both args were extended from a shortest type,
1673 use that type if that is safe. */
1680 {
1686 /* If one of the operands is a non-negative constant
1687 that fits in the target type, then the type of the
1688 other operand does not matter. */
1697 /* If constant is unsigned and fits in the target
1698 type, then the result will also fit. */
1700 && unsigned0
1703 && unsigned1
1706 }
1707 }
1708 /* Warn for integer types converted to smaller integer types. */
1712 /* When they are the same width but different signedness,
1713 then the value may change. */
1716 /* Even when converted to a bigger type, if the type is
1717 unsigned but expr is signed, then negative values
1718 will be changed. */
1722 }
1724 /* Warn for integer types converted to real types if and only if
1725 all the range of values of the integer type cannot be
1726 represented by the real type. */
1730 {
1731 /* Don't warn about char y = 0xff; float x = (int) y; */
1737 }
1739 /* Warn for real types converted to smaller real types. */
1745 /* Check conversion between two complex types. */
1748 {
1749 /* Extract underlying types (i.e., type of real and imaginary
1750 parts) of expr_type and type. */
1754 /* Warn for real types converted to integer types. */
1759 /* Warn for real types converted to smaller real types. */
1765 /* Check conversion for complex integer types. Here implementation
1766 is simpler than for real-domain integers because it does not
1767 involve sophisticated cases, such as bitmasks, casts, etc. */
1770 {
1771 /* Warn for integer types converted to smaller integer types. */
1775 /* Check for different signedness, see case for real-domain
1776 integers (above) for a more detailed comment. */
1782 }
1787 }
1789 /* Warn for complex types converted to real or integer types. */
1793 }
1796 }
1799 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1800 Invoke this function on every expression that is converted implicitly,
1801 i.e. because of language rules and not because of an explicit cast.
1802 INIT_CONST is true if the conversion is for arithmetic types for a static
1803 initializer and folding must apply accordingly (discarding floating-point
1804 exceptions and assuming the default rounding mode is in effect). */
1806 tree
1808 {
1809 tree result;
1810 tree expr_for_warning;
1812 /* Convert from a value with possible excess precision rather than
1813 via the semantic type, but do not warn about values not fitting
1814 exactly in the semantic type. */
1816 {
1819 expr_for_warning = (init_const
1824 }
1825 else
1840 }
1841 \f
1842 /* A node in a list that describes references to variables (EXPR), which are
1843 either read accesses if WRITER is zero, or write accesses, in which case
1844 WRITER is the parent of EXPR. */
1845 struct tlist
1846 {
1849 };
1851 /* Used to implement a cache the results of a call to verify_tree. We only
1852 use this for SAVE_EXPRs. */
1853 struct tlist_cache
1854 {
1858 tree expr;
1859 };
1861 /* Obstack to use when allocating tlist structures, and corresponding
1862 firstobj. */
1866 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1867 warnings. */
1869 /* SAVE_EXPRs need special treatment. We process them only once and then
1870 cache the results. */
1882 /* Create a new struct tlist and fill in its fields. */
1885 {
1892 }
1894 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1895 is nonnull, we ignore any node we find which has a writer equal to it. */
1897 static void
1899 {
1901 {
1908 }
1909 }
1911 /* Merge the nodes of ADD into TO. This merging process is done so that for
1912 each variable that already exists in TO, no new node is added; however if
1913 there is a write access recorded in ADD, and an occurrence on TO is only
1914 a read access, then the occurrence in TO will be modified to record the
1915 write. */
1917 static void
1919 {
1926 {
1933 {
1937 }
1939 {
1943 }
1945 }
1946 }
1948 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1949 references in list LIST conflict with it, excluding reads if ONLY writers
1950 is nonzero. */
1952 static void
1955 {
1958 /* Avoid duplicate warnings. */
1964 {
1968 {
1973 }
1975 }
1976 }
1978 /* Given a list LIST of references to variables, find whether any of these
1979 can cause conflicts due to missing sequence points. */
1981 static void
1983 {
1987 {
1990 }
1991 }
1993 /* Return nonzero if X is a tree that can be verified by the sequence point
1994 warnings. */
1996 static bool
1998 {
2005 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.cc
2006 (lvalue_p) crash on TRY/CATCH. */
2013 /* No point to track non-const calls, they will never satisfy
2014 operand_equal_p. */
2022 }
2024 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2025 static bool
2027 {
2029 }
2031 /* Walk the tree X, and record accesses to variables. If X is written by the
2032 parent tree, WRITER is the parent.
2033 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2034 expression or its only operand forces a sequence point, then everything up
2035 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2036 in PNO_SP.
2037 Once we return, we will have emitted warnings if any subexpression before
2038 such a sequence point could be undefined. On a higher level, however, the
2039 sequence point may not be relevant, and we'll merge the two lists.
2041 Example: (b++, a) + b;
2042 The call that processes the COMPOUND_EXPR will store the increment of B
2043 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2044 processes the PLUS_EXPR will need to merge the two lists so that
2045 eventually, all accesses end up on the same list (and we'll warn about the
2046 unordered subexpressions b++ and b.
2048 A note on merging. If we modify the former example so that our expression
2049 becomes
2050 (b++, b) + a
2051 care must be taken not simply to add all three expressions into the final
2052 PNO_SP list. The function merge_tlist takes care of that by merging the
2053 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2054 way, so that no more than one access to B is recorded. */
2056 static void
2058 tree writer)
2059 {
2064 restart:
2065 /* X may be NULL if it is the operand of an empty statement expression
2066 ({ }). */
2077 {
2086 sequenced_binary:
2114 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2115 two first, to avoid warning for (a ? b++ : b++). */
2131 /* Expressions inside the LHS are not ordered wrt. the sequence points
2132 in the RHS. Example:
2133 *a = (a++, 2)
2134 Despite the fact that the modification of "a" is in the before_sp
2135 list (tmp_before), it conflicts with the use of "a" in the LHS.
2136 We can handle this by adding the contents of tmp_list3
2137 to those of tmp_before, and redoing the collision warnings for that
2138 list. */
2141 /* Exclude the LHS itself here; we first have to merge it into the
2142 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2143 didn't exclude the LHS, we'd get it twice, once as a read and once
2144 as a write. */
2155 /* We need to warn about conflicts among arguments and conflicts between
2156 args and the function address. Side effects of the function address,
2157 however, are not ordered by the sequence point of the call. */
2158 {
2159 call_expr_arg_iterator iter;
2160 tree arg;
2164 {
2169 }
2174 }
2177 /* Scan all the list, e.g. indices of multi dimensional array. */
2179 {
2185 }
2189 {
2196 {
2210 }
2214 }
2225 {
2228 }
2239 /* Treat as unary, the other operands aren't evaluated. */
2245 do_default:
2246 /* For other expressions, simply recurse on their operands.
2247 Manual tail recursion for unary expressions.
2248 Other non-expressions need not be processed. */
2250 {
2254 }
2256 {
2260 {
2265 }
2266 }
2268 }
2269 }
2273 /* Called from verify_sequence_points via walk_tree. */
2275 static tree
2277 {
2285 }
2287 /* Try to warn for undefined behavior in EXPR due to missing sequence
2288 points. */
2290 void
2292 {
2295 /* verify_tree is highly recursive, and merge_tlist is O(n^2),
2296 so we return early if the expression is too big. */
2304 {
2307 }
2312 }
2313 \f
2314 /* Validate the expression after `case' and apply default promotions. */
2316 static tree
2318 {
2324 /* Promote char or short to int. */
2327 {
2330 }
2335 }
2336 \f
2337 /* Return an integer type with BITS bits of precision,
2338 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2340 tree
2342 {
2372 {
2378 }
2397 }
2399 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2400 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2401 and saturating if SATP is nonzero, otherwise not saturating. */
2403 tree
2406 {
2410 else
2413 opt_scalar_mode opt_mode;
2414 scalar_mode mode;
2416 {
2420 }
2423 {
2425 "fixed-point types that have too many integral and "
2428 }
2431 }
2433 /* Used for communication between c_common_type_for_mode and
2434 c_register_builtin_type. */
2435 tree registered_builtin_types;
2437 /* Return a data type that has machine mode MODE.
2438 If the mode is an integer,
2439 then UNSIGNEDP selects between signed and unsigned types.
2440 If the mode is a fixed-point mode,
2441 then UNSIGNEDP selects between saturating and nonsaturating types. */
2443 tree
2445 {
2446 tree t;
2482 #if HOST_BITS_PER_WIDE_INT >= 64
2485 #endif
2506 {
2507 unsigned int precision
2512 }
2515 {
2516 machine_mode inner_mode;
2517 tree inner_type;
2538 }
2541 {
2546 }
2549 {
2554 }
2567 {
2653 }
2656 {
2662 }
2664 }
2666 tree
2668 {
2670 }
2672 /* Return a signed type the same as TYPE in other respects. */
2674 tree
2676 {
2678 }
2680 /* Return a type the same as TYPE except unsigned or
2681 signed according to UNSIGNEDP. */
2683 tree
2685 {
2686 tree type1;
2689 /* This block of code emulates the behavior of the old
2690 c_common_unsigned_type. In particular, it returns
2691 long_unsigned_type_node if passed a long, even when a int would
2692 have the same size. This is necessary for warnings to work
2693 correctly in archs where sizeof(int) == sizeof(long) */
2696 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2714 #if HOST_BITS_PER_WIDE_INT >= 64
2717 #endif
2727 #define C_COMMON_FIXED_TYPES(NAME) \
2728 if (type1 == short_ ## NAME ## _type_node \
2729 || type1 == unsigned_short_ ## NAME ## _type_node) \
2730 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2731 : short_ ## NAME ## _type_node; \
2732 if (type1 == NAME ## _type_node \
2733 || type1 == unsigned_ ## NAME ## _type_node) \
2734 return unsignedp ? unsigned_ ## NAME ## _type_node \
2735 : NAME ## _type_node; \
2736 if (type1 == long_ ## NAME ## _type_node \
2737 || type1 == unsigned_long_ ## NAME ## _type_node) \
2738 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2739 : long_ ## NAME ## _type_node; \
2740 if (type1 == long_long_ ## NAME ## _type_node \
2741 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2742 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2743 : long_long_ ## NAME ## _type_node;
2745 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2746 if (type1 == NAME ## _type_node \
2747 || type1 == u ## NAME ## _type_node) \
2748 return unsignedp ? u ## NAME ## _type_node \
2749 : NAME ## _type_node;
2751 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2752 if (type1 == sat_ ## short_ ## NAME ## _type_node \
2753 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2754 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2755 : sat_ ## short_ ## NAME ## _type_node; \
2756 if (type1 == sat_ ## NAME ## _type_node \
2757 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2758 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2759 : sat_ ## NAME ## _type_node; \
2760 if (type1 == sat_ ## long_ ## NAME ## _type_node \
2761 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2762 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2763 : sat_ ## long_ ## NAME ## _type_node; \
2764 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2765 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2766 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2767 : sat_ ## long_long_ ## NAME ## _type_node;
2769 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
2770 if (type1 == sat_ ## NAME ## _type_node \
2771 || type1 == sat_ ## u ## NAME ## _type_node) \
2772 return unsignedp ? sat_ ## u ## NAME ## _type_node \
2773 : sat_ ## NAME ## _type_node;
2799 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2800 the precision; they have precision set to match their range, but
2801 may use a wider mode to match an ABI. If we change modes, we may
2802 wind up with bad conversions. For INTEGER_TYPEs in C, must check
2803 the precision as well, so as to yield correct results for
2804 bit-field types. C++ does not have these separate bit-field
2805 types, and producing a signed or unsigned variant of an
2806 ENUMERAL_TYPE may cause other problems as well. */
2813 /* signed _BitInt(1) is invalid, avoid creating that. */
2817 #define TYPE_OK(node) \
2818 (TYPE_MODE (type) == TYPE_MODE (node) \
2819 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2839 #if HOST_BITS_PER_WIDE_INT >= 64
2842 #endif
2851 #undef TYPE_OK
2854 }
2856 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
2858 tree
2860 {
2863 /* Extended integer types of the same width as a standard type have
2864 lesser rank, so those of the same width as int promote to int or
2865 unsigned int and are valid for printf formats expecting int or
2866 unsigned int. To avoid such special cases, avoid creating
2867 extended integer types for bit-fields if a standard integer type
2868 is available. */
2886 }
2888 /* The C version of the register_builtin_type langhook. */
2890 void
2892 {
2893 tree decl;
2903 }
2904 \f
2905 /* Print an error message for invalid operands to arith operation
2906 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2907 RICHLOC is a rich location for the message, containing either
2908 three separate locations for each of the operator and operands
2910 lhs op rhs
2911 ~~~ ^~ ~~~
2913 (C FE), or one location ranging over all over them
2915 lhs op rhs
2916 ~~~~^~~~~~
2918 (C++ FE). */
2920 void
2923 {
2927 {
2972 }
2978 }
2979 \f
2980 /* Given an expression as a tree, return its original type. Do this
2981 by stripping any conversion that preserves the sign and precision. */
2982 static tree
2984 {
2987 }
2989 /* Subroutine of build_binary_op, used for comparison operations.
2990 See if the operands have both been converted from subword integer types
2991 and, if so, perhaps change them both back to their original type.
2992 This function is also responsible for converting the two operands
2993 to the proper common type for comparison.
2995 The arguments of this function are all pointers to local variables
2996 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2997 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2999 LOC is the location of the comparison.
3001 If this function returns non-NULL_TREE, it means that the comparison has
3002 a constant value. What this function returns is an expression for
3003 that value. */
3005 tree
3008 {
3009 tree type;
3017 /* Throw away any conversions to wider types
3018 already present in the operands. */
3023 /* If primopN is first sign-extended from primopN's precision to opN's
3024 precision, then zero-extended from opN's precision to
3025 *restype_ptr precision, shortenings might be invalid. */
3028 && !unsignedp0
3033 && !unsignedp1
3037 /* Handle the case that OP0 does not *contain* a conversion
3038 but it *requires* conversion to FINAL_TYPE. */
3045 /* If one of the operands must be floated, we cannot optimize. */
3049 /* If first arg is constant, swap the args (changing operation
3050 so value is preserved), for canonicalization. Don't do this if
3051 the second arg is 0. */
3056 {
3065 {
3080 }
3082 }
3084 /* If comparing an integer against a constant more bits wide,
3085 maybe we can deduce a value of 1 or 0 independent of the data.
3086 Or else truncate the constant now
3087 rather than extend the variable at run time.
3089 This is only interesting if the constant is the wider arg.
3090 Also, it is not safe if the constant is unsigned and the
3091 variable arg is signed, since in this case the variable
3092 would be sign-extended and then regarded as unsigned.
3093 Our technique fails in this case because the lowest/highest
3094 possible unsigned results don't follow naturally from the
3095 lowest/highest possible values of the variable operand.
3096 For just EQ_EXPR and NE_EXPR there is another technique that
3097 could be used: see if the constant can be faithfully represented
3098 in the other operand's type, by truncating it and reextending it
3099 and see if that preserves the constant's value. */
3105 {
3108 /* 1 if comparison is nominally unsigned. */
3110 tree val;
3122 {
3123 /* Convert primop1 to target type, but do not introduce
3124 additional overflow. We know primop1 is an int_cst. */
3130 }
3132 {
3135 }
3143 /* This used to be a switch, but Genix compiler can't handle that. */
3145 {
3148 }
3150 {
3153 }
3155 {
3160 }
3162 {
3167 }
3169 {
3174 }
3176 {
3181 }
3183 /* If primop0 was sign-extended and unsigned comparison specd,
3184 we did a signed comparison above using the signed type bounds.
3185 But the comparison we output must be unsigned.
3187 Also, for inequalities, VAL is no good; but if the signed
3188 comparison had *any* fixed result, it follows that the
3189 unsigned comparison just tests the sign in reverse
3190 (positive values are LE, negative ones GE).
3191 So we can generate an unsigned comparison
3192 against an extreme value of the signed type. */
3195 {
3198 {
3213 }
3215 }
3218 /* Don't warn if it's from a (non-system) macro. */
3219 && !(from_macro_expansion_at
3220 (expansion_point_location_if_in_system_header
3222 {
3229 }
3232 {
3233 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3237 }
3239 /* Value is not predetermined, but do the comparison
3240 in the type of the operand that is not constant.
3241 TYPE is already properly set. */
3242 }
3244 /* If either arg is decimal float and the other is float, find the
3245 proper common type to use for comparison. */
3251 /* If either arg is decimal float and the other is float, fail. */
3255 {
3259 }
3266 /* If args' natural types are both narrower than nominal type
3267 and both extend in the same manner, compare them
3268 in the type of the wider arg.
3269 Otherwise must actually extend both to the nominal
3270 common type lest different ways of extending
3271 alter the result.
3272 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3279 {
3282 type);
3283 /* Make sure shorter operand is extended the right way
3284 to match the longer operand. */
3285 primop0
3288 primop0);
3289 primop1
3292 primop1);
3293 }
3294 else
3295 {
3296 /* Here we must do the comparison on the nominal type
3297 using the args exactly as we received them. */
3302 /* We want to fold unsigned comparisons of >= and < against zero.
3303 For these, we may also issue a warning if we have a non-constant
3304 compared against zero, where the zero was spelled as "0" (rather
3305 than merely folding to it).
3306 If we have at least one constant, then op1 is constant
3307 and we may have a non-constant expression as op0. */
3310 {
3312 /* All unsigned values are >= 0, so we warn. However,
3313 if OP0 is a constant that is >= 0, the signedness of
3314 the comparison isn't an issue, so suppress the
3315 warning. */
3321 folded_op0)))
3322 /* Do not warn for enumeration types. */
3326 {
3330 "comparison of unsigned expression in %<>= 0%> "
3338 "comparison of unsigned expression in %<< 0%> "
3345 }
3348 {
3349 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3354 }
3355 }
3356 }
3364 }
3365 \f
3366 /* Return a tree for the sum or difference (RESULTCODE says which)
3367 of pointer PTROP and integer INTOP. */
3369 tree
3372 {
3375 /* The result is a pointer of the same type that is being added. */
3379 {
3386 }
3388 {
3395 }
3399 else
3400 {
3404 /* Wrap the pointer expression in a SAVE_EXPR to make sure it
3405 is evaluated first when the size expression may depend
3406 on it for VM types. */
3410 {
3413 }
3414 }
3416 /* We are manipulating pointer values, so we don't need to warn
3417 about relying on undefined signed overflow. We disable the
3418 warning here because we use integer types so fold won't know that
3419 they are really pointers. */
3422 /* If what we are about to multiply by the size of the elements
3423 contains a constant term, apply distributive law
3424 and multiply that constant term separately.
3425 This helps produce common subexpressions. */
3430 /* If the constant comes from pointer subtraction,
3431 skip this optimization--it would cause an error. */
3433 /* If the constant is unsigned, and smaller than the pointer size,
3434 then we must skip this optimization. This is because it could cause
3435 an overflow error if the constant is negative but INTOP is not. */
3439 {
3444 /* Convert both subexpression types to the type of intop,
3445 because weird cases involving pointer arithmetic
3446 can result in a sum or difference with different type args. */
3452 }
3454 /* Convert the integer argument to a type the same size as sizetype
3455 so the multiply won't overflow spuriously. */
3461 /* Replace the integer argument with a suitable product by the object size.
3462 Do this multiplication as signed, then convert to the appropriate type
3463 for the pointer operation and disregard an overflow that occurred only
3464 because of the sign-extension change in the latter conversion. */
3465 {
3471 }
3473 /* Create the sum or difference. */
3482 }
3483 \f
3484 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3485 and if NON_CONST is known not to be permitted in an evaluated part
3486 of a constant expression. */
3488 tree
3490 {
3493 /* This should never be called for C++. */
3497 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3504 }
3506 /* Return whether EXPR is a declaration whose address can never be NULL.
3507 The address of the first struct member could be NULL only if it were
3508 accessed through a NULL pointer, and such an access would be invalid.
3509 The address of a weak symbol may be null unless it has a definition. */
3511 bool
3513 {
3526 /* Ordinary (non-weak) symbols have nonnull addresses. */
3530 /* Initialized weak symbols have nonnull addresses. */
3534 /* Uninitialized extern weak symbols and weak symbols with no
3535 allocated storage might have a null address. */
3540 /* Weakref symbols might have a null address unless their referent
3541 is known not to. Don't bother following weakref targets here. */
3545 }
3547 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3548 or for an `if' or `while' statement or ?..: exp. It should already
3549 have been validated to be of suitable type; otherwise, a bad
3550 diagnostic may result.
3552 The EXPR is located at LOCATION.
3554 This preparation consists of taking the ordinary
3555 representation of an expression expr and producing a valid tree
3556 boolean expression describing whether expr is nonzero. We could
3557 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3558 but we optimize comparisons, &&, ||, and !.
3560 The resulting type should always be `truthvalue_type_node'. */
3562 tree
3564 {
3567 {
3614 ? truthvalue_true_node
3620 ? truthvalue_true_node
3625 /* Fall through. */
3628 {
3631 /* Check both EXPR and INNER for suppression. */
3634 {
3635 /* Common Ada programmer's mistake. */
3637 OPT_Waddress,
3639 inner);
3642 }
3644 }
3662 /* These don't change whether an object is nonzero or zero. */
3667 /* These don't change whether an object is zero or nonzero, but
3668 we can't ignore them if their second arg has side-effects. */
3670 {
3673 c_common_truthvalue_conversion
3676 }
3677 else
3687 /* We will only warn on signed shifts here, because the majority of
3688 false positive warnings happen in code where unsigned arithmetic
3689 was used in anticipation of a possible overflow.
3690 Furthermore, if we see an unsigned type here we know that the
3691 result of the shift is not subject to integer promotion rules. */
3702 {
3712 "%<?:%> using integer constants in boolean context, "
3722 }
3723 /* Distribute the conversion into the arms of a COND_EXPR. */
3725 /* Avoid premature folding. */
3727 else
3728 {
3731 /* Folding will happen later for C. */
3740 }
3742 CASE_CONVERT:
3743 {
3748 && !c_inhibit_evaluation_warnings
3750 {
3756 OPT_Waddress,
3757 "the compiler can assume that the address of "
3759 inner);
3760 }
3762 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3763 since that affects how `default_conversion' will behave. */
3767 /* Don't strip a conversion from C++0x scoped enum, since they
3768 don't implicitly convert to other types. */
3772 /* If this isn't narrowing the argument, we can ignore it. */
3774 {
3780 /* Suppress -Waddress for casts to intptr_t, propagating
3781 any suppression from the enclosing expression to its
3782 operand. */
3785 }
3786 }
3791 && warn_parentheses
3793 "suggest parentheses around assignment used as "
3799 {
3803 }
3808 }
3811 {
3813 expr = (build_binary_op
3817 c_common_truthvalue_conversion
3820 c_common_truthvalue_conversion
3825 }
3828 {
3833 }
3834 else
3837 ret:
3840 }
3841 \f
3850 /* Apply the TYPE_QUALS to the new DECL. */
3852 void
3854 {
3862 /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
3863 constructor can produce constant init, so rely on cp_finish_decl to
3864 clear TREE_READONLY if the variable has non-constant init. */
3867 {
3870 }
3872 {
3874 /* Allow 'restrict' on arrays of pointers.
3875 FIXME currently we just ignore it. */
3881 }
3882 }
3884 /* Return the typed-based alias set for T, which may be an expression
3885 or a type. Return -1 if we don't do anything special. */
3887 alias_set_type
3889 {
3890 /* For VLAs, use the alias set of the element type rather than the
3891 default of alias set 0 for types compared structurally. */
3893 {
3897 }
3899 /* That's all the expressions we handle specially. */
3903 /* Unlike char, char8_t doesn't alias in C++. (In C, char8_t is not
3904 a distinct type.) */
3908 /* The C standard guarantees that any object may be accessed via an
3909 lvalue that has narrow character type. */
3915 /* The C standard specifically allows aliasing between signed and
3916 unsigned variants of the same type. We treat the signed
3917 variant as canonical. */
3920 {
3923 /* t1 == t can happen for boolean nodes which are always unsigned. */
3926 }
3929 }
3930 \f
3931 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
3932 the IS_SIZEOF parameter indicates which operator is being applied.
3933 The COMPLAIN flag controls whether we should diagnose possibly
3934 ill-formed constructs or not. LOC is the location of the SIZEOF or
3935 TYPEOF operator. If MIN_ALIGNOF, the least alignment required for
3936 a type in any context should be returned, rather than the normal
3937 alignment for that type. */
3939 tree
3943 {
3951 {
3953 {
3960 }
3961 else
3962 {
3964 {
3968 else
3971 }
3973 }
3974 }
3976 {
3984 }
3987 || is_sizeof
3989 {
3994 }
3997 {
4002 }
4005 {
4009 }
4010 else
4011 {
4013 /* Convert in case a char is more than one unit. */
4019 else
4021 }
4023 /* VALUE will have the middle-end integer type sizetype.
4024 However, we should really return a value of type `size_t',
4025 which is just a typedef for an ordinary integer type. */
4029 }
4031 /* Implement the __alignof keyword: Return the minimum required
4032 alignment of EXPR, measured in bytes. For VAR_DECLs,
4033 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4034 from an "aligned" __attribute__ specification). LOC is the
4035 location of the ALIGNOF operator. */
4037 tree
4039 {
4040 tree t;
4050 {
4053 }
4059 {
4066 {
4073 }
4075 }
4076 else
4080 }
4081 \f
4082 /* Handle C and C++ default attributes. */
4084 enum built_in_attribute
4085 {
4086 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4087 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4088 #define DEF_ATTR_STRING(ENUM, VALUE) ENUM,
4089 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4090 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4092 #undef DEF_ATTR_NULL_TREE
4093 #undef DEF_ATTR_INT
4094 #undef DEF_ATTR_STRING
4095 #undef DEF_ATTR_IDENT
4096 #undef DEF_ATTR_TREE_LIST
4097 ATTR_LAST
4098 };
4104 enum c_builtin_type
4105 {
4106 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4107 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4108 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4109 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4110 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4111 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4112 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4113 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4114 ARG6) NAME,
4115 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4116 ARG6, ARG7) NAME,
4117 #define DEF_FUNCTION_TYPE_8(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4118 ARG6, ARG7, ARG8) NAME,
4119 #define DEF_FUNCTION_TYPE_9(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4120 ARG6, ARG7, ARG8, ARG9) NAME,
4121 #define DEF_FUNCTION_TYPE_10(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4122 ARG6, ARG7, ARG8, ARG9, ARG10) NAME,
4123 #define DEF_FUNCTION_TYPE_11(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4124 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) NAME,
4125 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4126 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4127 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4128 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4129 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4130 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4131 NAME,
4132 #define DEF_FUNCTION_TYPE_VAR_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4133 ARG6) NAME,
4134 #define DEF_FUNCTION_TYPE_VAR_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4135 ARG6, ARG7) NAME,
4136 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4138 #undef DEF_PRIMITIVE_TYPE
4139 #undef DEF_FUNCTION_TYPE_0
4140 #undef DEF_FUNCTION_TYPE_1
4141 #undef DEF_FUNCTION_TYPE_2
4142 #undef DEF_FUNCTION_TYPE_3
4143 #undef DEF_FUNCTION_TYPE_4
4144 #undef DEF_FUNCTION_TYPE_5
4145 #undef DEF_FUNCTION_TYPE_6
4146 #undef DEF_FUNCTION_TYPE_7
4147 #undef DEF_FUNCTION_TYPE_8
4148 #undef DEF_FUNCTION_TYPE_9
4149 #undef DEF_FUNCTION_TYPE_10
4150 #undef DEF_FUNCTION_TYPE_11
4151 #undef DEF_FUNCTION_TYPE_VAR_0
4152 #undef DEF_FUNCTION_TYPE_VAR_1
4153 #undef DEF_FUNCTION_TYPE_VAR_2
4154 #undef DEF_FUNCTION_TYPE_VAR_3
4155 #undef DEF_FUNCTION_TYPE_VAR_4
4156 #undef DEF_FUNCTION_TYPE_VAR_5
4157 #undef DEF_FUNCTION_TYPE_VAR_6
4158 #undef DEF_FUNCTION_TYPE_VAR_7
4159 #undef DEF_POINTER_TYPE
4160 BT_LAST
4161 };
4165 /* A temporary array for c_common_nodes_and_builtins. Used in
4166 communication with def_fn_type. */
4169 /* A helper function for c_common_nodes_and_builtins. Build function type
4170 for DEF with return type RET and N arguments. If VAR is true, then the
4171 function should be variadic after those N arguments, or, if N is zero,
4172 unprototyped.
4174 Takes special care not to ICE if any of the types involved are
4175 error_mark_node, which indicates that said type is not in fact available
4176 (see builtin_type_for_size). In which case the function type as a whole
4177 should be error_mark_node. */
4179 static void
4181 {
4182 tree t;
4189 {
4195 }
4203 else
4205 else
4208 egress:
4211 }
4213 /* Build builtin functions common to both C and C++ language
4214 frontends. */
4216 static void
4218 {
4219 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4220 builtin_types[ENUM] = VALUE;
4221 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4222 def_fn_type (ENUM, RETURN, 0, 0);
4223 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4224 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4225 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4226 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4227 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4228 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4229 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4230 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4231 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4232 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4233 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4234 ARG6) \
4235 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4236 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4237 ARG6, ARG7) \
4238 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4239 #define DEF_FUNCTION_TYPE_8(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4240 ARG6, ARG7, ARG8) \
4241 def_fn_type (ENUM, RETURN, 0, 8, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4242 ARG7, ARG8);
4243 #define DEF_FUNCTION_TYPE_9(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4244 ARG6, ARG7, ARG8, ARG9) \
4245 def_fn_type (ENUM, RETURN, 0, 9, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4246 ARG7, ARG8, ARG9);
4247 #define DEF_FUNCTION_TYPE_10(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4248 ARG6, ARG7, ARG8, ARG9, ARG10) \
4249 def_fn_type (ENUM, RETURN, 0, 10, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4250 ARG7, ARG8, ARG9, ARG10);
4251 #define DEF_FUNCTION_TYPE_11(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4252 ARG6, ARG7, ARG8, ARG9, ARG10, ARG11) \
4253 def_fn_type (ENUM, RETURN, 0, 11, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, \
4254 ARG7, ARG8, ARG9, ARG10, ARG11);
4255 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4256 def_fn_type (ENUM, RETURN, 1, 0);
4257 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4258 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4259 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4260 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4261 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4262 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4263 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4264 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4265 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4266 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4267 #define DEF_FUNCTION_TYPE_VAR_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4268 ARG6) \
4269 def_fn_type (ENUM, RETURN, 1, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4270 #define DEF_FUNCTION_TYPE_VAR_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4271 ARG6, ARG7) \
4272 def_fn_type (ENUM, RETURN, 1, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4273 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4274 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4278 #undef DEF_PRIMITIVE_TYPE
4279 #undef DEF_FUNCTION_TYPE_0
4280 #undef DEF_FUNCTION_TYPE_1
4281 #undef DEF_FUNCTION_TYPE_2
4282 #undef DEF_FUNCTION_TYPE_3
4283 #undef DEF_FUNCTION_TYPE_4
4284 #undef DEF_FUNCTION_TYPE_5
4285 #undef DEF_FUNCTION_TYPE_6
4286 #undef DEF_FUNCTION_TYPE_7
4287 #undef DEF_FUNCTION_TYPE_8
4288 #undef DEF_FUNCTION_TYPE_9
4289 #undef DEF_FUNCTION_TYPE_10
4290 #undef DEF_FUNCTION_TYPE_11
4291 #undef DEF_FUNCTION_TYPE_VAR_0
4292 #undef DEF_FUNCTION_TYPE_VAR_1
4293 #undef DEF_FUNCTION_TYPE_VAR_2
4294 #undef DEF_FUNCTION_TYPE_VAR_3
4295 #undef DEF_FUNCTION_TYPE_VAR_4
4296 #undef DEF_FUNCTION_TYPE_VAR_5
4297 #undef DEF_FUNCTION_TYPE_VAR_6
4298 #undef DEF_FUNCTION_TYPE_VAR_7
4299 #undef DEF_POINTER_TYPE
4304 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4305 NONANSI_P, ATTRS, IMPLICIT, COND) \
4306 if (NAME && COND) \
4307 def_builtin_1 (ENUM, NAME, CLASS, \
4308 builtin_types[(int) TYPE], \
4309 builtin_types[(int) LIBTYPE], \
4310 BOTH_P, FALLBACK_P, NONANSI_P, \
4311 built_in_attributes[(int) ATTRS], IMPLICIT);
4317 }
4319 /* Like get_identifier, but avoid warnings about null arguments when
4320 the argument may be NULL for targets where GCC lacks stdint.h type
4321 information. */
4325 {
4327 }
4329 /* Build tree nodes and builtin functions common to both C and C++ language
4330 frontends. */
4332 void
4334 {
4339 tree array_domain_type;
4340 tree va_list_ref_type_node;
4341 tree va_list_arg_type_node;
4346 /* Define `int' and `char' first so that dbx will output them first. */
4350 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4351 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4352 but not C. Are the conditionals here needed? */
4358 long_unsigned_type_node);
4361 {
4377 }
4382 long_long_integer_type_node);
4384 long_long_unsigned_type_node);
4387 long_long_unsigned_type_node);
4390 short_unsigned_type_node);
4393 short_unsigned_type_node);
4395 /* Define both `signed char' and `unsigned char'. */
4399 /* These are types that c_common_type_for_size and
4400 c_common_type_for_mode use. */
4403 intQI_type_node));
4406 intHI_type_node));
4409 intSI_type_node));
4412 intDI_type_node));
4413 #if HOST_BITS_PER_WIDE_INT >= 64
4414 /* Note that this is different than the __int128 type that's part of
4415 the generic __intN support. */
4418 TYPE_DECL,
4420 intTI_type_node));
4421 #endif
4424 unsigned_intQI_type_node));
4427 unsigned_intHI_type_node));
4430 unsigned_intSI_type_node));
4433 unsigned_intDI_type_node));
4434 #if HOST_BITS_PER_WIDE_INT >= 64
4437 TYPE_DECL,
4439 unsigned_intTI_type_node));
4440 #endif
4442 /* Create the widest literal types. */
4444 {
4447 }
4448 else
4449 {
4452 }
4456 pid_type_node =
4464 {
4468 }
4470 /* For C, let float128t_type_node (__float128 in some backends) be the
4471 same type as float128_type_node (_Float128), for C++ let those
4472 be distinct types that mangle and behave differently. */
4476 /* Only supported decimal floating point extension if the target
4477 actually supports underlying modes. */
4481 {
4486 }
4489 {
4494 long_long_fract_type_node);
4496 unsigned_short_fract_type_node);
4498 unsigned_fract_type_node);
4500 unsigned_long_fract_type_node);
4502 unsigned_long_long_fract_type_node);
4504 sat_short_fract_type_node);
4507 sat_long_fract_type_node);
4509 sat_long_long_fract_type_node);
4511 sat_unsigned_short_fract_type_node);
4513 sat_unsigned_fract_type_node);
4515 sat_unsigned_long_fract_type_node);
4517 sat_unsigned_long_long_fract_type_node);
4522 long_long_accum_type_node);
4524 unsigned_short_accum_type_node);
4526 unsigned_accum_type_node);
4528 unsigned_long_accum_type_node);
4530 unsigned_long_long_accum_type_node);
4532 sat_short_accum_type_node);
4535 sat_long_accum_type_node);
4537 sat_long_long_accum_type_node);
4539 sat_unsigned_short_accum_type_node);
4541 sat_unsigned_accum_type_node);
4543 sat_unsigned_long_accum_type_node);
4545 sat_unsigned_long_long_accum_type_node);
4547 }
4550 TYPE_DECL,
4552 complex_integer_type_node));
4554 TYPE_DECL,
4556 complex_float_type_node));
4558 TYPE_DECL,
4560 complex_double_type_node));
4564 complex_long_double_type_node));
4569 {
4575 TYPE_DECL,
4578 }
4580 /* Make fileptr_type_node a distinct void * type until
4581 FILE type is defined. Likewise for const struct tm*. */
4588 /* Set the TYPE_NAME for any variants that were built before
4589 record_builtin_type gave names to the built-in types. */
4590 {
4596 }
4598 /* Make a type to be the domain of a few array types
4599 whose domains don't really matter.
4600 200 is small enough that it always fits in size_t
4601 and large enough that it can hold most function names for the
4602 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4605 /* Make a type for arrays of characters.
4606 With luck nothing will ever really depend on the length of this
4607 array type. */
4608 char_array_type_node
4612 const_string_type_node
4616 /* This is special for C++ so functions can be overloaded. */
4622 {
4625 else
4628 }
4630 /* This is for wide string constants. */
4631 wchar_array_type_node
4634 /* Define 'char8_t'. */
4639 {
4645 }
4647 /* This is for UTF-8 string constants. */
4648 char8_array_type_node
4651 /* Define 'char16_t'. */
4656 {
4661 }
4663 /* This is for UTF-16 string constants. */
4664 char16_array_type_node
4667 /* Define 'char32_t'. */
4672 {
4677 }
4679 /* This is for UTF-32 string constants. */
4680 char32_array_type_node
4685 else
4686 wint_type_node =
4689 intmax_type_node =
4691 uintmax_type_node =
4695 sig_atomic_type_node =
4698 int8_type_node =
4701 int16_type_node =
4704 int32_type_node =
4707 int64_type_node =
4710 uint8_type_node =
4722 int_least8_type_node =
4725 int_least16_type_node =
4728 int_least32_type_node =
4731 int_least64_type_node =
4734 uint_least8_type_node =
4737 uint_least16_type_node =
4740 uint_least32_type_node =
4743 uint_least64_type_node =
4746 int_fast8_type_node =
4749 int_fast16_type_node =
4752 int_fast32_type_node =
4755 int_fast64_type_node =
4758 uint_fast8_type_node =
4761 uint_fast16_type_node =
4764 uint_fast32_type_node =
4767 uint_fast64_type_node =
4770 intptr_type_node =
4773 uintptr_type_node =
4782 va_list_type_node));
4784 {
4787 tree ptype;
4790 {
4794 ptype));
4796 }
4797 }
4800 {
4803 }
4804 else
4805 {
4808 }
4814 /* Create the built-in __null node. It is important that this is
4815 not shared. */
4819 /* Create the built-in nullptr node. This part of its initialization is
4820 common to C and C++. The front ends can further adjust its definition
4821 in {c,cxx}_init_decl_processing. In particular, we aren't setting the
4822 alignment here for C++ backward ABI bug compatibility. */
4831 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4833 }
4835 /* The number of named compound-literals generated thus far. */
4838 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4840 void
4842 {
4845 compound_literal_number);
4846 compound_literal_number++;
4848 }
4850 /* build_va_arg helper function. Return a VA_ARG_EXPR with location LOC, type
4851 TYPE and operand OP. */
4853 static tree
4855 {
4859 }
4861 /* Return a VA_ARG_EXPR corresponding to a source-level expression
4862 va_arg (EXPR, TYPE) at source location LOC. */
4864 tree
4866 {
4869 ? error_mark_node
4874 {
4878 /* Let's handle things neutrally, if expr:
4879 - has undeclared type, or
4880 - is not an va_list type. */
4882 }
4885 {
4886 /* Case 1: Not an array type. */
4888 /* Take the address, to get '&ap'. Note that &ap is not a va_list
4889 type. */
4894 }
4896 /* Case 2: Array type.
4898 Background:
4900 For contrast, let's start with the simple case (case 1). If
4901 canon_va_type is not an array type, but say a char *, then when
4902 passing-by-value a va_list, the type of the va_list param decl is
4903 the same as for another va_list decl (all ap's are char *):
4905 f2_1 (char * ap)
4906 D.1815 = VA_ARG (&ap, 0B, 1);
4907 return D.1815;
4909 f2 (int i)
4910 char * ap.0;
4911 char * ap;
4912 __builtin_va_start (&ap, 0);
4913 ap.0 = ap;
4914 res = f2_1 (ap.0);
4915 __builtin_va_end (&ap);
4916 D.1812 = res;
4917 return D.1812;
4919 However, if canon_va_type is ARRAY_TYPE, then when passing-by-value a
4920 va_list the type of the va_list param decl (case 2b, struct * ap) is not
4921 the same as for another va_list decl (case 2a, struct ap[1]).
4923 f2_1 (struct * ap)
4924 D.1844 = VA_ARG (ap, 0B, 0);
4925 return D.1844;
4927 f2 (int i)
4928 struct ap[1];
4929 __builtin_va_start (&ap, 0);
4930 res = f2_1 (&ap);
4931 __builtin_va_end (&ap);
4932 D.1841 = res;
4933 return D.1841;
4935 Case 2b is different because:
4936 - on the callee side, the parm decl has declared type va_list, but
4937 grokdeclarator changes the type of the parm decl to a pointer to the
4938 array elem type.
4939 - on the caller side, the pass-by-value uses &ap.
4941 We unify these two cases (case 2a: va_list is array type,
4942 case 2b: va_list is pointer to array elem type), by adding '&' for the
4943 array type case, such that we have a pointer to array elem in both
4944 cases. */
4947 {
4948 /* Case 2a: va_list is array type. */
4950 /* Take the address, to get '&ap'. Make sure it's a pointer to array
4951 elem type. */
4954 expr);
4956 /* Verify that &ap is still recognized as having va_list type. */
4957 tree canon_expr_type
4960 }
4961 else
4962 {
4963 /* Case 2b: va_list is pointer to array elem type. */
4966 /* Comparison as in std_canonical_va_list_type. */
4970 /* Don't take the address. We've already got '&ap'. */
4971 ;
4972 }
4975 }
4978 /* Linked list of disabled built-in functions. */
4980 struct disabled_builtin
4981 {
4984 };
4989 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4990 begins with "__builtin_", give an error. */
4992 void
4994 {
4997 else
4998 {
5003 }
5004 }
5007 /* Return true if the built-in function NAME has been disabled, false
5008 otherwise. */
5010 static bool
5012 {
5015 {
5018 }
5020 }
5023 /* Worker for DEF_BUILTIN.
5024 Possibly define a builtin function with one or two names.
5025 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5026 nonansi_p and flag_no_nonansi_builtin. */
5028 static void
5035 {
5036 tree decl;
5048 fnattrs);
5057 }
5058 \f
5059 /* Nonzero if the type T promotes to int. This is (nearly) the
5060 integral promotions defined in ISO C99 6.3.1.1/2. */
5062 bool
5064 {
5066 {
5076 /* ??? Technically all enumerations not larger than an int
5077 promote to an int. But this is used along code paths
5078 that only want to notice a size change. */
5086 }
5087 }
5089 /* Return 1 if PARMS specifies a fixed number of parameters
5090 and none of their types is affected by default promotions. */
5092 bool
5094 {
5095 const_tree t;
5097 {
5114 }
5116 }
5118 /* Recursively remove any '*' or '&' operator from TYPE. */
5119 tree
5121 {
5125 }
5127 /* Recursively remove pointer or array type from TYPE. */
5128 tree
5130 {
5134 }
5136 /* Used to compare case labels. K1 and K2 are actually tree nodes
5137 representing case labels, or NULL_TREE for a `default' label.
5138 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5139 K2, and 0 if K1 and K2 are equal. */
5141 int
5143 {
5144 /* Consider a NULL key (such as arises with a `default' label) to be
5145 smaller than anything else. */
5152 }
5154 /* Process a case label, located at LOC, for the range LOW_VALUE
5155 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5156 then this case label is actually a `default' label. If only
5157 HIGH_VALUE is NULL_TREE, then case label was declared using the
5158 usual C/C++ syntax, rather than the GNU case range extension.
5159 CASES is a tree containing all the case ranges processed so far;
5160 COND is the condition for the switch-statement itself.
5161 Returns the CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no
5162 CASE_LABEL_EXPR is created. ATTRS are the attributes to be applied
5163 to the label. */
5165 tree
5168 {
5169 tree type;
5170 tree label;
5171 tree case_label;
5172 splay_tree_node node;
5174 /* Create the LABEL_DECL itself. */
5178 /* If there was an error processing the switch condition, bail now
5179 before we get more confused. */
5187 {
5190 }
5192 /* Case ranges are a GNU extension. */
5194 {
5199 {
5202 "ISO C does not support range expressions in switch "
5204 else
5206 "ISO C does not support range expressions in switch "
5208 }
5211 "ISO C does not support range expressions in switch "
5213 }
5217 {
5225 "conversion of %qE to %qT in range expression changes "
5233 }
5235 {
5242 "conversion of %qE to %qT in range expression changes "
5250 }
5253 {
5254 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5255 really a case range, even though it was written that way.
5256 Remove the HIGH_VALUE to simplify later processing. */
5260 {
5263 }
5264 }
5266 /* Look up the LOW_VALUE in the table of case labels we already
5267 have. */
5269 /* If there was not an exact match, check for overlapping ranges.
5270 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5271 that's a `default' label and the only overlap is an exact match. */
5273 {
5274 splay_tree_node low_bound;
5275 splay_tree_node high_bound;
5277 /* Even though there wasn't an exact match, there might be an
5278 overlap between this case range and another case range.
5279 Since we've (inductively) not allowed any overlapping case
5280 ranges, we simply need to find the greatest low case label
5281 that is smaller that LOW_VALUE, and the smallest low case
5282 label that is greater than LOW_VALUE. If there is an overlap
5283 it will occur in one of these two ranges. */
5289 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5290 the LOW_VALUE, so there is no need to check unless the
5291 LOW_BOUND is in fact itself a case range. */
5297 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5298 range is bigger than the low end of the current range, so we
5299 are only interested if the current range is a real range, and
5300 not an ordinary case label. */
5302 && high_value
5304 high_value)
5307 }
5308 /* If there was an overlap, issue an error. */
5310 {
5314 {
5318 }
5320 {
5323 }
5324 else
5325 {
5329 }
5331 }
5333 /* Add a CASE_LABEL to the statement-tree. */
5335 /* Register this case label in the splay tree. */
5342 error_out:
5343 /* Add a label so that the back-end doesn't think that the beginning of
5344 the switch is unreachable. Note that we do not add a case label, as
5345 that just leads to duplicates and thence to failure later on. */
5347 {
5350 }
5352 }
5354 /* Subroutine of c_switch_covers_all_cases_p, called via
5355 splay_tree_foreach. Return 1 if it doesn't cover all the cases.
5356 ARGS[0] is initially NULL and after the first iteration is the
5357 so far highest case label. ARGS[1] is the minimum of SWITCH_COND's
5358 type. */
5360 static int
5362 {
5366 /* If there is a default case, we shouldn't have called this. */
5370 {
5373 }
5379 else
5382 }
5384 /* Return true if switch with CASES and switch condition with type
5385 covers all possible values in the case labels. */
5387 bool
5389 {
5390 /* If there is default:, this is always the case. */
5391 splay_tree_node default_node
5403 /* If there are no cases at all, or if the highest case label
5404 is smaller than TYPE_MAX_VALUE, return false. */
5410 }
5412 /* Return true if stmt can fall through. Used by block_may_fallthru
5413 default case. */
5415 bool
5417 {
5419 {
5427 }
5428 }
5430 /* Finish an expression taking the address of LABEL (an
5431 IDENTIFIER_NODE). Returns an expression for the address.
5433 LOC is the location for the expression returned. */
5435 tree
5437 {
5438 tree result;
5448 else
5449 {
5452 /* The current function is not necessarily uninlinable.
5453 Computed gotos are incompatible with inlining, but the value
5454 here could be used only in a diagnostic, for example. */
5456 }
5459 }
5460 \f
5462 /* Given a boolean expression ARG, return a tree representing an increment
5463 or decrement (as indicated by CODE) of ARG. The front end must check for
5464 invalid cases (e.g., decrement in C++). */
5465 tree
5467 {
5468 tree val;
5473 {
5496 }
5499 }
5500 \f
5501 /* Built-in macros for stddef.h and stdint.h, that require macros
5502 defined in this file. */
5503 void
5505 {
5509 /* C++ has wchar_t as a builtin type, C doesn't, so if WINT_TYPE
5510 maps to wchar_t, define it to the underlying WCHAR_TYPE in C, and
5511 to wchar_t in C++, so the desired type equivalence holds. */
5515 else
5577 /* GIMPLE FE testcases need access to the GCC internal 'sizetype'.
5578 Expose it as __SIZETYPE__. */
5581 }
5583 static void
5585 {
5586 /* Fill in the built_in_attributes array. */
5587 #define DEF_ATTR_NULL_TREE(ENUM) \
5588 built_in_attributes[(int) ENUM] = NULL_TREE;
5589 #define DEF_ATTR_INT(ENUM, VALUE) \
5590 built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
5591 #define DEF_ATTR_STRING(ENUM, VALUE) \
5592 built_in_attributes[(int) ENUM] = build_string (strlen (VALUE), VALUE);
5593 #define DEF_ATTR_IDENT(ENUM, STRING) \
5594 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5595 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5596 built_in_attributes[(int) ENUM] \
5597 = tree_cons (built_in_attributes[(int) PURPOSE], \
5598 built_in_attributes[(int) VALUE], \
5599 built_in_attributes[(int) CHAIN]);
5601 #undef DEF_ATTR_NULL_TREE
5602 #undef DEF_ATTR_INT
5603 #undef DEF_ATTR_IDENT
5604 #undef DEF_ATTR_TREE_LIST
5605 }
5607 /* Check whether the byte alignment ALIGN is a valid user-specified
5608 alignment less than the supported maximum. If so, return ALIGN's
5609 base-2 log; if not, output an error and return -1. If OBJFILE
5610 then reject alignments greater than MAX_OFILE_ALIGNMENT when
5611 converted to bits. Otherwise, consider valid only alignments
5612 that are less than HOST_BITS_PER_INT - LOG2_BITS_PER_UNIT.
5613 Zero is not considered a valid argument (and results in -1 on
5614 return) but it only triggers a warning when WARN_ZERO is set. */
5616 int
5618 {
5624 {
5627 }
5630 {
5634 align);
5636 }
5638 /* Log2 of the byte alignment ALIGN. */
5642 {
5644 align);
5646 }
5649 {
5652 {
5656 }
5657 }
5660 {
5664 }
5667 }
5669 /* Determine the ELF symbol visibility for DECL, which is either a
5670 variable or a function. It is an error to use this function if a
5671 definition of DECL is not available in this translation unit.
5672 Returns true if the final visibility has been determined by this
5673 function; false if the caller is free to make additional
5674 modifications. */
5676 bool
5678 {
5681 /* If the user explicitly specified the visibility with an
5682 attribute, honor that. DECL_VISIBILITY will have been set during
5683 the processing of the attribute. We check for an explicit
5684 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5685 to distinguish the use of an attribute from the use of a "#pragma
5686 GCC visibility push(...)"; in the latter case we still want other
5687 considerations to be able to overrule the #pragma. */
5689 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5694 /* Set default visibility to whatever the user supplied with
5695 visibility_specified depending on #pragma GCC visibility. */
5697 {
5700 {
5703 /* If visibility changed and DECL already has DECL_RTL, ensure
5704 symbol flags are updated. */
5709 }
5710 }
5712 }
5714 /* Data to communicate through check_function_arguments_recurse between
5715 check_function_nonnull and check_nonnull_arg. */
5717 struct nonnull_arg_ctx
5718 {
5719 /* Location of the call. */
5720 location_t loc;
5721 /* The function whose arguments are being checked and its type (used
5722 for calls through function pointers). */
5724 /* True if a warning has been issued. */
5726 };
5728 /* Check the argument list of a function call to CTX.FNDECL of CTX.FNTYPE
5729 for null in argument slots that are marked as requiring a non-null
5730 pointer argument. The NARGS arguments are passed in the array ARGARRAY.
5731 Return true if we have warned. */
5733 static bool
5735 {
5738 {
5741 {
5742 /* For certain lambda expressions the C++ front end emits calls
5743 that pass a null this pointer as an argument named __closure
5744 to the member operator() of empty function. Detect those
5745 and avoid checking them, but proceed to check the remaining
5746 arguments. */
5750 }
5752 /* In calls to C++ non-static member functions check the this
5753 pointer regardless of whether the function is declared with
5754 attribute nonnull. */
5759 }
5766 /* See if any of the nonnull attributes has no arguments. If so,
5767 then every pointer argument is checked (in which case the check
5768 for pointer type is done in check_nonnull_arg). */
5770 do
5778 else
5779 {
5780 /* Walk the argument list. If we encounter an argument number we
5781 should check for non-null, do it. */
5783 {
5785 {
5789 }
5794 OPT_Wnonnull);
5795 }
5796 }
5798 }
5800 /* Check that the Nth argument of a function call (counting backwards
5801 from the end) is a (pointer)0. The NARGS arguments are passed in the
5802 array ARGARRAY. */
5804 static void
5806 {
5810 {
5813 tree sentinel;
5814 function_args_iterator iter;
5815 tree t;
5817 /* Skip over the named arguments. */
5819 {
5822 len++;
5823 }
5826 {
5829 }
5831 /* The sentinel must be one of the varargs, i.e.
5832 in position >= the number of fixed arguments. */
5834 {
5838 }
5840 /* Validate the sentinel. */
5845 /* Although __null (in C++) is only an integer we allow it
5846 nevertheless, as we are guaranteed that it's exactly
5847 as wide as a pointer, and we don't want to force
5848 users to cast the NULL they have written there.
5849 We warn with -Wstrict-null-sentinel, though. */
5852 }
5853 }
5855 /* Check that the same argument isn't passed to two or more
5856 restrict-qualified formal and issue a -Wrestrict warning
5857 if it is. Return true if a warning has been issued. */
5859 static bool
5862 {
5866 /* Call fold_for_warn on all of the arguments. */
5873 {
5874 /* Avoid diagnosing calls built-ins with a zero size/bound
5875 here. They are checked in more detail elsewhere. */
5884 }
5892 {
5893 tree type;
5895 {
5898 }
5899 else
5900 {
5903 }
5908 }
5914 }
5916 /* Helper for check_function_nonnull; given a list of operands which
5917 must be non-null in ARGS, determine if operand PARAM_NUM should be
5918 checked. */
5920 static bool
5922 {
5926 {
5933 }
5935 }
5937 /* Check that the function argument PARAM (which is operand number
5938 PARAM_NUM) is non-null. This is called by check_function_nonnull
5939 via check_function_arguments_recurse. */
5941 static void
5943 {
5946 /* Just skip checking the argument if it's not a pointer. This can
5947 happen if the "nonnull" attribute was given without an operand
5948 list (which means to check every pointer argument). */
5955 /* Diagnose the simple cases of null arguments. */
5959 auto_diagnostic_group adg;
5968 {
5975 }
5976 else
5977 {
5985 }
5989 }
5991 /* Helper for attribute handling; fetch the operand number from
5992 the attribute argument list. */
5994 bool
5996 {
5997 /* Verify the arg number is a small constant. */
5999 {
6002 }
6003 else
6005 }
6007 /* Arguments being collected for optimization. */
6012 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
6013 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
6014 false for #pragma GCC optimize. */
6016 bool
6018 {
6025 tree ap;
6027 /* Build up argv vector. Just in case the string is stored away, use garbage
6028 collected strings. */
6033 {
6037 {
6041 }
6044 {
6045 /* Split string into multiple substrings. */
6053 {
6060 {
6064 }
6065 else
6066 {
6069 }
6071 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
6072 options. */
6074 {
6079 else
6083 }
6085 /* Can't use GC memory here, see PR88007. */
6089 {
6092 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
6093 itself is -Os, and any other switch begins with a -f. */
6099 }
6104 }
6106 }
6107 }
6115 /* Now parse the options. */
6119 /* Drop non-Optimization options. */
6122 {
6124 {
6130 else
6135 }
6138 j++;
6139 }
6142 /* Merge the decoded options with save_decoded_options. */
6144 unsigned merged_decoded_options_count
6146 cl_decoded_option *merged_decoded_options
6149 /* Note the first decoded_options is used for the program name. */
6155 /* And apply them. */
6165 }
6167 /* Check whether ATTR is a valid attribute fallthrough. */
6169 bool
6171 {
6177 /* It is no longer true that "this attribute shall appear at most once in
6178 each attribute-list", but we still give a warning. */
6182 /* No attribute-argument-clause shall be present. */
6186 /* Warn if other attributes are found. */
6188 {
6192 {
6194 /* The specifications of standard attributes in C mean
6195 this is a constraint violation. */
6198 else
6200 }
6201 }
6203 }
6205 \f
6206 /* Check for valid arguments being passed to a function with FNTYPE.
6207 There are NARGS arguments in the array ARGARRAY. LOC should be used
6208 for diagnostics. Return true if either -Wnonnull or -Wrestrict has
6209 been issued.
6211 The arguments in ARGARRAY may not have been folded yet (e.g. for C++,
6212 to preserve location wrappers); checks that require folded arguments
6213 should call fold_for_warn on them.
6215 Use the frontend-supplied COMP_TYPES when determining if
6216 one type is a subclass of another. */
6218 bool
6222 {
6225 /* Check for null being passed in a pointer argument that must be
6226 non-null. In C++, this includes the this pointer. We also need
6227 to do this if format checking is enabled. */
6229 {
6232 }
6234 /* Check for errors in format strings. */
6244 {
6246 {
6251 /* Let the sprintf pass handle these. */
6256 }
6257 }
6259 /* check_function_restrict sets the DECL_READ_P for arguments
6260 so it must be called unconditionally. */
6264 }
6266 /* Generic argument checking recursion routine. PARAM is the argument to
6267 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
6268 once the argument is resolved. CTX is context for the callback.
6269 OPT is the warning for which this is done. */
6270 void
6275 opt_code opt)
6276 {
6283 {
6284 /* Strip coercion. */
6287 opt);
6289 }
6292 {
6294 tree attrs;
6297 /* See if this is a call to a known internationalization function
6298 that modifies a format arg. Such a function may have multiple
6299 format_arg attributes (for example, ngettext). */
6302 attrs;
6305 {
6306 tree inner_arg;
6307 tree format_num_expr;
6310 call_expr_arg_iterator iter;
6312 /* Extract the argument number, which was previously checked
6313 to be valid. */
6322 {
6325 opt);
6328 }
6329 }
6331 /* If we found a format_arg attribute and did a recursive check,
6332 we are done with checking this argument. Otherwise, we continue
6333 and this will be considered a non-literal. */
6336 }
6339 {
6340 /* Simplify to avoid warning for an impossible case. */
6343 {
6344 /* Check both halves of the conditional expression. */
6352 }
6353 }
6356 }
6358 /* Checks for a builtin function FNDECL that the number of arguments
6359 NARGS against the required number REQUIRED and issues an error if
6360 there is a mismatch. Returns true if the number of arguments is
6361 correct, otherwise false. LOC is the location of FNDECL. */
6363 static bool
6366 {
6368 {
6371 }
6373 {
6376 }
6378 }
6380 /* Helper macro for check_builtin_function_arguments. */
6381 #define ARG_LOCATION(N) \
6382 (arg_loc.is_empty () \
6383 ? EXPR_LOC_OR_LOC (args[(N)], input_location) \
6384 : expansion_point_location (arg_loc[(N)]))
6386 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
6387 Returns false if there was an error, otherwise true. LOC is the
6388 location of the function; ARG_LOC is a vector of locations of the
6389 arguments. If FNDECL is the result of resolving an overloaded
6390 target built-in, ORIG_FNDECL is the original function decl,
6391 otherwise it is null. */
6393 bool
6397 {
6411 {
6414 {
6417 fndecl);
6419 }
6420 /* fall through */
6423 {
6424 /* Get the requested alignment (in bits) if it's a constant
6425 integer expression. */
6426 unsigned HOST_WIDE_INT align
6429 /* Determine if the requested alignment is a power of 2. */
6433 /* The maximum alignment in bits corresponding to the same
6434 maximum in bytes enforced in check_user_alignment(). */
6437 /* Reject invalid alignments. */
6439 {
6441 "second argument to function %qE must be a constant "
6445 }
6447 }
6460 {
6462 {
6466 }
6468 }
6479 {
6488 {
6492 }
6494 }
6499 {
6502 {
6506 }
6509 {
6513 }
6515 }
6520 {
6524 {
6528 }
6530 }
6537 {
6541 {
6545 }
6548 {
6552 }
6554 {
6558 }
6560 {
6564 }
6566 {
6571 }
6573 {
6578 }
6580 }
6587 {
6591 {
6595 }
6597 {
6601 }
6603 {
6607 }
6609 }
6614 {
6616 {
6620 }
6622 {
6626 }
6628 {
6633 }
6635 {
6640 }
6642 }
6654 {
6656 {
6660 }
6666 {
6670 }
6671 }
6676 {
6680 }
6682 {
6686 }
6688 {
6692 }
6695 {
6697 {
6701 }
6702 }
6704 {
6708 }
6713 }
6714 }
6716 /* Subroutine of c_parse_error.
6717 Return the result of concatenating LHS and RHS. RHS is really
6718 a string literal, its first character is indicated by RHS_START and
6719 RHS_SIZE is its length (including the terminating NUL character).
6721 The caller is responsible for deleting the returned pointer. */
6725 {
6731 }
6733 /* Issue the error given by GMSGID at RICHLOC, indicating that it occurred
6734 before TOKEN, which had the associated VALUE. */
6736 void
6740 {
6741 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
6752 {
6757 {
6773 }
6777 else
6783 }
6806 {
6811 }
6821 {
6826 }
6827 else
6831 {
6834 }
6835 #undef catenate_messages
6836 }
6838 /* Return the gcc option code associated with the reason for a cpp
6839 message, or 0 if none. */
6841 static diagnostic_option_id
6843 {
6847 {
6850 }
6852 }
6854 /* Return TRUE if the given option index corresponds to a diagnostic
6855 issued by libcpp. Linear search seems fine for now. */
6856 bool
6858 {
6861 {
6864 }
6866 }
6868 /* Callback from cpp_diagnostic for PFILE to print diagnostics from the
6869 preprocessor. The diagnostic is of type LEVEL, with REASON set
6870 to the reason code if LEVEL is represents a warning, at location
6871 RICHLOC unless this is after lexing and the compiler's location
6872 should be used instead; MSG is the translated message and AP
6873 the arguments. Returns true if a diagnostic was emitted, false
6874 otherwise. */
6876 bool
6882 {
6883 diagnostic_info diagnostic;
6884 diagnostic_t dlevel;
6889 {
6894 /* Fall through. */
6919 }
6930 }
6932 /* Convert a character from the host to the target execution character
6933 set. cpplib handles this, mostly. */
6935 HOST_WIDE_INT
6937 {
6938 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6939 zero-extended under -fno-signed-char. cpplib insists that characters
6940 and character constants are always unsigned. Hence we must convert
6941 back and forth. */
6949 else
6951 }
6953 /* Fold an offsetof-like expression. EXPR is a nested sequence of component
6954 references with an INDIRECT_REF of a constant at the bottom; much like the
6955 traditional rendering of offsetof as a macro. TYPE is the desired type of
6956 the whole expression. Return the folded result. */
6958 tree
6960 {
6964 {
6980 {
6983 }
6993 {
6997 }
7011 /* Check if the offset goes beyond the upper bound of the array. */
7013 {
7019 {
7024 {
7025 tree v;
7032 {
7040 }
7041 /* Don't warn if the array might be considered a poor
7042 man's flexible array member with a very permissive
7043 definition thereof. */
7047 "index %E denotes an offset "
7050 }
7051 }
7052 }
7059 /* Handle static members of volatile structs. */
7066 }
7071 }
7072 \f
7073 /* *PTYPE is an incomplete array. Complete it with a domain based on
7074 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7075 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7076 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
7078 int
7080 {
7087 {
7091 {
7092 int eltsize
7096 }
7098 {
7102 {
7106 }
7107 else
7108 {
7109 tree curindex;
7122 {
7127 {
7129 {
7130 /* Since we treat size types now as ordinary
7131 unsigned types, we need an explicit overflow
7132 check. */
7137 }
7139 curindex
7144 else
7146 size_one_node);
7147 }
7150 }
7152 {
7156 }
7157 }
7158 }
7159 else
7160 {
7161 /* Make an error message unless that happened already. */
7164 }
7165 }
7166 else
7167 {
7171 }
7178 else
7181 /* Using build_distinct_type_copy and modifying things afterward instead
7182 of using build_array_type to create a new type preserves all of the
7183 TYPE_LANG_FLAG_? bits that the front end may have set. */
7192 /* Set TYPE_STRUCTURAL_EQUALITY_P early. */
7196 else
7199 /* Make sure we have the canonical MAIN_TYPE. */
7203 /* Fix the canonical type. */
7217 else
7223 {
7225 /* If we proceed with the array type as it is, we'll eventually
7226 crash in tree_to_[su]hwi(). */
7228 }
7232 }
7234 /* INIT is an constructor of a structure with a flexible array member.
7235 Complete the flexible array member with a domain based on it's value. */
7236 void
7238 {
7252 else
7254 }
7256 /* Like c_mark_addressable but don't check register qualifier. */
7257 void
7259 {
7261 {
7264 else
7266 }
7278 }
7281 \f
7282 /* Used to help initialize the builtin-types.def table. When a type of
7283 the correct size doesn't exist, use error_mark_node instead of NULL.
7284 The later results in segfaults even when a decl using the type doesn't
7285 get invoked. */
7287 tree
7289 {
7292 }
7294 /* Work out the size of the first argument of a call to
7295 __builtin_speculation_safe_value. Only pointers and integral types
7296 are permitted. Return -1 if the argument type is not supported or
7297 the size is too large; 0 if the argument type is a pointer or the
7298 size if it is integral. */
7299 static enum built_in_function
7301 {
7302 /* Type of the argument. */
7303 tree type;
7307 {
7310 }
7314 {
7315 /* Force array-to-pointer decay for C++. */
7318 }
7334 incompatible:
7335 /* Issue the diagnostic only if the argument is valid, otherwise
7336 it would be redundant at best and could be misleading. */
7342 }
7344 /* Validate and coerce PARAMS, the arguments to ORIG_FUNCTION to fit
7345 the prototype for FUNCTION. The first argument is mandatory, a second
7346 argument, if present, must be type compatible with the first. */
7347 static bool
7350 {
7351 tree val;
7354 {
7357 }
7360 {
7363 }
7370 {
7372 "expecting argument of type pointer or of type integer "
7375 }
7379 {
7387 {
7390 }
7392 }
7395 }
7397 /* Cast the result of the builtin back to the type of the first argument,
7398 preserving any qualifiers that it might have. */
7399 static tree
7401 {
7410 }
7412 /* A helper function for resolve_overloaded_builtin in resolving the
7413 overloaded __sync_ builtins. Returns a positive power of 2 if the
7414 first operand of PARAMS is a pointer to a supported data type.
7415 Returns 0 if an error is encountered. Return -1 for _BitInt
7416 __atomic*fetch* with unsupported type which should be handled by
7417 a cas loop.
7418 FETCH is true when FUNCTION is one of the _FETCH_OP_ or _OP_FETCH_
7419 built-ins. ORIG_FORMAT is for __sync_* rather than __atomic_*
7420 built-ins. */
7422 static int
7425 {
7426 /* Type of the argument. */
7427 tree argtype;
7428 /* Type the argument points to. */
7429 tree type;
7433 {
7436 }
7440 {
7441 /* Force array-to-pointer decay for C++. */
7444 }
7460 && fetch
7461 && !orig_format
7472 incompatible:
7473 /* Issue the diagnostic only if the argument is valid, otherwise
7474 it would be redundant at best and could be misleading. */
7479 }
7481 /* A helper function for resolve_overloaded_builtin. Adds casts to
7482 PARAMS to make arguments match up with those of FUNCTION. Drops
7483 the variadic arguments at the end. Returns false if some error
7484 was encountered; true on success. */
7486 static bool
7489 {
7490 function_args_iterator iter;
7491 tree ptype;
7495 /* We've declared the implementation functions to use "volatile void *"
7496 as the pointer parameter, so we shouldn't get any complaints from the
7497 call to check_function_arguments what ever type the user used. */
7502 /* For the rest of the values, we need to cast these to FTYPE, so that we
7503 don't get warnings for passing pointer types, etc. */
7506 {
7510 /* XXX void_type_node belies the abstraction. */
7516 {
7519 }
7521 /* Only convert parameters if arg_type is unsigned integer type with
7522 new format sync routines, i.e. don't attempt to convert pointer
7523 arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
7524 bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
7525 kinds). */
7527 {
7528 /* Ideally for the first conversion we'd use convert_for_assignment
7529 so that we get warnings for anything that doesn't match the pointer
7530 type. This isn't portable across the C and C++ front ends atm. */
7535 }
7538 }
7540 /* __atomic routines are not variadic. */
7542 {
7545 }
7547 /* The definition of these primitives is variadic, with the remaining
7548 being "an optional list of variables protected by the memory barrier".
7549 No clue what that's supposed to mean, precisely, but we consider all
7550 call-clobbered variables to be protected so we're safe. */
7554 }
7556 /* A helper function for resolve_overloaded_builtin. Adds a cast to
7557 RESULT to make it match the type of the first pointer argument in
7558 PARAMS. */
7560 static tree
7562 {
7567 /* New format doesn't require casting unless the types are the same size. */
7570 else
7572 }
7574 /* This function verifies the PARAMS to generic atomic FUNCTION.
7575 It returns the size if all the parameters are the same size, otherwise
7576 0 is returned if the parameters are invalid. */
7578 static int
7581 {
7587 tree type_0;
7589 /* Determine the parameter makeup. */
7591 {
7614 }
7617 {
7620 }
7622 /* Get type of first parameter, and determine its size. */
7625 {
7626 /* Force array-to-pointer decay for C++. */
7629 }
7631 {
7633 function);
7635 }
7638 {
7640 function);
7642 }
7644 /* Types must be compile time constant sizes. */
7646 {
7649 function);
7651 }
7655 /* Zero size objects are not allowed. */
7657 {
7660 function);
7662 }
7664 /* Check each other parameter is a pointer and the same size. */
7666 {
7669 /* __atomic_compare_exchange has a bool in the 4th position, skip it. */
7673 {
7674 /* Force array-to-pointer decay for C++. */
7677 }
7679 {
7681 function);
7683 }
7687 {
7691 }
7693 {
7697 }
7701 {
7703 function);
7705 }
7707 {
7708 auto_diagnostic_group d;
7710 /* Must not write to an argument of a const-qualified type. */
7712 {
7714 {
7718 }
7719 else
7722 function);
7723 }
7724 /* Only the first argument is allowed to be volatile. */
7726 {
7728 {
7732 }
7733 else
7736 function);
7737 }
7738 }
7739 }
7741 /* Check memory model parameters for validity. */
7743 {
7746 {
7748 function);
7750 }
7753 {
7754 /* memmodel_base masks the low 16 bits, thus ignore any bits above
7755 it by using TREE_INT_CST_LOW instead of tree_to_*hwi. Those high
7756 bits will be checked later during expansion in target specific
7757 way. */
7761 function);
7762 }
7763 }
7766 }
7769 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
7770 at the beginning of the parameter list PARAMS representing the size of the
7771 objects. This is to match the library ABI requirement. LOC is the location
7772 of the function call.
7773 The new function is returned if it needed rebuilding, otherwise NULL_TREE is
7774 returned to allow the external call to be constructed. */
7776 static tree
7779 {
7780 tree size_node;
7782 /* Insert a SIZE_T parameter as the first param. If there isn't
7783 enough space, allocate a new vector and recursively re-build with that. */
7785 {
7788 tree f;
7798 }
7800 /* Add the size parameter and leave as a function call for processing. */
7804 }
7807 /* Return whether atomic operations for naturally aligned N-byte
7808 arguments are supported, whether inline or through libatomic. */
7809 static bool
7811 {
7813 {
7825 }
7826 }
7828 /* This will process an __atomic_exchange function call, determine whether it
7829 needs to be mapped to the _N variation, or turned into a library call.
7830 LOC is the location of the builtin call.
7831 FUNCTION is the DECL that has been invoked;
7832 PARAMS is the argument list for the call. The return value is non-null
7833 TRUE is returned if it is translated into the proper format for a call to the
7834 external library, and NEW_RETURN is set the tree for that function.
7835 FALSE is returned if processing for the _N variation is required, and
7836 NEW_RETURN is set to the return value the result is copied into. */
7837 static bool
7840 {
7845 /* Size of 0 is an error condition. */
7847 {
7850 }
7852 /* If not a lock-free size, change to the library generic format. */
7854 {
7857 }
7859 /* Otherwise there is a lockfree match, transform the call from:
7860 void fn(T* mem, T* desired, T* return, model)
7861 into
7862 *return = (T) (fn (In* mem, (In) *desired, model)) */
7869 /* Create pointer to appropriate size. */
7873 /* Convert object pointer to required type. */
7876 /* Convert new value to required type, and dereference it.
7877 If *p1 type can have padding or may involve floating point which
7878 could e.g. be promoted to wider precision and demoted afterwards,
7879 state of padding bits might not be preserved. */
7886 /* Move memory model to the 3rd position, and end param list. */
7890 /* Convert return pointer and dereference it for later assignment. */
7894 }
7897 /* This will process an __atomic_compare_exchange function call, determine
7898 whether it needs to be mapped to the _N variation, or turned into a lib call.
7899 LOC is the location of the builtin call.
7900 FUNCTION is the DECL that has been invoked;
7901 PARAMS is the argument list for the call. The return value is non-null
7902 TRUE is returned if it is translated into the proper format for a call to the
7903 external library, and NEW_RETURN is set the tree for that function.
7904 FALSE is returned if processing for the _N variation is required. */
7906 static bool
7910 {
7915 /* Size of 0 is an error condition. */
7917 {
7920 }
7922 /* If not a lock-free size, change to the library generic format. */
7924 {
7925 /* The library generic format does not have the weak parameter, so
7926 remove it from the param list. Since a parameter has been removed,
7927 we can be sure that there is room for the SIZE_T parameter, meaning
7928 there will not be a recursive rebuilding of the parameter list, so
7929 there is no danger this will be done twice. */
7931 {
7935 }
7938 }
7940 /* Otherwise, there is a match, so the call needs to be transformed from:
7941 bool fn(T* mem, T* desired, T* return, weak, success, failure)
7942 into
7943 bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail) */
7949 /* Create pointer to appropriate size. */
7953 /* Convert object pointer to required type. */
7957 /* Convert expected pointer to required type. */
7961 /* Convert desired value to required type, and dereference it.
7962 If *p2 type can have padding or may involve floating point which
7963 could e.g. be promoted to wider precision and demoted afterwards,
7964 state of padding bits might not be preserved. */
7971 /* The rest of the parameters are fine. NULL means no special return value
7972 processing.*/
7975 }
7978 /* This will process an __atomic_load function call, determine whether it
7979 needs to be mapped to the _N variation, or turned into a library call.
7980 LOC is the location of the builtin call.
7981 FUNCTION is the DECL that has been invoked;
7982 PARAMS is the argument list for the call. The return value is non-null
7983 TRUE is returned if it is translated into the proper format for a call to the
7984 external library, and NEW_RETURN is set the tree for that function.
7985 FALSE is returned if processing for the _N variation is required, and
7986 NEW_RETURN is set to the return value the result is copied into. */
7988 static bool
7991 {
7996 /* Size of 0 is an error condition. */
7998 {
8001 }
8003 /* If not a lock-free size, change to the library generic format. */
8005 {
8008 }
8010 /* Otherwise, there is a match, so the call needs to be transformed from:
8011 void fn(T* mem, T* return, model)
8012 into
8013 *return = (T) (fn ((In *) mem, model)) */
8019 /* Create pointer to appropriate size. */
8023 /* Convert object pointer to required type. */
8027 /* Move memory model to the 2nd position, and end param list. */
8031 /* Convert return pointer and dereference it for later assignment. */
8035 }
8038 /* This will process an __atomic_store function call, determine whether it
8039 needs to be mapped to the _N variation, or turned into a library call.
8040 LOC is the location of the builtin call.
8041 FUNCTION is the DECL that has been invoked;
8042 PARAMS is the argument list for the call. The return value is non-null
8043 TRUE is returned if it is translated into the proper format for a call to the
8044 external library, and NEW_RETURN is set the tree for that function.
8045 FALSE is returned if processing for the _N variation is required, and
8046 NEW_RETURN is set to the return value the result is copied into. */
8048 static bool
8051 {
8056 /* Size of 0 is an error condition. */
8058 {
8061 }
8063 /* If not a lock-free size, change to the library generic format. */
8065 {
8068 }
8070 /* Otherwise, there is a match, so the call needs to be transformed from:
8071 void fn(T* mem, T* value, model)
8072 into
8073 fn ((In *) mem, (In) *value, model) */
8078 /* Create pointer to appropriate size. */
8082 /* Convert object pointer to required type. */
8086 /* Convert new value to required type, and dereference it. */
8091 /* The memory model is in the right spot already. Return is void. */
8095 }
8098 /* Emit __atomic*fetch* on _BitInt which doesn't have a size of
8099 1, 2, 4, 8 or 16 bytes using __atomic_compare_exchange loop.
8100 ORIG_CODE is the DECL_FUNCTION_CODE of ORIG_FUNCTION and
8101 ORIG_PARAMS arguments of the call. */
8103 static tree
8106 tree orig_function,
8108 {
8112 {
8155 }
8158 {
8161 else
8164 }
8176 {
8180 }
8182 {
8187 }
8189 {
8192 NULL_TREE);
8194 }
8196 {
8199 NULL_TREE);
8201 }
8222 /* __atomic_load (addr, &old, SEQ_CST). */
8231 NULL_TREE);
8235 /* loop: */
8238 /* newval = old + val; */
8239 tree rhs;
8241 {
8245 {
8246 tree utype
8252 }
8253 else
8268 }
8270 NULL_TREE);
8274 /* if (__atomic_compare_exchange (addr, &old, &new, false, model, model))
8275 goto done; */
8286 else
8295 tree stmt
8300 /* goto loop; */
8305 /* done: */
8313 /* Finish the compound statement. */
8317 NULL_TREE);
8318 }
8321 /* Some builtin functions are placeholders for other expressions. This
8322 function should be called immediately after parsing the call expression
8323 before surrounding code has committed to the type of the expression.
8325 LOC is the location of the builtin call.
8327 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8328 PARAMS is the argument list for the call. The return value is non-null
8329 when expansion is complete, and null if normal processing should
8330 continue. */
8332 tree
8335 {
8336 /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
8337 Those are not valid to call with a pointer to _Bool (or C++ bool)
8338 and so must be rejected. */
8344 {
8350 else
8354 }
8356 /* Handle BUILT_IN_NORMAL here. */
8359 {
8361 {
8363 enum built_in_function fncode
8374 {
8377 NULL);
8383 }
8384 else
8385 {
8386 /* This target doesn't have, or doesn't need, active mitigation
8387 against incorrect speculative execution. Simply return the
8388 first parameter to the builtin. */
8390 /* The user has invoked __builtin_speculation_safe_value
8391 even though __HAVE_SPECULATION_SAFE_VALUE is not
8392 defined: emit a warning. */
8394 "this target does not define a speculation barrier; "
8395 "your program will still execute correctly, "
8396 "but incorrect speculation may not be "
8399 /* If the optional second argument is present, handle any side
8400 effects now. */
8407 }
8408 }
8414 {
8415 /* Handle these 4 together so that they can fall through to the next
8416 case if the call is transformed to an _N variant. */
8418 {
8420 {
8424 /* Change to the _N variant. */
8427 }
8430 {
8432 params,
8435 /* Change to the _N variant. */
8438 }
8440 {
8444 /* Change to the _N variant. */
8447 }
8449 {
8453 /* Change to the _N variant. */
8456 }
8459 }
8460 }
8461 /* FALLTHRU */
8467 /* FALLTHRU */
8481 /* FALLTHRU */
8498 {
8499 /* The following are not _FETCH_OPs and must be accepted with
8500 pointers to _Bool (or C++ bool). */
8521 orig_format))
8526 NULL);
8536 /* Prevent -Wunused-value warning. */
8539 /* If new_return is set, assign function to that expr and cast the
8540 result to void since the generic interface returned void. */
8542 {
8543 /* Cast function result from I{1,2,4,8,16} to the required type. */
8545 {
8550 /* For _BitInt which has the padding bits undefined
8551 convert to the _BitInt type rather than VCE to force
8552 zero or sign extension. */
8554 }
8555 result
8558 result);
8562 }
8564 }
8568 }
8569 }
8571 /* vector_types_compatible_elements_p is used in type checks of vectors
8572 values used as operands of binary operators. Where it returns true, and
8573 the other checks of the caller succeed (being vector types in he first
8574 place, and matching number of elements), we can just treat the types
8575 as essentially the same.
8576 Contrast with vector_targets_convertible_p, which is used for vector
8577 pointer types, and vector_types_convertible_p, which will allow
8578 language-specific matches under the control of flag_lax_vector_conversions,
8579 and might still require a conversion. */
8580 /* True if vector types T1 and T2 can be inputs to the same binary
8581 operator without conversion.
8582 We don't check the overall vector size here because some of our callers
8583 want to give different error messages when the vectors are compatible
8584 except for the element count. */
8586 bool
8588 {
8604 /* Equality works here because c_common_signed_type uses
8605 TYPE_MAIN_VARIANT. */
8613 }
8615 /* Check for missing format attributes on function pointers. LTYPE is
8616 the new type or left-hand side type. RTYPE is the old type or
8617 right-hand side type. Returns TRUE if LTYPE is missing the desired
8618 attribute. */
8620 bool
8622 {
8624 tree ra;
8630 {
8631 tree la;
8636 }
8637 else
8639 }
8641 /* Setup a TYPE_DECL node as a typedef representation.
8643 X is a TYPE_DECL for a typedef statement. Create a brand new
8644 ..._TYPE node (which will be just a variant of the existing
8645 ..._TYPE node with identical properties) and then install X
8646 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
8648 The whole point here is to end up with a situation where each
8649 and every ..._TYPE node the compiler creates will be uniquely
8650 associated with AT MOST one node representing a typedef name.
8651 This way, even though the compiler substitutes corresponding
8652 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
8653 early on, later parts of the compiler can always do the reverse
8654 translation and get back the corresponding typedef name. For
8655 example, given:
8657 typedef struct S MY_TYPE;
8658 MY_TYPE object;
8660 Later parts of the compiler might only know that `object' was of
8661 type `struct S' if it were not for code just below. With this
8662 code however, later parts of the compiler see something like:
8664 struct S' == struct S
8665 typedef struct S' MY_TYPE;
8666 struct S' object;
8668 And they can then deduce (from the node for type struct S') that
8669 the original object declaration was:
8671 MY_TYPE object;
8673 Being able to do this is important for proper support of protoize,
8674 and also for generating precise symbolic debugging information
8675 which takes full account of the programmer's (typedef) vocabulary.
8677 Obviously, we don't want to generate a duplicate ..._TYPE node if
8678 the TYPE_DECL node that we are now processing really represents a
8679 standard built-in type. */
8681 void
8683 {
8687 {
8690 }
8693 else
8694 {
8701 /* Mark the type as used only when its type decl is decorated
8702 with attribute unused. */
8707 }
8708 }
8710 /* Return true if it is worth exposing the DECL_ORIGINAL_TYPE of TYPE to
8711 the user in diagnostics, false if it would be better to use TYPE itself.
8712 TYPE is known to satisfy typedef_variant_p. */
8714 bool
8716 {
8720 /* Look through any typedef in "user" code. */
8724 /* If the original type is also named and is in the user namespace,
8725 assume it too is a user-facing type. */
8732 {
8733 /* Don't look through to an anonymous vector type, since the syntax
8734 we use for them in diagnostics isn't real C or C++ syntax.
8735 And if ORIG_TYPE is named but in the implementation namespace,
8736 TYPE is likely to be more meaningful to the user. */
8740 /* Don't expose anonymous tag types that are presumably meant to be
8741 known by their typedef name. Also don't expose tags that are in
8742 the implementation namespace, such as:
8744 typedef struct __foo foo; */
8750 /* Look through to anything else. */
8753 }
8754 }
8756 /* Record the types used by the current global variable declaration
8757 being parsed, so that we can decide later to emit their debug info.
8758 Those types are in types_used_by_cur_var_decl, and we are going to
8759 store them in the types_used_by_vars_hash hash table.
8760 DECL is the declaration of the global variable that has been parsed. */
8762 void
8764 {
8768 {
8771 }
8772 }
8774 /* The C and C++ parsers both use vectors to hold function arguments.
8775 For efficiency, we keep a cache of unused vectors. This is the
8776 cache. */
8781 /* Return a new vector from the cache. If the cache is empty,
8782 allocate a new vector. These vectors are GC'ed, so it is OK if the
8783 pointer is not released.. */
8787 {
8790 else
8791 {
8792 /* Passing 0 to vec::alloc returns NULL, and our callers require
8793 that we always return a non-NULL value. The vector code uses
8794 4 when growing a NULL vector, so we do too. */
8798 }
8799 }
8801 /* Release a vector of trees back to the cache. */
8803 void
8805 {
8807 {
8809 /* Don't cache vecs that have expanded more than once. On a p64
8810 target, vecs double in alloc size with each power of 2 elements, e.g
8811 at 16 elements the alloc increases from 128 to 256 bytes. */
8813 else
8814 {
8817 }
8818 }
8819 }
8821 /* Get a new tree vector holding a single tree. */
8825 {
8829 }
8831 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain. */
8835 {
8840 }
8842 /* Get a new tree vector of the values of a CONSTRUCTOR. */
8846 {
8852 }
8854 /* Get a new tree vector which is a copy of an existing one. */
8858 {
8861 tree t;
8868 }
8870 /* Return true if KEYWORD starts a type specifier. */
8872 bool
8874 {
8876 {
8887 CASE_RID_FLOATN_NX:
8913 }
8914 }
8916 /* Return true if KEYWORD names a type qualifier. */
8918 bool
8920 {
8922 {
8930 }
8931 }
8933 /* Return true if KEYWORD names a storage class specifier.
8935 RID_TYPEDEF is not included in this list despite `typedef' being
8936 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
8937 such for syntactic convenience only. */
8939 bool
8941 {
8943 {
8953 }
8954 }
8956 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
8958 static bool
8960 {
8962 {
8970 }
8971 }
8973 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
8974 declaration-specifier (C99 6.7). */
8976 bool
8978 {
8985 {
8993 }
8994 }
8996 /* Initialize language-specific-bits of tree_contains_struct. */
8998 void
9000 {
9013 }
9015 /* Build a user-defined numeric literal out of an integer constant type VALUE
9016 with identifier SUFFIX. */
9018 tree
9021 {
9028 }
9030 /* For vector[index], convert the vector to an array of the underlying type.
9031 Return true if the resulting ARRAY_REF should not be an lvalue. */
9033 bool
9036 {
9039 {
9041 tree newitype;
9051 /* We are building an ARRAY_REF so mark the vector as addressable
9052 to not run into the gimplifiers premature setting of DECL_GIMPLE_REG_P
9053 for function parameters. */
9056 /* Make sure qualifiers are copied from the vector type to the new element
9057 of the array type. */
9064 }
9066 }
9068 /* Determine which of the operands, if any, is a scalar that needs to be
9069 converted to a vector, for the range of operations. */
9070 enum stv_conv
9073 {
9081 {
9082 /* Most GENERIC binary expressions require homogeneous arguments.
9083 LSHIFT_EXPR and RSHIFT_EXPR are exceptions and accept a first
9084 argument that is a vector and a second one that is a scalar, so
9085 we never return stv_secondarg for them. */
9090 {
9093 {
9098 }
9099 else
9101 }
9108 /* fall through */
9129 /* What about UNLT_EXPR? */
9131 {
9135 }
9139 {
9142 {
9147 }
9149 }
9151 /* Allow integer --> real conversion if safe. */
9155 {
9158 {
9163 }
9165 }
9168 }
9171 }
9173 /* Return the alignment of std::max_align_t.
9175 [support.types.layout] The type max_align_t is a POD type whose alignment
9176 requirement is at least as great as that of every scalar type, and whose
9177 alignment requirement is supported in every context. */
9179 unsigned
9181 {
9187 }
9189 /* Return true iff ALIGN is an integral constant that is a fundamental
9190 alignment, as defined by [basic.align] in the c++-11
9191 specifications.
9193 That is:
9195 [A fundamental alignment is represented by an alignment less than or
9196 equal to the greatest alignment supported by the implementation
9197 in all contexts, which is equal to alignof(max_align_t)]. */
9199 bool
9201 {
9203 }
9205 /* Return true if T is a pointer to a zero-sized aggregate. */
9207 bool
9209 {
9214 }
9216 /* For an EXPR of a FUNCTION_TYPE that references a GCC built-in function
9217 with no library fallback or for an ADDR_EXPR whose operand is such type
9218 issues an error pointing to the location LOC.
9219 Returns true when the expression has been diagnosed and false
9220 otherwise. */
9222 bool
9224 {
9233 /* The intersection of DECL_BUILT_IN and DECL_IS_UNDECLARED_BUILTIN avoids
9234 false positives for user-declared built-ins such as abs or
9235 strlen, and for C++ operators new and delete.
9236 The c_decl_implicit() test avoids false positives for implicitly
9237 declared built-ins with library fallbacks (such as abs). */
9242 {
9246 /* Reject arguments that are built-in functions with
9247 no library fallback. */
9251 }
9254 }
9256 /* Issue an ERROR for an invalid SIZE of array NAME which is null
9257 for unnamed arrays. */
9259 void
9262 {
9265 {
9269 name);
9270 else
9277 else
9279 size);
9285 else
9293 else
9299 }
9300 }
9302 /* Check if array size calculations overflow or if the array covers more
9303 than half of the address space. Return true if the size of the array
9304 is valid, false otherwise. T is either the type of the array or its
9305 size, and NAME is the name of the array, or null for unnamed arrays. */
9307 bool
9309 {
9313 const_tree size;
9315 {
9319 }
9320 else
9326 cst_size_error error;
9334 /* Show the value of the enumerator rather than its name. */
9339 }
9341 /* Read SOURCE_DATE_EPOCH from environment to have a deterministic
9342 timestamp to replace embedded current dates to get reproducible
9343 results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
9345 time_t
9347 {
9357 #if defined(INT64_T_IS_LONG)
9359 #else
9361 #endif
9364 {
9369 }
9372 }
9374 /* Callback for libcpp for offering spelling suggestions for misspelled
9375 directives. GOAL is an unrecognized string; CANDIDATES is a
9376 NULL-terminated array of candidate strings. Return the closest
9377 match to GOAL within CANDIDATES, or NULL if none are good
9378 suggestions. */
9383 {
9388 }
9390 /* Return the latice point which is the wider of the two FLT_EVAL_METHOD
9391 modes X, Y. This isn't just >, as the FLT_EVAL_METHOD values added
9392 by C TS 18661-3 for interchange types that are computed in their
9393 native precision are larger than the C11 values for evaluating in the
9394 precision of float/double/long double. If either mode is
9395 FLT_EVAL_METHOD_UNPREDICTABLE, return that. */
9397 enum flt_eval_method
9400 {
9405 /* GCC only supports one interchange type right now, _Float16. If
9406 we're evaluating _Float16 in 16-bit precision, then flt_eval_method
9407 will be FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
9413 /* Other values for flt_eval_method are directly comparable, and we want
9414 the maximum. */
9416 }
9418 /* Return the value that should be set for FLT_EVAL_METHOD in the
9419 context of ISO/IEC TS 18861-3.
9421 This relates to the effective excess precision seen by the user,
9422 which is the join point of the precision the target requests for
9423 -fexcess-precision={standard,fast,16} and the implicit excess precision
9424 the target uses. */
9426 static enum flt_eval_method
9428 {
9429 enum flt_eval_method implicit
9432 enum excess_precision_type flag_type
9434 ? EXCESS_PRECISION_TYPE_STANDARD
9436 ? EXCESS_PRECISION_TYPE_FLOAT16
9439 enum flt_eval_method requested
9443 }
9445 /* As c_cpp_ts18661_flt_eval_method, but clamps the expected values to
9446 those that were permitted by C11. That is to say, eliminates
9447 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16. */
9449 static enum flt_eval_method
9451 {
9453 FLT_EVAL_METHOD_PROMOTE_TO_FLOAT);
9454 }
9456 /* Return the value that should be set for FLT_EVAL_METHOD.
9457 MAYBE_C11_ONLY_P is TRUE if we should check
9458 FLAG_PERMITTED_EVAL_METHODS as to whether we should limit the possible
9459 values we can return to those from C99/C11, and FALSE otherwise.
9460 See the comments on c_ts18661_flt_eval_method for what value we choose
9461 to set here. */
9463 int
9465 {
9467 && flag_permitted_flt_eval_methods
9470 else
9472 }
9474 /* An enum for get_missing_token_insertion_kind for describing the best
9475 place to insert a missing token, if there is one. */
9477 enum missing_token_insertion_kind
9478 {
9479 MTIK_IMPOSSIBLE,
9480 MTIK_INSERT_BEFORE_NEXT,
9481 MTIK_INSERT_AFTER_PREV
9482 };
9484 /* Given a missing token of TYPE, determine if it is reasonable to
9485 emit a fix-it hint suggesting the insertion of the token, and,
9486 if so, where the token should be inserted relative to other tokens.
9488 It only makes sense to do this for values of TYPE that are symbols.
9490 Some symbols should go before the next token, e.g. in:
9491 if flag)
9492 we want to insert the missing '(' immediately before "flag",
9493 giving:
9494 if (flag)
9495 rather than:
9496 if( flag)
9497 These use MTIK_INSERT_BEFORE_NEXT.
9499 Other symbols should go after the previous token, e.g. in:
9500 if (flag
9501 do_something ();
9502 we want to insert the missing ')' immediately after the "flag",
9503 giving:
9504 if (flag)
9505 do_something ();
9506 rather than:
9507 if (flag
9508 )do_something ();
9509 These use MTIK_INSERT_AFTER_PREV. */
9511 static enum missing_token_insertion_kind
9513 {
9515 {
9516 /* Insert missing "opening" brackets immediately
9517 before the next token. */
9522 /* Insert other missing symbols immediately after
9523 the previous token. */
9531 /* Other kinds of token don't get fix-it hints. */
9534 }
9535 }
9537 /* Given RICHLOC, a location for a diagnostic describing a missing token
9538 of kind TOKEN_TYPE, potentially add a fix-it hint suggesting the
9539 insertion of the token.
9541 The location of the attempted fix-it hint depends on TOKEN_TYPE:
9542 it will either be:
9543 (a) immediately after PREV_TOKEN_LOC, or
9545 (b) immediately before the primary location within RICHLOC (taken to
9546 be that of the token following where the token was expected).
9548 If we manage to add a fix-it hint, then the location of the
9549 fix-it hint is likely to be more useful as the primary location
9550 of the diagnostic than that of the following token, so we swap
9551 these locations.
9553 For example, given this bogus code:
9554 123456789012345678901234567890
9555 1 | int missing_semicolon (void)
9556 2 | {
9557 3 | return 42
9558 4 | }
9560 we will emit:
9562 "expected ';' before '}'"
9564 RICHLOC's primary location is at the closing brace, so before "swapping"
9565 we would emit the error at line 4 column 1:
9567 123456789012345678901234567890
9568 3 | return 42 |< fix-it hint emitted for this line
9569 | ; |
9570 4 | } |< "expected ';' before '}'" emitted at this line
9571 | ^ |
9573 It's more useful for the location of the diagnostic to be at the
9574 fix-it hint, so we swap the locations, so the primary location
9575 is at the fix-it hint, with the old primary location inserted
9576 as a secondary location, giving this, with the error at line 3
9577 column 12:
9579 123456789012345678901234567890
9580 3 | return 42 |< "expected ';' before '}'" emitted at this line,
9581 | ^ | with fix-it hint
9582 4 | ; |
9583 | } |< secondary range emitted here
9584 | ~ |. */
9586 void
9589 location_t prev_token_loc)
9590 {
9593 enum missing_token_insertion_kind mtik
9597 {
9606 /* Attempt to add the fix-it hint before the primary location
9607 of RICHLOC. */
9612 /* Attempt to add the fix-it hint after PREV_TOKEN_LOC. */
9616 }
9618 /* If we were successful, use the fix-it hint's location as the
9619 primary location within RICHLOC, adding the old primary location
9620 back as a secondary location. */
9622 {
9629 }
9630 }
9632 #if CHECKING_P
9636 /* Verify that fold_for_warn on error_mark_node is safe. */
9638 static void
9640 {
9642 }
9644 /* Run all of the selftests within this file. */
9646 static void
9648 {
9650 }
9652 /* Run all of the tests within c-family. */
9654 void
9656 {
9664 }
9670 /* Attempt to locate a suitable location within FILE for a
9671 #include directive to be inserted before.
9672 LOC is the location of the relevant diagnostic.
9674 Attempt to return the location within FILE immediately
9675 after the last #include within that file, or the start of
9676 that file if it has no #include directives.
9678 Return UNKNOWN_LOCATION if no suitable location is found,
9679 or if an error occurs. */
9681 static location_t
9683 {
9684 /* Locate the last ordinary map within FILE that ended with a #include. */
9687 /* ...and the next ordinary map within FILE after that one. */
9690 /* ...and the first ordinary map within FILE. */
9693 /* Get ordinary map containing LOC (or its expansion). */
9700 {
9706 /* We cannot use pointer equality, because with preprocessed
9707 input all filename strings are unique. */
9709 {
9712 }
9714 /* Likewise, use strcmp, and reject any line-zero introductory
9715 map. */
9717 {
9722 }
9724 /* Stop searching when reaching the ord_map containing LOC,
9725 as it makes no sense to provide fix-it hints that appear
9726 after the diagnostic in question. */
9729 }
9731 /* Determine where to insert the #include. */
9734 /* We want the next ordmap in the file after the last one that's a
9735 #include, but failing that, the start of the file. */
9738 else
9744 /* The "start_location" is column 0, meaning "the whole line".
9745 rich_location and edit_context can't cope with this, so use
9746 column 1 instead. */
9749 }
9751 /* A map from filenames to sets of headers added to them, for
9752 ensuring idempotency within maybe_add_include_fixit. */
9754 /* The values within the map. We need string comparison as there's
9755 no guarantee that two different diagnostics that are recommending
9756 adding e.g. "<stdio.h>" are using the same buffer. */
9760 /* The map itself. We don't need string comparison for the filename keys,
9761 as they come from libcpp. */
9766 /* Attempt to add a fix-it hint to RICHLOC, adding "#include HEADER\n"
9767 in a suitable location within the file of RICHLOC's primary
9768 location.
9770 This function is idempotent: a header will be added at most once to
9771 any given file.
9773 If OVERRIDE_LOCATION is true, then if a fix-it is added and will be
9774 printed, then RICHLOC's primary location will be replaced by that of
9775 the fix-it hint (for use by "inform" notes where the location of the
9776 issue has already been reported). */
9778 void
9781 {
9787 /* Idempotency: don't add the same header more than once to a given file. */
9793 /* ...then we've already added HEADER to that file. */
9799 /* Attempt to locate a suitable place for the new directive. */
9800 location_t include_insert_loc
9810 {
9811 /* Replace the primary location with that of the insertion point for the
9812 fix-it hint.
9814 We use SHOW_LINES_WITHOUT_RANGE so that we don't meaningless print a
9815 caret for the insertion point (or colorize it).
9817 Hence we print e.g.:
9819 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
9820 73 | # include <debug/vector>
9821 +++ |+#include <vector>
9822 74 | #endif
9824 rather than:
9826 ../x86_64-pc-linux-gnu/libstdc++-v3/include/vector:74:1: note: msg 2
9827 73 | # include <debug/vector>
9828 +++ |+#include <vector>
9829 74 | #endif
9830 | ^
9832 avoiding the caret on the first column of line 74. */
9834 }
9835 }
9837 /* Attempt to convert a braced array initializer list CTOR for array
9838 TYPE into a STRING_CST for convenience and efficiency. Return
9839 the converted string on success or the original ctor on failure.
9840 Also, for non-convertable CTORs which contain RAW_DATA_CST values
9841 among the elts try to extend the range of RAW_DATA_CSTs. */
9843 static tree
9845 {
9846 /* Ignore non-members with unknown size like arrays with unspecified
9847 bound. */
9852 /* If the target char size differs from the host char size, we'd risk
9853 loosing data and getting object sizes wrong by converting to
9854 host chars. */
9858 /* STRING_CST doesn't support wide characters. */
9861 /* If the array has an explicit bound, use it to constrain the size
9862 of the string. If it doesn't, be sure to create a string that's
9863 as long as implied by the index of the last zero specified via
9864 a designator, as in:
9865 const char a[] = { [7] = 0 }; */
9868 {
9871 }
9872 else
9875 /* Avoid converting initializers for zero-length arrays (but do
9876 create them for flexible array members). */
9890 {
9892 {
9893 /* The preprocessor always surrounds CPP_EMBED tokens in between
9894 CPP_NUMBER and CPP_COMMA tokens. Try to undo that here now that
9895 the whole initializer is parsed. E.g. if we have
9896 [0] = 'T', [1] = "his is a #embed tex", [20] = 't'
9897 where the middle value is RAW_DATA_CST and in its owner this is
9898 surrounded by 'T' and 't' characters, we can create from it just
9899 [0] = "This is a #embed text"
9900 Similarly if a RAW_DATA_CST needs to be split into two parts
9901 because of designated init store but the stored value is actually
9902 the same as in the RAW_DATA_OWNER's memory we can merge multiple
9903 RAW_DATA_CSTs. */
9905 && index
9907 {
9911 {
9912 start
9915 }
9916 else
9917 {
9919 start
9922 }
9926 {
9935 {
9940 }
9945 }
9949 {
9961 {
9965 }
9969 {
9975 }
9982 }
9985 {
9988 else
9998 }
9999 }
10001 {
10005 }
10007 }
10011 {
10013 {
10016 }
10018 }
10020 /* auto_vec is limited to UINT_MAX elements. */
10022 {
10025 }
10027 /* Avoid non-constant initializers. */
10029 {
10033 }
10035 /* Skip over embedded nuls except the last one (initializer
10036 elements are in ascending order of indices). */
10042 {
10045 }
10047 /* Bail if the CTOR has a block of more than 256 embedded nuls
10048 due to implicitly initialized elements. */
10051 {
10054 }
10057 {
10060 }
10063 {
10066 }
10069 }
10072 {
10076 }
10078 /* Append a nul string termination. */
10082 /* Build a STRING_CST with the same type as the array. */
10086 }
10088 /* Implementation of the two-argument braced_lists_to_string withe
10089 the same arguments plus MEMBER which is set for struct members
10090 to allow initializers for flexible member arrays. */
10092 static tree
10094 {
10100 tree ttp;
10104 {
10107 {
10110 }
10111 }
10112 else
10121 {
10124 /* Handle array of arrays or struct member initializers. */
10125 tree val;
10128 {
10131 }
10132 }
10135 }
10137 /* Attempt to convert a CTOR containing braced array initializer lists
10138 for array TYPE into one containing STRING_CSTs, for convenience and
10139 efficiency. Recurse for arrays of arrays and member initializers.
10140 Return the converted CTOR or STRING_CST on success or the original
10141 CTOR otherwise. */
10143 tree
10145 {
10147 }
10150 /* Emit debug for functions before finalizing early debug. */
10152 void
10154 {
10155 /* Emit early debug for reachable functions, and by consequence,
10156 locally scoped symbols. Also emit debug for extern declared
10157 functions that are still reachable at this point. */
10164 }
10166 /* Determine whether TYPE is an ISO C99 flexible array member type "[]". */
10167 bool
10169 {
10177 }
10179 /* Get the LEVEL of the strict_flex_array for the ARRAY_FIELD based on the
10180 values of attribute strict_flex_array and the flag_strict_flex_arrays. */
10181 unsigned int
10183 {
10187 tree attr_strict_flex_array
10189 /* If there is a strict_flex_array attribute attached to the field,
10190 override the flag_strict_flex_arrays. */
10192 {
10193 /* Get the value of the level first from the attribute. */
10202 /* The attribute has higher priority than flag_struct_flex_array. */
10204 }
10206 }
10208 /* Map from identifiers to booleans. Value is true for features, and
10209 false for extensions. Used to implement __has_{feature,extension}. */
10214 /* Register a feature for __has_{feature,extension}. FEATURE_P is true
10215 if the feature identified by NAME is a feature (as opposed to an
10216 extension). */
10218 void
10220 {
10223 }
10225 /* Lazily initialize hash table for __has_{feature,extension},
10226 dispatching to the appropriate front end to register language-specific
10227 features. */
10229 static void
10231 {
10236 {
10244 }
10246 /* Register language-specific features. */
10248 }
10250 /* If STRICT_P is true, evaluate __has_feature (IDENT).
10251 Otherwise, evaluate __has_extension (IDENT). */
10253 bool
10255 {
10265 }
10267 /* This is the slow path of c-common.h's c_hardbool_type_attr. */
10269 tree
10271 {
10283 }