]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/c-family/c-common.c
projects / thirdparty / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/m68k/m68k.c (m68k_handle_option): Don't handle
[thirdparty/gcc.git] / gcc / c-family / c-common.c
CommitLineData
b0fc3e72 1/* Subroutines shared by all languages that are variants of C.
d513ec2f 2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
fdd84b77 3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
2d9d8740 4 Free Software Foundation, Inc.
b0fc3e72 5
f12b58b3 6This file is part of GCC.
b0fc3e72 7
f12b58b3 8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
8c4c00c1 10Software Foundation; either version 3, or (at your option) any later
f12b58b3 11version.
b0fc3e72 12
f12b58b3 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
b0fc3e72 17
18You should have received a copy of the GNU General Public License
8c4c00c1 19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
b0fc3e72 21
22#include "config.h"
405711de 23#include "system.h"
805e22b2 24#include "coretypes.h"
25#include "tm.h"
e48d0f41 26#include "intl.h"
b0fc3e72 27#include "tree.h"
b0fc3e72 28#include "flags.h"
cd03a192 29#include "output.h"
a3fa7feb 30#include "c-pragma.h"
dc12af01 31#include "ggc.h"
e41f0d80 32#include "c-common.h"
6c536c4f 33#include "c-objc.h"
d8c9779c 34#include "tm_p.h"
4e91a871 35#include "obstack.h"
a654e028 36#include "cpplib.h"
8ee295a7 37#include "target.h"
96554925 38#include "langhooks.h"
f3dde807 39#include "tree-inline.h"
69579044 40#include "toplev.h"
7f5f3953 41#include "diagnostic.h"
4ee9c684 42#include "tree-iterator.h"
43#include "hashtab.h"
b55af61c 44#include "tree-mudflap.h"
e08bd2f4 45#include "opts.h"
62eec3b4 46#include "cgraph.h"
b9fc964a 47#include "target-def.h"
979d3efc 48#include "libfuncs.h"
fd6f6435 49
90cc7820 50cpp_reader *parse_in; /* Declared in c-pragma.h. */
a654e028 51
72040e7e 52/* The following symbols are subsumed in the c_global_trees array, and
44e9fa65 53 listed here individually for documentation purposes.
72040e7e 54
55 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
56
57 tree short_integer_type_node;
58 tree long_integer_type_node;
59 tree long_long_integer_type_node;
6388cfe2 60 tree int128_integer_type_node;
72040e7e 61
62 tree short_unsigned_type_node;
63 tree long_unsigned_type_node;
64 tree long_long_unsigned_type_node;
6388cfe2 65 tree int128_unsigned_type_node;
72040e7e 66
3c2239cf 67 tree truthvalue_type_node;
68 tree truthvalue_false_node;
69 tree truthvalue_true_node;
72040e7e 70
71 tree ptrdiff_type_node;
72
73 tree unsigned_char_type_node;
74 tree signed_char_type_node;
75 tree wchar_type_node;
72040e7e 76
924bbf02 77 tree char16_type_node;
78 tree char32_type_node;
79
72040e7e 80 tree float_type_node;
81 tree double_type_node;
82 tree long_double_type_node;
83
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;
88
c4503c0a 89 tree dfloat32_type_node;
90 tree dfloat64_type_node;
91 tree_dfloat128_type_node;
92
72040e7e 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;
98
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;
104
105 tree widest_integer_literal_type_node;
106 tree widest_unsigned_literal_type_node;
107
108 Nodes for types `void *' and `const void *'.
109
110 tree ptr_type_node, const_ptr_type_node;
111
112 Nodes for types `char *' and `const char *'.
113
114 tree string_type_node, const_string_type_node;
115
116 Type `char[SOMENUMBER]'.
117 Used when an array of char is needed and the size is irrelevant.
118
119 tree char_array_type_node;
120
121 Type `int[SOMENUMBER]' or something like it.
122 Used when an array of int needed and the size is irrelevant.
123
124 tree int_array_type_node;
125
126 Type `wchar_t[SOMENUMBER]' or something like it.
127 Used when a wide string literal is created.
128
129 tree wchar_array_type_node;
130
924bbf02 131 Type `char16_t[SOMENUMBER]' or something like it.
132 Used when a UTF-16 string literal is created.
133
134 tree char16_array_type_node;
135
136 Type `char32_t[SOMENUMBER]' or something like it.
137 Used when a UTF-32 string literal is created.
138
139 tree char32_array_type_node;
140
72040e7e 141 Type `int ()' -- used for implicit declaration of functions.
142
143 tree default_function_type;
144
72040e7e 145 A VOID_TYPE node, packaged in a TREE_LIST.
146
147 tree void_list_node;
148
734c98be 149 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
65b7f83f 150 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
151 VAR_DECLS, but C++ does.)
71d9fc9b 152
65b7f83f 153 tree function_name_decl_node;
734c98be 154 tree pretty_function_name_decl_node;
65b7f83f 155 tree c99_function_name_decl_node;
156
157 Stack of nested function name VAR_DECLs.
1cae46be 158
65b7f83f 159 tree saved_function_name_decls;
71d9fc9b 160
72040e7e 161*/
162
163tree c_global_trees[CTI_MAX];
573aba85 164\f
574a6990 165/* Switches common to the C front ends. */
166
f7070933 167/* Nonzero means don't output line number information. */
168
169char flag_no_line_commands;
170
171/* Nonzero causes -E output not to be done, but directives such as
172 #define that have side effects are still obeyed. */
173
174char flag_no_output;
175
176/* Nonzero means dump macros in some fashion. */
177
178char flag_dump_macros;
179
180/* Nonzero means pass #include lines through to the output. */
181
182char flag_dump_includes;
183
d718b525 184/* Nonzero means process PCH files while preprocessing. */
185
186bool flag_pch_preprocess;
187
573aba85 188/* The file name to which we should write a precompiled header, or
189 NULL if no header will be written in this compile. */
190
191const char *pch_file;
192
1ed9d5f5 193/* Nonzero if an ISO standard was selected. It rejects macros in the
194 user's namespace. */
195int flag_iso;
196
1cae46be 197/* Warn about #pragma directives that are not recognized. */
574a6990 198
1cae46be 199int warn_unknown_pragmas; /* Tri state variable. */
574a6990 200
574a6990 201/* Warn about format/argument anomalies in calls to formatted I/O functions
202 (*printf, *scanf, strftime, strfmon, etc.). */
203
204int warn_format;
205
574a6990 206/* C/ObjC language option variables. */
207
208
574a6990 209/* Nonzero means allow type mismatches in conditional expressions;
210 just make their values `void'. */
211
212int flag_cond_mismatch;
213
214/* Nonzero means enable C89 Amendment 1 features. */
215
216int flag_isoc94;
217
39012afb 218/* Nonzero means use the ISO C99 (or C1X) dialect of C. */
574a6990 219
220int flag_isoc99;
221
39012afb 222/* Nonzero means use the ISO C1X dialect of C. */
223
224int flag_isoc1x;
225
8b332087 226/* Nonzero means that we have builtin functions, and main is an int. */
574a6990 227
228int flag_hosted = 1;
229
574a6990 230
231/* ObjC language option variables. */
232
233
574a6990 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. */
237
238int print_struct_values;
239
f0b5f617 240/* Tells the compiler what is the constant string class for ObjC. */
574a6990 241
242const char *constant_string_class_name;
243
574a6990 244
245/* C++ language option variables. */
246
247
574a6990 248/* Nonzero means generate separate instantiation control files and
249 juggle them at link time. */
250
251int flag_use_repository;
252
6dcdb5de 253/* The C++ dialect being used. C++98 is the default. */
0fe6eeac 254
6dcdb5de 255enum cxx_dialect cxx_dialect = cxx98;
0fe6eeac 256
9dcd0d49 257/* Maximum template instantiation depth. This limit exists to limit the
54cf6eed 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. */
574a6990 260
9dcd0d49 261int max_tinst_depth = 1024;
574a6990 262
988fc1d1 263/* The elements of `ridpointers' are identifier nodes for the reserved
264 type names and storage classes. It is indexed by a RID_... value. */
265tree *ridpointers;
266
e60a6f7b 267tree (*make_fname_decl) (location_t, tree, int);
9e5a737d 268
48d94ede 269/* Nonzero means don't warn about problems that occur when the code is
270 executed. */
271int c_inhibit_evaluation_warnings;
e78703c1 272
93be21c0 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. */
279bool in_late_binary_op;
280
7f5f3953 281/* Whether lexing has been completed, so subsequent preprocessor
282 errors should use the compiler's input_location. */
283bool done_lexing = false;
284
2c0e001b 285/* Information about how a function name is generated. */
65b7f83f 286struct fname_var_t
287{
e99c3a1d 288 tree *const decl; /* pointer to the VAR_DECL. */
289 const unsigned rid; /* RID number for the identifier. */
290 const int pretty; /* How pretty is it? */
65b7f83f 291};
292
2c0e001b 293/* The three ways of getting then name of the current function. */
65b7f83f 294
295const struct fname_var_t fname_vars[] =
296{
2c0e001b 297 /* C99 compliant __func__, must be first. */
65b7f83f 298 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
2c0e001b 299 /* GCC __FUNCTION__ compliant. */
65b7f83f 300 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
2c0e001b 301 /* GCC __PRETTY_FUNCTION__ compliant. */
65b7f83f 302 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
303 {NULL, 0, 0},
304};
305
79396169 306/* Global visibility options. */
307struct visibility_flags visibility_options;
308
a75b1c71 309static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
2ca392fd 310static tree check_case_value (tree);
311static bool check_case_bounds (tree, tree, tree *, tree *);
be43ff5a 312
1cae46be 313static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
314static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
315static tree handle_common_attribute (tree *, tree, tree, int, bool *);
316static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
5de92639 317static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
318static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
1cae46be 319static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
bdb1f0d1 320static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
7bd95dfd 321static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
1cae46be 322static tree handle_always_inline_attribute (tree *, tree, tree, int,
323 bool *);
1b16fc45 324static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
325static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
0cdd9887 326static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
10fc867f 327static tree handle_error_attribute (tree *, tree, tree, int, bool *);
1cae46be 328static tree handle_used_attribute (tree *, tree, tree, int, bool *);
329static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
62eec3b4 330static tree handle_externally_visible_attribute (tree *, tree, tree, int,
331 bool *);
1cae46be 332static tree handle_const_attribute (tree *, tree, tree, int, bool *);
333static tree handle_transparent_union_attribute (tree *, tree, tree,
334 int, bool *);
335static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
336static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
337static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
338static tree handle_section_attribute (tree *, tree, tree, int, bool *);
339static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
340static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
85c0a25c 341static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
342static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
1cae46be 343static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
f4a30bd7 344static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
1cae46be 345static tree handle_visibility_attribute (tree *, tree, tree, int,
346 bool *);
347static tree handle_tls_model_attribute (tree *, tree, tree, int,
348 bool *);
349static tree handle_no_instrument_function_attribute (tree *, tree,
350 tree, int, bool *);
351static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
26d1c5ff 352static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
1cae46be 353static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
354 bool *);
355static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
fc09b200 356static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
1cae46be 357static tree handle_deprecated_attribute (tree *, tree, tree, int,
358 bool *);
359static tree handle_vector_size_attribute (tree *, tree, tree, int,
360 bool *);
361static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
362static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
363static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
8a8cdb8d 364static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
365 bool *);
bf6c8de0 366static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
b5c26b42 367static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
4a29c97c 368static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
24470055 369static tree handle_target_attribute (tree *, tree, tree, int, bool *);
46f8e3b0 370static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
48b14f50 371static tree handle_no_split_stack_attribute (tree *, tree, tree, int, bool *);
8ce86007 372static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
1cae46be 373
d01f58f9 374static void check_function_nonnull (tree, int, tree *);
1cae46be 375static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
376static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
377static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
860251be 378static int resort_field_decl_cmp (const void *, const void *);
dbf6c367 379
5c6e5756 380/* Reserved words. The third field is a mask: keywords are disabled
381 if they match the mask.
382
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
390
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.
b27e241e 394 In C with -Wc++-compat, we warn if D_CXXWARN is set.
5c6e5756 395
b27e241e 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*/
5c6e5756 401const struct c_common_resword c_common_reswords[] =
402{
403 { "_Bool", RID_BOOL, D_CONLY },
404 { "_Complex", RID_COMPLEX, 0 },
c1800156 405 { "_Imaginary", RID_IMAGINARY, D_CONLY },
5c6e5756 406 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
407 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
408 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
409 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
410 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
411 { "_Sat", RID_SAT, D_CONLY | D_EXT },
f80e7755 412 { "_Static_assert", RID_STATIC_ASSERT, D_CONLY },
5c6e5756 413 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
414 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
415 { "__alignof", RID_ALIGNOF, 0 },
416 { "__alignof__", RID_ALIGNOF, 0 },
417 { "__asm", RID_ASM, 0 },
418 { "__asm__", RID_ASM, 0 },
419 { "__attribute", RID_ATTRIBUTE, 0 },
420 { "__attribute__", RID_ATTRIBUTE, 0 },
421 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
422 { "__builtin_offsetof", RID_OFFSETOF, 0 },
423 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
424 { "__builtin_va_arg", RID_VA_ARG, 0 },
425 { "__complex", RID_COMPLEX, 0 },
426 { "__complex__", RID_COMPLEX, 0 },
427 { "__const", RID_CONST, 0 },
428 { "__const__", RID_CONST, 0 },
429 { "__decltype", RID_DECLTYPE, D_CXXONLY },
430 { "__extension__", RID_EXTENSION, 0 },
431 { "__func__", RID_C99_FUNCTION_NAME, 0 },
432 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
433 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
434 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
435 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
436 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
437 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
438 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
439 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
6388cfe2 440 { "__int128", RID_INT128, 0 },
5c6e5756 441 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
442 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
443 { "__is_class", RID_IS_CLASS, D_CXXONLY },
444 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
445 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
446 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
447 { "__is_pod", RID_IS_POD, D_CXXONLY },
448 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
c1c67b4f 449 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
450 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY },
5c6e5756 451 { "__is_union", RID_IS_UNION, D_CXXONLY },
5290e253 452 { "__is_literal_type", RID_IS_LITERAL_TYPE, D_CXXONLY },
5c6e5756 453 { "__imag", RID_IMAGPART, 0 },
454 { "__imag__", RID_IMAGPART, 0 },
455 { "__inline", RID_INLINE, 0 },
456 { "__inline__", RID_INLINE, 0 },
457 { "__label__", RID_LABEL, 0 },
458 { "__null", RID_NULL, 0 },
459 { "__real", RID_REALPART, 0 },
460 { "__real__", RID_REALPART, 0 },
461 { "__restrict", RID_RESTRICT, 0 },
462 { "__restrict__", RID_RESTRICT, 0 },
463 { "__signed", RID_SIGNED, 0 },
464 { "__signed__", RID_SIGNED, 0 },
465 { "__thread", RID_THREAD, 0 },
466 { "__typeof", RID_TYPEOF, 0 },
467 { "__typeof__", RID_TYPEOF, 0 },
468 { "__volatile", RID_VOLATILE, 0 },
469 { "__volatile__", RID_VOLATILE, 0 },
e463efd7 470 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX0X | D_CXXWARN },
5c6e5756 471 { "asm", RID_ASM, D_ASM },
472 { "auto", RID_AUTO, 0 },
dbd982c9 473 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
5c6e5756 474 { "break", RID_BREAK, 0 },
475 { "case", RID_CASE, 0 },
51030405 476 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
5c6e5756 477 { "char", RID_CHAR, 0 },
51030405 478 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
479 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
480 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
5c6e5756 481 { "const", RID_CONST, 0 },
17814aca 482 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX0X | D_CXXWARN },
5c6e5756 483 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
484 { "continue", RID_CONTINUE, 0 },
51030405 485 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
5c6e5756 486 { "default", RID_DEFAULT, 0 },
51030405 487 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
5c6e5756 488 { "do", RID_DO, 0 },
489 { "double", RID_DOUBLE, 0 },
490 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
491 { "else", RID_ELSE, 0 },
492 { "enum", RID_ENUM, 0 },
51030405 493 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
494 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
5c6e5756 495 { "extern", RID_EXTERN, 0 },
51030405 496 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
5c6e5756 497 { "float", RID_FLOAT, 0 },
498 { "for", RID_FOR, 0 },
51030405 499 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
5c6e5756 500 { "goto", RID_GOTO, 0 },
501 { "if", RID_IF, 0 },
502 { "inline", RID_INLINE, D_EXT89 },
503 { "int", RID_INT, 0 },
504 { "long", RID_LONG, 0 },
505 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
51030405 506 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
507 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
98fe9664 508 { "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX0X | D_CXXWARN },
6fe11077 509 { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX0X | D_CXXWARN },
51030405 510 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
511 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
512 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
513 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
5c6e5756 514 { "register", RID_REGISTER, 0 },
515 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
516 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
517 { "return", RID_RETURN, 0 },
518 { "short", RID_SHORT, 0 },
519 { "signed", RID_SIGNED, 0 },
520 { "sizeof", RID_SIZEOF, 0 },
521 { "static", RID_STATIC, 0 },
522 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
523 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
524 { "struct", RID_STRUCT, 0 },
525 { "switch", RID_SWITCH, 0 },
51030405 526 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
527 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
528 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
529 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
530 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
5c6e5756 531 { "typedef", RID_TYPEDEF, 0 },
51030405 532 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
533 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
5c6e5756 534 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
535 { "union", RID_UNION, 0 },
536 { "unsigned", RID_UNSIGNED, 0 },
51030405 537 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
538 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
5c6e5756 539 { "void", RID_VOID, 0 },
540 { "volatile", RID_VOLATILE, 0 },
541 { "wchar_t", RID_WCHAR, D_CXXONLY },
542 { "while", RID_WHILE, 0 },
543 /* These Objective-C keywords are recognized only immediately after
544 an '@'. */
545 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
546 { "defs", RID_AT_DEFS, D_OBJC },
547 { "encode", RID_AT_ENCODE, D_OBJC },
548 { "end", RID_AT_END, D_OBJC },
549 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
550 { "interface", RID_AT_INTERFACE, D_OBJC },
551 { "protocol", RID_AT_PROTOCOL, D_OBJC },
552 { "selector", RID_AT_SELECTOR, D_OBJC },
553 { "finally", RID_AT_FINALLY, D_OBJC },
554 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
069761fb 555 { "optional", RID_AT_OPTIONAL, D_OBJC },
556 { "required", RID_AT_REQUIRED, D_OBJC },
86c110ac 557 { "property", RID_AT_PROPERTY, D_OBJC },
4a8875ed 558 { "package", RID_AT_PACKAGE, D_OBJC },
e1f293c0 559 { "synthesize", RID_AT_SYNTHESIZE, D_OBJC },
560 { "dynamic", RID_AT_DYNAMIC, D_OBJC },
5c6e5756 561 /* These are recognized only in protocol-qualifier context
562 (see above) */
563 { "bycopy", RID_BYCOPY, D_OBJC },
564 { "byref", RID_BYREF, D_OBJC },
565 { "in", RID_IN, D_OBJC },
566 { "inout", RID_INOUT, D_OBJC },
567 { "oneway", RID_ONEWAY, D_OBJC },
568 { "out", RID_OUT, D_OBJC },
86c110ac 569 /* These are recognized inside a property attribute list */
7590f0e5 570 { "assign", RID_ASSIGN, D_OBJC },
571 { "copy", RID_COPY, D_OBJC },
86c110ac 572 { "getter", RID_GETTER, D_OBJC },
7590f0e5 573 { "nonatomic", RID_NONATOMIC, D_OBJC },
574 { "readonly", RID_READONLY, D_OBJC },
575 { "readwrite", RID_READWRITE, D_OBJC },
576 { "retain", RID_RETAIN, D_OBJC },
86c110ac 577 { "setter", RID_SETTER, D_OBJC },
5c6e5756 578};
579
580const unsigned int num_c_common_reswords =
581 sizeof c_common_reswords / sizeof (struct c_common_resword);
582
f8e93a2e 583/* Table of machine-independent attributes common to all C-like languages. */
584const struct attribute_spec c_common_attribute_table[] =
585{
ac86af5d 586 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
587 affects_type_identity } */
f8e93a2e 588 { "packed", 0, 0, false, false, false,
ac86af5d 589 handle_packed_attribute , false},
f8e93a2e 590 { "nocommon", 0, 0, true, false, false,
ac86af5d 591 handle_nocommon_attribute, false},
f8e93a2e 592 { "common", 0, 0, true, false, false,
ac86af5d 593 handle_common_attribute, false },
f8e93a2e 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. */
599 { "noreturn", 0, 0, true, false, false,
ac86af5d 600 handle_noreturn_attribute, false },
f8e93a2e 601 { "volatile", 0, 0, true, false, false,
ac86af5d 602 handle_noreturn_attribute, false },
f8e93a2e 603 { "noinline", 0, 0, true, false, false,
ac86af5d 604 handle_noinline_attribute, false },
bdb1f0d1 605 { "noclone", 0, 0, true, false, false,
ac86af5d 606 handle_noclone_attribute, false },
7bd95dfd 607 { "leaf", 0, 0, true, false, false,
ac86af5d 608 handle_leaf_attribute, false },
f8e93a2e 609 { "always_inline", 0, 0, true, false, false,
ac86af5d 610 handle_always_inline_attribute, false },
541e4101 611 { "gnu_inline", 0, 0, true, false, false,
ac86af5d 612 handle_gnu_inline_attribute, false },
1b16fc45 613 { "artificial", 0, 0, true, false, false,
ac86af5d 614 handle_artificial_attribute, false },
0cdd9887 615 { "flatten", 0, 0, true, false, false,
ac86af5d 616 handle_flatten_attribute, false },
f8e93a2e 617 { "used", 0, 0, true, false, false,
ac86af5d 618 handle_used_attribute, false },
f8e93a2e 619 { "unused", 0, 0, false, false, false,
ac86af5d 620 handle_unused_attribute, false },
62eec3b4 621 { "externally_visible", 0, 0, true, false, false,
ac86af5d 622 handle_externally_visible_attribute, false },
f8e93a2e 623 /* The same comments as for noreturn attributes apply to const ones. */
624 { "const", 0, 0, true, false, false,
ac86af5d 625 handle_const_attribute, false },
f8e93a2e 626 { "transparent_union", 0, 0, false, false, false,
ac86af5d 627 handle_transparent_union_attribute, false },
9af7fd5b 628 { "constructor", 0, 1, true, false, false,
ac86af5d 629 handle_constructor_attribute, false },
9af7fd5b 630 { "destructor", 0, 1, true, false, false,
ac86af5d 631 handle_destructor_attribute, false },
f8e93a2e 632 { "mode", 1, 1, false, true, false,
ac86af5d 633 handle_mode_attribute, false },
f8e93a2e 634 { "section", 1, 1, true, false, false,
ac86af5d 635 handle_section_attribute, false },
f8e93a2e 636 { "aligned", 0, 1, false, false, false,
ac86af5d 637 handle_aligned_attribute, false },
f8e93a2e 638 { "weak", 0, 0, true, false, false,
ac86af5d 639 handle_weak_attribute, false },
85c0a25c 640 { "ifunc", 1, 1, true, false, false,
ac86af5d 641 handle_ifunc_attribute, false },
f8e93a2e 642 { "alias", 1, 1, true, false, false,
ac86af5d 643 handle_alias_attribute, false },
f4a30bd7 644 { "weakref", 0, 1, true, false, false,
ac86af5d 645 handle_weakref_attribute, false },
f8e93a2e 646 { "no_instrument_function", 0, 0, true, false, false,
ac86af5d 647 handle_no_instrument_function_attribute,
648 false },
f8e93a2e 649 { "malloc", 0, 0, true, false, false,
ac86af5d 650 handle_malloc_attribute, false },
26d1c5ff 651 { "returns_twice", 0, 0, true, false, false,
ac86af5d 652 handle_returns_twice_attribute, false },
f8e93a2e 653 { "no_stack_limit", 0, 0, true, false, false,
ac86af5d 654 handle_no_limit_stack_attribute, false },
f8e93a2e 655 { "pure", 0, 0, true, false, false,
ac86af5d 656 handle_pure_attribute, false },
fc09b200 657 /* For internal use (marking of builtins) only. The name contains space
658 to prevent its usage in source code. */
659 { "no vops", 0, 0, true, false, false,
ac86af5d 660 handle_novops_attribute, false },
45c4e798 661 { "deprecated", 0, 1, false, false, false,
ac86af5d 662 handle_deprecated_attribute, false },
f8e93a2e 663 { "vector_size", 1, 1, false, true, false,
ac86af5d 664 handle_vector_size_attribute, false },
b212f378 665 { "visibility", 1, 1, false, false, false,
ac86af5d 666 handle_visibility_attribute, false },
24dfead4 667 { "tls_model", 1, 1, true, false, false,
ac86af5d 668 handle_tls_model_attribute, false },
dbf6c367 669 { "nonnull", 0, -1, false, true, true,
ac86af5d 670 handle_nonnull_attribute, false },
fa987697 671 { "nothrow", 0, 0, true, false, false,
ac86af5d 672 handle_nothrow_attribute, false },
673 { "may_alias", 0, 0, false, true, false, NULL, false },
7acb29a3 674 { "cleanup", 1, 1, true, false, false,
ac86af5d 675 handle_cleanup_attribute, false },
8a8cdb8d 676 { "warn_unused_result", 0, 0, false, true, true,
ac86af5d 677 handle_warn_unused_result_attribute, false },
50ca527f 678 { "sentinel", 0, 1, false, true, true,
ac86af5d 679 handle_sentinel_attribute, false },
b5c26b42 680 /* For internal use (marking of builtins) only. The name contains space
681 to prevent its usage in source code. */
682 { "type generic", 0, 0, false, true, true,
ac86af5d 683 handle_type_generic_attribute, false },
4a29c97c 684 { "alloc_size", 1, 2, false, true, true,
ac86af5d 685 handle_alloc_size_attribute, false },
5de92639 686 { "cold", 0, 0, true, false, false,
ac86af5d 687 handle_cold_attribute, false },
5de92639 688 { "hot", 0, 0, true, false, false,
ac86af5d 689 handle_hot_attribute, false },
10fc867f 690 { "warning", 1, 1, true, false, false,
ac86af5d 691 handle_error_attribute, false },
10fc867f 692 { "error", 1, 1, true, false, false,
ac86af5d 693 handle_error_attribute, false },
24470055 694 { "target", 1, -1, true, false, false,
ac86af5d 695 handle_target_attribute, false },
46f8e3b0 696 { "optimize", 1, -1, true, false, false,
ac86af5d 697 handle_optimize_attribute, false },
48b14f50 698 { "no_split_stack", 0, 0, true, false, false,
ac86af5d 699 handle_no_split_stack_attribute, false },
8ce86007 700 /* For internal use (marking of builtins and runtime functions) only.
701 The name contains space to prevent its usage in source code. */
702 { "fn spec", 1, 1, false, true, true,
ac86af5d 703 handle_fnspec_attribute, false },
704 { NULL, 0, 0, false, false, false, NULL, false }
f8e93a2e 705};
706
707/* Give the specifications for the format attributes, used by C and all
d716ce75 708 descendants. */
f8e93a2e 709
710const struct attribute_spec c_common_format_attribute_table[] =
711{
ac86af5d 712 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
713 affects_type_identity } */
f8e93a2e 714 { "format", 3, 3, false, true, true,
ac86af5d 715 handle_format_attribute, false },
f8e93a2e 716 { "format_arg", 1, 1, false, true, true,
ac86af5d 717 handle_format_arg_attribute, false },
718 { NULL, 0, 0, false, false, false, NULL, false }
f8e93a2e 719};
720
6d5d708e 721/* Return identifier for address space AS. */
34208e18 722
6d5d708e 723const char *
724c_addr_space_name (addr_space_t as)
725{
34208e18 726 int rid = RID_FIRST_ADDR_SPACE + as;
727 gcc_assert (ridpointers [rid]);
728 return IDENTIFIER_POINTER (ridpointers [rid]);
6d5d708e 729}
730
2c0e001b 731/* Push current bindings for the function name VAR_DECLS. */
f4e3c278 732
733void
1cae46be 734start_fname_decls (void)
f4e3c278 735{
65b7f83f 736 unsigned ix;
737 tree saved = NULL_TREE;
1cae46be 738
65b7f83f 739 for (ix = 0; fname_vars[ix].decl; ix++)
740 {
741 tree decl = *fname_vars[ix].decl;
f4e3c278 742
65b7f83f 743 if (decl)
744 {
7016c612 745 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
65b7f83f 746 *fname_vars[ix].decl = NULL_TREE;
747 }
748 }
749 if (saved || saved_function_name_decls)
750 /* Normally they'll have been NULL, so only push if we've got a
751 stack, or they are non-NULL. */
752 saved_function_name_decls = tree_cons (saved, NULL_TREE,
753 saved_function_name_decls);
754}
755
2363ef00 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. */
65b7f83f 760
761void
1cae46be 762finish_fname_decls (void)
65b7f83f 763{
764 unsigned ix;
2363ef00 765 tree stmts = NULL_TREE;
65b7f83f 766 tree stack = saved_function_name_decls;
767
768 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
2363ef00 769 append_to_statement_list (TREE_VALUE (stack), &stmts);
1cae46be 770
2363ef00 771 if (stmts)
65b7f83f 772 {
2363ef00 773 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
5c423bd6 774
2363ef00 775 if (TREE_CODE (*bodyp) == BIND_EXPR)
776 bodyp = &BIND_EXPR_BODY (*bodyp);
81010c97 777
bc2b76e0 778 append_to_statement_list_force (*bodyp, &stmts);
2363ef00 779 *bodyp = stmts;
65b7f83f 780 }
1cae46be 781
65b7f83f 782 for (ix = 0; fname_vars[ix].decl; ix++)
783 *fname_vars[ix].decl = NULL_TREE;
1cae46be 784
65b7f83f 785 if (stack)
f4e3c278 786 {
2c0e001b 787 /* We had saved values, restore them. */
65b7f83f 788 tree saved;
789
790 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
791 {
792 tree decl = TREE_PURPOSE (saved);
793 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
1cae46be 794
65b7f83f 795 *fname_vars[ix].decl = decl;
796 }
797 stack = TREE_CHAIN (stack);
f4e3c278 798 }
65b7f83f 799 saved_function_name_decls = stack;
800}
801
81010c97 802/* Return the text name of the current function, suitably prettified
5fc7fa69 803 by PRETTY_P. Return string must be freed by caller. */
65b7f83f 804
805const char *
1cae46be 806fname_as_string (int pretty_p)
65b7f83f 807{
9ad4bb1e 808 const char *name = "top level";
5fc7fa69 809 char *namep;
8115b8be 810 int vrb = 2, len;
811 cpp_string cstr = { 0, 0 }, strname;
9ad4bb1e 812
84166705 813 if (!pretty_p)
9ad4bb1e 814 {
815 name = "";
816 vrb = 0;
817 }
818
819 if (current_function_decl)
dc24ddbd 820 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
9ad4bb1e 821
8115b8be 822 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
5fc7fa69 823
8115b8be 824 namep = XNEWVEC (char, len);
825 snprintf (namep, len, "\"%s\"", name);
826 strname.text = (unsigned char *) namep;
827 strname.len = len - 1;
5fc7fa69 828
924bbf02 829 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
8115b8be 830 {
831 XDELETEVEC (namep);
832 return (const char *) cstr.text;
5fc7fa69 833 }
5fc7fa69 834
835 return namep;
65b7f83f 836}
837
65b7f83f 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
e3b80d49 843 this language independent code. LOC is the location of the
844 function. */
65b7f83f 845
846tree
e3b80d49 847fname_decl (location_t loc, unsigned int rid, tree id)
65b7f83f 848{
849 unsigned ix;
850 tree decl = NULL_TREE;
851
852 for (ix = 0; fname_vars[ix].decl; ix++)
853 if (fname_vars[ix].rid == rid)
854 break;
855
856 decl = *fname_vars[ix].decl;
857 if (!decl)
f4e3c278 858 {
2222b3c6 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
7299020b 863 it from appearing in the RTL. */
2363ef00 864 tree stmts;
9a6486a6 865 location_t saved_location = input_location;
9a6486a6 866 input_location = UNKNOWN_LOCATION;
1cae46be 867
2363ef00 868 stmts = push_stmt_list ();
e60a6f7b 869 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
2363ef00 870 stmts = pop_stmt_list (stmts);
871 if (!IS_EMPTY_STMT (stmts))
872 saved_function_name_decls
873 = tree_cons (decl, stmts, saved_function_name_decls);
65b7f83f 874 *fname_vars[ix].decl = decl;
9a6486a6 875 input_location = saved_location;
f4e3c278 876 }
65b7f83f 877 if (!ix && !current_function_decl)
e3b80d49 878 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
81010c97 879
65b7f83f 880 return decl;
f4e3c278 881}
882
070236f0 883/* Given a STRING_CST, give it a suitable array-of-chars data type. */
b0fc3e72 884
885tree
1cae46be 886fix_string_type (tree value)
b0fc3e72 887{
070236f0 888 int length = TREE_STRING_LENGTH (value);
889 int nchars;
00d26680 890 tree e_type, i_type, a_type;
891
73be5127 892 /* Compute the number of elements, for the array type. */
924bbf02 893 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
894 {
895 nchars = length;
896 e_type = char_type_node;
897 }
898 else if (TREE_TYPE (value) == char16_array_type_node)
899 {
900 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
901 e_type = char16_type_node;
902 }
903 else if (TREE_TYPE (value) == char32_array_type_node)
904 {
905 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
906 e_type = char32_type_node;
907 }
908 else
909 {
910 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
911 e_type = wchar_type_node;
912 }
b0fc3e72 913
1d752508 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). */
918 if (warn_overlength_strings)
919 {
920 const int nchars_max = flag_isoc99 ? 4095 : 509;
921 const int relevant_std = flag_isoc99 ? 99 : 90;
922 if (nchars - 1 > nchars_max)
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. */
21ca8540 927 pedwarn (input_location, OPT_Woverlength_strings,
8864917d 928 "string length %qd is greater than the length %qd "
1d752508 929 "ISO C%d compilers are required to support",
930 nchars - 1, nchars_max, relevant_std);
931 }
82cfc7f7 932
390be14e 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*'.
00d26680 941
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. */
7016c612 948 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
00d26680 949 a_type = build_array_type (e_type, i_type);
390be14e 950 if (c_dialect_cxx() || warn_write_strings)
aebc8537 951 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
3a10ba35 952
00d26680 953 TREE_TYPE (value) = a_type;
b8e3b7ad 954 TREE_CONSTANT (value) = 1;
a814bad5 955 TREE_READONLY (value) = 1;
b0fc3e72 956 TREE_STATIC (value) = 1;
957 return value;
958}
959\f
a75b1c71 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. */
974
975tree
976c_fully_fold (tree expr, bool in_init, bool *maybe_const)
977{
978 tree ret;
c6418a4e 979 tree eptype = NULL_TREE;
a75b1c71 980 bool dummy = true;
981 bool maybe_const_itself = true;
389dd41b 982 location_t loc = EXPR_LOCATION (expr);
a75b1c71 983
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. */
987 if (c_dialect_cxx ())
988 gcc_unreachable ();
989
990 if (!maybe_const)
991 maybe_const = &dummy;
c6418a4e 992 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
993 {
994 eptype = TREE_TYPE (expr);
995 expr = TREE_OPERAND (expr, 0);
996 }
a75b1c71 997 ret = c_fully_fold_internal (expr, in_init, maybe_const,
998 &maybe_const_itself);
c6418a4e 999 if (eptype)
389dd41b 1000 ret = fold_convert_loc (loc, eptype, ret);
a75b1c71 1001 *maybe_const &= maybe_const_itself;
1002 return ret;
1003}
1004
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). */
1012
1013static tree
1014c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1015 bool *maybe_const_itself)
1016{
1017 tree ret = expr;
1018 enum tree_code code = TREE_CODE (expr);
1019 enum tree_code_class kind = TREE_CODE_CLASS (code);
1020 location_t loc = EXPR_LOCATION (expr);
1021 tree op0, op1, op2, op3;
1022 tree orig_op0, orig_op1, orig_op2;
1023 bool op0_const = true, op1_const = true, op2_const = true;
1024 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1025 bool nowarning = TREE_NO_WARNING (expr);
672d914b 1026 int unused_p;
a75b1c71 1027
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. */
1031 if (c_dialect_cxx ())
1032 gcc_unreachable ();
1033
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. */
1037 if (!IS_EXPR_CODE_CLASS (kind)
1038 || kind == tcc_statement
1039 || code == SAVE_EXPR)
1040 return expr;
1041
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. */
1045 if (kind == tcc_vl_exp)
1046 {
1047 *maybe_const_operands = false;
1048 ret = fold (expr);
1049 goto out;
1050 }
1051
1052 if (code == C_MAYBE_CONST_EXPR)
1053 {
1054 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1055 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1056 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1057 *maybe_const_operands = false;
1058 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1059 *maybe_const_itself = false;
1060 if (pre && !in_init)
1061 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1062 else
1063 ret = inner;
1064 goto out;
1065 }
1066
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.) */
1073 switch (code)
1074 {
1075 case MODIFY_EXPR:
1076 case PREDECREMENT_EXPR:
1077 case PREINCREMENT_EXPR:
1078 case POSTDECREMENT_EXPR:
1079 case POSTINCREMENT_EXPR:
1080 case COMPOUND_EXPR:
1081 *maybe_const_operands = false;
1082 break;
1083
1084 case VA_ARG_EXPR:
1085 case TARGET_EXPR:
1086 case BIND_EXPR:
1087 case OBJ_TYPE_REF:
1088 *maybe_const_operands = false;
1089 ret = fold (expr);
1090 goto out;
1091
1092 default:
1093 break;
1094 }
1095
1096 /* Fold individual tree codes as appropriate. */
1097 switch (code)
1098 {
1099 case COMPOUND_LITERAL_EXPR:
1100 /* Any non-constancy will have been marked in a containing
1101 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1102 goto out;
1103
1104 case COMPONENT_REF:
1105 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1106 op1 = TREE_OPERAND (expr, 1);
1107 op2 = TREE_OPERAND (expr, 2);
1108 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1109 maybe_const_itself);
f59e3889 1110 STRIP_TYPE_NOPS (op0);
a75b1c71 1111 if (op0 != orig_op0)
1112 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1113 if (ret != expr)
1114 {
1115 TREE_READONLY (ret) = TREE_READONLY (expr);
1116 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1117 }
1118 goto out;
1119
1120 case ARRAY_REF:
1121 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1122 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1123 op2 = TREE_OPERAND (expr, 2);
1124 op3 = TREE_OPERAND (expr, 3);
1125 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1126 maybe_const_itself);
f59e3889 1127 STRIP_TYPE_NOPS (op0);
a75b1c71 1128 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1129 maybe_const_itself);
f59e3889 1130 STRIP_TYPE_NOPS (op1);
a75b1c71 1131 op1 = decl_constant_value_for_optimization (op1);
1132 if (op0 != orig_op0 || op1 != orig_op1)
1133 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1134 if (ret != expr)
1135 {
1136 TREE_READONLY (ret) = TREE_READONLY (expr);
1137 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1138 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1139 }
1140 ret = fold (ret);
1141 goto out;
1142
1143 case COMPOUND_EXPR:
1144 case MODIFY_EXPR:
1145 case PREDECREMENT_EXPR:
1146 case PREINCREMENT_EXPR:
1147 case POSTDECREMENT_EXPR:
1148 case POSTINCREMENT_EXPR:
1149 case PLUS_EXPR:
1150 case MINUS_EXPR:
1151 case MULT_EXPR:
1152 case POINTER_PLUS_EXPR:
1153 case TRUNC_DIV_EXPR:
1154 case CEIL_DIV_EXPR:
1155 case FLOOR_DIV_EXPR:
1156 case TRUNC_MOD_EXPR:
1157 case RDIV_EXPR:
1158 case EXACT_DIV_EXPR:
1159 case LSHIFT_EXPR:
1160 case RSHIFT_EXPR:
1161 case BIT_IOR_EXPR:
1162 case BIT_XOR_EXPR:
1163 case BIT_AND_EXPR:
1164 case LT_EXPR:
1165 case LE_EXPR:
1166 case GT_EXPR:
1167 case GE_EXPR:
1168 case EQ_EXPR:
1169 case NE_EXPR:
1170 case COMPLEX_EXPR:
1171 case TRUTH_AND_EXPR:
1172 case TRUTH_OR_EXPR:
1173 case TRUTH_XOR_EXPR:
1174 case UNORDERED_EXPR:
1175 case ORDERED_EXPR:
1176 case UNLT_EXPR:
1177 case UNLE_EXPR:
1178 case UNGT_EXPR:
1179 case UNGE_EXPR:
1180 case UNEQ_EXPR:
1181 /* Binary operations evaluating both arguments (increment and
1182 decrement are binary internally in GCC). */
1183 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1184 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1185 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1186 maybe_const_itself);
f59e3889 1187 STRIP_TYPE_NOPS (op0);
a75b1c71 1188 if (code != MODIFY_EXPR
1189 && code != PREDECREMENT_EXPR
1190 && code != PREINCREMENT_EXPR
1191 && code != POSTDECREMENT_EXPR
1192 && code != POSTINCREMENT_EXPR)
1193 op0 = decl_constant_value_for_optimization (op0);
1194 /* The RHS of a MODIFY_EXPR was fully folded when building that
1195 expression for the sake of conversion warnings. */
1196 if (code != MODIFY_EXPR)
1197 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1198 maybe_const_itself);
f59e3889 1199 STRIP_TYPE_NOPS (op1);
a75b1c71 1200 op1 = decl_constant_value_for_optimization (op1);
1201 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1202 ret = in_init
389dd41b 1203 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1204 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
a75b1c71 1205 else
1206 ret = fold (expr);
672d914b 1207 if (TREE_OVERFLOW_P (ret)
1208 && !TREE_OVERFLOW_P (op0)
1209 && !TREE_OVERFLOW_P (op1))
1210 overflow_warning (EXPR_LOCATION (expr), ret);
a75b1c71 1211 goto out;
1212
1213 case INDIRECT_REF:
1214 case FIX_TRUNC_EXPR:
1215 case FLOAT_EXPR:
1216 CASE_CONVERT:
2b19dfe4 1217 case VIEW_CONVERT_EXPR:
a75b1c71 1218 case NON_LVALUE_EXPR:
1219 case NEGATE_EXPR:
1220 case BIT_NOT_EXPR:
1221 case TRUTH_NOT_EXPR:
1222 case ADDR_EXPR:
1223 case CONJ_EXPR:
1224 case REALPART_EXPR:
1225 case IMAGPART_EXPR:
1226 /* Unary operations. */
1227 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1228 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1229 maybe_const_itself);
f59e3889 1230 STRIP_TYPE_NOPS (op0);
a75b1c71 1231 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1232 op0 = decl_constant_value_for_optimization (op0);
1233 if (op0 != orig_op0 || in_init)
1234 ret = in_init
389dd41b 1235 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1236 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
a75b1c71 1237 else
1238 ret = fold (expr);
1239 if (code == INDIRECT_REF
1240 && ret != expr
1241 && TREE_CODE (ret) == INDIRECT_REF)
1242 {
1243 TREE_READONLY (ret) = TREE_READONLY (expr);
1244 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1245 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1246 }
672d914b 1247 switch (code)
1248 {
1249 case FIX_TRUNC_EXPR:
1250 case FLOAT_EXPR:
1251 CASE_CONVERT:
1252 /* Don't warn about explicit conversions. We will already
1253 have warned about suspect implicit conversions. */
1254 break;
1255
1256 default:
1257 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1258 overflow_warning (EXPR_LOCATION (expr), ret);
1259 break;
1260 }
a75b1c71 1261 goto out;
1262
1263 case TRUTH_ANDIF_EXPR:
1264 case TRUTH_ORIF_EXPR:
1265 /* Binary operations not necessarily evaluating both
1266 arguments. */
1267 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1268 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1269 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
f59e3889 1270 STRIP_TYPE_NOPS (op0);
672d914b 1271
1272 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1273 ? truthvalue_false_node
1274 : truthvalue_true_node));
1275 c_inhibit_evaluation_warnings += unused_p;
a75b1c71 1276 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
f59e3889 1277 STRIP_TYPE_NOPS (op1);
672d914b 1278 c_inhibit_evaluation_warnings -= unused_p;
1279
a75b1c71 1280 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1281 ret = in_init
389dd41b 1282 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1283 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
a75b1c71 1284 else
1285 ret = fold (expr);
1286 *maybe_const_operands &= op0_const;
1287 *maybe_const_itself &= op0_const_self;
1288 if (!(flag_isoc99
1289 && op0_const
1290 && op0_const_self
1291 && (code == TRUTH_ANDIF_EXPR
1292 ? op0 == truthvalue_false_node
1293 : op0 == truthvalue_true_node)))
1294 *maybe_const_operands &= op1_const;
1295 if (!(op0_const
1296 && op0_const_self
1297 && (code == TRUTH_ANDIF_EXPR
1298 ? op0 == truthvalue_false_node
1299 : op0 == truthvalue_true_node)))
1300 *maybe_const_itself &= op1_const_self;
1301 goto out;
1302
1303 case COND_EXPR:
1304 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1305 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1306 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1307 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
672d914b 1308
f59e3889 1309 STRIP_TYPE_NOPS (op0);
672d914b 1310 c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
a75b1c71 1311 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
f59e3889 1312 STRIP_TYPE_NOPS (op1);
672d914b 1313 c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1314
1315 c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
a75b1c71 1316 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
f59e3889 1317 STRIP_TYPE_NOPS (op2);
672d914b 1318 c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1319
a75b1c71 1320 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
389dd41b 1321 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
a75b1c71 1322 else
1323 ret = fold (expr);
1324 *maybe_const_operands &= op0_const;
1325 *maybe_const_itself &= op0_const_self;
1326 if (!(flag_isoc99
1327 && op0_const
1328 && op0_const_self
1329 && op0 == truthvalue_false_node))
1330 *maybe_const_operands &= op1_const;
1331 if (!(op0_const
1332 && op0_const_self
1333 && op0 == truthvalue_false_node))
1334 *maybe_const_itself &= op1_const_self;
1335 if (!(flag_isoc99
1336 && op0_const
1337 && op0_const_self
1338 && op0 == truthvalue_true_node))
1339 *maybe_const_operands &= op2_const;
1340 if (!(op0_const
1341 && op0_const_self
1342 && op0 == truthvalue_true_node))
1343 *maybe_const_itself &= op2_const_self;
1344 goto out;
1345
c6418a4e 1346 case EXCESS_PRECISION_EXPR:
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. */
1353 gcc_unreachable ();
1354
a75b1c71 1355 default:
1356 /* Various codes may appear through folding built-in functions
1357 and their arguments. */
1358 goto out;
1359 }
1360
1361 out:
1362 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1363 have been done by this point, so remove them again. */
1364 nowarning |= TREE_NO_WARNING (ret);
1365 STRIP_TYPE_NOPS (ret);
1366 if (nowarning && !TREE_NO_WARNING (ret))
1367 {
1368 if (!CAN_HAVE_LOCATION_P (ret))
1369 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1370 TREE_NO_WARNING (ret) = 1;
1371 }
1372 if (ret != expr)
1373 protected_set_expr_location (ret, loc);
1374 return ret;
1375}
1376
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? */
1381
1382tree
1383decl_constant_value_for_optimization (tree exp)
1384{
1385 tree ret;
1386
1387 /* This function is only used by C, for c_fully_fold and other
1388 optimization, and may not be correct for C++. */
1389 if (c_dialect_cxx ())
1390 gcc_unreachable ();
1391
1392 if (!optimize
1393 || TREE_CODE (exp) != VAR_DECL
1394 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1395 || DECL_MODE (exp) == BLKmode)
1396 return exp;
1397
1398 ret = decl_constant_value (exp);
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. */
1402 if (ret != exp && TREE_STATIC (exp))
1403 ret = unshare_expr (ret);
1404 return ret;
1405}
1406
2a1736ed 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. */
b2806639 1412
1413void
1cae46be 1414constant_expression_warning (tree value)
07317e69 1415{
48e1416a 1416 if (warn_overflow && pedantic
07317e69 1417 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1418 || TREE_CODE (value) == FIXED_CST
1419 || TREE_CODE (value) == VECTOR_CST
1420 || TREE_CODE (value) == COMPLEX_CST)
1421 && TREE_OVERFLOW (value))
21ca8540 1422 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
07317e69 1423}
1424
1425/* The same as above but print an unconditional error. */
1426void
1427constant_expression_error (tree value)
b2806639 1428{
837e1122 1429 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
9421ebb9 1430 || TREE_CODE (value) == FIXED_CST
886cfd4f 1431 || TREE_CODE (value) == VECTOR_CST
837e1122 1432 || TREE_CODE (value) == COMPLEX_CST)
07317e69 1433 && TREE_OVERFLOW (value))
1434 error ("overflow in constant expression");
2a1736ed 1435}
1436
f170d67f 1437/* Print a warning if an expression had overflow in folding and its
1438 operands hadn't.
1439
2a1736ed 1440 Invoke this function on every expression that
1441 (1) appears in the source code, and
f170d67f 1442 (2) is a constant expression that overflowed, and
2a1736ed 1443 (3) is not already checked by convert_and_check;
f170d67f 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. */
2a1736ed 1447
1448void
e60a6f7b 1449overflow_warning (location_t loc, tree value)
2a1736ed 1450{
48d94ede 1451 if (c_inhibit_evaluation_warnings != 0)
1452 return;
f170d67f 1453
1454 switch (TREE_CODE (value))
886cfd4f 1455 {
f170d67f 1456 case INTEGER_CST:
e60a6f7b 1457 warning_at (loc, OPT_Woverflow, "integer overflow in expression");
f170d67f 1458 break;
48e1416a 1459
f170d67f 1460 case REAL_CST:
e60a6f7b 1461 warning_at (loc, OPT_Woverflow,
1462 "floating point overflow in expression");
f170d67f 1463 break;
48e1416a 1464
9421ebb9 1465 case FIXED_CST:
e60a6f7b 1466 warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
9421ebb9 1467 break;
1468
f170d67f 1469 case VECTOR_CST:
e60a6f7b 1470 warning_at (loc, OPT_Woverflow, "vector overflow in expression");
f170d67f 1471 break;
48e1416a 1472
f170d67f 1473 case COMPLEX_CST:
1474 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
e60a6f7b 1475 warning_at (loc, OPT_Woverflow,
1476 "complex integer overflow in expression");
f170d67f 1477 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
e60a6f7b 1478 warning_at (loc, OPT_Woverflow,
1479 "complex floating point overflow in expression");
f170d67f 1480 break;
1481
1482 default:
1483 break;
886cfd4f 1484 }
2a1736ed 1485}
1486
03033af4 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
9c20c4fc 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. */
b13d1547 1492void
9c20c4fc 1493warn_logical_operator (location_t location, enum tree_code code, tree type,
48e1416a 1494 enum tree_code code_left, tree op_left,
03033af4 1495 enum tree_code ARG_UNUSED (code_right), tree op_right)
b13d1547 1496{
9c20c4fc 1497 int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1498 int in0_p, in1_p, in_p;
1499 tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1500 bool strict_overflow_p = false;
1501
03033af4 1502 if (code != TRUTH_ANDIF_EXPR
1503 && code != TRUTH_AND_EXPR
1504 && code != TRUTH_ORIF_EXPR
1505 && code != TRUTH_OR_EXPR)
1506 return;
1507
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. */
1513 if (!truth_value_p (code_left)
1514 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1515 && !CONSTANT_CLASS_P (op_left)
1516 && !TREE_NO_WARNING (op_left)
1517 && TREE_CODE (op_right) == INTEGER_CST
1518 && !integer_zerop (op_right)
1519 && !integer_onep (op_right))
b13d1547 1520 {
9c20c4fc 1521 if (or_op)
03033af4 1522 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1523 " applied to non-boolean constant");
1524 else
1525 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1526 " applied to non-boolean constant");
1527 TREE_NO_WARNING (op_left) = true;
9c20c4fc 1528 return;
1529 }
1530
1531 /* We do not warn for constants because they are typical of macro
1532 expansions that test for features. */
1533 if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1534 return;
1535
1536 /* This warning only makes sense with logical operands. */
1537 if (!(truth_value_p (TREE_CODE (op_left))
1538 || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1539 || !(truth_value_p (TREE_CODE (op_right))
1540 || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1541 return;
1542
1543 lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1544 rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1545
1546 if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1547 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1548
1549 if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1550 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
48e1416a 1551
9c20c4fc 1552 /* If this is an OR operation, invert both sides; we will invert
1553 again at the end. */
1554 if (or_op)
1555 in0_p = !in0_p, in1_p = !in1_p;
48e1416a 1556
9c20c4fc 1557 /* If both expressions are the same, if we can merge the ranges, and we
0969aa9b 1558 can build the range test, return it or it inverted. */
1559 if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
9c20c4fc 1560 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1561 in1_p, low1, high1)
389dd41b 1562 && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1563 type, lhs, in_p, low, high)))
9c20c4fc 1564 {
1565 if (TREE_CODE (tem) != INTEGER_CST)
1566 return;
1567
1568 if (or_op)
1569 warning_at (location, OPT_Wlogical_op,
1570 "logical %<or%> "
1571 "of collectively exhaustive tests is always true");
1572 else
1573 warning_at (location, OPT_Wlogical_op,
1574 "logical %<and%> "
1575 "of mutually exclusive tests is always false");
b13d1547 1576 }
1577}
1578
1579
bcf22371 1580/* Print a warning about casts that might indicate violation
1581 of strict aliasing rules if -Wstrict-aliasing is used and
1e31ff37 1582 strict aliasing mode is in effect. OTYPE is the original
1583 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
bcf22371 1584
e6fa0ea6 1585bool
1e31ff37 1586strict_aliasing_warning (tree otype, tree type, tree expr)
bcf22371 1587{
45bb3afb 1588 /* Strip pointer conversion chains and get to the correct original type. */
1589 STRIP_NOPS (expr);
1590 otype = TREE_TYPE (expr);
1591
f06537f2 1592 if (!(flag_strict_aliasing
1593 && POINTER_TYPE_P (type)
1594 && POINTER_TYPE_P (otype)
1595 && !VOID_TYPE_P (TREE_TYPE (type)))
1596 /* If the type we are casting to is a ref-all pointer
1597 dereferencing it is always valid. */
1598 || TYPE_REF_CAN_ALIAS_ALL (type))
e6fa0ea6 1599 return false;
1600
1601 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
bcf22371 1602 && (DECL_P (TREE_OPERAND (expr, 0))
e6fa0ea6 1603 || handled_component_p (TREE_OPERAND (expr, 0))))
bcf22371 1604 {
1605 /* Casting the address of an object to non void pointer. Warn
1606 if the cast breaks type based aliasing. */
e6fa0ea6 1607 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1608 {
1609 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1610 "might break strict-aliasing rules");
1611 return true;
1612 }
bcf22371 1613 else
1614 {
48e1416a 1615 /* warn_strict_aliasing >= 3. This includes the default (3).
e6fa0ea6 1616 Only warn if the cast is dereferenced immediately. */
32c2fdea 1617 alias_set_type set1 =
e6fa0ea6 1618 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
32c2fdea 1619 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
bcf22371 1620
62d823d0 1621 if (set1 != set2 && set2 != 0
1622 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
e6fa0ea6 1623 {
1624 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1625 "pointer will break strict-aliasing rules");
1626 return true;
1627 }
1628 else if (warn_strict_aliasing == 2
879f881c 1629 && !alias_sets_must_conflict_p (set1, set2))
e6fa0ea6 1630 {
1631 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1632 "pointer might break strict-aliasing rules");
1633 return true;
1634 }
bcf22371 1635 }
1636 }
e6fa0ea6 1637 else
1638 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
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. */
32c2fdea 1644 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1645 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1646 if (!COMPLETE_TYPE_P (type)
879f881c 1647 || !alias_sets_must_conflict_p (set1, set2))
e6fa0ea6 1648 {
1649 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1650 "pointer might break strict-aliasing rules");
1651 return true;
1652 }
1653 }
1654
1655 return false;
bcf22371 1656}
1657
3f08e399 1658/* Warn for unlikely, improbable, or stupid DECL declarations
1659 of `main'. */
1660
1661void
1662check_main_parameter_types (tree decl)
1663{
1664 tree args;
1665 int argct = 0;
1666
1667 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1668 args = TREE_CHAIN (args))
1669 {
1670 tree type = args ? TREE_VALUE (args) : 0;
1671
7accad14 1672 if (type == void_type_node || type == error_mark_node )
3f08e399 1673 break;
1674
1675 ++argct;
1676 switch (argct)
1677 {
1678 case 1:
1679 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
48e1416a 1680 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
23efcc02 1681 decl);
3f08e399 1682 break;
1683
1684 case 2:
1685 if (TREE_CODE (type) != POINTER_TYPE
1686 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1687 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1688 != char_type_node))
21ca8540 1689 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
23efcc02 1690 decl);
3f08e399 1691 break;
1692
1693 case 3:
1694 if (TREE_CODE (type) != POINTER_TYPE
1695 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1696 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1697 != char_type_node))
21ca8540 1698 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
23efcc02 1699 "%<char **%>", decl);
3f08e399 1700 break;
1701 }
1702 }
1703
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. */
1707 if (argct > 0 && (argct < 2 || argct > 3))
21ca8540 1708 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
3f08e399 1709}
1710
ed7c4e62 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. */
1714bool
1715vector_targets_convertible_p (const_tree t1, const_tree t2)
1716{
1717 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
8d125f7d 1718 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
ed7c4e62 1719 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1720 return true;
1721
1722 return false;
1723}
1724
546c4794 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. */
1730bool
9f627b1a 1731vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
8b4b9810 1732{
546c4794 1733 static bool emitted_lax_note = false;
ae6db8ab 1734 bool convertible_lax;
1735
8d125f7d 1736 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
ae6db8ab 1737 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1738 return true;
1739
1740 convertible_lax =
1741 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1742 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1743 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1744 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1745 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
546c4794 1746
1747 if (!convertible_lax || flag_lax_vector_conversions)
1748 return convertible_lax;
1749
1750 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
29f51994 1751 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
546c4794 1752 return true;
1753
1754 if (emit_lax_note && !emitted_lax_note)
1755 {
1756 emitted_lax_note = true;
5bcc316e 1757 inform (input_location, "use -flax-vector-conversions to permit "
546c4794 1758 "conversions between vectors with differing "
1759 "element types or numbers of subparts");
1760 }
1761
1762 return false;
8b4b9810 1763}
1764
2561cea2 1765/* This is a helper function of build_binary_op.
1766
1767 For certain operations if both args were extended from the same
1768 smaller type, do the arithmetic in that type and then extend.
1769
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
48e1416a 1775 but calculated in (unsigned short) it would be (unsigned short)-1.
2561cea2 1776*/
1777tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1778{
1779 int unsigned0, unsigned1;
1780 tree arg0, arg1;
1781 int uns;
1782 tree type;
1783
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
48e1416a 1790
2561cea2 1791 (long long int) (unsigned int) signed_char
1792
1793 which get_narrower would narrow down to
48e1416a 1794
2561cea2 1795 (unsigned int) signed char
48e1416a 1796
2561cea2 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. */
1800 op0 = convert (result_type, op0);
1801 op1 = convert (result_type, op1);
1802
1803 arg0 = get_narrower (op0, &unsigned0);
1804 arg1 = get_narrower (op1, &unsigned1);
1805
1806 /* UNS is 1 if the operation to be done is an unsigned one. */
1807 uns = TYPE_UNSIGNED (result_type);
1808
1809 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1810 but it *requires* conversion to FINAL_TYPE. */
48e1416a 1811
2561cea2 1812 if ((TYPE_PRECISION (TREE_TYPE (op0))
1813 == TYPE_PRECISION (TREE_TYPE (arg0)))
1814 && TREE_TYPE (op0) != result_type)
1815 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1816 if ((TYPE_PRECISION (TREE_TYPE (op1))
1817 == TYPE_PRECISION (TREE_TYPE (arg1)))
1818 && TREE_TYPE (op1) != result_type)
1819 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
48e1416a 1820
2561cea2 1821 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
48e1416a 1822
2561cea2 1823 /* For bitwise operations, signedness of nominal type
1824 does not matter. Consider only how operands were extended. */
1825 if (bitwise)
1826 uns = unsigned0;
48e1416a 1827
2561cea2 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. */
48e1416a 1831
2561cea2 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. */
1835 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1836 < TYPE_PRECISION (result_type))
1837 && (TYPE_PRECISION (TREE_TYPE (arg1))
1838 == TYPE_PRECISION (TREE_TYPE (arg0)))
1839 && unsigned0 == unsigned1
1840 && (unsigned0 || !uns))
1841 return c_common_signed_or_unsigned_type
1842 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1843
1844 else if (TREE_CODE (arg0) == INTEGER_CST
1845 && (unsigned1 || !uns)
1846 && (TYPE_PRECISION (TREE_TYPE (arg1))
1847 < TYPE_PRECISION (result_type))
1848 && (type
1849 = c_common_signed_or_unsigned_type (unsigned1,
1850 TREE_TYPE (arg1)))
1851 && !POINTER_TYPE_P (type)
1852 && int_fits_type_p (arg0, type))
1853 return type;
1854
1855 else if (TREE_CODE (arg1) == INTEGER_CST
1856 && (unsigned0 || !uns)
1857 && (TYPE_PRECISION (TREE_TYPE (arg0))
1858 < TYPE_PRECISION (result_type))
1859 && (type
1860 = c_common_signed_or_unsigned_type (unsigned0,
1861 TREE_TYPE (arg0)))
1862 && !POINTER_TYPE_P (type)
1863 && int_fits_type_p (arg1, type))
1864 return type;
1865
1866 return result_type;
1867}
1868
d31d55f0 1869/* Warns if the conversion of EXPR to TYPE may alter a value.
59dd8856 1870 This is a helper function for warnings_for_convert_and_check. */
d31d55f0 1871
1872static void
1873conversion_warning (tree type, tree expr)
1874{
1875 bool give_warning = false;
1876
5b16c152 1877 int i;
1878 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
27259707 1879 tree expr_type = TREE_TYPE (expr);
8637f1db 1880 location_t loc = EXPR_LOC_OR_HERE (expr);
d31d55f0 1881
7ee0d227 1882 if (!warn_conversion && !warn_sign_conversion)
1883 return;
1884
5b16c152 1885 /* If any operand is artificial, then this expression was generated
1886 by the compiler and we do not warn. */
1887 for (i = 0; i < expr_num_operands; i++)
1888 {
1889 tree op = TREE_OPERAND (expr, i);
7bdc5064 1890 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
5b16c152 1891 return;
1892 }
1893
27259707 1894 switch (TREE_CODE (expr))
d31d55f0 1895 {
27259707 1896 case EQ_EXPR:
1897 case NE_EXPR:
1898 case LE_EXPR:
1899 case GE_EXPR:
1900 case LT_EXPR:
1901 case GT_EXPR:
1902 case TRUTH_ANDIF_EXPR:
1903 case TRUTH_ORIF_EXPR:
1904 case TRUTH_AND_EXPR:
1905 case TRUTH_OR_EXPR:
1906 case TRUTH_XOR_EXPR:
1907 case TRUTH_NOT_EXPR:
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. */
48e1416a 1911 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
200dd99c 1912 warning_at (loc, OPT_Wconversion,
1913 "conversion to %qT from boolean expression", type);
27259707 1914 return;
1915
1916 case REAL_CST:
1917 case INTEGER_CST:
1918
d31d55f0 1919 /* Warn for real constant that is not an exact integer converted
1920 to integer type. */
27259707 1921 if (TREE_CODE (expr_type) == REAL_TYPE
d31d55f0 1922 && TREE_CODE (type) == INTEGER_TYPE)
1923 {
27259707 1924 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
d31d55f0 1925 give_warning = true;
1926 }
da1fb07b 1927 /* Warn for an integer constant that does not fit into integer type. */
27259707 1928 else if (TREE_CODE (expr_type) == INTEGER_TYPE
d31d55f0 1929 && TREE_CODE (type) == INTEGER_TYPE
da1fb07b 1930 && !int_fits_type_p (expr, type))
1931 {
48e1416a 1932 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
27259707 1933 && tree_int_cst_sgn (expr) < 0)
200dd99c 1934 warning_at (loc, OPT_Wsign_conversion, "negative integer"
1935 " implicitly converted to unsigned type");
27259707 1936 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
200dd99c 1937 warning_at (loc, OPT_Wsign_conversion, "conversion of unsigned"
1938 " constant value to negative integer");
7ee0d227 1939 else
1940 give_warning = true;
da1fb07b 1941 }
d31d55f0 1942 else if (TREE_CODE (type) == REAL_TYPE)
1943 {
1944 /* Warn for an integer constant that does not fit into real type. */
27259707 1945 if (TREE_CODE (expr_type) == INTEGER_TYPE)
d31d55f0 1946 {
1947 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1948 if (!exact_real_truncate (TYPE_MODE (type), &a))
1949 give_warning = true;
1950 }
1951 /* Warn for a real constant that does not fit into a smaller
1952 real type. */
27259707 1953 else if (TREE_CODE (expr_type) == REAL_TYPE
1954 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
d31d55f0 1955 {
1956 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1957 if (!exact_real_truncate (TYPE_MODE (type), &a))
1958 give_warning = true;
1959 }
1960 }
1961
1962 if (give_warning)
200dd99c 1963 warning_at (loc, OPT_Wconversion,
1964 "conversion to %qT alters %qT constant value",
1965 type, expr_type);
27259707 1966
1967 return;
1968
1969 case COND_EXPR:
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. */
1974 tree op1 = TREE_OPERAND (expr, 1);
1975 tree op2 = TREE_OPERAND (expr, 2);
1976
48e1416a 1977 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
27259707 1978 || TREE_CODE (op1) == COND_EXPR)
1979 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1980 || TREE_CODE (op2) == COND_EXPR))
1981 {
1982 conversion_warning (type, op1);
1983 conversion_warning (type, op2);
1984 return;
1985 }
1986 /* Fall through. */
1987 }
1988
1989 default: /* 'expr' is not a constant. */
2561cea2 1990
d31d55f0 1991 /* Warn for real types converted to integer types. */
2561cea2 1992 if (TREE_CODE (expr_type) == REAL_TYPE
d31d55f0 1993 && TREE_CODE (type) == INTEGER_TYPE)
1994 give_warning = true;
1995
2561cea2 1996 else if (TREE_CODE (expr_type) == INTEGER_TYPE
d31d55f0 1997 && TREE_CODE (type) == INTEGER_TYPE)
1998 {
69609004 1999 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
f9d856a4 2000 expr = get_unwidened (expr, 0);
2561cea2 2001 expr_type = TREE_TYPE (expr);
69609004 2002
2561cea2 2003 /* Don't warn for short y; short x = ((int)y & 0xff); */
48e1416a 2004 if (TREE_CODE (expr) == BIT_AND_EXPR
2005 || TREE_CODE (expr) == BIT_IOR_EXPR
2561cea2 2006 || TREE_CODE (expr) == BIT_XOR_EXPR)
2007 {
27259707 2008 /* If both args were extended from a shortest type,
2009 use that type if that is safe. */
48e1416a 2010 expr_type = shorten_binary_op (expr_type,
2011 TREE_OPERAND (expr, 0),
2012 TREE_OPERAND (expr, 1),
2561cea2 2013 /* bitwise */1);
2014
2561cea2 2015 if (TREE_CODE (expr) == BIT_AND_EXPR)
2016 {
2017 tree op0 = TREE_OPERAND (expr, 0);
2018 tree op1 = TREE_OPERAND (expr, 1);
30de145b 2019 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2020 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2021
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. */
2561cea2 2025 if ((TREE_CODE (op0) == INTEGER_CST
2026 && int_fits_type_p (op0, c_common_signed_type (type))
2027 && int_fits_type_p (op0, c_common_unsigned_type (type)))
2028 || (TREE_CODE (op1) == INTEGER_CST
27259707 2029 && int_fits_type_p (op1, c_common_signed_type (type))
48e1416a 2030 && int_fits_type_p (op1,
27259707 2031 c_common_unsigned_type (type))))
2561cea2 2032 return;
30de145b 2033 /* If constant is unsigned and fits in the target
2034 type, then the result will also fit. */
2035 else if ((TREE_CODE (op0) == INTEGER_CST
48e1416a 2036 && unsigned0
30de145b 2037 && int_fits_type_p (op0, type))
2038 || (TREE_CODE (op1) == INTEGER_CST
2039 && unsigned1
2040 && int_fits_type_p (op1, type)))
2041 return;
2561cea2 2042 }
2043 }
d31d55f0 2044 /* Warn for integer types converted to smaller integer types. */
48e1416a 2045 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
7ee0d227 2046 give_warning = true;
2047
2048 /* When they are the same width but different signedness,
2049 then the value may change. */
27259707 2050 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2561cea2 2051 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
7ee0d227 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. */
2561cea2 2055 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
200dd99c 2056 warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT "
2057 "may change the sign of the result",
2058 type, expr_type);
d31d55f0 2059 }
2060
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. */
2561cea2 2064 else if (TREE_CODE (expr_type) == INTEGER_TYPE
d31d55f0 2065 && TREE_CODE (type) == REAL_TYPE)
2066 {
4c2cfa81 2067 tree type_low_bound, type_high_bound;
2068 REAL_VALUE_TYPE real_low_bound, real_high_bound;
2069
2070 /* Don't warn about char y = 0xff; float x = (int) y; */
2071 expr = get_unwidened (expr, 0);
2072 expr_type = TREE_TYPE (expr);
2073
2074 type_low_bound = TYPE_MIN_VALUE (expr_type);
2075 type_high_bound = TYPE_MAX_VALUE (expr_type);
2076 real_low_bound = real_value_from_int_cst (0, type_low_bound);
2077 real_high_bound = real_value_from_int_cst (0, type_high_bound);
d31d55f0 2078
2079 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2080 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2081 give_warning = true;
2082 }
2083
2084 /* Warn for real types converted to smaller real types. */
2561cea2 2085 else if (TREE_CODE (expr_type) == REAL_TYPE
d31d55f0 2086 && TREE_CODE (type) == REAL_TYPE
27259707 2087 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
d31d55f0 2088 give_warning = true;
2089
2090
2091 if (give_warning)
200dd99c 2092 warning_at (loc, OPT_Wconversion,
2093 "conversion to %qT from %qT may alter its value",
2094 type, expr_type);
d31d55f0 2095 }
2096}
2097
59dd8856 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. */
2a1736ed 2101
59dd8856 2102void
2103warnings_for_convert_and_check (tree type, tree expr, tree result)
2a1736ed 2104{
da1fb07b 2105 if (TREE_CODE (expr) == INTEGER_CST
2106 && (TREE_CODE (type) == INTEGER_TYPE
2107 || TREE_CODE (type) == ENUMERAL_TYPE)
2108 && !int_fits_type_p (expr, type))
2109 {
d31d55f0 2110 /* Do not diagnose overflow in a constant expression merely
2111 because a conversion overflowed. */
da1fb07b 2112 if (TREE_OVERFLOW (result))
eddad94a 2113 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2114
da1fb07b 2115 if (TYPE_UNSIGNED (type))
d31d55f0 2116 {
da1fb07b 2117 /* This detects cases like converting -129 or 256 to
2118 unsigned char. */
2119 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2120 warning (OPT_Woverflow,
2121 "large integer implicitly truncated to unsigned type");
7ee0d227 2122 else
da1fb07b 2123 conversion_warning (type, expr);
2124 }
48e1416a 2125 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
e0913805 2126 warning (OPT_Woverflow,
2127 "overflow in implicit constant conversion");
2128 /* No warning for converting 0x80000000 to int. */
2129 else if (pedantic
2130 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2131 || TYPE_PRECISION (TREE_TYPE (expr))
2132 != TYPE_PRECISION (type)))
2133 warning (OPT_Woverflow,
2134 "overflow in implicit constant conversion");
2135
7ee0d227 2136 else
e0913805 2137 conversion_warning (type, expr);
2a1736ed 2138 }
9421ebb9 2139 else if ((TREE_CODE (result) == INTEGER_CST
2140 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
da1fb07b 2141 warning (OPT_Woverflow,
2142 "overflow in implicit constant conversion");
7ee0d227 2143 else
da1fb07b 2144 conversion_warning (type, expr);
59dd8856 2145}
2146
2147
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. */
2151
2152tree
2153convert_and_check (tree type, tree expr)
2154{
2155 tree result;
c6418a4e 2156 tree expr_for_warning;
2157
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. */
2161 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2162 {
2163 tree orig_type = TREE_TYPE (expr);
2164 expr = TREE_OPERAND (expr, 0);
2165 expr_for_warning = convert (orig_type, expr);
2166 if (orig_type == type)
2167 return expr_for_warning;
2168 }
2169 else
2170 expr_for_warning = expr;
59dd8856 2171
2172 if (TREE_TYPE (expr) == type)
2173 return expr;
48e1416a 2174
59dd8856 2175 result = convert (type, expr);
2176
48d94ede 2177 if (c_inhibit_evaluation_warnings == 0
2178 && !TREE_OVERFLOW_P (expr)
2179 && result != error_mark_node)
c6418a4e 2180 warnings_for_convert_and_check (type, expr_for_warning, result);
59dd8856 2181
da1fb07b 2182 return result;
b2806639 2183}
2184\f
4e91a871 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. */
2188struct tlist
2189{
2190 struct tlist *next;
2191 tree expr, writer;
2192};
2193
2194/* Used to implement a cache the results of a call to verify_tree. We only
2195 use this for SAVE_EXPRs. */
2196struct tlist_cache
2197{
2198 struct tlist_cache *next;
2199 struct tlist *cache_before_sp;
2200 struct tlist *cache_after_sp;
2201 tree expr;
481c6ce6 2202};
2203
4e91a871 2204/* Obstack to use when allocating tlist structures, and corresponding
2205 firstobj. */
2206static struct obstack tlist_obstack;
2207static char *tlist_firstobj = 0;
2208
2209/* Keep track of the identifiers we've warned about, so we can avoid duplicate
2210 warnings. */
2211static struct tlist *warned_ids;
2212/* SAVE_EXPRs need special treatment. We process them only once and then
2213 cache the results. */
2214static struct tlist_cache *save_expr_cache;
2215
1cae46be 2216static void add_tlist (struct tlist **, struct tlist *, tree, int);
2217static void merge_tlist (struct tlist **, struct tlist *, int);
2218static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2219static int warning_candidate_p (tree);
79973b57 2220static bool candidate_equal_p (const_tree, const_tree);
1cae46be 2221static void warn_for_collisions (struct tlist *);
2222static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2223static struct tlist *new_tlist (struct tlist *, tree, tree);
481c6ce6 2224
4e91a871 2225/* Create a new struct tlist and fill in its fields. */
2226static struct tlist *
1cae46be 2227new_tlist (struct tlist *next, tree t, tree writer)
4e91a871 2228{
2229 struct tlist *l;
9318f22c 2230 l = XOBNEW (&tlist_obstack, struct tlist);
4e91a871 2231 l->next = next;
2232 l->expr = t;
2233 l->writer = writer;
2234 return l;
2235}
2236
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. */
2239
2240static void
1cae46be 2241add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
4e91a871 2242{
2243 while (add)
2244 {
2245 struct tlist *next = add->next;
84166705 2246 if (!copy)
4e91a871 2247 add->next = *to;
79973b57 2248 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
4e91a871 2249 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2250 add = next;
2251 }
2252}
2253
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. */
481c6ce6 2259
2260static void
1cae46be 2261merge_tlist (struct tlist **to, struct tlist *add, int copy)
4e91a871 2262{
2263 struct tlist **end = to;
2264
2265 while (*end)
2266 end = &(*end)->next;
2267
2268 while (add)
2269 {
2270 int found = 0;
2271 struct tlist *tmp2;
2272 struct tlist *next = add->next;
2273
2274 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
79973b57 2275 if (candidate_equal_p (tmp2->expr, add->expr))
4e91a871 2276 {
2277 found = 1;
84166705 2278 if (!tmp2->writer)
4e91a871 2279 tmp2->writer = add->writer;
2280 }
84166705 2281 if (!found)
4e91a871 2282 {
2283 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2284 end = &(*end)->next;
2285 *end = 0;
2286 }
2287 add = next;
2288 }
2289}
2290
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. */
2294
2295static void
1cae46be 2296warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2297 int only_writes)
4e91a871 2298{
2299 struct tlist *tmp;
2300
2301 /* Avoid duplicate warnings. */
2302 for (tmp = warned_ids; tmp; tmp = tmp->next)
79973b57 2303 if (candidate_equal_p (tmp->expr, written))
4e91a871 2304 return;
2305
2306 while (list)
2307 {
79973b57 2308 if (candidate_equal_p (list->expr, written)
2309 && !candidate_equal_p (list->writer, writer)
2310 && (!only_writes || list->writer))
4e91a871 2311 {
2312 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
8637f1db 2313 warning_at (EXPR_LOC_OR_HERE (writer),
6513b50d 2314 OPT_Wsequence_point, "operation on %qE may be undefined",
2315 list->expr);
4e91a871 2316 }
2317 list = list->next;
2318 }
2319}
2320
2321/* Given a list LIST of references to variables, find whether any of these
2322 can cause conflicts due to missing sequence points. */
2323
2324static void
1cae46be 2325warn_for_collisions (struct tlist *list)
4e91a871 2326{
2327 struct tlist *tmp;
1cae46be 2328
4e91a871 2329 for (tmp = list; tmp; tmp = tmp->next)
2330 {
2331 if (tmp->writer)
2332 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2333 }
2334}
2335
734c98be 2336/* Return nonzero if X is a tree that can be verified by the sequence point
4e91a871 2337 warnings. */
2338static int
1cae46be 2339warning_candidate_p (tree x)
481c6ce6 2340{
6ef8d12f 2341 if (DECL_P (x) && DECL_ARTIFICIAL (x))
2342 return 0;
2343
2344 /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
79973b57 2345 (lvalue_p) crash on TRY/CATCH. */
6ef8d12f 2346 if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x)))
2347 return 0;
2348
2349 if (!lvalue_p (x))
2350 return 0;
2351
2352 /* No point to track non-const calls, they will never satisfy
2353 operand_equal_p. */
2354 if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0)
2355 return 0;
2356
2357 if (TREE_CODE (x) == STRING_CST)
2358 return 0;
2359
2360 return 1;
79973b57 2361}
2362
2363/* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2364static bool
2365candidate_equal_p (const_tree x, const_tree y)
2366{
2367 return (x == y) || (x && y && operand_equal_p (x, y, 0));
4e91a871 2368}
481c6ce6 2369
4e91a871 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.
2379
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.
2386
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. */
481c6ce6 2394
4e91a871 2395static void
1cae46be 2396verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2397 tree writer)
4e91a871 2398{
2399 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2400 enum tree_code code;
ce45a448 2401 enum tree_code_class cl;
481c6ce6 2402
e5b75768 2403 /* X may be NULL if it is the operand of an empty statement expression
2404 ({ }). */
2405 if (x == NULL)
2406 return;
2407
4e91a871 2408 restart:
2409 code = TREE_CODE (x);
e916c70c 2410 cl = TREE_CODE_CLASS (code);
481c6ce6 2411
4e91a871 2412 if (warning_candidate_p (x))
79973b57 2413 *pno_sp = new_tlist (*pno_sp, x, writer);
4e91a871 2414
2415 switch (code)
2416 {
67b28e3e 2417 case CONSTRUCTOR:
2418 return;
2419
4e91a871 2420 case COMPOUND_EXPR:
2421 case TRUTH_ANDIF_EXPR:
2422 case TRUTH_ORIF_EXPR:
2423 tmp_before = tmp_nosp = tmp_list3 = 0;
2424 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2425 warn_for_collisions (tmp_nosp);
2426 merge_tlist (pbefore_sp, tmp_before, 0);
2427 merge_tlist (pbefore_sp, tmp_nosp, 0);
2428 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2429 merge_tlist (pbefore_sp, tmp_list3, 0);
2430 return;
2431
2432 case COND_EXPR:
2433 tmp_before = tmp_list2 = 0;
2434 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2435 warn_for_collisions (tmp_list2);
2436 merge_tlist (pbefore_sp, tmp_before, 0);
2437 merge_tlist (pbefore_sp, tmp_list2, 1);
2438
2439 tmp_list3 = tmp_nosp = 0;
2440 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2441 warn_for_collisions (tmp_nosp);
2442 merge_tlist (pbefore_sp, tmp_list3, 0);
2443
2444 tmp_list3 = tmp_list2 = 0;
2445 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2446 warn_for_collisions (tmp_list2);
2447 merge_tlist (pbefore_sp, tmp_list3, 0);
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++). */
2450 merge_tlist (&tmp_nosp, tmp_list2, 0);
2451 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2452 return;
2453
481c6ce6 2454 case PREDECREMENT_EXPR:
2455 case PREINCREMENT_EXPR:
2456 case POSTDECREMENT_EXPR:
2457 case POSTINCREMENT_EXPR:
4e91a871 2458 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2459 return;
2460
2461 case MODIFY_EXPR:
2462 tmp_before = tmp_nosp = tmp_list3 = 0;
2463 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2464 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
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. */
2473 add_tlist (&tmp_before, tmp_list3, x, 1);
2474 warn_for_collisions (tmp_before);
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. */
2479 add_tlist (pno_sp, tmp_list3, x, 0);
2480 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2481
2482 merge_tlist (pbefore_sp, tmp_before, 0);
2483 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2484 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2485 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2486 return;
481c6ce6 2487
2488 case CALL_EXPR:
4e91a871 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. */
c2f47e15 2492 {
2493 call_expr_arg_iterator iter;
2494 tree arg;
48e1416a 2495 tmp_before = tmp_nosp = 0;
c2f47e15 2496 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2497 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2498 {
2499 tmp_list2 = tmp_list3 = 0;
2500 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2501 merge_tlist (&tmp_list3, tmp_list2, 0);
2502 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2503 }
2504 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2505 warn_for_collisions (tmp_before);
2506 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2507 return;
2508 }
481c6ce6 2509
2510 case TREE_LIST:
2511 /* Scan all the list, e.g. indices of multi dimensional array. */
2512 while (x)
2513 {
4e91a871 2514 tmp_before = tmp_nosp = 0;
2515 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2516 merge_tlist (&tmp_nosp, tmp_before, 0);
2517 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
481c6ce6 2518 x = TREE_CHAIN (x);
2519 }
4e91a871 2520 return;
481c6ce6 2521
4e91a871 2522 case SAVE_EXPR:
2523 {
2524 struct tlist_cache *t;
2525 for (t = save_expr_cache; t; t = t->next)
79973b57 2526 if (candidate_equal_p (t->expr, x))
4e91a871 2527 break;
481c6ce6 2528
84166705 2529 if (!t)
481c6ce6 2530 {
9318f22c 2531 t = XOBNEW (&tlist_obstack, struct tlist_cache);
4e91a871 2532 t->next = save_expr_cache;
2533 t->expr = x;
2534 save_expr_cache = t;
2535
2536 tmp_before = tmp_nosp = 0;
2537 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2538 warn_for_collisions (tmp_nosp);
2539
2540 tmp_list3 = 0;
2541 while (tmp_nosp)
2542 {
2543 struct tlist *t = tmp_nosp;
2544 tmp_nosp = t->next;
2545 merge_tlist (&tmp_list3, t, 0);
2546 }
2547 t->cache_before_sp = tmp_before;
2548 t->cache_after_sp = tmp_list3;
481c6ce6 2549 }
4e91a871 2550 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2551 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2552 return;
2553 }
481c6ce6 2554
012916cb 2555 case ADDR_EXPR:
2556 x = TREE_OPERAND (x, 0);
2557 if (DECL_P (x))
2558 return;
2559 writer = 0;
2560 goto restart;
2561
ce45a448 2562 default:
2563 /* For other expressions, simply recurse on their operands.
a0c938f0 2564 Manual tail recursion for unary expressions.
ce45a448 2565 Other non-expressions need not be processed. */
2566 if (cl == tcc_unary)
2567 {
ce45a448 2568 x = TREE_OPERAND (x, 0);
2569 writer = 0;
2570 goto restart;
2571 }
2572 else if (IS_EXPR_CODE_CLASS (cl))
2573 {
2574 int lp;
c2f47e15 2575 int max = TREE_OPERAND_LENGTH (x);
ce45a448 2576 for (lp = 0; lp < max; lp++)
2577 {
2578 tmp_before = tmp_nosp = 0;
2579 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2580 merge_tlist (&tmp_nosp, tmp_before, 0);
2581 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2582 }
2583 }
2584 return;
481c6ce6 2585 }
481c6ce6 2586}
2587
974e2c0c 2588/* Try to warn for undefined behavior in EXPR due to missing sequence
481c6ce6 2589 points. */
2590
4b987fac 2591DEBUG_FUNCTION void
1cae46be 2592verify_sequence_points (tree expr)
481c6ce6 2593{
4e91a871 2594 struct tlist *before_sp = 0, *after_sp = 0;
481c6ce6 2595
4e91a871 2596 warned_ids = 0;
2597 save_expr_cache = 0;
2598 if (tlist_firstobj == 0)
481c6ce6 2599 {
4e91a871 2600 gcc_obstack_init (&tlist_obstack);
4fd61bc6 2601 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
481c6ce6 2602 }
2603
4e91a871 2604 verify_tree (expr, &before_sp, &after_sp, 0);
2605 warn_for_collisions (after_sp);
2606 obstack_free (&tlist_obstack, tlist_firstobj);
481c6ce6 2607}
b0fc3e72 2608\f
2609/* Validate the expression after `case' and apply default promotions. */
2610
2ca392fd 2611static tree
1cae46be 2612check_case_value (tree value)
b0fc3e72 2613{
2614 if (value == NULL_TREE)
2615 return value;
2616
b96dc121 2617 if (TREE_CODE (value) == INTEGER_CST)
2618 /* Promote char or short to int. */
2619 value = perform_integral_promotions (value);
2620 else if (value != error_mark_node)
b0fc3e72 2621 {
2622 error ("case label does not reduce to an integer constant");
2623 value = error_mark_node;
2624 }
b0fc3e72 2625
6433f1c2 2626 constant_expression_warning (value);
2627
b0fc3e72 2628 return value;
2629}
2630\f
2ca392fd 2631/* See if the case values LOW and HIGH are in the range of the original
5c9dae64 2632 type (i.e. before the default conversion to int) of the switch testing
2ca392fd 2633 expression.
2634 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
91275768 2635 the type before promoting it. CASE_LOW_P is a pointer to the lower
2ca392fd 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
5c9dae64 2639 CASE_LOW_P (i.e. the default case).
442e3cb9 2640 Returns true if the case label is in range of ORIG_TYPE (saturated or
2ca392fd 2641 untouched) or false if the label is out of range. */
2642
2643static bool
2644check_case_bounds (tree type, tree orig_type,
2645 tree *case_low_p, tree *case_high_p)
2646{
2647 tree min_value, max_value;
2648 tree case_low = *case_low_p;
2649 tree case_high = case_high_p ? *case_high_p : case_low;
2650
2651 /* If there was a problem with the original type, do nothing. */
2652 if (orig_type == error_mark_node)
2653 return true;
2654
2655 min_value = TYPE_MIN_VALUE (orig_type);
2656 max_value = TYPE_MAX_VALUE (orig_type);
2657
2658 /* Case label is less than minimum for type. */
2659 if (tree_int_cst_compare (case_low, min_value) < 0
2660 && tree_int_cst_compare (case_high, min_value) < 0)
2661 {
c3ceba8e 2662 warning (0, "case label value is less than minimum value for type");
2ca392fd 2663 return false;
2664 }
b27ac6b5 2665
2ca392fd 2666 /* Case value is greater than maximum for type. */
2667 if (tree_int_cst_compare (case_low, max_value) > 0
2668 && tree_int_cst_compare (case_high, max_value) > 0)
2669 {
c3ceba8e 2670 warning (0, "case label value exceeds maximum value for type");
2ca392fd 2671 return false;
2672 }
2673
2674 /* Saturate lower case label value to minimum. */
2675 if (tree_int_cst_compare (case_high, min_value) >= 0
2676 && tree_int_cst_compare (case_low, min_value) < 0)
2677 {
c3ceba8e 2678 warning (0, "lower value in case label range"
2ca392fd 2679 " less than minimum value for type");
2680 case_low = min_value;
2681 }
b27ac6b5 2682
2ca392fd 2683 /* Saturate upper case label value to maximum. */
2684 if (tree_int_cst_compare (case_low, max_value) <= 0
2685 && tree_int_cst_compare (case_high, max_value) > 0)
2686 {
c3ceba8e 2687 warning (0, "upper value in case label range"
2ca392fd 2688 " exceeds maximum value for type");
2689 case_high = max_value;
2690 }
2691
2692 if (*case_low_p != case_low)
2693 *case_low_p = convert (type, case_low);
2694 if (case_high_p && *case_high_p != case_high)
2695 *case_high_p = convert (type, case_high);
2696
2697 return true;
2698}
2699\f
b0fc3e72 2700/* Return an integer type with BITS bits of precision,
2701 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2702
2703tree
1cae46be 2704c_common_type_for_size (unsigned int bits, int unsignedp)
b0fc3e72 2705{
46375237 2706 if (bits == TYPE_PRECISION (integer_type_node))
2707 return unsignedp ? unsigned_type_node : integer_type_node;
2708
bacde65a 2709 if (bits == TYPE_PRECISION (signed_char_type_node))
b0fc3e72 2710 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2711
bacde65a 2712 if (bits == TYPE_PRECISION (short_integer_type_node))
b0fc3e72 2713 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2714
bacde65a 2715 if (bits == TYPE_PRECISION (long_integer_type_node))
b0fc3e72 2716 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2717
bacde65a 2718 if (bits == TYPE_PRECISION (long_long_integer_type_node))
b0fc3e72 2719 return (unsignedp ? long_long_unsigned_type_node
2720 : long_long_integer_type_node);
2721
6388cfe2 2722 if (int128_integer_type_node
2723 && bits == TYPE_PRECISION (int128_integer_type_node))
2724 return (unsignedp ? int128_unsigned_type_node
2725 : int128_integer_type_node);
2726
f57fa2ea 2727 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2728 return (unsignedp ? widest_unsigned_literal_type_node
2729 : widest_integer_literal_type_node);
2730
bacde65a 2731 if (bits <= TYPE_PRECISION (intQI_type_node))
2732 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2733
2734 if (bits <= TYPE_PRECISION (intHI_type_node))
2735 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2736
2737 if (bits <= TYPE_PRECISION (intSI_type_node))
2738 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2739
2740 if (bits <= TYPE_PRECISION (intDI_type_node))
2741 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2742
b0fc3e72 2743 return 0;
2744}
2745
9421ebb9 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. */
2749
2750tree
2751c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2752 int unsignedp, int satp)
2753{
2754 enum machine_mode mode;
2755 if (ibit == 0)
2756 mode = unsignedp ? UQQmode : QQmode;
2757 else
2758 mode = unsignedp ? UHAmode : HAmode;
2759
2760 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2761 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2762 break;
2763
2764 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2765 {
2766 sorry ("GCC cannot support operators with integer types and "
2767 "fixed-point types that have too many integral and "
2768 "fractional bits together");
2769 return 0;
2770 }
2771
2772 return c_common_type_for_mode (mode, satp);
2773}
2774
5b247e9f 2775/* Used for communication between c_common_type_for_mode and
2776 c_register_builtin_type. */
2777static GTY(()) tree registered_builtin_types;
2778
b0fc3e72 2779/* Return a data type that has machine mode MODE.
2780 If the mode is an integer,
9421ebb9 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. */
b0fc3e72 2784
2785tree
1cae46be 2786c_common_type_for_mode (enum machine_mode mode, int unsignedp)
b0fc3e72 2787{
5b247e9f 2788 tree t;
2789
46375237 2790 if (mode == TYPE_MODE (integer_type_node))
2791 return unsignedp ? unsigned_type_node : integer_type_node;
2792
b0fc3e72 2793 if (mode == TYPE_MODE (signed_char_type_node))
2794 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2795
2796 if (mode == TYPE_MODE (short_integer_type_node))
2797 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2798
b0fc3e72 2799 if (mode == TYPE_MODE (long_integer_type_node))
2800 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2801
2802 if (mode == TYPE_MODE (long_long_integer_type_node))
2803 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2804
6388cfe2 2805 if (int128_integer_type_node
2806 && mode == TYPE_MODE (int128_integer_type_node))
2807 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2808
f57fa2ea 2809 if (mode == TYPE_MODE (widest_integer_literal_type_node))
44e9fa65 2810 return unsignedp ? widest_unsigned_literal_type_node
4ee9c684 2811 : widest_integer_literal_type_node;
f57fa2ea 2812
88ae7f04 2813 if (mode == QImode)
bacde65a 2814 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2815
88ae7f04 2816 if (mode == HImode)
bacde65a 2817 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2818
88ae7f04 2819 if (mode == SImode)
bacde65a 2820 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2821
88ae7f04 2822 if (mode == DImode)
bacde65a 2823 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2824
cc1cc1c7 2825#if HOST_BITS_PER_WIDE_INT >= 64
6274009c 2826 if (mode == TYPE_MODE (intTI_type_node))
2827 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
cc1cc1c7 2828#endif
6274009c 2829
b0fc3e72 2830 if (mode == TYPE_MODE (float_type_node))
2831 return float_type_node;
2832
2833 if (mode == TYPE_MODE (double_type_node))
2834 return double_type_node;
2835
2836 if (mode == TYPE_MODE (long_double_type_node))
2837 return long_double_type_node;
2838
545c2bde 2839 if (mode == TYPE_MODE (void_type_node))
2840 return void_type_node;
b27ac6b5 2841
b0fc3e72 2842 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
61b9b73c 2843 return (unsignedp
2844 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2845 : make_signed_type (GET_MODE_PRECISION (mode)));
b0fc3e72 2846
2847 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
61b9b73c 2848 return (unsignedp
2849 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2850 : make_signed_type (GET_MODE_PRECISION (mode)));
b0fc3e72 2851
0dfc45b5 2852 if (COMPLEX_MODE_P (mode))
2853 {
2854 enum machine_mode inner_mode;
2855 tree inner_type;
2856
2857 if (mode == TYPE_MODE (complex_float_type_node))
2858 return complex_float_type_node;
2859 if (mode == TYPE_MODE (complex_double_type_node))
2860 return complex_double_type_node;
2861 if (mode == TYPE_MODE (complex_long_double_type_node))
2862 return complex_long_double_type_node;
2863
2864 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2865 return complex_integer_type_node;
2866
2867 inner_mode = GET_MODE_INNER (mode);
2868 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2869 if (inner_type != NULL_TREE)
2870 return build_complex_type (inner_type);
2871 }
2872 else if (VECTOR_MODE_P (mode))
4917c376 2873 {
2874 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2875 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2876 if (inner_type != NULL_TREE)
2877 return build_vector_type_for_mode (inner_type, mode);
88ae7f04 2878 }
e2ea7e3a 2879
c4503c0a 2880 if (mode == TYPE_MODE (dfloat32_type_node))
2881 return dfloat32_type_node;
2882 if (mode == TYPE_MODE (dfloat64_type_node))
2883 return dfloat64_type_node;
2884 if (mode == TYPE_MODE (dfloat128_type_node))
2885 return dfloat128_type_node;
2886
9421ebb9 2887 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2888 {
2889 if (mode == TYPE_MODE (short_fract_type_node))
2890 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2891 if (mode == TYPE_MODE (fract_type_node))
2892 return unsignedp ? sat_fract_type_node : fract_type_node;
2893 if (mode == TYPE_MODE (long_fract_type_node))
2894 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2895 if (mode == TYPE_MODE (long_long_fract_type_node))
2896 return unsignedp ? sat_long_long_fract_type_node
2897 : long_long_fract_type_node;
2898
2899 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2900 return unsignedp ? sat_unsigned_short_fract_type_node
2901 : unsigned_short_fract_type_node;
2902 if (mode == TYPE_MODE (unsigned_fract_type_node))
2903 return unsignedp ? sat_unsigned_fract_type_node
2904 : unsigned_fract_type_node;
2905 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2906 return unsignedp ? sat_unsigned_long_fract_type_node
2907 : unsigned_long_fract_type_node;
2908 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2909 return unsignedp ? sat_unsigned_long_long_fract_type_node
2910 : unsigned_long_long_fract_type_node;
2911
2912 if (mode == TYPE_MODE (short_accum_type_node))
2913 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2914 if (mode == TYPE_MODE (accum_type_node))
2915 return unsignedp ? sat_accum_type_node : accum_type_node;
2916 if (mode == TYPE_MODE (long_accum_type_node))
2917 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2918 if (mode == TYPE_MODE (long_long_accum_type_node))
2919 return unsignedp ? sat_long_long_accum_type_node
2920 : long_long_accum_type_node;
2921
2922 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2923 return unsignedp ? sat_unsigned_short_accum_type_node
2924 : unsigned_short_accum_type_node;
2925 if (mode == TYPE_MODE (unsigned_accum_type_node))
2926 return unsignedp ? sat_unsigned_accum_type_node
2927 : unsigned_accum_type_node;
2928 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2929 return unsignedp ? sat_unsigned_long_accum_type_node
2930 : unsigned_long_accum_type_node;
2931 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2932 return unsignedp ? sat_unsigned_long_long_accum_type_node
2933 : unsigned_long_long_accum_type_node;
2934
2935 if (mode == QQmode)
2936 return unsignedp ? sat_qq_type_node : qq_type_node;
2937 if (mode == HQmode)
2938 return unsignedp ? sat_hq_type_node : hq_type_node;
2939 if (mode == SQmode)
2940 return unsignedp ? sat_sq_type_node : sq_type_node;
2941 if (mode == DQmode)
2942 return unsignedp ? sat_dq_type_node : dq_type_node;
2943 if (mode == TQmode)
2944 return unsignedp ? sat_tq_type_node : tq_type_node;
2945
2946 if (mode == UQQmode)
2947 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2948 if (mode == UHQmode)
2949 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2950 if (mode == USQmode)
2951 return unsignedp ? sat_usq_type_node : usq_type_node;
2952 if (mode == UDQmode)
2953 return unsignedp ? sat_udq_type_node : udq_type_node;
2954 if (mode == UTQmode)
2955 return unsignedp ? sat_utq_type_node : utq_type_node;
2956
2957 if (mode == HAmode)
2958 return unsignedp ? sat_ha_type_node : ha_type_node;
2959 if (mode == SAmode)
2960 return unsignedp ? sat_sa_type_node : sa_type_node;
2961 if (mode == DAmode)
2962 return unsignedp ? sat_da_type_node : da_type_node;
2963 if (mode == TAmode)
2964 return unsignedp ? sat_ta_type_node : ta_type_node;
2965
2966 if (mode == UHAmode)
2967 return unsignedp ? sat_uha_type_node : uha_type_node;
2968 if (mode == USAmode)
2969 return unsignedp ? sat_usa_type_node : usa_type_node;
2970 if (mode == UDAmode)
2971 return unsignedp ? sat_uda_type_node : uda_type_node;
2972 if (mode == UTAmode)
2973 return unsignedp ? sat_uta_type_node : uta_type_node;
2974 }
2975
5b247e9f 2976 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2977 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2978 return TREE_VALUE (t);
2979
b0fc3e72 2980 return 0;
2981}
20d39783 2982
11773141 2983tree
2984c_common_unsigned_type (tree type)
2985{
2986 return c_common_signed_or_unsigned_type (1, type);
2987}
2988
20d39783 2989/* Return a signed type the same as TYPE in other respects. */
2990
2991tree
1cae46be 2992c_common_signed_type (tree type)
20d39783 2993{
4070745f 2994 return c_common_signed_or_unsigned_type (0, type);
20d39783 2995}
2996
2997/* Return a type the same as TYPE except unsigned or
2998 signed according to UNSIGNEDP. */
2999
3000tree
1cae46be 3001c_common_signed_or_unsigned_type (int unsignedp, tree type)
20d39783 3002{
7a91101f 3003 tree type1;
20d39783 3004
7a91101f 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) */
3010
3011 type1 = TYPE_MAIN_VARIANT (type);
3012 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3013 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3014 if (type1 == integer_type_node || type1 == unsigned_type_node)
3015 return unsignedp ? unsigned_type_node : integer_type_node;
3016 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3017 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3018 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3019 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3020 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3021 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
6388cfe2 3022 if (int128_integer_type_node
3023 && (type1 == int128_integer_type_node
3024 || type1 == int128_unsigned_type_node))
3025 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
7a91101f 3026 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3027 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3028#if HOST_BITS_PER_WIDE_INT >= 64
3029 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3030 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3031#endif
3032 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3033 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3034 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3035 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3036 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3037 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3038 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3039 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3040
9f92e1a2 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;
3058
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;
3064
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;
3082
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;
3088
3089 C_COMMON_FIXED_TYPES (fract);
3090 C_COMMON_FIXED_TYPES_SAT (fract);
3091 C_COMMON_FIXED_TYPES (accum);
3092 C_COMMON_FIXED_TYPES_SAT (accum);
3093
3094 C_COMMON_FIXED_MODE_TYPES (qq);
3095 C_COMMON_FIXED_MODE_TYPES (hq);
3096 C_COMMON_FIXED_MODE_TYPES (sq);
3097 C_COMMON_FIXED_MODE_TYPES (dq);
3098 C_COMMON_FIXED_MODE_TYPES (tq);
3099 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3100 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3101 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3102 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3103 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3104 C_COMMON_FIXED_MODE_TYPES (ha);
3105 C_COMMON_FIXED_MODE_TYPES (sa);
3106 C_COMMON_FIXED_MODE_TYPES (da);
3107 C_COMMON_FIXED_MODE_TYPES (ta);
3108 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3109 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3110 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3111 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
9421ebb9 3112
4f7f7efd 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. */
3121
ac265864 3122 if (!INTEGRAL_TYPE_P (type)
3123 || TYPE_UNSIGNED (type) == unsignedp)
3124 return type;
3125
4f7f7efd 3126#define TYPE_OK(node) \
3127 (TYPE_MODE (type) == TYPE_MODE (node) \
0c4abe5b 3128 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
4f7f7efd 3129 if (TYPE_OK (signed_char_type_node))
20d39783 3130 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
4f7f7efd 3131 if (TYPE_OK (integer_type_node))
20d39783 3132 return unsignedp ? unsigned_type_node : integer_type_node;
4f7f7efd 3133 if (TYPE_OK (short_integer_type_node))
20d39783 3134 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
4f7f7efd 3135 if (TYPE_OK (long_integer_type_node))
20d39783 3136 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
4f7f7efd 3137 if (TYPE_OK (long_long_integer_type_node))
20d39783 3138 return (unsignedp ? long_long_unsigned_type_node
3139 : long_long_integer_type_node);
6388cfe2 3140 if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3141 return (unsignedp ? int128_unsigned_type_node
3142 : int128_integer_type_node);
4f7f7efd 3143 if (TYPE_OK (widest_integer_literal_type_node))
20d39783 3144 return (unsignedp ? widest_unsigned_literal_type_node
3145 : widest_integer_literal_type_node);
ef11801e 3146
3147#if HOST_BITS_PER_WIDE_INT >= 64
4f7f7efd 3148 if (TYPE_OK (intTI_type_node))
ef11801e 3149 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3150#endif
4f7f7efd 3151 if (TYPE_OK (intDI_type_node))
ef11801e 3152 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
4f7f7efd 3153 if (TYPE_OK (intSI_type_node))
ef11801e 3154 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
4f7f7efd 3155 if (TYPE_OK (intHI_type_node))
ef11801e 3156 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
4f7f7efd 3157 if (TYPE_OK (intQI_type_node))
ef11801e 3158 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
4f7f7efd 3159#undef TYPE_OK
ef11801e 3160
0c4abe5b 3161 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
20d39783 3162}
b268e47e 3163
c0e47fd4 3164/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3165
3166tree
3167c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
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. */
3175 if (width == TYPE_PRECISION (integer_type_node))
3176 return unsignedp ? unsigned_type_node : integer_type_node;
3177 if (width == TYPE_PRECISION (signed_char_type_node))
3178 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3179 if (width == TYPE_PRECISION (short_integer_type_node))
3180 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3181 if (width == TYPE_PRECISION (long_integer_type_node))
3182 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3183 if (width == TYPE_PRECISION (long_long_integer_type_node))
3184 return (unsignedp ? long_long_unsigned_type_node
3185 : long_long_integer_type_node);
6388cfe2 3186 if (int128_integer_type_node
3187 && width == TYPE_PRECISION (int128_integer_type_node))
3188 return (unsignedp ? int128_unsigned_type_node
3189 : int128_integer_type_node);
c0e47fd4 3190 return build_nonstandard_integer_type (width, unsignedp);
3191}
3192
b268e47e 3193/* The C version of the register_builtin_type langhook. */
3194
3195void
3196c_register_builtin_type (tree type, const char* name)
3197{
3198 tree decl;
3199
e60a6f7b 3200 decl = build_decl (UNKNOWN_LOCATION,
3201 TYPE_DECL, get_identifier (name), type);
b268e47e 3202 DECL_ARTIFICIAL (decl) = 1;
3203 if (!TYPE_NAME (type))
3204 TYPE_NAME (type) = decl;
3205 pushdecl (decl);
5b247e9f 3206
3207 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
b268e47e 3208}
a9b9d10c 3209\f
aff9e656 3210/* Print an error message for invalid operands to arith operation
8e70fb09 3211 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3212 LOCATION is the location of the message. */
b0fc3e72 3213
3214void
8e70fb09 3215binary_op_error (location_t location, enum tree_code code,
3216 tree type0, tree type1)
b0fc3e72 3217{
19cb6b50 3218 const char *opname;
f03946e4 3219
b0fc3e72 3220 switch (code)
3221 {
b0fc3e72 3222 case PLUS_EXPR:
3223 opname = "+"; break;
3224 case MINUS_EXPR:
3225 opname = "-"; break;
3226 case MULT_EXPR:
3227 opname = "*"; break;
3228 case MAX_EXPR:
3229 opname = "max"; break;
3230 case MIN_EXPR:
3231 opname = "min"; break;
3232 case EQ_EXPR:
3233 opname = "=="; break;
3234 case NE_EXPR:
3235 opname = "!="; break;
3236 case LE_EXPR:
3237 opname = "<="; break;
3238 case GE_EXPR:
3239 opname = ">="; break;
3240 case LT_EXPR:
3241 opname = "<"; break;
3242 case GT_EXPR:
3243 opname = ">"; break;
3244 case LSHIFT_EXPR:
3245 opname = "<<"; break;
3246 case RSHIFT_EXPR:
3247 opname = ">>"; break;
3248 case TRUNC_MOD_EXPR:
66618a1e 3249 case FLOOR_MOD_EXPR:
b0fc3e72 3250 opname = "%"; break;
3251 case TRUNC_DIV_EXPR:
66618a1e 3252 case FLOOR_DIV_EXPR:
b0fc3e72 3253 opname = "/"; break;
3254 case BIT_AND_EXPR:
3255 opname = "&"; break;
3256 case BIT_IOR_EXPR:
3257 opname = "|"; break;
3258 case TRUTH_ANDIF_EXPR:
3259 opname = "&&"; break;
3260 case TRUTH_ORIF_EXPR:
3261 opname = "||"; break;
3262 case BIT_XOR_EXPR:
3263 opname = "^"; break;
31f820d2 3264 default:
315ba355 3265 gcc_unreachable ();
b0fc3e72 3266 }
8e70fb09 3267 error_at (location,
3268 "invalid operands to binary %s (have %qT and %qT)", opname,
3269 type0, type1);
b0fc3e72 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.
5b511807 3275 This function is also responsible for converting the two operands
3276 to the proper common type for comparison.
b0fc3e72 3277
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.
3281
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. */
3285
3286tree
1cae46be 3287shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3288 enum tree_code *rescode_ptr)
b0fc3e72 3289{
19cb6b50 3290 tree type;
b0fc3e72 3291 tree op0 = *op0_ptr;
3292 tree op1 = *op1_ptr;
3293 int unsignedp0, unsignedp1;
3294 int real1, real2;
3295 tree primop0, primop1;
3296 enum tree_code code = *rescode_ptr;
3297
3298 /* Throw away any conversions to wider types
3299 already present in the operands. */
3300
3301 primop0 = get_narrower (op0, &unsignedp0);
3302 primop1 = get_narrower (op1, &unsignedp1);
3303
119d06b2 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. */
3307 if (TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (TREE_TYPE (op0))
3308 && TYPE_PRECISION (TREE_TYPE (op0)) < TYPE_PRECISION (*restype_ptr)
3309 && !unsignedp0
3310 && TYPE_UNSIGNED (TREE_TYPE (op0)))
3311 primop0 = op0;
3312 if (TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (TREE_TYPE (op1))
3313 && TYPE_PRECISION (TREE_TYPE (op1)) < TYPE_PRECISION (*restype_ptr)
3314 && !unsignedp1
3315 && TYPE_UNSIGNED (TREE_TYPE (op1)))
3316 primop1 = op1;
3317
b0fc3e72 3318 /* Handle the case that OP0 does not *contain* a conversion
3319 but it *requires* conversion to FINAL_TYPE. */
3320
3321 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
78a8ed03 3322 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
b0fc3e72 3323 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
78a8ed03 3324 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
b0fc3e72 3325
3326 /* If one of the operands must be floated, we cannot optimize. */
3327 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3328 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3329
3330 /* If first arg is constant, swap the args (changing operation
2bd278cc 3331 so value is preserved), for canonicalization. Don't do this if
3332 the second arg is 0. */
b0fc3e72 3333
2bd278cc 3334 if (TREE_CONSTANT (primop0)
9421ebb9 3335 && !integer_zerop (primop1) && !real_zerop (primop1)
3336 && !fixed_zerop (primop1))
b0fc3e72 3337 {
19cb6b50 3338 tree tem = primop0;
3339 int temi = unsignedp0;
b0fc3e72 3340 primop0 = primop1;
3341 primop1 = tem;
3342 tem = op0;
3343 op0 = op1;
3344 op1 = tem;
3345 *op0_ptr = op0;
3346 *op1_ptr = op1;
3347 unsignedp0 = unsignedp1;
3348 unsignedp1 = temi;
3349 temi = real1;
3350 real1 = real2;
3351 real2 = temi;
3352
3353 switch (code)
3354 {
3355 case LT_EXPR:
3356 code = GT_EXPR;
3357 break;
3358 case GT_EXPR:
3359 code = LT_EXPR;
3360 break;
3361 case LE_EXPR:
3362 code = GE_EXPR;
3363 break;
3364 case GE_EXPR:
3365 code = LE_EXPR;
3366 break;
31f820d2 3367 default:
3368 break;
b0fc3e72 3369 }
3370 *rescode_ptr = code;
3371 }
3372
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.
3377
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. */
3389
3390 if (!real1 && !real2
9421ebb9 3391 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
b0fc3e72 3392 && TREE_CODE (primop1) == INTEGER_CST
3393 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3394 {
3395 int min_gt, max_gt, min_lt, max_lt;
3396 tree maxval, minval;
3397 /* 1 if comparison is nominally unsigned. */
78a8ed03 3398 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
b0fc3e72 3399 tree val;
3400
4070745f 3401 type = c_common_signed_or_unsigned_type (unsignedp0,
3402 TREE_TYPE (primop0));
cda09c61 3403
b0fc3e72 3404 maxval = TYPE_MAX_VALUE (type);
3405 minval = TYPE_MIN_VALUE (type);
3406
3407 if (unsignedp && !unsignedp0)
4070745f 3408 *restype_ptr = c_common_signed_type (*restype_ptr);
b0fc3e72 3409
3410 if (TREE_TYPE (primop1) != *restype_ptr)
18dbec6f 3411 {
9a5e8086 3412 /* Convert primop1 to target type, but do not introduce
3413 additional overflow. We know primop1 is an int_cst. */
c8110c8f 3414 primop1 = force_fit_type_double (*restype_ptr,
d3237426 3415 tree_to_double_int (primop1),
3416 0, TREE_OVERFLOW (primop1));
18dbec6f 3417 }
b0fc3e72 3418 if (type != *restype_ptr)
3419 {
3420 minval = convert (*restype_ptr, minval);
3421 maxval = convert (*restype_ptr, maxval);
3422 }
3423
3424 if (unsignedp && unsignedp0)
3425 {
3426 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3427 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3428 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3429 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3430 }
3431 else
3432 {
3433 min_gt = INT_CST_LT (primop1, minval);
3434 max_gt = INT_CST_LT (primop1, maxval);
3435 min_lt = INT_CST_LT (minval, primop1);
3436 max_lt = INT_CST_LT (maxval, primop1);
3437 }
3438
3439 val = 0;
3440 /* This used to be a switch, but Genix compiler can't handle that. */
3441 if (code == NE_EXPR)
3442 {
3443 if (max_lt || min_gt)
3c2239cf 3444 val = truthvalue_true_node;
b0fc3e72 3445 }
3446 else if (code == EQ_EXPR)
3447 {
3448 if (max_lt || min_gt)
3c2239cf 3449 val = truthvalue_false_node;
b0fc3e72 3450 }
3451 else if (code == LT_EXPR)
3452 {
3453 if (max_lt)
3c2239cf 3454 val = truthvalue_true_node;
b0fc3e72 3455 if (!min_lt)
3c2239cf 3456 val = truthvalue_false_node;
b0fc3e72 3457 }
3458 else if (code == GT_EXPR)
3459 {
3460 if (min_gt)
3c2239cf 3461 val = truthvalue_true_node;
b0fc3e72 3462 if (!max_gt)
3c2239cf 3463 val = truthvalue_false_node;
b0fc3e72 3464 }
3465 else if (code == LE_EXPR)
3466 {
3467 if (!max_gt)
3c2239cf 3468 val = truthvalue_true_node;
b0fc3e72 3469 if (min_gt)
3c2239cf 3470 val = truthvalue_false_node;
b0fc3e72 3471 }
3472 else if (code == GE_EXPR)
3473 {
3474 if (!min_lt)
3c2239cf 3475 val = truthvalue_true_node;
b0fc3e72 3476 if (max_lt)
3c2239cf 3477 val = truthvalue_false_node;
b0fc3e72 3478 }
3479
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.
3483
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. */
3490
3491 if (unsignedp && !unsignedp0)
3492 {
3493 if (val != 0)
3494 switch (code)
3495 {
3496 case LT_EXPR:
3497 case GE_EXPR:
3498 primop1 = TYPE_MIN_VALUE (type);
3499 val = 0;
3500 break;
3501
3502 case LE_EXPR:
3503 case GT_EXPR:
3504 primop1 = TYPE_MAX_VALUE (type);
3505 val = 0;
3506 break;
31f820d2 3507
3508 default:
3509 break;
b0fc3e72 3510 }
11773141 3511 type = c_common_unsigned_type (type);
b0fc3e72 3512 }
3513
fe5f2366 3514 if (TREE_CODE (primop0) != INTEGER_CST)
b0fc3e72 3515 {
3c2239cf 3516 if (val == truthvalue_false_node)
e6e352cb 3517 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3c2239cf 3518 if (val == truthvalue_true_node)
e6e352cb 3519 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
b0fc3e72 3520 }
3521
3522 if (val != 0)
3523 {
3524 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3525 if (TREE_SIDE_EFFECTS (primop0))
14ae0310 3526 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
b0fc3e72 3527 return val;
3528 }
3529
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 }
c4503c0a 3534
3535 /* If either arg is decimal float and the other is float, find the
3536 proper common type to use for comparison. */
3537 else if (real1 && real2
3538 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3539 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3540 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3541
b0fc3e72 3542 else if (real1 && real2
2203bd5c 3543 && (TYPE_PRECISION (TREE_TYPE (primop0))
3544 == TYPE_PRECISION (TREE_TYPE (primop1))))
b0fc3e72 3545 type = TREE_TYPE (primop0);
3546
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.) */
3554
3555 else if (unsignedp0 == unsignedp1 && real1 == real2
3556 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3557 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3558 {
3559 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
4070745f 3560 type = c_common_signed_or_unsigned_type (unsignedp0
78a8ed03 3561 || TYPE_UNSIGNED (*restype_ptr),
4070745f 3562 type);
b0fc3e72 3563 /* Make sure shorter operand is extended the right way
3564 to match the longer operand. */
4070745f 3565 primop0
3566 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3567 TREE_TYPE (primop0)),
3568 primop0);
3569 primop1
3570 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3571 TREE_TYPE (primop1)),
3572 primop1);
b0fc3e72 3573 }
3574 else
3575 {
3576 /* Here we must do the comparison on the nominal type
3577 using the args exactly as we received them. */
3578 type = *restype_ptr;
3579 primop0 = op0;
3580 primop1 = op1;
3581
3582 if (!real1 && !real2 && integer_zerop (primop1)
78a8ed03 3583 && TYPE_UNSIGNED (*restype_ptr))
b0fc3e72 3584 {
3585 tree value = 0;
3586 switch (code)
3587 {
3588 case GE_EXPR:
e6e352cb 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. */
3593 if (warn_type_limits && !in_system_header
84166705 3594 && !(TREE_CODE (primop0) == INTEGER_CST
3595 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3596 primop0))))
48e1416a 3597 warning (OPT_Wtype_limits,
e6e352cb 3598 "comparison of unsigned expression >= 0 is always true");
3c2239cf 3599 value = truthvalue_true_node;
b0fc3e72 3600 break;
3601
3602 case LT_EXPR:
e6e352cb 3603 if (warn_type_limits && !in_system_header
84166705 3604 && !(TREE_CODE (primop0) == INTEGER_CST
3605 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3606 primop0))))
48e1416a 3607 warning (OPT_Wtype_limits,
e6e352cb 3608 "comparison of unsigned expression < 0 is always false");
3c2239cf 3609 value = truthvalue_false_node;
31f820d2 3610 break;
3611
3612 default:
3613 break;
b0fc3e72 3614 }
3615
3616 if (value != 0)
3617 {
3618 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3619 if (TREE_SIDE_EFFECTS (primop0))
14ae0310 3620 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3621 primop0, value);
b0fc3e72 3622 return value;
3623 }
3624 }
3625 }
3626
3627 *op0_ptr = convert (type, primop0);
3628 *op1_ptr = convert (type, primop1);
3629
3c2239cf 3630 *restype_ptr = truthvalue_type_node;
b0fc3e72 3631
3632 return 0;
3633}
3634\f
1c26100f 3635/* Return a tree for the sum or difference (RESULTCODE says which)
3636 of pointer PTROP and integer INTOP. */
3637
3638tree
389dd41b 3639pointer_int_sum (location_t loc, enum tree_code resultcode,
3640 tree ptrop, tree intop)
1c26100f 3641{
add6ee5e 3642 tree size_exp, ret;
1c26100f 3643
1c26100f 3644 /* The result is a pointer of the same type that is being added. */
1c26100f 3645 tree result_type = TREE_TYPE (ptrop);
3646
3647 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3648 {
48e1416a 3649 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
8864917d 3650 "pointer of type %<void *%> used in arithmetic");
1c26100f 3651 size_exp = integer_one_node;
3652 }
3653 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3654 {
48e1416a 3655 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
8864917d 3656 "pointer to a function used in arithmetic");
1c26100f 3657 size_exp = integer_one_node;
3658 }
3659 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3660 {
48e1416a 3661 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
8864917d 3662 "pointer to member function used in arithmetic");
1c26100f 3663 size_exp = integer_one_node;
3664 }
1c26100f 3665 else
3666 size_exp = size_in_bytes (TREE_TYPE (result_type));
3667
add6ee5e 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. */
3672 fold_defer_overflow_warnings ();
3673
1c26100f 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. */
1c26100f 3678 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
84166705 3679 && !TREE_CONSTANT (intop)
1c26100f 3680 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3681 && TREE_CONSTANT (size_exp)
3682 /* If the constant comes from pointer subtraction,
3683 skip this optimization--it would cause an error. */
3684 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
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. */
84166705 3688 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
1c26100f 3689 || (TYPE_PRECISION (TREE_TYPE (intop))
3690 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3691 {
3692 enum tree_code subcode = resultcode;
3693 tree int_type = TREE_TYPE (intop);
3694 if (TREE_CODE (intop) == MINUS_EXPR)
3695 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
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. */
8e70fb09 3699 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3700 subcode, ptrop,
1c26100f 3701 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3702 intop = convert (int_type, TREE_OPERAND (intop, 0));
3703 }
3704
3705 /* Convert the integer argument to a type the same size as sizetype
3706 so the multiply won't overflow spuriously. */
1c26100f 3707 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
78a8ed03 3708 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
1cae46be 3709 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
78a8ed03 3710 TYPE_UNSIGNED (sizetype)), intop);
1c26100f 3711
3712 /* Replace the integer argument with a suitable product by the object size.
c6feb9f1 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 {
3717 tree t = build_binary_op (loc,
3718 MULT_EXPR, intop,
3719 convert (TREE_TYPE (intop), size_exp), 1);
3720 intop = convert (sizetype, t);
3721 if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3722 intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3723 TREE_INT_CST_HIGH (intop));
3724 }
0de36bdb 3725
499e523f 3726 /* Create the sum or difference. */
0de36bdb 3727 if (resultcode == MINUS_EXPR)
389dd41b 3728 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
1c26100f 3729
389dd41b 3730 ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
add6ee5e 3731
3732 fold_undefer_and_ignore_overflow_warnings ();
3733
3734 return ret;
1c26100f 3735}
3736\f
f59e3889 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. */
3740
3741tree
3742c_wrap_maybe_const (tree expr, bool non_const)
3743{
3744 bool nowarning = TREE_NO_WARNING (expr);
3745 location_t loc = EXPR_LOCATION (expr);
3746
3747 /* This should never be called for C++. */
3748 if (c_dialect_cxx ())
3749 gcc_unreachable ();
3750
3751 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3752 STRIP_TYPE_NOPS (expr);
3753 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3754 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3755 if (nowarning)
3756 TREE_NO_WARNING (expr) = 1;
3757 protected_set_expr_location (expr, loc);
3758
3759 return expr;
3760}
3761
a75b1c71 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. */
3766
3767tree
3768c_save_expr (tree expr)
3769{
3770 bool maybe_const = true;
3771 if (c_dialect_cxx ())
3772 return save_expr (expr);
3773 expr = c_fully_fold (expr, false, &maybe_const);
3774 expr = save_expr (expr);
3775 if (!maybe_const)
f59e3889 3776 expr = c_wrap_maybe_const (expr, true);
a75b1c71 3777 return expr;
3778}
3779
6b68e71a 3780/* Return whether EXPR is a declaration whose address can never be
3781 NULL. */
3782
3783bool
9f627b1a 3784decl_with_nonnull_addr_p (const_tree expr)
6b68e71a 3785{
3786 return (DECL_P (expr)
3787 && (TREE_CODE (expr) == PARM_DECL
3788 || TREE_CODE (expr) == LABEL_DECL
3789 || !DECL_WEAK (expr)));
3790}
3791
b0fc3e72 3792/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
45a78cc0 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.
b0fc3e72 3796
8e70fb09 3797 The EXPR is located at LOCATION.
3798
b0fc3e72 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
3c2239cf 3802 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
b0fc3e72 3803 but we optimize comparisons, &&, ||, and !.
3804
3c2239cf 3805 The resulting type should always be `truthvalue_type_node'. */
b0fc3e72 3806
3807tree
8e70fb09 3808c_common_truthvalue_conversion (location_t location, tree expr)
b0fc3e72 3809{
b0fc3e72 3810 switch (TREE_CODE (expr))
3811 {
318a728f 3812 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
e1232ce2 3813 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3814 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3815 case ORDERED_EXPR: case UNORDERED_EXPR:
ce04dcdc 3816 if (TREE_TYPE (expr) == truthvalue_type_node)
3817 return expr;
e60a6f7b 3818 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
ce04dcdc 3819 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
e60a6f7b 3820 goto ret;
ce04dcdc 3821
b0fc3e72 3822 case TRUTH_ANDIF_EXPR:
3823 case TRUTH_ORIF_EXPR:
3824 case TRUTH_AND_EXPR:
3825 case TRUTH_OR_EXPR:
31f6e93c 3826 case TRUTH_XOR_EXPR:
ce04dcdc 3827 if (TREE_TYPE (expr) == truthvalue_type_node)
3828 return expr;
e60a6f7b 3829 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
48e1416a 3830 c_common_truthvalue_conversion (location,
e60a6f7b 3831 TREE_OPERAND (expr, 0)),
3832 c_common_truthvalue_conversion (location,
3833 TREE_OPERAND (expr, 1)));
3834 goto ret;
3e851b85 3835
f6e28f72 3836 case TRUTH_NOT_EXPR:
ce04dcdc 3837 if (TREE_TYPE (expr) == truthvalue_type_node)
3838 return expr;
e60a6f7b 3839 expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3840 c_common_truthvalue_conversion (location,
3841 TREE_OPERAND (expr, 0)));
3842 goto ret;
f6e28f72 3843
b0fc3e72 3844 case ERROR_MARK:
3845 return expr;
3846
3847 case INTEGER_CST:
eddad94a 3848 return integer_zerop (expr) ? truthvalue_false_node
3849 : truthvalue_true_node;
b0fc3e72 3850
3851 case REAL_CST:
5000e21c 3852 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3853 ? truthvalue_true_node
3854 : truthvalue_false_node;
b0fc3e72 3855
9421ebb9 3856 case FIXED_CST:
3857 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3858 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3859 ? truthvalue_true_node
3860 : truthvalue_false_node;
3861
ce04dcdc 3862 case FUNCTION_DECL:
b6889cb0 3863 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
ce04dcdc 3864 /* Fall through. */
3865
b0fc3e72 3866 case ADDR_EXPR:
ce871053 3867 {
ee7d4d6a 3868 tree inner = TREE_OPERAND (expr, 0);
6b68e71a 3869 if (decl_with_nonnull_addr_p (inner))
ce871053 3870 {
6b68e71a 3871 /* Common Ada/Pascal programmer's mistake. */
8e70fb09 3872 warning_at (location,
3873 OPT_Waddress,
3874 "the address of %qD will always evaluate as %<true%>",
3875 inner);
ce871053 3876 return truthvalue_true_node;
3877 }
d473d901 3878 break;
ce871053 3879 }
b0fc3e72 3880
2203bd5c 3881 case COMPLEX_EXPR:
e60a6f7b 3882 expr = build_binary_op (EXPR_LOCATION (expr),
8e70fb09 3883 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
95809de4 3884 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
8e70fb09 3885 c_common_truthvalue_conversion (location,
3886 TREE_OPERAND (expr, 0)),
3887 c_common_truthvalue_conversion (location,
3888 TREE_OPERAND (expr, 1)),
2203bd5c 3889 0);
e60a6f7b 3890 goto ret;
2203bd5c 3891
b0fc3e72 3892 case NEGATE_EXPR:
3893 case ABS_EXPR:
3894 case FLOAT_EXPR:
c6418a4e 3895 case EXCESS_PRECISION_EXPR:
d10cfa8d 3896 /* These don't change whether an object is nonzero or zero. */
8e70fb09 3897 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
b0fc3e72 3898
3899 case LROTATE_EXPR:
3900 case RROTATE_EXPR:
d10cfa8d 3901 /* These don't change whether an object is zero or nonzero, but
b0fc3e72 3902 we can't ignore them if their second arg has side-effects. */
3903 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
e60a6f7b 3904 {
3905 expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
3906 TREE_OPERAND (expr, 1),
48e1416a 3907 c_common_truthvalue_conversion
e60a6f7b 3908 (location, TREE_OPERAND (expr, 0)));
3909 goto ret;
3910 }
b0fc3e72 3911 else
8e70fb09 3912 return c_common_truthvalue_conversion (location,
3913 TREE_OPERAND (expr, 0));
73be5127 3914
b0fc3e72 3915 case COND_EXPR:
3916 /* Distribute the conversion into the arms of a COND_EXPR. */
a75b1c71 3917 if (c_dialect_cxx ())
e60a6f7b 3918 {
389dd41b 3919 expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
e60a6f7b 3920 TREE_OPERAND (expr, 0),
3921 c_common_truthvalue_conversion (location,
3922 TREE_OPERAND (expr,
3923 1)),
3924 c_common_truthvalue_conversion (location,
3925 TREE_OPERAND (expr,
3926 2)));
3927 goto ret;
3928 }
a75b1c71 3929 else
e60a6f7b 3930 {
3931 /* Folding will happen later for C. */
3932 expr = build3 (COND_EXPR, truthvalue_type_node,
3933 TREE_OPERAND (expr, 0),
3934 c_common_truthvalue_conversion (location,
3935 TREE_OPERAND (expr, 1)),
3936 c_common_truthvalue_conversion (location,
3937 TREE_OPERAND (expr, 2)));
3938 goto ret;
3939 }
b0fc3e72 3940
72dd6141 3941 CASE_CONVERT:
b0fc3e72 3942 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3943 since that affects how `default_conversion' will behave. */
3944 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3945 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3946 break;
b0fc3e72 3947 /* If this is widening the argument, we can ignore it. */
3948 if (TYPE_PRECISION (TREE_TYPE (expr))
3949 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
8e70fb09 3950 return c_common_truthvalue_conversion (location,
3951 TREE_OPERAND (expr, 0));
b0fc3e72 3952 break;
3953
16837b18 3954 case MODIFY_EXPR:
60a0513e 3955 if (!TREE_NO_WARNING (expr)
3956 && warn_parentheses)
3957 {
3958 warning (OPT_Wparentheses,
3959 "suggest parentheses around assignment used as truth value");
3960 TREE_NO_WARNING (expr) = 1;
3961 }
16837b18 3962 break;
73be5127 3963
31f820d2 3964 default:
3965 break;
b0fc3e72 3966 }
3967
2ba726d2 3968 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
a0748b7d 3969 {
93be21c0 3970 tree t = (in_late_binary_op ? save_expr (expr) : c_save_expr (expr));
e60a6f7b 3971 expr = (build_binary_op
8e70fb09 3972 (EXPR_LOCATION (expr),
3973 (TREE_SIDE_EFFECTS (expr)
a0748b7d 3974 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
b6889cb0 3975 c_common_truthvalue_conversion
3976 (location,
3977 build_unary_op (location, REALPART_EXPR, t, 0)),
3978 c_common_truthvalue_conversion
3979 (location,
3980 build_unary_op (location, IMAGPART_EXPR, t, 0)),
a0748b7d 3981 0));
e60a6f7b 3982 goto ret;
a0748b7d 3983 }
2ba726d2 3984
9421ebb9 3985 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3986 {
3987 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3988 FCONST0 (TYPE_MODE
3989 (TREE_TYPE (expr))));
43158006 3990 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
9421ebb9 3991 }
e60a6f7b 3992 else
3993 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
9421ebb9 3994
e60a6f7b 3995 ret:
3996 protected_set_expr_location (expr, location);
3997 return expr;
b0fc3e72 3998}
3999\f
3237155d 4000static void def_builtin_1 (enum built_in_function fncode,
4001 const char *name,
4002 enum built_in_class fnclass,
4003 tree fntype, tree libtype,
4004 bool both_p, bool fallback_p, bool nonansi_p,
4005 tree fnattrs, bool implicit_p);
0d4238dc 4006
a5b1863e 4007
4008/* Apply the TYPE_QUALS to the new DECL. */
4009
4010void
1cae46be 4011c_apply_type_quals_to_decl (int type_quals, tree decl)
a5b1863e 4012{
adfb367f 4013 tree type = TREE_TYPE (decl);
b27ac6b5 4014
e4eabbe4 4015 if (type == error_mark_node)
4016 return;
adfb367f 4017
4018 if (((type_quals & TYPE_QUAL_CONST)
4019 || (type && TREE_CODE (type) == REFERENCE_TYPE))
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. */
4025 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
a5b1863e 4026 TREE_READONLY (decl) = 1;
4027 if (type_quals & TYPE_QUAL_VOLATILE)
4028 {
4029 TREE_SIDE_EFFECTS (decl) = 1;
4030 TREE_THIS_VOLATILE (decl) = 1;
4031 }
d91a20bc 4032 if (type_quals & TYPE_QUAL_RESTRICT)
a5b1863e 4033 {
adfb367f 4034 while (type && TREE_CODE (type) == ARRAY_TYPE)
4035 /* Allow 'restrict' on arrays of pointers.
4036 FIXME currently we just ignore it. */
4037 type = TREE_TYPE (type);
4038 if (!type
4039 || !POINTER_TYPE_P (type)
4040 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
b0b1af64 4041 error ("invalid use of %<restrict%>");
a5b1863e 4042 }
4043}
4044
4ee9c684 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
0bed3869 4048 on some of the simple stuff and leaves the details to comptypes. */
4ee9c684 4049
4050static hashval_t
4051c_type_hash (const void *p)
4052{
ecf2703d 4053 int n_elements;
4ee9c684 4054 int shift, size;
aae87fc3 4055 const_tree const t = (const_tree) p;
4ee9c684 4056 tree t2;
4057 switch (TREE_CODE (t))
4058 {
fbf0afd1 4059 /* For pointers, hash on pointee type plus some swizzling. */
2363ef00 4060 case POINTER_TYPE:
4061 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4062 /* Hash on number of elements and total size. */
4063 case ENUMERAL_TYPE:
4064 shift = 3;
4065 t2 = TYPE_VALUES (t);
4066 break;
4067 case RECORD_TYPE:
4068 shift = 0;
4069 t2 = TYPE_FIELDS (t);
4070 break;
4071 case QUAL_UNION_TYPE:
4072 shift = 1;
4073 t2 = TYPE_FIELDS (t);
4074 break;
4075 case UNION_TYPE:
4076 shift = 2;
4077 t2 = TYPE_FIELDS (t);
4078 break;
4079 default:
231bd014 4080 gcc_unreachable ();
4ee9c684 4081 }
ecf2703d 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. */
4084 n_elements = list_length (t2);
78c2e180 4085 /* We might have a VLA here. */
4086 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4087 size = 0;
4088 else
4089 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
ecf2703d 4090 return ((size << 24) | (n_elements << shift));
4ee9c684 4091}
4092
1ecd4018 4093static GTY((param_is (union tree_node))) htab_t type_hash_table;
4094
b5ba9f3a 4095/* Return the typed-based alias set for T, which may be an expression
f7c44134 4096 or a type. Return -1 if we don't do anything special. */
b5ba9f3a 4097
32c2fdea 4098alias_set_type
1cae46be 4099c_common_get_alias_set (tree t)
b5ba9f3a 4100{
be4f2de7 4101 tree u;
4ee9c684 4102 PTR *slot;
1cae46be 4103
e58c17e7 4104 /* For VLAs, use the alias set of the element type rather than the
4105 default of alias set 0 for types compared structurally. */
4106 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4107 {
4108 if (TREE_CODE (t) == ARRAY_TYPE)
4109 return get_alias_set (TREE_TYPE (t));
4110 return -1;
4111 }
4112
be4f2de7 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. */
4119 for (u = t;
4120 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4121 u = TREE_OPERAND (u, 0))
4122 if (TREE_CODE (u) == COMPONENT_REF
4123 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4124 return 0;
1e2513d9 4125
9fcc3e54 4126 /* That's all the expressions we handle specially. */
84166705 4127 if (!TYPE_P (t))
9fcc3e54 4128 return -1;
4129
d716ce75 4130 /* The C standard guarantees that any object may be accessed via an
9fcc3e54 4131 lvalue that has character type. */
4132 if (t == char_type_node
4133 || t == signed_char_type_node
4134 || t == unsigned_char_type_node)
f7c44134 4135 return 0;
a5b1863e 4136
1607663f 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. */
78a8ed03 4140 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
a8868e19 4141 {
4070745f 4142 tree t1 = c_common_signed_type (t);
1607663f 4143
a8868e19 4144 /* t1 == t can happen for boolean nodes which are always unsigned. */
4145 if (t1 != t)
4146 return get_alias_set (t1);
4147 }
1e2513d9 4148
4ee9c684 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.) */
4155
4156 if (c_language != clk_c || flag_isoc99)
4157 return -1;
4158
0bed3869 4159 /* Save time if there's only one input file. */
e08bd2f4 4160 if (num_in_fnames == 1)
4ee9c684 4161 return -1;
4162
4163 /* Pointers need special handling if they point to any type that
4164 needs special handling (below). */
4165 if (TREE_CODE (t) == POINTER_TYPE)
4166 {
4167 tree t2;
4168 /* Find bottom type under any nested POINTERs. */
b27ac6b5 4169 for (t2 = TREE_TYPE (t);
af592f67 4170 TREE_CODE (t2) == POINTER_TYPE;
4171 t2 = TREE_TYPE (t2))
4172 ;
b27ac6b5 4173 if (TREE_CODE (t2) != RECORD_TYPE
af592f67 4174 && TREE_CODE (t2) != ENUMERAL_TYPE
4175 && TREE_CODE (t2) != QUAL_UNION_TYPE
4176 && TREE_CODE (t2) != UNION_TYPE)
4177 return -1;
4ee9c684 4178 if (TYPE_SIZE (t2) == 0)
af592f67 4179 return -1;
4ee9c684 4180 }
4181 /* These are the only cases that need special handling. */
b27ac6b5 4182 if (TREE_CODE (t) != RECORD_TYPE
4ee9c684 4183 && TREE_CODE (t) != ENUMERAL_TYPE
4184 && TREE_CODE (t) != QUAL_UNION_TYPE
4185 && TREE_CODE (t) != UNION_TYPE
4186 && TREE_CODE (t) != POINTER_TYPE)
4187 return -1;
4188 /* Undefined? */
4189 if (TYPE_SIZE (t) == 0)
4190 return -1;
4191
b27ac6b5 4192 /* Look up t in hash table. Only one of the compatible types within each
4ee9c684 4193 alias set is recorded in the table. */
4194 if (!type_hash_table)
1ecd4018 4195 type_hash_table = htab_create_ggc (1021, c_type_hash,
4ee9c684 4196 (htab_eq) lang_hooks.types_compatible_p,
4197 NULL);
4198 slot = htab_find_slot (type_hash_table, t, INSERT);
4199 if (*slot != NULL)
ad16cb2c 4200 {
4201 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4202 return TYPE_ALIAS_SET ((tree)*slot);
4203 }
4ee9c684 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. */
4207 *slot = t;
4208
f7c44134 4209 return -1;
b5ba9f3a 4210}
902b4e01 4211\f
e60a6f7b 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. */
908c697e 4217
902b4e01 4218tree
e60a6f7b 4219c_sizeof_or_alignof_type (location_t loc,
4220 tree type, bool is_sizeof, int complain)
902b4e01 4221{
d4c4d95c 4222 const char *op_name;
4223 tree value = NULL;
4224 enum tree_code type_code = TREE_CODE (type);
1cae46be 4225
908c697e 4226 op_name = is_sizeof ? "sizeof" : "__alignof__";
1cae46be 4227
d4c4d95c 4228 if (type_code == FUNCTION_TYPE)
902b4e01 4229 {
908c697e 4230 if (is_sizeof)
d4c4d95c 4231 {
d3a4d008 4232 if (complain && (pedantic || warn_pointer_arith))
48e1416a 4233 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
8864917d 4234 "invalid application of %<sizeof%> to a function type");
ebd21de4 4235 else if (!complain)
4236 return error_mark_node;
d4c4d95c 4237 value = size_one_node;
4238 }
4239 else
4240 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4241 }
4242 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4243 {
1cae46be 4244 if (type_code == VOID_TYPE
d3a4d008 4245 && complain && (pedantic || warn_pointer_arith))
48e1416a 4246 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
8864917d 4247 "invalid application of %qs to a void type", op_name);
ebd21de4 4248 else if (!complain)
4249 return error_mark_node;
d4c4d95c 4250 value = size_one_node;
902b4e01 4251 }
902b4e01 4252 else if (!COMPLETE_TYPE_P (type))
4253 {
d3a4d008 4254 if (complain)
e60a6f7b 4255 error_at (loc, "invalid application of %qs to incomplete type %qT ",
4256 op_name, type);
9c719c74 4257 return error_mark_node;
902b4e01 4258 }
4259 else
d4c4d95c 4260 {
908c697e 4261 if (is_sizeof)
d4c4d95c 4262 /* Convert in case a char is more than one unit. */
389dd41b 4263 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4264 size_int (TYPE_PRECISION (char_type_node)
4265 / BITS_PER_UNIT));
d4c4d95c 4266 else
d37625c0 4267 value = size_int (TYPE_ALIGN_UNIT (type));
d4c4d95c 4268 }
902b4e01 4269
d4c4d95c 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. */
389dd41b 4274 value = fold_convert_loc (loc, size_type_node, value);
1d8fc210 4275 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
1cae46be 4276
d4c4d95c 4277 return value;
902b4e01 4278}
4279
4280/* Implement the __alignof keyword: Return the minimum required
097b5c8b 4281 alignment of EXPR, measured in bytes. For VAR_DECLs,
4282 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
e60a6f7b 4283 from an "aligned" __attribute__ specification). LOC is the
4284 location of the ALIGNOF operator. */
72040e7e 4285
902b4e01 4286tree
e60a6f7b 4287c_alignof_expr (location_t loc, tree expr)
902b4e01 4288{
4289 tree t;
4290
097b5c8b 4291 if (VAR_OR_FUNCTION_DECL_P (expr))
d37625c0 4292 t = size_int (DECL_ALIGN_UNIT (expr));
1cae46be 4293
902b4e01 4294 else if (TREE_CODE (expr) == COMPONENT_REF
4295 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4296 {
e60a6f7b 4297 error_at (loc, "%<__alignof%> applied to a bit-field");
902b4e01 4298 t = size_one_node;
4299 }
4300 else if (TREE_CODE (expr) == COMPONENT_REF
7cc7e163 4301 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
d37625c0 4302 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
1cae46be 4303
902b4e01 4304 else if (TREE_CODE (expr) == INDIRECT_REF)
4305 {
4306 tree t = TREE_OPERAND (expr, 0);
4307 tree best = t;
4308 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
1cae46be 4309
72dd6141 4310 while (CONVERT_EXPR_P (t)
7cc7e163 4311 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
902b4e01 4312 {
4313 int thisalign;
4314
4315 t = TREE_OPERAND (t, 0);
4316 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4317 if (thisalign > bestalign)
4318 best = t, bestalign = thisalign;
4319 }
e60a6f7b 4320 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
902b4e01 4321 }
4322 else
e60a6f7b 4323 return c_alignof (loc, TREE_TYPE (expr));
902b4e01 4324
389dd41b 4325 return fold_convert_loc (loc, size_type_node, t);
902b4e01 4326}
4327\f
8fe4a266 4328/* Handle C and C++ default attributes. */
4329
4330enum 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,
8fe4a266 4336#include "builtin-attrs.def"
4337#undef DEF_ATTR_NULL_TREE
4338#undef DEF_ATTR_INT
4339#undef DEF_ATTR_IDENT
4340#undef DEF_ATTR_TREE_LIST
8fe4a266 4341 ATTR_LAST
4342};
4343
4344static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4345
1cae46be 4346static void c_init_attributes (void);
8fe4a266 4347
27213ba3 4348enum c_builtin_type
72040e7e 4349{
d2d4bdde 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,
0a39fd54 4356#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
27213ba3 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,
d2d4bdde 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,
03901330 4362#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
0a39fd54 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,
d2d4bdde 4366#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4367#include "builtin-types.def"
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
0a39fd54 4374#undef DEF_FUNCTION_TYPE_5
4375#undef DEF_FUNCTION_TYPE_6
27213ba3 4376#undef DEF_FUNCTION_TYPE_7
d2d4bdde 4377#undef DEF_FUNCTION_TYPE_VAR_0
4378#undef DEF_FUNCTION_TYPE_VAR_1
4379#undef DEF_FUNCTION_TYPE_VAR_2
03901330 4380#undef DEF_FUNCTION_TYPE_VAR_3
0a39fd54 4381#undef DEF_FUNCTION_TYPE_VAR_4
4382#undef DEF_FUNCTION_TYPE_VAR_5
d2d4bdde 4383#undef DEF_POINTER_TYPE
27213ba3 4384 BT_LAST
4385};
4386
4387typedef enum c_builtin_type builtin_type;
d2d4bdde 4388
27213ba3 4389/* A temporary array for c_common_nodes_and_builtins. Used in
4390 communication with def_fn_type. */
4391static tree builtin_types[(int) BT_LAST + 1];
d2d4bdde 4392
27213ba3 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.
4396
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. */
4401
4402static void
4403def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4404{
4405 tree args = NULL, t;
4406 va_list list;
4407 int i;
4408
4409 va_start (list, n);
4410 for (i = 0; i < n; ++i)
4411 {
7d339f93 4412 builtin_type a = (builtin_type) va_arg (list, int);
27213ba3 4413 t = builtin_types[a];
4414 if (t == error_mark_node)
4415 goto egress;
4416 args = tree_cons (NULL_TREE, t, args);
4417 }
4418 va_end (list);
4419
4420 args = nreverse (args);
4421 if (!var)
4422 args = chainon (args, void_list_node);
4423
4424 t = builtin_types[ret];
4425 if (t == error_mark_node)
4426 goto egress;
4427 t = build_function_type (t, args);
4428
4429 egress:
4430 builtin_types[def] = t;
451c8e2f 4431 va_end (list);
27213ba3 4432}
4433
dce22712 4434/* Build builtin functions common to both C and C++ language
4435 frontends. */
4436
4437static void
4438c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
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]);
4474
4475#include "builtin-types.def"
4476
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
4491 builtin_types[(int) BT_LAST] = NULL_TREE;
4492
4493 c_init_attributes ();
4494
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);
4503#include "builtins.def"
4504#undef DEF_BUILTIN
4505
87eb1c28 4506 targetm.init_builtins ();
4507
471eff36 4508 build_common_builtin_nodes ();
dce22712 4509
dce22712 4510 if (flag_mudflap)
4511 mudflap_init ();
4512}
4513
9e6687c8 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. */
4517
4518static inline tree
4519c_get_ident (const char *id)
4520{
4521 return get_identifier (id);
4522}
4523
27213ba3 4524/* Build tree nodes and builtin functions common to both C and C++ language
4525 frontends. */
4526
4527void
4528c_common_nodes_and_builtins (void)
4529{
924bbf02 4530 int char16_type_size;
4531 int char32_type_size;
174fcc61 4532 int wchar_type_size;
4533 tree array_domain_type;
2d47cc32 4534 tree va_list_ref_type_node;
8a15c04a 4535 tree va_list_arg_type_node;
a66c9326 4536
174fcc61 4537 /* Define `int' and `char' first so that dbx will output them first. */
d946ea19 4538 record_builtin_type (RID_INT, NULL, integer_type_node);
174fcc61 4539 record_builtin_type (RID_CHAR, "char", char_type_node);
4540
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? */
c0f19401 4544 if (c_dialect_cxx ())
d946ea19 4545 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
174fcc61 4546 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4547 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4548 record_builtin_type (RID_MAX, "long unsigned int",
4549 long_unsigned_type_node);
6388cfe2 4550 if (int128_integer_type_node != NULL_TREE)
4551 {
4552 record_builtin_type (RID_INT128, "__int128",
4553 int128_integer_type_node);
4554 record_builtin_type (RID_MAX, "__int128 unsigned",
4555 int128_unsigned_type_node);
4556 }
c0f19401 4557 if (c_dialect_cxx ())
174fcc61 4558 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4559 record_builtin_type (RID_MAX, "long long int",
4560 long_long_integer_type_node);
4561 record_builtin_type (RID_MAX, "long long unsigned int",
4562 long_long_unsigned_type_node);
c0f19401 4563 if (c_dialect_cxx ())
174fcc61 4564 record_builtin_type (RID_MAX, "long long unsigned",
4565 long_long_unsigned_type_node);
4566 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4567 record_builtin_type (RID_MAX, "short unsigned int",
4568 short_unsigned_type_node);
c0f19401 4569 if (c_dialect_cxx ())
174fcc61 4570 record_builtin_type (RID_MAX, "unsigned short",
4571 short_unsigned_type_node);
4572
4573 /* Define both `signed char' and `unsigned char'. */
4574 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4575 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4576
771d21fa 4577 /* These are types that c_common_type_for_size and
4578 c_common_type_for_mode use. */
e60a6f7b 4579 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4580 TYPE_DECL, NULL_TREE,
dc24ddbd 4581 intQI_type_node));
e60a6f7b 4582 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4583 TYPE_DECL, NULL_TREE,
dc24ddbd 4584 intHI_type_node));
e60a6f7b 4585 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4586 TYPE_DECL, NULL_TREE,
dc24ddbd 4587 intSI_type_node));
e60a6f7b 4588 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4589 TYPE_DECL, NULL_TREE,
dc24ddbd 4590 intDI_type_node));
174fcc61 4591#if HOST_BITS_PER_WIDE_INT >= 64
f1515a39 4592 if (targetm.scalar_mode_supported_p (TImode))
e60a6f7b 4593 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4594 TYPE_DECL,
f1515a39 4595 get_identifier ("__int128_t"),
4596 intTI_type_node));
174fcc61 4597#endif
e60a6f7b 4598 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4599 TYPE_DECL, NULL_TREE,
dc24ddbd 4600 unsigned_intQI_type_node));
e60a6f7b 4601 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4602 TYPE_DECL, NULL_TREE,
dc24ddbd 4603 unsigned_intHI_type_node));
e60a6f7b 4604 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4605 TYPE_DECL, NULL_TREE,
dc24ddbd 4606 unsigned_intSI_type_node));
e60a6f7b 4607 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4608 TYPE_DECL, NULL_TREE,
dc24ddbd 4609 unsigned_intDI_type_node));
174fcc61 4610#if HOST_BITS_PER_WIDE_INT >= 64
f1515a39 4611 if (targetm.scalar_mode_supported_p (TImode))
e60a6f7b 4612 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4613 TYPE_DECL,
f1515a39 4614 get_identifier ("__uint128_t"),
4615 unsigned_intTI_type_node));
174fcc61 4616#endif
4617
4618 /* Create the widest literal types. */
4619 widest_integer_literal_type_node
4620 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
e60a6f7b 4621 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4622 TYPE_DECL, NULL_TREE,
dc24ddbd 4623 widest_integer_literal_type_node));
174fcc61 4624
4625 widest_unsigned_literal_type_node
4626 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
e60a6f7b 4627 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4628 TYPE_DECL, NULL_TREE,
dc24ddbd 4629 widest_unsigned_literal_type_node));
174fcc61 4630
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. */
654ef926 4634 size_type_node =
174fcc61 4635 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
654ef926 4636 signed_size_type_node = c_common_signed_type (size_type_node);
4637 set_sizetype (size_type_node);
174fcc61 4638
73673831 4639 pid_type_node =
4640 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4641
174fcc61 4642 build_common_tree_nodes_2 (flag_short_double);
4643
d946ea19 4644 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4645 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
174fcc61 4646 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4647
c4503c0a 4648 /* Only supported decimal floating point extension if the target
4649 actually supports underlying modes. */
48e1416a 4650 if (targetm.scalar_mode_supported_p (SDmode)
c4503c0a 4651 && targetm.scalar_mode_supported_p (DDmode)
4652 && targetm.scalar_mode_supported_p (TDmode))
4653 {
4654 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4655 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4656 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4657 }
4658
9421ebb9 4659 if (targetm.fixed_point_supported_p ())
4660 {
4661 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4662 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4663 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4664 record_builtin_type (RID_MAX, "long long _Fract",
4665 long_long_fract_type_node);
4666 record_builtin_type (RID_MAX, "unsigned short _Fract",
4667 unsigned_short_fract_type_node);
4668 record_builtin_type (RID_MAX, "unsigned _Fract",
4669 unsigned_fract_type_node);
4670 record_builtin_type (RID_MAX, "unsigned long _Fract",
4671 unsigned_long_fract_type_node);
4672 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4673 unsigned_long_long_fract_type_node);
4674 record_builtin_type (RID_MAX, "_Sat short _Fract",
4675 sat_short_fract_type_node);
4676 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4677 record_builtin_type (RID_MAX, "_Sat long _Fract",
4678 sat_long_fract_type_node);
4679 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4680 sat_long_long_fract_type_node);
4681 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4682 sat_unsigned_short_fract_type_node);
4683 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4684 sat_unsigned_fract_type_node);
4685 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4686 sat_unsigned_long_fract_type_node);
4687 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4688 sat_unsigned_long_long_fract_type_node);
4689 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4690 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4691 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4692 record_builtin_type (RID_MAX, "long long _Accum",
4693 long_long_accum_type_node);
4694 record_builtin_type (RID_MAX, "unsigned short _Accum",
4695 unsigned_short_accum_type_node);
4696 record_builtin_type (RID_MAX, "unsigned _Accum",
4697 unsigned_accum_type_node);
4698 record_builtin_type (RID_MAX, "unsigned long _Accum",
4699 unsigned_long_accum_type_node);
4700 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4701 unsigned_long_long_accum_type_node);
4702 record_builtin_type (RID_MAX, "_Sat short _Accum",
4703 sat_short_accum_type_node);
4704 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4705 record_builtin_type (RID_MAX, "_Sat long _Accum",
4706 sat_long_accum_type_node);
4707 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4708 sat_long_long_accum_type_node);
4709 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4710 sat_unsigned_short_accum_type_node);
4711 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4712 sat_unsigned_accum_type_node);
4713 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4714 sat_unsigned_long_accum_type_node);
4715 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4716 sat_unsigned_long_long_accum_type_node);
4717
4718 }
4719
e60a6f7b 4720 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4721 TYPE_DECL,
dc24ddbd 4722 get_identifier ("complex int"),
4723 complex_integer_type_node));
e60a6f7b 4724 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4725 TYPE_DECL,
dc24ddbd 4726 get_identifier ("complex float"),
4727 complex_float_type_node));
e60a6f7b 4728 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4729 TYPE_DECL,
dc24ddbd 4730 get_identifier ("complex double"),
4731 complex_double_type_node));
4732 lang_hooks.decls.pushdecl
e60a6f7b 4733 (build_decl (UNKNOWN_LOCATION,
4734 TYPE_DECL, get_identifier ("complex long double"),
20325f61 4735 complex_long_double_type_node));
174fcc61 4736
e256d445 4737 if (c_dialect_cxx ())
4738 /* For C++, make fileptr_type_node a distinct void * type until
4739 FILE type is defined. */
e086912e 4740 fileptr_type_node = build_variant_type_copy (ptr_type_node);
e256d445 4741
d946ea19 4742 record_builtin_type (RID_VOID, NULL, void_type_node);
174fcc61 4743
6753bca0 4744 /* Set the TYPE_NAME for any variants that were built before
4745 record_builtin_type gave names to the built-in types. */
4746 {
4747 tree void_name = TYPE_NAME (void_type_node);
4748 TYPE_NAME (void_type_node) = NULL_TREE;
4749 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4750 = void_name;
4751 TYPE_NAME (void_type_node) = void_name;
4752 }
4753
fbf0afd1 4754 /* This node must not be shared. */
7c446c95 4755 void_zero_node = make_node (INTEGER_CST);
d2d4bdde 4756 TREE_TYPE (void_zero_node) = void_type_node;
4757
174fcc61 4758 void_list_node = build_void_list_node ();
4759
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__. */
4765 array_domain_type = build_index_type (size_int (200));
4766
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
4771 = build_array_type (char_type_node, array_domain_type);
4772
4773 /* Likewise for arrays of ints. */
4774 int_array_type_node
4775 = build_array_type (integer_type_node, array_domain_type);
4776
d2d4bdde 4777 string_type_node = build_pointer_type (char_type_node);
4778 const_string_type_node
4779 = build_pointer_type (build_qualified_type
4780 (char_type_node, TYPE_QUAL_CONST));
4781
174fcc61 4782 /* This is special for C++ so functions can be overloaded. */
18ef7ac2 4783 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
174fcc61 4784 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4785 wchar_type_size = TYPE_PRECISION (wchar_type_node);
f3449a3c 4786 underlying_wchar_type_node = wchar_type_node;
c0f19401 4787 if (c_dialect_cxx ())
174fcc61 4788 {
78a8ed03 4789 if (TYPE_UNSIGNED (wchar_type_node))
174fcc61 4790 wchar_type_node = make_unsigned_type (wchar_type_size);
4791 else
4792 wchar_type_node = make_signed_type (wchar_type_size);
4793 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4794 }
174fcc61 4795
4796 /* This is for wide string constants. */
4797 wchar_array_type_node
4798 = build_array_type (wchar_type_node, array_domain_type);
4799
924bbf02 4800 /* Define 'char16_t'. */
4801 char16_type_node = get_identifier (CHAR16_TYPE);
4802 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4803 char16_type_size = TYPE_PRECISION (char16_type_node);
4804 if (c_dialect_cxx ())
4805 {
4806 char16_type_node = make_unsigned_type (char16_type_size);
4807
4808 if (cxx_dialect == cxx0x)
4809 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4810 }
4811
4812 /* This is for UTF-16 string constants. */
4813 char16_array_type_node
4814 = build_array_type (char16_type_node, array_domain_type);
4815
4816 /* Define 'char32_t'. */
4817 char32_type_node = get_identifier (CHAR32_TYPE);
4818 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4819 char32_type_size = TYPE_PRECISION (char32_type_node);
4820 if (c_dialect_cxx ())
4821 {
4822 char32_type_node = make_unsigned_type (char32_type_size);
4823
4824 if (cxx_dialect == cxx0x)
4825 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4826 }
4827
4828 /* This is for UTF-32 string constants. */
4829 char32_array_type_node
4830 = build_array_type (char32_type_node, array_domain_type);
4831
6bf5ed8d 4832 wint_type_node =
4833 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4834
4835 intmax_type_node =
4836 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4837 uintmax_type_node =
4838 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4839
f3449a3c 4840 if (SIG_ATOMIC_TYPE)
4841 sig_atomic_type_node =
9e6687c8 4842 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
f3449a3c 4843 if (INT8_TYPE)
4844 int8_type_node =
9e6687c8 4845 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
f3449a3c 4846 if (INT16_TYPE)
4847 int16_type_node =
9e6687c8 4848 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
f3449a3c 4849 if (INT32_TYPE)
4850 int32_type_node =
9e6687c8 4851 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
f3449a3c 4852 if (INT64_TYPE)
4853 int64_type_node =
9e6687c8 4854 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
f3449a3c 4855 if (UINT8_TYPE)
4856 uint8_type_node =
9e6687c8 4857 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
f3449a3c 4858 if (UINT16_TYPE)
4859 uint16_type_node =
9e6687c8 4860 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
f3449a3c 4861 if (UINT32_TYPE)
4862 c_uint32_type_node =
9e6687c8 4863 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
f3449a3c 4864 if (UINT64_TYPE)
4865 c_uint64_type_node =
9e6687c8 4866 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
f3449a3c 4867 if (INT_LEAST8_TYPE)
4868 int_least8_type_node =
9e6687c8 4869 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
f3449a3c 4870 if (INT_LEAST16_TYPE)
4871 int_least16_type_node =
9e6687c8 4872 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
f3449a3c 4873 if (INT_LEAST32_TYPE)
4874 int_least32_type_node =
9e6687c8 4875 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
f3449a3c 4876 if (INT_LEAST64_TYPE)
4877 int_least64_type_node =
9e6687c8 4878 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
f3449a3c 4879 if (UINT_LEAST8_TYPE)
4880 uint_least8_type_node =
9e6687c8 4881 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
f3449a3c 4882 if (UINT_LEAST16_TYPE)
4883 uint_least16_type_node =
9e6687c8 4884 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
f3449a3c 4885 if (UINT_LEAST32_TYPE)
4886 uint_least32_type_node =
9e6687c8 4887 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
f3449a3c 4888 if (UINT_LEAST64_TYPE)
4889 uint_least64_type_node =
9e6687c8 4890 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
f3449a3c 4891 if (INT_FAST8_TYPE)
4892 int_fast8_type_node =
9e6687c8 4893 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
f3449a3c 4894 if (INT_FAST16_TYPE)
4895 int_fast16_type_node =
9e6687c8 4896 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
f3449a3c 4897 if (INT_FAST32_TYPE)
4898 int_fast32_type_node =
9e6687c8 4899 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
f3449a3c 4900 if (INT_FAST64_TYPE)
4901 int_fast64_type_node =
9e6687c8 4902 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
f3449a3c 4903 if (UINT_FAST8_TYPE)
4904 uint_fast8_type_node =
9e6687c8 4905 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
f3449a3c 4906 if (UINT_FAST16_TYPE)
4907 uint_fast16_type_node =
9e6687c8 4908 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
f3449a3c 4909 if (UINT_FAST32_TYPE)
4910 uint_fast32_type_node =
9e6687c8 4911 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
f3449a3c 4912 if (UINT_FAST64_TYPE)
4913 uint_fast64_type_node =
9e6687c8 4914 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
f3449a3c 4915 if (INTPTR_TYPE)
4916 intptr_type_node =
9e6687c8 4917 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
f3449a3c 4918 if (UINTPTR_TYPE)
4919 uintptr_type_node =
9e6687c8 4920 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
f3449a3c 4921
6bf5ed8d 4922 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4923 ptrdiff_type_node
4924 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
11773141 4925 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
6bf5ed8d 4926
dc24ddbd 4927 lang_hooks.decls.pushdecl
e60a6f7b 4928 (build_decl (UNKNOWN_LOCATION,
4929 TYPE_DECL, get_identifier ("__builtin_va_list"),
20325f61 4930 va_list_type_node));
202d6e5f 4931 if (targetm.enum_va_list_p)
acd6f472 4932 {
4933 int l;
4934 const char *pname;
4935 tree ptype;
5f57a8b1 4936
202d6e5f 4937 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
acd6f472 4938 {
4939 lang_hooks.decls.pushdecl
4940 (build_decl (UNKNOWN_LOCATION,
4941 TYPE_DECL, get_identifier (pname),
4942 ptype));
4943
4944 }
4945 }
8a15c04a 4946
8a15c04a 4947 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2d47cc32 4948 {
4949 va_list_arg_type_node = va_list_ref_type_node =
4950 build_pointer_type (TREE_TYPE (va_list_type_node));
4951 }
8a15c04a 4952 else
2d47cc32 4953 {
4954 va_list_arg_type_node = va_list_type_node;
4955 va_list_ref_type_node = build_reference_type (va_list_type_node);
4956 }
1cae46be 4957
dce22712 4958 if (!flag_preprocess_only)
4959 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
ffa8918b 4960
5c62f199 4961 main_identifier_node = get_identifier ("main");
ae84079f 4962
4963 /* Create the built-in __null node. It is important that this is
4964 not shared. */
4965 null_node = make_node (INTEGER_CST);
4966 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
27213ba3 4967
4968 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4969 memset (builtin_types, 0, sizeof (builtin_types));
72040e7e 4970}
a66c9326 4971
79b01846 4972/* The number of named compound-literals generated thus far. */
4973static GTY(()) int compound_literal_number;
4974
4975/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4976
4977void
4978set_compound_literal_name (tree decl)
4979{
4980 char *name;
4981 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4982 compound_literal_number);
4983 compound_literal_number++;
4984 DECL_NAME (decl) = get_identifier (name);
4985}
4986
a66c9326 4987tree
e60a6f7b 4988build_va_arg (location_t loc, tree expr, tree type)
a66c9326 4989{
e60a6f7b 4990 expr = build1 (VA_ARG_EXPR, type, expr);
4991 SET_EXPR_LOCATION (expr, loc);
4992 return expr;
a66c9326 4993}
0d4238dc 4994
4995
dd878098 4996/* Linked list of disabled built-in functions. */
4997
4998typedef struct disabled_builtin
4999{
5000 const char *name;
5001 struct disabled_builtin *next;
5002} disabled_builtin;
5003static disabled_builtin *disabled_builtins = NULL;
5004
1cae46be 5005static bool builtin_function_disabled_p (const char *);
dd878098 5006
5007/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5008 begins with "__builtin_", give an error. */
5009
5010void
1cae46be 5011disable_builtin_function (const char *name)
dd878098 5012{
5013 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
b0b1af64 5014 error ("cannot disable built-in function %qs", name);
dd878098 5015 else
5016 {
e85905e5 5017 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5018 new_disabled_builtin->name = name;
5019 new_disabled_builtin->next = disabled_builtins;
5020 disabled_builtins = new_disabled_builtin;
dd878098 5021 }
5022}
5023
5024
5025/* Return true if the built-in function NAME has been disabled, false
5026 otherwise. */
5027
5028static bool
1cae46be 5029builtin_function_disabled_p (const char *name)
dd878098 5030{
5031 disabled_builtin *p;
5032 for (p = disabled_builtins; p != NULL; p = p->next)
5033 {
5034 if (strcmp (name, p->name) == 0)
5035 return true;
5036 }
5037 return false;
5038}
5039
5040
3237155d 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. */
0d4238dc 5045
3237155d 5046static void
5047def_builtin_1 (enum built_in_function fncode,
5048 const char *name,
5049 enum built_in_class fnclass,
5050 tree fntype, tree libtype,
5051 bool both_p, bool fallback_p, bool nonansi_p,
5052 tree fnattrs, bool implicit_p)
0d4238dc 5053{
3237155d 5054 tree decl;
5055 const char *libname;
5056
27213ba3 5057 if (fntype == error_mark_node)
5058 return;
5059
3237155d 5060 gcc_assert ((!both_p && !fallback_p)
5061 || !strncmp (name, "__builtin_",
5062 strlen ("__builtin_")));
5063
5064 libname = name + strlen ("__builtin_");
54be5d7e 5065 decl = add_builtin_function (name, fntype, fncode, fnclass,
5066 (fallback_p ? libname : NULL),
5067 fnattrs);
3237155d 5068 if (both_p
5069 && !flag_no_builtin && !builtin_function_disabled_p (libname)
dd878098 5070 && !(nonansi_p && flag_no_nonansi_builtin))
54be5d7e 5071 add_builtin_function (libname, libtype, fncode, fnclass,
5072 NULL, fnattrs);
a40609e6 5073
3237155d 5074 built_in_decls[(int) fncode] = decl;
5075 if (implicit_p)
5076 implicit_built_in_decls[(int) fncode] = decl;
0d4238dc 5077}
e94026da 5078\f
d7aeef06 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. */
5081
5082bool
9f627b1a 5083c_promoting_integer_type_p (const_tree t)
d7aeef06 5084{
5085 switch (TREE_CODE (t))
5086 {
5087 case INTEGER_TYPE:
5088 return (TYPE_MAIN_VARIANT (t) == char_type_node
5089 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5090 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5091 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
7aa1e6eb 5092 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5093 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
d7aeef06 5094
5095 case ENUMERAL_TYPE:
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. */
5099 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5100
5101 case BOOLEAN_TYPE:
5102 return 1;
5103
5104 default:
5105 return 0;
5106 }
5107}
5108
e94026da 5109/* Return 1 if PARMS specifies a fixed number of parameters
5110 and none of their types is affected by default promotions. */
5111
5112int
9f627b1a 5113self_promoting_args_p (const_tree parms)
e94026da 5114{
9f627b1a 5115 const_tree t;
e94026da 5116 for (t = parms; t; t = TREE_CHAIN (t))
5117 {
19cb6b50 5118 tree type = TREE_VALUE (t);
43f74bc4 5119
e1d8e198 5120 if (type == error_mark_node)
5121 continue;
5122
e94026da 5123 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5124 return 0;
5125
5126 if (type == 0)
5127 return 0;
5128
5129 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5130 return 0;
5131
d7aeef06 5132 if (c_promoting_integer_type_p (type))
e94026da 5133 return 0;
5134 }
5135 return 1;
5136}
605fb01e 5137
c10de5e7 5138/* Recursively remove any '*' or '&' operator from TYPE. */
5139tree
5140strip_pointer_operator (tree t)
5141{
5142 while (POINTER_TYPE_P (t))
5143 t = TREE_TYPE (t);
5144 return t;
5145}
5146
57a0ed23 5147/* Recursively remove pointer or array type from TYPE. */
5148tree
5149strip_pointer_or_array_types (tree t)
5150{
5151 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5152 t = TREE_TYPE (t);
5153 return t;
5154}
5155
e41f0d80 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. */
5160
5161int
1cae46be 5162case_compare (splay_tree_key k1, splay_tree_key k2)
e41f0d80 5163{
5164 /* Consider a NULL key (such as arises with a `default' label) to be
5165 smaller than anything else. */
5166 if (!k1)
5167 return k2 ? -1 : 0;
5168 else if (!k2)
5169 return k1 ? 1 : 0;
5170
5171 return tree_int_cst_compare ((tree) k1, (tree) k2);
5172}
5173
e60a6f7b 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. */
e41f0d80 5183
5184tree
e60a6f7b 5185c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
2ca392fd 5186 tree low_value, tree high_value)
e41f0d80 5187{
5188 tree type;
5189 tree label;
5190 tree case_label;
5191 splay_tree_node node;
5192
5193 /* Create the LABEL_DECL itself. */
e60a6f7b 5194 label = create_artificial_label (loc);
e41f0d80 5195
5196 /* If there was an error processing the switch condition, bail now
5197 before we get more confused. */
5198 if (!cond || cond == error_mark_node)
4ee9c684 5199 goto error_out;
e41f0d80 5200
1cae46be 5201 if ((low_value && TREE_TYPE (low_value)
5202 && POINTER_TYPE_P (TREE_TYPE (low_value)))
e41f0d80 5203 || (high_value && TREE_TYPE (high_value)
5204 && POINTER_TYPE_P (TREE_TYPE (high_value))))
b96dc121 5205 {
e60a6f7b 5206 error_at (loc, "pointers are not permitted as case values");
b96dc121 5207 goto error_out;
5208 }
e41f0d80 5209
5210 /* Case ranges are a GNU extension. */
8864917d 5211 if (high_value)
48e1416a 5212 pedwarn (loc, OPT_pedantic,
8864917d 5213 "range expressions in switch statements are non-standard");
e41f0d80 5214
5215 type = TREE_TYPE (cond);
5216 if (low_value)
5217 {
5218 low_value = check_case_value (low_value);
5219 low_value = convert_and_check (type, low_value);
96722196 5220 if (low_value == error_mark_node)
5221 goto error_out;
e41f0d80 5222 }
5223 if (high_value)
5224 {
5225 high_value = check_case_value (high_value);
5226 high_value = convert_and_check (type, high_value);
96722196 5227 if (high_value == error_mark_node)
5228 goto error_out;
e41f0d80 5229 }
5230
96722196 5231 if (low_value && high_value)
5232 {
5233 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
a0c938f0 5234 really a case range, even though it was written that way.
5235 Remove the HIGH_VALUE to simplify later processing. */
96722196 5236 if (tree_int_cst_equal (low_value, high_value))
5237 high_value = NULL_TREE;
5238 else if (!tree_int_cst_lt (low_value, high_value))
e60a6f7b 5239 warning_at (loc, 0, "empty range specified");
96722196 5240 }
e41f0d80 5241
2ca392fd 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. */
5245 if (low_value
84166705 5246 && !check_case_bounds (type, orig_type,
5247 &low_value, high_value ? &high_value : NULL))
2ca392fd 5248 return NULL_TREE;
5249
e41f0d80 5250 /* Look up the LOW_VALUE in the table of case labels we already
5251 have. */
5252 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
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. */
5256 if (!node && (low_value || high_value))
5257 {
5258 splay_tree_node low_bound;
5259 splay_tree_node high_bound;
5260
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. */
5268 low_bound = splay_tree_predecessor (cases,
5269 (splay_tree_key) low_value);
5270 high_bound = splay_tree_successor (cases,
5271 (splay_tree_key) low_value);
5272
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. */
5276 if (low_bound
5277 && CASE_HIGH ((tree) low_bound->value)
5278 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5279 low_value) >= 0)
5280 node = low_bound;
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. */
1cae46be 5285 else if (high_bound
e41f0d80 5286 && high_value
5287 && (tree_int_cst_compare ((tree) high_bound->key,
5288 high_value)
5289 <= 0))
5290 node = high_bound;
5291 }
5292 /* If there was an overlap, issue an error. */
5293 if (node)
5294 {
eaae3b75 5295 tree duplicate = CASE_LABEL ((tree) node->value);
e41f0d80 5296
5297 if (high_value)
5298 {
e60a6f7b 5299 error_at (loc, "duplicate (or overlapping) case value");
5300 error_at (DECL_SOURCE_LOCATION (duplicate),
5301 "this is the first entry overlapping that value");
e41f0d80 5302 }
5303 else if (low_value)
5304 {
e60a6f7b 5305 error_at (loc, "duplicate case value") ;
5306 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
e41f0d80 5307 }
5308 else
5309 {
e60a6f7b 5310 error_at (loc, "multiple default labels in one switch");
5311 error_at (DECL_SOURCE_LOCATION (duplicate),
5312 "this is the first default label");
e41f0d80 5313 }
4ee9c684 5314 goto error_out;
e41f0d80 5315 }
5316
5317 /* Add a CASE_LABEL to the statement-tree. */
e60a6f7b 5318 case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
e41f0d80 5319 /* Register this case label in the splay tree. */
1cae46be 5320 splay_tree_insert (cases,
e41f0d80 5321 (splay_tree_key) low_value,
5322 (splay_tree_value) case_label);
5323
5324 return case_label;
4ee9c684 5325
5326 error_out:
daf6dff5 5327 /* Add a label so that the back-end doesn't think that the beginning of
4ee9c684 5328 the switch is unreachable. Note that we do not add a case label, as
a53ff4c1 5329 that just leads to duplicates and thence to failure later on. */
4ee9c684 5330 if (!cases->root)
5331 {
e60a6f7b 5332 tree t = create_artificial_label (loc);
5333 add_stmt (build_stmt (loc, LABEL_EXPR, t));
4ee9c684 5334 }
5335 return error_mark_node;
5336}
5337
5338/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5339 Used to verify that case values match up with enumerator values. */
5340
5341static void
5342match_case_to_enum_1 (tree key, tree type, tree label)
5343{
5344 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5345
5346 /* ??? Not working too hard to print the double-word value.
5347 Should perhaps be done with %lwd in the diagnostic routines? */
5348 if (TREE_INT_CST_HIGH (key) == 0)
5349 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5350 TREE_INT_CST_LOW (key));
5351 else if (!TYPE_UNSIGNED (type)
5352 && TREE_INT_CST_HIGH (key) == -1
5353 && TREE_INT_CST_LOW (key) != 0)
5354 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5355 -TREE_INT_CST_LOW (key));
5356 else
5357 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
7df7561b 5358 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5359 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4ee9c684 5360
5361 if (TYPE_NAME (type) == 0)
712d2297 5362 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5363 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5364 "case value %qs not in enumerated type",
5365 buf);
4ee9c684 5366 else
712d2297 5367 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5368 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5369 "case value %qs not in enumerated type %qT",
5370 buf, type);
4ee9c684 5371}
5372
359d87c6 5373/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5374 Used to verify that case values match up with enumerator values. */
5375
4ee9c684 5376static int
5377match_case_to_enum (splay_tree_node node, void *data)
5378{
5379 tree label = (tree) node->value;
4fd61bc6 5380 tree type = (tree) data;
4ee9c684 5381
5382 /* Skip default case. */
5383 if (!CASE_LOW (label))
5384 return 0;
5385
359d87c6 5386 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4ee9c684 5387 when we did our enum->case scan. Reset our scratch bit after. */
359d87c6 5388 if (!CASE_LOW_SEEN (label))
4ee9c684 5389 match_case_to_enum_1 (CASE_LOW (label), type, label);
5390 else
359d87c6 5391 CASE_LOW_SEEN (label) = 0;
4ee9c684 5392
359d87c6 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. */
4ee9c684 5396 if (CASE_HIGH (label))
5397 {
359d87c6 5398 if (!CASE_HIGH_SEEN (label))
5399 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5400 else
5401 CASE_HIGH_SEEN (label) = 0;
4ee9c684 5402 }
5403
5404 return 0;
5405}
5406
e7911019 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. */
4ee9c684 5413
e7911019 5414void
5415c_do_switch_warnings (splay_tree cases, location_t switch_location,
5416 tree type, tree cond)
4ee9c684 5417{
b27ac6b5 5418 splay_tree_node default_node;
359d87c6 5419 splay_tree_node node;
5420 tree chain;
4ee9c684 5421
5422 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5423 return;
5424
4ee9c684 5425 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
8b6866af 5426 if (!default_node)
5fb6a912 5427 warning_at (switch_location, OPT_Wswitch_default,
5428 "switch missing default case");
4ee9c684 5429
359d87c6 5430 /* From here on, we only care about about enumerated types. */
5431 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5432 return;
5433
561017b5 5434 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5435 if (!warn_switch_enum && !warn_switch)
359d87c6 5436 return;
5437
561017b5 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. */
5442
359d87c6 5443 /* Clearing COND if it is not an integer constant simplifies
5444 the tests inside the loop below. */
5445 if (TREE_CODE (cond) != INTEGER_CST)
5446 cond = NULL_TREE;
5447
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. */
4ee9c684 5452
359d87c6 5453 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5454 {
5455 tree value = TREE_VALUE (chain);
3f00a6c0 5456 if (TREE_CODE (value) == CONST_DECL)
5457 value = DECL_INITIAL (value);
359d87c6 5458 node = splay_tree_lookup (cases, (splay_tree_key) value);
5459 if (node)
4ee9c684 5460 {
359d87c6 5461 /* Mark the CASE_LOW part of the case entry as seen. */
5462 tree label = (tree) node->value;
5463 CASE_LOW_SEEN (label) = 1;
5464 continue;
5465 }
5466
5467 /* Even though there wasn't an exact match, there might be a
f0b5f617 5468 case range which includes the enumerator's value. */
359d87c6 5469 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5470 if (node && CASE_HIGH ((tree) node->value))
5471 {
5472 tree label = (tree) node->value;
5473 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5474 if (cmp >= 0)
4ee9c684 5475 {
359d87c6 5476 /* If we match the upper bound exactly, mark the CASE_HIGH
5477 part of the case entry as seen. */
5478 if (cmp == 0)
5479 CASE_HIGH_SEEN (label) = 1;
5480 continue;
4ee9c684 5481 }
5482 }
5483
359d87c6 5484 /* We've now determined that this enumerated literal isn't
5485 handled by the case labels of the switch statement. */
4ee9c684 5486
359d87c6 5487 /* If the switch expression is a constant, we only really care
5488 about whether that constant is handled by the switch. */
5489 if (cond && tree_int_cst_compare (cond, value))
5490 continue;
4ee9c684 5491
6cbbbc89 5492 /* If there is a default_node, the only relevant option is
561017b5 5493 Wswitch-enum. Otherwise, if both are enabled then we prefer
6cbbbc89 5494 to warn using -Wswitch because -Wswitch is enabled by -Wall
5495 while -Wswitch-enum is explicit. */
561017b5 5496 warning_at (switch_location,
5497 (default_node || !warn_switch
5498 ? OPT_Wswitch_enum
5499 : OPT_Wswitch),
5500 "enumeration value %qE not handled in switch",
5501 TREE_PURPOSE (chain));
4ee9c684 5502 }
359d87c6 5503
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.
5507
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. */
6cbbbc89 5512
359d87c6 5513 splay_tree_foreach (cases, match_case_to_enum, type);
e41f0d80 5514}
5515
9dd48740 5516/* Finish an expression taking the address of LABEL (an
dda49785 5517 IDENTIFIER_NODE). Returns an expression for the address.
5518
5519 LOC is the location for the expression returned. */
d0a47c8d 5520
1cae46be 5521tree
dda49785 5522finish_label_address_expr (tree label, location_t loc)
d0a47c8d 5523{
5524 tree result;
5525
21ca8540 5526 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
d0a47c8d 5527
9dd48740 5528 if (label == error_mark_node)
5529 return error_mark_node;
5530
d0a47c8d 5531 label = lookup_label (label);
5532 if (label == NULL_TREE)
5533 result = null_pointer_node;
5534 else
5535 {
5536 TREE_USED (label) = 1;
5537 result = build1 (ADDR_EXPR, ptr_type_node, label);
344cd9b2 5538 /* The current function is not necessarily uninlinable.
d0a47c8d 5539 Computed gotos are incompatible with inlining, but the value
5540 here could be used only in a diagnostic, for example. */
dda49785 5541 protected_set_expr_location (result, loc);
d0a47c8d 5542 }
5543
5544 return result;
5545}
4f9a1c9b 5546\f
5547
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++). */
5551tree
1cae46be 5552boolean_increment (enum tree_code code, tree arg)
4f9a1c9b 5553{
5554 tree val;
69db191c 5555 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
c0f19401 5556
4f9a1c9b 5557 arg = stabilize_reference (arg);
5558 switch (code)
5559 {
5560 case PREINCREMENT_EXPR:
14ae0310 5561 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4f9a1c9b 5562 break;
5563 case POSTINCREMENT_EXPR:
14ae0310 5564 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4f9a1c9b 5565 arg = save_expr (arg);
14ae0310 5566 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5567 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4f9a1c9b 5568 break;
5569 case PREDECREMENT_EXPR:
14ae0310 5570 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
389dd41b 5571 invert_truthvalue_loc (input_location, arg));
4f9a1c9b 5572 break;
5573 case POSTDECREMENT_EXPR:
14ae0310 5574 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
389dd41b 5575 invert_truthvalue_loc (input_location, arg));
4f9a1c9b 5576 arg = save_expr (arg);
14ae0310 5577 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5578 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4f9a1c9b 5579 break;
5580 default:
231bd014 5581 gcc_unreachable ();
4f9a1c9b 5582 }
5583 TREE_SIDE_EFFECTS (val) = 1;
5584 return val;
5585}
76a6e674 5586\f
f3449a3c 5587/* Built-in macros for stddef.h and stdint.h, that require macros
5588 defined in this file. */
79cf3ec1 5589void
1cae46be 5590c_stddef_cpp_builtins(void)
1ed9d5f5 5591{
63994318 5592 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5593 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5594 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5595 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
36bccbfc 5596 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5597 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
b0726616 5598 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5599 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
f3449a3c 5600 if (SIG_ATOMIC_TYPE)
5601 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5602 if (INT8_TYPE)
5603 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5604 if (INT16_TYPE)
5605 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5606 if (INT32_TYPE)
5607 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5608 if (INT64_TYPE)
5609 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5610 if (UINT8_TYPE)
5611 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5612 if (UINT16_TYPE)
5613 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5614 if (UINT32_TYPE)
5615 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5616 if (UINT64_TYPE)
5617 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5618 if (INT_LEAST8_TYPE)
5619 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5620 if (INT_LEAST16_TYPE)
5621 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5622 if (INT_LEAST32_TYPE)
5623 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5624 if (INT_LEAST64_TYPE)
5625 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5626 if (UINT_LEAST8_TYPE)
5627 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5628 if (UINT_LEAST16_TYPE)
5629 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5630 if (UINT_LEAST32_TYPE)
5631 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5632 if (UINT_LEAST64_TYPE)
5633 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5634 if (INT_FAST8_TYPE)
5635 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5636 if (INT_FAST16_TYPE)
5637 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5638 if (INT_FAST32_TYPE)
5639 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5640 if (INT_FAST64_TYPE)
5641 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5642 if (UINT_FAST8_TYPE)
5643 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5644 if (UINT_FAST16_TYPE)
5645 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5646 if (UINT_FAST32_TYPE)
5647 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5648 if (UINT_FAST64_TYPE)
5649 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5650 if (INTPTR_TYPE)
5651 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5652 if (UINTPTR_TYPE)
5653 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
574006c3 5654}
5655
7d3b509a 5656static void
1cae46be 5657c_init_attributes (void)
7d3b509a 5658{
5659 /* Fill in the built_in_attributes array. */
7c446c95 5660#define DEF_ATTR_NULL_TREE(ENUM) \
7d3b509a 5661 built_in_attributes[(int) ENUM] = NULL_TREE;
7c446c95 5662#define DEF_ATTR_INT(ENUM, VALUE) \
7016c612 5663 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
7d3b509a 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]);
7d3b509a 5671#include "builtin-attrs.def"
5672#undef DEF_ATTR_NULL_TREE
5673#undef DEF_ATTR_INT
5674#undef DEF_ATTR_IDENT
5675#undef DEF_ATTR_TREE_LIST
76a6e674 5676}
5f3cead1 5677
33199a81 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. */
5680
5681bool
47b19b94 5682attribute_takes_identifier_p (const_tree attr_id)
33199a81 5683{
9bf1c74e 5684 const struct attribute_spec *spec = lookup_attribute_spec (attr_id);
02cb1060 5685 if (spec == NULL)
5686 /* Unknown attribute that we'll end up ignoring, return true so we
5687 don't complain about an identifier argument. */
5688 return true;
5689 else if (!strcmp ("mode", spec->name)
5690 || !strcmp ("format", spec->name)
5691 || !strcmp ("cleanup", spec->name))
47b19b94 5692 return true;
5693 else
5694 return targetm.attribute_takes_identifier_p (attr_id);
33199a81 5695}
5696
f8e93a2e 5697/* Attribute handlers common to C front ends. */
5698
5699/* Handle a "packed" attribute; arguments as in
5700 struct attribute_spec.handler. */
5701
5702static tree
9a03a746 5703handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
09347743 5704 int flags, bool *no_add_attrs)
f8e93a2e 5705{
f40175cb 5706 if (TYPE_P (*node))
f8e93a2e 5707 {
5708 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 5709 *node = build_variant_type_copy (*node);
f40175cb 5710 TYPE_PACKED (*node) = 1;
f8e93a2e 5711 }
5712 else if (TREE_CODE (*node) == FIELD_DECL)
c2ab04f9 5713 {
9fd767c5 5714 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5715 /* Still pack bitfields. */
5716 && ! DECL_INITIAL (*node))
c2ab04f9 5717 warning (OPT_Wattributes,
5718 "%qE attribute ignored for field of type %qT",
5719 name, TREE_TYPE (*node));
5720 else
5721 DECL_PACKED (*node) = 1;
5722 }
f8e93a2e 5723 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
f40175cb 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. */
f8e93a2e 5727 else
5728 {
9b2d6d13 5729 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5730 *no_add_attrs = true;
5731 }
5732
5733 return NULL_TREE;
5734}
5735
5736/* Handle a "nocommon" attribute; arguments as in
5737 struct attribute_spec.handler. */
5738
5739static tree
1cae46be 5740handle_nocommon_attribute (tree *node, tree name,
9a03a746 5741 tree ARG_UNUSED (args),
5742 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5743{
5744 if (TREE_CODE (*node) == VAR_DECL)
5745 DECL_COMMON (*node) = 0;
5746 else
5747 {
9b2d6d13 5748 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5749 *no_add_attrs = true;
5750 }
5751
5752 return NULL_TREE;
5753}
5754
5755/* Handle a "common" attribute; arguments as in
5756 struct attribute_spec.handler. */
5757
5758static tree
9a03a746 5759handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5760 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5761{
5762 if (TREE_CODE (*node) == VAR_DECL)
5763 DECL_COMMON (*node) = 1;
5764 else
5765 {
9b2d6d13 5766 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5767 *no_add_attrs = true;
5768 }
5769
5770 return NULL_TREE;
5771}
5772
5773/* Handle a "noreturn" attribute; arguments as in
5774 struct attribute_spec.handler. */
5775
5776static tree
9a03a746 5777handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5778 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5779{
5780 tree type = TREE_TYPE (*node);
5781
5782 /* See FIXME comment in c_common_attribute_table. */
8c582e4f 5783 if (TREE_CODE (*node) == FUNCTION_DECL
5784 || objc_method_decl (TREE_CODE (*node)))
f8e93a2e 5785 TREE_THIS_VOLATILE (*node) = 1;
5786 else if (TREE_CODE (type) == POINTER_TYPE
5787 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5788 TREE_TYPE (*node)
5789 = build_pointer_type
5790 (build_type_variant (TREE_TYPE (type),
71bda45d 5791 TYPE_READONLY (TREE_TYPE (type)), 1));
f8e93a2e 5792 else
5793 {
9b2d6d13 5794 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5795 *no_add_attrs = true;
5796 }
5797
5798 return NULL_TREE;
5799}
5800
5de92639 5801/* Handle a "hot" and attribute; arguments as in
5802 struct attribute_spec.handler. */
5803
5804static tree
5805handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
46f8e3b0 5806 int ARG_UNUSED (flags), bool *no_add_attrs)
5de92639 5807{
5808 if (TREE_CODE (*node) == FUNCTION_DECL)
5809 {
5810 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5811 {
5812 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5813 name, "cold");
5814 *no_add_attrs = true;
5815 }
24470055 5816 /* Most of the rest of the hot processing is done later with
5817 lookup_attribute. */
5de92639 5818 }
5819 else
5820 {
5821 warning (OPT_Wattributes, "%qE attribute ignored", name);
5822 *no_add_attrs = true;
5823 }
5824
5825 return NULL_TREE;
5826}
5827/* Handle a "cold" and attribute; arguments as in
5828 struct attribute_spec.handler. */
5829
5830static tree
5831handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5832 int ARG_UNUSED (flags), bool *no_add_attrs)
5833{
5834 if (TREE_CODE (*node) == FUNCTION_DECL)
5835 {
5836 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5837 {
5838 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5839 name, "hot");
5840 *no_add_attrs = true;
5841 }
24470055 5842 /* Most of the rest of the cold processing is done later with
5843 lookup_attribute. */
5de92639 5844 }
5845 else
5846 {
5847 warning (OPT_Wattributes, "%qE attribute ignored", name);
5848 *no_add_attrs = true;
5849 }
5850
5851 return NULL_TREE;
5852}
5853
f8e93a2e 5854/* Handle a "noinline" attribute; arguments as in
5855 struct attribute_spec.handler. */
5856
5857static tree
1cae46be 5858handle_noinline_attribute (tree *node, tree name,
9a03a746 5859 tree ARG_UNUSED (args),
5860 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5861{
5862 if (TREE_CODE (*node) == FUNCTION_DECL)
5863 DECL_UNINLINABLE (*node) = 1;
5864 else
5865 {
9b2d6d13 5866 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5867 *no_add_attrs = true;
5868 }
5869
5870 return NULL_TREE;
5871}
5872
bdb1f0d1 5873/* Handle a "noclone" attribute; arguments as in
5874 struct attribute_spec.handler. */
5875
5876static tree
5877handle_noclone_attribute (tree *node, tree name,
5878 tree ARG_UNUSED (args),
5879 int ARG_UNUSED (flags), bool *no_add_attrs)
5880{
5881 if (TREE_CODE (*node) != FUNCTION_DECL)
5882 {
5883 warning (OPT_Wattributes, "%qE attribute ignored", name);
5884 *no_add_attrs = true;
5885 }
5886
5887 return NULL_TREE;
5888}
5889
f8e93a2e 5890/* Handle a "always_inline" attribute; arguments as in
5891 struct attribute_spec.handler. */
5892
5893static tree
1cae46be 5894handle_always_inline_attribute (tree *node, tree name,
9a03a746 5895 tree ARG_UNUSED (args),
5896 int ARG_UNUSED (flags),
09347743 5897 bool *no_add_attrs)
f8e93a2e 5898{
5899 if (TREE_CODE (*node) == FUNCTION_DECL)
5900 {
ebb7d626 5901 /* Set the attribute and mark it for disregarding inline
5902 limits. */
5903 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
f8e93a2e 5904 }
5905 else
5906 {
9b2d6d13 5907 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5908 *no_add_attrs = true;
541e4101 5909 }
5910
5911 return NULL_TREE;
5912}
5913
5914/* Handle a "gnu_inline" attribute; arguments as in
5915 struct attribute_spec.handler. */
5916
5917static tree
5918handle_gnu_inline_attribute (tree *node, tree name,
5919 tree ARG_UNUSED (args),
5920 int ARG_UNUSED (flags),
5921 bool *no_add_attrs)
5922{
5923 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5924 {
5925 /* Do nothing else, just set the attribute. We'll get at
5926 it later with lookup_attribute. */
5927 }
5928 else
5929 {
5930 warning (OPT_Wattributes, "%qE attribute ignored", name);
5931 *no_add_attrs = true;
7bd95dfd 5932 }
5933
5934 return NULL_TREE;
5935}
5936
5937/* Handle a "leaf" attribute; arguments as in
5938 struct attribute_spec.handler. */
5939
5940static tree
5941handle_leaf_attribute (tree *node, tree name,
5942 tree ARG_UNUSED (args),
5943 int ARG_UNUSED (flags), bool *no_add_attrs)
5944{
5945 if (TREE_CODE (*node) != FUNCTION_DECL)
5946 {
5947 warning (OPT_Wattributes, "%qE attribute ignored", name);
5948 *no_add_attrs = true;
5949 }
5950 if (!TREE_PUBLIC (*node))
5951 {
5952 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
5953 *no_add_attrs = true;
f8e93a2e 5954 }
5955
5956 return NULL_TREE;
5957}
5958
1b16fc45 5959/* Handle an "artificial" attribute; arguments as in
5960 struct attribute_spec.handler. */
5961
5962static tree
5963handle_artificial_attribute (tree *node, tree name,
5964 tree ARG_UNUSED (args),
5965 int ARG_UNUSED (flags),
5966 bool *no_add_attrs)
5967{
5968 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5969 {
5970 /* Do nothing else, just set the attribute. We'll get at
5971 it later with lookup_attribute. */
5972 }
5973 else
5974 {
5975 warning (OPT_Wattributes, "%qE attribute ignored", name);
5976 *no_add_attrs = true;
5977 }
5978
5979 return NULL_TREE;
5980}
5981
0cdd9887 5982/* Handle a "flatten" attribute; arguments as in
5983 struct attribute_spec.handler. */
5984
5985static tree
5986handle_flatten_attribute (tree *node, tree name,
a0c938f0 5987 tree args ATTRIBUTE_UNUSED,
5988 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
0cdd9887 5989{
5990 if (TREE_CODE (*node) == FUNCTION_DECL)
5991 /* Do nothing else, just set the attribute. We'll get at
5992 it later with lookup_attribute. */
5993 ;
5994 else
5995 {
5996 warning (OPT_Wattributes, "%qE attribute ignored", name);
5997 *no_add_attrs = true;
5998 }
5999
6000 return NULL_TREE;
6001}
6002
10fc867f 6003/* Handle a "warning" or "error" attribute; arguments as in
6004 struct attribute_spec.handler. */
6005
6006static tree
6007handle_error_attribute (tree *node, tree name, tree args,
6008 int ARG_UNUSED (flags), bool *no_add_attrs)
6009{
6010 if (TREE_CODE (*node) == FUNCTION_DECL
6011 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6012 /* Do nothing else, just set the attribute. We'll get at
6013 it later with lookup_attribute. */
6014 ;
6015 else
6016 {
6017 warning (OPT_Wattributes, "%qE attribute ignored", name);
6018 *no_add_attrs = true;
6019 }
6020
6021 return NULL_TREE;
6022}
0cdd9887 6023
f8e93a2e 6024/* Handle a "used" attribute; arguments as in
6025 struct attribute_spec.handler. */
6026
6027static tree
9a03a746 6028handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6029 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6030{
d0a31bd8 6031 tree node = *pnode;
6032
6033 if (TREE_CODE (node) == FUNCTION_DECL
6034 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
f54ed8bc 6035 {
f54ed8bc 6036 TREE_USED (node) = 1;
9423c9b7 6037 DECL_PRESERVE_P (node) = 1;
abc6c64f 6038 if (TREE_CODE (node) == VAR_DECL)
6039 DECL_READ_P (node) = 1;
f54ed8bc 6040 }
f8e93a2e 6041 else
6042 {
9b2d6d13 6043 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6044 *no_add_attrs = true;
6045 }
6046
6047 return NULL_TREE;
6048}
6049
6050/* Handle a "unused" attribute; arguments as in
6051 struct attribute_spec.handler. */
6052
6053static tree
9a03a746 6054handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6055 int flags, bool *no_add_attrs)
f8e93a2e 6056{
6057 if (DECL_P (*node))
6058 {
6059 tree decl = *node;
6060
6061 if (TREE_CODE (decl) == PARM_DECL
6062 || TREE_CODE (decl) == VAR_DECL
6063 || TREE_CODE (decl) == FUNCTION_DECL
6064 || TREE_CODE (decl) == LABEL_DECL
6065 || TREE_CODE (decl) == TYPE_DECL)
abc6c64f 6066 {
6067 TREE_USED (decl) = 1;
6068 if (TREE_CODE (decl) == VAR_DECL
6069 || TREE_CODE (decl) == PARM_DECL)
6070 DECL_READ_P (decl) = 1;
6071 }
f8e93a2e 6072 else
6073 {
9b2d6d13 6074 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6075 *no_add_attrs = true;
6076 }
6077 }
6078 else
6079 {
6080 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 6081 *node = build_variant_type_copy (*node);
f8e93a2e 6082 TREE_USED (*node) = 1;
6083 }
6084
6085 return NULL_TREE;
6086}
6087
62eec3b4 6088/* Handle a "externally_visible" attribute; arguments as in
6089 struct attribute_spec.handler. */
6090
6091static tree
6092handle_externally_visible_attribute (tree *pnode, tree name,
6093 tree ARG_UNUSED (args),
6094 int ARG_UNUSED (flags),
6095 bool *no_add_attrs)
6096{
6097 tree node = *pnode;
6098
ba12ea31 6099 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
62eec3b4 6100 {
ba12ea31 6101 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6102 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6103 {
6104 warning (OPT_Wattributes,
6105 "%qE attribute have effect only on public objects", name);
6106 *no_add_attrs = true;
6107 }
62eec3b4 6108 }
62eec3b4 6109 else
6110 {
6111 warning (OPT_Wattributes, "%qE attribute ignored", name);
6112 *no_add_attrs = true;
6113 }
6114
6115 return NULL_TREE;
6116}
6117
f8e93a2e 6118/* Handle a "const" attribute; arguments as in
6119 struct attribute_spec.handler. */
6120
6121static tree
9a03a746 6122handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6123 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6124{
6125 tree type = TREE_TYPE (*node);
6126
6127 /* See FIXME comment on noreturn in c_common_attribute_table. */
6128 if (TREE_CODE (*node) == FUNCTION_DECL)
6129 TREE_READONLY (*node) = 1;
6130 else if (TREE_CODE (type) == POINTER_TYPE
6131 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6132 TREE_TYPE (*node)
6133 = build_pointer_type
6134 (build_type_variant (TREE_TYPE (type), 1,
6135 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6136 else
6137 {
9b2d6d13 6138 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6139 *no_add_attrs = true;
6140 }
6141
6142 return NULL_TREE;
6143}
6144
6145/* Handle a "transparent_union" attribute; arguments as in
6146 struct attribute_spec.handler. */
6147
6148static tree
1cae46be 6149handle_transparent_union_attribute (tree *node, tree name,
9a03a746 6150 tree ARG_UNUSED (args), int flags,
09347743 6151 bool *no_add_attrs)
f8e93a2e 6152{
881eb642 6153 tree type;
03908818 6154
6155 *no_add_attrs = true;
f8e93a2e 6156
881eb642 6157 if (TREE_CODE (*node) == TYPE_DECL)
6158 node = &TREE_TYPE (*node);
6159 type = *node;
f8e93a2e 6160
03908818 6161 if (TREE_CODE (type) == UNION_TYPE)
f8e93a2e 6162 {
03908818 6163 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6164 the code in finish_struct. */
f8e93a2e 6165 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
03908818 6166 {
6167 if (TYPE_FIELDS (type) == NULL_TREE
914d1151 6168 || c_dialect_cxx ()
03908818 6169 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6170 goto ignored;
6171
6172 /* A type variant isn't good enough, since we don't a cast
6173 to such a type removed as a no-op. */
6174 *node = type = build_duplicate_type (type);
6175 }
6176
8df5a43d 6177 TYPE_TRANSPARENT_AGGR (type) = 1;
03908818 6178 return NULL_TREE;
f8e93a2e 6179 }
6180
03908818 6181 ignored:
6182 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6183 return NULL_TREE;
6184}
6185
9af7fd5b 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. */
6190
6191static priority_type
6192get_priority (tree args, bool is_destructor)
6193{
6194 HOST_WIDE_INT pri;
6c181a06 6195 tree arg;
9af7fd5b 6196
6197 if (!args)
6198 return DEFAULT_INIT_PRIORITY;
48e1416a 6199
28fbc04f 6200 if (!SUPPORTS_INIT_PRIORITY)
6201 {
6202 if (is_destructor)
6203 error ("destructor priorities are not supported");
6204 else
6205 error ("constructor priorities are not supported");
6206 return DEFAULT_INIT_PRIORITY;
6207 }
6208
6c181a06 6209 arg = TREE_VALUE (args);
6210 if (!host_integerp (arg, /*pos=*/0)
6211 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
9af7fd5b 6212 goto invalid;
6213
6214 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6215 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6216 goto invalid;
6217
6218 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6219 {
6220 if (is_destructor)
6221 warning (0,
6222 "destructor priorities from 0 to %d are reserved "
48e1416a 6223 "for the implementation",
9af7fd5b 6224 MAX_RESERVED_INIT_PRIORITY);
6225 else
6226 warning (0,
6227 "constructor priorities from 0 to %d are reserved "
48e1416a 6228 "for the implementation",
9af7fd5b 6229 MAX_RESERVED_INIT_PRIORITY);
6230 }
6231 return pri;
6232
6233 invalid:
6234 if (is_destructor)
6235 error ("destructor priorities must be integers from 0 to %d inclusive",
6236 MAX_INIT_PRIORITY);
6237 else
6238 error ("constructor priorities must be integers from 0 to %d inclusive",
6239 MAX_INIT_PRIORITY);
6240 return DEFAULT_INIT_PRIORITY;
6241}
6242
f8e93a2e 6243/* Handle a "constructor" attribute; arguments as in
6244 struct attribute_spec.handler. */
6245
6246static tree
9af7fd5b 6247handle_constructor_attribute (tree *node, tree name, tree args,
9a03a746 6248 int ARG_UNUSED (flags),
09347743 6249 bool *no_add_attrs)
f8e93a2e 6250{
6251 tree decl = *node;
6252 tree type = TREE_TYPE (decl);
6253
6254 if (TREE_CODE (decl) == FUNCTION_DECL
6255 && TREE_CODE (type) == FUNCTION_TYPE
6256 && decl_function_context (decl) == 0)
6257 {
9af7fd5b 6258 priority_type priority;
f8e93a2e 6259 DECL_STATIC_CONSTRUCTOR (decl) = 1;
9af7fd5b 6260 priority = get_priority (args, /*is_destructor=*/false);
6261 SET_DECL_INIT_PRIORITY (decl, priority);
f8e93a2e 6262 TREE_USED (decl) = 1;
6263 }
6264 else
6265 {
9b2d6d13 6266 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6267 *no_add_attrs = true;
6268 }
6269
6270 return NULL_TREE;
6271}
6272
6273/* Handle a "destructor" attribute; arguments as in
6274 struct attribute_spec.handler. */
6275
6276static tree
9af7fd5b 6277handle_destructor_attribute (tree *node, tree name, tree args,
9a03a746 6278 int ARG_UNUSED (flags),
09347743 6279 bool *no_add_attrs)
f8e93a2e 6280{
6281 tree decl = *node;
6282 tree type = TREE_TYPE (decl);
6283
6284 if (TREE_CODE (decl) == FUNCTION_DECL
6285 && TREE_CODE (type) == FUNCTION_TYPE
6286 && decl_function_context (decl) == 0)
6287 {
9af7fd5b 6288 priority_type priority;
f8e93a2e 6289 DECL_STATIC_DESTRUCTOR (decl) = 1;
9af7fd5b 6290 priority = get_priority (args, /*is_destructor=*/true);
6291 SET_DECL_FINI_PRIORITY (decl, priority);
f8e93a2e 6292 TREE_USED (decl) = 1;
6293 }
6294 else
6295 {
9b2d6d13 6296 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6297 *no_add_attrs = true;
6298 }
6299
6300 return NULL_TREE;
6301}
6302
1c58e3f1 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. */
6306
6307static int
6308vector_mode_valid_p (enum machine_mode mode)
6309{
6310 enum mode_class mclass = GET_MODE_CLASS (mode);
6311 enum machine_mode innermode;
6312
6313 /* Doh! What's going on? */
6314 if (mclass != MODE_VECTOR_INT
6315 && mclass != MODE_VECTOR_FLOAT
6316 && mclass != MODE_VECTOR_FRACT
6317 && mclass != MODE_VECTOR_UFRACT
6318 && mclass != MODE_VECTOR_ACCUM
6319 && mclass != MODE_VECTOR_UACCUM)
6320 return 0;
6321
6322 /* Hardware support. Woo hoo! */
6323 if (targetm.vector_mode_supported_p (mode))
6324 return 1;
6325
6326 innermode = GET_MODE_INNER (mode);
6327
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. */
6330
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. */
6333 return targetm.scalar_mode_supported_p (innermode);
6334}
6335
6336
f8e93a2e 6337/* Handle a "mode" attribute; arguments as in
6338 struct attribute_spec.handler. */
6339
6340static tree
9a03a746 6341handle_mode_attribute (tree *node, tree name, tree args,
6342 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6343{
6344 tree type = *node;
d1dd9ac0 6345 tree ident = TREE_VALUE (args);
f8e93a2e 6346
6347 *no_add_attrs = true;
6348
d1dd9ac0 6349 if (TREE_CODE (ident) != IDENTIFIER_NODE)
9b2d6d13 6350 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6351 else
6352 {
6353 int j;
d1dd9ac0 6354 const char *p = IDENTIFIER_POINTER (ident);
f8e93a2e 6355 int len = strlen (p);
6356 enum machine_mode mode = VOIDmode;
6357 tree typefm;
b2aef146 6358 bool valid_mode;
f8e93a2e 6359
6360 if (len > 4 && p[0] == '_' && p[1] == '_'
6361 && p[len - 1] == '_' && p[len - 2] == '_')
6362 {
4fd61bc6 6363 char *newp = (char *) alloca (len - 1);
f8e93a2e 6364
6365 strcpy (newp, &p[2]);
6366 newp[len - 4] = '\0';
6367 p = newp;
6368 }
6369
6370 /* Change this type to have a type with the specified mode.
6371 First check for the special modes. */
84166705 6372 if (!strcmp (p, "byte"))
f8e93a2e 6373 mode = byte_mode;
6374 else if (!strcmp (p, "word"))
6375 mode = word_mode;
84166705 6376 else if (!strcmp (p, "pointer"))
f8e93a2e 6377 mode = ptr_mode;
0ef89dfd 6378 else if (!strcmp (p, "libgcc_cmp_return"))
6379 mode = targetm.libgcc_cmp_return_mode ();
6380 else if (!strcmp (p, "libgcc_shift_count"))
6381 mode = targetm.libgcc_shift_count_mode ();
1bd43494 6382 else if (!strcmp (p, "unwind_word"))
6383 mode = targetm.unwind_word_mode ();
f8e93a2e 6384 else
6385 for (j = 0; j < NUM_MACHINE_MODES; j++)
6386 if (!strcmp (p, GET_MODE_NAME (j)))
743a6f47 6387 {
6388 mode = (enum machine_mode) j;
6389 break;
6390 }
f8e93a2e 6391
6392 if (mode == VOIDmode)
4917c376 6393 {
d1dd9ac0 6394 error ("unknown machine mode %qE", ident);
4917c376 6395 return NULL_TREE;
6396 }
6397
b2aef146 6398 valid_mode = false;
6399 switch (GET_MODE_CLASS (mode))
4917c376 6400 {
b2aef146 6401 case MODE_INT:
6402 case MODE_PARTIAL_INT:
6403 case MODE_FLOAT:
c4503c0a 6404 case MODE_DECIMAL_FLOAT:
9421ebb9 6405 case MODE_FRACT:
6406 case MODE_UFRACT:
6407 case MODE_ACCUM:
6408 case MODE_UACCUM:
b2aef146 6409 valid_mode = targetm.scalar_mode_supported_p (mode);
6410 break;
6411
6412 case MODE_COMPLEX_INT:
6413 case MODE_COMPLEX_FLOAT:
6414 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6415 break;
6416
6417 case MODE_VECTOR_INT:
6418 case MODE_VECTOR_FLOAT:
9421ebb9 6419 case MODE_VECTOR_FRACT:
6420 case MODE_VECTOR_UFRACT:
6421 case MODE_VECTOR_ACCUM:
6422 case MODE_VECTOR_UACCUM:
9b2d6d13 6423 warning (OPT_Wattributes, "specifying vector types with "
6424 "__attribute__ ((mode)) is deprecated");
6425 warning (OPT_Wattributes,
6426 "use __attribute__ ((vector_size)) instead");
b2aef146 6427 valid_mode = vector_mode_valid_p (mode);
6428 break;
4917c376 6429
b2aef146 6430 default:
6431 break;
6432 }
6433 if (!valid_mode)
6434 {
1e5fcbe2 6435 error ("unable to emulate %qs", p);
b2aef146 6436 return NULL_TREE;
6437 }
4917c376 6438
b2aef146 6439 if (POINTER_TYPE_P (type))
ead34f59 6440 {
6d5d708e 6441 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
b2aef146 6442 tree (*fn)(tree, enum machine_mode, bool);
6443
6d5d708e 6444 if (!targetm.addr_space.valid_pointer_mode (mode, as))
ead34f59 6445 {
1e5fcbe2 6446 error ("invalid pointer mode %qs", p);
ead34f59 6447 return NULL_TREE;
6448 }
6449
a0c938f0 6450 if (TREE_CODE (type) == POINTER_TYPE)
b2aef146 6451 fn = build_pointer_type_for_mode;
805e22b2 6452 else
b2aef146 6453 fn = build_reference_type_for_mode;
6454 typefm = fn (TREE_TYPE (type), mode, false);
ead34f59 6455 }
b2aef146 6456 else
9421ebb9 6457 {
6458 /* For fixed-point modes, we need to test if the signness of type
6459 and the machine mode are consistent. */
6460 if (ALL_FIXED_POINT_MODE_P (mode)
6461 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6462 {
bf776685 6463 error ("signedness of type and machine mode %qs don%'t match", p);
9421ebb9 6464 return NULL_TREE;
6465 }
6466 /* For fixed-point modes, we need to pass saturating info. */
6467 typefm = lang_hooks.types.type_for_mode (mode,
6468 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6469 : TYPE_UNSIGNED (type));
6470 }
3a648ab9 6471
b2aef146 6472 if (typefm == NULL_TREE)
6473 {
743a6f47 6474 error ("no data type for mode %qs", p);
b2aef146 6475 return NULL_TREE;
6476 }
3a648ab9 6477 else if (TREE_CODE (type) == ENUMERAL_TYPE)
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. */
6482 if (TREE_CODE (typefm) != INTEGER_TYPE)
6483 {
743a6f47 6484 error ("cannot use mode %qs for enumeral types", p);
3a648ab9 6485 return NULL_TREE;
6486 }
6487
10080eac 6488 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6489 {
6490 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6491 typefm = type;
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. */
6500 if (TYPE_UNSIGNED (type))
6501 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6502 else
6503 typefm = make_signed_type (TYPE_PRECISION (typefm));
6504 TREE_TYPE (typefm) = type;
6505 }
3a648ab9 6506 }
4bf450a1 6507 else if (VECTOR_MODE_P (mode)
6508 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6509 : TREE_CODE (type) != TREE_CODE (typefm))
743a6f47 6510 {
6511 error ("mode %qs applied to inappropriate type", p);
6512 return NULL_TREE;
6513 }
6514
b2aef146 6515 *node = typefm;
f8e93a2e 6516 }
6517
6518 return NULL_TREE;
6519}
6520
6521/* Handle a "section" attribute; arguments as in
6522 struct attribute_spec.handler. */
6523
6524static tree
9a03a746 6525handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6526 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6527{
6528 tree decl = *node;
6529
6530 if (targetm.have_named_sections)
6531 {
065efcb1 6532 user_defined_section_attribute = true;
6533
f8e93a2e 6534 if ((TREE_CODE (decl) == FUNCTION_DECL
6535 || TREE_CODE (decl) == VAR_DECL)
6536 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6537 {
6538 if (TREE_CODE (decl) == VAR_DECL
6539 && current_function_decl != NULL_TREE
84166705 6540 && !TREE_STATIC (decl))
f8e93a2e 6541 {
48e1416a 6542 error_at (DECL_SOURCE_LOCATION (decl),
712d2297 6543 "section attribute cannot be specified for "
6544 "local variables");
f8e93a2e 6545 *no_add_attrs = true;
6546 }
6547
6548 /* The decl may have already been given a section attribute
6549 from a previous declaration. Ensure they match. */
6550 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6551 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6552 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6553 {
3cf8b391 6554 error ("section of %q+D conflicts with previous declaration",
6555 *node);
f8e93a2e 6556 *no_add_attrs = true;
6557 }
38475469 6558 else if (TREE_CODE (decl) == VAR_DECL
6559 && !targetm.have_tls && targetm.emutls.tmpl_section
6560 && DECL_THREAD_LOCAL_P (decl))
6561 {
6562 error ("section of %q+D cannot be overridden", *node);
6563 *no_add_attrs = true;
6564 }
f8e93a2e 6565 else
6566 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6567 }
6568 else
6569 {
3cf8b391 6570 error ("section attribute not allowed for %q+D", *node);
f8e93a2e 6571 *no_add_attrs = true;
6572 }
6573 }
6574 else
6575 {
712d2297 6576 error_at (DECL_SOURCE_LOCATION (*node),
6577 "section attributes are not supported for this target");
f8e93a2e 6578 *no_add_attrs = true;
6579 }
6580
6581 return NULL_TREE;
6582}
6583
6584/* Handle a "aligned" attribute; arguments as in
6585 struct attribute_spec.handler. */
6586
6587static tree
9a03a746 6588handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
09347743 6589 int flags, bool *no_add_attrs)
f8e93a2e 6590{
6591 tree decl = NULL_TREE;
6592 tree *type = NULL;
6593 int is_type = 0;
6594 tree align_expr = (args ? TREE_VALUE (args)
02421213 6595 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
f8e93a2e 6596 int i;
6597
6598 if (DECL_P (*node))
6599 {
6600 decl = *node;
6601 type = &TREE_TYPE (decl);
6602 is_type = TREE_CODE (*node) == TYPE_DECL;
6603 }
6604 else if (TYPE_P (*node))
6605 type = node, is_type = 1;
6606
f8e93a2e 6607 if (TREE_CODE (align_expr) != INTEGER_CST)
6608 {
6609 error ("requested alignment is not a constant");
6610 *no_add_attrs = true;
6611 }
6612 else if ((i = tree_log2 (align_expr)) == -1)
6613 {
6614 error ("requested alignment is not a power of 2");
6615 *no_add_attrs = true;
6616 }
7cfdc2f0 6617 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
f8e93a2e 6618 {
6619 error ("requested alignment is too large");
6620 *no_add_attrs = true;
6621 }
6622 else if (is_type)
6623 {
2ec3af9c 6624 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6625 /* OK, modify the type in place. */;
f8e93a2e 6626 /* If we have a TYPE_DECL, then copy the type, so that we
6627 don't accidentally modify a builtin type. See pushdecl. */
2ec3af9c 6628 else if (decl && TREE_TYPE (decl) != error_mark_node
6629 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
f8e93a2e 6630 {
6631 tree tt = TREE_TYPE (decl);
e086912e 6632 *type = build_variant_type_copy (*type);
f8e93a2e 6633 DECL_ORIGINAL_TYPE (decl) = tt;
6634 TYPE_NAME (*type) = decl;
6635 TREE_USED (*type) = TREE_USED (decl);
6636 TREE_TYPE (decl) = *type;
6637 }
2ec3af9c 6638 else
e086912e 6639 *type = build_variant_type_copy (*type);
f8e93a2e 6640
7cfdc2f0 6641 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
f8e93a2e 6642 TYPE_USER_ALIGN (*type) = 1;
6643 }
097b5c8b 6644 else if (! VAR_OR_FUNCTION_DECL_P (decl)
f8e93a2e 6645 && TREE_CODE (decl) != FIELD_DECL)
6646 {
3cf8b391 6647 error ("alignment may not be specified for %q+D", decl);
f8e93a2e 6648 *no_add_attrs = true;
6649 }
097b5c8b 6650 else if (TREE_CODE (decl) == FUNCTION_DECL
7cfdc2f0 6651 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
097b5c8b 6652 {
6653 if (DECL_USER_ALIGN (decl))
6654 error ("alignment for %q+D was previously specified as %d "
6655 "and may not be decreased", decl,
6656 DECL_ALIGN (decl) / BITS_PER_UNIT);
6657 else
6658 error ("alignment for %q+D must be at least %d", decl,
6659 DECL_ALIGN (decl) / BITS_PER_UNIT);
6660 *no_add_attrs = true;
6661 }
f8e93a2e 6662 else
6663 {
7cfdc2f0 6664 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
f8e93a2e 6665 DECL_USER_ALIGN (decl) = 1;
6666 }
6667
6668 return NULL_TREE;
6669}
6670
6671/* Handle a "weak" attribute; arguments as in
6672 struct attribute_spec.handler. */
6673
6674static tree
f948b309 6675handle_weak_attribute (tree *node, tree name,
9a03a746 6676 tree ARG_UNUSED (args),
6677 int ARG_UNUSED (flags),
6678 bool * ARG_UNUSED (no_add_attrs))
f8e93a2e 6679{
f948b309 6680 if (TREE_CODE (*node) == FUNCTION_DECL
059a60f3 6681 && DECL_DECLARED_INLINE_P (*node))
6682 {
0725e25c 6683 warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
059a60f3 6684 *no_add_attrs = true;
6685 }
85c0a25c 6686 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6687 {
6688 error ("indirect function %q+D cannot be declared weak", *node);
6689 *no_add_attrs = true;
6690 return NULL_TREE;
6691 }
059a60f3 6692 else if (TREE_CODE (*node) == FUNCTION_DECL
6693 || TREE_CODE (*node) == VAR_DECL)
f948b309 6694 declare_weak (*node);
6695 else
6696 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6697
6698 return NULL_TREE;
6699}
6700
85c0a25c 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. */
f8e93a2e 6704
6705static tree
85c0a25c 6706handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
6707 bool *no_add_attrs)
f8e93a2e 6708{
6709 tree decl = *node;
6710
85c0a25c 6711 if (TREE_CODE (decl) != FUNCTION_DECL
6712 && (!is_alias || TREE_CODE (decl) != VAR_DECL))
9e830260 6713 {
6714 warning (OPT_Wattributes, "%qE attribute ignored", name);
6715 *no_add_attrs = true;
6716 }
6717 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
48e1416a 6718 || (TREE_CODE (decl) != FUNCTION_DECL
0a3ecdc1 6719 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6720 /* A static variable declaration is always a tentative definition,
6721 but the alias is a non-tentative definition which overrides. */
48e1416a 6722 || (TREE_CODE (decl) != FUNCTION_DECL
0a3ecdc1 6723 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
f8e93a2e 6724 {
85c0a25c 6725 error ("%q+D defined both normally and as %qE attribute", decl, name);
f8e93a2e 6726 *no_add_attrs = true;
85c0a25c 6727 return NULL_TREE;
f8e93a2e 6728 }
85c0a25c 6729 else if (!is_alias
6730 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
6731 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
6732 {
6733 error ("weak %q+D cannot be defined %qE", decl, name);
6734 *no_add_attrs = true;
6735 return NULL_TREE;
6736 }
8c42f0d9 6737
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. */
6743 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
f8e93a2e 6744 {
6745 tree id;
6746
6747 id = TREE_VALUE (args);
6748 if (TREE_CODE (id) != STRING_CST)
6749 {
85c0a25c 6750 error ("attribute %qE argument not a string", name);
f8e93a2e 6751 *no_add_attrs = true;
6752 return NULL_TREE;
6753 }
6754 id = get_identifier (TREE_STRING_POINTER (id));
6755 /* This counts as a use of the object pointed to. */
6756 TREE_USED (id) = 1;
6757
6758 if (TREE_CODE (decl) == FUNCTION_DECL)
6759 DECL_INITIAL (decl) = error_mark_node;
6760 else
4ee9c684 6761 {
f4a30bd7 6762 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6763 DECL_EXTERNAL (decl) = 1;
6764 else
6765 DECL_EXTERNAL (decl) = 0;
4ee9c684 6766 TREE_STATIC (decl) = 1;
6767 }
85c0a25c 6768
6769 if (!is_alias)
6770 /* ifuncs are also aliases, so set that attribute too. */
6771 DECL_ATTRIBUTES (decl)
6772 = tree_cons (get_identifier ("alias"), args, DECL_ATTRIBUTES (decl));
f8e93a2e 6773 }
6774 else
6775 {
9b2d6d13 6776 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6777 *no_add_attrs = true;
6778 }
6779
6780 return NULL_TREE;
6781}
6782
85c0a25c 6783/* Handle an "alias" or "ifunc" attribute; arguments as in
6784 struct attribute_spec.handler. */
6785
6786static tree
6787handle_ifunc_attribute (tree *node, tree name, tree args,
6788 int ARG_UNUSED (flags), bool *no_add_attrs)
6789{
6790 return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
6791}
6792
6793/* Handle an "alias" or "ifunc" attribute; arguments as in
6794 struct attribute_spec.handler. */
6795
6796static tree
6797handle_alias_attribute (tree *node, tree name, tree args,
6798 int ARG_UNUSED (flags), bool *no_add_attrs)
6799{
6800 return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
6801}
6802
f4a30bd7 6803/* Handle a "weakref" attribute; arguments as in struct
6804 attribute_spec.handler. */
6805
6806static tree
6807handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6808 int flags, bool *no_add_attrs)
6809{
6810 tree attr = NULL_TREE;
6811
83852912 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. */
64a7bd81 6815 if (decl_function_context (*node)
6816 || current_function_decl
6817 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
83852912 6818 {
6819 warning (OPT_Wattributes, "%qE attribute ignored", name);
6820 *no_add_attrs = true;
6821 return NULL_TREE;
6822 }
6823
85c0a25c 6824 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6825 {
6826 error ("indirect function %q+D cannot be declared weakref", *node);
6827 *no_add_attrs = true;
6828 return NULL_TREE;
6829 }
6830
f4a30bd7 6831 /* The idea here is that `weakref("name")' mutates into `weakref,
6832 alias("name")', and weakref without arguments, in turn,
6833 implicitly adds weak. */
6834
6835 if (args)
6836 {
6837 attr = tree_cons (get_identifier ("alias"), args, attr);
6838 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6839
6840 *no_add_attrs = true;
0a3ecdc1 6841
6842 decl_attributes (node, attr, flags);
f4a30bd7 6843 }
6844 else
6845 {
6846 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
712d2297 6847 error_at (DECL_SOURCE_LOCATION (*node),
6848 "weakref attribute must appear before alias attribute");
f4a30bd7 6849
0a3ecdc1 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. */
6853 DECL_WEAK (*node) = 1;
f4a30bd7 6854 }
6855
f4a30bd7 6856 return NULL_TREE;
6857}
6858
f8e93a2e 6859/* Handle an "visibility" attribute; arguments as in
6860 struct attribute_spec.handler. */
6861
6862static tree
1cae46be 6863handle_visibility_attribute (tree *node, tree name, tree args,
9a03a746 6864 int ARG_UNUSED (flags),
4a2849cb 6865 bool *ARG_UNUSED (no_add_attrs))
f8e93a2e 6866{
6867 tree decl = *node;
9c40570a 6868 tree id = TREE_VALUE (args);
4a2849cb 6869 enum symbol_visibility vis;
f8e93a2e 6870
b212f378 6871 if (TYPE_P (*node))
6872 {
4a2849cb 6873 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6874 /* OK */;
6875 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6876 {
6877 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6878 name);
6879 return NULL_TREE;
6880 }
6881 else if (TYPE_FIELDS (*node))
6882 {
6883 error ("%qE attribute ignored because %qT is already defined",
6884 name, *node);
6885 return NULL_TREE;
6886 }
b212f378 6887 }
84166705 6888 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
f8e93a2e 6889 {
9b2d6d13 6890 warning (OPT_Wattributes, "%qE attribute ignored", name);
9c40570a 6891 return NULL_TREE;
f8e93a2e 6892 }
f8e93a2e 6893
9c40570a 6894 if (TREE_CODE (id) != STRING_CST)
6895 {
07e3a3d2 6896 error ("visibility argument not a string");
9c40570a 6897 return NULL_TREE;
f8e93a2e 6898 }
b27ac6b5 6899
b212f378 6900 /* If this is a type, set the visibility on the type decl. */
6901 if (TYPE_P (decl))
6902 {
6903 decl = TYPE_NAME (decl);
84166705 6904 if (!decl)
a0c938f0 6905 return NULL_TREE;
e147aab3 6906 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6907 {
9b2d6d13 6908 warning (OPT_Wattributes, "%qE attribute ignored on types",
e147aab3 6909 name);
6910 return NULL_TREE;
6911 }
b212f378 6912 }
f8e93a2e 6913
9c40570a 6914 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4a2849cb 6915 vis = VISIBILITY_DEFAULT;
9c40570a 6916 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4a2849cb 6917 vis = VISIBILITY_INTERNAL;
9c40570a 6918 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4a2849cb 6919 vis = VISIBILITY_HIDDEN;
9c40570a 6920 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4a2849cb 6921 vis = VISIBILITY_PROTECTED;
9c40570a 6922 else
4a2849cb 6923 {
6924 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6925 vis = VISIBILITY_DEFAULT;
6926 }
6927
6928 if (DECL_VISIBILITY_SPECIFIED (decl)
098a01e7 6929 && vis != DECL_VISIBILITY (decl))
6930 {
6931 tree attributes = (TYPE_P (*node)
6932 ? TYPE_ATTRIBUTES (*node)
6933 : DECL_ATTRIBUTES (decl));
6934 if (lookup_attribute ("visibility", attributes))
6935 error ("%qD redeclared with different visibility", decl);
6936 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6937 && lookup_attribute ("dllimport", attributes))
6938 error ("%qD was declared %qs which implies default visibility",
6939 decl, "dllimport");
6940 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6941 && lookup_attribute ("dllexport", attributes))
6942 error ("%qD was declared %qs which implies default visibility",
6943 decl, "dllexport");
6944 }
4a2849cb 6945
6946 DECL_VISIBILITY (decl) = vis;
b212f378 6947 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6948
4a2849cb 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. */
9c40570a 6953
f8e93a2e 6954 return NULL_TREE;
6955}
6956
3aa0c315 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. */
6963
6964bool
6965c_determine_visibility (tree decl)
6966{
1d8fc210 6967 gcc_assert (TREE_CODE (decl) == VAR_DECL
6968 || TREE_CODE (decl) == FUNCTION_DECL);
3aa0c315 6969
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. */
098a01e7 6977 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6978 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6979 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6980 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
3aa0c315 6981 return true;
6982
4a2849cb 6983 /* Set default visibility to whatever the user supplied with
6984 visibility_specified depending on #pragma GCC visibility. */
6985 if (!DECL_VISIBILITY_SPECIFIED (decl))
6986 {
2d9d8740 6987 if (visibility_options.inpragma
6988 || DECL_VISIBILITY (decl) != default_visibility)
6989 {
6990 DECL_VISIBILITY (decl) = default_visibility;
6991 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6992 /* If visibility changed and DECL already has DECL_RTL, ensure
6993 symbol flags are updated. */
6994 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6995 || TREE_CODE (decl) == FUNCTION_DECL)
6996 && DECL_RTL_SET_P (decl))
6997 make_decl_rtl (decl);
6998 }
4a2849cb 6999 }
3aa0c315 7000 return false;
7001}
7002
24dfead4 7003/* Handle an "tls_model" attribute; arguments as in
7004 struct attribute_spec.handler. */
7005
7006static tree
1cae46be 7007handle_tls_model_attribute (tree *node, tree name, tree args,
9a03a746 7008 int ARG_UNUSED (flags), bool *no_add_attrs)
24dfead4 7009{
1b53eb20 7010 tree id;
24dfead4 7011 tree decl = *node;
1b53eb20 7012 enum tls_model kind;
24dfead4 7013
1b53eb20 7014 *no_add_attrs = true;
7015
c34f8a78 7016 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
24dfead4 7017 {
9b2d6d13 7018 warning (OPT_Wattributes, "%qE attribute ignored", name);
1b53eb20 7019 return NULL_TREE;
24dfead4 7020 }
24dfead4 7021
1b53eb20 7022 kind = DECL_TLS_MODEL (decl);
7023 id = TREE_VALUE (args);
7024 if (TREE_CODE (id) != STRING_CST)
7025 {
7026 error ("tls_model argument not a string");
7027 return NULL_TREE;
24dfead4 7028 }
7029
1b53eb20 7030 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7031 kind = TLS_MODEL_LOCAL_EXEC;
7032 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7033 kind = TLS_MODEL_INITIAL_EXEC;
7034 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7035 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7036 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7037 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7038 else
7039 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7040
7041 DECL_TLS_MODEL (decl) = kind;
24dfead4 7042 return NULL_TREE;
7043}
7044
f8e93a2e 7045/* Handle a "no_instrument_function" attribute; arguments as in
7046 struct attribute_spec.handler. */
7047
7048static tree
1cae46be 7049handle_no_instrument_function_attribute (tree *node, tree name,
9a03a746 7050 tree ARG_UNUSED (args),
7051 int ARG_UNUSED (flags),
09347743 7052 bool *no_add_attrs)
f8e93a2e 7053{
7054 tree decl = *node;
7055
7056 if (TREE_CODE (decl) != FUNCTION_DECL)
7057 {
712d2297 7058 error_at (DECL_SOURCE_LOCATION (decl),
7059 "%qE attribute applies only to functions", name);
f8e93a2e 7060 *no_add_attrs = true;
7061 }
7062 else if (DECL_INITIAL (decl))
7063 {
712d2297 7064 error_at (DECL_SOURCE_LOCATION (decl),
7065 "can%'t set %qE attribute after definition", name);
f8e93a2e 7066 *no_add_attrs = true;
7067 }
7068 else
7069 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7070
7071 return NULL_TREE;
7072}
7073
7074/* Handle a "malloc" attribute; arguments as in
7075 struct attribute_spec.handler. */
7076
7077static tree
9a03a746 7078handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7079 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 7080{
a5147fca 7081 if (TREE_CODE (*node) == FUNCTION_DECL
7082 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
f8e93a2e 7083 DECL_IS_MALLOC (*node) = 1;
f8e93a2e 7084 else
7085 {
9b2d6d13 7086 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7087 *no_add_attrs = true;
7088 }
7089
7090 return NULL_TREE;
7091}
7092
4a29c97c 7093/* Handle a "alloc_size" attribute; arguments as in
7094 struct attribute_spec.handler. */
7095
7096static tree
7097handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7098 int ARG_UNUSED (flags), bool *no_add_attrs)
7099{
2802826e 7100 unsigned arg_count = type_num_arguments (*node);
4a29c97c 7101 for (; args; args = TREE_CHAIN (args))
7102 {
7103 tree position = TREE_VALUE (args);
7104
7105 if (TREE_CODE (position) != INTEGER_CST
48e1416a 7106 || TREE_INT_CST_HIGH (position)
4a29c97c 7107 || TREE_INT_CST_LOW (position) < 1
7108 || TREE_INT_CST_LOW (position) > arg_count )
7109 {
48e1416a 7110 warning (OPT_Wattributes,
4a29c97c 7111 "alloc_size parameter outside range");
7112 *no_add_attrs = true;
7113 return NULL_TREE;
7114 }
7115 }
7116 return NULL_TREE;
7117}
7118
8ce86007 7119/* Handle a "fn spec" attribute; arguments as in
7120 struct attribute_spec.handler. */
7121
7122static tree
7123handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7124 tree args, int ARG_UNUSED (flags),
7125 bool *no_add_attrs ATTRIBUTE_UNUSED)
7126{
7127 gcc_assert (args
7128 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7129 && !TREE_CHAIN (args));
7130 return NULL_TREE;
7131}
7132
26d1c5ff 7133/* Handle a "returns_twice" attribute; arguments as in
7134 struct attribute_spec.handler. */
7135
7136static tree
7137handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7138 int ARG_UNUSED (flags), bool *no_add_attrs)
7139{
7140 if (TREE_CODE (*node) == FUNCTION_DECL)
7141 DECL_IS_RETURNS_TWICE (*node) = 1;
7142 else
7143 {
9b2d6d13 7144 warning (OPT_Wattributes, "%qE attribute ignored", name);
26d1c5ff 7145 *no_add_attrs = true;
7146 }
7147
7148 return NULL_TREE;
7149}
7150
f8e93a2e 7151/* Handle a "no_limit_stack" attribute; arguments as in
7152 struct attribute_spec.handler. */
7153
7154static tree
1cae46be 7155handle_no_limit_stack_attribute (tree *node, tree name,
9a03a746 7156 tree ARG_UNUSED (args),
7157 int ARG_UNUSED (flags),
09347743 7158 bool *no_add_attrs)
f8e93a2e 7159{
7160 tree decl = *node;
7161
7162 if (TREE_CODE (decl) != FUNCTION_DECL)
7163 {
712d2297 7164 error_at (DECL_SOURCE_LOCATION (decl),
7165 "%qE attribute applies only to functions", name);
f8e93a2e 7166 *no_add_attrs = true;
7167 }
7168 else if (DECL_INITIAL (decl))
7169 {
712d2297 7170 error_at (DECL_SOURCE_LOCATION (decl),
7171 "can%'t set %qE attribute after definition", name);
f8e93a2e 7172 *no_add_attrs = true;
7173 }
7174 else
7175 DECL_NO_LIMIT_STACK (decl) = 1;
7176
7177 return NULL_TREE;
7178}
7179
7180/* Handle a "pure" attribute; arguments as in
7181 struct attribute_spec.handler. */
7182
7183static tree
9a03a746 7184handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7185 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 7186{
7187 if (TREE_CODE (*node) == FUNCTION_DECL)
9c2a0c05 7188 DECL_PURE_P (*node) = 1;
f8e93a2e 7189 /* ??? TODO: Support types. */
7190 else
7191 {
9b2d6d13 7192 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7193 *no_add_attrs = true;
7194 }
7195
7196 return NULL_TREE;
7197}
7198
fc09b200 7199/* Handle a "no vops" attribute; arguments as in
7200 struct attribute_spec.handler. */
7201
7202static tree
7203handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7204 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7205 bool *ARG_UNUSED (no_add_attrs))
7206{
7207 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7208 DECL_IS_NOVOPS (*node) = 1;
7209 return NULL_TREE;
7210}
7211
f8e93a2e 7212/* Handle a "deprecated" attribute; arguments as in
7213 struct attribute_spec.handler. */
1cae46be 7214
f8e93a2e 7215static tree
1cae46be 7216handle_deprecated_attribute (tree *node, tree name,
45c4e798 7217 tree args, int flags,
09347743 7218 bool *no_add_attrs)
f8e93a2e 7219{
7220 tree type = NULL_TREE;
7221 int warn = 0;
782858b8 7222 tree what = NULL_TREE;
1cae46be 7223
45c4e798 7224 if (!args)
7225 *no_add_attrs = true;
7226 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7227 {
7228 error ("deprecated message is not a string");
7229 *no_add_attrs = true;
7230 }
7231
f8e93a2e 7232 if (DECL_P (*node))
7233 {
7234 tree decl = *node;
7235 type = TREE_TYPE (decl);
1cae46be 7236
f8e93a2e 7237 if (TREE_CODE (decl) == TYPE_DECL
7238 || TREE_CODE (decl) == PARM_DECL
7239 || TREE_CODE (decl) == VAR_DECL
7240 || TREE_CODE (decl) == FUNCTION_DECL
40c8d1dd 7241 || TREE_CODE (decl) == FIELD_DECL
7242 || objc_method_decl (TREE_CODE (decl)))
f8e93a2e 7243 TREE_DEPRECATED (decl) = 1;
7244 else
7245 warn = 1;
7246 }
7247 else if (TYPE_P (*node))
7248 {
7249 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 7250 *node = build_variant_type_copy (*node);
f8e93a2e 7251 TREE_DEPRECATED (*node) = 1;
7252 type = *node;
7253 }
7254 else
7255 warn = 1;
1cae46be 7256
f8e93a2e 7257 if (warn)
7258 {
7259 *no_add_attrs = true;
7260 if (type && TYPE_NAME (type))
7261 {
7262 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
782858b8 7263 what = TYPE_NAME (*node);
f8e93a2e 7264 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7265 && DECL_NAME (TYPE_NAME (type)))
782858b8 7266 what = DECL_NAME (TYPE_NAME (type));
f8e93a2e 7267 }
7268 if (what)
9b2d6d13 7269 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
f8e93a2e 7270 else
9b2d6d13 7271 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7272 }
7273
7274 return NULL_TREE;
7275}
7276
f8e93a2e 7277/* Handle a "vector_size" attribute; arguments as in
7278 struct attribute_spec.handler. */
7279
7280static tree
1cae46be 7281handle_vector_size_attribute (tree *node, tree name, tree args,
9a03a746 7282 int ARG_UNUSED (flags),
09347743 7283 bool *no_add_attrs)
f8e93a2e 7284{
7285 unsigned HOST_WIDE_INT vecsize, nunits;
83e2a11b 7286 enum machine_mode orig_mode;
4917c376 7287 tree type = *node, new_type, size;
f8e93a2e 7288
7289 *no_add_attrs = true;
7290
4917c376 7291 size = TREE_VALUE (args);
4917c376 7292
84166705 7293 if (!host_integerp (size, 1))
f8e93a2e 7294 {
9b2d6d13 7295 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7296 return NULL_TREE;
7297 }
7298
7299 /* Get the vector size (in bytes). */
4917c376 7300 vecsize = tree_low_cst (size, 1);
f8e93a2e 7301
7302 /* We need to provide for vector pointers, vector arrays, and
7303 functions returning vectors. For example:
7304
7305 __attribute__((vector_size(16))) short *foo;
7306
7307 In this case, the mode is SI, but the type being modified is
7308 HI, so we need to look further. */
7309
7310 while (POINTER_TYPE_P (type)
7311 || TREE_CODE (type) == FUNCTION_TYPE
5bfb0742 7312 || TREE_CODE (type) == METHOD_TYPE
2cb0e5d9 7313 || TREE_CODE (type) == ARRAY_TYPE
7314 || TREE_CODE (type) == OFFSET_TYPE)
f8e93a2e 7315 type = TREE_TYPE (type);
7316
7317 /* Get the mode of the type being modified. */
7318 orig_mode = TYPE_MODE (type);
7319
2cb0e5d9 7320 if ((!INTEGRAL_TYPE_P (type)
7321 && !SCALAR_FLOAT_TYPE_P (type)
7322 && !FIXED_POINT_TYPE_P (type))
cee7491d 7323 || (!SCALAR_FLOAT_MODE_P (orig_mode)
9421ebb9 7324 && GET_MODE_CLASS (orig_mode) != MODE_INT
7325 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7ec31215 7326 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7327 || TREE_CODE (type) == BOOLEAN_TYPE)
f8e93a2e 7328 {
782858b8 7329 error ("invalid vector type for attribute %qE", name);
f8e93a2e 7330 return NULL_TREE;
7331 }
7332
39cc3e6d 7333 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7334 {
7335 error ("vector size not an integral multiple of component size");
7336 return NULL;
7337 }
7338
7339 if (vecsize == 0)
7340 {
7341 error ("zero vector size");
7342 return NULL;
7343 }
7344
f8e93a2e 7345 /* Calculate how many units fit in the vector. */
7346 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
83e2a11b 7347 if (nunits & (nunits - 1))
f8e93a2e 7348 {
83e2a11b 7349 error ("number of components of the vector not a power of two");
f8e93a2e 7350 return NULL_TREE;
7351 }
7352
83e2a11b 7353 new_type = build_vector_type (type, nunits);
f8e93a2e 7354
7355 /* Build back pointers if needed. */
d991e6e8 7356 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
f8e93a2e 7357
7358 return NULL_TREE;
7359}
7360
dbf6c367 7361/* Handle the "nonnull" attribute. */
7362static tree
9a03a746 7363handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7364 tree args, int ARG_UNUSED (flags),
09347743 7365 bool *no_add_attrs)
dbf6c367 7366{
7367 tree type = *node;
7368 unsigned HOST_WIDE_INT attr_arg_num;
7369
7370 /* If no arguments are specified, all pointer arguments should be
d716ce75 7371 non-null. Verify a full prototype is given so that the arguments
dbf6c367 7372 will have the correct types when we actually check them later. */
84166705 7373 if (!args)
dbf6c367 7374 {
a36cf284 7375 if (!prototype_p (type))
dbf6c367 7376 {
7377 error ("nonnull attribute without arguments on a non-prototype");
4ee9c684 7378 *no_add_attrs = true;
dbf6c367 7379 }
7380 return NULL_TREE;
7381 }
7382
7383 /* Argument list specified. Verify that each argument number references
7384 a pointer argument. */
7385 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7386 {
7387 tree argument;
4ee9c684 7388 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
dbf6c367 7389
84166705 7390 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
dbf6c367 7391 {
07e3a3d2 7392 error ("nonnull argument has invalid operand number (argument %lu)",
dbf6c367 7393 (unsigned long) attr_arg_num);
7394 *no_add_attrs = true;
7395 return NULL_TREE;
7396 }
7397
7398 argument = TYPE_ARG_TYPES (type);
7399 if (argument)
7400 {
7401 for (ck_num = 1; ; ck_num++)
7402 {
84166705 7403 if (!argument || ck_num == arg_num)
dbf6c367 7404 break;
7405 argument = TREE_CHAIN (argument);
7406 }
7407
84166705 7408 if (!argument
dbf6c367 7409 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7410 {
07e3a3d2 7411 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
dbf6c367 7412 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7413 *no_add_attrs = true;
7414 return NULL_TREE;
7415 }
7416
4ee9c684 7417 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
dbf6c367 7418 {
07e3a3d2 7419 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
dbf6c367 7420 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7421 *no_add_attrs = true;
7422 return NULL_TREE;
7423 }
7424 }
7425 }
7426
7427 return NULL_TREE;
7428}
7429
7430/* Check the argument list of a function call for null in argument slots
d01f58f9 7431 that are marked as requiring a non-null pointer argument. The NARGS
7432 arguments are passed in the array ARGARRAY.
7433*/
dbf6c367 7434
7435static void
d01f58f9 7436check_function_nonnull (tree attrs, int nargs, tree *argarray)
dbf6c367 7437{
d01f58f9 7438 tree a, args;
7439 int i;
dbf6c367 7440
7441 for (a = attrs; a; a = TREE_CHAIN (a))
7442 {
7443 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7444 {
4ee9c684 7445 args = TREE_VALUE (a);
dbf6c367 7446
4ee9c684 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
dbf6c367 7450 for pointer type is done in check_nonnull_arg). */
d01f58f9 7451 for (i = 0; i < nargs; i++)
4ee9c684 7452 {
d01f58f9 7453 if (!args || nonnull_check_p (args, i + 1))
e4603171 7454 check_function_arguments_recurse (check_nonnull_arg, NULL,
d01f58f9 7455 argarray[i],
7456 i + 1);
4ee9c684 7457 }
dbf6c367 7458 }
7459 }
7460}
7461
50ca527f 7462/* Check that the Nth argument of a function call (counting backwards
d01f58f9 7463 from the end) is a (pointer)0. The NARGS arguments are passed in the
7464 array ARGARRAY. */
bf6c8de0 7465
7466static void
d01f58f9 7467check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
bf6c8de0 7468{
7469 tree attr = lookup_attribute ("sentinel", attrs);
7470
7471 if (attr)
7472 {
d01f58f9 7473 int len = 0;
7474 int pos = 0;
7475 tree sentinel;
a0c938f0 7476
d01f58f9 7477 /* Skip over the named arguments. */
7478 while (typelist && len < nargs)
a0c938f0 7479 {
d01f58f9 7480 typelist = TREE_CHAIN (typelist);
7481 len++;
7482 }
50ca527f 7483
d01f58f9 7484 if (TREE_VALUE (attr))
7485 {
7486 tree p = TREE_VALUE (TREE_VALUE (attr));
7487 pos = TREE_INT_CST_LOW (p);
7488 }
50ca527f 7489
d01f58f9 7490 /* The sentinel must be one of the varargs, i.e.
7491 in position >= the number of fixed arguments. */
7492 if ((nargs - 1 - pos) < len)
7493 {
7494 warning (OPT_Wformat,
7495 "not enough variable arguments to fit a sentinel");
7496 return;
bf6c8de0 7497 }
d01f58f9 7498
7499 /* Validate the sentinel. */
7500 sentinel = argarray[nargs - 1 - pos];
7501 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7502 || !integer_zerop (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. */
7508 && (warn_strict_null_sentinel || null_node != sentinel))
7509 warning (OPT_Wformat, "missing sentinel in function call");
bf6c8de0 7510 }
7511}
7512
dbf6c367 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. */
7516
7517static bool
1cae46be 7518nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
dbf6c367 7519{
4ee9c684 7520 unsigned HOST_WIDE_INT arg_num = 0;
dbf6c367 7521
7522 for (; args; args = TREE_CHAIN (args))
7523 {
231bd014 7524 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7525
7526 gcc_assert (found);
dbf6c367 7527
7528 if (arg_num == param_num)
7529 return true;
7530 }
7531 return false;
7532}
7533
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. */
7537
7538static void
9a03a746 7539check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
1cae46be 7540 unsigned HOST_WIDE_INT param_num)
dbf6c367 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). */
7545
7546 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7547 return;
7548
7549 if (integer_zerop (param))
155b601b 7550 warning (OPT_Wnonnull, "null argument where non-null required "
7551 "(argument %lu)", (unsigned long) param_num);
dbf6c367 7552}
7553
7554/* Helper for nonnull attribute handling; fetch the operand number
7555 from the attribute argument list. */
7556
7557static bool
1cae46be 7558get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
dbf6c367 7559{
67409385 7560 /* Verify the arg number is a constant. */
dbf6c367 7561 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7562 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7563 return false;
7564
7565 *valp = TREE_INT_CST_LOW (arg_num_expr);
7566 return true;
7567}
fa987697 7568
7569/* Handle a "nothrow" attribute; arguments as in
7570 struct attribute_spec.handler. */
7571
7572static tree
9a03a746 7573handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7574 int ARG_UNUSED (flags), bool *no_add_attrs)
fa987697 7575{
7576 if (TREE_CODE (*node) == FUNCTION_DECL)
7577 TREE_NOTHROW (*node) = 1;
7578 /* ??? TODO: Support types. */
7579 else
7580 {
9b2d6d13 7581 warning (OPT_Wattributes, "%qE attribute ignored", name);
fa987697 7582 *no_add_attrs = true;
7583 }
7584
7585 return NULL_TREE;
7586}
7acb29a3 7587
7588/* Handle a "cleanup" attribute; arguments as in
7589 struct attribute_spec.handler. */
7590
7591static tree
1cae46be 7592handle_cleanup_attribute (tree *node, tree name, tree args,
9a03a746 7593 int ARG_UNUSED (flags), bool *no_add_attrs)
7acb29a3 7594{
7595 tree decl = *node;
7596 tree cleanup_id, cleanup_decl;
7597
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. */
7602 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7603 {
9b2d6d13 7604 warning (OPT_Wattributes, "%qE attribute ignored", name);
7acb29a3 7605 *no_add_attrs = true;
7606 return NULL_TREE;
7607 }
7608
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. */
7612 cleanup_id = TREE_VALUE (args);
7613 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7614 {
07e3a3d2 7615 error ("cleanup argument not an identifier");
7acb29a3 7616 *no_add_attrs = true;
7617 return NULL_TREE;
7618 }
d1c41717 7619 cleanup_decl = lookup_name (cleanup_id);
7acb29a3 7620 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7621 {
07e3a3d2 7622 error ("cleanup argument not a function");
7acb29a3 7623 *no_add_attrs = true;
7624 return NULL_TREE;
7625 }
7626
1cae46be 7627 /* That the function has proper type is checked with the
7acb29a3 7628 eventual call to build_function_call. */
7629
7630 return NULL_TREE;
7631}
8a8cdb8d 7632
7633/* Handle a "warn_unused_result" attribute. No special handling. */
7634
7635static tree
7636handle_warn_unused_result_attribute (tree *node, tree name,
9a03a746 7637 tree ARG_UNUSED (args),
7638 int ARG_UNUSED (flags), bool *no_add_attrs)
8a8cdb8d 7639{
7640 /* Ignore the attribute for functions not returning any value. */
7641 if (VOID_TYPE_P (TREE_TYPE (*node)))
7642 {
9b2d6d13 7643 warning (OPT_Wattributes, "%qE attribute ignored", name);
8a8cdb8d 7644 *no_add_attrs = true;
7645 }
7646
7647 return NULL_TREE;
7648}
bf6c8de0 7649
7650/* Handle a "sentinel" attribute. */
7651
7652static tree
50ca527f 7653handle_sentinel_attribute (tree *node, tree name, tree args,
bf6c8de0 7654 int ARG_UNUSED (flags), bool *no_add_attrs)
7655{
7656 tree params = TYPE_ARG_TYPES (*node);
7657
a36cf284 7658 if (!prototype_p (*node))
bf6c8de0 7659 {
9b2d6d13 7660 warning (OPT_Wattributes,
7661 "%qE attribute requires prototypes with named arguments", name);
bf6c8de0 7662 *no_add_attrs = true;
bf6c8de0 7663 }
50ca527f 7664 else
7665 {
7666 while (TREE_CHAIN (params))
7667 params = TREE_CHAIN (params);
bf6c8de0 7668
50ca527f 7669 if (VOID_TYPE_P (TREE_VALUE (params)))
a0c938f0 7670 {
9b2d6d13 7671 warning (OPT_Wattributes,
7672 "%qE attribute only applies to variadic functions", name);
50ca527f 7673 *no_add_attrs = true;
7674 }
7675 }
a0c938f0 7676
50ca527f 7677 if (args)
bf6c8de0 7678 {
50ca527f 7679 tree position = TREE_VALUE (args);
7680
50ca527f 7681 if (TREE_CODE (position) != INTEGER_CST)
a0c938f0 7682 {
48e1416a 7683 warning (OPT_Wattributes,
01b54db5 7684 "requested position is not an integer constant");
50ca527f 7685 *no_add_attrs = true;
7686 }
7687 else
a0c938f0 7688 {
50ca527f 7689 if (tree_int_cst_lt (position, integer_zero_node))
7690 {
01b54db5 7691 warning (OPT_Wattributes,
7692 "requested position is less than zero");
50ca527f 7693 *no_add_attrs = true;
7694 }
7695 }
bf6c8de0 7696 }
a0c938f0 7697
bf6c8de0 7698 return NULL_TREE;
7699}
b5c26b42 7700
7701/* Handle a "type_generic" attribute. */
7702
7703static tree
7704handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7705 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7706 bool * ARG_UNUSED (no_add_attrs))
7707{
19fbe3a4 7708 tree params;
48e1416a 7709
19fbe3a4 7710 /* Ensure we have a function type. */
7711 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
48e1416a 7712
19fbe3a4 7713 params = TYPE_ARG_TYPES (*node);
7714 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7715 params = TREE_CHAIN (params);
7716
7717 /* Ensure we have a variadic function. */
7718 gcc_assert (!params);
b5c26b42 7719
7720 return NULL_TREE;
7721}
46f8e3b0 7722
24470055 7723/* Handle a "target" attribute. */
46f8e3b0 7724
7725static tree
24470055 7726handle_target_attribute (tree *node, tree name, tree args, int flags,
46f8e3b0 7727 bool *no_add_attrs)
7728{
7729 /* Ensure we have a function type. */
7730 if (TREE_CODE (*node) != FUNCTION_DECL)
7731 {
7732 warning (OPT_Wattributes, "%qE attribute ignored", name);
7733 *no_add_attrs = true;
7734 }
46f8e3b0 7735 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7736 flags))
7737 *no_add_attrs = true;
7738
7739 return NULL_TREE;
7740}
7741
7742/* Arguments being collected for optimization. */
7743typedef const char *const_char_p; /* For DEF_VEC_P. */
7744DEF_VEC_P(const_char_p);
7745DEF_VEC_ALLOC_P(const_char_p, gc);
7746static GTY(()) VEC(const_char_p, gc) *optimize_args;
7747
7748
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. */
7752
7753bool
7754parse_optimize_options (tree args, bool attr_p)
7755{
7756 bool ret = true;
7757 unsigned opt_argc;
7758 unsigned i;
2becf397 7759 int saved_flag_strict_aliasing;
46f8e3b0 7760 const char **opt_argv;
615ef0bb 7761 struct cl_decoded_option *decoded_options;
7762 unsigned int decoded_options_count;
46f8e3b0 7763 tree ap;
7764
7765 /* Build up argv vector. Just in case the string is stored away, use garbage
7766 collected strings. */
7767 VEC_truncate (const_char_p, optimize_args, 0);
7768 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7769
7770 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7771 {
7772 tree value = TREE_VALUE (ap);
7773
7774 if (TREE_CODE (value) == INTEGER_CST)
7775 {
7776 char buffer[20];
7777 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7778 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7779 }
7780
7781 else if (TREE_CODE (value) == STRING_CST)
7782 {
7783 /* Split string into multiple substrings. */
7784 size_t len = TREE_STRING_LENGTH (value);
7785 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7786 char *end = p + len;
7787 char *comma;
7788 char *next_p = p;
7789
7790 while (next_p != NULL)
7791 {
7792 size_t len2;
7793 char *q, *r;
7794
7795 p = next_p;
7796 comma = strchr (p, ',');
7797 if (comma)
7798 {
7799 len2 = comma - p;
7800 *comma = '\0';
7801 next_p = comma+1;
7802 }
7803 else
7804 {
7805 len2 = end - p;
7806 next_p = NULL;
7807 }
7808
ba72912a 7809 r = q = (char *) ggc_alloc_atomic (len2 + 3);
46f8e3b0 7810
7811 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7812 options. */
7813 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7814 {
7815 ret = false;
7816 if (attr_p)
7817 warning (OPT_Wattributes,
ebd7c4c1 7818 "bad option %s to optimize attribute", p);
46f8e3b0 7819 else
7820 warning (OPT_Wpragmas,
e44b0a1f 7821 "bad option %s to pragma attribute", p);
46f8e3b0 7822 continue;
7823 }
7824
7825 if (*p != '-')
7826 {
7827 *r++ = '-';
7828
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. */
7831 if ((*p >= '0' && *p <= '9')
7832 || (p[0] == 's' && p[1] == '\0'))
7833 *r++ = 'O';
7834 else if (*p != 'O')
7835 *r++ = 'f';
7836 }
7837
7838 memcpy (r, p, len2);
7839 r[len2] = '\0';
7840 VEC_safe_push (const_char_p, gc, optimize_args, q);
7841 }
7842
7843 }
7844 }
7845
7846 opt_argc = VEC_length (const_char_p, optimize_args);
7847 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7848
7849 for (i = 1; i < opt_argc; i++)
7850 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7851
2becf397 7852 saved_flag_strict_aliasing = flag_strict_aliasing;
7853
46f8e3b0 7854 /* Now parse the options. */
f3f006ad 7855 decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv,
7856 &decoded_options,
7857 &decoded_options_count);
7858 decode_options (&global_options, &global_options_set,
3c6c0e40 7859 decoded_options, decoded_options_count,
7860 input_location, global_dc);
46f8e3b0 7861
4bec06b3 7862 targetm.override_options_after_change();
7863
2becf397 7864 /* Don't allow changing -fstrict-aliasing. */
7865 flag_strict_aliasing = saved_flag_strict_aliasing;
7866
46f8e3b0 7867 VEC_truncate (const_char_p, optimize_args, 0);
7868 return ret;
7869}
7870
7871/* For handling "optimize" attribute. arguments as in
7872 struct attribute_spec.handler. */
7873
7874static tree
7875handle_optimize_attribute (tree *node, tree name, tree args,
7876 int ARG_UNUSED (flags), bool *no_add_attrs)
7877{
7878 /* Ensure we have a function type. */
7879 if (TREE_CODE (*node) != FUNCTION_DECL)
7880 {
7881 warning (OPT_Wattributes, "%qE attribute ignored", name);
7882 *no_add_attrs = true;
7883 }
7884 else
7885 {
7886 struct cl_optimization cur_opts;
7887 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7888
7889 /* Save current options. */
2c5d2e39 7890 cl_optimization_save (&cur_opts, &global_options);
46f8e3b0 7891
7892 /* If we previously had some optimization options, use them as the
7893 default. */
7894 if (old_opts)
2c5d2e39 7895 cl_optimization_restore (&global_options,
7896 TREE_OPTIMIZATION (old_opts));
46f8e3b0 7897
7898 /* Parse options, and update the vector. */
7899 parse_optimize_options (args, true);
7900 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7901 = build_optimization_node ();
7902
7903 /* Restore current options. */
2c5d2e39 7904 cl_optimization_restore (&global_options, &cur_opts);
46f8e3b0 7905 }
7906
7907 return NULL_TREE;
7908}
48b14f50 7909
7910/* Handle a "no_split_stack" attribute. */
7911
7912static tree
7913handle_no_split_stack_attribute (tree *node, tree name,
7914 tree ARG_UNUSED (args),
7915 int ARG_UNUSED (flags),
7916 bool *no_add_attrs)
7917{
7918 tree decl = *node;
7919
7920 if (TREE_CODE (decl) != FUNCTION_DECL)
7921 {
7922 error_at (DECL_SOURCE_LOCATION (decl),
7923 "%qE attribute applies only to functions", name);
7924 *no_add_attrs = true;
7925 }
7926 else if (DECL_INITIAL (decl))
7927 {
7928 error_at (DECL_SOURCE_LOCATION (decl),
7929 "can%'t set %qE attribute after definition", name);
7930 *no_add_attrs = true;
7931 }
7932
7933 return NULL_TREE;
7934}
dbf6c367 7935\f
d01f58f9 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 */
dbf6c367 7940void
d01f58f9 7941check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
dbf6c367 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. */
7945
7946 if (warn_nonnull)
d01f58f9 7947 check_function_nonnull (attrs, nargs, argarray);
dbf6c367 7948
7949 /* Check for errors in format strings. */
7950
95c90e04 7951 if (warn_format || warn_missing_format_attribute)
d01f58f9 7952 check_function_format (attrs, nargs, argarray);
95c90e04 7953
7954 if (warn_format)
d01f58f9 7955 check_function_sentinel (attrs, nargs, argarray, typelist);
dbf6c367 7956}
7957
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. */
7961void
1cae46be 7962check_function_arguments_recurse (void (*callback)
7963 (void *, tree, unsigned HOST_WIDE_INT),
7964 void *ctx, tree param,
7965 unsigned HOST_WIDE_INT param_num)
dbf6c367 7966{
72dd6141 7967 if (CONVERT_EXPR_P (param)
c44afe23 7968 && (TYPE_PRECISION (TREE_TYPE (param))
7969 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
dbf6c367 7970 {
7971 /* Strip coercion. */
7972 check_function_arguments_recurse (callback, ctx,
4ee9c684 7973 TREE_OPERAND (param, 0), param_num);
dbf6c367 7974 return;
7975 }
7976
7977 if (TREE_CODE (param) == CALL_EXPR)
7978 {
c2f47e15 7979 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
dbf6c367 7980 tree attrs;
7981 bool found_format_arg = false;
7982
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). */
7986
7987 for (attrs = TYPE_ATTRIBUTES (type);
7988 attrs;
7989 attrs = TREE_CHAIN (attrs))
7990 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7991 {
c2f47e15 7992 tree inner_arg;
dbf6c367 7993 tree format_num_expr;
7994 int format_num;
7995 int i;
c2f47e15 7996 call_expr_arg_iterator iter;
dbf6c367 7997
7998 /* Extract the argument number, which was previously checked
7999 to be valid. */
8000 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
dbf6c367 8001
231bd014 8002 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
8003 && !TREE_INT_CST_HIGH (format_num_expr));
dbf6c367 8004
8005 format_num = TREE_INT_CST_LOW (format_num_expr);
8006
c2f47e15 8007 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
8008 inner_arg != 0;
8009 inner_arg = next_call_expr_arg (&iter), i++)
dbf6c367 8010 if (i == format_num)
8011 {
8012 check_function_arguments_recurse (callback, ctx,
c2f47e15 8013 inner_arg, param_num);
dbf6c367 8014 found_format_arg = true;
8015 break;
8016 }
8017 }
8018
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. */
8022 if (found_format_arg)
8023 return;
8024 }
8025
8026 if (TREE_CODE (param) == COND_EXPR)
8027 {
8028 /* Check both halves of the conditional expression. */
8029 check_function_arguments_recurse (callback, ctx,
4ee9c684 8030 TREE_OPERAND (param, 1), param_num);
dbf6c367 8031 check_function_arguments_recurse (callback, ctx,
4ee9c684 8032 TREE_OPERAND (param, 2), param_num);
dbf6c367 8033 return;
8034 }
8035
8036 (*callback) (ctx, param, param_num);
8037}
1f3233d1 8038
60cce472 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. */
d43cee80 8043
8044static bool
60cce472 8045builtin_function_validate_nargs (tree fndecl, int nargs, int required)
d43cee80 8046{
8047 if (nargs < required)
8048 {
60cce472 8049 error_at (input_location,
8050 "not enough arguments to function %qE", fndecl);
d43cee80 8051 return false;
8052 }
8053 else if (nargs > required)
8054 {
60cce472 8055 error_at (input_location,
8056 "too many arguments to function %qE", fndecl);
d43cee80 8057 return false;
8058 }
8059 return true;
8060}
8061
8062/* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8063 Returns false if there was an error, otherwise true. */
8064
8065bool
8066check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8067{
8068 if (!DECL_BUILT_IN (fndecl)
8069 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8070 return true;
8071
8072 switch (DECL_FUNCTION_CODE (fndecl))
8073 {
8074 case BUILT_IN_CONSTANT_P:
60cce472 8075 return builtin_function_validate_nargs (fndecl, nargs, 1);
d43cee80 8076
8077 case BUILT_IN_ISFINITE:
8078 case BUILT_IN_ISINF:
c319d56a 8079 case BUILT_IN_ISINF_SIGN:
d43cee80 8080 case BUILT_IN_ISNAN:
8081 case BUILT_IN_ISNORMAL:
60cce472 8082 if (builtin_function_validate_nargs (fndecl, nargs, 1))
d43cee80 8083 {
8084 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8085 {
8086 error ("non-floating-point argument in call to "
8087 "function %qE", fndecl);
8088 return false;
8089 }
8090 return true;
8091 }
8092 return false;
8093
8094 case BUILT_IN_ISGREATER:
8095 case BUILT_IN_ISGREATEREQUAL:
8096 case BUILT_IN_ISLESS:
8097 case BUILT_IN_ISLESSEQUAL:
8098 case BUILT_IN_ISLESSGREATER:
8099 case BUILT_IN_ISUNORDERED:
60cce472 8100 if (builtin_function_validate_nargs (fndecl, nargs, 2))
d43cee80 8101 {
8102 enum tree_code code0, code1;
8103 code0 = TREE_CODE (TREE_TYPE (args[0]));
8104 code1 = TREE_CODE (TREE_TYPE (args[1]));
8105 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8106 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8107 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8108 {
8109 error ("non-floating-point arguments in call to "
8110 "function %qE", fndecl);
8111 return false;
8112 }
8113 return true;
8114 }
8115 return false;
8116
19fbe3a4 8117 case BUILT_IN_FPCLASSIFY:
60cce472 8118 if (builtin_function_validate_nargs (fndecl, nargs, 6))
19fbe3a4 8119 {
8120 unsigned i;
48e1416a 8121
19fbe3a4 8122 for (i=0; i<5; i++)
8123 if (TREE_CODE (args[i]) != INTEGER_CST)
8124 {
8125 error ("non-const integer argument %u in call to function %qE",
8126 i+1, fndecl);
8127 return false;
8128 }
8129
8130 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8131 {
8132 error ("non-floating-point argument in call to function %qE",
8133 fndecl);
8134 return false;
8135 }
8136 return true;
8137 }
8138 return false;
8139
d43cee80 8140 default:
8141 return true;
8142 }
8143}
8144
860251be 8145/* Function to help qsort sort FIELD_DECLs by name order. */
8146
8147int
8148field_decl_cmp (const void *x_p, const void *y_p)
8149{
4fd61bc6 8150 const tree *const x = (const tree *const) x_p;
8151 const tree *const y = (const tree *const) y_p;
8152
860251be 8153 if (DECL_NAME (*x) == DECL_NAME (*y))
8154 /* A nontype is "greater" than a type. */
8155 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8156 if (DECL_NAME (*x) == NULL_TREE)
8157 return -1;
8158 if (DECL_NAME (*y) == NULL_TREE)
8159 return 1;
8160 if (DECL_NAME (*x) < DECL_NAME (*y))
8161 return -1;
8162 return 1;
8163}
8164
8165static struct {
8166 gt_pointer_operator new_value;
8167 void *cookie;
8168} resort_data;
8169
8170/* This routine compares two fields like field_decl_cmp but using the
8171pointer operator in resort_data. */
8172
8173static int
8174resort_field_decl_cmp (const void *x_p, const void *y_p)
8175{
4fd61bc6 8176 const tree *const x = (const tree *const) x_p;
8177 const tree *const y = (const tree *const) y_p;
860251be 8178
8179 if (DECL_NAME (*x) == DECL_NAME (*y))
8180 /* A nontype is "greater" than a type. */
8181 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8182 if (DECL_NAME (*x) == NULL_TREE)
8183 return -1;
8184 if (DECL_NAME (*y) == NULL_TREE)
8185 return 1;
8186 {
8187 tree d1 = DECL_NAME (*x);
8188 tree d2 = DECL_NAME (*y);
8189 resort_data.new_value (&d1, resort_data.cookie);
8190 resort_data.new_value (&d2, resort_data.cookie);
8191 if (d1 < d2)
8192 return -1;
8193 }
8194 return 1;
8195}
8196
8197/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8198
8199void
8200resort_sorted_fields (void *obj,
9a03a746 8201 void * ARG_UNUSED (orig_obj),
4ee9c684 8202 gt_pointer_operator new_value,
8203 void *cookie)
860251be 8204{
9a03a746 8205 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
860251be 8206 resort_data.new_value = new_value;
8207 resort_data.cookie = cookie;
8208 qsort (&sf->elts[0], sf->len, sizeof (tree),
4ee9c684 8209 resort_field_decl_cmp);
860251be 8210}
8211
209c9752 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
cfee01e3 8215 RHS_SIZE is its length (including the terminating NUL character).
209c9752 8216
8217 The caller is responsible for deleting the returned pointer. */
8218
8219static char *
8220catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8221{
8222 const int lhs_size = strlen (lhs);
8223 char *result = XNEWVEC (char, lhs_size + rhs_size);
8224 strncpy (result, lhs, lhs_size);
8225 strncpy (result + lhs_size, rhs_start, rhs_size);
8226 return result;
8227}
8228
380c6697 8229/* Issue the error given by GMSGID, indicating that it occurred before
92b128ed 8230 TOKEN, which had the associated VALUE. */
8231
8232void
48e1416a 8233c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
ba99525e 8234 tree value, unsigned char token_flags)
92b128ed 8235{
209c9752 8236#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8237
8238 char *message = NULL;
92b128ed 8239
ba99525e 8240 if (token_type == CPP_EOF)
380c6697 8241 message = catenate_messages (gmsgid, " at end of input");
48e1416a 8242 else if (token_type == CPP_CHAR
8243 || token_type == CPP_WCHAR
ba99525e 8244 || token_type == CPP_CHAR16
8245 || token_type == CPP_CHAR32)
92b128ed 8246 {
8247 unsigned int val = TREE_INT_CST_LOW (value);
924bbf02 8248 const char *prefix;
8249
ba99525e 8250 switch (token_type)
924bbf02 8251 {
8252 default:
8253 prefix = "";
8254 break;
8255 case CPP_WCHAR:
8256 prefix = "L";
8257 break;
8258 case CPP_CHAR16:
8259 prefix = "u";
8260 break;
8261 case CPP_CHAR32:
8262 prefix = "U";
8263 break;
8264 }
8265
92b128ed 8266 if (val <= UCHAR_MAX && ISGRAPH (val))
a0c938f0 8267 message = catenate_messages (gmsgid, " before %s'%c'");
92b128ed 8268 else
a0c938f0 8269 message = catenate_messages (gmsgid, " before %s'\\x%x'");
209c9752 8270
924bbf02 8271 error (message, prefix, val);
209c9752 8272 free (message);
8273 message = NULL;
92b128ed 8274 }
48e1416a 8275 else if (token_type == CPP_STRING
8276 || token_type == CPP_WSTRING
ba99525e 8277 || token_type == CPP_STRING16
538ba11a 8278 || token_type == CPP_STRING32
8279 || token_type == CPP_UTF8STRING)
380c6697 8280 message = catenate_messages (gmsgid, " before string constant");
ba99525e 8281 else if (token_type == CPP_NUMBER)
380c6697 8282 message = catenate_messages (gmsgid, " before numeric constant");
ba99525e 8283 else if (token_type == CPP_NAME)
209c9752 8284 {
380c6697 8285 message = catenate_messages (gmsgid, " before %qE");
782858b8 8286 error (message, value);
209c9752 8287 free (message);
8288 message = NULL;
8289 }
ba99525e 8290 else if (token_type == CPP_PRAGMA)
b75b98aa 8291 message = catenate_messages (gmsgid, " before %<#pragma%>");
ba99525e 8292 else if (token_type == CPP_PRAGMA_EOL)
b75b98aa 8293 message = catenate_messages (gmsgid, " before end of line");
ba99525e 8294 else if (token_type < N_TTYPES)
209c9752 8295 {
380c6697 8296 message = catenate_messages (gmsgid, " before %qs token");
ba99525e 8297 error (message, cpp_type2name (token_type, token_flags));
209c9752 8298 free (message);
8299 message = NULL;
8300 }
92b128ed 8301 else
380c6697 8302 error (gmsgid);
209c9752 8303
8304 if (message)
8305 {
8306 error (message);
8307 free (message);
8308 }
a0c938f0 8309#undef catenate_messages
92b128ed 8310}
8311
3a79f5da 8312/* Mapping for cpp message reasons to the options that enable them. */
8313
8314struct reason_option_codes_t
8315{
8316 const int reason; /* cpplib message reason. */
8317 const int option_code; /* gcc option that controls this message. */
8318};
8319
8320static const struct reason_option_codes_t option_codes[] = {
8321 {CPP_W_DEPRECATED, OPT_Wdeprecated},
67089c6b 8322 {CPP_W_COMMENTS, OPT_Wcomment},
3a79f5da 8323 {CPP_W_TRIGRAPHS, OPT_Wtrigraphs},
8324 {CPP_W_MULTICHAR, OPT_Wmultichar},
8325 {CPP_W_TRADITIONAL, OPT_Wtraditional},
8326 {CPP_W_LONG_LONG, OPT_Wlong_long},
8327 {CPP_W_ENDIF_LABELS, OPT_Wendif_labels},
8328 {CPP_W_VARIADIC_MACROS, OPT_Wvariadic_macros},
8329 {CPP_W_BUILTIN_MACRO_REDEFINED, OPT_Wbuiltin_macro_redefined},
8330 {CPP_W_UNDEF, OPT_Wundef},
8331 {CPP_W_UNUSED_MACROS, OPT_Wunused_macros},
8332 {CPP_W_CXX_OPERATOR_NAMES, OPT_Wc___compat},
8333 {CPP_W_NORMALIZE, OPT_Wnormalized_},
8334 {CPP_W_INVALID_PCH, OPT_Winvalid_pch},
8335 {CPP_W_WARNING_DIRECTIVE, OPT_Wcpp},
8336 {CPP_W_NONE, 0}
8337};
8338
8339/* Return the gcc option code associated with the reason for a cpp
8340 message, or 0 if none. */
8341
8342static int
8343c_option_controlling_cpp_error (int reason)
8344{
8345 const struct reason_option_codes_t *entry;
8346
8347 for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8348 {
8349 if (entry->reason == reason)
8350 return entry->option_code;
8351 }
8352 return 0;
8353}
8354
7f5f3953 8355/* Callback from cpp_error for PFILE to print diagnostics from the
3a79f5da 8356 preprocessor. The diagnostic is of type LEVEL, with REASON set
8357 to the reason code if LEVEL is represents a warning, at location
7f5f3953 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. */
8363
8364bool
3a79f5da 8365c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
7f5f3953 8366 location_t location, unsigned int column_override,
8367 const char *msg, va_list *ap)
8368{
8369 diagnostic_info diagnostic;
8370 diagnostic_t dlevel;
5ae82d58 8371 bool save_warn_system_headers = global_dc->dc_warn_system_headers;
7f5f3953 8372 bool ret;
8373
8374 switch (level)
8375 {
8376 case CPP_DL_WARNING_SYSHDR:
8377 if (flag_no_output)
8378 return false;
5ae82d58 8379 global_dc->dc_warn_system_headers = 1;
7f5f3953 8380 /* Fall through. */
8381 case CPP_DL_WARNING:
8382 if (flag_no_output)
8383 return false;
8384 dlevel = DK_WARNING;
8385 break;
8386 case CPP_DL_PEDWARN:
8387 if (flag_no_output && !flag_pedantic_errors)
8388 return false;
8389 dlevel = DK_PEDWARN;
8390 break;
8391 case CPP_DL_ERROR:
8392 dlevel = DK_ERROR;
8393 break;
8394 case CPP_DL_ICE:
8395 dlevel = DK_ICE;
8396 break;
8397 case CPP_DL_NOTE:
8398 dlevel = DK_NOTE;
8399 break;
ff903809 8400 case CPP_DL_FATAL:
8401 dlevel = DK_FATAL;
8402 break;
7f5f3953 8403 default:
8404 gcc_unreachable ();
8405 }
8406 if (done_lexing)
8407 location = input_location;
8408 diagnostic_set_info_translated (&diagnostic, msg, ap,
8409 location, dlevel);
8410 if (column_override)
8411 diagnostic_override_column (&diagnostic, column_override);
3a79f5da 8412 diagnostic_override_option_index (&diagnostic,
8413 c_option_controlling_cpp_error (reason));
7f5f3953 8414 ret = report_diagnostic (&diagnostic);
8415 if (level == CPP_DL_WARNING_SYSHDR)
5ae82d58 8416 global_dc->dc_warn_system_headers = save_warn_system_headers;
7f5f3953 8417 return ret;
8418}
8419
624d37a6 8420/* Convert a character from the host to the target execution character
8421 set. cpplib handles this, mostly. */
8422
8423HOST_WIDE_INT
8424c_common_to_target_charset (HOST_WIDE_INT c)
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. */
8430 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8431
8432 uc = cpp_host_to_exec_charset (parse_in, uc);
8433
8434 if (flag_signed_char)
8435 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8436 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8437 else
8438 return uc;
8439}
8440
af28855b 8441/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
d897f7c2 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. */
af28855b 8445
8446static tree
d897f7c2 8447fold_offsetof_1 (tree expr, tree stop_ref)
af28855b 8448{
8449 enum tree_code code = PLUS_EXPR;
8450 tree base, off, t;
8451
d897f7c2 8452 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8453 return size_zero_node;
8454
af28855b 8455 switch (TREE_CODE (expr))
8456 {
8457 case ERROR_MARK:
8458 return expr;
8459
6b11d2e3 8460 case VAR_DECL:
8461 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8462 return error_mark_node;
8463
d897f7c2 8464 case CALL_EXPR:
cf1a89a3 8465 case TARGET_EXPR:
d897f7c2 8466 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8467 return error_mark_node;
8468
d897f7c2 8469 case NOP_EXPR:
8470 case INDIRECT_REF:
64ed018c 8471 if (!integer_zerop (TREE_OPERAND (expr, 0)))
8472 {
8473 error ("cannot apply %<offsetof%> to a non constant address");
8474 return error_mark_node;
8475 }
8476 return size_zero_node;
d897f7c2 8477
af28855b 8478 case COMPONENT_REF:
d897f7c2 8479 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
af28855b 8480 if (base == error_mark_node)
8481 return base;
8482
8483 t = TREE_OPERAND (expr, 1);
8484 if (DECL_C_BIT_FIELD (t))
8485 {
8486 error ("attempt to take address of bit-field structure "
782858b8 8487 "member %qD", t);
af28855b 8488 return error_mark_node;
8489 }
389dd41b 8490 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8491 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8492 1)
8493 / BITS_PER_UNIT));
af28855b 8494 break;
8495
8496 case ARRAY_REF:
d897f7c2 8497 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
af28855b 8498 if (base == error_mark_node)
8499 return base;
8500
8501 t = TREE_OPERAND (expr, 1);
8502 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8503 {
8504 code = MINUS_EXPR;
389dd41b 8505 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
af28855b 8506 }
8507 t = convert (sizetype, t);
8508 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
64ed018c 8509
8510 /* Check if the offset goes beyond the upper bound of the array. */
e0559d69 8511 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8512 {
8513 tree upbound = array_ref_up_bound (expr);
8514 if (upbound != NULL_TREE
8515 && TREE_CODE (upbound) == INTEGER_CST
8516 && !tree_int_cst_equal (upbound,
8517 TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8518 {
8519 upbound = size_binop (PLUS_EXPR, upbound,
8520 build_int_cst (TREE_TYPE (upbound), 1));
8521 if (tree_int_cst_lt (upbound, t))
8522 {
8523 tree v;
8524
8525 for (v = TREE_OPERAND (expr, 0);
8526 TREE_CODE (v) == COMPONENT_REF;
8527 v = TREE_OPERAND (v, 0))
8528 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8529 == RECORD_TYPE)
8530 {
1767a056 8531 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8532 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
e0559d69 8533 if (TREE_CODE (fld_chain) == FIELD_DECL)
8534 break;
8535
8536 if (fld_chain)
8537 break;
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. */
8542 if (TREE_CODE (v) == ARRAY_REF
8543 || TREE_CODE (v) == COMPONENT_REF)
8544 warning (OPT_Warray_bounds,
8545 "index %E denotes an offset "
8546 "greater than size of %qT",
8547 t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8548 }
8549 }
8550 }
af28855b 8551 break;
8552
ede90cc2 8553 case COMPOUND_EXPR:
8554 /* Handle static members of volatile structs. */
8555 t = TREE_OPERAND (expr, 1);
8556 gcc_assert (TREE_CODE (t) == VAR_DECL);
8557 return fold_offsetof_1 (t, stop_ref);
8558
af28855b 8559 default:
231bd014 8560 gcc_unreachable ();
af28855b 8561 }
8562
8563 return size_binop (code, base, off);
8564}
8565
8566tree
d897f7c2 8567fold_offsetof (tree expr, tree stop_ref)
af28855b 8568{
8569 /* Convert back from the internal sizetype to size_t. */
d897f7c2 8570 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
af28855b 8571}
8572
b9bdfa0b 8573/* Warn for A ?: C expressions (with B omitted) where A is a boolean
8574 expression, because B will always be true. */
8575
8576void
8577warn_for_omitted_condop (location_t location, tree cond)
8578{
8579 if (truth_value_p (TREE_CODE (cond)))
8580 warning_at (location, OPT_Wparentheses,
8581 "the omitted middle operand in ?: will always be %<true%>, "
8582 "suggest explicit middle operand");
8583}
8584
a1f90215 8585/* Give an error for storing into ARG, which is 'const'. USE indicates
8586 how ARG was being used. */
8587
8588void
8589readonly_error (tree arg, enum lvalue_use use)
8590{
8591 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
8592 || use == lv_asm);
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))))
8599 if (TREE_CODE (arg) == COMPONENT_REF)
8600 {
8601 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
8602 error (READONLY_MSG (G_("assignment of member "
8603 "%qD in read-only object"),
8604 G_("increment of member "
8605 "%qD in read-only object"),
8606 G_("decrement of member "
8607 "%qD in read-only object"),
8608 G_("member %qD in read-only object "
8609 "used as %<asm%> output")),
8610 TREE_OPERAND (arg, 1));
8611 else
8612 error (READONLY_MSG (G_("assignment of read-only member %qD"),
8613 G_("increment of read-only member %qD"),
8614 G_("decrement of read-only member %qD"),
8615 G_("read-only member %qD used as %<asm%> output")),
8616 TREE_OPERAND (arg, 1));
8617 }
8618 else if (TREE_CODE (arg) == VAR_DECL)
8619 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
8620 G_("increment of read-only variable %qD"),
8621 G_("decrement of read-only variable %qD"),
8622 G_("read-only variable %qD used as %<asm%> output")),
8623 arg);
8624 else if (TREE_CODE (arg) == PARM_DECL)
8625 error (READONLY_MSG (G_("assignment of read-only parameter %qD"),
8626 G_("increment of read-only parameter %qD"),
8627 G_("decrement of read-only parameter %qD"),
8628 G_("read-only parameter %qD use as %<asm%> output")),
8629 arg);
8630 else if (TREE_CODE (arg) == RESULT_DECL)
8631 {
8632 gcc_assert (c_dialect_cxx ());
8633 error (READONLY_MSG (G_("assignment of "
8634 "read-only named return value %qD"),
8635 G_("increment of "
8636 "read-only named return value %qD"),
8637 G_("decrement of "
8638 "read-only named return value %qD"),
8639 G_("read-only named return value %qD "
8640 "used as %<asm%>output")),
8641 arg);
8642 }
8643 else if (TREE_CODE (arg) == FUNCTION_DECL)
8644 error (READONLY_MSG (G_("assignment of function %qD"),
8645 G_("increment of function %qD"),
8646 G_("decrement of function %qD"),
8647 G_("function %qD used as %<asm%> output")),
8648 arg);
8649 else
8650 error (READONLY_MSG (G_("assignment of read-only location %qE"),
8651 G_("increment of read-only location %qE"),
8652 G_("decrement of read-only location %qE"),
8653 G_("read-only location %qE used as %<asm%> output")),
8654 arg);
8655}
8656
e35976b1 8657/* Print an error message for an invalid lvalue. USE says
fdd84b77 8658 how the lvalue is being used and so selects the error message. LOC
8659 is the location for the error. */
ab6bb714 8660
e35976b1 8661void
fdd84b77 8662lvalue_error (location_t loc, enum lvalue_use use)
ab6bb714 8663{
e35976b1 8664 switch (use)
ab6bb714 8665 {
e35976b1 8666 case lv_assign:
fdd84b77 8667 error_at (loc, "lvalue required as left operand of assignment");
e35976b1 8668 break;
8669 case lv_increment:
fdd84b77 8670 error_at (loc, "lvalue required as increment operand");
e35976b1 8671 break;
8672 case lv_decrement:
fdd84b77 8673 error_at (loc, "lvalue required as decrement operand");
e35976b1 8674 break;
8675 case lv_addressof:
fdd84b77 8676 error_at (loc, "lvalue required as unary %<&%> operand");
e35976b1 8677 break;
8678 case lv_asm:
fdd84b77 8679 error_at (loc, "lvalue required in asm statement");
e35976b1 8680 break;
8681 default:
8682 gcc_unreachable ();
ab6bb714 8683 }
ab6bb714 8684}
b1bbc8e5 8685
8686/* Print an error message for an invalid indirection of type TYPE.
8687 ERRSTRING is the name of the operator for the indirection. */
8688
8689void
8690invalid_indirection_error (location_t loc, tree type, ref_operator errstring)
8691{
8692 switch (errstring)
8693 {
8694 case RO_NULL:
8695 gcc_assert (c_dialect_cxx ());
8696 error_at (loc, "invalid type argument (have %qT)", type);
8697 break;
8698 case RO_ARRAY_INDEXING:
8699 error_at (loc,
8700 "invalid type argument of array indexing (have %qT)",
8701 type);
8702 break;
8703 case RO_UNARY_STAR:
8704 error_at (loc,
8705 "invalid type argument of unary %<*%> (have %qT)",
8706 type);
8707 break;
8708 case RO_ARROW:
8709 error_at (loc,
8710 "invalid type argument of %<->%> (have %qT)",
8711 type);
8712 break;
8713 case RO_IMPLICIT_CONVERSION:
8714 error_at (loc,
8715 "invalid type argument of implicit conversion (have %qT)",
8716 type);
8717 break;
8718 default:
8719 gcc_unreachable ();
8720 }
8721}
c271bdb2 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. */
8727
8728int
8729complete_array_type (tree *ptype, tree initial_value, bool do_default)
8730{
8731 tree maxindex, type, main_type, elt, unqual_elt;
8732 int failure = 0, quals;
6753bca0 8733 hashval_t hashcode = 0;
c271bdb2 8734
8735 maxindex = size_zero_node;
8736 if (initial_value)
8737 {
8738 if (TREE_CODE (initial_value) == STRING_CST)
8739 {
8740 int eltsize
8741 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8742 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8743 }
8744 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8745 {
c75b4594 8746 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
c271bdb2 8747
c75b4594 8748 if (VEC_empty (constructor_elt, v))
c271bdb2 8749 {
8750 if (pedantic)
8751 failure = 3;
8752 maxindex = integer_minus_one_node;
8753 }
8754 else
8755 {
8756 tree curindex;
c75b4594 8757 unsigned HOST_WIDE_INT cnt;
8758 constructor_elt *ce;
cee43f7e 8759 bool fold_p = false;
c271bdb2 8760
c75b4594 8761 if (VEC_index (constructor_elt, v, 0)->index)
389dd41b 8762 maxindex = fold_convert_loc (input_location, sizetype,
8763 VEC_index (constructor_elt,
8764 v, 0)->index);
c271bdb2 8765 curindex = maxindex;
8766
c75b4594 8767 for (cnt = 1;
8768 VEC_iterate (constructor_elt, v, cnt, ce);
8769 cnt++)
c271bdb2 8770 {
cee43f7e 8771 bool curfold_p = false;
c75b4594 8772 if (ce->index)
cee43f7e 8773 curindex = ce->index, curfold_p = true;
c271bdb2 8774 else
cee43f7e 8775 {
8776 if (fold_p)
8777 curindex = fold_convert (sizetype, curindex);
389dd41b 8778 curindex = size_binop (PLUS_EXPR, curindex,
8779 size_one_node);
cee43f7e 8780 }
c271bdb2 8781 if (tree_int_cst_lt (maxindex, curindex))
cee43f7e 8782 maxindex = curindex, fold_p = curfold_p;
c271bdb2 8783 }
cee43f7e 8784 if (fold_p)
8785 maxindex = fold_convert (sizetype, maxindex);
c271bdb2 8786 }
8787 }
8788 else
8789 {
8790 /* Make an error message unless that happened already. */
8791 if (initial_value != error_mark_node)
8792 failure = 1;
8793 }
8794 }
8795 else
8796 {
8797 failure = 2;
8798 if (!do_default)
8799 return failure;
8800 }
8801
8802 type = *ptype;
8803 elt = TREE_TYPE (type);
8804 quals = TYPE_QUALS (strip_array_types (elt));
8805 if (quals == 0)
8806 unqual_elt = elt;
8807 else
6d5d708e 8808 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
c271bdb2 8809
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. */
8813 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8814 TREE_TYPE (main_type) = unqual_elt;
8815 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8816 layout_type (main_type);
8817
6753bca0 8818 /* Make sure we have the canonical MAIN_TYPE. */
8819 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
48e1416a 8820 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6753bca0 8821 hashcode);
8822 main_type = type_hash_canon (hashcode, main_type);
8823
796735dc 8824 /* Fix the canonical type. */
8825 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8826 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8827 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8828 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8829 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8830 != TYPE_DOMAIN (main_type)))
48e1416a 8831 TYPE_CANONICAL (main_type)
796735dc 8832 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8833 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8834 else
8835 TYPE_CANONICAL (main_type) = main_type;
8836
c271bdb2 8837 if (quals == 0)
8838 type = main_type;
8839 else
8840 type = c_build_qualified_type (main_type, quals);
8841
4f5b8f2a 8842 if (COMPLETE_TYPE_P (type)
8843 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8844 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8845 {
8846 error ("size of array is too large");
8847 /* If we proceed with the array type as it is, we'll eventually
8848 crash in tree_low_cst(). */
8849 type = error_mark_node;
8850 }
8851
c271bdb2 8852 *ptype = type;
8853 return failure;
8854}
ab6bb714 8855
93426222 8856/* Like c_mark_addressable but don't check register qualifier. */
8857void
8858c_common_mark_addressable_vec (tree t)
8859{
8860 while (handled_component_p (t))
8861 t = TREE_OPERAND (t, 0);
8862 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8863 return;
8864 TREE_ADDRESSABLE (t) = 1;
8865}
8866
8867
b6a5fc45 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. */
8873
8874tree
8875builtin_type_for_size (int size, bool unsignedp)
8876{
8877 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8878 return type ? type : error_mark_node;
8879}
8880
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. */
8885
8886static int
b9c74b4d 8887sync_resolve_size (tree function, VEC(tree,gc) *params)
b6a5fc45 8888{
8889 tree type;
8890 int size;
8891
b9c74b4d 8892 if (VEC_empty (tree, params))
b6a5fc45 8893 {
8894 error ("too few arguments to function %qE", function);
8895 return 0;
8896 }
8897
b9c74b4d 8898 type = TREE_TYPE (VEC_index (tree, params, 0));
b6a5fc45 8899 if (TREE_CODE (type) != POINTER_TYPE)
8900 goto incompatible;
8901
8902 type = TREE_TYPE (type);
8903 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8904 goto incompatible;
8905
8906 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
27213ba3 8907 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
b6a5fc45 8908 return size;
8909
8910 incompatible:
8911 error ("incompatible type for argument %d of %qE", 1, function);
8912 return 0;
8913}
8914
a0c938f0 8915/* A helper function for resolve_overloaded_builtin. Adds casts to
b6a5fc45 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. */
8919
8920static bool
b9c74b4d 8921sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
b6a5fc45 8922{
8923 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8924 tree ptype;
b9c74b4d 8925 unsigned int parmnum;
b6a5fc45 8926
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. */
8930 arg_types = TREE_CHAIN (arg_types);
b9c74b4d 8931 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
b6a5fc45 8932
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. */
b9c74b4d 8935 parmnum = 0;
b6a5fc45 8936 while (arg_types != void_list_node)
8937 {
8938 tree val;
8939
b9c74b4d 8940 ++parmnum;
8941 if (VEC_length (tree, params) <= parmnum)
b6a5fc45 8942 {
8943 error ("too few arguments to function %qE", orig_function);
8944 return false;
8945 }
8946
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. */
b9c74b4d 8950 val = VEC_index (tree, params, parmnum);
b6a5fc45 8951 val = convert (ptype, val);
8952 val = convert (TREE_VALUE (arg_types), val);
b9c74b4d 8953 VEC_replace (tree, params, parmnum, val);
b6a5fc45 8954
8955 arg_types = TREE_CHAIN (arg_types);
b6a5fc45 8956 }
8957
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. */
b9c74b4d 8962 VEC_truncate (tree, params, parmnum + 1);
b6a5fc45 8963
8964 return true;
8965}
8966
a0c938f0 8967/* A helper function for resolve_overloaded_builtin. Adds a cast to
b6a5fc45 8968 RESULT to make it match the type of the first pointer argument in
8969 PARAMS. */
8970
8971static tree
b9c74b4d 8972sync_resolve_return (tree first_param, tree result)
b6a5fc45 8973{
b9c74b4d 8974 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
10080eac 8975 ptype = TYPE_MAIN_VARIANT (ptype);
b6a5fc45 8976 return convert (ptype, result);
8977}
8978
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.
8982
e60a6f7b 8983 LOC is the location of the builtin call.
8984
b6a5fc45 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. */
8989
8990tree
e60a6f7b 8991resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
b6a5fc45 8992{
8993 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
65441f6f 8994 switch (DECL_BUILT_IN_CLASS (function))
8995 {
8996 case BUILT_IN_NORMAL:
8997 break;
8998 case BUILT_IN_MD:
8999 if (targetm.resolve_overloaded_builtin)
e60a6f7b 9000 return targetm.resolve_overloaded_builtin (loc, function, params);
65441f6f 9001 else
a0c938f0 9002 return NULL_TREE;
65441f6f 9003 default:
9004 return NULL_TREE;
9005 }
a0c938f0 9006
65441f6f 9007 /* Handle BUILT_IN_NORMAL here. */
b6a5fc45 9008 switch (orig_code)
9009 {
9010 case BUILT_IN_FETCH_AND_ADD_N:
9011 case BUILT_IN_FETCH_AND_SUB_N:
9012 case BUILT_IN_FETCH_AND_OR_N:
9013 case BUILT_IN_FETCH_AND_AND_N:
9014 case BUILT_IN_FETCH_AND_XOR_N:
9015 case BUILT_IN_FETCH_AND_NAND_N:
9016 case BUILT_IN_ADD_AND_FETCH_N:
9017 case BUILT_IN_SUB_AND_FETCH_N:
9018 case BUILT_IN_OR_AND_FETCH_N:
9019 case BUILT_IN_AND_AND_FETCH_N:
9020 case BUILT_IN_XOR_AND_FETCH_N:
9021 case BUILT_IN_NAND_AND_FETCH_N:
9022 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
9023 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
9024 case BUILT_IN_LOCK_TEST_AND_SET_N:
9025 case BUILT_IN_LOCK_RELEASE_N:
9026 {
9027 int n = sync_resolve_size (function, params);
b9c74b4d 9028 tree new_function, first_param, result;
b6a5fc45 9029
9030 if (n == 0)
9031 return error_mark_node;
9032
9033 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
9034 if (!sync_resolve_params (function, new_function, params))
9035 return error_mark_node;
9036
b9c74b4d 9037 first_param = VEC_index (tree, params, 0);
e60a6f7b 9038 result = build_function_call_vec (loc, new_function, params, NULL);
b6a5fc45 9039 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
9040 && orig_code != BUILT_IN_LOCK_RELEASE_N)
b9c74b4d 9041 result = sync_resolve_return (first_param, result);
b6a5fc45 9042
9043 return result;
9044 }
9045
9046 default:
65441f6f 9047 return NULL_TREE;
b6a5fc45 9048 }
9049}
9050
491255f5 9051/* Ignoring their sign, return true if two scalar types are the same. */
9052bool
9053same_scalar_type_ignoring_signedness (tree t1, tree t2)
9054{
9055 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
9056
9421ebb9 9057 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
9058 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
9059 || c2 == FIXED_POINT_TYPE));
491255f5 9060
9061 /* Equality works here because c_common_signed_type uses
9062 TYPE_MAIN_VARIANT. */
11773141 9063 return c_common_signed_type (t1)
9064 == c_common_signed_type (t2);
491255f5 9065}
9066
be7350e7 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. */
9071
9072bool
9073check_missing_format_attribute (tree ltype, tree rtype)
9074{
9075 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
9076 tree ra;
9077
9078 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
9079 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
9080 break;
9081 if (ra)
9082 {
9083 tree la;
9084 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
9085 if (is_attribute_p ("format", TREE_PURPOSE (la)))
9086 break;
9087 return !la;
9088 }
9089 else
9090 return false;
9091}
9092
2840aae4 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. */
9099
9100void
9101warn_array_subscript_with_type_char (tree index)
9102{
9103 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
9104 && TREE_CODE (index) != INTEGER_CST)
9105 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
9106}
9107
e534436e 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
82012ffe 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. */
e534436e 9116
9117void
82012ffe 9118warn_about_parentheses (enum tree_code code,
269f7979 9119 enum tree_code code_left, tree arg_left,
82012ffe 9120 enum tree_code code_right, tree arg_right)
e534436e 9121{
9122 if (!warn_parentheses)
9123 return;
9124
82012ffe 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 \
9131 /* Folding may create 0 or 1 integers from other expressions. */ \
9132 || ((CODE) != INTEGER_CST \
9133 && (integer_onep (ARG) || integer_zerop (ARG))))
9134
48e1416a 9135 switch (code)
e534436e 9136 {
82012ffe 9137 case LSHIFT_EXPR:
9138 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
e534436e 9139 warning (OPT_Wparentheses,
82012ffe 9140 "suggest parentheses around %<+%> inside %<<<%>");
9141 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9142 warning (OPT_Wparentheses,
9143 "suggest parentheses around %<-%> inside %<<<%>");
9144 return;
e534436e 9145
82012ffe 9146 case RSHIFT_EXPR:
9147 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
e534436e 9148 warning (OPT_Wparentheses,
82012ffe 9149 "suggest parentheses around %<+%> inside %<>>%>");
9150 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9151 warning (OPT_Wparentheses,
9152 "suggest parentheses around %<-%> inside %<>>%>");
9153 return;
e534436e 9154
82012ffe 9155 case TRUTH_ORIF_EXPR:
9156 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9157 warning (OPT_Wparentheses,
9158 "suggest parentheses around %<&&%> within %<||%>");
9159 return;
9160
9161 case BIT_IOR_EXPR:
e534436e 9162 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9163 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9164 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9165 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9166 warning (OPT_Wparentheses,
82012ffe 9167 "suggest parentheses around arithmetic in operand of %<|%>");
e534436e 9168 /* Check cases like x|y==z */
82012ffe 9169 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9170 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9171 warning (OPT_Wparentheses,
82012ffe 9172 "suggest parentheses around comparison in operand of %<|%>");
9173 /* Check cases like !x | y */
9174 else if (code_left == TRUTH_NOT_EXPR
9175 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
96bda40f 9176 warning (OPT_Wparentheses, "suggest parentheses around operand of "
82012ffe 9177 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9178 return;
e534436e 9179
82012ffe 9180 case BIT_XOR_EXPR:
e534436e 9181 if (code_left == BIT_AND_EXPR
9182 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9183 || code_right == BIT_AND_EXPR
9184 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9185 warning (OPT_Wparentheses,
82012ffe 9186 "suggest parentheses around arithmetic in operand of %<^%>");
e534436e 9187 /* Check cases like x^y==z */
82012ffe 9188 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9189 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9190 warning (OPT_Wparentheses,
82012ffe 9191 "suggest parentheses around comparison in operand of %<^%>");
9192 return;
e534436e 9193
82012ffe 9194 case BIT_AND_EXPR:
9195 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9196 warning (OPT_Wparentheses,
9197 "suggest parentheses around %<+%> in operand of %<&%>");
9198 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
e534436e 9199 warning (OPT_Wparentheses,
82012ffe 9200 "suggest parentheses around %<-%> in operand of %<&%>");
e534436e 9201 /* Check cases like x&y==z */
82012ffe 9202 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9203 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9204 warning (OPT_Wparentheses,
82012ffe 9205 "suggest parentheses around comparison in operand of %<&%>");
9206 /* Check cases like !x & y */
9207 else if (code_left == TRUTH_NOT_EXPR
9208 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
96bda40f 9209 warning (OPT_Wparentheses, "suggest parentheses around operand of "
82012ffe 9210 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9211 return;
e534436e 9212
82012ffe 9213 case EQ_EXPR:
6ce0c450 9214 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9215 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9216 warning (OPT_Wparentheses,
82012ffe 9217 "suggest parentheses around comparison in operand of %<==%>");
9218 return;
9219 case NE_EXPR:
9220 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9221 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9222 warning (OPT_Wparentheses,
9223 "suggest parentheses around comparison in operand of %<!=%>");
9224 return;
9225
9226 default:
9227 if (TREE_CODE_CLASS (code) == tcc_comparison
9228 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
269f7979 9229 && code_left != NE_EXPR && code_left != EQ_EXPR
9230 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
82012ffe 9231 || (TREE_CODE_CLASS (code_right) == tcc_comparison
269f7979 9232 && code_right != NE_EXPR && code_right != EQ_EXPR
9233 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
82012ffe 9234 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
6ce0c450 9235 "have their mathematical meaning");
82012ffe 9236 return;
6ce0c450 9237 }
82012ffe 9238#undef NOT_A_BOOLEAN_EXPR_P
e534436e 9239}
9240
92fccaaa 9241/* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9242
9243void
9244warn_for_unused_label (tree label)
9245{
9246 if (!TREE_USED (label))
9247 {
9248 if (DECL_INITIAL (label))
9249 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9250 else
9251 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9252 }
9253}
2840aae4 9254
b6889cb0 9255/* Warn for division by zero according to the value of DIVISOR. LOC
9256 is the location of the division operator. */
f092582b 9257
9258void
b6889cb0 9259warn_for_div_by_zero (location_t loc, tree divisor)
f092582b 9260{
9421ebb9 9261 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9262 about division by zero. Do not issue a warning if DIVISOR has a
f092582b 9263 floating-point type, since we consider 0.0/0.0 a valid way of
9264 generating a NaN. */
48d94ede 9265 if (c_inhibit_evaluation_warnings == 0
9421ebb9 9266 && (integer_zerop (divisor) || fixed_zerop (divisor)))
b6889cb0 9267 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
f092582b 9268}
9269
13869a99 9270/* Subroutine of build_binary_op. Give warnings for comparisons
9271 between signed and unsigned quantities that may fail. Do the
9272 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9273 so that casts will be considered, but default promotions won't
8e70fb09 9274 be.
9275
9276 LOCATION is the location of the comparison operator.
13869a99 9277
9278 The arguments of this function map directly to local variables
9279 of build_binary_op. */
9280
48e1416a 9281void
8e70fb09 9282warn_for_sign_compare (location_t location,
48e1416a 9283 tree orig_op0, tree orig_op1,
9284 tree op0, tree op1,
13869a99 9285 tree result_type, enum tree_code resultcode)
9286{
9287 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9288 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9289 int unsignedp0, unsignedp1;
48e1416a 9290
13869a99 9291 /* In C++, check for comparison of different enum types. */
9292 if (c_dialect_cxx()
9293 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9294 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9295 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
895b662f 9296 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
13869a99 9297 {
8e70fb09 9298 warning_at (location,
9299 OPT_Wsign_compare, "comparison between types %qT and %qT",
9300 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
13869a99 9301 }
9302
9303 /* Do not warn if the comparison is being done in a signed type,
9304 since the signed type will only be chosen if it can represent
9305 all the values of the unsigned type. */
9306 if (!TYPE_UNSIGNED (result_type))
9307 /* OK */;
9308 /* Do not warn if both operands are unsigned. */
9309 else if (op0_signed == op1_signed)
9310 /* OK */;
9311 else
9312 {
895b662f 9313 tree sop, uop, base_type;
13869a99 9314 bool ovf;
895b662f 9315
13869a99 9316 if (op0_signed)
9317 sop = orig_op0, uop = orig_op1;
48e1416a 9318 else
13869a99 9319 sop = orig_op1, uop = orig_op0;
9320
48e1416a 9321 STRIP_TYPE_NOPS (sop);
13869a99 9322 STRIP_TYPE_NOPS (uop);
895b662f 9323 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9324 ? TREE_TYPE (result_type) : result_type);
13869a99 9325
9326 /* Do not warn if the signed quantity is an unsuffixed integer
9327 literal (or some static constant expression involving such
9328 literals or a conditional expression involving such literals)
9329 and it is non-negative. */
9330 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9331 /* OK */;
9332 /* Do not warn if the comparison is an equality operation, the
9333 unsigned quantity is an integral constant, and it would fit
9334 in the result if the result were signed. */
9335 else if (TREE_CODE (uop) == INTEGER_CST
9336 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
895b662f 9337 && int_fits_type_p (uop, c_common_signed_type (base_type)))
13869a99 9338 /* OK */;
9339 /* In C, do not warn if the unsigned quantity is an enumeration
9340 constant and its maximum value would fit in the result if the
9341 result were signed. */
9342 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9343 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9344 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
895b662f 9345 c_common_signed_type (base_type)))
13869a99 9346 /* OK */;
48e1416a 9347 else
8e70fb09 9348 warning_at (location,
48e1416a 9349 OPT_Wsign_compare,
8e70fb09 9350 "comparison between signed and unsigned integer expressions");
13869a99 9351 }
48e1416a 9352
13869a99 9353 /* Warn if two unsigned values are being compared in a size larger
9354 than their original size, and one (and only one) is the result of
9355 a `~' operator. This comparison will always fail.
48e1416a 9356
13869a99 9357 Also warn if one operand is a constant, and the constant does not
9358 have all bits set that are set in the ~ operand when it is
9359 extended. */
9360
9361 op0 = get_narrower (op0, &unsignedp0);
9362 op1 = get_narrower (op1, &unsignedp1);
48e1416a 9363
13869a99 9364 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9365 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9366 {
9367 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9368 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9369 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9370 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9371
9372 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9373 {
9374 tree primop;
9375 HOST_WIDE_INT constant, mask;
9376 int unsignedp;
9377 unsigned int bits;
48e1416a 9378
13869a99 9379 if (host_integerp (op0, 0))
9380 {
9381 primop = op1;
9382 unsignedp = unsignedp1;
9383 constant = tree_low_cst (op0, 0);
9384 }
9385 else
9386 {
9387 primop = op0;
9388 unsignedp = unsignedp0;
9389 constant = tree_low_cst (op1, 0);
9390 }
48e1416a 9391
13869a99 9392 bits = TYPE_PRECISION (TREE_TYPE (primop));
9393 if (bits < TYPE_PRECISION (result_type)
9394 && bits < HOST_BITS_PER_LONG && unsignedp)
9395 {
9396 mask = (~ (HOST_WIDE_INT) 0) << bits;
9397 if ((mask & constant) != mask)
9398 {
9399 if (constant == 0)
48e1416a 9400 warning (OPT_Wsign_compare,
13869a99 9401 "promoted ~unsigned is always non-zero");
9402 else
48e1416a 9403 warning_at (location, OPT_Wsign_compare,
8e70fb09 9404 "comparison of promoted ~unsigned with constant");
13869a99 9405 }
9406 }
9407 }
9408 else if (unsignedp0 && unsignedp1
9409 && (TYPE_PRECISION (TREE_TYPE (op0))
9410 < TYPE_PRECISION (result_type))
9411 && (TYPE_PRECISION (TREE_TYPE (op1))
9412 < TYPE_PRECISION (result_type)))
8e70fb09 9413 warning_at (location, OPT_Wsign_compare,
13869a99 9414 "comparison of promoted ~unsigned with unsigned");
9415 }
9416}
9417
5ba33bf4 9418/* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9419 type via c_common_type. If -Wdouble-promotion is in use, and the
9420 conditions for warning have been met, issue a warning. GMSGID is
9421 the warning message. It must have two %T specifiers for the type
9422 that was converted (generally "float") and the type to which it was
9423 converted (generally "double), respectively. LOC is the location
9424 to which the awrning should refer. */
9425
9426void
9427do_warn_double_promotion (tree result_type, tree type1, tree type2,
9428 const char *gmsgid, location_t loc)
9429{
9430 tree source_type;
9431
9432 if (!warn_double_promotion)
9433 return;
9434 /* If the conversion will not occur at run-time, there is no need to
9435 warn about it. */
9436 if (c_inhibit_evaluation_warnings)
9437 return;
9438 if (TYPE_MAIN_VARIANT (result_type) != double_type_node
9439 && TYPE_MAIN_VARIANT (result_type) != complex_double_type_node)
9440 return;
9441 if (TYPE_MAIN_VARIANT (type1) == float_type_node
9442 || TYPE_MAIN_VARIANT (type1) == complex_float_type_node)
9443 source_type = type1;
9444 else if (TYPE_MAIN_VARIANT (type2) == float_type_node
9445 || TYPE_MAIN_VARIANT (type2) == complex_float_type_node)
9446 source_type = type2;
9447 else
9448 return;
9449 warning_at (loc, OPT_Wdouble_promotion, gmsgid, source_type, result_type);
9450}
9451
41771881 9452/* Setup a TYPE_DECL node as a typedef representation.
9453
9454 X is a TYPE_DECL for a typedef statement. Create a brand new
9455 ..._TYPE node (which will be just a variant of the existing
9456 ..._TYPE node with identical properties) and then install X
9457 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9458
9459 The whole point here is to end up with a situation where each
9460 and every ..._TYPE node the compiler creates will be uniquely
9461 associated with AT MOST one node representing a typedef name.
9462 This way, even though the compiler substitutes corresponding
9463 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9464 early on, later parts of the compiler can always do the reverse
9465 translation and get back the corresponding typedef name. For
9466 example, given:
9467
9468 typedef struct S MY_TYPE;
9469 MY_TYPE object;
9470
9471 Later parts of the compiler might only know that `object' was of
9472 type `struct S' if it were not for code just below. With this
9473 code however, later parts of the compiler see something like:
9474
9475 struct S' == struct S
9476 typedef struct S' MY_TYPE;
9477 struct S' object;
9478
9479 And they can then deduce (from the node for type struct S') that
9480 the original object declaration was:
9481
9482 MY_TYPE object;
9483
9484 Being able to do this is important for proper support of protoize,
9485 and also for generating precise symbolic debugging information
9486 which takes full account of the programmer's (typedef) vocabulary.
9487
9488 Obviously, we don't want to generate a duplicate ..._TYPE node if
9489 the TYPE_DECL node that we are now processing really represents a
9490 standard built-in type. */
9491
9492void
9493set_underlying_type (tree x)
9494{
9495 if (x == error_mark_node)
9496 return;
9497 if (DECL_IS_BUILTIN (x))
9498 {
9499 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9500 TYPE_NAME (TREE_TYPE (x)) = x;
9501 }
9502 else if (TREE_TYPE (x) != error_mark_node
9503 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9504 {
9505 tree tt = TREE_TYPE (x);
9506 DECL_ORIGINAL_TYPE (x) = tt;
9507 tt = build_variant_type_copy (tt);
9508 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9509 TYPE_NAME (tt) = x;
9510 TREE_USED (tt) = TREE_USED (x);
9511 TREE_TYPE (x) = tt;
9512 }
9513}
9514
1a4c44c5 9515/* Record the types used by the current global variable declaration
9516 being parsed, so that we can decide later to emit their debug info.
9517 Those types are in types_used_by_cur_var_decl, and we are going to
9518 store them in the types_used_by_vars_hash hash table.
9519 DECL is the declaration of the global variable that has been parsed. */
9520
9521void
9522record_types_used_by_current_var_decl (tree decl)
9523{
9524 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9525
aef48c9a 9526 while (!VEC_empty (tree, types_used_by_cur_var_decl))
1a4c44c5 9527 {
aef48c9a 9528 tree type = VEC_pop (tree, types_used_by_cur_var_decl);
9529 types_used_by_var_decl_insert (type, decl);
1a4c44c5 9530 }
9531}
9532
f352a3fb 9533/* The C and C++ parsers both use vectors to hold function arguments.
9534 For efficiency, we keep a cache of unused vectors. This is the
9535 cache. */
9536
9537typedef VEC(tree,gc)* tree_gc_vec;
9538DEF_VEC_P(tree_gc_vec);
9539DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9540static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9541
9542/* Return a new vector from the cache. If the cache is empty,
9543 allocate a new vector. These vectors are GC'ed, so it is OK if the
9544 pointer is not released.. */
9545
9546VEC(tree,gc) *
9547make_tree_vector (void)
9548{
9549 if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9550 return VEC_pop (tree_gc_vec, tree_vector_cache);
9551 else
9552 {
9553 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9554 that we always return a non-NULL value. The vector code uses
9555 4 when growing a NULL vector, so we do too. */
9556 return VEC_alloc (tree, gc, 4);
9557 }
9558}
9559
9560/* Release a vector of trees back to the cache. */
9561
9562void
9563release_tree_vector (VEC(tree,gc) *vec)
9564{
9565 if (vec != NULL)
9566 {
9567 VEC_truncate (tree, vec, 0);
9568 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9569 }
9570}
9571
9572/* Get a new tree vector holding a single tree. */
9573
9574VEC(tree,gc) *
9575make_tree_vector_single (tree t)
9576{
9577 VEC(tree,gc) *ret = make_tree_vector ();
9578 VEC_quick_push (tree, ret, t);
9579 return ret;
9580}
9581
9582/* Get a new tree vector which is a copy of an existing one. */
9583
9584VEC(tree,gc) *
9585make_tree_vector_copy (const VEC(tree,gc) *orig)
9586{
9587 VEC(tree,gc) *ret;
9588 unsigned int ix;
9589 tree t;
9590
9591 ret = make_tree_vector ();
9592 VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
48148244 9593 FOR_EACH_VEC_ELT (tree, orig, ix, t)
f352a3fb 9594 VEC_quick_push (tree, ret, t);
9595 return ret;
9596}
9597
a9ffdd35 9598/* Return true if KEYWORD starts a type specifier. */
9599
9600bool
9601keyword_begins_type_specifier (enum rid keyword)
9602{
9603 switch (keyword)
9604 {
9605 case RID_INT:
9606 case RID_CHAR:
9607 case RID_FLOAT:
9608 case RID_DOUBLE:
9609 case RID_VOID:
9610 case RID_INT128:
9611 case RID_UNSIGNED:
9612 case RID_LONG:
9613 case RID_SHORT:
9614 case RID_SIGNED:
9615 case RID_DFLOAT32:
9616 case RID_DFLOAT64:
9617 case RID_DFLOAT128:
9618 case RID_FRACT:
9619 case RID_ACCUM:
9620 case RID_BOOL:
9621 case RID_WCHAR:
9622 case RID_CHAR16:
9623 case RID_CHAR32:
9624 case RID_SAT:
9625 case RID_COMPLEX:
9626 case RID_TYPEOF:
9627 case RID_STRUCT:
9628 case RID_CLASS:
9629 case RID_UNION:
9630 case RID_ENUM:
9631 return true;
9632 default:
9633 return false;
9634 }
9635}
9636
9637/* Return true if KEYWORD names a type qualifier. */
9638
9639bool
9640keyword_is_type_qualifier (enum rid keyword)
9641{
9642 switch (keyword)
9643 {
9644 case RID_CONST:
9645 case RID_VOLATILE:
9646 case RID_RESTRICT:
9647 return true;
9648 default:
9649 return false;
9650 }
9651}
9652
9653/* Return true if KEYWORD names a storage class specifier.
9654
9655 RID_TYPEDEF is not included in this list despite `typedef' being
9656 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
9657 such for syntactic convenience only. */
9658
9659bool
9660keyword_is_storage_class_specifier (enum rid keyword)
9661{
9662 switch (keyword)
9663 {
9664 case RID_STATIC:
9665 case RID_EXTERN:
9666 case RID_REGISTER:
9667 case RID_AUTO:
9668 case RID_MUTABLE:
9669 case RID_THREAD:
9670 return true;
9671 default:
9672 return false;
9673 }
9674}
9675
fad3f658 9676/* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
9677
9678static bool
9679keyword_is_function_specifier (enum rid keyword)
9680{
9681 switch (keyword)
9682 {
9683 case RID_INLINE:
9684 case RID_VIRTUAL:
9685 case RID_EXPLICIT:
9686 return true;
9687 default:
9688 return false;
9689 }
9690}
9691
9692/* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
9693 declaration-specifier (C99 6.7). */
9694
9695bool
9696keyword_is_decl_specifier (enum rid keyword)
9697{
9698 if (keyword_is_storage_class_specifier (keyword)
9699 || keyword_is_type_qualifier (keyword)
9700 || keyword_is_function_specifier (keyword))
9701 return true;
9702
9703 switch (keyword)
9704 {
9705 case RID_TYPEDEF:
9706 case RID_FRIEND:
9707 case RID_CONSTEXPR:
9708 return true;
9709 default:
9710 return false;
9711 }
9712}
9713
7bedc3a0 9714#include "gt-c-family-c-common.h"
Mirror of https://gcc.gnu.org/git/gcc.git