| blob | cab9e7efa572f0de8a3e66d5d94e6d156f2ddeb1 |
1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
52 /* The following symbols are subsumed in the c_global_trees array, and
53 listed here individually for documentation purposes.
55 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
57 tree short_integer_type_node;
58 tree long_integer_type_node;
59 tree long_long_integer_type_node;
60 tree int128_integer_type_node;
62 tree short_unsigned_type_node;
63 tree long_unsigned_type_node;
64 tree long_long_unsigned_type_node;
65 tree int128_unsigned_type_node;
67 tree truthvalue_type_node;
68 tree truthvalue_false_node;
69 tree truthvalue_true_node;
71 tree ptrdiff_type_node;
73 tree unsigned_char_type_node;
74 tree signed_char_type_node;
75 tree wchar_type_node;
77 tree char16_type_node;
78 tree char32_type_node;
80 tree float_type_node;
81 tree double_type_node;
82 tree long_double_type_node;
84 tree complex_integer_type_node;
85 tree complex_float_type_node;
86 tree complex_double_type_node;
87 tree complex_long_double_type_node;
89 tree dfloat32_type_node;
90 tree dfloat64_type_node;
91 tree_dfloat128_type_node;
93 tree intQI_type_node;
94 tree intHI_type_node;
95 tree intSI_type_node;
96 tree intDI_type_node;
97 tree intTI_type_node;
99 tree unsigned_intQI_type_node;
100 tree unsigned_intHI_type_node;
101 tree unsigned_intSI_type_node;
102 tree unsigned_intDI_type_node;
103 tree unsigned_intTI_type_node;
105 tree widest_integer_literal_type_node;
106 tree widest_unsigned_literal_type_node;
108 Nodes for types `void *' and `const void *'.
110 tree ptr_type_node, const_ptr_type_node;
112 Nodes for types `char *' and `const char *'.
114 tree string_type_node, const_string_type_node;
116 Type `char[SOMENUMBER]'.
117 Used when an array of char is needed and the size is irrelevant.
119 tree char_array_type_node;
121 Type `int[SOMENUMBER]' or something like it.
122 Used when an array of int needed and the size is irrelevant.
124 tree int_array_type_node;
126 Type `wchar_t[SOMENUMBER]' or something like it.
127 Used when a wide string literal is created.
129 tree wchar_array_type_node;
131 Type `char16_t[SOMENUMBER]' or something like it.
132 Used when a UTF-16 string literal is created.
134 tree char16_array_type_node;
136 Type `char32_t[SOMENUMBER]' or something like it.
137 Used when a UTF-32 string literal is created.
139 tree char32_array_type_node;
141 Type `int ()' -- used for implicit declaration of functions.
143 tree default_function_type;
145 A VOID_TYPE node, packaged in a TREE_LIST.
147 tree void_list_node;
149 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
150 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
151 VAR_DECLS, but C++ does.)
153 tree function_name_decl_node;
154 tree pretty_function_name_decl_node;
155 tree c99_function_name_decl_node;
157 Stack of nested function name VAR_DECLs.
159 tree saved_function_name_decls;
161 */
164 \f
165 /* Switches common to the C front ends. */
167 /* Nonzero means don't output line number information. */
171 /* Nonzero causes -E output not to be done, but directives such as
172 #define that have side effects are still obeyed. */
176 /* Nonzero means dump macros in some fashion. */
180 /* Nonzero means pass #include lines through to the output. */
184 /* Nonzero means process PCH files while preprocessing. */
188 /* The file name to which we should write a precompiled header, or
189 NULL if no header will be written in this compile. */
193 /* Nonzero if an ISO standard was selected. It rejects macros in the
194 user's namespace. */
197 /* Warn about #pragma directives that are not recognized. */
201 /* Warn about format/argument anomalies in calls to formatted I/O functions
202 (*printf, *scanf, strftime, strfmon, etc.). */
206 /* C/ObjC language option variables. */
209 /* Nonzero means allow type mismatches in conditional expressions;
210 just make their values `void'. */
214 /* Nonzero means enable C89 Amendment 1 features. */
218 /* Nonzero means use the ISO C99 (or C1X) dialect of C. */
222 /* Nonzero means use the ISO C1X dialect of C. */
226 /* Nonzero means that we have builtin functions, and main is an int. */
231 /* ObjC language option variables. */
234 /* Tells the compiler that this is a special run. Do not perform any
235 compiling, instead we are to test some platform dependent features
236 and output a C header file with appropriate definitions. */
240 /* Tells the compiler what is the constant string class for ObjC. */
245 /* C++ language option variables. */
248 /* Nonzero means generate separate instantiation control files and
249 juggle them at link time. */
253 /* The C++ dialect being used. C++98 is the default. */
257 /* Maximum template instantiation depth. This limit exists to limit the
258 time it takes to notice excessively recursive template instantiations;
259 the default value of 1024 is likely to be in the next C++ standard. */
263 /* The elements of `ridpointers' are identifier nodes for the reserved
264 type names and storage classes. It is indexed by a RID_... value. */
269 /* Nonzero means don't warn about problems that occur when the code is
270 executed. */
273 /* Whether we are building a boolean conversion inside
274 convert_for_assignment, or some other late binary operation. If
275 build_binary_op is called for C (from code shared by C and C++) in
276 this case, then the operands have already been folded and the
277 result will not be folded again, so C_MAYBE_CONST_EXPR should not
278 be generated. */
281 /* Whether lexing has been completed, so subsequent preprocessor
282 errors should use the compiler's input_location. */
285 /* Information about how a function name is generated. */
286 struct fname_var_t
287 {
291 };
293 /* The three ways of getting then name of the current function. */
296 {
297 /* C99 compliant __func__, must be first. */
299 /* GCC __FUNCTION__ compliant. */
301 /* GCC __PRETTY_FUNCTION__ compliant. */
304 };
306 /* Global visibility options. */
380 /* Reserved words. The third field is a mask: keywords are disabled
381 if they match the mask.
383 Masks for languages:
384 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
385 C --std=c99: D_CXXONLY | D_OBJC
386 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
387 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
388 C++ --std=c0x: D_CONLY | D_OBJC
389 ObjC++ is like C++ except that D_OBJC is not set
391 If -fno-asm is used, D_ASM is added to the mask. If
392 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
393 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
394 In C with -Wc++-compat, we warn if D_CXXWARN is set.
396 Note the complication of the D_CXX_OBJC keywords. These are
397 reserved words such as 'class'. In C++, 'class' is a reserved
398 word. In Objective-C++ it is too. In Objective-C, it is a
399 reserved word too, but only if it follows an '@' sign.
400 */
402 {
543 /* These Objective-C keywords are recognized only immediately after
544 an '@'. */
561 /* These are recognized only in protocol-qualifier context
562 (see above) */
569 /* These are recognized inside a property attribute list */
578 };
583 /* Table of machine-independent attributes common to all C-like languages. */
585 {
586 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
587 affects_type_identity } */
594 /* FIXME: logically, noreturn attributes should be listed as
595 "false, true, true" and apply to function types. But implementing this
596 would require all the places in the compiler that use TREE_THIS_VOLATILE
597 on a decl to identify non-returning functions to be located and fixed
598 to check the function type instead. */
623 /* The same comments as for noreturn attributes apply to const ones. */
647 handle_no_instrument_function_attribute,
657 /* For internal use (marking of builtins) only. The name contains space
658 to prevent its usage in source code. */
680 /* For internal use (marking of builtins) only. The name contains space
681 to prevent its usage in source code. */
700 /* For internal use (marking of builtins and runtime functions) only.
701 The name contains space to prevent its usage in source code. */
705 };
707 /* Give the specifications for the format attributes, used by C and all
708 descendants. */
711 {
712 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
713 affects_type_identity } */
719 };
721 /* Return identifier for address space AS. */
725 {
729 }
731 /* Push current bindings for the function name VAR_DECLS. */
733 void
735 {
740 {
744 {
747 }
748 }
750 /* Normally they'll have been NULL, so only push if we've got a
751 stack, or they are non-NULL. */
753 saved_function_name_decls);
754 }
756 /* Finish up the current bindings, adding them into the current function's
757 statement tree. This must be done _before_ finish_stmt_tree is called.
758 If there is no current function, we must be at file scope and no statements
759 are involved. Pop the previous bindings. */
761 void
763 {
772 {
780 }
786 {
787 /* We had saved values, restore them. */
788 tree saved;
791 {
796 }
798 }
800 }
802 /* Return the text name of the current function, suitably prettified
803 by PRETTY_P. Return string must be freed by caller. */
807 {
814 {
817 }
830 {
833 }
836 }
838 /* Return the VAR_DECL for a const char array naming the current
839 function. If the VAR_DECL has not yet been created, create it
840 now. RID indicates how it should be formatted and IDENTIFIER_NODE
841 ID is its name (unfortunately C and C++ hold the RID values of
842 keywords in different places, so we can't derive RID from ID in
843 this language independent code. LOC is the location of the
844 function. */
846 tree
848 {
858 {
859 /* If a tree is built here, it would normally have the lineno of
860 the current statement. Later this tree will be moved to the
861 beginning of the function and this line number will be wrong.
862 To avoid this problem set the lineno to 0 here; that prevents
863 it from appearing in the RTL. */
864 tree stmts;
872 saved_function_name_decls
876 }
881 }
883 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
885 tree
887 {
892 /* Compute the number of elements, for the array type. */
894 {
897 }
899 {
902 }
904 {
907 }
908 else
909 {
912 }
914 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
915 limit in C++98 Annex B is very large (65536) and is not normative,
916 so we do not diagnose it (warn_overlength_strings is forced off
917 in c_common_post_options). */
919 {
923 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
924 separate the %d from the 'C'. 'ISO' should not be
925 translated, but it may be moved after 'C%d' in languages
926 where modifiers follow nouns. */
928 "string length %qd is greater than the length %qd "
931 }
933 /* Create the array type for the string constant. The ISO C++
934 standard says that a string literal has type `const char[N]' or
935 `const wchar_t[N]'. We use the same logic when invoked as a C
936 front-end with -Wwrite-strings.
937 ??? We should change the type of an expression depending on the
938 state of a warning flag. We should just be warning -- see how
939 this is handled in the C++ front-end for the deprecated implicit
940 conversion from string literals to `char*' or `wchar_t*'.
942 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
943 array type being the unqualified version of that type.
944 Therefore, if we are constructing an array of const char, we must
945 construct the matching unqualified array type first. The C front
946 end does not require this, but it does no harm, so we do it
947 unconditionally. */
958 }
959 \f
960 /* Fully fold EXPR, an expression that was not folded (beyond integer
961 constant expressions and null pointer constants) when being built
962 up. If IN_INIT, this is in a static initializer and certain
963 changes are made to the folding done. Clear *MAYBE_CONST if
964 MAYBE_CONST is not NULL and EXPR is definitely not a constant
965 expression because it contains an evaluated operator (in C99) or an
966 operator outside of sizeof returning an integer constant (in C90)
967 not permitted in constant expressions, or because it contains an
968 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
969 set to true by callers before calling this function.) Return the
970 folded expression. Function arguments have already been folded
971 before calling this function, as have the contents of SAVE_EXPR,
972 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
973 C_MAYBE_CONST_EXPR. */
975 tree
977 {
978 tree ret;
984 /* This function is not relevant to C++ because C++ folds while
985 parsing, and may need changes to be correct for C++ when C++
986 stops folding while parsing. */
993 {
996 }
1003 }
1005 /* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
1006 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
1007 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1008 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1009 both evaluated and unevaluated subexpressions while
1010 *MAYBE_CONST_ITSELF is carried from only evaluated
1011 subexpressions). */
1013 static tree
1016 {
1028 /* This function is not relevant to C++ because C++ folds while
1029 parsing, and may need changes to be correct for C++ when C++
1030 stops folding while parsing. */
1034 /* Constants, declarations, statements, errors, SAVE_EXPRs and
1035 anything else not counted as an expression cannot usefully be
1036 folded further at this point. */
1042 /* Operands of variable-length expressions (function calls) have
1043 already been folded, as have __builtin_* function calls, and such
1044 expressions cannot occur in constant expressions. */
1046 {
1050 }
1053 {
1062 else
1065 }
1067 /* Assignment, increment, decrement, function call and comma
1068 operators, and statement expressions, cannot occur in constant
1069 expressions if evaluated / outside of sizeof. (Function calls
1070 were handled above, though VA_ARG_EXPR is treated like a function
1071 call here, and statement expressions are handled through
1072 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1074 {
1094 }
1096 /* Fold individual tree codes as appropriate. */
1098 {
1100 /* Any non-constancy will have been marked in a containing
1101 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1109 maybe_const_itself);
1114 {
1117 }
1126 maybe_const_itself);
1129 maybe_const_itself);
1135 {
1139 }
1181 /* Binary operations evaluating both arguments (increment and
1182 decrement are binary internally in GCC). */
1186 maybe_const_itself);
1194 /* The RHS of a MODIFY_EXPR was fully folded when building that
1195 expression for the sake of conversion warnings. */
1198 maybe_const_itself);
1202 ret = in_init
1205 else
1216 CASE_CONVERT:
1226 /* Unary operations. */
1229 maybe_const_itself);
1234 ret = in_init
1237 else
1242 {
1246 }
1248 {
1251 CASE_CONVERT:
1252 /* Don't warn about explicit conversions. We will already
1253 have warned about suspect implicit conversions. */
1260 }
1265 /* Binary operations not necessarily evaluating both
1266 arguments. */
1273 ? truthvalue_false_node
1281 ret = in_init
1284 else
1289 && op0_const
1290 && op0_const_self
1296 && op0_const_self
1322 else
1327 && op0_const
1328 && op0_const_self
1332 && op0_const_self
1336 && op0_const
1337 && op0_const_self
1341 && op0_const_self
1347 /* Each case where an operand with excess precision may be
1348 encountered must remove the EXCESS_PRECISION_EXPR around
1349 inner operands and possibly put one around the whole
1350 expression or possibly convert to the semantic type (which
1351 c_fully_fold does); we cannot tell at this stage which is
1352 appropriate in any particular case. */
1356 /* Various codes may appear through folding built-in functions
1357 and their arguments. */
1359 }
1361 out:
1362 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1363 have been done by this point, so remove them again. */
1367 {
1371 }
1375 }
1377 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1378 return EXP. Otherwise, return either EXP or its known constant
1379 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1380 Is the BLKmode test appropriate? */
1382 tree
1384 {
1385 tree ret;
1387 /* This function is only used by C, for c_fully_fold and other
1388 optimization, and may not be correct for C++. */
1399 /* Avoid unwanted tree sharing between the initializer and current
1400 function's body where the tree can be modified e.g. by the
1401 gimplifier. */
1405 }
1407 /* Print a warning if a constant expression had overflow in folding.
1408 Invoke this function on every expression that the language
1409 requires to be a constant expression.
1410 Note the ANSI C standard says it is erroneous for a
1411 constant expression to overflow. */
1413 void
1415 {
1423 }
1425 /* The same as above but print an unconditional error. */
1426 void
1428 {
1435 }
1437 /* Print a warning if an expression had overflow in folding and its
1438 operands hadn't.
1440 Invoke this function on every expression that
1441 (1) appears in the source code, and
1442 (2) is a constant expression that overflowed, and
1443 (3) is not already checked by convert_and_check;
1444 however, do not invoke this function on operands of explicit casts
1445 or when the expression is the result of an operator and any operand
1446 already overflowed. */
1448 void
1450 {
1455 {
1484 }
1485 }
1487 /* Warn about uses of logical || / && operator in a context where it
1488 is likely that the bitwise equivalent was intended by the
1489 programmer. We have seen an expression in which CODE is a binary
1490 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1491 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
1492 void
1496 {
1508 /* Warn if &&/|| are being used in a context where it is
1509 likely that the bitwise equivalent was intended by the
1510 programmer. That is, an expression such as op && MASK
1511 where op should not be any boolean expression, nor a
1512 constant, and mask seems to be a non-boolean integer constant. */
1520 {
1524 else
1529 }
1531 /* We do not warn for constants because they are typical of macro
1532 expansions that test for features. */
1536 /* This warning only makes sense with logical operands. */
1552 /* If this is an OR operation, invert both sides; we will invert
1553 again at the end. */
1557 /* If both expressions are the same, if we can merge the ranges, and we
1558 can build the range test, return it or it inverted. */
1564 {
1570 "logical %<or%> "
1572 else
1574 "logical %<and%> "
1576 }
1577 }
1580 /* Print a warning about casts that might indicate violation
1581 of strict aliasing rules if -Wstrict-aliasing is used and
1582 strict aliasing mode is in effect. OTYPE is the original
1583 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1585 bool
1587 {
1588 /* Strip pointer conversion chains and get to the correct original type. */
1596 /* If the type we are casting to is a ref-all pointer
1597 dereferencing it is always valid. */
1604 {
1605 /* Casting the address of an object to non void pointer. Warn
1606 if the cast breaks type based aliasing. */
1608 {
1612 }
1613 else
1614 {
1615 /* warn_strict_aliasing >= 3. This includes the default (3).
1616 Only warn if the cast is dereferenced immediately. */
1617 alias_set_type set1 =
1623 {
1627 }
1630 {
1634 }
1635 }
1636 }
1637 else
1639 {
1640 /* At this level, warn for any conversions, even if an address is
1641 not taken in the same statement. This will likely produce many
1642 false positives, but could be useful to pinpoint problems that
1643 are not revealed at higher levels. */
1648 {
1652 }
1653 }
1656 }
1658 /* Warn for unlikely, improbable, or stupid DECL declarations
1659 of `main'. */
1661 void
1663 {
1664 tree args;
1669 {
1677 {
1681 decl);
1690 decl);
1701 }
1702 }
1704 /* It is intentional that this message does not mention the third
1705 argument because it's only mentioned in an appendix of the
1706 standard. */
1709 }
1711 /* True if pointers to distinct types T1 and T2 can be converted to
1712 each other without an explicit cast. Only returns true for opaque
1713 vector types. */
1714 bool
1716 {
1723 }
1725 /* True if vector types T1 and T2 can be converted to each other
1726 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1727 can only be converted with -flax-vector-conversions yet that is not
1728 in effect, emit a note telling the user about that option if such
1729 a note has not previously been emitted. */
1730 bool
1732 {
1740 convertible_lax =
1755 {
1758 "conversions between vectors with differing "
1760 }
1763 }
1765 /* This is a helper function of build_binary_op.
1767 For certain operations if both args were extended from the same
1768 smaller type, do the arithmetic in that type and then extend.
1770 BITWISE indicates a bitwise operation.
1771 For them, this optimization is safe only if
1772 both args are zero-extended or both are sign-extended.
1773 Otherwise, we might change the result.
1774 Eg, (short)-1 | (unsigned short)-1 is (int)-1
1775 but calculated in (unsigned short) it would be (unsigned short)-1.
1776 */
1778 {
1782 tree type;
1784 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1785 excessive narrowing when we call get_narrower below. For
1786 example, suppose that OP0 is of unsigned int extended
1787 from signed char and that RESULT_TYPE is long long int.
1788 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1789 like
1791 (long long int) (unsigned int) signed_char
1793 which get_narrower would narrow down to
1795 (unsigned int) signed char
1797 If we do not cast OP0 first, get_narrower would return
1798 signed_char, which is inconsistent with the case of the
1799 explicit cast. */
1806 /* UNS is 1 if the operation to be done is an unsigned one. */
1809 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1810 but it *requires* conversion to FINAL_TYPE. */
1821 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
1823 /* For bitwise operations, signedness of nominal type
1824 does not matter. Consider only how operands were extended. */
1828 /* Note that in all three cases below we refrain from optimizing
1829 an unsigned operation on sign-extended args.
1830 That would not be valid. */
1832 /* Both args variable: if both extended in same way
1833 from same width, do it in that width.
1834 Do it unsigned if args were zero-extended. */
1841 return c_common_signed_or_unsigned_type
1848 && (type
1859 && (type
1867 }
1869 /* Warns if the conversion of EXPR to TYPE may alter a value.
1870 This is a helper function for warnings_for_convert_and_check. */
1872 static void
1874 {
1885 /* If any operand is artificial, then this expression was generated
1886 by the compiler and we do not warn. */
1888 {
1892 }
1895 {
1908 /* Conversion from boolean to a signed:1 bit-field (which only
1909 can hold the values 0 and -1) doesn't lose information - but
1910 it does change the value. */
1919 /* Warn for real constant that is not an exact integer converted
1920 to integer type. */
1923 {
1926 }
1927 /* Warn for an integer constant that does not fit into integer type. */
1931 {
1939 else
1941 }
1943 {
1944 /* Warn for an integer constant that does not fit into real type. */
1946 {
1950 }
1951 /* Warn for a real constant that does not fit into a smaller
1952 real type. */
1955 {
1959 }
1960 }
1970 {
1971 /* In case of COND_EXPR, if both operands are constants or
1972 COND_EXPR, then we do not care about the type of COND_EXPR,
1973 only about the conversion of each operand. */
1981 {
1985 }
1986 /* Fall through. */
1987 }
1991 /* Warn for real types converted to integer types. */
1998 {
1999 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
2003 /* Don't warn for short y; short x = ((int)y & 0xff); */
2007 {
2008 /* If both args were extended from a shortest type,
2009 use that type if that is safe. */
2016 {
2022 /* If one of the operands is a non-negative constant
2023 that fits in the target type, then the type of the
2024 other operand does not matter. */
2033 /* If constant is unsigned and fits in the target
2034 type, then the result will also fit. */
2036 && unsigned0
2039 && unsigned1
2042 }
2043 }
2044 /* Warn for integer types converted to smaller integer types. */
2048 /* When they are the same width but different signedness,
2049 then the value may change. */
2052 /* Even when converted to a bigger type, if the type is
2053 unsigned but expr is signed, then negative values
2054 will be changed. */
2059 }
2061 /* Warn for integer types converted to real types if and only if
2062 all the range of values of the integer type cannot be
2063 represented by the real type. */
2066 {
2070 /* Don't warn about char y = 0xff; float x = (int) y; */
2082 }
2084 /* Warn for real types converted to smaller real types. */
2095 }
2096 }
2098 /* Produce warnings after a conversion. RESULT is the result of
2099 converting EXPR to TYPE. This is a helper function for
2100 convert_and_check and cp_convert_and_check. */
2102 void
2104 {
2109 {
2110 /* Do not diagnose overflow in a constant expression merely
2111 because a conversion overflowed. */
2116 {
2117 /* This detects cases like converting -129 or 256 to
2118 unsigned char. */
2122 else
2124 }
2128 /* No warning for converting 0x80000000 to int. */
2136 else
2138 }
2143 else
2145 }
2148 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2149 Invoke this function on every expression that is converted implicitly,
2150 i.e. because of language rules and not because of an explicit cast. */
2152 tree
2154 {
2155 tree result;
2156 tree expr_for_warning;
2158 /* Convert from a value with possible excess precision rather than
2159 via the semantic type, but do not warn about values not fitting
2160 exactly in the semantic type. */
2162 {
2168 }
2169 else
2183 }
2184 \f
2185 /* A node in a list that describes references to variables (EXPR), which are
2186 either read accesses if WRITER is zero, or write accesses, in which case
2187 WRITER is the parent of EXPR. */
2188 struct tlist
2189 {
2192 };
2194 /* Used to implement a cache the results of a call to verify_tree. We only
2195 use this for SAVE_EXPRs. */
2196 struct tlist_cache
2197 {
2201 tree expr;
2202 };
2204 /* Obstack to use when allocating tlist structures, and corresponding
2205 firstobj. */
2209 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2210 warnings. */
2212 /* SAVE_EXPRs need special treatment. We process them only once and then
2213 cache the results. */
2225 /* Create a new struct tlist and fill in its fields. */
2228 {
2235 }
2237 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2238 is nonnull, we ignore any node we find which has a writer equal to it. */
2240 static void
2242 {
2244 {
2251 }
2252 }
2254 /* Merge the nodes of ADD into TO. This merging process is done so that for
2255 each variable that already exists in TO, no new node is added; however if
2256 there is a write access recorded in ADD, and an occurrence on TO is only
2257 a read access, then the occurrence in TO will be modified to record the
2258 write. */
2260 static void
2262 {
2269 {
2276 {
2280 }
2282 {
2286 }
2288 }
2289 }
2291 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2292 references in list LIST conflict with it, excluding reads if ONLY writers
2293 is nonzero. */
2295 static void
2298 {
2301 /* Avoid duplicate warnings. */
2307 {
2311 {
2316 }
2318 }
2319 }
2321 /* Given a list LIST of references to variables, find whether any of these
2322 can cause conflicts due to missing sequence points. */
2324 static void
2326 {
2330 {
2333 }
2334 }
2336 /* Return nonzero if X is a tree that can be verified by the sequence point
2337 warnings. */
2338 static int
2340 {
2344 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2345 (lvalue_p) crash on TRY/CATCH. */
2352 /* No point to track non-const calls, they will never satisfy
2353 operand_equal_p. */
2361 }
2363 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2364 static bool
2366 {
2368 }
2370 /* Walk the tree X, and record accesses to variables. If X is written by the
2371 parent tree, WRITER is the parent.
2372 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2373 expression or its only operand forces a sequence point, then everything up
2374 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2375 in PNO_SP.
2376 Once we return, we will have emitted warnings if any subexpression before
2377 such a sequence point could be undefined. On a higher level, however, the
2378 sequence point may not be relevant, and we'll merge the two lists.
2380 Example: (b++, a) + b;
2381 The call that processes the COMPOUND_EXPR will store the increment of B
2382 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2383 processes the PLUS_EXPR will need to merge the two lists so that
2384 eventually, all accesses end up on the same list (and we'll warn about the
2385 unordered subexpressions b++ and b.
2387 A note on merging. If we modify the former example so that our expression
2388 becomes
2389 (b++, b) + a
2390 care must be taken not simply to add all three expressions into the final
2391 PNO_SP list. The function merge_tlist takes care of that by merging the
2392 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2393 way, so that no more than one access to B is recorded. */
2395 static void
2397 tree writer)
2398 {
2403 /* X may be NULL if it is the operand of an empty statement expression
2404 ({ }). */
2408 restart:
2416 {
2448 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2449 two first, to avoid warning for (a ? b++ : b++). */
2465 /* Expressions inside the LHS are not ordered wrt. the sequence points
2466 in the RHS. Example:
2467 *a = (a++, 2)
2468 Despite the fact that the modification of "a" is in the before_sp
2469 list (tmp_before), it conflicts with the use of "a" in the LHS.
2470 We can handle this by adding the contents of tmp_list3
2471 to those of tmp_before, and redoing the collision warnings for that
2472 list. */
2475 /* Exclude the LHS itself here; we first have to merge it into the
2476 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2477 didn't exclude the LHS, we'd get it twice, once as a read and once
2478 as a write. */
2489 /* We need to warn about conflicts among arguments and conflicts between
2490 args and the function address. Side effects of the function address,
2491 however, are not ordered by the sequence point of the call. */
2492 {
2493 call_expr_arg_iterator iter;
2494 tree arg;
2498 {
2503 }
2508 }
2511 /* Scan all the list, e.g. indices of multi dimensional array. */
2513 {
2519 }
2523 {
2530 {
2542 {
2546 }
2549 }
2553 }
2563 /* For other expressions, simply recurse on their operands.
2564 Manual tail recursion for unary expressions.
2565 Other non-expressions need not be processed. */
2567 {
2571 }
2573 {
2577 {
2582 }
2583 }
2585 }
2586 }
2588 /* Try to warn for undefined behavior in EXPR due to missing sequence
2589 points. */
2591 DEBUG_FUNCTION void
2593 {
2599 {
2602 }
2607 }
2608 \f
2609 /* Validate the expression after `case' and apply default promotions. */
2611 static tree
2613 {
2618 /* Promote char or short to int. */
2621 {
2624 }
2629 }
2630 \f
2631 /* See if the case values LOW and HIGH are in the range of the original
2632 type (i.e. before the default conversion to int) of the switch testing
2633 expression.
2634 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2635 the type before promoting it. CASE_LOW_P is a pointer to the lower
2636 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2637 if the case is not a case range.
2638 The caller has to make sure that we are not called with NULL for
2639 CASE_LOW_P (i.e. the default case).
2640 Returns true if the case label is in range of ORIG_TYPE (saturated or
2641 untouched) or false if the label is out of range. */
2643 static bool
2646 {
2651 /* If there was a problem with the original type, do nothing. */
2658 /* Case label is less than minimum for type. */
2661 {
2664 }
2666 /* Case value is greater than maximum for type. */
2669 {
2672 }
2674 /* Saturate lower case label value to minimum. */
2677 {
2681 }
2683 /* Saturate upper case label value to maximum. */
2686 {
2690 }
2698 }
2699 \f
2700 /* Return an integer type with BITS bits of precision,
2701 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2703 tree
2705 {
2744 }
2746 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2747 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2748 and saturating if SATP is nonzero, otherwise not saturating. */
2750 tree
2753 {
2757 else
2765 {
2767 "fixed-point types that have too many integral and "
2770 }
2773 }
2775 /* Used for communication between c_common_type_for_mode and
2776 c_register_builtin_type. */
2779 /* Return a data type that has machine mode MODE.
2780 If the mode is an integer,
2781 then UNSIGNEDP selects between signed and unsigned types.
2782 If the mode is a fixed-point mode,
2783 then UNSIGNEDP selects between saturating and nonsaturating types. */
2785 tree
2787 {
2788 tree t;
2825 #if HOST_BITS_PER_WIDE_INT >= 64
2828 #endif
2853 {
2855 tree inner_type;
2871 }
2873 {
2878 }
2888 {
2974 }
2981 }
2983 tree
2985 {
2987 }
2989 /* Return a signed type the same as TYPE in other respects. */
2991 tree
2993 {
2995 }
2997 /* Return a type the same as TYPE except unsigned or
2998 signed according to UNSIGNEDP. */
3000 tree
3002 {
3003 tree type1;
3005 /* This block of code emulates the behavior of the old
3006 c_common_unsigned_type. In particular, it returns
3007 long_unsigned_type_node if passed a long, even when a int would
3008 have the same size. This is necessary for warnings to work
3009 correctly in archs where sizeof(int) == sizeof(long) */
3012 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3028 #if HOST_BITS_PER_WIDE_INT >= 64
3031 #endif
3041 #define C_COMMON_FIXED_TYPES(NAME) \
3042 if (type1 == short_ ## NAME ## _type_node \
3043 || type1 == unsigned_short_ ## NAME ## _type_node) \
3044 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3045 : short_ ## NAME ## _type_node; \
3046 if (type1 == NAME ## _type_node \
3047 || type1 == unsigned_ ## NAME ## _type_node) \
3048 return unsignedp ? unsigned_ ## NAME ## _type_node \
3049 : NAME ## _type_node; \
3050 if (type1 == long_ ## NAME ## _type_node \
3051 || type1 == unsigned_long_ ## NAME ## _type_node) \
3052 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3053 : long_ ## NAME ## _type_node; \
3054 if (type1 == long_long_ ## NAME ## _type_node \
3055 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3056 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3057 : long_long_ ## NAME ## _type_node;
3059 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3060 if (type1 == NAME ## _type_node \
3061 || type1 == u ## NAME ## _type_node) \
3062 return unsignedp ? u ## NAME ## _type_node \
3063 : NAME ## _type_node;
3065 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3066 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3067 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3068 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3069 : sat_ ## short_ ## NAME ## _type_node; \
3070 if (type1 == sat_ ## NAME ## _type_node \
3071 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3072 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3073 : sat_ ## NAME ## _type_node; \
3074 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3075 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3076 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3077 : sat_ ## long_ ## NAME ## _type_node; \
3078 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3079 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3080 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3081 : sat_ ## long_long_ ## NAME ## _type_node;
3083 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3084 if (type1 == sat_ ## NAME ## _type_node \
3085 || type1 == sat_ ## u ## NAME ## _type_node) \
3086 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3087 : sat_ ## NAME ## _type_node;
3113 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3114 the precision; they have precision set to match their range, but
3115 may use a wider mode to match an ABI. If we change modes, we may
3116 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3117 the precision as well, so as to yield correct results for
3118 bit-field types. C++ does not have these separate bit-field
3119 types, and producing a signed or unsigned variant of an
3120 ENUMERAL_TYPE may cause other problems as well. */
3126 #define TYPE_OK(node) \
3127 (TYPE_MODE (type) == TYPE_MODE (node) \
3128 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3147 #if HOST_BITS_PER_WIDE_INT >= 64
3150 #endif
3159 #undef TYPE_OK
3162 }
3164 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3166 tree
3168 {
3169 /* Extended integer types of the same width as a standard type have
3170 lesser rank, so those of the same width as int promote to int or
3171 unsigned int and are valid for printf formats expecting int or
3172 unsigned int. To avoid such special cases, avoid creating
3173 extended integer types for bit-fields if a standard integer type
3174 is available. */
3191 }
3193 /* The C version of the register_builtin_type langhook. */
3195 void
3197 {
3198 tree decl;
3208 }
3209 \f
3210 /* Print an error message for invalid operands to arith operation
3211 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3212 LOCATION is the location of the message. */
3214 void
3217 {
3221 {
3266 }
3270 }
3271 \f
3272 /* Subroutine of build_binary_op, used for comparison operations.
3273 See if the operands have both been converted from subword integer types
3274 and, if so, perhaps change them both back to their original type.
3275 This function is also responsible for converting the two operands
3276 to the proper common type for comparison.
3278 The arguments of this function are all pointers to local variables
3279 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3280 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3282 If this function returns nonzero, it means that the comparison has
3283 a constant value. What this function returns is an expression for
3284 that value. */
3286 tree
3289 {
3290 tree type;
3298 /* Throw away any conversions to wider types
3299 already present in the operands. */
3304 /* If primopN is first sign-extended from primopN's precision to opN's
3305 precision, then zero-extended from opN's precision to
3306 *restype_ptr precision, shortenings might be invalid. */
3309 && !unsignedp0
3314 && !unsignedp1
3318 /* Handle the case that OP0 does not *contain* a conversion
3319 but it *requires* conversion to FINAL_TYPE. */
3326 /* If one of the operands must be floated, we cannot optimize. */
3330 /* If first arg is constant, swap the args (changing operation
3331 so value is preserved), for canonicalization. Don't do this if
3332 the second arg is 0. */
3337 {
3354 {
3369 }
3371 }
3373 /* If comparing an integer against a constant more bits wide,
3374 maybe we can deduce a value of 1 or 0 independent of the data.
3375 Or else truncate the constant now
3376 rather than extend the variable at run time.
3378 This is only interesting if the constant is the wider arg.
3379 Also, it is not safe if the constant is unsigned and the
3380 variable arg is signed, since in this case the variable
3381 would be sign-extended and then regarded as unsigned.
3382 Our technique fails in this case because the lowest/highest
3383 possible unsigned results don't follow naturally from the
3384 lowest/highest possible values of the variable operand.
3385 For just EQ_EXPR and NE_EXPR there is another technique that
3386 could be used: see if the constant can be faithfully represented
3387 in the other operand's type, by truncating it and reextending it
3388 and see if that preserves the constant's value. */
3394 {
3397 /* 1 if comparison is nominally unsigned. */
3399 tree val;
3411 {
3412 /* Convert primop1 to target type, but do not introduce
3413 additional overflow. We know primop1 is an int_cst. */
3417 }
3419 {
3422 }
3425 {
3430 }
3431 else
3432 {
3437 }
3440 /* This used to be a switch, but Genix compiler can't handle that. */
3442 {
3445 }
3447 {
3450 }
3452 {
3457 }
3459 {
3464 }
3466 {
3471 }
3473 {
3478 }
3480 /* If primop0 was sign-extended and unsigned comparison specd,
3481 we did a signed comparison above using the signed type bounds.
3482 But the comparison we output must be unsigned.
3484 Also, for inequalities, VAL is no good; but if the signed
3485 comparison had *any* fixed result, it follows that the
3486 unsigned comparison just tests the sign in reverse
3487 (positive values are LE, negative ones GE).
3488 So we can generate an unsigned comparison
3489 against an extreme value of the signed type. */
3492 {
3495 {
3510 }
3512 }
3515 {
3520 }
3523 {
3524 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3528 }
3530 /* Value is not predetermined, but do the comparison
3531 in the type of the operand that is not constant.
3532 TYPE is already properly set. */
3533 }
3535 /* If either arg is decimal float and the other is float, find the
3536 proper common type to use for comparison. */
3547 /* If args' natural types are both narrower than nominal type
3548 and both extend in the same manner, compare them
3549 in the type of the wider arg.
3550 Otherwise must actually extend both to the nominal
3551 common type lest different ways of extending
3552 alter the result.
3553 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3558 {
3562 type);
3563 /* Make sure shorter operand is extended the right way
3564 to match the longer operand. */
3565 primop0
3568 primop0);
3569 primop1
3572 primop1);
3573 }
3574 else
3575 {
3576 /* Here we must do the comparison on the nominal type
3577 using the args exactly as we received them. */
3584 {
3587 {
3589 /* All unsigned values are >= 0, so we warn. However,
3590 if OP0 is a constant that is >= 0, the signedness of
3591 the comparison isn't an issue, so suppress the
3592 warning. */
3596 primop0))))
3606 primop0))))
3614 }
3617 {
3618 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3623 }
3624 }
3625 }
3633 }
3634 \f
3635 /* Return a tree for the sum or difference (RESULTCODE says which)
3636 of pointer PTROP and integer INTOP. */
3638 tree
3641 {
3644 /* The result is a pointer of the same type that is being added. */
3648 {
3652 }
3654 {
3658 }
3660 {
3664 }
3665 else
3668 /* We are manipulating pointer values, so we don't need to warn
3669 about relying on undefined signed overflow. We disable the
3670 warning here because we use integer types so fold won't know that
3671 they are really pointers. */
3674 /* If what we are about to multiply by the size of the elements
3675 contains a constant term, apply distributive law
3676 and multiply that constant term separately.
3677 This helps produce common subexpressions. */
3682 /* If the constant comes from pointer subtraction,
3683 skip this optimization--it would cause an error. */
3685 /* If the constant is unsigned, and smaller than the pointer size,
3686 then we must skip this optimization. This is because it could cause
3687 an overflow error if the constant is negative but INTOP is not. */
3691 {
3696 /* Convert both subexpression types to the type of intop,
3697 because weird cases involving pointer arithmetic
3698 can result in a sum or difference with different type args. */
3703 }
3705 /* Convert the integer argument to a type the same size as sizetype
3706 so the multiply won't overflow spuriously. */
3712 /* Replace the integer argument with a suitable product by the object size.
3713 Do this multiplication as signed, then convert to the appropriate type
3714 for the pointer operation and disregard an overflow that occured only
3715 because of the sign-extension change in the latter conversion. */
3716 {
3724 }
3726 /* Create the sum or difference. */
3735 }
3736 \f
3737 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3738 and if NON_CONST is known not to be permitted in an evaluated part
3739 of a constant expression. */
3741 tree
3743 {
3747 /* This should never be called for C++. */
3751 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3760 }
3762 /* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3763 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3764 around the SAVE_EXPR if needed so that c_fully_fold does not need
3765 to look inside SAVE_EXPRs. */
3767 tree
3769 {
3778 }
3780 /* Return whether EXPR is a declaration whose address can never be
3781 NULL. */
3783 bool
3785 {
3790 }
3792 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3793 or for an `if' or `while' statement or ?..: exp. It should already
3794 have been validated to be of suitable type; otherwise, a bad
3795 diagnostic may result.
3797 The EXPR is located at LOCATION.
3799 This preparation consists of taking the ordinary
3800 representation of an expression expr and producing a valid tree
3801 boolean expression describing whether expr is nonzero. We could
3802 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3803 but we optimize comparisons, &&, ||, and !.
3805 The resulting type should always be `truthvalue_type_node'. */
3807 tree
3809 {
3811 {
3853 ? truthvalue_true_node
3859 ? truthvalue_true_node
3864 /* Fall through. */
3867 {
3870 {
3871 /* Common Ada/Pascal programmer's mistake. */
3873 OPT_Waddress,
3875 inner);
3877 }
3879 }
3896 /* These don't change whether an object is nonzero or zero. */
3901 /* These don't change whether an object is zero or nonzero, but
3902 we can't ignore them if their second arg has side-effects. */
3904 {
3907 c_common_truthvalue_conversion
3910 }
3911 else
3916 /* Distribute the conversion into the arms of a COND_EXPR. */
3918 {
3928 }
3929 else
3930 {
3931 /* Folding will happen later for C. */
3939 }
3941 CASE_CONVERT:
3942 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3943 since that affects how `default_conversion' will behave. */
3947 /* If this is widening the argument, we can ignore it. */
3957 {
3961 }
3966 }
3969 {
3971 expr = (build_binary_op
3975 c_common_truthvalue_conversion
3978 c_common_truthvalue_conversion
3983 }
3986 {
3991 }
3992 else
3995 ret:
3998 }
3999 \f
4008 /* Apply the TYPE_QUALS to the new DECL. */
4010 void
4012 {
4020 /* An object declared 'const' is only readonly after it is
4021 initialized. We don't have any way of expressing this currently,
4022 so we need to be conservative and unset TREE_READONLY for types
4023 with constructors. Otherwise aliasing code will ignore stores in
4024 an inline constructor. */
4028 {
4031 }
4033 {
4035 /* Allow 'restrict' on arrays of pointers.
4036 FIXME currently we just ignore it. */
4042 }
4043 }
4045 /* Hash function for the problem of multiple type definitions in
4046 different files. This must hash all types that will compare
4047 equal via comptypes to the same value. In practice it hashes
4048 on some of the simple stuff and leaves the details to comptypes. */
4050 static hashval_t
4052 {
4056 tree t2;
4058 {
4059 /* For pointers, hash on pointee type plus some swizzling. */
4062 /* Hash on number of elements and total size. */
4081 }
4082 /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4083 TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST. */
4085 /* We might have a VLA here. */
4088 else
4091 }
4095 /* Return the typed-based alias set for T, which may be an expression
4096 or a type. Return -1 if we don't do anything special. */
4098 alias_set_type
4100 {
4101 tree u;
4104 /* For VLAs, use the alias set of the element type rather than the
4105 default of alias set 0 for types compared structurally. */
4107 {
4111 }
4113 /* Permit type-punning when accessing a union, provided the access
4114 is directly through the union. For example, this code does not
4115 permit taking the address of a union member and then storing
4116 through it. Even the type-punning allowed here is a GCC
4117 extension, albeit a common and useful one; the C standard says
4118 that such accesses have implementation-defined behavior. */
4126 /* That's all the expressions we handle specially. */
4130 /* The C standard guarantees that any object may be accessed via an
4131 lvalue that has character type. */
4137 /* The C standard specifically allows aliasing between signed and
4138 unsigned variants of the same type. We treat the signed
4139 variant as canonical. */
4141 {
4144 /* t1 == t can happen for boolean nodes which are always unsigned. */
4147 }
4149 /* Handle the case of multiple type nodes referring to "the same" type,
4150 which occurs with IMA. These share an alias set. FIXME: Currently only
4151 C90 is handled. (In C99 type compatibility is not transitive, which
4152 complicates things mightily. The alias set splay trees can theoretically
4153 represent this, but insertion is tricky when you consider all the
4154 different orders things might arrive in.) */
4159 /* Save time if there's only one input file. */
4163 /* Pointers need special handling if they point to any type that
4164 needs special handling (below). */
4166 {
4167 tree t2;
4168 /* Find bottom type under any nested POINTERs. */
4172 ;
4180 }
4181 /* These are the only cases that need special handling. */
4188 /* Undefined? */
4192 /* Look up t in hash table. Only one of the compatible types within each
4193 alias set is recorded in the table. */
4197 NULL);
4200 {
4203 }
4204 else
4205 /* Our caller will assign and record (in t) a new alias set; all we need
4206 to do is remember t in the hash table. */
4210 }
4211 \f
4212 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4213 the second parameter indicates which OPERATOR is being applied.
4214 The COMPLAIN flag controls whether we should diagnose possibly
4215 ill-formed constructs or not. LOC is the location of the SIZEOF or
4216 TYPEOF operator. */
4218 tree
4221 {
4229 {
4231 {
4238 }
4239 else
4241 }
4243 {
4251 }
4253 {
4258 }
4259 else
4260 {
4262 /* Convert in case a char is more than one unit. */
4266 else
4268 }
4270 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4271 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4272 never happen. However, this node should really have type
4273 `size_t', which is just a typedef for an ordinary integer type. */
4278 }
4280 /* Implement the __alignof keyword: Return the minimum required
4281 alignment of EXPR, measured in bytes. For VAR_DECLs,
4282 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4283 from an "aligned" __attribute__ specification). LOC is the
4284 location of the ALIGNOF operator. */
4286 tree
4288 {
4289 tree t;
4296 {
4299 }
4305 {
4312 {
4319 }
4321 }
4322 else
4326 }
4327 \f
4328 /* Handle C and C++ default attributes. */
4330 enum built_in_attribute
4331 {
4332 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4333 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4334 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4335 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4337 #undef DEF_ATTR_NULL_TREE
4338 #undef DEF_ATTR_INT
4339 #undef DEF_ATTR_IDENT
4340 #undef DEF_ATTR_TREE_LIST
4341 ATTR_LAST
4342 };
4348 enum c_builtin_type
4349 {
4350 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4351 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4352 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4353 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4354 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4355 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4356 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4357 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4358 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4359 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4360 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4361 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4362 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4363 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4364 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4365 NAME,
4366 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4368 #undef DEF_PRIMITIVE_TYPE
4369 #undef DEF_FUNCTION_TYPE_0
4370 #undef DEF_FUNCTION_TYPE_1
4371 #undef DEF_FUNCTION_TYPE_2
4372 #undef DEF_FUNCTION_TYPE_3
4373 #undef DEF_FUNCTION_TYPE_4
4374 #undef DEF_FUNCTION_TYPE_5
4375 #undef DEF_FUNCTION_TYPE_6
4376 #undef DEF_FUNCTION_TYPE_7
4377 #undef DEF_FUNCTION_TYPE_VAR_0
4378 #undef DEF_FUNCTION_TYPE_VAR_1
4379 #undef DEF_FUNCTION_TYPE_VAR_2
4380 #undef DEF_FUNCTION_TYPE_VAR_3
4381 #undef DEF_FUNCTION_TYPE_VAR_4
4382 #undef DEF_FUNCTION_TYPE_VAR_5
4383 #undef DEF_POINTER_TYPE
4384 BT_LAST
4385 };
4389 /* A temporary array for c_common_nodes_and_builtins. Used in
4390 communication with def_fn_type. */
4393 /* A helper function for c_common_nodes_and_builtins. Build function type
4394 for DEF with return type RET and N arguments. If VAR is true, then the
4395 function should be variadic after those N arguments.
4397 Takes special care not to ICE if any of the types involved are
4398 error_mark_node, which indicates that said type is not in fact available
4399 (see builtin_type_for_size). In which case the function type as a whole
4400 should be error_mark_node. */
4402 static void
4404 {
4411 {
4417 }
4429 egress:
4432 }
4434 /* Build builtin functions common to both C and C++ language
4435 frontends. */
4437 static void
4439 {
4440 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4441 builtin_types[ENUM] = VALUE;
4442 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4443 def_fn_type (ENUM, RETURN, 0, 0);
4444 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4445 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4446 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4447 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4448 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4449 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4450 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4451 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4452 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4453 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4454 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4455 ARG6) \
4456 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4457 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4458 ARG6, ARG7) \
4459 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4460 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4461 def_fn_type (ENUM, RETURN, 1, 0);
4462 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4463 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4464 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4465 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4466 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4467 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4468 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4469 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4470 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4471 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4472 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4473 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4477 #undef DEF_PRIMITIVE_TYPE
4478 #undef DEF_FUNCTION_TYPE_1
4479 #undef DEF_FUNCTION_TYPE_2
4480 #undef DEF_FUNCTION_TYPE_3
4481 #undef DEF_FUNCTION_TYPE_4
4482 #undef DEF_FUNCTION_TYPE_5
4483 #undef DEF_FUNCTION_TYPE_6
4484 #undef DEF_FUNCTION_TYPE_VAR_0
4485 #undef DEF_FUNCTION_TYPE_VAR_1
4486 #undef DEF_FUNCTION_TYPE_VAR_2
4487 #undef DEF_FUNCTION_TYPE_VAR_3
4488 #undef DEF_FUNCTION_TYPE_VAR_4
4489 #undef DEF_FUNCTION_TYPE_VAR_5
4490 #undef DEF_POINTER_TYPE
4495 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4496 NONANSI_P, ATTRS, IMPLICIT, COND) \
4497 if (NAME && COND) \
4498 def_builtin_1 (ENUM, NAME, CLASS, \
4499 builtin_types[(int) TYPE], \
4500 builtin_types[(int) LIBTYPE], \
4501 BOTH_P, FALLBACK_P, NONANSI_P, \
4502 built_in_attributes[(int) ATTRS], IMPLICIT);
4504 #undef DEF_BUILTIN
4512 }
4514 /* Like get_identifier, but avoid warnings about null arguments when
4515 the argument may be NULL for targets where GCC lacks stdint.h type
4516 information. */
4520 {
4522 }
4524 /* Build tree nodes and builtin functions common to both C and C++ language
4525 frontends. */
4527 void
4529 {
4533 tree array_domain_type;
4534 tree va_list_ref_type_node;
4535 tree va_list_arg_type_node;
4537 /* Define `int' and `char' first so that dbx will output them first. */
4541 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4542 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4543 but not C. Are the conditionals here needed? */
4549 long_unsigned_type_node);
4551 {
4553 int128_integer_type_node);
4555 int128_unsigned_type_node);
4556 }
4560 long_long_integer_type_node);
4562 long_long_unsigned_type_node);
4565 long_long_unsigned_type_node);
4568 short_unsigned_type_node);
4571 short_unsigned_type_node);
4573 /* Define both `signed char' and `unsigned char'. */
4577 /* These are types that c_common_type_for_size and
4578 c_common_type_for_mode use. */
4581 intQI_type_node));
4584 intHI_type_node));
4587 intSI_type_node));
4590 intDI_type_node));
4591 #if HOST_BITS_PER_WIDE_INT >= 64
4594 TYPE_DECL,
4596 intTI_type_node));
4597 #endif
4600 unsigned_intQI_type_node));
4603 unsigned_intHI_type_node));
4606 unsigned_intSI_type_node));
4609 unsigned_intDI_type_node));
4610 #if HOST_BITS_PER_WIDE_INT >= 64
4613 TYPE_DECL,
4615 unsigned_intTI_type_node));
4616 #endif
4618 /* Create the widest literal types. */
4619 widest_integer_literal_type_node
4623 widest_integer_literal_type_node));
4625 widest_unsigned_literal_type_node
4629 widest_unsigned_literal_type_node));
4631 /* `unsigned long' is the standard type for sizeof.
4632 Note that stddef.h uses `unsigned long',
4633 and this must agree, even if long and int are the same size. */
4634 size_type_node =
4639 pid_type_node =
4648 /* Only supported decimal floating point extension if the target
4649 actually supports underlying modes. */
4653 {
4657 }
4660 {
4665 long_long_fract_type_node);
4667 unsigned_short_fract_type_node);
4669 unsigned_fract_type_node);
4671 unsigned_long_fract_type_node);
4673 unsigned_long_long_fract_type_node);
4675 sat_short_fract_type_node);
4678 sat_long_fract_type_node);
4680 sat_long_long_fract_type_node);
4682 sat_unsigned_short_fract_type_node);
4684 sat_unsigned_fract_type_node);
4686 sat_unsigned_long_fract_type_node);
4688 sat_unsigned_long_long_fract_type_node);
4693 long_long_accum_type_node);
4695 unsigned_short_accum_type_node);
4697 unsigned_accum_type_node);
4699 unsigned_long_accum_type_node);
4701 unsigned_long_long_accum_type_node);
4703 sat_short_accum_type_node);
4706 sat_long_accum_type_node);
4708 sat_long_long_accum_type_node);
4710 sat_unsigned_short_accum_type_node);
4712 sat_unsigned_accum_type_node);
4714 sat_unsigned_long_accum_type_node);
4716 sat_unsigned_long_long_accum_type_node);
4718 }
4721 TYPE_DECL,
4723 complex_integer_type_node));
4725 TYPE_DECL,
4727 complex_float_type_node));
4729 TYPE_DECL,
4731 complex_double_type_node));
4735 complex_long_double_type_node));
4738 /* For C++, make fileptr_type_node a distinct void * type until
4739 FILE type is defined. */
4744 /* Set the TYPE_NAME for any variants that were built before
4745 record_builtin_type gave names to the built-in types. */
4746 {
4752 }
4754 /* This node must not be shared. */
4760 /* Make a type to be the domain of a few array types
4761 whose domains don't really matter.
4762 200 is small enough that it always fits in size_t
4763 and large enough that it can hold most function names for the
4764 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4767 /* Make a type for arrays of characters.
4768 With luck nothing will ever really depend on the length of this
4769 array type. */
4770 char_array_type_node
4773 /* Likewise for arrays of ints. */
4774 int_array_type_node
4778 const_string_type_node
4782 /* This is special for C++ so functions can be overloaded. */
4788 {
4791 else
4794 }
4796 /* This is for wide string constants. */
4797 wchar_array_type_node
4800 /* Define 'char16_t'. */
4805 {
4810 }
4812 /* This is for UTF-16 string constants. */
4813 char16_array_type_node
4816 /* Define 'char32_t'. */
4821 {
4826 }
4828 /* This is for UTF-32 string constants. */
4829 char32_array_type_node
4832 wint_type_node =
4835 intmax_type_node =
4837 uintmax_type_node =
4841 sig_atomic_type_node =
4844 int8_type_node =
4847 int16_type_node =
4850 int32_type_node =
4853 int64_type_node =
4856 uint8_type_node =
4859 uint16_type_node =
4862 c_uint32_type_node =
4865 c_uint64_type_node =
4868 int_least8_type_node =
4871 int_least16_type_node =
4874 int_least32_type_node =
4877 int_least64_type_node =
4880 uint_least8_type_node =
4883 uint_least16_type_node =
4886 uint_least32_type_node =
4889 uint_least64_type_node =
4892 int_fast8_type_node =
4895 int_fast16_type_node =
4898 int_fast32_type_node =
4901 int_fast64_type_node =
4904 uint_fast8_type_node =
4907 uint_fast16_type_node =
4910 uint_fast32_type_node =
4913 uint_fast64_type_node =
4916 intptr_type_node =
4919 uintptr_type_node =
4923 ptrdiff_type_node
4930 va_list_type_node));
4932 {
4935 tree ptype;
4938 {
4942 ptype));
4944 }
4945 }
4948 {
4951 }
4952 else
4953 {
4956 }
4963 /* Create the built-in __null node. It is important that this is
4964 not shared. */
4968 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4970 }
4972 /* The number of named compound-literals generated thus far. */
4975 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4977 void
4979 {
4982 compound_literal_number);
4983 compound_literal_number++;
4985 }
4987 tree
4989 {
4993 }
4996 /* Linked list of disabled built-in functions. */
4999 {
5007 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5008 begins with "__builtin_", give an error. */
5010 void
5012 {
5015 else
5016 {
5021 }
5022 }
5025 /* Return true if the built-in function NAME has been disabled, false
5026 otherwise. */
5028 static bool
5030 {
5033 {
5036 }
5038 }
5041 /* Worker for DEF_BUILTIN.
5042 Possibly define a builtin function with one or two names.
5043 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5044 nonansi_p and flag_no_nonansi_builtin. */
5046 static void
5053 {
5054 tree decl;
5067 fnattrs);
5077 }
5078 \f
5079 /* Nonzero if the type T promotes to int. This is (nearly) the
5080 integral promotions defined in ISO C99 6.3.1.1/2. */
5082 bool
5084 {
5086 {
5096 /* ??? Technically all enumerations not larger than an int
5097 promote to an int. But this is used along code paths
5098 that only want to notice a size change. */
5106 }
5107 }
5109 /* Return 1 if PARMS specifies a fixed number of parameters
5110 and none of their types is affected by default promotions. */
5112 int
5114 {
5115 const_tree t;
5117 {
5134 }
5136 }
5138 /* Recursively remove any '*' or '&' operator from TYPE. */
5139 tree
5141 {
5145 }
5147 /* Recursively remove pointer or array type from TYPE. */
5148 tree
5150 {
5154 }
5156 /* Used to compare case labels. K1 and K2 are actually tree nodes
5157 representing case labels, or NULL_TREE for a `default' label.
5158 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5159 K2, and 0 if K1 and K2 are equal. */
5161 int
5163 {
5164 /* Consider a NULL key (such as arises with a `default' label) to be
5165 smaller than anything else. */
5172 }
5174 /* Process a case label, located at LOC, for the range LOW_VALUE
5175 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5176 then this case label is actually a `default' label. If only
5177 HIGH_VALUE is NULL_TREE, then case label was declared using the
5178 usual C/C++ syntax, rather than the GNU case range extension.
5179 CASES is a tree containing all the case ranges processed so far;
5180 COND is the condition for the switch-statement itself. Returns the
5181 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5182 is created. */
5184 tree
5187 {
5188 tree type;
5189 tree label;
5190 tree case_label;
5191 splay_tree_node node;
5193 /* Create the LABEL_DECL itself. */
5196 /* If there was an error processing the switch condition, bail now
5197 before we get more confused. */
5205 {
5208 }
5210 /* Case ranges are a GNU extension. */
5217 {
5222 }
5224 {
5229 }
5232 {
5233 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5234 really a case range, even though it was written that way.
5235 Remove the HIGH_VALUE to simplify later processing. */
5240 }
5242 /* See if the case is in range of the type of the original testing
5243 expression. If both low_value and high_value are out of range,
5244 don't insert the case label and return NULL_TREE. */
5250 /* Look up the LOW_VALUE in the table of case labels we already
5251 have. */
5253 /* If there was not an exact match, check for overlapping ranges.
5254 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5255 that's a `default' label and the only overlap is an exact match. */
5257 {
5258 splay_tree_node low_bound;
5259 splay_tree_node high_bound;
5261 /* Even though there wasn't an exact match, there might be an
5262 overlap between this case range and another case range.
5263 Since we've (inductively) not allowed any overlapping case
5264 ranges, we simply need to find the greatest low case label
5265 that is smaller that LOW_VALUE, and the smallest low case
5266 label that is greater than LOW_VALUE. If there is an overlap
5267 it will occur in one of these two ranges. */
5273 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5274 the LOW_VALUE, so there is no need to check unless the
5275 LOW_BOUND is in fact itself a case range. */
5281 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5282 range is bigger than the low end of the current range, so we
5283 are only interested if the current range is a real range, and
5284 not an ordinary case label. */
5286 && high_value
5288 high_value)
5291 }
5292 /* If there was an overlap, issue an error. */
5294 {
5298 {
5302 }
5304 {
5307 }
5308 else
5309 {
5313 }
5315 }
5317 /* Add a CASE_LABEL to the statement-tree. */
5319 /* Register this case label in the splay tree. */
5326 error_out:
5327 /* Add a label so that the back-end doesn't think that the beginning of
5328 the switch is unreachable. Note that we do not add a case label, as
5329 that just leads to duplicates and thence to failure later on. */
5331 {
5334 }
5336 }
5338 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5339 Used to verify that case values match up with enumerator values. */
5341 static void
5343 {
5346 /* ??? Not working too hard to print the double-word value.
5347 Should perhaps be done with %lwd in the diagnostic routines? */
5356 else
5365 buf);
5366 else
5371 }
5373 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5374 Used to verify that case values match up with enumerator values. */
5376 static int
5378 {
5382 /* Skip default case. */
5386 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5387 when we did our enum->case scan. Reset our scratch bit after. */
5390 else
5393 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5394 not set, that means that CASE_HIGH did not appear when we did our
5395 enum->case scan. Reset our scratch bit after. */
5397 {
5400 else
5402 }
5405 }
5407 /* Handle -Wswitch*. Called from the front end after parsing the
5408 switch construct. */
5409 /* ??? Should probably be somewhere generic, since other languages
5410 besides C and C++ would want this. At the moment, however, C/C++
5411 are the only tree-ssa languages that support enumerations at all,
5412 so the point is moot. */
5414 void
5417 {
5418 splay_tree_node default_node;
5419 splay_tree_node node;
5420 tree chain;
5430 /* From here on, we only care about about enumerated types. */
5434 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5438 /* Check the cases. Warn about case values which are not members of
5439 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5440 there is no default case, check that exactly all enumeration
5441 literals are covered by the cases. */
5443 /* Clearing COND if it is not an integer constant simplifies
5444 the tests inside the loop below. */
5448 /* The time complexity here is O(N*lg(N)) worst case, but for the
5449 common case of monotonically increasing enumerators, it is
5450 O(N), since the nature of the splay tree will keep the next
5451 element adjacent to the root at all times. */
5454 {
5460 {
5461 /* Mark the CASE_LOW part of the case entry as seen. */
5465 }
5467 /* Even though there wasn't an exact match, there might be a
5468 case range which includes the enumerator's value. */
5471 {
5475 {
5476 /* If we match the upper bound exactly, mark the CASE_HIGH
5477 part of the case entry as seen. */
5481 }
5482 }
5484 /* We've now determined that this enumerated literal isn't
5485 handled by the case labels of the switch statement. */
5487 /* If the switch expression is a constant, we only really care
5488 about whether that constant is handled by the switch. */
5492 /* If there is a default_node, the only relevant option is
5493 Wswitch-enum. Otherwise, if both are enabled then we prefer
5494 to warn using -Wswitch because -Wswitch is enabled by -Wall
5495 while -Wswitch-enum is explicit. */
5498 ? OPT_Wswitch_enum
5502 }
5504 /* Warn if there are case expressions that don't correspond to
5505 enumerators. This can occur since C and C++ don't enforce
5506 type-checking of assignments to enumeration variables.
5508 The time complexity here is now always O(N) worst case, since
5509 we should have marked both the lower bound and upper bound of
5510 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5511 above. This scan also resets those fields. */
5514 }
5516 /* Finish an expression taking the address of LABEL (an
5517 IDENTIFIER_NODE). Returns an expression for the address.
5519 LOC is the location for the expression returned. */
5521 tree
5523 {
5524 tree result;
5534 else
5535 {
5538 /* The current function is not necessarily uninlinable.
5539 Computed gotos are incompatible with inlining, but the value
5540 here could be used only in a diagnostic, for example. */
5542 }
5545 }
5546 \f
5548 /* Given a boolean expression ARG, return a tree representing an increment
5549 or decrement (as indicated by CODE) of ARG. The front end must check for
5550 invalid cases (e.g., decrement in C++). */
5551 tree
5553 {
5554 tree val;
5559 {
5582 }
5585 }
5586 \f
5587 /* Built-in macros for stddef.h and stdint.h, that require macros
5588 defined in this file. */
5589 void
5591 {
5654 }
5656 static void
5658 {
5659 /* Fill in the built_in_attributes array. */
5660 #define DEF_ATTR_NULL_TREE(ENUM) \
5661 built_in_attributes[(int) ENUM] = NULL_TREE;
5662 #define DEF_ATTR_INT(ENUM, VALUE) \
5663 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5664 #define DEF_ATTR_IDENT(ENUM, STRING) \
5665 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5666 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5667 built_in_attributes[(int) ENUM] \
5668 = tree_cons (built_in_attributes[(int) PURPOSE], \
5669 built_in_attributes[(int) VALUE], \
5670 built_in_attributes[(int) CHAIN]);
5672 #undef DEF_ATTR_NULL_TREE
5673 #undef DEF_ATTR_INT
5674 #undef DEF_ATTR_IDENT
5675 #undef DEF_ATTR_TREE_LIST
5676 }
5678 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5679 identifier as an argument, so the front end shouldn't look it up. */
5681 bool
5683 {
5686 /* Unknown attribute that we'll end up ignoring, return true so we
5687 don't complain about an identifier argument. */
5693 else
5695 }
5697 /* Attribute handlers common to C front ends. */
5699 /* Handle a "packed" attribute; arguments as in
5700 struct attribute_spec.handler. */
5702 static tree
5705 {
5707 {
5711 }
5713 {
5715 /* Still pack bitfields. */
5720 else
5722 }
5723 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5724 used for DECL_REGISTER. It wouldn't mean anything anyway.
5725 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5726 that changes what the typedef is typing. */
5727 else
5728 {
5731 }
5734 }
5736 /* Handle a "nocommon" attribute; arguments as in
5737 struct attribute_spec.handler. */
5739 static tree
5743 {
5746 else
5747 {
5750 }
5753 }
5755 /* Handle a "common" attribute; arguments as in
5756 struct attribute_spec.handler. */
5758 static tree
5761 {
5764 else
5765 {
5768 }
5771 }
5773 /* Handle a "noreturn" attribute; arguments as in
5774 struct attribute_spec.handler. */
5776 static tree
5779 {
5782 /* See FIXME comment in c_common_attribute_table. */
5789 = build_pointer_type
5792 else
5793 {
5796 }
5799 }
5801 /* Handle a "hot" and attribute; arguments as in
5802 struct attribute_spec.handler. */
5804 static tree
5807 {
5809 {
5811 {
5815 }
5816 /* Most of the rest of the hot processing is done later with
5817 lookup_attribute. */
5818 }
5819 else
5820 {
5823 }
5826 }
5827 /* Handle a "cold" and attribute; arguments as in
5828 struct attribute_spec.handler. */
5830 static tree
5833 {
5835 {
5837 {
5841 }
5842 /* Most of the rest of the cold processing is done later with
5843 lookup_attribute. */
5844 }
5845 else
5846 {
5849 }
5852 }
5854 /* Handle a "noinline" attribute; arguments as in
5855 struct attribute_spec.handler. */
5857 static tree
5861 {
5864 else
5865 {
5868 }
5871 }
5873 /* Handle a "noclone" attribute; arguments as in
5874 struct attribute_spec.handler. */
5876 static tree
5880 {
5882 {
5885 }
5888 }
5890 /* Handle a "always_inline" attribute; arguments as in
5891 struct attribute_spec.handler. */
5893 static tree
5898 {
5900 {
5901 /* Set the attribute and mark it for disregarding inline
5902 limits. */
5904 }
5905 else
5906 {
5909 }
5912 }
5914 /* Handle a "gnu_inline" attribute; arguments as in
5915 struct attribute_spec.handler. */
5917 static tree
5922 {
5924 {
5925 /* Do nothing else, just set the attribute. We'll get at
5926 it later with lookup_attribute. */
5927 }
5928 else
5929 {
5932 }
5935 }
5937 /* Handle a "leaf" attribute; arguments as in
5938 struct attribute_spec.handler. */
5940 static tree
5944 {
5946 {
5949 }
5951 {
5954 }
5957 }
5959 /* Handle an "artificial" attribute; arguments as in
5960 struct attribute_spec.handler. */
5962 static tree
5967 {
5969 {
5970 /* Do nothing else, just set the attribute. We'll get at
5971 it later with lookup_attribute. */
5972 }
5973 else
5974 {
5977 }
5980 }
5982 /* Handle a "flatten" attribute; arguments as in
5983 struct attribute_spec.handler. */
5985 static tree
5987 tree args ATTRIBUTE_UNUSED,
5989 {
5991 /* Do nothing else, just set the attribute. We'll get at
5992 it later with lookup_attribute. */
5993 ;
5994 else
5995 {
5998 }
6001 }
6003 /* Handle a "warning" or "error" attribute; arguments as in
6004 struct attribute_spec.handler. */
6006 static tree
6009 {
6012 /* Do nothing else, just set the attribute. We'll get at
6013 it later with lookup_attribute. */
6014 ;
6015 else
6016 {
6019 }
6022 }
6024 /* Handle a "used" attribute; arguments as in
6025 struct attribute_spec.handler. */
6027 static tree
6030 {
6035 {
6040 }
6041 else
6042 {
6045 }
6048 }
6050 /* Handle a "unused" attribute; arguments as in
6051 struct attribute_spec.handler. */
6053 static tree
6056 {
6058 {
6066 {
6071 }
6072 else
6073 {
6076 }
6077 }
6078 else
6079 {
6083 }
6086 }
6088 /* Handle a "externally_visible" attribute; arguments as in
6089 struct attribute_spec.handler. */
6091 static tree
6096 {
6100 {
6103 {
6107 }
6108 }
6109 else
6110 {
6113 }
6116 }
6118 /* Handle a "const" attribute; arguments as in
6119 struct attribute_spec.handler. */
6121 static tree
6124 {
6127 /* See FIXME comment on noreturn in c_common_attribute_table. */
6133 = build_pointer_type
6136 else
6137 {
6140 }
6143 }
6145 /* Handle a "transparent_union" attribute; arguments as in
6146 struct attribute_spec.handler. */
6148 static tree
6152 {
6153 tree type;
6162 {
6163 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6164 the code in finish_struct. */
6166 {
6172 /* A type variant isn't good enough, since we don't a cast
6173 to such a type removed as a no-op. */
6175 }
6179 }
6181 ignored:
6184 }
6186 /* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6187 get the requested priority for a constructor or destructor,
6188 possibly issuing diagnostics for invalid or reserved
6189 priorities. */
6191 static priority_type
6193 {
6194 HOST_WIDE_INT pri;
6195 tree arg;
6201 {
6204 else
6207 }
6219 {
6222 "destructor priorities from 0 to %d are reserved "
6224 MAX_RESERVED_INIT_PRIORITY);
6225 else
6227 "constructor priorities from 0 to %d are reserved "
6229 MAX_RESERVED_INIT_PRIORITY);
6230 }
6233 invalid:
6236 MAX_INIT_PRIORITY);
6237 else
6239 MAX_INIT_PRIORITY);
6241 }
6243 /* Handle a "constructor" attribute; arguments as in
6244 struct attribute_spec.handler. */
6246 static tree
6250 {
6257 {
6258 priority_type priority;
6263 }
6264 else
6265 {
6268 }
6271 }
6273 /* Handle a "destructor" attribute; arguments as in
6274 struct attribute_spec.handler. */
6276 static tree
6280 {
6287 {
6288 priority_type priority;
6293 }
6294 else
6295 {
6298 }
6301 }
6303 /* Nonzero if the mode is a valid vector mode for this architecture.
6304 This returns nonzero even if there is no hardware support for the
6305 vector mode, but we can emulate with narrower modes. */
6307 static int
6309 {
6313 /* Doh! What's going on? */
6322 /* Hardware support. Woo hoo! */
6328 /* We should probably return 1 if requesting V4DI and we have no DI,
6329 but we have V2DI, but this is probably very unlikely. */
6331 /* If we have support for the inner mode, we can safely emulate it.
6332 We may not have V2DI, but me can emulate with a pair of DIs. */
6334 }
6337 /* Handle a "mode" attribute; arguments as in
6338 struct attribute_spec.handler. */
6340 static tree
6343 {
6351 else
6352 {
6357 tree typefm;
6362 {
6368 }
6370 /* Change this type to have a type with the specified mode.
6371 First check for the special modes. */
6384 else
6387 {
6390 }
6393 {
6396 }
6400 {
6432 }
6434 {
6437 }
6440 {
6445 {
6448 }
6452 else
6455 }
6456 else
6457 {
6458 /* For fixed-point modes, we need to test if the signness of type
6459 and the machine mode are consistent. */
6462 {
6465 }
6466 /* For fixed-point modes, we need to pass saturating info. */
6470 }
6473 {
6476 }
6478 {
6479 /* For enumeral types, copy the precision from the integer
6480 type returned above. If not an INTEGER_TYPE, we can't use
6481 this mode for this type. */
6483 {
6486 }
6489 {
6492 }
6493 else
6494 {
6495 /* We cannot build a type variant, as there's code that assumes
6496 that TYPE_MAIN_VARIANT has the same mode. This includes the
6497 debug generators. Instead, create a subrange type. This
6498 results in all of the enumeral values being emitted only once
6499 in the original, and the subtype gets them by reference. */
6502 else
6505 }
6506 }
6510 {
6513 }
6516 }
6519 }
6521 /* Handle a "section" attribute; arguments as in
6522 struct attribute_spec.handler. */
6524 static tree
6527 {
6531 {
6537 {
6541 {
6543 "section attribute cannot be specified for "
6546 }
6548 /* The decl may have already been given a section attribute
6549 from a previous declaration. Ensure they match. */
6553 {
6557 }
6561 {
6564 }
6565 else
6567 }
6568 else
6569 {
6572 }
6573 }
6574 else
6575 {
6579 }
6582 }
6584 /* Handle a "aligned" attribute; arguments as in
6585 struct attribute_spec.handler. */
6587 static tree
6590 {
6599 {
6603 }
6608 {
6611 }
6613 {
6616 }
6618 {
6621 }
6623 {
6626 /* If we have a TYPE_DECL, then copy the type, so that we
6627 don't accidentally modify a builtin type. See pushdecl. */
6630 {
6637 }
6638 else
6643 }
6646 {
6649 }
6652 {
6657 else
6661 }
6662 else
6663 {
6666 }
6669 }
6671 /* Handle a "weak" attribute; arguments as in
6672 struct attribute_spec.handler. */
6674 static tree
6679 {
6682 {
6685 }
6687 {
6691 }
6695 else
6699 }
6701 /* Handle an "alias" or "ifunc" attribute; arguments as in
6702 struct attribute_spec.handler, except that IS_ALIAS tells us
6703 whether this is an alias as opposed to ifunc attribute. */
6705 static tree
6708 {
6713 {
6716 }
6720 /* A static variable declaration is always a tentative definition,
6721 but the alias is a non-tentative definition which overrides. */
6724 {
6728 }
6732 {
6736 }
6738 /* Note that the very first time we process a nested declaration,
6739 decl_function_context will not be set. Indeed, *would* never
6740 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6741 we do below. After such frobbery, pushdecl would set the context.
6742 In any case, this is never what we want. */
6744 {
6745 tree id;
6749 {
6753 }
6755 /* This counts as a use of the object pointed to. */
6760 else
6761 {
6764 else
6767 }
6770 /* ifuncs are also aliases, so set that attribute too. */
6773 }
6774 else
6775 {
6778 }
6781 }
6783 /* Handle an "alias" or "ifunc" attribute; arguments as in
6784 struct attribute_spec.handler. */
6786 static tree
6789 {
6791 }
6793 /* Handle an "alias" or "ifunc" attribute; arguments as in
6794 struct attribute_spec.handler. */
6796 static tree
6799 {
6801 }
6803 /* Handle a "weakref" attribute; arguments as in struct
6804 attribute_spec.handler. */
6806 static tree
6809 {
6812 /* We must ignore the attribute when it is associated with
6813 local-scoped decls, since attribute alias is ignored and many
6814 such symbols do not even have a DECL_WEAK field. */
6816 || current_function_decl
6818 {
6822 }
6825 {
6829 }
6831 /* The idea here is that `weakref("name")' mutates into `weakref,
6832 alias("name")', and weakref without arguments, in turn,
6833 implicitly adds weak. */
6836 {
6843 }
6844 else
6845 {
6850 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6851 and that isn't supported; and because it wants to add it to
6852 the list of weak decls, which isn't helpful. */
6854 }
6857 }
6859 /* Handle an "visibility" attribute; arguments as in
6860 struct attribute_spec.handler. */
6862 static tree
6866 {
6872 {
6876 {
6878 name);
6880 }
6882 {
6886 }
6887 }
6889 {
6892 }
6895 {
6898 }
6900 /* If this is a type, set the visibility on the type decl. */
6902 {
6907 {
6909 name);
6911 }
6912 }
6922 else
6923 {
6924 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6926 }
6930 {
6944 }
6949 /* Go ahead and attach the attribute to the node as well. This is needed
6950 so we can determine whether we have VISIBILITY_DEFAULT because the
6951 visibility was not specified, or because it was explicitly overridden
6952 from the containing scope. */
6955 }
6957 /* Determine the ELF symbol visibility for DECL, which is either a
6958 variable or a function. It is an error to use this function if a
6959 definition of DECL is not available in this translation unit.
6960 Returns true if the final visibility has been determined by this
6961 function; false if the caller is free to make additional
6962 modifications. */
6964 bool
6966 {
6970 /* If the user explicitly specified the visibility with an
6971 attribute, honor that. DECL_VISIBILITY will have been set during
6972 the processing of the attribute. We check for an explicit
6973 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6974 to distinguish the use of an attribute from the use of a "#pragma
6975 GCC visibility push(...)"; in the latter case we still want other
6976 considerations to be able to overrule the #pragma. */
6978 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6983 /* Set default visibility to whatever the user supplied with
6984 visibility_specified depending on #pragma GCC visibility. */
6986 {
6989 {
6992 /* If visibility changed and DECL already has DECL_RTL, ensure
6993 symbol flags are updated. */
6998 }
6999 }
7001 }
7003 /* Handle an "tls_model" attribute; arguments as in
7004 struct attribute_spec.handler. */
7006 static tree
7009 {
7010 tree id;
7017 {
7020 }
7025 {
7028 }
7038 else
7039 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7043 }
7045 /* Handle a "no_instrument_function" attribute; arguments as in
7046 struct attribute_spec.handler. */
7048 static tree
7053 {
7057 {
7061 }
7063 {
7067 }
7068 else
7072 }
7074 /* Handle a "malloc" attribute; arguments as in
7075 struct attribute_spec.handler. */
7077 static tree
7080 {
7084 else
7085 {
7088 }
7091 }
7093 /* Handle a "alloc_size" attribute; arguments as in
7094 struct attribute_spec.handler. */
7096 static tree
7099 {
7102 {
7109 {
7114 }
7115 }
7117 }
7119 /* Handle a "fn spec" attribute; arguments as in
7120 struct attribute_spec.handler. */
7122 static tree
7126 {
7131 }
7133 /* Handle a "returns_twice" attribute; arguments as in
7134 struct attribute_spec.handler. */
7136 static tree
7139 {
7142 else
7143 {
7146 }
7149 }
7151 /* Handle a "no_limit_stack" attribute; arguments as in
7152 struct attribute_spec.handler. */
7154 static tree
7159 {
7163 {
7167 }
7169 {
7173 }
7174 else
7178 }
7180 /* Handle a "pure" attribute; arguments as in
7181 struct attribute_spec.handler. */
7183 static tree
7186 {
7189 /* ??? TODO: Support types. */
7190 else
7191 {
7194 }
7197 }
7199 /* Handle a "no vops" attribute; arguments as in
7200 struct attribute_spec.handler. */
7202 static tree
7206 {
7210 }
7212 /* Handle a "deprecated" attribute; arguments as in
7213 struct attribute_spec.handler. */
7215 static tree
7219 {
7227 {
7230 }
7233 {
7244 else
7246 }
7248 {
7253 }
7254 else
7258 {
7261 {
7267 }
7270 else
7272 }
7275 }
7277 /* Handle a "vector_size" attribute; arguments as in
7278 struct attribute_spec.handler. */
7280 static tree
7284 {
7294 {
7297 }
7299 /* Get the vector size (in bytes). */
7302 /* We need to provide for vector pointers, vector arrays, and
7303 functions returning vectors. For example:
7305 __attribute__((vector_size(16))) short *foo;
7307 In this case, the mode is SI, but the type being modified is
7308 HI, so we need to look further. */
7317 /* Get the mode of the type being modified. */
7328 {
7331 }
7334 {
7337 }
7340 {
7343 }
7345 /* Calculate how many units fit in the vector. */
7348 {
7351 }
7355 /* Build back pointers if needed. */
7359 }
7361 /* Handle the "nonnull" attribute. */
7362 static tree
7366 {
7370 /* If no arguments are specified, all pointer arguments should be
7371 non-null. Verify a full prototype is given so that the arguments
7372 will have the correct types when we actually check them later. */
7374 {
7376 {
7379 }
7381 }
7383 /* Argument list specified. Verify that each argument number references
7384 a pointer argument. */
7386 {
7387 tree argument;
7391 {
7396 }
7400 {
7402 {
7406 }
7410 {
7415 }
7418 {
7423 }
7424 }
7425 }
7428 }
7430 /* Check the argument list of a function call for null in argument slots
7431 that are marked as requiring a non-null pointer argument. The NARGS
7432 arguments are passed in the array ARGARRAY.
7433 */
7435 static void
7437 {
7442 {
7444 {
7447 /* Walk the argument list. If we encounter an argument number we
7448 should check for non-null, do it. If the attribute has no args,
7449 then every pointer argument is checked (in which case the check
7450 for pointer type is done in check_nonnull_arg). */
7452 {
7457 }
7458 }
7459 }
7460 }
7462 /* Check that the Nth argument of a function call (counting backwards
7463 from the end) is a (pointer)0. The NARGS arguments are passed in the
7464 array ARGARRAY. */
7466 static void
7468 {
7472 {
7475 tree sentinel;
7477 /* Skip over the named arguments. */
7479 {
7481 len++;
7482 }
7485 {
7488 }
7490 /* The sentinel must be one of the varargs, i.e.
7491 in position >= the number of fixed arguments. */
7493 {
7497 }
7499 /* Validate the sentinel. */
7503 /* Although __null (in C++) is only an integer we allow it
7504 nevertheless, as we are guaranteed that it's exactly
7505 as wide as a pointer, and we don't want to force
7506 users to cast the NULL they have written there.
7507 We warn with -Wstrict-null-sentinel, though. */
7510 }
7511 }
7513 /* Helper for check_function_nonnull; given a list of operands which
7514 must be non-null in ARGS, determine if operand PARAM_NUM should be
7515 checked. */
7517 static bool
7519 {
7523 {
7530 }
7532 }
7534 /* Check that the function argument PARAM (which is operand number
7535 PARAM_NUM) is non-null. This is called by check_function_nonnull
7536 via check_function_arguments_recurse. */
7538 static void
7541 {
7542 /* Just skip checking the argument if it's not a pointer. This can
7543 happen if the "nonnull" attribute was given without an operand
7544 list (which means to check every pointer argument). */
7552 }
7554 /* Helper for nonnull attribute handling; fetch the operand number
7555 from the attribute argument list. */
7557 static bool
7559 {
7560 /* Verify the arg number is a constant. */
7567 }
7569 /* Handle a "nothrow" attribute; arguments as in
7570 struct attribute_spec.handler. */
7572 static tree
7575 {
7578 /* ??? TODO: Support types. */
7579 else
7580 {
7583 }
7586 }
7588 /* Handle a "cleanup" attribute; arguments as in
7589 struct attribute_spec.handler. */
7591 static tree
7594 {
7598 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7599 for global destructors in C++. This requires infrastructure that
7600 we don't have generically at the moment. It's also not a feature
7601 we'd be missing too much, since we do have attribute constructor. */
7603 {
7607 }
7609 /* Verify that the argument is a function in scope. */
7610 /* ??? We could support pointers to functions here as well, if
7611 that was considered desirable. */
7614 {
7618 }
7621 {
7625 }
7627 /* That the function has proper type is checked with the
7628 eventual call to build_function_call. */
7631 }
7633 /* Handle a "warn_unused_result" attribute. No special handling. */
7635 static tree
7639 {
7640 /* Ignore the attribute for functions not returning any value. */
7642 {
7645 }
7648 }
7650 /* Handle a "sentinel" attribute. */
7652 static tree
7655 {
7659 {
7663 }
7664 else
7665 {
7670 {
7674 }
7675 }
7678 {
7682 {
7686 }
7687 else
7688 {
7690 {
7694 }
7695 }
7696 }
7699 }
7701 /* Handle a "type_generic" attribute. */
7703 static tree
7707 {
7708 tree params;
7710 /* Ensure we have a function type. */
7717 /* Ensure we have a variadic function. */
7721 }
7723 /* Handle a "target" attribute. */
7725 static tree
7728 {
7729 /* Ensure we have a function type. */
7731 {
7734 }
7736 flags))
7740 }
7742 /* Arguments being collected for optimization. */
7749 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7750 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7751 false for #pragma GCC optimize. */
7753 bool
7755 {
7763 tree ap;
7765 /* Build up argv vector. Just in case the string is stored away, use garbage
7766 collected strings. */
7771 {
7775 {
7779 }
7782 {
7783 /* Split string into multiple substrings. */
7791 {
7798 {
7802 }
7803 else
7804 {
7807 }
7811 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7812 options. */
7814 {
7819 else
7823 }
7826 {
7829 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7830 itself is -Os, and any other switch begins with a -f. */
7836 }
7841 }
7843 }
7844 }
7854 /* Now parse the options. */
7864 /* Don't allow changing -fstrict-aliasing. */
7869 }
7871 /* For handling "optimize" attribute. arguments as in
7872 struct attribute_spec.handler. */
7874 static tree
7877 {
7878 /* Ensure we have a function type. */
7880 {
7883 }
7884 else
7885 {
7889 /* Save current options. */
7892 /* If we previously had some optimization options, use them as the
7893 default. */
7898 /* Parse options, and update the vector. */
7903 /* Restore current options. */
7905 }
7908 }
7910 /* Handle a "no_split_stack" attribute. */
7912 static tree
7917 {
7921 {
7925 }
7927 {
7931 }
7934 }
7935 \f
7936 /* Check for valid arguments being passed to a function.
7937 ATTRS is a list of attributes. There are NARGS arguments in the array
7938 ARGARRAY. TYPELIST is the list of argument types for the function.
7939 */
7940 void
7942 {
7943 /* Check for null being passed in a pointer argument that must be
7944 non-null. We also need to do this if format checking is enabled. */
7949 /* Check for errors in format strings. */
7956 }
7958 /* Generic argument checking recursion routine. PARAM is the argument to
7959 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7960 once the argument is resolved. CTX is context for the callback. */
7961 void
7966 {
7970 {
7971 /* Strip coercion. */
7975 }
7978 {
7980 tree attrs;
7983 /* See if this is a call to a known internationalization function
7984 that modifies a format arg. Such a function may have multiple
7985 format_arg attributes (for example, ngettext). */
7988 attrs;
7991 {
7992 tree inner_arg;
7993 tree format_num_expr;
7996 call_expr_arg_iterator iter;
7998 /* Extract the argument number, which was previously checked
7999 to be valid. */
8011 {
8016 }
8017 }
8019 /* If we found a format_arg attribute and did a recursive check,
8020 we are done with checking this argument. Otherwise, we continue
8021 and this will be considered a non-literal. */
8024 }
8027 {
8028 /* Check both halves of the conditional expression. */
8034 }
8037 }
8039 /* Checks for a builtin function FNDECL that the number of arguments
8040 NARGS against the required number REQUIRED and issues an error if
8041 there is a mismatch. Returns true if the number of arguments is
8042 correct, otherwise false. */
8044 static bool
8046 {
8048 {
8052 }
8054 {
8058 }
8060 }
8062 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8063 Returns false if there was an error, otherwise true. */
8065 bool
8067 {
8073 {
8083 {
8085 {
8089 }
8091 }
8101 {
8108 {
8112 }
8114 }
8119 {
8124 {
8128 }
8131 {
8133 fndecl);
8135 }
8137 }
8142 }
8143 }
8145 /* Function to help qsort sort FIELD_DECLs by name order. */
8147 int
8149 {
8154 /* A nontype is "greater" than a type. */
8163 }
8166 gt_pointer_operator new_value;
8170 /* This routine compares two fields like field_decl_cmp but using the
8171 pointer operator in resort_data. */
8173 static int
8175 {
8180 /* A nontype is "greater" than a type. */
8186 {
8193 }
8195 }
8197 /* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8199 void
8202 gt_pointer_operator new_value,
8204 {
8209 resort_field_decl_cmp);
8210 }
8212 /* Subroutine of c_parse_error.
8213 Return the result of concatenating LHS and RHS. RHS is really
8214 a string literal, its first character is indicated by RHS_START and
8215 RHS_SIZE is its length (including the terminating NUL character).
8217 The caller is responsible for deleting the returned pointer. */
8221 {
8227 }
8229 /* Issue the error given by GMSGID, indicating that it occurred before
8230 TOKEN, which had the associated VALUE. */
8232 void
8235 {
8236 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8246 {
8251 {
8264 }
8268 else
8274 }
8284 {
8289 }
8295 {
8300 }
8301 else
8305 {
8308 }
8309 #undef catenate_messages
8310 }
8312 /* Mapping for cpp message reasons to the options that enable them. */
8314 struct reason_option_codes_t
8315 {
8318 };
8337 };
8339 /* Return the gcc option code associated with the reason for a cpp
8340 message, or 0 if none. */
8342 static int
8344 {
8348 {
8351 }
8353 }
8355 /* Callback from cpp_error for PFILE to print diagnostics from the
8356 preprocessor. The diagnostic is of type LEVEL, with REASON set
8357 to the reason code if LEVEL is represents a warning, at location
8358 LOCATION unless this is after lexing and the compiler's location
8359 should be used instead, with column number possibly overridden by
8360 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8361 the arguments. Returns true if a diagnostic was emitted, false
8362 otherwise. */
8364 bool
8368 {
8369 diagnostic_info diagnostic;
8370 diagnostic_t dlevel;
8375 {
8380 /* Fall through. */
8405 }
8418 }
8420 /* Convert a character from the host to the target execution character
8421 set. cpplib handles this, mostly. */
8423 HOST_WIDE_INT
8425 {
8426 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8427 zero-extended under -fno-signed-char. cpplib insists that characters
8428 and character constants are always unsigned. Hence we must convert
8429 back and forth. */
8437 else
8439 }
8441 /* Build the result of __builtin_offsetof. EXPR is a nested sequence of
8442 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8443 NULL, at the bottom; much like the traditional rendering of offsetof as a
8444 macro. Returns the folded and properly cast result. */
8446 static tree
8448 {
8456 {
8472 {
8475 }
8485 {
8489 }
8503 {
8506 }
8510 /* Check if the offset goes beyond the upper bound of the array. */
8512 {
8518 {
8522 {
8523 tree v;
8530 {
8538 }
8539 /* Don't warn if the array might be considered a poor
8540 man's flexible array member with a very permissive
8541 definition thereof. */
8545 "index %E denotes an offset "
8548 }
8549 }
8550 }
8554 /* Handle static members of volatile structs. */
8561 }
8564 }
8566 tree
8568 {
8569 /* Convert back from the internal sizetype to size_t. */
8571 }
8573 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8574 expression, because B will always be true. */
8576 void
8578 {
8581 "the omitted middle operand in ?: will always be %<true%>, "
8583 }
8585 /* Give an error for storing into ARG, which is 'const'. USE indicates
8586 how ARG was being used. */
8588 void
8590 {
8593 /* Using this macro rather than (for example) arrays of messages
8594 ensures that all the format strings are checked at compile
8595 time. */
8596 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
8597 : (use == lv_increment ? (I) \
8598 : (use == lv_decrement ? (D) : (AS))))
8600 {
8611 else
8617 }
8623 arg);
8629 arg);
8631 {
8641 arg);
8642 }
8648 arg);
8649 else
8654 arg);
8655 }
8657 /* Print an error message for an invalid lvalue. USE says
8658 how the lvalue is being used and so selects the error message. LOC
8659 is the location for the error. */
8661 void
8663 {
8665 {
8683 }
8684 }
8686 /* Print an error message for an invalid indirection of type TYPE.
8687 ERRSTRING is the name of the operator for the indirection. */
8689 void
8691 {
8693 {
8701 type);
8706 type);
8711 type);
8716 type);
8720 }
8721 }
8722 \f
8723 /* *PTYPE is an incomplete array. Complete it with a domain based on
8724 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8725 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8726 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8728 int
8730 {
8737 {
8739 {
8740 int eltsize
8743 }
8745 {
8749 {
8753 }
8754 else
8755 {
8756 tree curindex;
8769 cnt++)
8770 {
8774 else
8775 {
8779 size_one_node);
8780 }
8783 }
8786 }
8787 }
8788 else
8789 {
8790 /* Make an error message unless that happened already. */
8793 }
8794 }
8795 else
8796 {
8800 }
8807 else
8810 /* Using build_distinct_type_copy and modifying things afterward instead
8811 of using build_array_type to create a new type preserves all of the
8812 TYPE_LANG_FLAG_? bits that the front end may have set. */
8818 /* Make sure we have the canonical MAIN_TYPE. */
8821 hashcode);
8824 /* Fix the canonical type. */
8834 else
8839 else
8845 {
8847 /* If we proceed with the array type as it is, we'll eventually
8848 crash in tree_low_cst(). */
8850 }
8854 }
8856 /* Like c_mark_addressable but don't check register qualifier. */
8857 void
8859 {
8865 }
8868 \f
8869 /* Used to help initialize the builtin-types.def table. When a type of
8870 the correct size doesn't exist, use error_mark_node instead of NULL.
8871 The later results in segfaults even when a decl using the type doesn't
8872 get invoked. */
8874 tree
8876 {
8879 }
8881 /* A helper function for resolve_overloaded_builtin in resolving the
8882 overloaded __sync_ builtins. Returns a positive power of 2 if the
8883 first operand of PARAMS is a pointer to a supported data type.
8884 Returns 0 if an error is encountered. */
8886 static int
8888 {
8889 tree type;
8893 {
8896 }
8910 incompatible:
8913 }
8915 /* A helper function for resolve_overloaded_builtin. Adds casts to
8916 PARAMS to make arguments match up with those of FUNCTION. Drops
8917 the variadic arguments at the end. Returns false if some error
8918 was encountered; true on success. */
8920 static bool
8922 {
8924 tree ptype;
8927 /* We've declared the implementation functions to use "volatile void *"
8928 as the pointer parameter, so we shouldn't get any complaints from the
8929 call to check_function_arguments what ever type the user used. */
8933 /* For the rest of the values, we need to cast these to FTYPE, so that we
8934 don't get warnings for passing pointer types, etc. */
8937 {
8938 tree val;
8942 {
8945 }
8947 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8948 so that we get warnings for anything that doesn't match the pointer
8949 type. This isn't portable across the C and C++ front ends atm. */
8956 }
8958 /* The definition of these primitives is variadic, with the remaining
8959 being "an optional list of variables protected by the memory barrier".
8960 No clue what that's supposed to mean, precisely, but we consider all
8961 call-clobbered variables to be protected so we're safe. */
8965 }
8967 /* A helper function for resolve_overloaded_builtin. Adds a cast to
8968 RESULT to make it match the type of the first pointer argument in
8969 PARAMS. */
8971 static tree
8973 {
8977 }
8979 /* Some builtin functions are placeholders for other expressions. This
8980 function should be called immediately after parsing the call expression
8981 before surrounding code has committed to the type of the expression.
8983 LOC is the location of the builtin call.
8985 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8986 PARAMS is the argument list for the call. The return value is non-null
8987 when expansion is complete, and null if normal processing should
8988 continue. */
8990 tree
8992 {
8995 {
9001 else
9005 }
9007 /* Handle BUILT_IN_NORMAL here. */
9009 {
9026 {
9044 }
9048 }
9049 }
9051 /* Ignoring their sign, return true if two scalar types are the same. */
9052 bool
9054 {
9061 /* Equality works here because c_common_signed_type uses
9062 TYPE_MAIN_VARIANT. */
9065 }
9067 /* Check for missing format attributes on function pointers. LTYPE is
9068 the new type or left-hand side type. RTYPE is the old type or
9069 right-hand side type. Returns TRUE if LTYPE is missing the desired
9070 attribute. */
9072 bool
9074 {
9076 tree ra;
9082 {
9083 tree la;
9088 }
9089 else
9091 }
9093 /* Subscripting with type char is likely to lose on a machine where
9094 chars are signed. So warn on any machine, but optionally. Don't
9095 warn for unsigned char since that type is safe. Don't warn for
9096 signed char because anyone who uses that must have done so
9097 deliberately. Furthermore, we reduce the false positive load by
9098 warning only for non-constant value of type char. */
9100 void
9102 {
9106 }
9108 /* Implement -Wparentheses for the unexpected C precedence rules, to
9109 cover cases like x + y << z which readers are likely to
9110 misinterpret. We have seen an expression in which CODE is a binary
9111 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
9112 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
9113 CODE_RIGHT may be ERROR_MARK, which means that that side of the
9114 expression was not formed using a binary or unary operator, or it
9115 was enclosed in parentheses. */
9117 void
9121 {
9125 /* This macro tests that the expression ARG with original tree code
9126 CODE appears to be a boolean expression. or the result of folding a
9127 boolean expression. */
9128 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
9129 (truth_value_p (TREE_CODE (ARG)) \
9130 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
9132 || ((CODE) != INTEGER_CST \
9133 && (integer_onep (ARG) || integer_zerop (ARG))))
9136 {
9168 /* Check cases like x|y==z */
9173 /* Check cases like !x | y */
9187 /* Check cases like x^y==z */
9201 /* Check cases like x&y==z */
9206 /* Check cases like !x & y */
9237 }
9238 #undef NOT_A_BOOLEAN_EXPR_P
9239 }
9241 /* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9243 void
9245 {
9247 {
9250 else
9252 }
9253 }
9255 #ifndef TARGET_HAS_TARGETCM
9257 #endif
9259 /* Warn for division by zero according to the value of DIVISOR. LOC
9260 is the location of the division operator. */
9262 void
9264 {
9265 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9266 about division by zero. Do not issue a warning if DIVISOR has a
9267 floating-point type, since we consider 0.0/0.0 a valid way of
9268 generating a NaN. */
9272 }
9274 /* Subroutine of build_binary_op. Give warnings for comparisons
9275 between signed and unsigned quantities that may fail. Do the
9276 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9277 so that casts will be considered, but default promotions won't
9278 be.
9280 LOCATION is the location of the comparison operator.
9282 The arguments of this function map directly to local variables
9283 of build_binary_op. */
9285 void
9290 {
9295 /* In C++, check for comparison of different enum types. */
9301 {
9305 }
9307 /* Do not warn if the comparison is being done in a signed type,
9308 since the signed type will only be chosen if it can represent
9309 all the values of the unsigned type. */
9312 /* Do not warn if both operands are unsigned. */
9315 else
9316 {
9322 else
9330 /* Do not warn if the signed quantity is an unsuffixed integer
9331 literal (or some static constant expression involving such
9332 literals or a conditional expression involving such literals)
9333 and it is non-negative. */
9336 /* Do not warn if the comparison is an equality operation, the
9337 unsigned quantity is an integral constant, and it would fit
9338 in the result if the result were signed. */
9343 /* In C, do not warn if the unsigned quantity is an enumeration
9344 constant and its maximum value would fit in the result if the
9345 result were signed. */
9351 else
9353 OPT_Wsign_compare,
9355 }
9357 /* Warn if two unsigned values are being compared in a size larger
9358 than their original size, and one (and only one) is the result of
9359 a `~' operator. This comparison will always fail.
9361 Also warn if one operand is a constant, and the constant does not
9362 have all bits set that are set in the ~ operand when it is
9363 extended. */
9370 {
9377 {
9378 tree primop;
9384 {
9388 }
9389 else
9390 {
9394 }
9399 {
9402 {
9406 else
9409 }
9410 }
9411 }
9419 }
9420 }
9422 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9423 type via c_common_type. If -Wdouble-promotion is in use, and the
9424 conditions for warning have been met, issue a warning. GMSGID is
9425 the warning message. It must have two %T specifiers for the type
9426 that was converted (generally "float") and the type to which it was
9427 converted (generally "double), respectively. LOC is the location
9428 to which the awrning should refer. */
9430 void
9433 {
9434 tree source_type;
9438 /* If the conversion will not occur at run-time, there is no need to
9439 warn about it. */
9451 else
9454 }
9456 /* Setup a TYPE_DECL node as a typedef representation.
9458 X is a TYPE_DECL for a typedef statement. Create a brand new
9459 ..._TYPE node (which will be just a variant of the existing
9460 ..._TYPE node with identical properties) and then install X
9461 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9463 The whole point here is to end up with a situation where each
9464 and every ..._TYPE node the compiler creates will be uniquely
9465 associated with AT MOST one node representing a typedef name.
9466 This way, even though the compiler substitutes corresponding
9467 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9468 early on, later parts of the compiler can always do the reverse
9469 translation and get back the corresponding typedef name. For
9470 example, given:
9472 typedef struct S MY_TYPE;
9473 MY_TYPE object;
9475 Later parts of the compiler might only know that `object' was of
9476 type `struct S' if it were not for code just below. With this
9477 code however, later parts of the compiler see something like:
9479 struct S' == struct S
9480 typedef struct S' MY_TYPE;
9481 struct S' object;
9483 And they can then deduce (from the node for type struct S') that
9484 the original object declaration was:
9486 MY_TYPE object;
9488 Being able to do this is important for proper support of protoize,
9489 and also for generating precise symbolic debugging information
9490 which takes full account of the programmer's (typedef) vocabulary.
9492 Obviously, we don't want to generate a duplicate ..._TYPE node if
9493 the TYPE_DECL node that we are now processing really represents a
9494 standard built-in type. */
9496 void
9498 {
9502 {
9505 }
9508 {
9516 }
9517 }
9519 /* Record the types used by the current global variable declaration
9520 being parsed, so that we can decide later to emit their debug info.
9521 Those types are in types_used_by_cur_var_decl, and we are going to
9522 store them in the types_used_by_vars_hash hash table.
9523 DECL is the declaration of the global variable that has been parsed. */
9525 void
9527 {
9531 {
9534 }
9535 }
9537 /* The C and C++ parsers both use vectors to hold function arguments.
9538 For efficiency, we keep a cache of unused vectors. This is the
9539 cache. */
9546 /* Return a new vector from the cache. If the cache is empty,
9547 allocate a new vector. These vectors are GC'ed, so it is OK if the
9548 pointer is not released.. */
9552 {
9555 else
9556 {
9557 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9558 that we always return a non-NULL value. The vector code uses
9559 4 when growing a NULL vector, so we do too. */
9561 }
9562 }
9564 /* Release a vector of trees back to the cache. */
9566 void
9568 {
9570 {
9573 }
9574 }
9576 /* Get a new tree vector holding a single tree. */
9580 {
9584 }
9586 /* Get a new tree vector which is a copy of an existing one. */
9590 {
9593 tree t;
9600 }
9602 /* Return true if KEYWORD starts a type specifier. */
9604 bool
9606 {
9608 {
9638 }
9639 }
9641 /* Return true if KEYWORD names a type qualifier. */
9643 bool
9645 {
9647 {
9654 }
9655 }
9657 /* Return true if KEYWORD names a storage class specifier.
9659 RID_TYPEDEF is not included in this list despite `typedef' being
9660 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
9661 such for syntactic convenience only. */
9663 bool
9665 {
9667 {
9677 }
9678 }
9680 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
9682 static bool
9684 {
9686 {
9693 }
9694 }
9696 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
9697 declaration-specifier (C99 6.7). */
9699 bool
9701 {
9708 {
9715 }
9716 }