]> 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
2011-03-25 Richard Guenther <rguenther@suse.de>
[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;
4431}
4432
dce22712 4433/* Build builtin functions common to both C and C++ language
4434 frontends. */
4435
4436static void
4437c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4438{
4439#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4440 builtin_types[ENUM] = VALUE;
4441#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4442 def_fn_type (ENUM, RETURN, 0, 0);
4443#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4444 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4445#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4446 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4447#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4448 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4449#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4450 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4451#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4452 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4453#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4454 ARG6) \
4455 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4456#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4457 ARG6, ARG7) \
4458 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4459#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4460 def_fn_type (ENUM, RETURN, 1, 0);
4461#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4462 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4463#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4464 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4465#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4466 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4467#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4468 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4469#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4470 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4471#define DEF_POINTER_TYPE(ENUM, TYPE) \
4472 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4473
4474#include "builtin-types.def"
4475
4476#undef DEF_PRIMITIVE_TYPE
4477#undef DEF_FUNCTION_TYPE_1
4478#undef DEF_FUNCTION_TYPE_2
4479#undef DEF_FUNCTION_TYPE_3
4480#undef DEF_FUNCTION_TYPE_4
4481#undef DEF_FUNCTION_TYPE_5
4482#undef DEF_FUNCTION_TYPE_6
4483#undef DEF_FUNCTION_TYPE_VAR_0
4484#undef DEF_FUNCTION_TYPE_VAR_1
4485#undef DEF_FUNCTION_TYPE_VAR_2
4486#undef DEF_FUNCTION_TYPE_VAR_3
4487#undef DEF_FUNCTION_TYPE_VAR_4
4488#undef DEF_FUNCTION_TYPE_VAR_5
4489#undef DEF_POINTER_TYPE
4490 builtin_types[(int) BT_LAST] = NULL_TREE;
4491
4492 c_init_attributes ();
4493
4494#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4495 NONANSI_P, ATTRS, IMPLICIT, COND) \
4496 if (NAME && COND) \
4497 def_builtin_1 (ENUM, NAME, CLASS, \
4498 builtin_types[(int) TYPE], \
4499 builtin_types[(int) LIBTYPE], \
4500 BOTH_P, FALLBACK_P, NONANSI_P, \
4501 built_in_attributes[(int) ATTRS], IMPLICIT);
4502#include "builtins.def"
4503#undef DEF_BUILTIN
4504
87eb1c28 4505 targetm.init_builtins ();
4506
471eff36 4507 build_common_builtin_nodes ();
dce22712 4508
dce22712 4509 if (flag_mudflap)
4510 mudflap_init ();
4511}
4512
9e6687c8 4513/* Like get_identifier, but avoid warnings about null arguments when
4514 the argument may be NULL for targets where GCC lacks stdint.h type
4515 information. */
4516
4517static inline tree
4518c_get_ident (const char *id)
4519{
4520 return get_identifier (id);
4521}
4522
27213ba3 4523/* Build tree nodes and builtin functions common to both C and C++ language
4524 frontends. */
4525
4526void
4527c_common_nodes_and_builtins (void)
4528{
924bbf02 4529 int char16_type_size;
4530 int char32_type_size;
174fcc61 4531 int wchar_type_size;
4532 tree array_domain_type;
2d47cc32 4533 tree va_list_ref_type_node;
8a15c04a 4534 tree va_list_arg_type_node;
a66c9326 4535
174fcc61 4536 /* Define `int' and `char' first so that dbx will output them first. */
d946ea19 4537 record_builtin_type (RID_INT, NULL, integer_type_node);
174fcc61 4538 record_builtin_type (RID_CHAR, "char", char_type_node);
4539
4540 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4541 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4542 but not C. Are the conditionals here needed? */
c0f19401 4543 if (c_dialect_cxx ())
d946ea19 4544 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
174fcc61 4545 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4546 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4547 record_builtin_type (RID_MAX, "long unsigned int",
4548 long_unsigned_type_node);
6388cfe2 4549 if (int128_integer_type_node != NULL_TREE)
4550 {
4551 record_builtin_type (RID_INT128, "__int128",
4552 int128_integer_type_node);
4553 record_builtin_type (RID_MAX, "__int128 unsigned",
4554 int128_unsigned_type_node);
4555 }
c0f19401 4556 if (c_dialect_cxx ())
174fcc61 4557 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4558 record_builtin_type (RID_MAX, "long long int",
4559 long_long_integer_type_node);
4560 record_builtin_type (RID_MAX, "long long unsigned int",
4561 long_long_unsigned_type_node);
c0f19401 4562 if (c_dialect_cxx ())
174fcc61 4563 record_builtin_type (RID_MAX, "long long unsigned",
4564 long_long_unsigned_type_node);
4565 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4566 record_builtin_type (RID_MAX, "short unsigned int",
4567 short_unsigned_type_node);
c0f19401 4568 if (c_dialect_cxx ())
174fcc61 4569 record_builtin_type (RID_MAX, "unsigned short",
4570 short_unsigned_type_node);
4571
4572 /* Define both `signed char' and `unsigned char'. */
4573 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4574 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4575
771d21fa 4576 /* These are types that c_common_type_for_size and
4577 c_common_type_for_mode use. */
e60a6f7b 4578 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4579 TYPE_DECL, NULL_TREE,
dc24ddbd 4580 intQI_type_node));
e60a6f7b 4581 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4582 TYPE_DECL, NULL_TREE,
dc24ddbd 4583 intHI_type_node));
e60a6f7b 4584 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4585 TYPE_DECL, NULL_TREE,
dc24ddbd 4586 intSI_type_node));
e60a6f7b 4587 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4588 TYPE_DECL, NULL_TREE,
dc24ddbd 4589 intDI_type_node));
174fcc61 4590#if HOST_BITS_PER_WIDE_INT >= 64
f1515a39 4591 if (targetm.scalar_mode_supported_p (TImode))
e60a6f7b 4592 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4593 TYPE_DECL,
f1515a39 4594 get_identifier ("__int128_t"),
4595 intTI_type_node));
174fcc61 4596#endif
e60a6f7b 4597 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4598 TYPE_DECL, NULL_TREE,
dc24ddbd 4599 unsigned_intQI_type_node));
e60a6f7b 4600 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4601 TYPE_DECL, NULL_TREE,
dc24ddbd 4602 unsigned_intHI_type_node));
e60a6f7b 4603 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4604 TYPE_DECL, NULL_TREE,
dc24ddbd 4605 unsigned_intSI_type_node));
e60a6f7b 4606 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4607 TYPE_DECL, NULL_TREE,
dc24ddbd 4608 unsigned_intDI_type_node));
174fcc61 4609#if HOST_BITS_PER_WIDE_INT >= 64
f1515a39 4610 if (targetm.scalar_mode_supported_p (TImode))
e60a6f7b 4611 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4612 TYPE_DECL,
f1515a39 4613 get_identifier ("__uint128_t"),
4614 unsigned_intTI_type_node));
174fcc61 4615#endif
4616
4617 /* Create the widest literal types. */
4618 widest_integer_literal_type_node
4619 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
e60a6f7b 4620 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4621 TYPE_DECL, NULL_TREE,
dc24ddbd 4622 widest_integer_literal_type_node));
174fcc61 4623
4624 widest_unsigned_literal_type_node
4625 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
e60a6f7b 4626 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4627 TYPE_DECL, NULL_TREE,
dc24ddbd 4628 widest_unsigned_literal_type_node));
174fcc61 4629
4630 /* `unsigned long' is the standard type for sizeof.
4631 Note that stddef.h uses `unsigned long',
4632 and this must agree, even if long and int are the same size. */
654ef926 4633 size_type_node =
174fcc61 4634 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
654ef926 4635 signed_size_type_node = c_common_signed_type (size_type_node);
4636 set_sizetype (size_type_node);
174fcc61 4637
73673831 4638 pid_type_node =
4639 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4640
174fcc61 4641 build_common_tree_nodes_2 (flag_short_double);
4642
d946ea19 4643 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4644 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
174fcc61 4645 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4646
c4503c0a 4647 /* Only supported decimal floating point extension if the target
4648 actually supports underlying modes. */
48e1416a 4649 if (targetm.scalar_mode_supported_p (SDmode)
c4503c0a 4650 && targetm.scalar_mode_supported_p (DDmode)
4651 && targetm.scalar_mode_supported_p (TDmode))
4652 {
4653 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4654 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4655 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4656 }
4657
9421ebb9 4658 if (targetm.fixed_point_supported_p ())
4659 {
4660 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4661 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4662 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4663 record_builtin_type (RID_MAX, "long long _Fract",
4664 long_long_fract_type_node);
4665 record_builtin_type (RID_MAX, "unsigned short _Fract",
4666 unsigned_short_fract_type_node);
4667 record_builtin_type (RID_MAX, "unsigned _Fract",
4668 unsigned_fract_type_node);
4669 record_builtin_type (RID_MAX, "unsigned long _Fract",
4670 unsigned_long_fract_type_node);
4671 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4672 unsigned_long_long_fract_type_node);
4673 record_builtin_type (RID_MAX, "_Sat short _Fract",
4674 sat_short_fract_type_node);
4675 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4676 record_builtin_type (RID_MAX, "_Sat long _Fract",
4677 sat_long_fract_type_node);
4678 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4679 sat_long_long_fract_type_node);
4680 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4681 sat_unsigned_short_fract_type_node);
4682 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4683 sat_unsigned_fract_type_node);
4684 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4685 sat_unsigned_long_fract_type_node);
4686 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4687 sat_unsigned_long_long_fract_type_node);
4688 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4689 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4690 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4691 record_builtin_type (RID_MAX, "long long _Accum",
4692 long_long_accum_type_node);
4693 record_builtin_type (RID_MAX, "unsigned short _Accum",
4694 unsigned_short_accum_type_node);
4695 record_builtin_type (RID_MAX, "unsigned _Accum",
4696 unsigned_accum_type_node);
4697 record_builtin_type (RID_MAX, "unsigned long _Accum",
4698 unsigned_long_accum_type_node);
4699 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4700 unsigned_long_long_accum_type_node);
4701 record_builtin_type (RID_MAX, "_Sat short _Accum",
4702 sat_short_accum_type_node);
4703 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4704 record_builtin_type (RID_MAX, "_Sat long _Accum",
4705 sat_long_accum_type_node);
4706 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4707 sat_long_long_accum_type_node);
4708 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4709 sat_unsigned_short_accum_type_node);
4710 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4711 sat_unsigned_accum_type_node);
4712 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4713 sat_unsigned_long_accum_type_node);
4714 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4715 sat_unsigned_long_long_accum_type_node);
4716
4717 }
4718
e60a6f7b 4719 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4720 TYPE_DECL,
dc24ddbd 4721 get_identifier ("complex int"),
4722 complex_integer_type_node));
e60a6f7b 4723 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4724 TYPE_DECL,
dc24ddbd 4725 get_identifier ("complex float"),
4726 complex_float_type_node));
e60a6f7b 4727 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4728 TYPE_DECL,
dc24ddbd 4729 get_identifier ("complex double"),
4730 complex_double_type_node));
4731 lang_hooks.decls.pushdecl
e60a6f7b 4732 (build_decl (UNKNOWN_LOCATION,
4733 TYPE_DECL, get_identifier ("complex long double"),
20325f61 4734 complex_long_double_type_node));
174fcc61 4735
e256d445 4736 if (c_dialect_cxx ())
4737 /* For C++, make fileptr_type_node a distinct void * type until
4738 FILE type is defined. */
e086912e 4739 fileptr_type_node = build_variant_type_copy (ptr_type_node);
e256d445 4740
d946ea19 4741 record_builtin_type (RID_VOID, NULL, void_type_node);
174fcc61 4742
6753bca0 4743 /* Set the TYPE_NAME for any variants that were built before
4744 record_builtin_type gave names to the built-in types. */
4745 {
4746 tree void_name = TYPE_NAME (void_type_node);
4747 TYPE_NAME (void_type_node) = NULL_TREE;
4748 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4749 = void_name;
4750 TYPE_NAME (void_type_node) = void_name;
4751 }
4752
fbf0afd1 4753 /* This node must not be shared. */
7c446c95 4754 void_zero_node = make_node (INTEGER_CST);
d2d4bdde 4755 TREE_TYPE (void_zero_node) = void_type_node;
4756
174fcc61 4757 void_list_node = build_void_list_node ();
4758
4759 /* Make a type to be the domain of a few array types
4760 whose domains don't really matter.
4761 200 is small enough that it always fits in size_t
4762 and large enough that it can hold most function names for the
4763 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4764 array_domain_type = build_index_type (size_int (200));
4765
4766 /* Make a type for arrays of characters.
4767 With luck nothing will ever really depend on the length of this
4768 array type. */
4769 char_array_type_node
4770 = build_array_type (char_type_node, array_domain_type);
4771
4772 /* Likewise for arrays of ints. */
4773 int_array_type_node
4774 = build_array_type (integer_type_node, array_domain_type);
4775
d2d4bdde 4776 string_type_node = build_pointer_type (char_type_node);
4777 const_string_type_node
4778 = build_pointer_type (build_qualified_type
4779 (char_type_node, TYPE_QUAL_CONST));
4780
174fcc61 4781 /* This is special for C++ so functions can be overloaded. */
18ef7ac2 4782 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
174fcc61 4783 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4784 wchar_type_size = TYPE_PRECISION (wchar_type_node);
f3449a3c 4785 underlying_wchar_type_node = wchar_type_node;
c0f19401 4786 if (c_dialect_cxx ())
174fcc61 4787 {
78a8ed03 4788 if (TYPE_UNSIGNED (wchar_type_node))
174fcc61 4789 wchar_type_node = make_unsigned_type (wchar_type_size);
4790 else
4791 wchar_type_node = make_signed_type (wchar_type_size);
4792 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4793 }
174fcc61 4794
4795 /* This is for wide string constants. */
4796 wchar_array_type_node
4797 = build_array_type (wchar_type_node, array_domain_type);
4798
924bbf02 4799 /* Define 'char16_t'. */
4800 char16_type_node = get_identifier (CHAR16_TYPE);
4801 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4802 char16_type_size = TYPE_PRECISION (char16_type_node);
4803 if (c_dialect_cxx ())
4804 {
4805 char16_type_node = make_unsigned_type (char16_type_size);
4806
4807 if (cxx_dialect == cxx0x)
4808 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4809 }
4810
4811 /* This is for UTF-16 string constants. */
4812 char16_array_type_node
4813 = build_array_type (char16_type_node, array_domain_type);
4814
4815 /* Define 'char32_t'. */
4816 char32_type_node = get_identifier (CHAR32_TYPE);
4817 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4818 char32_type_size = TYPE_PRECISION (char32_type_node);
4819 if (c_dialect_cxx ())
4820 {
4821 char32_type_node = make_unsigned_type (char32_type_size);
4822
4823 if (cxx_dialect == cxx0x)
4824 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4825 }
4826
4827 /* This is for UTF-32 string constants. */
4828 char32_array_type_node
4829 = build_array_type (char32_type_node, array_domain_type);
4830
6bf5ed8d 4831 wint_type_node =
4832 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4833
4834 intmax_type_node =
4835 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4836 uintmax_type_node =
4837 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4838
f3449a3c 4839 if (SIG_ATOMIC_TYPE)
4840 sig_atomic_type_node =
9e6687c8 4841 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
f3449a3c 4842 if (INT8_TYPE)
4843 int8_type_node =
9e6687c8 4844 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
f3449a3c 4845 if (INT16_TYPE)
4846 int16_type_node =
9e6687c8 4847 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
f3449a3c 4848 if (INT32_TYPE)
4849 int32_type_node =
9e6687c8 4850 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
f3449a3c 4851 if (INT64_TYPE)
4852 int64_type_node =
9e6687c8 4853 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
f3449a3c 4854 if (UINT8_TYPE)
4855 uint8_type_node =
9e6687c8 4856 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
f3449a3c 4857 if (UINT16_TYPE)
4858 uint16_type_node =
9e6687c8 4859 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
f3449a3c 4860 if (UINT32_TYPE)
4861 c_uint32_type_node =
9e6687c8 4862 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
f3449a3c 4863 if (UINT64_TYPE)
4864 c_uint64_type_node =
9e6687c8 4865 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
f3449a3c 4866 if (INT_LEAST8_TYPE)
4867 int_least8_type_node =
9e6687c8 4868 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
f3449a3c 4869 if (INT_LEAST16_TYPE)
4870 int_least16_type_node =
9e6687c8 4871 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
f3449a3c 4872 if (INT_LEAST32_TYPE)
4873 int_least32_type_node =
9e6687c8 4874 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
f3449a3c 4875 if (INT_LEAST64_TYPE)
4876 int_least64_type_node =
9e6687c8 4877 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
f3449a3c 4878 if (UINT_LEAST8_TYPE)
4879 uint_least8_type_node =
9e6687c8 4880 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
f3449a3c 4881 if (UINT_LEAST16_TYPE)
4882 uint_least16_type_node =
9e6687c8 4883 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
f3449a3c 4884 if (UINT_LEAST32_TYPE)
4885 uint_least32_type_node =
9e6687c8 4886 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
f3449a3c 4887 if (UINT_LEAST64_TYPE)
4888 uint_least64_type_node =
9e6687c8 4889 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
f3449a3c 4890 if (INT_FAST8_TYPE)
4891 int_fast8_type_node =
9e6687c8 4892 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
f3449a3c 4893 if (INT_FAST16_TYPE)
4894 int_fast16_type_node =
9e6687c8 4895 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
f3449a3c 4896 if (INT_FAST32_TYPE)
4897 int_fast32_type_node =
9e6687c8 4898 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
f3449a3c 4899 if (INT_FAST64_TYPE)
4900 int_fast64_type_node =
9e6687c8 4901 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
f3449a3c 4902 if (UINT_FAST8_TYPE)
4903 uint_fast8_type_node =
9e6687c8 4904 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
f3449a3c 4905 if (UINT_FAST16_TYPE)
4906 uint_fast16_type_node =
9e6687c8 4907 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
f3449a3c 4908 if (UINT_FAST32_TYPE)
4909 uint_fast32_type_node =
9e6687c8 4910 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
f3449a3c 4911 if (UINT_FAST64_TYPE)
4912 uint_fast64_type_node =
9e6687c8 4913 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
f3449a3c 4914 if (INTPTR_TYPE)
4915 intptr_type_node =
9e6687c8 4916 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
f3449a3c 4917 if (UINTPTR_TYPE)
4918 uintptr_type_node =
9e6687c8 4919 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
f3449a3c 4920
6bf5ed8d 4921 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4922 ptrdiff_type_node
4923 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
11773141 4924 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
6bf5ed8d 4925
dc24ddbd 4926 lang_hooks.decls.pushdecl
e60a6f7b 4927 (build_decl (UNKNOWN_LOCATION,
4928 TYPE_DECL, get_identifier ("__builtin_va_list"),
20325f61 4929 va_list_type_node));
202d6e5f 4930 if (targetm.enum_va_list_p)
acd6f472 4931 {
4932 int l;
4933 const char *pname;
4934 tree ptype;
5f57a8b1 4935
202d6e5f 4936 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
acd6f472 4937 {
4938 lang_hooks.decls.pushdecl
4939 (build_decl (UNKNOWN_LOCATION,
4940 TYPE_DECL, get_identifier (pname),
4941 ptype));
4942
4943 }
4944 }
8a15c04a 4945
8a15c04a 4946 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2d47cc32 4947 {
4948 va_list_arg_type_node = va_list_ref_type_node =
4949 build_pointer_type (TREE_TYPE (va_list_type_node));
4950 }
8a15c04a 4951 else
2d47cc32 4952 {
4953 va_list_arg_type_node = va_list_type_node;
4954 va_list_ref_type_node = build_reference_type (va_list_type_node);
4955 }
1cae46be 4956
dce22712 4957 if (!flag_preprocess_only)
4958 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
ffa8918b 4959
5c62f199 4960 main_identifier_node = get_identifier ("main");
ae84079f 4961
4962 /* Create the built-in __null node. It is important that this is
4963 not shared. */
4964 null_node = make_node (INTEGER_CST);
4965 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
27213ba3 4966
4967 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4968 memset (builtin_types, 0, sizeof (builtin_types));
72040e7e 4969}
a66c9326 4970
79b01846 4971/* The number of named compound-literals generated thus far. */
4972static GTY(()) int compound_literal_number;
4973
4974/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4975
4976void
4977set_compound_literal_name (tree decl)
4978{
4979 char *name;
4980 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4981 compound_literal_number);
4982 compound_literal_number++;
4983 DECL_NAME (decl) = get_identifier (name);
4984}
4985
a66c9326 4986tree
e60a6f7b 4987build_va_arg (location_t loc, tree expr, tree type)
a66c9326 4988{
e60a6f7b 4989 expr = build1 (VA_ARG_EXPR, type, expr);
4990 SET_EXPR_LOCATION (expr, loc);
4991 return expr;
a66c9326 4992}
0d4238dc 4993
4994
dd878098 4995/* Linked list of disabled built-in functions. */
4996
4997typedef struct disabled_builtin
4998{
4999 const char *name;
5000 struct disabled_builtin *next;
5001} disabled_builtin;
5002static disabled_builtin *disabled_builtins = NULL;
5003
1cae46be 5004static bool builtin_function_disabled_p (const char *);
dd878098 5005
5006/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
5007 begins with "__builtin_", give an error. */
5008
5009void
1cae46be 5010disable_builtin_function (const char *name)
dd878098 5011{
5012 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
b0b1af64 5013 error ("cannot disable built-in function %qs", name);
dd878098 5014 else
5015 {
e85905e5 5016 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5017 new_disabled_builtin->name = name;
5018 new_disabled_builtin->next = disabled_builtins;
5019 disabled_builtins = new_disabled_builtin;
dd878098 5020 }
5021}
5022
5023
5024/* Return true if the built-in function NAME has been disabled, false
5025 otherwise. */
5026
5027static bool
1cae46be 5028builtin_function_disabled_p (const char *name)
dd878098 5029{
5030 disabled_builtin *p;
5031 for (p = disabled_builtins; p != NULL; p = p->next)
5032 {
5033 if (strcmp (name, p->name) == 0)
5034 return true;
5035 }
5036 return false;
5037}
5038
5039
3237155d 5040/* Worker for DEF_BUILTIN.
5041 Possibly define a builtin function with one or two names.
5042 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5043 nonansi_p and flag_no_nonansi_builtin. */
0d4238dc 5044
3237155d 5045static void
5046def_builtin_1 (enum built_in_function fncode,
5047 const char *name,
5048 enum built_in_class fnclass,
5049 tree fntype, tree libtype,
5050 bool both_p, bool fallback_p, bool nonansi_p,
5051 tree fnattrs, bool implicit_p)
0d4238dc 5052{
3237155d 5053 tree decl;
5054 const char *libname;
5055
27213ba3 5056 if (fntype == error_mark_node)
5057 return;
5058
3237155d 5059 gcc_assert ((!both_p && !fallback_p)
5060 || !strncmp (name, "__builtin_",
5061 strlen ("__builtin_")));
5062
5063 libname = name + strlen ("__builtin_");
54be5d7e 5064 decl = add_builtin_function (name, fntype, fncode, fnclass,
5065 (fallback_p ? libname : NULL),
5066 fnattrs);
3237155d 5067 if (both_p
5068 && !flag_no_builtin && !builtin_function_disabled_p (libname)
dd878098 5069 && !(nonansi_p && flag_no_nonansi_builtin))
54be5d7e 5070 add_builtin_function (libname, libtype, fncode, fnclass,
5071 NULL, fnattrs);
a40609e6 5072
3237155d 5073 built_in_decls[(int) fncode] = decl;
5074 if (implicit_p)
5075 implicit_built_in_decls[(int) fncode] = decl;
0d4238dc 5076}
e94026da 5077\f
d7aeef06 5078/* Nonzero if the type T promotes to int. This is (nearly) the
5079 integral promotions defined in ISO C99 6.3.1.1/2. */
5080
5081bool
9f627b1a 5082c_promoting_integer_type_p (const_tree t)
d7aeef06 5083{
5084 switch (TREE_CODE (t))
5085 {
5086 case INTEGER_TYPE:
5087 return (TYPE_MAIN_VARIANT (t) == char_type_node
5088 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5089 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5090 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
7aa1e6eb 5091 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5092 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
d7aeef06 5093
5094 case ENUMERAL_TYPE:
5095 /* ??? Technically all enumerations not larger than an int
5096 promote to an int. But this is used along code paths
5097 that only want to notice a size change. */
5098 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5099
5100 case BOOLEAN_TYPE:
5101 return 1;
5102
5103 default:
5104 return 0;
5105 }
5106}
5107
e94026da 5108/* Return 1 if PARMS specifies a fixed number of parameters
5109 and none of their types is affected by default promotions. */
5110
5111int
9f627b1a 5112self_promoting_args_p (const_tree parms)
e94026da 5113{
9f627b1a 5114 const_tree t;
e94026da 5115 for (t = parms; t; t = TREE_CHAIN (t))
5116 {
19cb6b50 5117 tree type = TREE_VALUE (t);
43f74bc4 5118
e1d8e198 5119 if (type == error_mark_node)
5120 continue;
5121
e94026da 5122 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5123 return 0;
5124
5125 if (type == 0)
5126 return 0;
5127
5128 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5129 return 0;
5130
d7aeef06 5131 if (c_promoting_integer_type_p (type))
e94026da 5132 return 0;
5133 }
5134 return 1;
5135}
605fb01e 5136
c10de5e7 5137/* Recursively remove any '*' or '&' operator from TYPE. */
5138tree
5139strip_pointer_operator (tree t)
5140{
5141 while (POINTER_TYPE_P (t))
5142 t = TREE_TYPE (t);
5143 return t;
5144}
5145
57a0ed23 5146/* Recursively remove pointer or array type from TYPE. */
5147tree
5148strip_pointer_or_array_types (tree t)
5149{
5150 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5151 t = TREE_TYPE (t);
5152 return t;
5153}
5154
e41f0d80 5155/* Used to compare case labels. K1 and K2 are actually tree nodes
5156 representing case labels, or NULL_TREE for a `default' label.
5157 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5158 K2, and 0 if K1 and K2 are equal. */
5159
5160int
1cae46be 5161case_compare (splay_tree_key k1, splay_tree_key k2)
e41f0d80 5162{
5163 /* Consider a NULL key (such as arises with a `default' label) to be
5164 smaller than anything else. */
5165 if (!k1)
5166 return k2 ? -1 : 0;
5167 else if (!k2)
5168 return k1 ? 1 : 0;
5169
5170 return tree_int_cst_compare ((tree) k1, (tree) k2);
5171}
5172
e60a6f7b 5173/* Process a case label, located at LOC, for the range LOW_VALUE
5174 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5175 then this case label is actually a `default' label. If only
5176 HIGH_VALUE is NULL_TREE, then case label was declared using the
5177 usual C/C++ syntax, rather than the GNU case range extension.
5178 CASES is a tree containing all the case ranges processed so far;
5179 COND is the condition for the switch-statement itself. Returns the
5180 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5181 is created. */
e41f0d80 5182
5183tree
e60a6f7b 5184c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
2ca392fd 5185 tree low_value, tree high_value)
e41f0d80 5186{
5187 tree type;
5188 tree label;
5189 tree case_label;
5190 splay_tree_node node;
5191
5192 /* Create the LABEL_DECL itself. */
e60a6f7b 5193 label = create_artificial_label (loc);
e41f0d80 5194
5195 /* If there was an error processing the switch condition, bail now
5196 before we get more confused. */
5197 if (!cond || cond == error_mark_node)
4ee9c684 5198 goto error_out;
e41f0d80 5199
1cae46be 5200 if ((low_value && TREE_TYPE (low_value)
5201 && POINTER_TYPE_P (TREE_TYPE (low_value)))
e41f0d80 5202 || (high_value && TREE_TYPE (high_value)
5203 && POINTER_TYPE_P (TREE_TYPE (high_value))))
b96dc121 5204 {
e60a6f7b 5205 error_at (loc, "pointers are not permitted as case values");
b96dc121 5206 goto error_out;
5207 }
e41f0d80 5208
5209 /* Case ranges are a GNU extension. */
8864917d 5210 if (high_value)
48e1416a 5211 pedwarn (loc, OPT_pedantic,
8864917d 5212 "range expressions in switch statements are non-standard");
e41f0d80 5213
5214 type = TREE_TYPE (cond);
5215 if (low_value)
5216 {
5217 low_value = check_case_value (low_value);
5218 low_value = convert_and_check (type, low_value);
96722196 5219 if (low_value == error_mark_node)
5220 goto error_out;
e41f0d80 5221 }
5222 if (high_value)
5223 {
5224 high_value = check_case_value (high_value);
5225 high_value = convert_and_check (type, high_value);
96722196 5226 if (high_value == error_mark_node)
5227 goto error_out;
e41f0d80 5228 }
5229
96722196 5230 if (low_value && high_value)
5231 {
5232 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
a0c938f0 5233 really a case range, even though it was written that way.
5234 Remove the HIGH_VALUE to simplify later processing. */
96722196 5235 if (tree_int_cst_equal (low_value, high_value))
5236 high_value = NULL_TREE;
5237 else if (!tree_int_cst_lt (low_value, high_value))
e60a6f7b 5238 warning_at (loc, 0, "empty range specified");
96722196 5239 }
e41f0d80 5240
2ca392fd 5241 /* See if the case is in range of the type of the original testing
5242 expression. If both low_value and high_value are out of range,
5243 don't insert the case label and return NULL_TREE. */
5244 if (low_value
84166705 5245 && !check_case_bounds (type, orig_type,
5246 &low_value, high_value ? &high_value : NULL))
2ca392fd 5247 return NULL_TREE;
5248
e41f0d80 5249 /* Look up the LOW_VALUE in the table of case labels we already
5250 have. */
5251 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5252 /* If there was not an exact match, check for overlapping ranges.
5253 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5254 that's a `default' label and the only overlap is an exact match. */
5255 if (!node && (low_value || high_value))
5256 {
5257 splay_tree_node low_bound;
5258 splay_tree_node high_bound;
5259
5260 /* Even though there wasn't an exact match, there might be an
5261 overlap between this case range and another case range.
5262 Since we've (inductively) not allowed any overlapping case
5263 ranges, we simply need to find the greatest low case label
5264 that is smaller that LOW_VALUE, and the smallest low case
5265 label that is greater than LOW_VALUE. If there is an overlap
5266 it will occur in one of these two ranges. */
5267 low_bound = splay_tree_predecessor (cases,
5268 (splay_tree_key) low_value);
5269 high_bound = splay_tree_successor (cases,
5270 (splay_tree_key) low_value);
5271
5272 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5273 the LOW_VALUE, so there is no need to check unless the
5274 LOW_BOUND is in fact itself a case range. */
5275 if (low_bound
5276 && CASE_HIGH ((tree) low_bound->value)
5277 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5278 low_value) >= 0)
5279 node = low_bound;
5280 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5281 range is bigger than the low end of the current range, so we
5282 are only interested if the current range is a real range, and
5283 not an ordinary case label. */
1cae46be 5284 else if (high_bound
e41f0d80 5285 && high_value
5286 && (tree_int_cst_compare ((tree) high_bound->key,
5287 high_value)
5288 <= 0))
5289 node = high_bound;
5290 }
5291 /* If there was an overlap, issue an error. */
5292 if (node)
5293 {
eaae3b75 5294 tree duplicate = CASE_LABEL ((tree) node->value);
e41f0d80 5295
5296 if (high_value)
5297 {
e60a6f7b 5298 error_at (loc, "duplicate (or overlapping) case value");
5299 error_at (DECL_SOURCE_LOCATION (duplicate),
5300 "this is the first entry overlapping that value");
e41f0d80 5301 }
5302 else if (low_value)
5303 {
e60a6f7b 5304 error_at (loc, "duplicate case value") ;
5305 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
e41f0d80 5306 }
5307 else
5308 {
e60a6f7b 5309 error_at (loc, "multiple default labels in one switch");
5310 error_at (DECL_SOURCE_LOCATION (duplicate),
5311 "this is the first default label");
e41f0d80 5312 }
4ee9c684 5313 goto error_out;
e41f0d80 5314 }
5315
5316 /* Add a CASE_LABEL to the statement-tree. */
e60a6f7b 5317 case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
e41f0d80 5318 /* Register this case label in the splay tree. */
1cae46be 5319 splay_tree_insert (cases,
e41f0d80 5320 (splay_tree_key) low_value,
5321 (splay_tree_value) case_label);
5322
5323 return case_label;
4ee9c684 5324
5325 error_out:
daf6dff5 5326 /* Add a label so that the back-end doesn't think that the beginning of
4ee9c684 5327 the switch is unreachable. Note that we do not add a case label, as
a53ff4c1 5328 that just leads to duplicates and thence to failure later on. */
4ee9c684 5329 if (!cases->root)
5330 {
e60a6f7b 5331 tree t = create_artificial_label (loc);
5332 add_stmt (build_stmt (loc, LABEL_EXPR, t));
4ee9c684 5333 }
5334 return error_mark_node;
5335}
5336
5337/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5338 Used to verify that case values match up with enumerator values. */
5339
5340static void
5341match_case_to_enum_1 (tree key, tree type, tree label)
5342{
5343 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5344
5345 /* ??? Not working too hard to print the double-word value.
5346 Should perhaps be done with %lwd in the diagnostic routines? */
5347 if (TREE_INT_CST_HIGH (key) == 0)
5348 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5349 TREE_INT_CST_LOW (key));
5350 else if (!TYPE_UNSIGNED (type)
5351 && TREE_INT_CST_HIGH (key) == -1
5352 && TREE_INT_CST_LOW (key) != 0)
5353 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5354 -TREE_INT_CST_LOW (key));
5355 else
5356 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
7df7561b 5357 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5358 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4ee9c684 5359
5360 if (TYPE_NAME (type) == 0)
712d2297 5361 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5362 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5363 "case value %qs not in enumerated type",
5364 buf);
4ee9c684 5365 else
712d2297 5366 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5367 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5368 "case value %qs not in enumerated type %qT",
5369 buf, type);
4ee9c684 5370}
5371
359d87c6 5372/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5373 Used to verify that case values match up with enumerator values. */
5374
4ee9c684 5375static int
5376match_case_to_enum (splay_tree_node node, void *data)
5377{
5378 tree label = (tree) node->value;
4fd61bc6 5379 tree type = (tree) data;
4ee9c684 5380
5381 /* Skip default case. */
5382 if (!CASE_LOW (label))
5383 return 0;
5384
359d87c6 5385 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4ee9c684 5386 when we did our enum->case scan. Reset our scratch bit after. */
359d87c6 5387 if (!CASE_LOW_SEEN (label))
4ee9c684 5388 match_case_to_enum_1 (CASE_LOW (label), type, label);
5389 else
359d87c6 5390 CASE_LOW_SEEN (label) = 0;
4ee9c684 5391
359d87c6 5392 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5393 not set, that means that CASE_HIGH did not appear when we did our
5394 enum->case scan. Reset our scratch bit after. */
4ee9c684 5395 if (CASE_HIGH (label))
5396 {
359d87c6 5397 if (!CASE_HIGH_SEEN (label))
5398 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5399 else
5400 CASE_HIGH_SEEN (label) = 0;
4ee9c684 5401 }
5402
5403 return 0;
5404}
5405
e7911019 5406/* Handle -Wswitch*. Called from the front end after parsing the
5407 switch construct. */
5408/* ??? Should probably be somewhere generic, since other languages
5409 besides C and C++ would want this. At the moment, however, C/C++
5410 are the only tree-ssa languages that support enumerations at all,
5411 so the point is moot. */
4ee9c684 5412
e7911019 5413void
5414c_do_switch_warnings (splay_tree cases, location_t switch_location,
5415 tree type, tree cond)
4ee9c684 5416{
b27ac6b5 5417 splay_tree_node default_node;
359d87c6 5418 splay_tree_node node;
5419 tree chain;
4ee9c684 5420
5421 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5422 return;
5423
4ee9c684 5424 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
8b6866af 5425 if (!default_node)
5fb6a912 5426 warning_at (switch_location, OPT_Wswitch_default,
5427 "switch missing default case");
4ee9c684 5428
359d87c6 5429 /* From here on, we only care about about enumerated types. */
5430 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5431 return;
5432
561017b5 5433 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5434 if (!warn_switch_enum && !warn_switch)
359d87c6 5435 return;
5436
561017b5 5437 /* Check the cases. Warn about case values which are not members of
5438 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5439 there is no default case, check that exactly all enumeration
5440 literals are covered by the cases. */
5441
359d87c6 5442 /* Clearing COND if it is not an integer constant simplifies
5443 the tests inside the loop below. */
5444 if (TREE_CODE (cond) != INTEGER_CST)
5445 cond = NULL_TREE;
5446
5447 /* The time complexity here is O(N*lg(N)) worst case, but for the
5448 common case of monotonically increasing enumerators, it is
5449 O(N), since the nature of the splay tree will keep the next
5450 element adjacent to the root at all times. */
4ee9c684 5451
359d87c6 5452 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5453 {
5454 tree value = TREE_VALUE (chain);
3f00a6c0 5455 if (TREE_CODE (value) == CONST_DECL)
5456 value = DECL_INITIAL (value);
359d87c6 5457 node = splay_tree_lookup (cases, (splay_tree_key) value);
5458 if (node)
4ee9c684 5459 {
359d87c6 5460 /* Mark the CASE_LOW part of the case entry as seen. */
5461 tree label = (tree) node->value;
5462 CASE_LOW_SEEN (label) = 1;
5463 continue;
5464 }
5465
5466 /* Even though there wasn't an exact match, there might be a
f0b5f617 5467 case range which includes the enumerator's value. */
359d87c6 5468 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5469 if (node && CASE_HIGH ((tree) node->value))
5470 {
5471 tree label = (tree) node->value;
5472 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5473 if (cmp >= 0)
4ee9c684 5474 {
359d87c6 5475 /* If we match the upper bound exactly, mark the CASE_HIGH
5476 part of the case entry as seen. */
5477 if (cmp == 0)
5478 CASE_HIGH_SEEN (label) = 1;
5479 continue;
4ee9c684 5480 }
5481 }
5482
359d87c6 5483 /* We've now determined that this enumerated literal isn't
5484 handled by the case labels of the switch statement. */
4ee9c684 5485
359d87c6 5486 /* If the switch expression is a constant, we only really care
5487 about whether that constant is handled by the switch. */
5488 if (cond && tree_int_cst_compare (cond, value))
5489 continue;
4ee9c684 5490
6cbbbc89 5491 /* If there is a default_node, the only relevant option is
561017b5 5492 Wswitch-enum. Otherwise, if both are enabled then we prefer
6cbbbc89 5493 to warn using -Wswitch because -Wswitch is enabled by -Wall
5494 while -Wswitch-enum is explicit. */
561017b5 5495 warning_at (switch_location,
5496 (default_node || !warn_switch
5497 ? OPT_Wswitch_enum
5498 : OPT_Wswitch),
5499 "enumeration value %qE not handled in switch",
5500 TREE_PURPOSE (chain));
4ee9c684 5501 }
359d87c6 5502
5503 /* Warn if there are case expressions that don't correspond to
5504 enumerators. This can occur since C and C++ don't enforce
5505 type-checking of assignments to enumeration variables.
5506
5507 The time complexity here is now always O(N) worst case, since
5508 we should have marked both the lower bound and upper bound of
5509 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5510 above. This scan also resets those fields. */
6cbbbc89 5511
359d87c6 5512 splay_tree_foreach (cases, match_case_to_enum, type);
e41f0d80 5513}
5514
9dd48740 5515/* Finish an expression taking the address of LABEL (an
dda49785 5516 IDENTIFIER_NODE). Returns an expression for the address.
5517
5518 LOC is the location for the expression returned. */
d0a47c8d 5519
1cae46be 5520tree
dda49785 5521finish_label_address_expr (tree label, location_t loc)
d0a47c8d 5522{
5523 tree result;
5524
21ca8540 5525 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
d0a47c8d 5526
9dd48740 5527 if (label == error_mark_node)
5528 return error_mark_node;
5529
d0a47c8d 5530 label = lookup_label (label);
5531 if (label == NULL_TREE)
5532 result = null_pointer_node;
5533 else
5534 {
5535 TREE_USED (label) = 1;
5536 result = build1 (ADDR_EXPR, ptr_type_node, label);
344cd9b2 5537 /* The current function is not necessarily uninlinable.
d0a47c8d 5538 Computed gotos are incompatible with inlining, but the value
5539 here could be used only in a diagnostic, for example. */
dda49785 5540 protected_set_expr_location (result, loc);
d0a47c8d 5541 }
5542
5543 return result;
5544}
4f9a1c9b 5545\f
5546
5547/* Given a boolean expression ARG, return a tree representing an increment
5548 or decrement (as indicated by CODE) of ARG. The front end must check for
5549 invalid cases (e.g., decrement in C++). */
5550tree
1cae46be 5551boolean_increment (enum tree_code code, tree arg)
4f9a1c9b 5552{
5553 tree val;
69db191c 5554 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
c0f19401 5555
4f9a1c9b 5556 arg = stabilize_reference (arg);
5557 switch (code)
5558 {
5559 case PREINCREMENT_EXPR:
14ae0310 5560 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4f9a1c9b 5561 break;
5562 case POSTINCREMENT_EXPR:
14ae0310 5563 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4f9a1c9b 5564 arg = save_expr (arg);
14ae0310 5565 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5566 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4f9a1c9b 5567 break;
5568 case PREDECREMENT_EXPR:
14ae0310 5569 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
389dd41b 5570 invert_truthvalue_loc (input_location, arg));
4f9a1c9b 5571 break;
5572 case POSTDECREMENT_EXPR:
14ae0310 5573 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
389dd41b 5574 invert_truthvalue_loc (input_location, arg));
4f9a1c9b 5575 arg = save_expr (arg);
14ae0310 5576 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5577 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4f9a1c9b 5578 break;
5579 default:
231bd014 5580 gcc_unreachable ();
4f9a1c9b 5581 }
5582 TREE_SIDE_EFFECTS (val) = 1;
5583 return val;
5584}
76a6e674 5585\f
f3449a3c 5586/* Built-in macros for stddef.h and stdint.h, that require macros
5587 defined in this file. */
79cf3ec1 5588void
1cae46be 5589c_stddef_cpp_builtins(void)
1ed9d5f5 5590{
63994318 5591 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5592 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5593 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5594 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
36bccbfc 5595 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5596 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
b0726616 5597 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5598 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
f3449a3c 5599 if (SIG_ATOMIC_TYPE)
5600 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5601 if (INT8_TYPE)
5602 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5603 if (INT16_TYPE)
5604 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5605 if (INT32_TYPE)
5606 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5607 if (INT64_TYPE)
5608 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5609 if (UINT8_TYPE)
5610 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5611 if (UINT16_TYPE)
5612 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5613 if (UINT32_TYPE)
5614 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5615 if (UINT64_TYPE)
5616 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5617 if (INT_LEAST8_TYPE)
5618 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5619 if (INT_LEAST16_TYPE)
5620 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5621 if (INT_LEAST32_TYPE)
5622 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5623 if (INT_LEAST64_TYPE)
5624 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5625 if (UINT_LEAST8_TYPE)
5626 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5627 if (UINT_LEAST16_TYPE)
5628 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5629 if (UINT_LEAST32_TYPE)
5630 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5631 if (UINT_LEAST64_TYPE)
5632 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5633 if (INT_FAST8_TYPE)
5634 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5635 if (INT_FAST16_TYPE)
5636 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5637 if (INT_FAST32_TYPE)
5638 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5639 if (INT_FAST64_TYPE)
5640 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5641 if (UINT_FAST8_TYPE)
5642 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5643 if (UINT_FAST16_TYPE)
5644 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5645 if (UINT_FAST32_TYPE)
5646 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5647 if (UINT_FAST64_TYPE)
5648 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5649 if (INTPTR_TYPE)
5650 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5651 if (UINTPTR_TYPE)
5652 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
574006c3 5653}
5654
7d3b509a 5655static void
1cae46be 5656c_init_attributes (void)
7d3b509a 5657{
5658 /* Fill in the built_in_attributes array. */
7c446c95 5659#define DEF_ATTR_NULL_TREE(ENUM) \
7d3b509a 5660 built_in_attributes[(int) ENUM] = NULL_TREE;
7c446c95 5661#define DEF_ATTR_INT(ENUM, VALUE) \
7016c612 5662 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
7d3b509a 5663#define DEF_ATTR_IDENT(ENUM, STRING) \
5664 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5665#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5666 built_in_attributes[(int) ENUM] \
5667 = tree_cons (built_in_attributes[(int) PURPOSE], \
5668 built_in_attributes[(int) VALUE], \
5669 built_in_attributes[(int) CHAIN]);
7d3b509a 5670#include "builtin-attrs.def"
5671#undef DEF_ATTR_NULL_TREE
5672#undef DEF_ATTR_INT
5673#undef DEF_ATTR_IDENT
5674#undef DEF_ATTR_TREE_LIST
76a6e674 5675}
5f3cead1 5676
33199a81 5677/* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5678 identifier as an argument, so the front end shouldn't look it up. */
5679
5680bool
47b19b94 5681attribute_takes_identifier_p (const_tree attr_id)
33199a81 5682{
9bf1c74e 5683 const struct attribute_spec *spec = lookup_attribute_spec (attr_id);
02cb1060 5684 if (spec == NULL)
5685 /* Unknown attribute that we'll end up ignoring, return true so we
5686 don't complain about an identifier argument. */
5687 return true;
5688 else if (!strcmp ("mode", spec->name)
5689 || !strcmp ("format", spec->name)
5690 || !strcmp ("cleanup", spec->name))
47b19b94 5691 return true;
5692 else
5693 return targetm.attribute_takes_identifier_p (attr_id);
33199a81 5694}
5695
f8e93a2e 5696/* Attribute handlers common to C front ends. */
5697
5698/* Handle a "packed" attribute; arguments as in
5699 struct attribute_spec.handler. */
5700
5701static tree
9a03a746 5702handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
09347743 5703 int flags, bool *no_add_attrs)
f8e93a2e 5704{
f40175cb 5705 if (TYPE_P (*node))
f8e93a2e 5706 {
5707 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 5708 *node = build_variant_type_copy (*node);
f40175cb 5709 TYPE_PACKED (*node) = 1;
f8e93a2e 5710 }
5711 else if (TREE_CODE (*node) == FIELD_DECL)
c2ab04f9 5712 {
9fd767c5 5713 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5714 /* Still pack bitfields. */
5715 && ! DECL_INITIAL (*node))
c2ab04f9 5716 warning (OPT_Wattributes,
5717 "%qE attribute ignored for field of type %qT",
5718 name, TREE_TYPE (*node));
5719 else
5720 DECL_PACKED (*node) = 1;
5721 }
f8e93a2e 5722 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
f40175cb 5723 used for DECL_REGISTER. It wouldn't mean anything anyway.
5724 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5725 that changes what the typedef is typing. */
f8e93a2e 5726 else
5727 {
9b2d6d13 5728 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5729 *no_add_attrs = true;
5730 }
5731
5732 return NULL_TREE;
5733}
5734
5735/* Handle a "nocommon" attribute; arguments as in
5736 struct attribute_spec.handler. */
5737
5738static tree
1cae46be 5739handle_nocommon_attribute (tree *node, tree name,
9a03a746 5740 tree ARG_UNUSED (args),
5741 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5742{
5743 if (TREE_CODE (*node) == VAR_DECL)
5744 DECL_COMMON (*node) = 0;
5745 else
5746 {
9b2d6d13 5747 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5748 *no_add_attrs = true;
5749 }
5750
5751 return NULL_TREE;
5752}
5753
5754/* Handle a "common" attribute; arguments as in
5755 struct attribute_spec.handler. */
5756
5757static tree
9a03a746 5758handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5759 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5760{
5761 if (TREE_CODE (*node) == VAR_DECL)
5762 DECL_COMMON (*node) = 1;
5763 else
5764 {
9b2d6d13 5765 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5766 *no_add_attrs = true;
5767 }
5768
5769 return NULL_TREE;
5770}
5771
5772/* Handle a "noreturn" attribute; arguments as in
5773 struct attribute_spec.handler. */
5774
5775static tree
9a03a746 5776handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5777 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5778{
5779 tree type = TREE_TYPE (*node);
5780
5781 /* See FIXME comment in c_common_attribute_table. */
8c582e4f 5782 if (TREE_CODE (*node) == FUNCTION_DECL
5783 || objc_method_decl (TREE_CODE (*node)))
f8e93a2e 5784 TREE_THIS_VOLATILE (*node) = 1;
5785 else if (TREE_CODE (type) == POINTER_TYPE
5786 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5787 TREE_TYPE (*node)
5788 = build_pointer_type
5789 (build_type_variant (TREE_TYPE (type),
71bda45d 5790 TYPE_READONLY (TREE_TYPE (type)), 1));
f8e93a2e 5791 else
5792 {
9b2d6d13 5793 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5794 *no_add_attrs = true;
5795 }
5796
5797 return NULL_TREE;
5798}
5799
5de92639 5800/* Handle a "hot" and attribute; arguments as in
5801 struct attribute_spec.handler. */
5802
5803static tree
5804handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
46f8e3b0 5805 int ARG_UNUSED (flags), bool *no_add_attrs)
5de92639 5806{
5807 if (TREE_CODE (*node) == FUNCTION_DECL)
5808 {
5809 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5810 {
5811 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5812 name, "cold");
5813 *no_add_attrs = true;
5814 }
24470055 5815 /* Most of the rest of the hot processing is done later with
5816 lookup_attribute. */
5de92639 5817 }
5818 else
5819 {
5820 warning (OPT_Wattributes, "%qE attribute ignored", name);
5821 *no_add_attrs = true;
5822 }
5823
5824 return NULL_TREE;
5825}
5826/* Handle a "cold" and attribute; arguments as in
5827 struct attribute_spec.handler. */
5828
5829static tree
5830handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5831 int ARG_UNUSED (flags), bool *no_add_attrs)
5832{
5833 if (TREE_CODE (*node) == FUNCTION_DECL)
5834 {
5835 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5836 {
5837 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5838 name, "hot");
5839 *no_add_attrs = true;
5840 }
24470055 5841 /* Most of the rest of the cold processing is done later with
5842 lookup_attribute. */
5de92639 5843 }
5844 else
5845 {
5846 warning (OPT_Wattributes, "%qE attribute ignored", name);
5847 *no_add_attrs = true;
5848 }
5849
5850 return NULL_TREE;
5851}
5852
f8e93a2e 5853/* Handle a "noinline" attribute; arguments as in
5854 struct attribute_spec.handler. */
5855
5856static tree
1cae46be 5857handle_noinline_attribute (tree *node, tree name,
9a03a746 5858 tree ARG_UNUSED (args),
5859 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 5860{
5861 if (TREE_CODE (*node) == FUNCTION_DECL)
5862 DECL_UNINLINABLE (*node) = 1;
5863 else
5864 {
9b2d6d13 5865 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5866 *no_add_attrs = true;
5867 }
5868
5869 return NULL_TREE;
5870}
5871
bdb1f0d1 5872/* Handle a "noclone" attribute; arguments as in
5873 struct attribute_spec.handler. */
5874
5875static tree
5876handle_noclone_attribute (tree *node, tree name,
5877 tree ARG_UNUSED (args),
5878 int ARG_UNUSED (flags), bool *no_add_attrs)
5879{
5880 if (TREE_CODE (*node) != FUNCTION_DECL)
5881 {
5882 warning (OPT_Wattributes, "%qE attribute ignored", name);
5883 *no_add_attrs = true;
5884 }
5885
5886 return NULL_TREE;
5887}
5888
f8e93a2e 5889/* Handle a "always_inline" attribute; arguments as in
5890 struct attribute_spec.handler. */
5891
5892static tree
1cae46be 5893handle_always_inline_attribute (tree *node, tree name,
9a03a746 5894 tree ARG_UNUSED (args),
5895 int ARG_UNUSED (flags),
09347743 5896 bool *no_add_attrs)
f8e93a2e 5897{
5898 if (TREE_CODE (*node) == FUNCTION_DECL)
5899 {
ebb7d626 5900 /* Set the attribute and mark it for disregarding inline
5901 limits. */
5902 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
f8e93a2e 5903 }
5904 else
5905 {
9b2d6d13 5906 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 5907 *no_add_attrs = true;
541e4101 5908 }
5909
5910 return NULL_TREE;
5911}
5912
5913/* Handle a "gnu_inline" attribute; arguments as in
5914 struct attribute_spec.handler. */
5915
5916static tree
5917handle_gnu_inline_attribute (tree *node, tree name,
5918 tree ARG_UNUSED (args),
5919 int ARG_UNUSED (flags),
5920 bool *no_add_attrs)
5921{
5922 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5923 {
5924 /* Do nothing else, just set the attribute. We'll get at
5925 it later with lookup_attribute. */
5926 }
5927 else
5928 {
5929 warning (OPT_Wattributes, "%qE attribute ignored", name);
5930 *no_add_attrs = true;
7bd95dfd 5931 }
5932
5933 return NULL_TREE;
5934}
5935
5936/* Handle a "leaf" attribute; arguments as in
5937 struct attribute_spec.handler. */
5938
5939static tree
5940handle_leaf_attribute (tree *node, tree name,
5941 tree ARG_UNUSED (args),
5942 int ARG_UNUSED (flags), bool *no_add_attrs)
5943{
5944 if (TREE_CODE (*node) != FUNCTION_DECL)
5945 {
5946 warning (OPT_Wattributes, "%qE attribute ignored", name);
5947 *no_add_attrs = true;
5948 }
5949 if (!TREE_PUBLIC (*node))
5950 {
5951 warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
5952 *no_add_attrs = true;
f8e93a2e 5953 }
5954
5955 return NULL_TREE;
5956}
5957
1b16fc45 5958/* Handle an "artificial" attribute; arguments as in
5959 struct attribute_spec.handler. */
5960
5961static tree
5962handle_artificial_attribute (tree *node, tree name,
5963 tree ARG_UNUSED (args),
5964 int ARG_UNUSED (flags),
5965 bool *no_add_attrs)
5966{
5967 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5968 {
5969 /* Do nothing else, just set the attribute. We'll get at
5970 it later with lookup_attribute. */
5971 }
5972 else
5973 {
5974 warning (OPT_Wattributes, "%qE attribute ignored", name);
5975 *no_add_attrs = true;
5976 }
5977
5978 return NULL_TREE;
5979}
5980
0cdd9887 5981/* Handle a "flatten" attribute; arguments as in
5982 struct attribute_spec.handler. */
5983
5984static tree
5985handle_flatten_attribute (tree *node, tree name,
a0c938f0 5986 tree args ATTRIBUTE_UNUSED,
5987 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
0cdd9887 5988{
5989 if (TREE_CODE (*node) == FUNCTION_DECL)
5990 /* Do nothing else, just set the attribute. We'll get at
5991 it later with lookup_attribute. */
5992 ;
5993 else
5994 {
5995 warning (OPT_Wattributes, "%qE attribute ignored", name);
5996 *no_add_attrs = true;
5997 }
5998
5999 return NULL_TREE;
6000}
6001
10fc867f 6002/* Handle a "warning" or "error" attribute; arguments as in
6003 struct attribute_spec.handler. */
6004
6005static tree
6006handle_error_attribute (tree *node, tree name, tree args,
6007 int ARG_UNUSED (flags), bool *no_add_attrs)
6008{
6009 if (TREE_CODE (*node) == FUNCTION_DECL
6010 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6011 /* Do nothing else, just set the attribute. We'll get at
6012 it later with lookup_attribute. */
6013 ;
6014 else
6015 {
6016 warning (OPT_Wattributes, "%qE attribute ignored", name);
6017 *no_add_attrs = true;
6018 }
6019
6020 return NULL_TREE;
6021}
0cdd9887 6022
f8e93a2e 6023/* Handle a "used" attribute; arguments as in
6024 struct attribute_spec.handler. */
6025
6026static tree
9a03a746 6027handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6028 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6029{
d0a31bd8 6030 tree node = *pnode;
6031
6032 if (TREE_CODE (node) == FUNCTION_DECL
6033 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
f54ed8bc 6034 {
f54ed8bc 6035 TREE_USED (node) = 1;
9423c9b7 6036 DECL_PRESERVE_P (node) = 1;
abc6c64f 6037 if (TREE_CODE (node) == VAR_DECL)
6038 DECL_READ_P (node) = 1;
f54ed8bc 6039 }
f8e93a2e 6040 else
6041 {
9b2d6d13 6042 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6043 *no_add_attrs = true;
6044 }
6045
6046 return NULL_TREE;
6047}
6048
6049/* Handle a "unused" attribute; arguments as in
6050 struct attribute_spec.handler. */
6051
6052static tree
9a03a746 6053handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6054 int flags, bool *no_add_attrs)
f8e93a2e 6055{
6056 if (DECL_P (*node))
6057 {
6058 tree decl = *node;
6059
6060 if (TREE_CODE (decl) == PARM_DECL
6061 || TREE_CODE (decl) == VAR_DECL
6062 || TREE_CODE (decl) == FUNCTION_DECL
6063 || TREE_CODE (decl) == LABEL_DECL
6064 || TREE_CODE (decl) == TYPE_DECL)
abc6c64f 6065 {
6066 TREE_USED (decl) = 1;
6067 if (TREE_CODE (decl) == VAR_DECL
6068 || TREE_CODE (decl) == PARM_DECL)
6069 DECL_READ_P (decl) = 1;
6070 }
f8e93a2e 6071 else
6072 {
9b2d6d13 6073 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6074 *no_add_attrs = true;
6075 }
6076 }
6077 else
6078 {
6079 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 6080 *node = build_variant_type_copy (*node);
f8e93a2e 6081 TREE_USED (*node) = 1;
6082 }
6083
6084 return NULL_TREE;
6085}
6086
62eec3b4 6087/* Handle a "externally_visible" attribute; arguments as in
6088 struct attribute_spec.handler. */
6089
6090static tree
6091handle_externally_visible_attribute (tree *pnode, tree name,
6092 tree ARG_UNUSED (args),
6093 int ARG_UNUSED (flags),
6094 bool *no_add_attrs)
6095{
6096 tree node = *pnode;
6097
ba12ea31 6098 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
62eec3b4 6099 {
ba12ea31 6100 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6101 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6102 {
6103 warning (OPT_Wattributes,
6104 "%qE attribute have effect only on public objects", name);
6105 *no_add_attrs = true;
6106 }
62eec3b4 6107 }
62eec3b4 6108 else
6109 {
6110 warning (OPT_Wattributes, "%qE attribute ignored", name);
6111 *no_add_attrs = true;
6112 }
6113
6114 return NULL_TREE;
6115}
6116
f8e93a2e 6117/* Handle a "const" attribute; arguments as in
6118 struct attribute_spec.handler. */
6119
6120static tree
9a03a746 6121handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6122 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6123{
6124 tree type = TREE_TYPE (*node);
6125
6126 /* See FIXME comment on noreturn in c_common_attribute_table. */
6127 if (TREE_CODE (*node) == FUNCTION_DECL)
6128 TREE_READONLY (*node) = 1;
6129 else if (TREE_CODE (type) == POINTER_TYPE
6130 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6131 TREE_TYPE (*node)
6132 = build_pointer_type
6133 (build_type_variant (TREE_TYPE (type), 1,
6134 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6135 else
6136 {
9b2d6d13 6137 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6138 *no_add_attrs = true;
6139 }
6140
6141 return NULL_TREE;
6142}
6143
6144/* Handle a "transparent_union" attribute; arguments as in
6145 struct attribute_spec.handler. */
6146
6147static tree
1cae46be 6148handle_transparent_union_attribute (tree *node, tree name,
9a03a746 6149 tree ARG_UNUSED (args), int flags,
09347743 6150 bool *no_add_attrs)
f8e93a2e 6151{
881eb642 6152 tree type;
03908818 6153
6154 *no_add_attrs = true;
f8e93a2e 6155
881eb642 6156 if (TREE_CODE (*node) == TYPE_DECL)
6157 node = &TREE_TYPE (*node);
6158 type = *node;
f8e93a2e 6159
03908818 6160 if (TREE_CODE (type) == UNION_TYPE)
f8e93a2e 6161 {
03908818 6162 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6163 the code in finish_struct. */
f8e93a2e 6164 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
03908818 6165 {
6166 if (TYPE_FIELDS (type) == NULL_TREE
914d1151 6167 || c_dialect_cxx ()
03908818 6168 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6169 goto ignored;
6170
6171 /* A type variant isn't good enough, since we don't a cast
6172 to such a type removed as a no-op. */
6173 *node = type = build_duplicate_type (type);
6174 }
6175
8df5a43d 6176 TYPE_TRANSPARENT_AGGR (type) = 1;
03908818 6177 return NULL_TREE;
f8e93a2e 6178 }
6179
03908818 6180 ignored:
6181 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6182 return NULL_TREE;
6183}
6184
9af7fd5b 6185/* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6186 get the requested priority for a constructor or destructor,
6187 possibly issuing diagnostics for invalid or reserved
6188 priorities. */
6189
6190static priority_type
6191get_priority (tree args, bool is_destructor)
6192{
6193 HOST_WIDE_INT pri;
6c181a06 6194 tree arg;
9af7fd5b 6195
6196 if (!args)
6197 return DEFAULT_INIT_PRIORITY;
48e1416a 6198
28fbc04f 6199 if (!SUPPORTS_INIT_PRIORITY)
6200 {
6201 if (is_destructor)
6202 error ("destructor priorities are not supported");
6203 else
6204 error ("constructor priorities are not supported");
6205 return DEFAULT_INIT_PRIORITY;
6206 }
6207
6c181a06 6208 arg = TREE_VALUE (args);
6209 if (!host_integerp (arg, /*pos=*/0)
6210 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
9af7fd5b 6211 goto invalid;
6212
6213 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6214 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6215 goto invalid;
6216
6217 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6218 {
6219 if (is_destructor)
6220 warning (0,
6221 "destructor priorities from 0 to %d are reserved "
48e1416a 6222 "for the implementation",
9af7fd5b 6223 MAX_RESERVED_INIT_PRIORITY);
6224 else
6225 warning (0,
6226 "constructor priorities from 0 to %d are reserved "
48e1416a 6227 "for the implementation",
9af7fd5b 6228 MAX_RESERVED_INIT_PRIORITY);
6229 }
6230 return pri;
6231
6232 invalid:
6233 if (is_destructor)
6234 error ("destructor priorities must be integers from 0 to %d inclusive",
6235 MAX_INIT_PRIORITY);
6236 else
6237 error ("constructor priorities must be integers from 0 to %d inclusive",
6238 MAX_INIT_PRIORITY);
6239 return DEFAULT_INIT_PRIORITY;
6240}
6241
f8e93a2e 6242/* Handle a "constructor" attribute; arguments as in
6243 struct attribute_spec.handler. */
6244
6245static tree
9af7fd5b 6246handle_constructor_attribute (tree *node, tree name, tree args,
9a03a746 6247 int ARG_UNUSED (flags),
09347743 6248 bool *no_add_attrs)
f8e93a2e 6249{
6250 tree decl = *node;
6251 tree type = TREE_TYPE (decl);
6252
6253 if (TREE_CODE (decl) == FUNCTION_DECL
6254 && TREE_CODE (type) == FUNCTION_TYPE
6255 && decl_function_context (decl) == 0)
6256 {
9af7fd5b 6257 priority_type priority;
f8e93a2e 6258 DECL_STATIC_CONSTRUCTOR (decl) = 1;
9af7fd5b 6259 priority = get_priority (args, /*is_destructor=*/false);
6260 SET_DECL_INIT_PRIORITY (decl, priority);
f8e93a2e 6261 TREE_USED (decl) = 1;
6262 }
6263 else
6264 {
9b2d6d13 6265 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6266 *no_add_attrs = true;
6267 }
6268
6269 return NULL_TREE;
6270}
6271
6272/* Handle a "destructor" attribute; arguments as in
6273 struct attribute_spec.handler. */
6274
6275static tree
9af7fd5b 6276handle_destructor_attribute (tree *node, tree name, tree args,
9a03a746 6277 int ARG_UNUSED (flags),
09347743 6278 bool *no_add_attrs)
f8e93a2e 6279{
6280 tree decl = *node;
6281 tree type = TREE_TYPE (decl);
6282
6283 if (TREE_CODE (decl) == FUNCTION_DECL
6284 && TREE_CODE (type) == FUNCTION_TYPE
6285 && decl_function_context (decl) == 0)
6286 {
9af7fd5b 6287 priority_type priority;
f8e93a2e 6288 DECL_STATIC_DESTRUCTOR (decl) = 1;
9af7fd5b 6289 priority = get_priority (args, /*is_destructor=*/true);
6290 SET_DECL_FINI_PRIORITY (decl, priority);
f8e93a2e 6291 TREE_USED (decl) = 1;
6292 }
6293 else
6294 {
9b2d6d13 6295 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6296 *no_add_attrs = true;
6297 }
6298
6299 return NULL_TREE;
6300}
6301
1c58e3f1 6302/* Nonzero if the mode is a valid vector mode for this architecture.
6303 This returns nonzero even if there is no hardware support for the
6304 vector mode, but we can emulate with narrower modes. */
6305
6306static int
6307vector_mode_valid_p (enum machine_mode mode)
6308{
6309 enum mode_class mclass = GET_MODE_CLASS (mode);
6310 enum machine_mode innermode;
6311
6312 /* Doh! What's going on? */
6313 if (mclass != MODE_VECTOR_INT
6314 && mclass != MODE_VECTOR_FLOAT
6315 && mclass != MODE_VECTOR_FRACT
6316 && mclass != MODE_VECTOR_UFRACT
6317 && mclass != MODE_VECTOR_ACCUM
6318 && mclass != MODE_VECTOR_UACCUM)
6319 return 0;
6320
6321 /* Hardware support. Woo hoo! */
6322 if (targetm.vector_mode_supported_p (mode))
6323 return 1;
6324
6325 innermode = GET_MODE_INNER (mode);
6326
6327 /* We should probably return 1 if requesting V4DI and we have no DI,
6328 but we have V2DI, but this is probably very unlikely. */
6329
6330 /* If we have support for the inner mode, we can safely emulate it.
6331 We may not have V2DI, but me can emulate with a pair of DIs. */
6332 return targetm.scalar_mode_supported_p (innermode);
6333}
6334
6335
f8e93a2e 6336/* Handle a "mode" attribute; arguments as in
6337 struct attribute_spec.handler. */
6338
6339static tree
9a03a746 6340handle_mode_attribute (tree *node, tree name, tree args,
6341 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6342{
6343 tree type = *node;
d1dd9ac0 6344 tree ident = TREE_VALUE (args);
f8e93a2e 6345
6346 *no_add_attrs = true;
6347
d1dd9ac0 6348 if (TREE_CODE (ident) != IDENTIFIER_NODE)
9b2d6d13 6349 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6350 else
6351 {
6352 int j;
d1dd9ac0 6353 const char *p = IDENTIFIER_POINTER (ident);
f8e93a2e 6354 int len = strlen (p);
6355 enum machine_mode mode = VOIDmode;
6356 tree typefm;
b2aef146 6357 bool valid_mode;
f8e93a2e 6358
6359 if (len > 4 && p[0] == '_' && p[1] == '_'
6360 && p[len - 1] == '_' && p[len - 2] == '_')
6361 {
4fd61bc6 6362 char *newp = (char *) alloca (len - 1);
f8e93a2e 6363
6364 strcpy (newp, &p[2]);
6365 newp[len - 4] = '\0';
6366 p = newp;
6367 }
6368
6369 /* Change this type to have a type with the specified mode.
6370 First check for the special modes. */
84166705 6371 if (!strcmp (p, "byte"))
f8e93a2e 6372 mode = byte_mode;
6373 else if (!strcmp (p, "word"))
6374 mode = word_mode;
84166705 6375 else if (!strcmp (p, "pointer"))
f8e93a2e 6376 mode = ptr_mode;
0ef89dfd 6377 else if (!strcmp (p, "libgcc_cmp_return"))
6378 mode = targetm.libgcc_cmp_return_mode ();
6379 else if (!strcmp (p, "libgcc_shift_count"))
6380 mode = targetm.libgcc_shift_count_mode ();
1bd43494 6381 else if (!strcmp (p, "unwind_word"))
6382 mode = targetm.unwind_word_mode ();
f8e93a2e 6383 else
6384 for (j = 0; j < NUM_MACHINE_MODES; j++)
6385 if (!strcmp (p, GET_MODE_NAME (j)))
743a6f47 6386 {
6387 mode = (enum machine_mode) j;
6388 break;
6389 }
f8e93a2e 6390
6391 if (mode == VOIDmode)
4917c376 6392 {
d1dd9ac0 6393 error ("unknown machine mode %qE", ident);
4917c376 6394 return NULL_TREE;
6395 }
6396
b2aef146 6397 valid_mode = false;
6398 switch (GET_MODE_CLASS (mode))
4917c376 6399 {
b2aef146 6400 case MODE_INT:
6401 case MODE_PARTIAL_INT:
6402 case MODE_FLOAT:
c4503c0a 6403 case MODE_DECIMAL_FLOAT:
9421ebb9 6404 case MODE_FRACT:
6405 case MODE_UFRACT:
6406 case MODE_ACCUM:
6407 case MODE_UACCUM:
b2aef146 6408 valid_mode = targetm.scalar_mode_supported_p (mode);
6409 break;
6410
6411 case MODE_COMPLEX_INT:
6412 case MODE_COMPLEX_FLOAT:
6413 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6414 break;
6415
6416 case MODE_VECTOR_INT:
6417 case MODE_VECTOR_FLOAT:
9421ebb9 6418 case MODE_VECTOR_FRACT:
6419 case MODE_VECTOR_UFRACT:
6420 case MODE_VECTOR_ACCUM:
6421 case MODE_VECTOR_UACCUM:
9b2d6d13 6422 warning (OPT_Wattributes, "specifying vector types with "
6423 "__attribute__ ((mode)) is deprecated");
6424 warning (OPT_Wattributes,
6425 "use __attribute__ ((vector_size)) instead");
b2aef146 6426 valid_mode = vector_mode_valid_p (mode);
6427 break;
4917c376 6428
b2aef146 6429 default:
6430 break;
6431 }
6432 if (!valid_mode)
6433 {
1e5fcbe2 6434 error ("unable to emulate %qs", p);
b2aef146 6435 return NULL_TREE;
6436 }
4917c376 6437
b2aef146 6438 if (POINTER_TYPE_P (type))
ead34f59 6439 {
6d5d708e 6440 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
b2aef146 6441 tree (*fn)(tree, enum machine_mode, bool);
6442
6d5d708e 6443 if (!targetm.addr_space.valid_pointer_mode (mode, as))
ead34f59 6444 {
1e5fcbe2 6445 error ("invalid pointer mode %qs", p);
ead34f59 6446 return NULL_TREE;
6447 }
6448
a0c938f0 6449 if (TREE_CODE (type) == POINTER_TYPE)
b2aef146 6450 fn = build_pointer_type_for_mode;
805e22b2 6451 else
b2aef146 6452 fn = build_reference_type_for_mode;
6453 typefm = fn (TREE_TYPE (type), mode, false);
ead34f59 6454 }
b2aef146 6455 else
9421ebb9 6456 {
6457 /* For fixed-point modes, we need to test if the signness of type
6458 and the machine mode are consistent. */
6459 if (ALL_FIXED_POINT_MODE_P (mode)
6460 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6461 {
bf776685 6462 error ("signedness of type and machine mode %qs don%'t match", p);
9421ebb9 6463 return NULL_TREE;
6464 }
6465 /* For fixed-point modes, we need to pass saturating info. */
6466 typefm = lang_hooks.types.type_for_mode (mode,
6467 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6468 : TYPE_UNSIGNED (type));
6469 }
3a648ab9 6470
b2aef146 6471 if (typefm == NULL_TREE)
6472 {
743a6f47 6473 error ("no data type for mode %qs", p);
b2aef146 6474 return NULL_TREE;
6475 }
3a648ab9 6476 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6477 {
6478 /* For enumeral types, copy the precision from the integer
6479 type returned above. If not an INTEGER_TYPE, we can't use
6480 this mode for this type. */
6481 if (TREE_CODE (typefm) != INTEGER_TYPE)
6482 {
743a6f47 6483 error ("cannot use mode %qs for enumeral types", p);
3a648ab9 6484 return NULL_TREE;
6485 }
6486
10080eac 6487 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6488 {
6489 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6490 typefm = type;
6491 }
6492 else
6493 {
6494 /* We cannot build a type variant, as there's code that assumes
6495 that TYPE_MAIN_VARIANT has the same mode. This includes the
6496 debug generators. Instead, create a subrange type. This
6497 results in all of the enumeral values being emitted only once
6498 in the original, and the subtype gets them by reference. */
6499 if (TYPE_UNSIGNED (type))
6500 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6501 else
6502 typefm = make_signed_type (TYPE_PRECISION (typefm));
6503 TREE_TYPE (typefm) = type;
6504 }
3a648ab9 6505 }
4bf450a1 6506 else if (VECTOR_MODE_P (mode)
6507 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6508 : TREE_CODE (type) != TREE_CODE (typefm))
743a6f47 6509 {
6510 error ("mode %qs applied to inappropriate type", p);
6511 return NULL_TREE;
6512 }
6513
b2aef146 6514 *node = typefm;
f8e93a2e 6515 }
6516
6517 return NULL_TREE;
6518}
6519
6520/* Handle a "section" attribute; arguments as in
6521 struct attribute_spec.handler. */
6522
6523static tree
9a03a746 6524handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6525 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 6526{
6527 tree decl = *node;
6528
6529 if (targetm.have_named_sections)
6530 {
065efcb1 6531 user_defined_section_attribute = true;
6532
f8e93a2e 6533 if ((TREE_CODE (decl) == FUNCTION_DECL
6534 || TREE_CODE (decl) == VAR_DECL)
6535 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6536 {
6537 if (TREE_CODE (decl) == VAR_DECL
6538 && current_function_decl != NULL_TREE
84166705 6539 && !TREE_STATIC (decl))
f8e93a2e 6540 {
48e1416a 6541 error_at (DECL_SOURCE_LOCATION (decl),
712d2297 6542 "section attribute cannot be specified for "
6543 "local variables");
f8e93a2e 6544 *no_add_attrs = true;
6545 }
6546
6547 /* The decl may have already been given a section attribute
6548 from a previous declaration. Ensure they match. */
6549 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6550 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6551 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6552 {
3cf8b391 6553 error ("section of %q+D conflicts with previous declaration",
6554 *node);
f8e93a2e 6555 *no_add_attrs = true;
6556 }
38475469 6557 else if (TREE_CODE (decl) == VAR_DECL
6558 && !targetm.have_tls && targetm.emutls.tmpl_section
6559 && DECL_THREAD_LOCAL_P (decl))
6560 {
6561 error ("section of %q+D cannot be overridden", *node);
6562 *no_add_attrs = true;
6563 }
f8e93a2e 6564 else
6565 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6566 }
6567 else
6568 {
3cf8b391 6569 error ("section attribute not allowed for %q+D", *node);
f8e93a2e 6570 *no_add_attrs = true;
6571 }
6572 }
6573 else
6574 {
712d2297 6575 error_at (DECL_SOURCE_LOCATION (*node),
6576 "section attributes are not supported for this target");
f8e93a2e 6577 *no_add_attrs = true;
6578 }
6579
6580 return NULL_TREE;
6581}
6582
6583/* Handle a "aligned" attribute; arguments as in
6584 struct attribute_spec.handler. */
6585
6586static tree
9a03a746 6587handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
09347743 6588 int flags, bool *no_add_attrs)
f8e93a2e 6589{
6590 tree decl = NULL_TREE;
6591 tree *type = NULL;
6592 int is_type = 0;
6593 tree align_expr = (args ? TREE_VALUE (args)
02421213 6594 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
f8e93a2e 6595 int i;
6596
6597 if (DECL_P (*node))
6598 {
6599 decl = *node;
6600 type = &TREE_TYPE (decl);
6601 is_type = TREE_CODE (*node) == TYPE_DECL;
6602 }
6603 else if (TYPE_P (*node))
6604 type = node, is_type = 1;
6605
f8e93a2e 6606 if (TREE_CODE (align_expr) != INTEGER_CST)
6607 {
6608 error ("requested alignment is not a constant");
6609 *no_add_attrs = true;
6610 }
6611 else if ((i = tree_log2 (align_expr)) == -1)
6612 {
6613 error ("requested alignment is not a power of 2");
6614 *no_add_attrs = true;
6615 }
7cfdc2f0 6616 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
f8e93a2e 6617 {
6618 error ("requested alignment is too large");
6619 *no_add_attrs = true;
6620 }
6621 else if (is_type)
6622 {
2ec3af9c 6623 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6624 /* OK, modify the type in place. */;
f8e93a2e 6625 /* If we have a TYPE_DECL, then copy the type, so that we
6626 don't accidentally modify a builtin type. See pushdecl. */
2ec3af9c 6627 else if (decl && TREE_TYPE (decl) != error_mark_node
6628 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
f8e93a2e 6629 {
6630 tree tt = TREE_TYPE (decl);
e086912e 6631 *type = build_variant_type_copy (*type);
f8e93a2e 6632 DECL_ORIGINAL_TYPE (decl) = tt;
6633 TYPE_NAME (*type) = decl;
6634 TREE_USED (*type) = TREE_USED (decl);
6635 TREE_TYPE (decl) = *type;
6636 }
2ec3af9c 6637 else
e086912e 6638 *type = build_variant_type_copy (*type);
f8e93a2e 6639
7cfdc2f0 6640 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
f8e93a2e 6641 TYPE_USER_ALIGN (*type) = 1;
6642 }
097b5c8b 6643 else if (! VAR_OR_FUNCTION_DECL_P (decl)
f8e93a2e 6644 && TREE_CODE (decl) != FIELD_DECL)
6645 {
3cf8b391 6646 error ("alignment may not be specified for %q+D", decl);
f8e93a2e 6647 *no_add_attrs = true;
6648 }
097b5c8b 6649 else if (TREE_CODE (decl) == FUNCTION_DECL
7cfdc2f0 6650 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
097b5c8b 6651 {
6652 if (DECL_USER_ALIGN (decl))
6653 error ("alignment for %q+D was previously specified as %d "
6654 "and may not be decreased", decl,
6655 DECL_ALIGN (decl) / BITS_PER_UNIT);
6656 else
6657 error ("alignment for %q+D must be at least %d", decl,
6658 DECL_ALIGN (decl) / BITS_PER_UNIT);
6659 *no_add_attrs = true;
6660 }
f8e93a2e 6661 else
6662 {
7cfdc2f0 6663 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
f8e93a2e 6664 DECL_USER_ALIGN (decl) = 1;
6665 }
6666
6667 return NULL_TREE;
6668}
6669
6670/* Handle a "weak" attribute; arguments as in
6671 struct attribute_spec.handler. */
6672
6673static tree
f948b309 6674handle_weak_attribute (tree *node, tree name,
9a03a746 6675 tree ARG_UNUSED (args),
6676 int ARG_UNUSED (flags),
6677 bool * ARG_UNUSED (no_add_attrs))
f8e93a2e 6678{
f948b309 6679 if (TREE_CODE (*node) == FUNCTION_DECL
059a60f3 6680 && DECL_DECLARED_INLINE_P (*node))
6681 {
0725e25c 6682 warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
059a60f3 6683 *no_add_attrs = true;
6684 }
85c0a25c 6685 else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6686 {
6687 error ("indirect function %q+D cannot be declared weak", *node);
6688 *no_add_attrs = true;
6689 return NULL_TREE;
6690 }
059a60f3 6691 else if (TREE_CODE (*node) == FUNCTION_DECL
6692 || TREE_CODE (*node) == VAR_DECL)
f948b309 6693 declare_weak (*node);
6694 else
6695 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6696
6697 return NULL_TREE;
6698}
6699
85c0a25c 6700/* Handle an "alias" or "ifunc" attribute; arguments as in
6701 struct attribute_spec.handler, except that IS_ALIAS tells us
6702 whether this is an alias as opposed to ifunc attribute. */
f8e93a2e 6703
6704static tree
85c0a25c 6705handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
6706 bool *no_add_attrs)
f8e93a2e 6707{
6708 tree decl = *node;
6709
85c0a25c 6710 if (TREE_CODE (decl) != FUNCTION_DECL
6711 && (!is_alias || TREE_CODE (decl) != VAR_DECL))
9e830260 6712 {
6713 warning (OPT_Wattributes, "%qE attribute ignored", name);
6714 *no_add_attrs = true;
6715 }
6716 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
48e1416a 6717 || (TREE_CODE (decl) != FUNCTION_DECL
0a3ecdc1 6718 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6719 /* A static variable declaration is always a tentative definition,
6720 but the alias is a non-tentative definition which overrides. */
48e1416a 6721 || (TREE_CODE (decl) != FUNCTION_DECL
0a3ecdc1 6722 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
f8e93a2e 6723 {
85c0a25c 6724 error ("%q+D defined both normally and as %qE attribute", decl, name);
f8e93a2e 6725 *no_add_attrs = true;
85c0a25c 6726 return NULL_TREE;
f8e93a2e 6727 }
85c0a25c 6728 else if (!is_alias
6729 && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
6730 || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
6731 {
6732 error ("weak %q+D cannot be defined %qE", decl, name);
6733 *no_add_attrs = true;
6734 return NULL_TREE;
6735 }
8c42f0d9 6736
6737 /* Note that the very first time we process a nested declaration,
6738 decl_function_context will not be set. Indeed, *would* never
6739 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6740 we do below. After such frobbery, pushdecl would set the context.
6741 In any case, this is never what we want. */
6742 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
f8e93a2e 6743 {
6744 tree id;
6745
6746 id = TREE_VALUE (args);
6747 if (TREE_CODE (id) != STRING_CST)
6748 {
85c0a25c 6749 error ("attribute %qE argument not a string", name);
f8e93a2e 6750 *no_add_attrs = true;
6751 return NULL_TREE;
6752 }
6753 id = get_identifier (TREE_STRING_POINTER (id));
6754 /* This counts as a use of the object pointed to. */
6755 TREE_USED (id) = 1;
6756
6757 if (TREE_CODE (decl) == FUNCTION_DECL)
6758 DECL_INITIAL (decl) = error_mark_node;
6759 else
4ee9c684 6760 {
f4a30bd7 6761 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6762 DECL_EXTERNAL (decl) = 1;
6763 else
6764 DECL_EXTERNAL (decl) = 0;
4ee9c684 6765 TREE_STATIC (decl) = 1;
6766 }
85c0a25c 6767
6768 if (!is_alias)
6769 /* ifuncs are also aliases, so set that attribute too. */
6770 DECL_ATTRIBUTES (decl)
6771 = tree_cons (get_identifier ("alias"), args, DECL_ATTRIBUTES (decl));
f8e93a2e 6772 }
6773 else
6774 {
9b2d6d13 6775 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 6776 *no_add_attrs = true;
6777 }
6778
6779 return NULL_TREE;
6780}
6781
85c0a25c 6782/* Handle an "alias" or "ifunc" attribute; arguments as in
6783 struct attribute_spec.handler. */
6784
6785static tree
6786handle_ifunc_attribute (tree *node, tree name, tree args,
6787 int ARG_UNUSED (flags), bool *no_add_attrs)
6788{
6789 return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
6790}
6791
6792/* Handle an "alias" or "ifunc" attribute; arguments as in
6793 struct attribute_spec.handler. */
6794
6795static tree
6796handle_alias_attribute (tree *node, tree name, tree args,
6797 int ARG_UNUSED (flags), bool *no_add_attrs)
6798{
6799 return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
6800}
6801
f4a30bd7 6802/* Handle a "weakref" attribute; arguments as in struct
6803 attribute_spec.handler. */
6804
6805static tree
6806handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6807 int flags, bool *no_add_attrs)
6808{
6809 tree attr = NULL_TREE;
6810
83852912 6811 /* We must ignore the attribute when it is associated with
6812 local-scoped decls, since attribute alias is ignored and many
6813 such symbols do not even have a DECL_WEAK field. */
64a7bd81 6814 if (decl_function_context (*node)
6815 || current_function_decl
6816 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
83852912 6817 {
6818 warning (OPT_Wattributes, "%qE attribute ignored", name);
6819 *no_add_attrs = true;
6820 return NULL_TREE;
6821 }
6822
85c0a25c 6823 if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6824 {
6825 error ("indirect function %q+D cannot be declared weakref", *node);
6826 *no_add_attrs = true;
6827 return NULL_TREE;
6828 }
6829
f4a30bd7 6830 /* The idea here is that `weakref("name")' mutates into `weakref,
6831 alias("name")', and weakref without arguments, in turn,
6832 implicitly adds weak. */
6833
6834 if (args)
6835 {
6836 attr = tree_cons (get_identifier ("alias"), args, attr);
6837 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6838
6839 *no_add_attrs = true;
0a3ecdc1 6840
6841 decl_attributes (node, attr, flags);
f4a30bd7 6842 }
6843 else
6844 {
6845 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
712d2297 6846 error_at (DECL_SOURCE_LOCATION (*node),
6847 "weakref attribute must appear before alias attribute");
f4a30bd7 6848
0a3ecdc1 6849 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6850 and that isn't supported; and because it wants to add it to
6851 the list of weak decls, which isn't helpful. */
6852 DECL_WEAK (*node) = 1;
f4a30bd7 6853 }
6854
f4a30bd7 6855 return NULL_TREE;
6856}
6857
f8e93a2e 6858/* Handle an "visibility" attribute; arguments as in
6859 struct attribute_spec.handler. */
6860
6861static tree
1cae46be 6862handle_visibility_attribute (tree *node, tree name, tree args,
9a03a746 6863 int ARG_UNUSED (flags),
4a2849cb 6864 bool *ARG_UNUSED (no_add_attrs))
f8e93a2e 6865{
6866 tree decl = *node;
9c40570a 6867 tree id = TREE_VALUE (args);
4a2849cb 6868 enum symbol_visibility vis;
f8e93a2e 6869
b212f378 6870 if (TYPE_P (*node))
6871 {
4a2849cb 6872 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6873 /* OK */;
6874 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6875 {
6876 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6877 name);
6878 return NULL_TREE;
6879 }
6880 else if (TYPE_FIELDS (*node))
6881 {
6882 error ("%qE attribute ignored because %qT is already defined",
6883 name, *node);
6884 return NULL_TREE;
6885 }
b212f378 6886 }
84166705 6887 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
f8e93a2e 6888 {
9b2d6d13 6889 warning (OPT_Wattributes, "%qE attribute ignored", name);
9c40570a 6890 return NULL_TREE;
f8e93a2e 6891 }
f8e93a2e 6892
9c40570a 6893 if (TREE_CODE (id) != STRING_CST)
6894 {
07e3a3d2 6895 error ("visibility argument not a string");
9c40570a 6896 return NULL_TREE;
f8e93a2e 6897 }
b27ac6b5 6898
b212f378 6899 /* If this is a type, set the visibility on the type decl. */
6900 if (TYPE_P (decl))
6901 {
6902 decl = TYPE_NAME (decl);
84166705 6903 if (!decl)
a0c938f0 6904 return NULL_TREE;
e147aab3 6905 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6906 {
9b2d6d13 6907 warning (OPT_Wattributes, "%qE attribute ignored on types",
e147aab3 6908 name);
6909 return NULL_TREE;
6910 }
b212f378 6911 }
f8e93a2e 6912
9c40570a 6913 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4a2849cb 6914 vis = VISIBILITY_DEFAULT;
9c40570a 6915 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4a2849cb 6916 vis = VISIBILITY_INTERNAL;
9c40570a 6917 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4a2849cb 6918 vis = VISIBILITY_HIDDEN;
9c40570a 6919 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4a2849cb 6920 vis = VISIBILITY_PROTECTED;
9c40570a 6921 else
4a2849cb 6922 {
6923 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6924 vis = VISIBILITY_DEFAULT;
6925 }
6926
6927 if (DECL_VISIBILITY_SPECIFIED (decl)
098a01e7 6928 && vis != DECL_VISIBILITY (decl))
6929 {
6930 tree attributes = (TYPE_P (*node)
6931 ? TYPE_ATTRIBUTES (*node)
6932 : DECL_ATTRIBUTES (decl));
6933 if (lookup_attribute ("visibility", attributes))
6934 error ("%qD redeclared with different visibility", decl);
6935 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6936 && lookup_attribute ("dllimport", attributes))
6937 error ("%qD was declared %qs which implies default visibility",
6938 decl, "dllimport");
6939 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6940 && lookup_attribute ("dllexport", attributes))
6941 error ("%qD was declared %qs which implies default visibility",
6942 decl, "dllexport");
6943 }
4a2849cb 6944
6945 DECL_VISIBILITY (decl) = vis;
b212f378 6946 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6947
4a2849cb 6948 /* Go ahead and attach the attribute to the node as well. This is needed
6949 so we can determine whether we have VISIBILITY_DEFAULT because the
6950 visibility was not specified, or because it was explicitly overridden
6951 from the containing scope. */
9c40570a 6952
f8e93a2e 6953 return NULL_TREE;
6954}
6955
3aa0c315 6956/* Determine the ELF symbol visibility for DECL, which is either a
6957 variable or a function. It is an error to use this function if a
6958 definition of DECL is not available in this translation unit.
6959 Returns true if the final visibility has been determined by this
6960 function; false if the caller is free to make additional
6961 modifications. */
6962
6963bool
6964c_determine_visibility (tree decl)
6965{
1d8fc210 6966 gcc_assert (TREE_CODE (decl) == VAR_DECL
6967 || TREE_CODE (decl) == FUNCTION_DECL);
3aa0c315 6968
6969 /* If the user explicitly specified the visibility with an
6970 attribute, honor that. DECL_VISIBILITY will have been set during
6971 the processing of the attribute. We check for an explicit
6972 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6973 to distinguish the use of an attribute from the use of a "#pragma
6974 GCC visibility push(...)"; in the latter case we still want other
6975 considerations to be able to overrule the #pragma. */
098a01e7 6976 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6977 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6978 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6979 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
3aa0c315 6980 return true;
6981
4a2849cb 6982 /* Set default visibility to whatever the user supplied with
6983 visibility_specified depending on #pragma GCC visibility. */
6984 if (!DECL_VISIBILITY_SPECIFIED (decl))
6985 {
2d9d8740 6986 if (visibility_options.inpragma
6987 || DECL_VISIBILITY (decl) != default_visibility)
6988 {
6989 DECL_VISIBILITY (decl) = default_visibility;
6990 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6991 /* If visibility changed and DECL already has DECL_RTL, ensure
6992 symbol flags are updated. */
6993 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6994 || TREE_CODE (decl) == FUNCTION_DECL)
6995 && DECL_RTL_SET_P (decl))
6996 make_decl_rtl (decl);
6997 }
4a2849cb 6998 }
3aa0c315 6999 return false;
7000}
7001
24dfead4 7002/* Handle an "tls_model" attribute; arguments as in
7003 struct attribute_spec.handler. */
7004
7005static tree
1cae46be 7006handle_tls_model_attribute (tree *node, tree name, tree args,
9a03a746 7007 int ARG_UNUSED (flags), bool *no_add_attrs)
24dfead4 7008{
1b53eb20 7009 tree id;
24dfead4 7010 tree decl = *node;
1b53eb20 7011 enum tls_model kind;
24dfead4 7012
1b53eb20 7013 *no_add_attrs = true;
7014
c34f8a78 7015 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
24dfead4 7016 {
9b2d6d13 7017 warning (OPT_Wattributes, "%qE attribute ignored", name);
1b53eb20 7018 return NULL_TREE;
24dfead4 7019 }
24dfead4 7020
1b53eb20 7021 kind = DECL_TLS_MODEL (decl);
7022 id = TREE_VALUE (args);
7023 if (TREE_CODE (id) != STRING_CST)
7024 {
7025 error ("tls_model argument not a string");
7026 return NULL_TREE;
24dfead4 7027 }
7028
1b53eb20 7029 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7030 kind = TLS_MODEL_LOCAL_EXEC;
7031 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7032 kind = TLS_MODEL_INITIAL_EXEC;
7033 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7034 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7035 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7036 kind = TLS_MODEL_GLOBAL_DYNAMIC;
7037 else
7038 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7039
7040 DECL_TLS_MODEL (decl) = kind;
24dfead4 7041 return NULL_TREE;
7042}
7043
f8e93a2e 7044/* Handle a "no_instrument_function" attribute; arguments as in
7045 struct attribute_spec.handler. */
7046
7047static tree
1cae46be 7048handle_no_instrument_function_attribute (tree *node, tree name,
9a03a746 7049 tree ARG_UNUSED (args),
7050 int ARG_UNUSED (flags),
09347743 7051 bool *no_add_attrs)
f8e93a2e 7052{
7053 tree decl = *node;
7054
7055 if (TREE_CODE (decl) != FUNCTION_DECL)
7056 {
712d2297 7057 error_at (DECL_SOURCE_LOCATION (decl),
7058 "%qE attribute applies only to functions", name);
f8e93a2e 7059 *no_add_attrs = true;
7060 }
7061 else if (DECL_INITIAL (decl))
7062 {
712d2297 7063 error_at (DECL_SOURCE_LOCATION (decl),
7064 "can%'t set %qE attribute after definition", name);
f8e93a2e 7065 *no_add_attrs = true;
7066 }
7067 else
7068 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7069
7070 return NULL_TREE;
7071}
7072
7073/* Handle a "malloc" attribute; arguments as in
7074 struct attribute_spec.handler. */
7075
7076static tree
9a03a746 7077handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7078 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 7079{
a5147fca 7080 if (TREE_CODE (*node) == FUNCTION_DECL
7081 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
f8e93a2e 7082 DECL_IS_MALLOC (*node) = 1;
f8e93a2e 7083 else
7084 {
9b2d6d13 7085 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7086 *no_add_attrs = true;
7087 }
7088
7089 return NULL_TREE;
7090}
7091
4a29c97c 7092/* Handle a "alloc_size" attribute; arguments as in
7093 struct attribute_spec.handler. */
7094
7095static tree
7096handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7097 int ARG_UNUSED (flags), bool *no_add_attrs)
7098{
2802826e 7099 unsigned arg_count = type_num_arguments (*node);
4a29c97c 7100 for (; args; args = TREE_CHAIN (args))
7101 {
7102 tree position = TREE_VALUE (args);
7103
7104 if (TREE_CODE (position) != INTEGER_CST
48e1416a 7105 || TREE_INT_CST_HIGH (position)
4a29c97c 7106 || TREE_INT_CST_LOW (position) < 1
7107 || TREE_INT_CST_LOW (position) > arg_count )
7108 {
48e1416a 7109 warning (OPT_Wattributes,
4a29c97c 7110 "alloc_size parameter outside range");
7111 *no_add_attrs = true;
7112 return NULL_TREE;
7113 }
7114 }
7115 return NULL_TREE;
7116}
7117
8ce86007 7118/* Handle a "fn spec" attribute; arguments as in
7119 struct attribute_spec.handler. */
7120
7121static tree
7122handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7123 tree args, int ARG_UNUSED (flags),
7124 bool *no_add_attrs ATTRIBUTE_UNUSED)
7125{
7126 gcc_assert (args
7127 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7128 && !TREE_CHAIN (args));
7129 return NULL_TREE;
7130}
7131
26d1c5ff 7132/* Handle a "returns_twice" attribute; arguments as in
7133 struct attribute_spec.handler. */
7134
7135static tree
7136handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7137 int ARG_UNUSED (flags), bool *no_add_attrs)
7138{
7139 if (TREE_CODE (*node) == FUNCTION_DECL)
7140 DECL_IS_RETURNS_TWICE (*node) = 1;
7141 else
7142 {
9b2d6d13 7143 warning (OPT_Wattributes, "%qE attribute ignored", name);
26d1c5ff 7144 *no_add_attrs = true;
7145 }
7146
7147 return NULL_TREE;
7148}
7149
f8e93a2e 7150/* Handle a "no_limit_stack" attribute; arguments as in
7151 struct attribute_spec.handler. */
7152
7153static tree
1cae46be 7154handle_no_limit_stack_attribute (tree *node, tree name,
9a03a746 7155 tree ARG_UNUSED (args),
7156 int ARG_UNUSED (flags),
09347743 7157 bool *no_add_attrs)
f8e93a2e 7158{
7159 tree decl = *node;
7160
7161 if (TREE_CODE (decl) != FUNCTION_DECL)
7162 {
712d2297 7163 error_at (DECL_SOURCE_LOCATION (decl),
7164 "%qE attribute applies only to functions", name);
f8e93a2e 7165 *no_add_attrs = true;
7166 }
7167 else if (DECL_INITIAL (decl))
7168 {
712d2297 7169 error_at (DECL_SOURCE_LOCATION (decl),
7170 "can%'t set %qE attribute after definition", name);
f8e93a2e 7171 *no_add_attrs = true;
7172 }
7173 else
7174 DECL_NO_LIMIT_STACK (decl) = 1;
7175
7176 return NULL_TREE;
7177}
7178
7179/* Handle a "pure" attribute; arguments as in
7180 struct attribute_spec.handler. */
7181
7182static tree
9a03a746 7183handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7184 int ARG_UNUSED (flags), bool *no_add_attrs)
f8e93a2e 7185{
7186 if (TREE_CODE (*node) == FUNCTION_DECL)
9c2a0c05 7187 DECL_PURE_P (*node) = 1;
f8e93a2e 7188 /* ??? TODO: Support types. */
7189 else
7190 {
9b2d6d13 7191 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7192 *no_add_attrs = true;
7193 }
7194
7195 return NULL_TREE;
7196}
7197
fc09b200 7198/* Handle a "no vops" attribute; arguments as in
7199 struct attribute_spec.handler. */
7200
7201static tree
7202handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7203 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7204 bool *ARG_UNUSED (no_add_attrs))
7205{
7206 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7207 DECL_IS_NOVOPS (*node) = 1;
7208 return NULL_TREE;
7209}
7210
f8e93a2e 7211/* Handle a "deprecated" attribute; arguments as in
7212 struct attribute_spec.handler. */
1cae46be 7213
f8e93a2e 7214static tree
1cae46be 7215handle_deprecated_attribute (tree *node, tree name,
45c4e798 7216 tree args, int flags,
09347743 7217 bool *no_add_attrs)
f8e93a2e 7218{
7219 tree type = NULL_TREE;
7220 int warn = 0;
782858b8 7221 tree what = NULL_TREE;
1cae46be 7222
45c4e798 7223 if (!args)
7224 *no_add_attrs = true;
7225 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7226 {
7227 error ("deprecated message is not a string");
7228 *no_add_attrs = true;
7229 }
7230
f8e93a2e 7231 if (DECL_P (*node))
7232 {
7233 tree decl = *node;
7234 type = TREE_TYPE (decl);
1cae46be 7235
f8e93a2e 7236 if (TREE_CODE (decl) == TYPE_DECL
7237 || TREE_CODE (decl) == PARM_DECL
7238 || TREE_CODE (decl) == VAR_DECL
7239 || TREE_CODE (decl) == FUNCTION_DECL
40c8d1dd 7240 || TREE_CODE (decl) == FIELD_DECL
7241 || objc_method_decl (TREE_CODE (decl)))
f8e93a2e 7242 TREE_DEPRECATED (decl) = 1;
7243 else
7244 warn = 1;
7245 }
7246 else if (TYPE_P (*node))
7247 {
7248 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
e086912e 7249 *node = build_variant_type_copy (*node);
f8e93a2e 7250 TREE_DEPRECATED (*node) = 1;
7251 type = *node;
7252 }
7253 else
7254 warn = 1;
1cae46be 7255
f8e93a2e 7256 if (warn)
7257 {
7258 *no_add_attrs = true;
7259 if (type && TYPE_NAME (type))
7260 {
7261 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
782858b8 7262 what = TYPE_NAME (*node);
f8e93a2e 7263 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7264 && DECL_NAME (TYPE_NAME (type)))
782858b8 7265 what = DECL_NAME (TYPE_NAME (type));
f8e93a2e 7266 }
7267 if (what)
9b2d6d13 7268 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
f8e93a2e 7269 else
9b2d6d13 7270 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7271 }
7272
7273 return NULL_TREE;
7274}
7275
f8e93a2e 7276/* Handle a "vector_size" attribute; arguments as in
7277 struct attribute_spec.handler. */
7278
7279static tree
1cae46be 7280handle_vector_size_attribute (tree *node, tree name, tree args,
9a03a746 7281 int ARG_UNUSED (flags),
09347743 7282 bool *no_add_attrs)
f8e93a2e 7283{
7284 unsigned HOST_WIDE_INT vecsize, nunits;
83e2a11b 7285 enum machine_mode orig_mode;
4917c376 7286 tree type = *node, new_type, size;
f8e93a2e 7287
7288 *no_add_attrs = true;
7289
4917c376 7290 size = TREE_VALUE (args);
4917c376 7291
84166705 7292 if (!host_integerp (size, 1))
f8e93a2e 7293 {
9b2d6d13 7294 warning (OPT_Wattributes, "%qE attribute ignored", name);
f8e93a2e 7295 return NULL_TREE;
7296 }
7297
7298 /* Get the vector size (in bytes). */
4917c376 7299 vecsize = tree_low_cst (size, 1);
f8e93a2e 7300
7301 /* We need to provide for vector pointers, vector arrays, and
7302 functions returning vectors. For example:
7303
7304 __attribute__((vector_size(16))) short *foo;
7305
7306 In this case, the mode is SI, but the type being modified is
7307 HI, so we need to look further. */
7308
7309 while (POINTER_TYPE_P (type)
7310 || TREE_CODE (type) == FUNCTION_TYPE
5bfb0742 7311 || TREE_CODE (type) == METHOD_TYPE
2cb0e5d9 7312 || TREE_CODE (type) == ARRAY_TYPE
7313 || TREE_CODE (type) == OFFSET_TYPE)
f8e93a2e 7314 type = TREE_TYPE (type);
7315
7316 /* Get the mode of the type being modified. */
7317 orig_mode = TYPE_MODE (type);
7318
2cb0e5d9 7319 if ((!INTEGRAL_TYPE_P (type)
7320 && !SCALAR_FLOAT_TYPE_P (type)
7321 && !FIXED_POINT_TYPE_P (type))
cee7491d 7322 || (!SCALAR_FLOAT_MODE_P (orig_mode)
9421ebb9 7323 && GET_MODE_CLASS (orig_mode) != MODE_INT
7324 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7ec31215 7325 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7326 || TREE_CODE (type) == BOOLEAN_TYPE)
f8e93a2e 7327 {
782858b8 7328 error ("invalid vector type for attribute %qE", name);
f8e93a2e 7329 return NULL_TREE;
7330 }
7331
39cc3e6d 7332 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7333 {
7334 error ("vector size not an integral multiple of component size");
7335 return NULL;
7336 }
7337
7338 if (vecsize == 0)
7339 {
7340 error ("zero vector size");
7341 return NULL;
7342 }
7343
f8e93a2e 7344 /* Calculate how many units fit in the vector. */
7345 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
83e2a11b 7346 if (nunits & (nunits - 1))
f8e93a2e 7347 {
83e2a11b 7348 error ("number of components of the vector not a power of two");
f8e93a2e 7349 return NULL_TREE;
7350 }
7351
83e2a11b 7352 new_type = build_vector_type (type, nunits);
f8e93a2e 7353
7354 /* Build back pointers if needed. */
d991e6e8 7355 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
f8e93a2e 7356
7357 return NULL_TREE;
7358}
7359
dbf6c367 7360/* Handle the "nonnull" attribute. */
7361static tree
9a03a746 7362handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7363 tree args, int ARG_UNUSED (flags),
09347743 7364 bool *no_add_attrs)
dbf6c367 7365{
7366 tree type = *node;
7367 unsigned HOST_WIDE_INT attr_arg_num;
7368
7369 /* If no arguments are specified, all pointer arguments should be
d716ce75 7370 non-null. Verify a full prototype is given so that the arguments
dbf6c367 7371 will have the correct types when we actually check them later. */
84166705 7372 if (!args)
dbf6c367 7373 {
a36cf284 7374 if (!prototype_p (type))
dbf6c367 7375 {
7376 error ("nonnull attribute without arguments on a non-prototype");
4ee9c684 7377 *no_add_attrs = true;
dbf6c367 7378 }
7379 return NULL_TREE;
7380 }
7381
7382 /* Argument list specified. Verify that each argument number references
7383 a pointer argument. */
7384 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7385 {
7386 tree argument;
4ee9c684 7387 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
dbf6c367 7388
84166705 7389 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
dbf6c367 7390 {
07e3a3d2 7391 error ("nonnull argument has invalid operand number (argument %lu)",
dbf6c367 7392 (unsigned long) attr_arg_num);
7393 *no_add_attrs = true;
7394 return NULL_TREE;
7395 }
7396
7397 argument = TYPE_ARG_TYPES (type);
7398 if (argument)
7399 {
7400 for (ck_num = 1; ; ck_num++)
7401 {
84166705 7402 if (!argument || ck_num == arg_num)
dbf6c367 7403 break;
7404 argument = TREE_CHAIN (argument);
7405 }
7406
84166705 7407 if (!argument
dbf6c367 7408 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7409 {
07e3a3d2 7410 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
dbf6c367 7411 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7412 *no_add_attrs = true;
7413 return NULL_TREE;
7414 }
7415
4ee9c684 7416 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
dbf6c367 7417 {
07e3a3d2 7418 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
dbf6c367 7419 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7420 *no_add_attrs = true;
7421 return NULL_TREE;
7422 }
7423 }
7424 }
7425
7426 return NULL_TREE;
7427}
7428
7429/* Check the argument list of a function call for null in argument slots
d01f58f9 7430 that are marked as requiring a non-null pointer argument. The NARGS
7431 arguments are passed in the array ARGARRAY.
7432*/
dbf6c367 7433
7434static void
d01f58f9 7435check_function_nonnull (tree attrs, int nargs, tree *argarray)
dbf6c367 7436{
d01f58f9 7437 tree a, args;
7438 int i;
dbf6c367 7439
7440 for (a = attrs; a; a = TREE_CHAIN (a))
7441 {
7442 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7443 {
4ee9c684 7444 args = TREE_VALUE (a);
dbf6c367 7445
4ee9c684 7446 /* Walk the argument list. If we encounter an argument number we
7447 should check for non-null, do it. If the attribute has no args,
7448 then every pointer argument is checked (in which case the check
dbf6c367 7449 for pointer type is done in check_nonnull_arg). */
d01f58f9 7450 for (i = 0; i < nargs; i++)
4ee9c684 7451 {
d01f58f9 7452 if (!args || nonnull_check_p (args, i + 1))
e4603171 7453 check_function_arguments_recurse (check_nonnull_arg, NULL,
d01f58f9 7454 argarray[i],
7455 i + 1);
4ee9c684 7456 }
dbf6c367 7457 }
7458 }
7459}
7460
50ca527f 7461/* Check that the Nth argument of a function call (counting backwards
d01f58f9 7462 from the end) is a (pointer)0. The NARGS arguments are passed in the
7463 array ARGARRAY. */
bf6c8de0 7464
7465static void
d01f58f9 7466check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
bf6c8de0 7467{
7468 tree attr = lookup_attribute ("sentinel", attrs);
7469
7470 if (attr)
7471 {
d01f58f9 7472 int len = 0;
7473 int pos = 0;
7474 tree sentinel;
a0c938f0 7475
d01f58f9 7476 /* Skip over the named arguments. */
7477 while (typelist && len < nargs)
a0c938f0 7478 {
d01f58f9 7479 typelist = TREE_CHAIN (typelist);
7480 len++;
7481 }
50ca527f 7482
d01f58f9 7483 if (TREE_VALUE (attr))
7484 {
7485 tree p = TREE_VALUE (TREE_VALUE (attr));
7486 pos = TREE_INT_CST_LOW (p);
7487 }
50ca527f 7488
d01f58f9 7489 /* The sentinel must be one of the varargs, i.e.
7490 in position >= the number of fixed arguments. */
7491 if ((nargs - 1 - pos) < len)
7492 {
7493 warning (OPT_Wformat,
7494 "not enough variable arguments to fit a sentinel");
7495 return;
bf6c8de0 7496 }
d01f58f9 7497
7498 /* Validate the sentinel. */
7499 sentinel = argarray[nargs - 1 - pos];
7500 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7501 || !integer_zerop (sentinel))
7502 /* Although __null (in C++) is only an integer we allow it
7503 nevertheless, as we are guaranteed that it's exactly
7504 as wide as a pointer, and we don't want to force
7505 users to cast the NULL they have written there.
7506 We warn with -Wstrict-null-sentinel, though. */
7507 && (warn_strict_null_sentinel || null_node != sentinel))
7508 warning (OPT_Wformat, "missing sentinel in function call");
bf6c8de0 7509 }
7510}
7511
dbf6c367 7512/* Helper for check_function_nonnull; given a list of operands which
7513 must be non-null in ARGS, determine if operand PARAM_NUM should be
7514 checked. */
7515
7516static bool
1cae46be 7517nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
dbf6c367 7518{
4ee9c684 7519 unsigned HOST_WIDE_INT arg_num = 0;
dbf6c367 7520
7521 for (; args; args = TREE_CHAIN (args))
7522 {
231bd014 7523 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7524
7525 gcc_assert (found);
dbf6c367 7526
7527 if (arg_num == param_num)
7528 return true;
7529 }
7530 return false;
7531}
7532
7533/* Check that the function argument PARAM (which is operand number
7534 PARAM_NUM) is non-null. This is called by check_function_nonnull
7535 via check_function_arguments_recurse. */
7536
7537static void
9a03a746 7538check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
1cae46be 7539 unsigned HOST_WIDE_INT param_num)
dbf6c367 7540{
7541 /* Just skip checking the argument if it's not a pointer. This can
7542 happen if the "nonnull" attribute was given without an operand
7543 list (which means to check every pointer argument). */
7544
7545 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7546 return;
7547
7548 if (integer_zerop (param))
155b601b 7549 warning (OPT_Wnonnull, "null argument where non-null required "
7550 "(argument %lu)", (unsigned long) param_num);
dbf6c367 7551}
7552
7553/* Helper for nonnull attribute handling; fetch the operand number
7554 from the attribute argument list. */
7555
7556static bool
1cae46be 7557get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
dbf6c367 7558{
67409385 7559 /* Verify the arg number is a constant. */
dbf6c367 7560 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7561 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7562 return false;
7563
7564 *valp = TREE_INT_CST_LOW (arg_num_expr);
7565 return true;
7566}
fa987697 7567
7568/* Handle a "nothrow" attribute; arguments as in
7569 struct attribute_spec.handler. */
7570
7571static tree
9a03a746 7572handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7573 int ARG_UNUSED (flags), bool *no_add_attrs)
fa987697 7574{
7575 if (TREE_CODE (*node) == FUNCTION_DECL)
7576 TREE_NOTHROW (*node) = 1;
7577 /* ??? TODO: Support types. */
7578 else
7579 {
9b2d6d13 7580 warning (OPT_Wattributes, "%qE attribute ignored", name);
fa987697 7581 *no_add_attrs = true;
7582 }
7583
7584 return NULL_TREE;
7585}
7acb29a3 7586
7587/* Handle a "cleanup" attribute; arguments as in
7588 struct attribute_spec.handler. */
7589
7590static tree
1cae46be 7591handle_cleanup_attribute (tree *node, tree name, tree args,
9a03a746 7592 int ARG_UNUSED (flags), bool *no_add_attrs)
7acb29a3 7593{
7594 tree decl = *node;
7595 tree cleanup_id, cleanup_decl;
7596
7597 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7598 for global destructors in C++. This requires infrastructure that
7599 we don't have generically at the moment. It's also not a feature
7600 we'd be missing too much, since we do have attribute constructor. */
7601 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7602 {
9b2d6d13 7603 warning (OPT_Wattributes, "%qE attribute ignored", name);
7acb29a3 7604 *no_add_attrs = true;
7605 return NULL_TREE;
7606 }
7607
7608 /* Verify that the argument is a function in scope. */
7609 /* ??? We could support pointers to functions here as well, if
7610 that was considered desirable. */
7611 cleanup_id = TREE_VALUE (args);
7612 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7613 {
07e3a3d2 7614 error ("cleanup argument not an identifier");
7acb29a3 7615 *no_add_attrs = true;
7616 return NULL_TREE;
7617 }
d1c41717 7618 cleanup_decl = lookup_name (cleanup_id);
7acb29a3 7619 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7620 {
07e3a3d2 7621 error ("cleanup argument not a function");
7acb29a3 7622 *no_add_attrs = true;
7623 return NULL_TREE;
7624 }
7625
1cae46be 7626 /* That the function has proper type is checked with the
7acb29a3 7627 eventual call to build_function_call. */
7628
7629 return NULL_TREE;
7630}
8a8cdb8d 7631
7632/* Handle a "warn_unused_result" attribute. No special handling. */
7633
7634static tree
7635handle_warn_unused_result_attribute (tree *node, tree name,
9a03a746 7636 tree ARG_UNUSED (args),
7637 int ARG_UNUSED (flags), bool *no_add_attrs)
8a8cdb8d 7638{
7639 /* Ignore the attribute for functions not returning any value. */
7640 if (VOID_TYPE_P (TREE_TYPE (*node)))
7641 {
9b2d6d13 7642 warning (OPT_Wattributes, "%qE attribute ignored", name);
8a8cdb8d 7643 *no_add_attrs = true;
7644 }
7645
7646 return NULL_TREE;
7647}
bf6c8de0 7648
7649/* Handle a "sentinel" attribute. */
7650
7651static tree
50ca527f 7652handle_sentinel_attribute (tree *node, tree name, tree args,
bf6c8de0 7653 int ARG_UNUSED (flags), bool *no_add_attrs)
7654{
7655 tree params = TYPE_ARG_TYPES (*node);
7656
a36cf284 7657 if (!prototype_p (*node))
bf6c8de0 7658 {
9b2d6d13 7659 warning (OPT_Wattributes,
7660 "%qE attribute requires prototypes with named arguments", name);
bf6c8de0 7661 *no_add_attrs = true;
bf6c8de0 7662 }
50ca527f 7663 else
7664 {
7665 while (TREE_CHAIN (params))
7666 params = TREE_CHAIN (params);
bf6c8de0 7667
50ca527f 7668 if (VOID_TYPE_P (TREE_VALUE (params)))
a0c938f0 7669 {
9b2d6d13 7670 warning (OPT_Wattributes,
7671 "%qE attribute only applies to variadic functions", name);
50ca527f 7672 *no_add_attrs = true;
7673 }
7674 }
a0c938f0 7675
50ca527f 7676 if (args)
bf6c8de0 7677 {
50ca527f 7678 tree position = TREE_VALUE (args);
7679
50ca527f 7680 if (TREE_CODE (position) != INTEGER_CST)
a0c938f0 7681 {
48e1416a 7682 warning (OPT_Wattributes,
01b54db5 7683 "requested position is not an integer constant");
50ca527f 7684 *no_add_attrs = true;
7685 }
7686 else
a0c938f0 7687 {
50ca527f 7688 if (tree_int_cst_lt (position, integer_zero_node))
7689 {
01b54db5 7690 warning (OPT_Wattributes,
7691 "requested position is less than zero");
50ca527f 7692 *no_add_attrs = true;
7693 }
7694 }
bf6c8de0 7695 }
a0c938f0 7696
bf6c8de0 7697 return NULL_TREE;
7698}
b5c26b42 7699
7700/* Handle a "type_generic" attribute. */
7701
7702static tree
7703handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7704 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7705 bool * ARG_UNUSED (no_add_attrs))
7706{
19fbe3a4 7707 tree params;
48e1416a 7708
19fbe3a4 7709 /* Ensure we have a function type. */
7710 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
48e1416a 7711
19fbe3a4 7712 params = TYPE_ARG_TYPES (*node);
7713 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7714 params = TREE_CHAIN (params);
7715
7716 /* Ensure we have a variadic function. */
7717 gcc_assert (!params);
b5c26b42 7718
7719 return NULL_TREE;
7720}
46f8e3b0 7721
24470055 7722/* Handle a "target" attribute. */
46f8e3b0 7723
7724static tree
24470055 7725handle_target_attribute (tree *node, tree name, tree args, int flags,
46f8e3b0 7726 bool *no_add_attrs)
7727{
7728 /* Ensure we have a function type. */
7729 if (TREE_CODE (*node) != FUNCTION_DECL)
7730 {
7731 warning (OPT_Wattributes, "%qE attribute ignored", name);
7732 *no_add_attrs = true;
7733 }
46f8e3b0 7734 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7735 flags))
7736 *no_add_attrs = true;
7737
7738 return NULL_TREE;
7739}
7740
7741/* Arguments being collected for optimization. */
7742typedef const char *const_char_p; /* For DEF_VEC_P. */
7743DEF_VEC_P(const_char_p);
7744DEF_VEC_ALLOC_P(const_char_p, gc);
7745static GTY(()) VEC(const_char_p, gc) *optimize_args;
7746
7747
7748/* Inner function to convert a TREE_LIST to argv string to parse the optimize
7749 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7750 false for #pragma GCC optimize. */
7751
7752bool
7753parse_optimize_options (tree args, bool attr_p)
7754{
7755 bool ret = true;
7756 unsigned opt_argc;
7757 unsigned i;
2becf397 7758 int saved_flag_strict_aliasing;
46f8e3b0 7759 const char **opt_argv;
615ef0bb 7760 struct cl_decoded_option *decoded_options;
7761 unsigned int decoded_options_count;
46f8e3b0 7762 tree ap;
7763
7764 /* Build up argv vector. Just in case the string is stored away, use garbage
7765 collected strings. */
7766 VEC_truncate (const_char_p, optimize_args, 0);
7767 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7768
7769 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7770 {
7771 tree value = TREE_VALUE (ap);
7772
7773 if (TREE_CODE (value) == INTEGER_CST)
7774 {
7775 char buffer[20];
7776 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7777 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7778 }
7779
7780 else if (TREE_CODE (value) == STRING_CST)
7781 {
7782 /* Split string into multiple substrings. */
7783 size_t len = TREE_STRING_LENGTH (value);
7784 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7785 char *end = p + len;
7786 char *comma;
7787 char *next_p = p;
7788
7789 while (next_p != NULL)
7790 {
7791 size_t len2;
7792 char *q, *r;
7793
7794 p = next_p;
7795 comma = strchr (p, ',');
7796 if (comma)
7797 {
7798 len2 = comma - p;
7799 *comma = '\0';
7800 next_p = comma+1;
7801 }
7802 else
7803 {
7804 len2 = end - p;
7805 next_p = NULL;
7806 }
7807
ba72912a 7808 r = q = (char *) ggc_alloc_atomic (len2 + 3);
46f8e3b0 7809
7810 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7811 options. */
7812 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7813 {
7814 ret = false;
7815 if (attr_p)
7816 warning (OPT_Wattributes,
ebd7c4c1 7817 "bad option %s to optimize attribute", p);
46f8e3b0 7818 else
7819 warning (OPT_Wpragmas,
e44b0a1f 7820 "bad option %s to pragma attribute", p);
46f8e3b0 7821 continue;
7822 }
7823
7824 if (*p != '-')
7825 {
7826 *r++ = '-';
7827
7828 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7829 itself is -Os, and any other switch begins with a -f. */
7830 if ((*p >= '0' && *p <= '9')
7831 || (p[0] == 's' && p[1] == '\0'))
7832 *r++ = 'O';
7833 else if (*p != 'O')
7834 *r++ = 'f';
7835 }
7836
7837 memcpy (r, p, len2);
7838 r[len2] = '\0';
7839 VEC_safe_push (const_char_p, gc, optimize_args, q);
7840 }
7841
7842 }
7843 }
7844
7845 opt_argc = VEC_length (const_char_p, optimize_args);
7846 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7847
7848 for (i = 1; i < opt_argc; i++)
7849 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7850
2becf397 7851 saved_flag_strict_aliasing = flag_strict_aliasing;
7852
46f8e3b0 7853 /* Now parse the options. */
f3f006ad 7854 decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv,
7855 &decoded_options,
7856 &decoded_options_count);
7857 decode_options (&global_options, &global_options_set,
3c6c0e40 7858 decoded_options, decoded_options_count,
7859 input_location, global_dc);
46f8e3b0 7860
4bec06b3 7861 targetm.override_options_after_change();
7862
2becf397 7863 /* Don't allow changing -fstrict-aliasing. */
7864 flag_strict_aliasing = saved_flag_strict_aliasing;
7865
46f8e3b0 7866 VEC_truncate (const_char_p, optimize_args, 0);
7867 return ret;
7868}
7869
7870/* For handling "optimize" attribute. arguments as in
7871 struct attribute_spec.handler. */
7872
7873static tree
7874handle_optimize_attribute (tree *node, tree name, tree args,
7875 int ARG_UNUSED (flags), bool *no_add_attrs)
7876{
7877 /* Ensure we have a function type. */
7878 if (TREE_CODE (*node) != FUNCTION_DECL)
7879 {
7880 warning (OPT_Wattributes, "%qE attribute ignored", name);
7881 *no_add_attrs = true;
7882 }
7883 else
7884 {
7885 struct cl_optimization cur_opts;
7886 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7887
7888 /* Save current options. */
2c5d2e39 7889 cl_optimization_save (&cur_opts, &global_options);
46f8e3b0 7890
7891 /* If we previously had some optimization options, use them as the
7892 default. */
7893 if (old_opts)
2c5d2e39 7894 cl_optimization_restore (&global_options,
7895 TREE_OPTIMIZATION (old_opts));
46f8e3b0 7896
7897 /* Parse options, and update the vector. */
7898 parse_optimize_options (args, true);
7899 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7900 = build_optimization_node ();
7901
7902 /* Restore current options. */
2c5d2e39 7903 cl_optimization_restore (&global_options, &cur_opts);
46f8e3b0 7904 }
7905
7906 return NULL_TREE;
7907}
48b14f50 7908
7909/* Handle a "no_split_stack" attribute. */
7910
7911static tree
7912handle_no_split_stack_attribute (tree *node, tree name,
7913 tree ARG_UNUSED (args),
7914 int ARG_UNUSED (flags),
7915 bool *no_add_attrs)
7916{
7917 tree decl = *node;
7918
7919 if (TREE_CODE (decl) != FUNCTION_DECL)
7920 {
7921 error_at (DECL_SOURCE_LOCATION (decl),
7922 "%qE attribute applies only to functions", name);
7923 *no_add_attrs = true;
7924 }
7925 else if (DECL_INITIAL (decl))
7926 {
7927 error_at (DECL_SOURCE_LOCATION (decl),
7928 "can%'t set %qE attribute after definition", name);
7929 *no_add_attrs = true;
7930 }
7931
7932 return NULL_TREE;
7933}
dbf6c367 7934\f
d01f58f9 7935/* Check for valid arguments being passed to a function.
7936 ATTRS is a list of attributes. There are NARGS arguments in the array
7937 ARGARRAY. TYPELIST is the list of argument types for the function.
7938 */
dbf6c367 7939void
d01f58f9 7940check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
dbf6c367 7941{
7942 /* Check for null being passed in a pointer argument that must be
7943 non-null. We also need to do this if format checking is enabled. */
7944
7945 if (warn_nonnull)
d01f58f9 7946 check_function_nonnull (attrs, nargs, argarray);
dbf6c367 7947
7948 /* Check for errors in format strings. */
7949
95c90e04 7950 if (warn_format || warn_missing_format_attribute)
d01f58f9 7951 check_function_format (attrs, nargs, argarray);
95c90e04 7952
7953 if (warn_format)
d01f58f9 7954 check_function_sentinel (attrs, nargs, argarray, typelist);
dbf6c367 7955}
7956
7957/* Generic argument checking recursion routine. PARAM is the argument to
7958 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7959 once the argument is resolved. CTX is context for the callback. */
7960void
1cae46be 7961check_function_arguments_recurse (void (*callback)
7962 (void *, tree, unsigned HOST_WIDE_INT),
7963 void *ctx, tree param,
7964 unsigned HOST_WIDE_INT param_num)
dbf6c367 7965{
72dd6141 7966 if (CONVERT_EXPR_P (param)
c44afe23 7967 && (TYPE_PRECISION (TREE_TYPE (param))
7968 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
dbf6c367 7969 {
7970 /* Strip coercion. */
7971 check_function_arguments_recurse (callback, ctx,
4ee9c684 7972 TREE_OPERAND (param, 0), param_num);
dbf6c367 7973 return;
7974 }
7975
7976 if (TREE_CODE (param) == CALL_EXPR)
7977 {
c2f47e15 7978 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
dbf6c367 7979 tree attrs;
7980 bool found_format_arg = false;
7981
7982 /* See if this is a call to a known internationalization function
7983 that modifies a format arg. Such a function may have multiple
7984 format_arg attributes (for example, ngettext). */
7985
7986 for (attrs = TYPE_ATTRIBUTES (type);
7987 attrs;
7988 attrs = TREE_CHAIN (attrs))
7989 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7990 {
c2f47e15 7991 tree inner_arg;
dbf6c367 7992 tree format_num_expr;
7993 int format_num;
7994 int i;
c2f47e15 7995 call_expr_arg_iterator iter;
dbf6c367 7996
7997 /* Extract the argument number, which was previously checked
7998 to be valid. */
7999 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
dbf6c367 8000
231bd014 8001 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
8002 && !TREE_INT_CST_HIGH (format_num_expr));
dbf6c367 8003
8004 format_num = TREE_INT_CST_LOW (format_num_expr);
8005
c2f47e15 8006 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
8007 inner_arg != 0;
8008 inner_arg = next_call_expr_arg (&iter), i++)
dbf6c367 8009 if (i == format_num)
8010 {
8011 check_function_arguments_recurse (callback, ctx,
c2f47e15 8012 inner_arg, param_num);
dbf6c367 8013 found_format_arg = true;
8014 break;
8015 }
8016 }
8017
8018 /* If we found a format_arg attribute and did a recursive check,
8019 we are done with checking this argument. Otherwise, we continue
8020 and this will be considered a non-literal. */
8021 if (found_format_arg)
8022 return;
8023 }
8024
8025 if (TREE_CODE (param) == COND_EXPR)
8026 {
8027 /* Check both halves of the conditional expression. */
8028 check_function_arguments_recurse (callback, ctx,
4ee9c684 8029 TREE_OPERAND (param, 1), param_num);
dbf6c367 8030 check_function_arguments_recurse (callback, ctx,
4ee9c684 8031 TREE_OPERAND (param, 2), param_num);
dbf6c367 8032 return;
8033 }
8034
8035 (*callback) (ctx, param, param_num);
8036}
1f3233d1 8037
60cce472 8038/* Checks for a builtin function FNDECL that the number of arguments
8039 NARGS against the required number REQUIRED and issues an error if
8040 there is a mismatch. Returns true if the number of arguments is
8041 correct, otherwise false. */
d43cee80 8042
8043static bool
60cce472 8044builtin_function_validate_nargs (tree fndecl, int nargs, int required)
d43cee80 8045{
8046 if (nargs < required)
8047 {
60cce472 8048 error_at (input_location,
8049 "not enough arguments to function %qE", fndecl);
d43cee80 8050 return false;
8051 }
8052 else if (nargs > required)
8053 {
60cce472 8054 error_at (input_location,
8055 "too many arguments to function %qE", fndecl);
d43cee80 8056 return false;
8057 }
8058 return true;
8059}
8060
8061/* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8062 Returns false if there was an error, otherwise true. */
8063
8064bool
8065check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8066{
8067 if (!DECL_BUILT_IN (fndecl)
8068 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8069 return true;
8070
8071 switch (DECL_FUNCTION_CODE (fndecl))
8072 {
8073 case BUILT_IN_CONSTANT_P:
60cce472 8074 return builtin_function_validate_nargs (fndecl, nargs, 1);
d43cee80 8075
8076 case BUILT_IN_ISFINITE:
8077 case BUILT_IN_ISINF:
c319d56a 8078 case BUILT_IN_ISINF_SIGN:
d43cee80 8079 case BUILT_IN_ISNAN:
8080 case BUILT_IN_ISNORMAL:
60cce472 8081 if (builtin_function_validate_nargs (fndecl, nargs, 1))
d43cee80 8082 {
8083 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8084 {
8085 error ("non-floating-point argument in call to "
8086 "function %qE", fndecl);
8087 return false;
8088 }
8089 return true;
8090 }
8091 return false;
8092
8093 case BUILT_IN_ISGREATER:
8094 case BUILT_IN_ISGREATEREQUAL:
8095 case BUILT_IN_ISLESS:
8096 case BUILT_IN_ISLESSEQUAL:
8097 case BUILT_IN_ISLESSGREATER:
8098 case BUILT_IN_ISUNORDERED:
60cce472 8099 if (builtin_function_validate_nargs (fndecl, nargs, 2))
d43cee80 8100 {
8101 enum tree_code code0, code1;
8102 code0 = TREE_CODE (TREE_TYPE (args[0]));
8103 code1 = TREE_CODE (TREE_TYPE (args[1]));
8104 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8105 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8106 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8107 {
8108 error ("non-floating-point arguments in call to "
8109 "function %qE", fndecl);
8110 return false;
8111 }
8112 return true;
8113 }
8114 return false;
8115
19fbe3a4 8116 case BUILT_IN_FPCLASSIFY:
60cce472 8117 if (builtin_function_validate_nargs (fndecl, nargs, 6))
19fbe3a4 8118 {
8119 unsigned i;
48e1416a 8120
19fbe3a4 8121 for (i=0; i<5; i++)
8122 if (TREE_CODE (args[i]) != INTEGER_CST)
8123 {
8124 error ("non-const integer argument %u in call to function %qE",
8125 i+1, fndecl);
8126 return false;
8127 }
8128
8129 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8130 {
8131 error ("non-floating-point argument in call to function %qE",
8132 fndecl);
8133 return false;
8134 }
8135 return true;
8136 }
8137 return false;
8138
d43cee80 8139 default:
8140 return true;
8141 }
8142}
8143
860251be 8144/* Function to help qsort sort FIELD_DECLs by name order. */
8145
8146int
8147field_decl_cmp (const void *x_p, const void *y_p)
8148{
4fd61bc6 8149 const tree *const x = (const tree *const) x_p;
8150 const tree *const y = (const tree *const) y_p;
8151
860251be 8152 if (DECL_NAME (*x) == DECL_NAME (*y))
8153 /* A nontype is "greater" than a type. */
8154 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8155 if (DECL_NAME (*x) == NULL_TREE)
8156 return -1;
8157 if (DECL_NAME (*y) == NULL_TREE)
8158 return 1;
8159 if (DECL_NAME (*x) < DECL_NAME (*y))
8160 return -1;
8161 return 1;
8162}
8163
8164static struct {
8165 gt_pointer_operator new_value;
8166 void *cookie;
8167} resort_data;
8168
8169/* This routine compares two fields like field_decl_cmp but using the
8170pointer operator in resort_data. */
8171
8172static int
8173resort_field_decl_cmp (const void *x_p, const void *y_p)
8174{
4fd61bc6 8175 const tree *const x = (const tree *const) x_p;
8176 const tree *const y = (const tree *const) y_p;
860251be 8177
8178 if (DECL_NAME (*x) == DECL_NAME (*y))
8179 /* A nontype is "greater" than a type. */
8180 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8181 if (DECL_NAME (*x) == NULL_TREE)
8182 return -1;
8183 if (DECL_NAME (*y) == NULL_TREE)
8184 return 1;
8185 {
8186 tree d1 = DECL_NAME (*x);
8187 tree d2 = DECL_NAME (*y);
8188 resort_data.new_value (&d1, resort_data.cookie);
8189 resort_data.new_value (&d2, resort_data.cookie);
8190 if (d1 < d2)
8191 return -1;
8192 }
8193 return 1;
8194}
8195
8196/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8197
8198void
8199resort_sorted_fields (void *obj,
9a03a746 8200 void * ARG_UNUSED (orig_obj),
4ee9c684 8201 gt_pointer_operator new_value,
8202 void *cookie)
860251be 8203{
9a03a746 8204 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
860251be 8205 resort_data.new_value = new_value;
8206 resort_data.cookie = cookie;
8207 qsort (&sf->elts[0], sf->len, sizeof (tree),
4ee9c684 8208 resort_field_decl_cmp);
860251be 8209}
8210
209c9752 8211/* Subroutine of c_parse_error.
8212 Return the result of concatenating LHS and RHS. RHS is really
8213 a string literal, its first character is indicated by RHS_START and
cfee01e3 8214 RHS_SIZE is its length (including the terminating NUL character).
209c9752 8215
8216 The caller is responsible for deleting the returned pointer. */
8217
8218static char *
8219catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8220{
8221 const int lhs_size = strlen (lhs);
8222 char *result = XNEWVEC (char, lhs_size + rhs_size);
8223 strncpy (result, lhs, lhs_size);
8224 strncpy (result + lhs_size, rhs_start, rhs_size);
8225 return result;
8226}
8227
380c6697 8228/* Issue the error given by GMSGID, indicating that it occurred before
92b128ed 8229 TOKEN, which had the associated VALUE. */
8230
8231void
48e1416a 8232c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
ba99525e 8233 tree value, unsigned char token_flags)
92b128ed 8234{
209c9752 8235#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8236
8237 char *message = NULL;
92b128ed 8238
ba99525e 8239 if (token_type == CPP_EOF)
380c6697 8240 message = catenate_messages (gmsgid, " at end of input");
48e1416a 8241 else if (token_type == CPP_CHAR
8242 || token_type == CPP_WCHAR
ba99525e 8243 || token_type == CPP_CHAR16
8244 || token_type == CPP_CHAR32)
92b128ed 8245 {
8246 unsigned int val = TREE_INT_CST_LOW (value);
924bbf02 8247 const char *prefix;
8248
ba99525e 8249 switch (token_type)
924bbf02 8250 {
8251 default:
8252 prefix = "";
8253 break;
8254 case CPP_WCHAR:
8255 prefix = "L";
8256 break;
8257 case CPP_CHAR16:
8258 prefix = "u";
8259 break;
8260 case CPP_CHAR32:
8261 prefix = "U";
8262 break;
8263 }
8264
92b128ed 8265 if (val <= UCHAR_MAX && ISGRAPH (val))
a0c938f0 8266 message = catenate_messages (gmsgid, " before %s'%c'");
92b128ed 8267 else
a0c938f0 8268 message = catenate_messages (gmsgid, " before %s'\\x%x'");
209c9752 8269
924bbf02 8270 error (message, prefix, val);
209c9752 8271 free (message);
8272 message = NULL;
92b128ed 8273 }
48e1416a 8274 else if (token_type == CPP_STRING
8275 || token_type == CPP_WSTRING
ba99525e 8276 || token_type == CPP_STRING16
538ba11a 8277 || token_type == CPP_STRING32
8278 || token_type == CPP_UTF8STRING)
380c6697 8279 message = catenate_messages (gmsgid, " before string constant");
ba99525e 8280 else if (token_type == CPP_NUMBER)
380c6697 8281 message = catenate_messages (gmsgid, " before numeric constant");
ba99525e 8282 else if (token_type == CPP_NAME)
209c9752 8283 {
380c6697 8284 message = catenate_messages (gmsgid, " before %qE");
782858b8 8285 error (message, value);
209c9752 8286 free (message);
8287 message = NULL;
8288 }
ba99525e 8289 else if (token_type == CPP_PRAGMA)
b75b98aa 8290 message = catenate_messages (gmsgid, " before %<#pragma%>");
ba99525e 8291 else if (token_type == CPP_PRAGMA_EOL)
b75b98aa 8292 message = catenate_messages (gmsgid, " before end of line");
ba99525e 8293 else if (token_type < N_TTYPES)
209c9752 8294 {
380c6697 8295 message = catenate_messages (gmsgid, " before %qs token");
ba99525e 8296 error (message, cpp_type2name (token_type, token_flags));
209c9752 8297 free (message);
8298 message = NULL;
8299 }
92b128ed 8300 else
380c6697 8301 error (gmsgid);
209c9752 8302
8303 if (message)
8304 {
8305 error (message);
8306 free (message);
8307 }
a0c938f0 8308#undef catenate_messages
92b128ed 8309}
8310
3a79f5da 8311/* Mapping for cpp message reasons to the options that enable them. */
8312
8313struct reason_option_codes_t
8314{
8315 const int reason; /* cpplib message reason. */
8316 const int option_code; /* gcc option that controls this message. */
8317};
8318
8319static const struct reason_option_codes_t option_codes[] = {
8320 {CPP_W_DEPRECATED, OPT_Wdeprecated},
67089c6b 8321 {CPP_W_COMMENTS, OPT_Wcomment},
3a79f5da 8322 {CPP_W_TRIGRAPHS, OPT_Wtrigraphs},
8323 {CPP_W_MULTICHAR, OPT_Wmultichar},
8324 {CPP_W_TRADITIONAL, OPT_Wtraditional},
8325 {CPP_W_LONG_LONG, OPT_Wlong_long},
8326 {CPP_W_ENDIF_LABELS, OPT_Wendif_labels},
8327 {CPP_W_VARIADIC_MACROS, OPT_Wvariadic_macros},
8328 {CPP_W_BUILTIN_MACRO_REDEFINED, OPT_Wbuiltin_macro_redefined},
8329 {CPP_W_UNDEF, OPT_Wundef},
8330 {CPP_W_UNUSED_MACROS, OPT_Wunused_macros},
8331 {CPP_W_CXX_OPERATOR_NAMES, OPT_Wc___compat},
8332 {CPP_W_NORMALIZE, OPT_Wnormalized_},
8333 {CPP_W_INVALID_PCH, OPT_Winvalid_pch},
8334 {CPP_W_WARNING_DIRECTIVE, OPT_Wcpp},
8335 {CPP_W_NONE, 0}
8336};
8337
8338/* Return the gcc option code associated with the reason for a cpp
8339 message, or 0 if none. */
8340
8341static int
8342c_option_controlling_cpp_error (int reason)
8343{
8344 const struct reason_option_codes_t *entry;
8345
8346 for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8347 {
8348 if (entry->reason == reason)
8349 return entry->option_code;
8350 }
8351 return 0;
8352}
8353
7f5f3953 8354/* Callback from cpp_error for PFILE to print diagnostics from the
3a79f5da 8355 preprocessor. The diagnostic is of type LEVEL, with REASON set
8356 to the reason code if LEVEL is represents a warning, at location
7f5f3953 8357 LOCATION unless this is after lexing and the compiler's location
8358 should be used instead, with column number possibly overridden by
8359 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8360 the arguments. Returns true if a diagnostic was emitted, false
8361 otherwise. */
8362
8363bool
3a79f5da 8364c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
7f5f3953 8365 location_t location, unsigned int column_override,
8366 const char *msg, va_list *ap)
8367{
8368 diagnostic_info diagnostic;
8369 diagnostic_t dlevel;
5ae82d58 8370 bool save_warn_system_headers = global_dc->dc_warn_system_headers;
7f5f3953 8371 bool ret;
8372
8373 switch (level)
8374 {
8375 case CPP_DL_WARNING_SYSHDR:
8376 if (flag_no_output)
8377 return false;
5ae82d58 8378 global_dc->dc_warn_system_headers = 1;
7f5f3953 8379 /* Fall through. */
8380 case CPP_DL_WARNING:
8381 if (flag_no_output)
8382 return false;
8383 dlevel = DK_WARNING;
8384 break;
8385 case CPP_DL_PEDWARN:
8386 if (flag_no_output && !flag_pedantic_errors)
8387 return false;
8388 dlevel = DK_PEDWARN;
8389 break;
8390 case CPP_DL_ERROR:
8391 dlevel = DK_ERROR;
8392 break;
8393 case CPP_DL_ICE:
8394 dlevel = DK_ICE;
8395 break;
8396 case CPP_DL_NOTE:
8397 dlevel = DK_NOTE;
8398 break;
ff903809 8399 case CPP_DL_FATAL:
8400 dlevel = DK_FATAL;
8401 break;
7f5f3953 8402 default:
8403 gcc_unreachable ();
8404 }
8405 if (done_lexing)
8406 location = input_location;
8407 diagnostic_set_info_translated (&diagnostic, msg, ap,
8408 location, dlevel);
8409 if (column_override)
8410 diagnostic_override_column (&diagnostic, column_override);
3a79f5da 8411 diagnostic_override_option_index (&diagnostic,
8412 c_option_controlling_cpp_error (reason));
7f5f3953 8413 ret = report_diagnostic (&diagnostic);
8414 if (level == CPP_DL_WARNING_SYSHDR)
5ae82d58 8415 global_dc->dc_warn_system_headers = save_warn_system_headers;
7f5f3953 8416 return ret;
8417}
8418
624d37a6 8419/* Convert a character from the host to the target execution character
8420 set. cpplib handles this, mostly. */
8421
8422HOST_WIDE_INT
8423c_common_to_target_charset (HOST_WIDE_INT c)
8424{
8425 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8426 zero-extended under -fno-signed-char. cpplib insists that characters
8427 and character constants are always unsigned. Hence we must convert
8428 back and forth. */
8429 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8430
8431 uc = cpp_host_to_exec_charset (parse_in, uc);
8432
8433 if (flag_signed_char)
8434 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8435 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8436 else
8437 return uc;
8438}
8439
af28855b 8440/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
d897f7c2 8441 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8442 NULL, at the bottom; much like the traditional rendering of offsetof as a
8443 macro. Returns the folded and properly cast result. */
af28855b 8444
8445static tree
d897f7c2 8446fold_offsetof_1 (tree expr, tree stop_ref)
af28855b 8447{
8448 enum tree_code code = PLUS_EXPR;
8449 tree base, off, t;
8450
d897f7c2 8451 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8452 return size_zero_node;
8453
af28855b 8454 switch (TREE_CODE (expr))
8455 {
8456 case ERROR_MARK:
8457 return expr;
8458
6b11d2e3 8459 case VAR_DECL:
8460 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8461 return error_mark_node;
8462
d897f7c2 8463 case CALL_EXPR:
cf1a89a3 8464 case TARGET_EXPR:
d897f7c2 8465 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8466 return error_mark_node;
8467
d897f7c2 8468 case NOP_EXPR:
8469 case INDIRECT_REF:
64ed018c 8470 if (!integer_zerop (TREE_OPERAND (expr, 0)))
8471 {
8472 error ("cannot apply %<offsetof%> to a non constant address");
8473 return error_mark_node;
8474 }
8475 return size_zero_node;
d897f7c2 8476
af28855b 8477 case COMPONENT_REF:
d897f7c2 8478 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
af28855b 8479 if (base == error_mark_node)
8480 return base;
8481
8482 t = TREE_OPERAND (expr, 1);
8483 if (DECL_C_BIT_FIELD (t))
8484 {
8485 error ("attempt to take address of bit-field structure "
782858b8 8486 "member %qD", t);
af28855b 8487 return error_mark_node;
8488 }
389dd41b 8489 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8490 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8491 1)
8492 / BITS_PER_UNIT));
af28855b 8493 break;
8494
8495 case ARRAY_REF:
d897f7c2 8496 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
af28855b 8497 if (base == error_mark_node)
8498 return base;
8499
8500 t = TREE_OPERAND (expr, 1);
8501 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8502 {
8503 code = MINUS_EXPR;
389dd41b 8504 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
af28855b 8505 }
8506 t = convert (sizetype, t);
8507 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
64ed018c 8508
8509 /* Check if the offset goes beyond the upper bound of the array. */
e0559d69 8510 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8511 {
8512 tree upbound = array_ref_up_bound (expr);
8513 if (upbound != NULL_TREE
8514 && TREE_CODE (upbound) == INTEGER_CST
8515 && !tree_int_cst_equal (upbound,
8516 TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8517 {
8518 upbound = size_binop (PLUS_EXPR, upbound,
8519 build_int_cst (TREE_TYPE (upbound), 1));
8520 if (tree_int_cst_lt (upbound, t))
8521 {
8522 tree v;
8523
8524 for (v = TREE_OPERAND (expr, 0);
8525 TREE_CODE (v) == COMPONENT_REF;
8526 v = TREE_OPERAND (v, 0))
8527 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8528 == RECORD_TYPE)
8529 {
1767a056 8530 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8531 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
e0559d69 8532 if (TREE_CODE (fld_chain) == FIELD_DECL)
8533 break;
8534
8535 if (fld_chain)
8536 break;
8537 }
8538 /* Don't warn if the array might be considered a poor
8539 man's flexible array member with a very permissive
8540 definition thereof. */
8541 if (TREE_CODE (v) == ARRAY_REF
8542 || TREE_CODE (v) == COMPONENT_REF)
8543 warning (OPT_Warray_bounds,
8544 "index %E denotes an offset "
8545 "greater than size of %qT",
8546 t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8547 }
8548 }
8549 }
af28855b 8550 break;
8551
ede90cc2 8552 case COMPOUND_EXPR:
8553 /* Handle static members of volatile structs. */
8554 t = TREE_OPERAND (expr, 1);
8555 gcc_assert (TREE_CODE (t) == VAR_DECL);
8556 return fold_offsetof_1 (t, stop_ref);
8557
af28855b 8558 default:
231bd014 8559 gcc_unreachable ();
af28855b 8560 }
8561
8562 return size_binop (code, base, off);
8563}
8564
8565tree
d897f7c2 8566fold_offsetof (tree expr, tree stop_ref)
af28855b 8567{
8568 /* Convert back from the internal sizetype to size_t. */
d897f7c2 8569 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
af28855b 8570}
8571
b9bdfa0b 8572/* Warn for A ?: C expressions (with B omitted) where A is a boolean
8573 expression, because B will always be true. */
8574
8575void
8576warn_for_omitted_condop (location_t location, tree cond)
8577{
8578 if (truth_value_p (TREE_CODE (cond)))
8579 warning_at (location, OPT_Wparentheses,
8580 "the omitted middle operand in ?: will always be %<true%>, "
8581 "suggest explicit middle operand");
8582}
8583
a1f90215 8584/* Give an error for storing into ARG, which is 'const'. USE indicates
8585 how ARG was being used. */
8586
8587void
8588readonly_error (tree arg, enum lvalue_use use)
8589{
8590 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
8591 || use == lv_asm);
8592 /* Using this macro rather than (for example) arrays of messages
8593 ensures that all the format strings are checked at compile
8594 time. */
8595#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
8596 : (use == lv_increment ? (I) \
8597 : (use == lv_decrement ? (D) : (AS))))
8598 if (TREE_CODE (arg) == COMPONENT_REF)
8599 {
8600 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
8601 error (READONLY_MSG (G_("assignment of member "
8602 "%qD in read-only object"),
8603 G_("increment of member "
8604 "%qD in read-only object"),
8605 G_("decrement of member "
8606 "%qD in read-only object"),
8607 G_("member %qD in read-only object "
8608 "used as %<asm%> output")),
8609 TREE_OPERAND (arg, 1));
8610 else
8611 error (READONLY_MSG (G_("assignment of read-only member %qD"),
8612 G_("increment of read-only member %qD"),
8613 G_("decrement of read-only member %qD"),
8614 G_("read-only member %qD used as %<asm%> output")),
8615 TREE_OPERAND (arg, 1));
8616 }
8617 else if (TREE_CODE (arg) == VAR_DECL)
8618 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
8619 G_("increment of read-only variable %qD"),
8620 G_("decrement of read-only variable %qD"),
8621 G_("read-only variable %qD used as %<asm%> output")),
8622 arg);
8623 else if (TREE_CODE (arg) == PARM_DECL)
8624 error (READONLY_MSG (G_("assignment of read-only parameter %qD"),
8625 G_("increment of read-only parameter %qD"),
8626 G_("decrement of read-only parameter %qD"),
8627 G_("read-only parameter %qD use as %<asm%> output")),
8628 arg);
8629 else if (TREE_CODE (arg) == RESULT_DECL)
8630 {
8631 gcc_assert (c_dialect_cxx ());
8632 error (READONLY_MSG (G_("assignment of "
8633 "read-only named return value %qD"),
8634 G_("increment of "
8635 "read-only named return value %qD"),
8636 G_("decrement of "
8637 "read-only named return value %qD"),
8638 G_("read-only named return value %qD "
8639 "used as %<asm%>output")),
8640 arg);
8641 }
8642 else if (TREE_CODE (arg) == FUNCTION_DECL)
8643 error (READONLY_MSG (G_("assignment of function %qD"),
8644 G_("increment of function %qD"),
8645 G_("decrement of function %qD"),
8646 G_("function %qD used as %<asm%> output")),
8647 arg);
8648 else
8649 error (READONLY_MSG (G_("assignment of read-only location %qE"),
8650 G_("increment of read-only location %qE"),
8651 G_("decrement of read-only location %qE"),
8652 G_("read-only location %qE used as %<asm%> output")),
8653 arg);
8654}
8655
e35976b1 8656/* Print an error message for an invalid lvalue. USE says
fdd84b77 8657 how the lvalue is being used and so selects the error message. LOC
8658 is the location for the error. */
ab6bb714 8659
e35976b1 8660void
fdd84b77 8661lvalue_error (location_t loc, enum lvalue_use use)
ab6bb714 8662{
e35976b1 8663 switch (use)
ab6bb714 8664 {
e35976b1 8665 case lv_assign:
fdd84b77 8666 error_at (loc, "lvalue required as left operand of assignment");
e35976b1 8667 break;
8668 case lv_increment:
fdd84b77 8669 error_at (loc, "lvalue required as increment operand");
e35976b1 8670 break;
8671 case lv_decrement:
fdd84b77 8672 error_at (loc, "lvalue required as decrement operand");
e35976b1 8673 break;
8674 case lv_addressof:
fdd84b77 8675 error_at (loc, "lvalue required as unary %<&%> operand");
e35976b1 8676 break;
8677 case lv_asm:
fdd84b77 8678 error_at (loc, "lvalue required in asm statement");
e35976b1 8679 break;
8680 default:
8681 gcc_unreachable ();
ab6bb714 8682 }
ab6bb714 8683}
b1bbc8e5 8684
8685/* Print an error message for an invalid indirection of type TYPE.
8686 ERRSTRING is the name of the operator for the indirection. */
8687
8688void
8689invalid_indirection_error (location_t loc, tree type, ref_operator errstring)
8690{
8691 switch (errstring)
8692 {
8693 case RO_NULL:
8694 gcc_assert (c_dialect_cxx ());
8695 error_at (loc, "invalid type argument (have %qT)", type);
8696 break;
8697 case RO_ARRAY_INDEXING:
8698 error_at (loc,
8699 "invalid type argument of array indexing (have %qT)",
8700 type);
8701 break;
8702 case RO_UNARY_STAR:
8703 error_at (loc,
8704 "invalid type argument of unary %<*%> (have %qT)",
8705 type);
8706 break;
8707 case RO_ARROW:
8708 error_at (loc,
8709 "invalid type argument of %<->%> (have %qT)",
8710 type);
8711 break;
8712 case RO_IMPLICIT_CONVERSION:
8713 error_at (loc,
8714 "invalid type argument of implicit conversion (have %qT)",
8715 type);
8716 break;
8717 default:
8718 gcc_unreachable ();
8719 }
8720}
c271bdb2 8721\f
8722/* *PTYPE is an incomplete array. Complete it with a domain based on
8723 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8724 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8725 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8726
8727int
8728complete_array_type (tree *ptype, tree initial_value, bool do_default)
8729{
8730 tree maxindex, type, main_type, elt, unqual_elt;
8731 int failure = 0, quals;
6753bca0 8732 hashval_t hashcode = 0;
c271bdb2 8733
8734 maxindex = size_zero_node;
8735 if (initial_value)
8736 {
8737 if (TREE_CODE (initial_value) == STRING_CST)
8738 {
8739 int eltsize
8740 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8741 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8742 }
8743 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8744 {
c75b4594 8745 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
c271bdb2 8746
c75b4594 8747 if (VEC_empty (constructor_elt, v))
c271bdb2 8748 {
8749 if (pedantic)
8750 failure = 3;
8751 maxindex = integer_minus_one_node;
8752 }
8753 else
8754 {
8755 tree curindex;
c75b4594 8756 unsigned HOST_WIDE_INT cnt;
8757 constructor_elt *ce;
cee43f7e 8758 bool fold_p = false;
c271bdb2 8759
c75b4594 8760 if (VEC_index (constructor_elt, v, 0)->index)
389dd41b 8761 maxindex = fold_convert_loc (input_location, sizetype,
8762 VEC_index (constructor_elt,
8763 v, 0)->index);
c271bdb2 8764 curindex = maxindex;
8765
c75b4594 8766 for (cnt = 1;
8767 VEC_iterate (constructor_elt, v, cnt, ce);
8768 cnt++)
c271bdb2 8769 {
cee43f7e 8770 bool curfold_p = false;
c75b4594 8771 if (ce->index)
cee43f7e 8772 curindex = ce->index, curfold_p = true;
c271bdb2 8773 else
cee43f7e 8774 {
8775 if (fold_p)
8776 curindex = fold_convert (sizetype, curindex);
389dd41b 8777 curindex = size_binop (PLUS_EXPR, curindex,
8778 size_one_node);
cee43f7e 8779 }
c271bdb2 8780 if (tree_int_cst_lt (maxindex, curindex))
cee43f7e 8781 maxindex = curindex, fold_p = curfold_p;
c271bdb2 8782 }
cee43f7e 8783 if (fold_p)
8784 maxindex = fold_convert (sizetype, maxindex);
c271bdb2 8785 }
8786 }
8787 else
8788 {
8789 /* Make an error message unless that happened already. */
8790 if (initial_value != error_mark_node)
8791 failure = 1;
8792 }
8793 }
8794 else
8795 {
8796 failure = 2;
8797 if (!do_default)
8798 return failure;
8799 }
8800
8801 type = *ptype;
8802 elt = TREE_TYPE (type);
8803 quals = TYPE_QUALS (strip_array_types (elt));
8804 if (quals == 0)
8805 unqual_elt = elt;
8806 else
6d5d708e 8807 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
c271bdb2 8808
8809 /* Using build_distinct_type_copy and modifying things afterward instead
8810 of using build_array_type to create a new type preserves all of the
8811 TYPE_LANG_FLAG_? bits that the front end may have set. */
8812 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8813 TREE_TYPE (main_type) = unqual_elt;
8814 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8815 layout_type (main_type);
8816
6753bca0 8817 /* Make sure we have the canonical MAIN_TYPE. */
8818 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
48e1416a 8819 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
6753bca0 8820 hashcode);
8821 main_type = type_hash_canon (hashcode, main_type);
8822
796735dc 8823 /* Fix the canonical type. */
8824 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8825 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8826 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8827 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8828 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8829 != TYPE_DOMAIN (main_type)))
48e1416a 8830 TYPE_CANONICAL (main_type)
796735dc 8831 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8832 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8833 else
8834 TYPE_CANONICAL (main_type) = main_type;
8835
c271bdb2 8836 if (quals == 0)
8837 type = main_type;
8838 else
8839 type = c_build_qualified_type (main_type, quals);
8840
4f5b8f2a 8841 if (COMPLETE_TYPE_P (type)
8842 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8843 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8844 {
8845 error ("size of array is too large");
8846 /* If we proceed with the array type as it is, we'll eventually
8847 crash in tree_low_cst(). */
8848 type = error_mark_node;
8849 }
8850
c271bdb2 8851 *ptype = type;
8852 return failure;
8853}
ab6bb714 8854
93426222 8855/* Like c_mark_addressable but don't check register qualifier. */
8856void
8857c_common_mark_addressable_vec (tree t)
8858{
8859 while (handled_component_p (t))
8860 t = TREE_OPERAND (t, 0);
8861 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8862 return;
8863 TREE_ADDRESSABLE (t) = 1;
8864}
8865
8866
b6a5fc45 8867\f
8868/* Used to help initialize the builtin-types.def table. When a type of
8869 the correct size doesn't exist, use error_mark_node instead of NULL.
8870 The later results in segfaults even when a decl using the type doesn't
8871 get invoked. */
8872
8873tree
8874builtin_type_for_size (int size, bool unsignedp)
8875{
8876 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8877 return type ? type : error_mark_node;
8878}
8879
8880/* A helper function for resolve_overloaded_builtin in resolving the
8881 overloaded __sync_ builtins. Returns a positive power of 2 if the
8882 first operand of PARAMS is a pointer to a supported data type.
8883 Returns 0 if an error is encountered. */
8884
8885static int
b9c74b4d 8886sync_resolve_size (tree function, VEC(tree,gc) *params)
b6a5fc45 8887{
8888 tree type;
8889 int size;
8890
b9c74b4d 8891 if (VEC_empty (tree, params))
b6a5fc45 8892 {
8893 error ("too few arguments to function %qE", function);
8894 return 0;
8895 }
8896
b9c74b4d 8897 type = TREE_TYPE (VEC_index (tree, params, 0));
b6a5fc45 8898 if (TREE_CODE (type) != POINTER_TYPE)
8899 goto incompatible;
8900
8901 type = TREE_TYPE (type);
8902 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8903 goto incompatible;
8904
8905 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
27213ba3 8906 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
b6a5fc45 8907 return size;
8908
8909 incompatible:
8910 error ("incompatible type for argument %d of %qE", 1, function);
8911 return 0;
8912}
8913
a0c938f0 8914/* A helper function for resolve_overloaded_builtin. Adds casts to
b6a5fc45 8915 PARAMS to make arguments match up with those of FUNCTION. Drops
8916 the variadic arguments at the end. Returns false if some error
8917 was encountered; true on success. */
8918
8919static bool
b9c74b4d 8920sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
b6a5fc45 8921{
8922 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8923 tree ptype;
b9c74b4d 8924 unsigned int parmnum;
b6a5fc45 8925
8926 /* We've declared the implementation functions to use "volatile void *"
8927 as the pointer parameter, so we shouldn't get any complaints from the
8928 call to check_function_arguments what ever type the user used. */
8929 arg_types = TREE_CHAIN (arg_types);
b9c74b4d 8930 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
b6a5fc45 8931
8932 /* For the rest of the values, we need to cast these to FTYPE, so that we
8933 don't get warnings for passing pointer types, etc. */
b9c74b4d 8934 parmnum = 0;
b6a5fc45 8935 while (arg_types != void_list_node)
8936 {
8937 tree val;
8938
b9c74b4d 8939 ++parmnum;
8940 if (VEC_length (tree, params) <= parmnum)
b6a5fc45 8941 {
8942 error ("too few arguments to function %qE", orig_function);
8943 return false;
8944 }
8945
8946 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8947 so that we get warnings for anything that doesn't match the pointer
8948 type. This isn't portable across the C and C++ front ends atm. */
b9c74b4d 8949 val = VEC_index (tree, params, parmnum);
b6a5fc45 8950 val = convert (ptype, val);
8951 val = convert (TREE_VALUE (arg_types), val);
b9c74b4d 8952 VEC_replace (tree, params, parmnum, val);
b6a5fc45 8953
8954 arg_types = TREE_CHAIN (arg_types);
b6a5fc45 8955 }
8956
8957 /* The definition of these primitives is variadic, with the remaining
8958 being "an optional list of variables protected by the memory barrier".
8959 No clue what that's supposed to mean, precisely, but we consider all
8960 call-clobbered variables to be protected so we're safe. */
b9c74b4d 8961 VEC_truncate (tree, params, parmnum + 1);
b6a5fc45 8962
8963 return true;
8964}
8965
a0c938f0 8966/* A helper function for resolve_overloaded_builtin. Adds a cast to
b6a5fc45 8967 RESULT to make it match the type of the first pointer argument in
8968 PARAMS. */
8969
8970static tree
b9c74b4d 8971sync_resolve_return (tree first_param, tree result)
b6a5fc45 8972{
b9c74b4d 8973 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
10080eac 8974 ptype = TYPE_MAIN_VARIANT (ptype);
b6a5fc45 8975 return convert (ptype, result);
8976}
8977
8978/* Some builtin functions are placeholders for other expressions. This
8979 function should be called immediately after parsing the call expression
8980 before surrounding code has committed to the type of the expression.
8981
e60a6f7b 8982 LOC is the location of the builtin call.
8983
b6a5fc45 8984 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8985 PARAMS is the argument list for the call. The return value is non-null
8986 when expansion is complete, and null if normal processing should
8987 continue. */
8988
8989tree
e60a6f7b 8990resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
b6a5fc45 8991{
8992 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
65441f6f 8993 switch (DECL_BUILT_IN_CLASS (function))
8994 {
8995 case BUILT_IN_NORMAL:
8996 break;
8997 case BUILT_IN_MD:
8998 if (targetm.resolve_overloaded_builtin)
e60a6f7b 8999 return targetm.resolve_overloaded_builtin (loc, function, params);
65441f6f 9000 else
a0c938f0 9001 return NULL_TREE;
65441f6f 9002 default:
9003 return NULL_TREE;
9004 }
a0c938f0 9005
65441f6f 9006 /* Handle BUILT_IN_NORMAL here. */
b6a5fc45 9007 switch (orig_code)
9008 {
9009 case BUILT_IN_FETCH_AND_ADD_N:
9010 case BUILT_IN_FETCH_AND_SUB_N:
9011 case BUILT_IN_FETCH_AND_OR_N:
9012 case BUILT_IN_FETCH_AND_AND_N:
9013 case BUILT_IN_FETCH_AND_XOR_N:
9014 case BUILT_IN_FETCH_AND_NAND_N:
9015 case BUILT_IN_ADD_AND_FETCH_N:
9016 case BUILT_IN_SUB_AND_FETCH_N:
9017 case BUILT_IN_OR_AND_FETCH_N:
9018 case BUILT_IN_AND_AND_FETCH_N:
9019 case BUILT_IN_XOR_AND_FETCH_N:
9020 case BUILT_IN_NAND_AND_FETCH_N:
9021 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
9022 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
9023 case BUILT_IN_LOCK_TEST_AND_SET_N:
9024 case BUILT_IN_LOCK_RELEASE_N:
9025 {
9026 int n = sync_resolve_size (function, params);
b9c74b4d 9027 tree new_function, first_param, result;
b6a5fc45 9028
9029 if (n == 0)
9030 return error_mark_node;
9031
9032 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
9033 if (!sync_resolve_params (function, new_function, params))
9034 return error_mark_node;
9035
b9c74b4d 9036 first_param = VEC_index (tree, params, 0);
e60a6f7b 9037 result = build_function_call_vec (loc, new_function, params, NULL);
b6a5fc45 9038 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
9039 && orig_code != BUILT_IN_LOCK_RELEASE_N)
b9c74b4d 9040 result = sync_resolve_return (first_param, result);
b6a5fc45 9041
9042 return result;
9043 }
9044
9045 default:
65441f6f 9046 return NULL_TREE;
b6a5fc45 9047 }
9048}
9049
491255f5 9050/* Ignoring their sign, return true if two scalar types are the same. */
9051bool
9052same_scalar_type_ignoring_signedness (tree t1, tree t2)
9053{
9054 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
9055
9421ebb9 9056 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
9057 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
9058 || c2 == FIXED_POINT_TYPE));
491255f5 9059
9060 /* Equality works here because c_common_signed_type uses
9061 TYPE_MAIN_VARIANT. */
11773141 9062 return c_common_signed_type (t1)
9063 == c_common_signed_type (t2);
491255f5 9064}
9065
be7350e7 9066/* Check for missing format attributes on function pointers. LTYPE is
9067 the new type or left-hand side type. RTYPE is the old type or
9068 right-hand side type. Returns TRUE if LTYPE is missing the desired
9069 attribute. */
9070
9071bool
9072check_missing_format_attribute (tree ltype, tree rtype)
9073{
9074 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
9075 tree ra;
9076
9077 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
9078 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
9079 break;
9080 if (ra)
9081 {
9082 tree la;
9083 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
9084 if (is_attribute_p ("format", TREE_PURPOSE (la)))
9085 break;
9086 return !la;
9087 }
9088 else
9089 return false;
9090}
9091
2840aae4 9092/* Subscripting with type char is likely to lose on a machine where
9093 chars are signed. So warn on any machine, but optionally. Don't
9094 warn for unsigned char since that type is safe. Don't warn for
9095 signed char because anyone who uses that must have done so
9096 deliberately. Furthermore, we reduce the false positive load by
9097 warning only for non-constant value of type char. */
9098
9099void
9100warn_array_subscript_with_type_char (tree index)
9101{
9102 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
9103 && TREE_CODE (index) != INTEGER_CST)
9104 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
9105}
9106
e534436e 9107/* Implement -Wparentheses for the unexpected C precedence rules, to
9108 cover cases like x + y << z which readers are likely to
9109 misinterpret. We have seen an expression in which CODE is a binary
82012ffe 9110 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
9111 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
9112 CODE_RIGHT may be ERROR_MARK, which means that that side of the
9113 expression was not formed using a binary or unary operator, or it
9114 was enclosed in parentheses. */
e534436e 9115
9116void
82012ffe 9117warn_about_parentheses (enum tree_code code,
269f7979 9118 enum tree_code code_left, tree arg_left,
82012ffe 9119 enum tree_code code_right, tree arg_right)
e534436e 9120{
9121 if (!warn_parentheses)
9122 return;
9123
82012ffe 9124 /* This macro tests that the expression ARG with original tree code
9125 CODE appears to be a boolean expression. or the result of folding a
9126 boolean expression. */
9127#define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
9128 (truth_value_p (TREE_CODE (ARG)) \
9129 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
9130 /* Folding may create 0 or 1 integers from other expressions. */ \
9131 || ((CODE) != INTEGER_CST \
9132 && (integer_onep (ARG) || integer_zerop (ARG))))
9133
48e1416a 9134 switch (code)
e534436e 9135 {
82012ffe 9136 case LSHIFT_EXPR:
9137 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
e534436e 9138 warning (OPT_Wparentheses,
82012ffe 9139 "suggest parentheses around %<+%> inside %<<<%>");
9140 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9141 warning (OPT_Wparentheses,
9142 "suggest parentheses around %<-%> inside %<<<%>");
9143 return;
e534436e 9144
82012ffe 9145 case RSHIFT_EXPR:
9146 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
e534436e 9147 warning (OPT_Wparentheses,
82012ffe 9148 "suggest parentheses around %<+%> inside %<>>%>");
9149 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9150 warning (OPT_Wparentheses,
9151 "suggest parentheses around %<-%> inside %<>>%>");
9152 return;
e534436e 9153
82012ffe 9154 case TRUTH_ORIF_EXPR:
9155 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9156 warning (OPT_Wparentheses,
9157 "suggest parentheses around %<&&%> within %<||%>");
9158 return;
9159
9160 case BIT_IOR_EXPR:
e534436e 9161 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9162 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9163 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9164 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9165 warning (OPT_Wparentheses,
82012ffe 9166 "suggest parentheses around arithmetic in operand of %<|%>");
e534436e 9167 /* Check cases like x|y==z */
82012ffe 9168 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9169 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9170 warning (OPT_Wparentheses,
82012ffe 9171 "suggest parentheses around comparison in operand of %<|%>");
9172 /* Check cases like !x | y */
9173 else if (code_left == TRUTH_NOT_EXPR
9174 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
96bda40f 9175 warning (OPT_Wparentheses, "suggest parentheses around operand of "
82012ffe 9176 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9177 return;
e534436e 9178
82012ffe 9179 case BIT_XOR_EXPR:
e534436e 9180 if (code_left == BIT_AND_EXPR
9181 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9182 || code_right == BIT_AND_EXPR
9183 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9184 warning (OPT_Wparentheses,
82012ffe 9185 "suggest parentheses around arithmetic in operand of %<^%>");
e534436e 9186 /* Check cases like x^y==z */
82012ffe 9187 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9188 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9189 warning (OPT_Wparentheses,
82012ffe 9190 "suggest parentheses around comparison in operand of %<^%>");
9191 return;
e534436e 9192
82012ffe 9193 case BIT_AND_EXPR:
9194 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9195 warning (OPT_Wparentheses,
9196 "suggest parentheses around %<+%> in operand of %<&%>");
9197 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
e534436e 9198 warning (OPT_Wparentheses,
82012ffe 9199 "suggest parentheses around %<-%> in operand of %<&%>");
e534436e 9200 /* Check cases like x&y==z */
82012ffe 9201 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9202 || TREE_CODE_CLASS (code_right) == tcc_comparison)
e534436e 9203 warning (OPT_Wparentheses,
82012ffe 9204 "suggest parentheses around comparison in operand of %<&%>");
9205 /* Check cases like !x & y */
9206 else if (code_left == TRUTH_NOT_EXPR
9207 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
96bda40f 9208 warning (OPT_Wparentheses, "suggest parentheses around operand of "
82012ffe 9209 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9210 return;
e534436e 9211
82012ffe 9212 case EQ_EXPR:
6ce0c450 9213 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9214 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9215 warning (OPT_Wparentheses,
82012ffe 9216 "suggest parentheses around comparison in operand of %<==%>");
9217 return;
9218 case NE_EXPR:
9219 if (TREE_CODE_CLASS (code_left) == tcc_comparison
9220 || TREE_CODE_CLASS (code_right) == tcc_comparison)
9221 warning (OPT_Wparentheses,
9222 "suggest parentheses around comparison in operand of %<!=%>");
9223 return;
9224
9225 default:
9226 if (TREE_CODE_CLASS (code) == tcc_comparison
9227 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
269f7979 9228 && code_left != NE_EXPR && code_left != EQ_EXPR
9229 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
82012ffe 9230 || (TREE_CODE_CLASS (code_right) == tcc_comparison
269f7979 9231 && code_right != NE_EXPR && code_right != EQ_EXPR
9232 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
82012ffe 9233 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
6ce0c450 9234 "have their mathematical meaning");
82012ffe 9235 return;
6ce0c450 9236 }
82012ffe 9237#undef NOT_A_BOOLEAN_EXPR_P
e534436e 9238}
9239
92fccaaa 9240/* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
9241
9242void
9243warn_for_unused_label (tree label)
9244{
9245 if (!TREE_USED (label))
9246 {
9247 if (DECL_INITIAL (label))
9248 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9249 else
9250 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9251 }
9252}
2840aae4 9253
b9fc964a 9254#ifndef TARGET_HAS_TARGETCM
9255struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9256#endif
9257
b6889cb0 9258/* Warn for division by zero according to the value of DIVISOR. LOC
9259 is the location of the division operator. */
f092582b 9260
9261void
b6889cb0 9262warn_for_div_by_zero (location_t loc, tree divisor)
f092582b 9263{
9421ebb9 9264 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9265 about division by zero. Do not issue a warning if DIVISOR has a
f092582b 9266 floating-point type, since we consider 0.0/0.0 a valid way of
9267 generating a NaN. */
48d94ede 9268 if (c_inhibit_evaluation_warnings == 0
9421ebb9 9269 && (integer_zerop (divisor) || fixed_zerop (divisor)))
b6889cb0 9270 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
f092582b 9271}
9272
13869a99 9273/* Subroutine of build_binary_op. Give warnings for comparisons
9274 between signed and unsigned quantities that may fail. Do the
9275 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9276 so that casts will be considered, but default promotions won't
8e70fb09 9277 be.
9278
9279 LOCATION is the location of the comparison operator.
13869a99 9280
9281 The arguments of this function map directly to local variables
9282 of build_binary_op. */
9283
48e1416a 9284void
8e70fb09 9285warn_for_sign_compare (location_t location,
48e1416a 9286 tree orig_op0, tree orig_op1,
9287 tree op0, tree op1,
13869a99 9288 tree result_type, enum tree_code resultcode)
9289{
9290 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9291 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9292 int unsignedp0, unsignedp1;
48e1416a 9293
13869a99 9294 /* In C++, check for comparison of different enum types. */
9295 if (c_dialect_cxx()
9296 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9297 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9298 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
895b662f 9299 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
13869a99 9300 {
8e70fb09 9301 warning_at (location,
9302 OPT_Wsign_compare, "comparison between types %qT and %qT",
9303 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
13869a99 9304 }
9305
9306 /* Do not warn if the comparison is being done in a signed type,
9307 since the signed type will only be chosen if it can represent
9308 all the values of the unsigned type. */
9309 if (!TYPE_UNSIGNED (result_type))
9310 /* OK */;
9311 /* Do not warn if both operands are unsigned. */
9312 else if (op0_signed == op1_signed)
9313 /* OK */;
9314 else
9315 {
895b662f 9316 tree sop, uop, base_type;
13869a99 9317 bool ovf;
895b662f 9318
13869a99 9319 if (op0_signed)
9320 sop = orig_op0, uop = orig_op1;
48e1416a 9321 else
13869a99 9322 sop = orig_op1, uop = orig_op0;
9323
48e1416a 9324 STRIP_TYPE_NOPS (sop);
13869a99 9325 STRIP_TYPE_NOPS (uop);
895b662f 9326 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9327 ? TREE_TYPE (result_type) : result_type);
13869a99 9328
9329 /* Do not warn if the signed quantity is an unsuffixed integer
9330 literal (or some static constant expression involving such
9331 literals or a conditional expression involving such literals)
9332 and it is non-negative. */
9333 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9334 /* OK */;
9335 /* Do not warn if the comparison is an equality operation, the
9336 unsigned quantity is an integral constant, and it would fit
9337 in the result if the result were signed. */
9338 else if (TREE_CODE (uop) == INTEGER_CST
9339 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
895b662f 9340 && int_fits_type_p (uop, c_common_signed_type (base_type)))
13869a99 9341 /* OK */;
9342 /* In C, do not warn if the unsigned quantity is an enumeration
9343 constant and its maximum value would fit in the result if the
9344 result were signed. */
9345 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9346 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9347 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
895b662f 9348 c_common_signed_type (base_type)))
13869a99 9349 /* OK */;
48e1416a 9350 else
8e70fb09 9351 warning_at (location,
48e1416a 9352 OPT_Wsign_compare,
8e70fb09 9353 "comparison between signed and unsigned integer expressions");
13869a99 9354 }
48e1416a 9355
13869a99 9356 /* Warn if two unsigned values are being compared in a size larger
9357 than their original size, and one (and only one) is the result of
9358 a `~' operator. This comparison will always fail.
48e1416a 9359
13869a99 9360 Also warn if one operand is a constant, and the constant does not
9361 have all bits set that are set in the ~ operand when it is
9362 extended. */
9363
9364 op0 = get_narrower (op0, &unsignedp0);
9365 op1 = get_narrower (op1, &unsignedp1);
48e1416a 9366
13869a99 9367 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9368 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9369 {
9370 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9371 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9372 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9373 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9374
9375 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9376 {
9377 tree primop;
9378 HOST_WIDE_INT constant, mask;
9379 int unsignedp;
9380 unsigned int bits;
48e1416a 9381
13869a99 9382 if (host_integerp (op0, 0))
9383 {
9384 primop = op1;
9385 unsignedp = unsignedp1;
9386 constant = tree_low_cst (op0, 0);
9387 }
9388 else
9389 {
9390 primop = op0;
9391 unsignedp = unsignedp0;
9392 constant = tree_low_cst (op1, 0);
9393 }
48e1416a 9394
13869a99 9395 bits = TYPE_PRECISION (TREE_TYPE (primop));
9396 if (bits < TYPE_PRECISION (result_type)
9397 && bits < HOST_BITS_PER_LONG && unsignedp)
9398 {
9399 mask = (~ (HOST_WIDE_INT) 0) << bits;
9400 if ((mask & constant) != mask)
9401 {
9402 if (constant == 0)
48e1416a 9403 warning (OPT_Wsign_compare,
13869a99 9404 "promoted ~unsigned is always non-zero");
9405 else
48e1416a 9406 warning_at (location, OPT_Wsign_compare,
8e70fb09 9407 "comparison of promoted ~unsigned with constant");
13869a99 9408 }
9409 }
9410 }
9411 else if (unsignedp0 && unsignedp1
9412 && (TYPE_PRECISION (TREE_TYPE (op0))
9413 < TYPE_PRECISION (result_type))
9414 && (TYPE_PRECISION (TREE_TYPE (op1))
9415 < TYPE_PRECISION (result_type)))
8e70fb09 9416 warning_at (location, OPT_Wsign_compare,
13869a99 9417 "comparison of promoted ~unsigned with unsigned");
9418 }
9419}
9420
5ba33bf4 9421/* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
9422 type via c_common_type. If -Wdouble-promotion is in use, and the
9423 conditions for warning have been met, issue a warning. GMSGID is
9424 the warning message. It must have two %T specifiers for the type
9425 that was converted (generally "float") and the type to which it was
9426 converted (generally "double), respectively. LOC is the location
9427 to which the awrning should refer. */
9428
9429void
9430do_warn_double_promotion (tree result_type, tree type1, tree type2,
9431 const char *gmsgid, location_t loc)
9432{
9433 tree source_type;
9434
9435 if (!warn_double_promotion)
9436 return;
9437 /* If the conversion will not occur at run-time, there is no need to
9438 warn about it. */
9439 if (c_inhibit_evaluation_warnings)
9440 return;
9441 if (TYPE_MAIN_VARIANT (result_type) != double_type_node
9442 && TYPE_MAIN_VARIANT (result_type) != complex_double_type_node)
9443 return;
9444 if (TYPE_MAIN_VARIANT (type1) == float_type_node
9445 || TYPE_MAIN_VARIANT (type1) == complex_float_type_node)
9446 source_type = type1;
9447 else if (TYPE_MAIN_VARIANT (type2) == float_type_node
9448 || TYPE_MAIN_VARIANT (type2) == complex_float_type_node)
9449 source_type = type2;
9450 else
9451 return;
9452 warning_at (loc, OPT_Wdouble_promotion, gmsgid, source_type, result_type);
9453}
9454
41771881 9455/* Setup a TYPE_DECL node as a typedef representation.
9456
9457 X is a TYPE_DECL for a typedef statement. Create a brand new
9458 ..._TYPE node (which will be just a variant of the existing
9459 ..._TYPE node with identical properties) and then install X
9460 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9461
9462 The whole point here is to end up with a situation where each
9463 and every ..._TYPE node the compiler creates will be uniquely
9464 associated with AT MOST one node representing a typedef name.
9465 This way, even though the compiler substitutes corresponding
9466 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9467 early on, later parts of the compiler can always do the reverse
9468 translation and get back the corresponding typedef name. For
9469 example, given:
9470
9471 typedef struct S MY_TYPE;
9472 MY_TYPE object;
9473
9474 Later parts of the compiler might only know that `object' was of
9475 type `struct S' if it were not for code just below. With this
9476 code however, later parts of the compiler see something like:
9477
9478 struct S' == struct S
9479 typedef struct S' MY_TYPE;
9480 struct S' object;
9481
9482 And they can then deduce (from the node for type struct S') that
9483 the original object declaration was:
9484
9485 MY_TYPE object;
9486
9487 Being able to do this is important for proper support of protoize,
9488 and also for generating precise symbolic debugging information
9489 which takes full account of the programmer's (typedef) vocabulary.
9490
9491 Obviously, we don't want to generate a duplicate ..._TYPE node if
9492 the TYPE_DECL node that we are now processing really represents a
9493 standard built-in type. */
9494
9495void
9496set_underlying_type (tree x)
9497{
9498 if (x == error_mark_node)
9499 return;
9500 if (DECL_IS_BUILTIN (x))
9501 {
9502 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9503 TYPE_NAME (TREE_TYPE (x)) = x;
9504 }
9505 else if (TREE_TYPE (x) != error_mark_node
9506 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9507 {
9508 tree tt = TREE_TYPE (x);
9509 DECL_ORIGINAL_TYPE (x) = tt;
9510 tt = build_variant_type_copy (tt);
9511 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9512 TYPE_NAME (tt) = x;
9513 TREE_USED (tt) = TREE_USED (x);
9514 TREE_TYPE (x) = tt;
9515 }
9516}
9517
1a4c44c5 9518/* Record the types used by the current global variable declaration
9519 being parsed, so that we can decide later to emit their debug info.
9520 Those types are in types_used_by_cur_var_decl, and we are going to
9521 store them in the types_used_by_vars_hash hash table.
9522 DECL is the declaration of the global variable that has been parsed. */
9523
9524void
9525record_types_used_by_current_var_decl (tree decl)
9526{
9527 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9528
aef48c9a 9529 while (!VEC_empty (tree, types_used_by_cur_var_decl))
1a4c44c5 9530 {
aef48c9a 9531 tree type = VEC_pop (tree, types_used_by_cur_var_decl);
9532 types_used_by_var_decl_insert (type, decl);
1a4c44c5 9533 }
9534}
9535
f352a3fb 9536/* The C and C++ parsers both use vectors to hold function arguments.
9537 For efficiency, we keep a cache of unused vectors. This is the
9538 cache. */
9539
9540typedef VEC(tree,gc)* tree_gc_vec;
9541DEF_VEC_P(tree_gc_vec);
9542DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9543static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9544
9545/* Return a new vector from the cache. If the cache is empty,
9546 allocate a new vector. These vectors are GC'ed, so it is OK if the
9547 pointer is not released.. */
9548
9549VEC(tree,gc) *
9550make_tree_vector (void)
9551{
9552 if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9553 return VEC_pop (tree_gc_vec, tree_vector_cache);
9554 else
9555 {
9556 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9557 that we always return a non-NULL value. The vector code uses
9558 4 when growing a NULL vector, so we do too. */
9559 return VEC_alloc (tree, gc, 4);
9560 }
9561}
9562
9563/* Release a vector of trees back to the cache. */
9564
9565void
9566release_tree_vector (VEC(tree,gc) *vec)
9567{
9568 if (vec != NULL)
9569 {
9570 VEC_truncate (tree, vec, 0);
9571 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9572 }
9573}
9574
9575/* Get a new tree vector holding a single tree. */
9576
9577VEC(tree,gc) *
9578make_tree_vector_single (tree t)
9579{
9580 VEC(tree,gc) *ret = make_tree_vector ();
9581 VEC_quick_push (tree, ret, t);
9582 return ret;
9583}
9584
9585/* Get a new tree vector which is a copy of an existing one. */
9586
9587VEC(tree,gc) *
9588make_tree_vector_copy (const VEC(tree,gc) *orig)
9589{
9590 VEC(tree,gc) *ret;
9591 unsigned int ix;
9592 tree t;
9593
9594 ret = make_tree_vector ();
9595 VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
48148244 9596 FOR_EACH_VEC_ELT (tree, orig, ix, t)
f352a3fb 9597 VEC_quick_push (tree, ret, t);
9598 return ret;
9599}
9600
a9ffdd35 9601/* Return true if KEYWORD starts a type specifier. */
9602
9603bool
9604keyword_begins_type_specifier (enum rid keyword)
9605{
9606 switch (keyword)
9607 {
9608 case RID_INT:
9609 case RID_CHAR:
9610 case RID_FLOAT:
9611 case RID_DOUBLE:
9612 case RID_VOID:
9613 case RID_INT128:
9614 case RID_UNSIGNED:
9615 case RID_LONG:
9616 case RID_SHORT:
9617 case RID_SIGNED:
9618 case RID_DFLOAT32:
9619 case RID_DFLOAT64:
9620 case RID_DFLOAT128:
9621 case RID_FRACT:
9622 case RID_ACCUM:
9623 case RID_BOOL:
9624 case RID_WCHAR:
9625 case RID_CHAR16:
9626 case RID_CHAR32:
9627 case RID_SAT:
9628 case RID_COMPLEX:
9629 case RID_TYPEOF:
9630 case RID_STRUCT:
9631 case RID_CLASS:
9632 case RID_UNION:
9633 case RID_ENUM:
9634 return true;
9635 default:
9636 return false;
9637 }
9638}
9639
9640/* Return true if KEYWORD names a type qualifier. */
9641
9642bool
9643keyword_is_type_qualifier (enum rid keyword)
9644{
9645 switch (keyword)
9646 {
9647 case RID_CONST:
9648 case RID_VOLATILE:
9649 case RID_RESTRICT:
9650 return true;
9651 default:
9652 return false;
9653 }
9654}
9655
9656/* Return true if KEYWORD names a storage class specifier.
9657
9658 RID_TYPEDEF is not included in this list despite `typedef' being
9659 listed in C99 6.7.1.1. 6.7.1.3 indicates that `typedef' is listed as
9660 such for syntactic convenience only. */
9661
9662bool
9663keyword_is_storage_class_specifier (enum rid keyword)
9664{
9665 switch (keyword)
9666 {
9667 case RID_STATIC:
9668 case RID_EXTERN:
9669 case RID_REGISTER:
9670 case RID_AUTO:
9671 case RID_MUTABLE:
9672 case RID_THREAD:
9673 return true;
9674 default:
9675 return false;
9676 }
9677}
9678
fad3f658 9679/* Return true if KEYWORD names a function-specifier [dcl.fct.spec]. */
9680
9681static bool
9682keyword_is_function_specifier (enum rid keyword)
9683{
9684 switch (keyword)
9685 {
9686 case RID_INLINE:
9687 case RID_VIRTUAL:
9688 case RID_EXPLICIT:
9689 return true;
9690 default:
9691 return false;
9692 }
9693}
9694
9695/* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
9696 declaration-specifier (C99 6.7). */
9697
9698bool
9699keyword_is_decl_specifier (enum rid keyword)
9700{
9701 if (keyword_is_storage_class_specifier (keyword)
9702 || keyword_is_type_qualifier (keyword)
9703 || keyword_is_function_specifier (keyword))
9704 return true;
9705
9706 switch (keyword)
9707 {
9708 case RID_TYPEDEF:
9709 case RID_FRIEND:
9710 case RID_CONSTEXPR:
9711 return true;
9712 default:
9713 return false;
9714 }
9715}
9716
7bedc3a0 9717#include "gt-c-family-c-common.h"
Mirror of https://gcc.gnu.org/git/gcc.git