]> 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
gimplify.c (gimplify_modify_expr): When assigning to volatiles, copy the src value...
[thirdparty/gcc.git] / gcc / c-family / c-common.c
CommitLineData
b30f223b 1/* Subroutines shared by all languages that are variants of C.
1574ef13 2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
c75c517d 3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
09812622 4 Free Software Foundation, Inc.
b30f223b 5
1322177d 6This file is part of GCC.
b30f223b 7
1322177d
LB		 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
9dcd6f09 10Software Foundation; either version 3, or (at your option) any later
1322177d 11version.
b30f223b 12
1322177d
LB		 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.
b30f223b
RS		 17
18You should have received a copy of the GNU General Public License
9dcd6f09
NC		 19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
b30f223b
RS		 21
22#include "config.h"
670ee920 23#include "system.h"
4977bab6
ZW		 24#include "coretypes.h"
25#include "tm.h"
d9b2742a 26#include "intl.h"
b30f223b 27#include "tree.h"
b30f223b 28#include "flags.h"
d6f4ec51 29#include "output.h"
e2af664c 30#include "c-pragma.h"
1526a060 31#include "ggc.h"
8f17b5c5 32#include "c-common.h"
7bdb32b9 33#include "tm_p.h"
235cfbc4 34#include "obstack.h"
c8724862 35#include "cpplib.h"
12a68f1f 36#include "target.h"
7afff7cf 37#include "langhooks.h"
d57a4b98 38#include "tree-inline.h"
5f1989e6 39#include "toplev.h"
148e4216 40#include "diagnostic.h"
6de9cd9a
DN		 41#include "tree-iterator.h"
42#include "hashtab.h"
c31b8e1b 43#include "tree-mudflap.h"
d974312d 44#include "opts.h"
ce91e74c 45#include "cgraph.h"
1f1d5130 46#include "target-def.h"
6b2b8871 47#include "libfuncs.h"
cb60f38d 48
81a75f0f 49cpp_reader *parse_in; /* Declared in c-pragma.h. */
c8724862 50
7f4edbcb 51/* The following symbols are subsumed in the c_global_trees array, and
d125d268 52 listed here individually for documentation purposes.
7f4edbcb
BS		 53
54 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
55
56 tree short_integer_type_node;
57 tree long_integer_type_node;
58 tree long_long_integer_type_node;
a6766312 59 tree int128_integer_type_node;
7f4edbcb
BS		 60
61 tree short_unsigned_type_node;
62 tree long_unsigned_type_node;
63 tree long_long_unsigned_type_node;
a6766312 64 tree int128_unsigned_type_node;
7f4edbcb 65
de7df9eb
JM		 66 tree truthvalue_type_node;
67 tree truthvalue_false_node;
68 tree truthvalue_true_node;
7f4edbcb
BS		 69
70 tree ptrdiff_type_node;
71
72 tree unsigned_char_type_node;
73 tree signed_char_type_node;
74 tree wchar_type_node;
7f4edbcb 75
b6baa67d
KVH		 76 tree char16_type_node;
77 tree char32_type_node;
78
7f4edbcb
BS		 79 tree float_type_node;
80 tree double_type_node;
81 tree long_double_type_node;
82
83 tree complex_integer_type_node;
84 tree complex_float_type_node;
85 tree complex_double_type_node;
86 tree complex_long_double_type_node;
87
9a8ce21f
JG		 88 tree dfloat32_type_node;
89 tree dfloat64_type_node;
90 tree_dfloat128_type_node;
91
7f4edbcb
BS		 92 tree intQI_type_node;
93 tree intHI_type_node;
94 tree intSI_type_node;
95 tree intDI_type_node;
96 tree intTI_type_node;
97
98 tree unsigned_intQI_type_node;
99 tree unsigned_intHI_type_node;
100 tree unsigned_intSI_type_node;
101 tree unsigned_intDI_type_node;
102 tree unsigned_intTI_type_node;
103
104 tree widest_integer_literal_type_node;
105 tree widest_unsigned_literal_type_node;
106
107 Nodes for types `void *' and `const void *'.
108
109 tree ptr_type_node, const_ptr_type_node;
110
111 Nodes for types `char *' and `const char *'.
112
113 tree string_type_node, const_string_type_node;
114
115 Type `char[SOMENUMBER]'.
116 Used when an array of char is needed and the size is irrelevant.
117
118 tree char_array_type_node;
119
120 Type `int[SOMENUMBER]' or something like it.
121 Used when an array of int needed and the size is irrelevant.
122
123 tree int_array_type_node;
124
125 Type `wchar_t[SOMENUMBER]' or something like it.
126 Used when a wide string literal is created.
127
128 tree wchar_array_type_node;
129
b6baa67d
KVH		 130 Type `char16_t[SOMENUMBER]' or something like it.
131 Used when a UTF-16 string literal is created.
132
133 tree char16_array_type_node;
134
135 Type `char32_t[SOMENUMBER]' or something like it.
136 Used when a UTF-32 string literal is created.
137
138 tree char32_array_type_node;
139
7f4edbcb
BS		 140 Type `int ()' -- used for implicit declaration of functions.
141
142 tree default_function_type;
143
7f4edbcb
BS		 144 A VOID_TYPE node, packaged in a TREE_LIST.
145
146 tree void_list_node;
147
684d9f3b 148 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
0ba8a114
NS		 149 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
150 VAR_DECLS, but C++ does.)
63ad61ed 151
0ba8a114 152 tree function_name_decl_node;
684d9f3b 153 tree pretty_function_name_decl_node;
0ba8a114
NS		 154 tree c99_function_name_decl_node;
155
156 Stack of nested function name VAR_DECLs.
35b1a6fa 157
0ba8a114 158 tree saved_function_name_decls;
63ad61ed 159
7f4edbcb
BS		 160*/
161
162tree c_global_trees[CTI_MAX];
17211ab5 163\f
4078b403
NB		 164/* Switches common to the C front ends. */
165
63973df3
NB		 166/* Nonzero means don't output line number information. */
167
168char flag_no_line_commands;
169
170/* Nonzero causes -E output not to be done, but directives such as
171 #define that have side effects are still obeyed. */
172
173char flag_no_output;
174
175/* Nonzero means dump macros in some fashion. */
176
177char flag_dump_macros;
178
179/* Nonzero means pass #include lines through to the output. */
180
181char flag_dump_includes;
182
c0d578e6
GK		 183/* Nonzero means process PCH files while preprocessing. */
184
185bool flag_pch_preprocess;
186
17211ab5
GK		 187/* The file name to which we should write a precompiled header, or
188 NULL if no header will be written in this compile. */
189
190const char *pch_file;
191
3df89291
NB		 192/* Nonzero if an ISO standard was selected. It rejects macros in the
193 user's namespace. */
194int flag_iso;
195
35b1a6fa 196/* Warn about #pragma directives that are not recognized. */
4078b403 197
35b1a6fa 198int warn_unknown_pragmas; /* Tri state variable. */
4078b403 199
4078b403
NB		 200/* Warn about format/argument anomalies in calls to formatted I/O functions
201 (*printf, *scanf, strftime, strfmon, etc.). */
202
203int warn_format;
204
4078b403
NB		 205/* C/ObjC language option variables. */
206
207
4078b403
NB		 208/* Nonzero means allow type mismatches in conditional expressions;
209 just make their values `void'. */
210
211int flag_cond_mismatch;
212
213/* Nonzero means enable C89 Amendment 1 features. */
214
215int flag_isoc94;
216
2778d766 217/* Nonzero means use the ISO C99 (or C1X) dialect of C. */
4078b403
NB		 218
219int flag_isoc99;
220
2778d766
JM		 221/* Nonzero means use the ISO C1X dialect of C. */
222
223int flag_isoc1x;
224
6614fd40 225/* Nonzero means that we have builtin functions, and main is an int. */
4078b403
NB		 226
227int flag_hosted = 1;
228
4078b403
NB		 229
230/* ObjC language option variables. */
231
232
4078b403
NB		 233/* Tells the compiler that this is a special run. Do not perform any
234 compiling, instead we are to test some platform dependent features
235 and output a C header file with appropriate definitions. */
236
237int print_struct_values;
238
fa10beec 239/* Tells the compiler what is the constant string class for ObjC. */
4078b403
NB		 240
241const char *constant_string_class_name;
242
4078b403
NB		 243
244/* C++ language option variables. */
245
246
4078b403
NB		 247/* Nonzero means generate separate instantiation control files and
248 juggle them at link time. */
249
250int flag_use_repository;
251
c1ae8be5 252/* The C++ dialect being used. C++98 is the default. */
966541e3 253
c1ae8be5 254enum cxx_dialect cxx_dialect = cxx98;
966541e3 255
4afe7ad7
JM		 256/* Maximum template instantiation depth. This limit exists to limit the
257 time it takes to notice infinite template instantiations; the default
258 value of 1024 is likely to be in the next C++ standard. */
4078b403 259
4afe7ad7 260int max_tinst_depth = 1024;
4078b403
NB		 261
262
263
f09f1de5
MM		 264/* The elements of `ridpointers' are identifier nodes for the reserved
265 type names and storage classes. It is indexed by a RID_... value. */
266tree *ridpointers;
267
c2255bc4 268tree (*make_fname_decl) (location_t, tree, int);
2ce07e2d 269
7d882b83
ILT		 270/* Nonzero means don't warn about problems that occur when the code is
271 executed. */
272int c_inhibit_evaluation_warnings;
e78a3b42 273
148e4216
JM		 274/* Whether lexing has been completed, so subsequent preprocessor
275 errors should use the compiler's input_location. */
276bool done_lexing = false;
277
ec5c56db 278/* Information about how a function name is generated. */
0ba8a114
NS		 279struct fname_var_t
280{
8b60264b
KG		 281 tree *const decl; /* pointer to the VAR_DECL. */
282 const unsigned rid; /* RID number for the identifier. */
283 const int pretty; /* How pretty is it? */
0ba8a114
NS		 284};
285
ec5c56db 286/* The three ways of getting then name of the current function. */
0ba8a114
NS		 287
288const struct fname_var_t fname_vars[] =
289{
ec5c56db 290 /* C99 compliant __func__, must be first. */
0ba8a114 291 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
ec5c56db 292 /* GCC __FUNCTION__ compliant. */
0ba8a114 293 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
ec5c56db 294 /* GCC __PRETTY_FUNCTION__ compliant. */
0ba8a114
NS		 295 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
296 {NULL, 0, 0},
297};
298
928c19bb 299static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
a6c0a76c
SB		 300static tree check_case_value (tree);
301static bool check_case_bounds (tree, tree, tree *, tree *);
4724b3de 302
35b1a6fa
AJ		 303static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
304static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
305static tree handle_common_attribute (tree *, tree, tree, int, bool *);
306static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
52bf96d2
JH		 307static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
308static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
35b1a6fa 309static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
86631ea3 310static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
35b1a6fa
AJ		 311static tree handle_always_inline_attribute (tree *, tree, tree, int,
312 bool *);
d752cfdb
JJ		 313static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
314static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
0691d1d4 315static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
d2af6a68 316static tree handle_error_attribute (tree *, tree, tree, int, bool *);
35b1a6fa
AJ		 317static tree handle_used_attribute (tree *, tree, tree, int, bool *);
318static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
ce91e74c
JH		 319static tree handle_externally_visible_attribute (tree *, tree, tree, int,
320 bool *);
35b1a6fa
AJ		 321static tree handle_const_attribute (tree *, tree, tree, int, bool *);
322static tree handle_transparent_union_attribute (tree *, tree, tree,
323 int, bool *);
324static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
325static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
326static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
327static tree handle_section_attribute (tree *, tree, tree, int, bool *);
328static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
329static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
330static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
a0203ca7 331static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
35b1a6fa
AJ		 332static tree handle_visibility_attribute (tree *, tree, tree, int,
333 bool *);
334static tree handle_tls_model_attribute (tree *, tree, tree, int,
335 bool *);
336static tree handle_no_instrument_function_attribute (tree *, tree,
337 tree, int, bool *);
338static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
6e9a3221 339static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
35b1a6fa
AJ		 340static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
341 bool *);
342static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
dcd6de6d 343static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
35b1a6fa
AJ		 344static tree handle_deprecated_attribute (tree *, tree, tree, int,
345 bool *);
346static tree handle_vector_size_attribute (tree *, tree, tree, int,
347 bool *);
348static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
349static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
350static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
72954a4f
JM		 351static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
352 bool *);
3d091dac 353static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
b5d32c25 354static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
51bc54a6 355static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
5779e713 356static tree handle_target_attribute (tree *, tree, tree, int, bool *);
ab442df7 357static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
0b7b376d 358static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
35b1a6fa 359
94a0dd7b 360static void check_function_nonnull (tree, int, tree *);
35b1a6fa
AJ		 361static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
362static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
363static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
d07605f5 364static int resort_field_decl_cmp (const void *, const void *);
b34c7881 365
eea1139b
ILT		 366/* Reserved words. The third field is a mask: keywords are disabled
367 if they match the mask.
368
369 Masks for languages:
370 C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
371 C --std=c99: D_CXXONLY | D_OBJC
372 ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
373 C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
374 C++ --std=c0x: D_CONLY | D_OBJC
375 ObjC++ is like C++ except that D_OBJC is not set
376
377 If -fno-asm is used, D_ASM is added to the mask. If
378 -fno-gnu-keywords is used, D_EXT is added. If -fno-asm and C in
379 C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
2696a995 380 In C with -Wc++-compat, we warn if D_CXXWARN is set. */
eea1139b
ILT		 381
382const struct c_common_resword c_common_reswords[] =
383{
384 { "_Bool", RID_BOOL, D_CONLY },
385 { "_Complex", RID_COMPLEX, 0 },
fa5da7de 386 { "_Imaginary", RID_IMAGINARY, D_CONLY },
eea1139b
ILT		 387 { "_Decimal32", RID_DFLOAT32, D_CONLY | D_EXT },
388 { "_Decimal64", RID_DFLOAT64, D_CONLY | D_EXT },
389 { "_Decimal128", RID_DFLOAT128, D_CONLY | D_EXT },
390 { "_Fract", RID_FRACT, D_CONLY | D_EXT },
391 { "_Accum", RID_ACCUM, D_CONLY | D_EXT },
392 { "_Sat", RID_SAT, D_CONLY | D_EXT },
32912286 393 { "_Static_assert", RID_STATIC_ASSERT, D_CONLY },
eea1139b
ILT		 394 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
395 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
396 { "__alignof", RID_ALIGNOF, 0 },
397 { "__alignof__", RID_ALIGNOF, 0 },
398 { "__asm", RID_ASM, 0 },
399 { "__asm__", RID_ASM, 0 },
400 { "__attribute", RID_ATTRIBUTE, 0 },
401 { "__attribute__", RID_ATTRIBUTE, 0 },
402 { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
403 { "__builtin_offsetof", RID_OFFSETOF, 0 },
404 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
405 { "__builtin_va_arg", RID_VA_ARG, 0 },
406 { "__complex", RID_COMPLEX, 0 },
407 { "__complex__", RID_COMPLEX, 0 },
408 { "__const", RID_CONST, 0 },
409 { "__const__", RID_CONST, 0 },
410 { "__decltype", RID_DECLTYPE, D_CXXONLY },
411 { "__extension__", RID_EXTENSION, 0 },
412 { "__func__", RID_C99_FUNCTION_NAME, 0 },
413 { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
414 { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
415 { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
416 { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
417 { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
418 { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
419 { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
420 { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
a6766312 421 { "__int128", RID_INT128, 0 },
eea1139b
ILT		 422 { "__is_abstract", RID_IS_ABSTRACT, D_CXXONLY },
423 { "__is_base_of", RID_IS_BASE_OF, D_CXXONLY },
424 { "__is_class", RID_IS_CLASS, D_CXXONLY },
425 { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
426 { "__is_empty", RID_IS_EMPTY, D_CXXONLY },
427 { "__is_enum", RID_IS_ENUM, D_CXXONLY },
428 { "__is_pod", RID_IS_POD, D_CXXONLY },
429 { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
c32097d8
JM		 430 { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
431 { "__is_trivial", RID_IS_TRIVIAL, D_CXXONLY },
eea1139b
ILT		 432 { "__is_union", RID_IS_UNION, D_CXXONLY },
433 { "__imag", RID_IMAGPART, 0 },
434 { "__imag__", RID_IMAGPART, 0 },
435 { "__inline", RID_INLINE, 0 },
436 { "__inline__", RID_INLINE, 0 },
437 { "__label__", RID_LABEL, 0 },
438 { "__null", RID_NULL, 0 },
439 { "__real", RID_REALPART, 0 },
440 { "__real__", RID_REALPART, 0 },
441 { "__restrict", RID_RESTRICT, 0 },
442 { "__restrict__", RID_RESTRICT, 0 },
443 { "__signed", RID_SIGNED, 0 },
444 { "__signed__", RID_SIGNED, 0 },
445 { "__thread", RID_THREAD, 0 },
446 { "__typeof", RID_TYPEOF, 0 },
447 { "__typeof__", RID_TYPEOF, 0 },
448 { "__volatile", RID_VOLATILE, 0 },
449 { "__volatile__", RID_VOLATILE, 0 },
f4e8a943 450 { "alignof", RID_ALIGNOF, D_CXXONLY | D_CXX0X | D_CXXWARN },
eea1139b
ILT		 451 { "asm", RID_ASM, D_ASM },
452 { "auto", RID_AUTO, 0 },
03c3034e 453 { "bool", RID_BOOL, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 454 { "break", RID_BREAK, 0 },
455 { "case", RID_CASE, 0 },
2696a995 456 { "catch", RID_CATCH, D_CXX_OBJC | D_CXXWARN },
eea1139b 457 { "char", RID_CHAR, 0 },
2696a995
KG		 458 { "char16_t", RID_CHAR16, D_CXXONLY | D_CXX0X | D_CXXWARN },
459 { "char32_t", RID_CHAR32, D_CXXONLY | D_CXX0X | D_CXXWARN },
460 { "class", RID_CLASS, D_CXX_OBJC | D_CXXWARN },
eea1139b 461 { "const", RID_CONST, 0 },
7ecbca9d 462 { "constexpr", RID_CONSTEXPR, D_CXXONLY | D_CXX0X | D_CXXWARN },
eea1139b
ILT		 463 { "const_cast", RID_CONSTCAST, D_CXXONLY | D_CXXWARN },
464 { "continue", RID_CONTINUE, 0 },
2696a995 465 { "decltype", RID_DECLTYPE, D_CXXONLY | D_CXX0X | D_CXXWARN },
eea1139b 466 { "default", RID_DEFAULT, 0 },
2696a995 467 { "delete", RID_DELETE, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 468 { "do", RID_DO, 0 },
469 { "double", RID_DOUBLE, 0 },
470 { "dynamic_cast", RID_DYNCAST, D_CXXONLY | D_CXXWARN },
471 { "else", RID_ELSE, 0 },
472 { "enum", RID_ENUM, 0 },
2696a995
KG		 473 { "explicit", RID_EXPLICIT, D_CXXONLY | D_CXXWARN },
474 { "export", RID_EXPORT, D_CXXONLY | D_CXXWARN },
eea1139b 475 { "extern", RID_EXTERN, 0 },
2696a995 476 { "false", RID_FALSE, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 477 { "float", RID_FLOAT, 0 },
478 { "for", RID_FOR, 0 },
2696a995 479 { "friend", RID_FRIEND, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 480 { "goto", RID_GOTO, 0 },
481 { "if", RID_IF, 0 },
482 { "inline", RID_INLINE, D_EXT89 },
483 { "int", RID_INT, 0 },
484 { "long", RID_LONG, 0 },
485 { "mutable", RID_MUTABLE, D_CXXONLY | D_CXXWARN },
2696a995
KG		 486 { "namespace", RID_NAMESPACE, D_CXXONLY | D_CXXWARN },
487 { "new", RID_NEW, D_CXXONLY | D_CXXWARN },
0a766368 488 { "noexcept", RID_NOEXCEPT, D_CXXONLY | D_CXX0X | D_CXXWARN },
14c2101d 489 { "nullptr", RID_NULLPTR, D_CXXONLY | D_CXX0X | D_CXXWARN },
2696a995
KG		 490 { "operator", RID_OPERATOR, D_CXXONLY | D_CXXWARN },
491 { "private", RID_PRIVATE, D_CXX_OBJC | D_CXXWARN },
492 { "protected", RID_PROTECTED, D_CXX_OBJC | D_CXXWARN },
493 { "public", RID_PUBLIC, D_CXX_OBJC | D_CXXWARN },
eea1139b
ILT		 494 { "register", RID_REGISTER, 0 },
495 { "reinterpret_cast", RID_REINTCAST, D_CXXONLY | D_CXXWARN },
496 { "restrict", RID_RESTRICT, D_CONLY | D_C99 },
497 { "return", RID_RETURN, 0 },
498 { "short", RID_SHORT, 0 },
499 { "signed", RID_SIGNED, 0 },
500 { "sizeof", RID_SIZEOF, 0 },
501 { "static", RID_STATIC, 0 },
502 { "static_assert", RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
503 { "static_cast", RID_STATCAST, D_CXXONLY | D_CXXWARN },
504 { "struct", RID_STRUCT, 0 },
505 { "switch", RID_SWITCH, 0 },
2696a995
KG		 506 { "template", RID_TEMPLATE, D_CXXONLY | D_CXXWARN },
507 { "this", RID_THIS, D_CXXONLY | D_CXXWARN },
508 { "throw", RID_THROW, D_CXX_OBJC | D_CXXWARN },
509 { "true", RID_TRUE, D_CXXONLY | D_CXXWARN },
510 { "try", RID_TRY, D_CXX_OBJC | D_CXXWARN },
eea1139b 511 { "typedef", RID_TYPEDEF, 0 },
2696a995
KG		 512 { "typename", RID_TYPENAME, D_CXXONLY | D_CXXWARN },
513 { "typeid", RID_TYPEID, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 514 { "typeof", RID_TYPEOF, D_ASM | D_EXT },
515 { "union", RID_UNION, 0 },
516 { "unsigned", RID_UNSIGNED, 0 },
2696a995
KG		 517 { "using", RID_USING, D_CXXONLY | D_CXXWARN },
518 { "virtual", RID_VIRTUAL, D_CXXONLY | D_CXXWARN },
eea1139b
ILT		 519 { "void", RID_VOID, 0 },
520 { "volatile", RID_VOLATILE, 0 },
521 { "wchar_t", RID_WCHAR, D_CXXONLY },
522 { "while", RID_WHILE, 0 },
523 /* These Objective-C keywords are recognized only immediately after
524 an '@'. */
525 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
526 { "defs", RID_AT_DEFS, D_OBJC },
527 { "encode", RID_AT_ENCODE, D_OBJC },
528 { "end", RID_AT_END, D_OBJC },
529 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
530 { "interface", RID_AT_INTERFACE, D_OBJC },
531 { "protocol", RID_AT_PROTOCOL, D_OBJC },
532 { "selector", RID_AT_SELECTOR, D_OBJC },
533 { "finally", RID_AT_FINALLY, D_OBJC },
534 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
535 /* These are recognized only in protocol-qualifier context
536 (see above) */
537 { "bycopy", RID_BYCOPY, D_OBJC },
538 { "byref", RID_BYREF, D_OBJC },
539 { "in", RID_IN, D_OBJC },
540 { "inout", RID_INOUT, D_OBJC },
541 { "oneway", RID_ONEWAY, D_OBJC },
542 { "out", RID_OUT, D_OBJC },
543};
544
545const unsigned int num_c_common_reswords =
546 sizeof c_common_reswords / sizeof (struct c_common_resword);
547
349ae713
NB		 548/* Table of machine-independent attributes common to all C-like languages. */
549const struct attribute_spec c_common_attribute_table[] =
550{
551 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
552 { "packed", 0, 0, false, false, false,
35b1a6fa 553 handle_packed_attribute },
349ae713
NB		 554 { "nocommon", 0, 0, true, false, false,
555 handle_nocommon_attribute },
556 { "common", 0, 0, true, false, false,
557 handle_common_attribute },
558 /* FIXME: logically, noreturn attributes should be listed as
559 "false, true, true" and apply to function types. But implementing this
560 would require all the places in the compiler that use TREE_THIS_VOLATILE
561 on a decl to identify non-returning functions to be located and fixed
562 to check the function type instead. */
563 { "noreturn", 0, 0, true, false, false,
564 handle_noreturn_attribute },
565 { "volatile", 0, 0, true, false, false,
566 handle_noreturn_attribute },
567 { "noinline", 0, 0, true, false, false,
568 handle_noinline_attribute },
86631ea3
MJ		 569 { "noclone", 0, 0, true, false, false,
570 handle_noclone_attribute },
349ae713
NB		 571 { "always_inline", 0, 0, true, false, false,
572 handle_always_inline_attribute },
4eb7fd83
JJ		 573 { "gnu_inline", 0, 0, true, false, false,
574 handle_gnu_inline_attribute },
d752cfdb
JJ		 575 { "artificial", 0, 0, true, false, false,
576 handle_artificial_attribute },
0691d1d4 577 { "flatten", 0, 0, true, false, false,
c22cacf3 578 handle_flatten_attribute },
349ae713
NB		 579 { "used", 0, 0, true, false, false,
580 handle_used_attribute },
581 { "unused", 0, 0, false, false, false,
582 handle_unused_attribute },
ce91e74c
JH		 583 { "externally_visible", 0, 0, true, false, false,
584 handle_externally_visible_attribute },
349ae713
NB		 585 /* The same comments as for noreturn attributes apply to const ones. */
586 { "const", 0, 0, true, false, false,
587 handle_const_attribute },
588 { "transparent_union", 0, 0, false, false, false,
589 handle_transparent_union_attribute },
fc8600f9 590 { "constructor", 0, 1, true, false, false,
349ae713 591 handle_constructor_attribute },
fc8600f9 592 { "destructor", 0, 1, true, false, false,
349ae713
NB		 593 handle_destructor_attribute },
594 { "mode", 1, 1, false, true, false,
595 handle_mode_attribute },
596 { "section", 1, 1, true, false, false,
597 handle_section_attribute },
598 { "aligned", 0, 1, false, false, false,
599 handle_aligned_attribute },
600 { "weak", 0, 0, true, false, false,
601 handle_weak_attribute },
602 { "alias", 1, 1, true, false, false,
603 handle_alias_attribute },
a0203ca7
AO		 604 { "weakref", 0, 1, true, false, false,
605 handle_weakref_attribute },
349ae713
NB		 606 { "no_instrument_function", 0, 0, true, false, false,
607 handle_no_instrument_function_attribute },
608 { "malloc", 0, 0, true, false, false,
609 handle_malloc_attribute },
6e9a3221
AN		 610 { "returns_twice", 0, 0, true, false, false,
611 handle_returns_twice_attribute },
349ae713
NB		 612 { "no_stack_limit", 0, 0, true, false, false,
613 handle_no_limit_stack_attribute },
614 { "pure", 0, 0, true, false, false,
615 handle_pure_attribute },
dcd6de6d
ZD		 616 /* For internal use (marking of builtins) only. The name contains space
617 to prevent its usage in source code. */
618 { "no vops", 0, 0, true, false, false,
619 handle_novops_attribute },
9b86d6bb 620 { "deprecated", 0, 1, false, false, false,
349ae713
NB		 621 handle_deprecated_attribute },
622 { "vector_size", 1, 1, false, true, false,
623 handle_vector_size_attribute },
d7afec4b 624 { "visibility", 1, 1, false, false, false,
349ae713 625 handle_visibility_attribute },
dce81a1a
JJ		 626 { "tls_model", 1, 1, true, false, false,
627 handle_tls_model_attribute },
b34c7881
JT		 628 { "nonnull", 0, -1, false, true, true,
629 handle_nonnull_attribute },
39f2f3c8
RS		 630 { "nothrow", 0, 0, true, false, false,
631 handle_nothrow_attribute },
d18b1ed8 632 { "may_alias", 0, 0, false, true, false, NULL },
0bfa5f65
RH		 633 { "cleanup", 1, 1, true, false, false,
634 handle_cleanup_attribute },
72954a4f
JM		 635 { "warn_unused_result", 0, 0, false, true, true,
636 handle_warn_unused_result_attribute },
254986c7 637 { "sentinel", 0, 1, false, true, true,
3d091dac 638 handle_sentinel_attribute },
b5d32c25
KG		 639 /* For internal use (marking of builtins) only. The name contains space
640 to prevent its usage in source code. */
641 { "type generic", 0, 0, false, true, true,
642 handle_type_generic_attribute },
51bc54a6
DM		 643 { "alloc_size", 1, 2, false, true, true,
644 handle_alloc_size_attribute },
52bf96d2
JH		 645 { "cold", 0, 0, true, false, false,
646 handle_cold_attribute },
647 { "hot", 0, 0, true, false, false,
648 handle_hot_attribute },
d2af6a68
JJ		 649 { "warning", 1, 1, true, false, false,
650 handle_error_attribute },
651 { "error", 1, 1, true, false, false,
652 handle_error_attribute },
5779e713
MM		 653 { "target", 1, -1, true, false, false,
654 handle_target_attribute },
ab442df7
MM		 655 { "optimize", 1, -1, true, false, false,
656 handle_optimize_attribute },
0b7b376d
RG		 657 /* For internal use (marking of builtins and runtime functions) only.
658 The name contains space to prevent its usage in source code. */
659 { "fn spec", 1, 1, false, true, true,
660 handle_fnspec_attribute },
349ae713
NB		 661 { NULL, 0, 0, false, false, false, NULL }
662};
663
664/* Give the specifications for the format attributes, used by C and all
95bd1dd7 665 descendants. */
349ae713
NB		 666
667const struct attribute_spec c_common_format_attribute_table[] =
668{
669 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
670 { "format", 3, 3, false, true, true,
671 handle_format_attribute },
672 { "format_arg", 1, 1, false, true, true,
673 handle_format_arg_attribute },
674 { NULL, 0, 0, false, false, false, NULL }
675};
676
36c5e70a 677/* Return identifier for address space AS. */
3ef0694c 678
36c5e70a
BE		 679const char *
680c_addr_space_name (addr_space_t as)
681{
3ef0694c
UW		 682 int rid = RID_FIRST_ADDR_SPACE + as;
683 gcc_assert (ridpointers [rid]);
684 return IDENTIFIER_POINTER (ridpointers [rid]);
36c5e70a
BE		 685}
686
ec5c56db 687/* Push current bindings for the function name VAR_DECLS. */
7da551a2
RS		 688
689void
35b1a6fa 690start_fname_decls (void)
7da551a2 691{
0ba8a114
NS		 692 unsigned ix;
693 tree saved = NULL_TREE;
35b1a6fa 694
0ba8a114
NS		 695 for (ix = 0; fname_vars[ix].decl; ix++)
696 {
697 tree decl = *fname_vars[ix].decl;
7da551a2 698
0ba8a114
NS		 699 if (decl)
700 {
7d60be94 701 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
0ba8a114
NS		 702 *fname_vars[ix].decl = NULL_TREE;
703 }
704 }
705 if (saved || saved_function_name_decls)
706 /* Normally they'll have been NULL, so only push if we've got a
707 stack, or they are non-NULL. */
708 saved_function_name_decls = tree_cons (saved, NULL_TREE,
709 saved_function_name_decls);
710}
711
325c3691
RH		 712/* Finish up the current bindings, adding them into the current function's
713 statement tree. This must be done _before_ finish_stmt_tree is called.
714 If there is no current function, we must be at file scope and no statements
715 are involved. Pop the previous bindings. */
0ba8a114
NS		 716
717void
35b1a6fa 718finish_fname_decls (void)
0ba8a114
NS		 719{
720 unsigned ix;
325c3691 721 tree stmts = NULL_TREE;
0ba8a114
NS		 722 tree stack = saved_function_name_decls;
723
724 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
325c3691 725 append_to_statement_list (TREE_VALUE (stack), &stmts);
35b1a6fa 726
325c3691 727 if (stmts)
0ba8a114 728 {
325c3691 729 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
bfaba7a9 730
325c3691
RH		 731 if (TREE_CODE (*bodyp) == BIND_EXPR)
732 bodyp = &BIND_EXPR_BODY (*bodyp);
6cce57b0 733
86ad3aa9 734 append_to_statement_list_force (*bodyp, &stmts);
325c3691 735 *bodyp = stmts;
0ba8a114 736 }
35b1a6fa 737
0ba8a114
NS		 738 for (ix = 0; fname_vars[ix].decl; ix++)
739 *fname_vars[ix].decl = NULL_TREE;
35b1a6fa 740
0ba8a114 741 if (stack)
7da551a2 742 {
ec5c56db 743 /* We had saved values, restore them. */
0ba8a114
NS		 744 tree saved;
745
746 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
747 {
748 tree decl = TREE_PURPOSE (saved);
749 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
35b1a6fa 750
0ba8a114
NS		 751 *fname_vars[ix].decl = decl;
752 }
753 stack = TREE_CHAIN (stack);
7da551a2 754 }
0ba8a114
NS		 755 saved_function_name_decls = stack;
756}
757
6cce57b0 758/* Return the text name of the current function, suitably prettified
0d0bc036 759 by PRETTY_P. Return string must be freed by caller. */
0ba8a114
NS		 760
761const char *
35b1a6fa 762fname_as_string (int pretty_p)
0ba8a114 763{
47ab33b2 764 const char *name = "top level";
0d0bc036 765 char *namep;
46c2514e
TT		 766 int vrb = 2, len;
767 cpp_string cstr = { 0, 0 }, strname;
47ab33b2 768
3f75a254 769 if (!pretty_p)
47ab33b2
MA		 770 {
771 name = "";
772 vrb = 0;
773 }
774
775 if (current_function_decl)
ae2bcd98 776 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
47ab33b2 777
46c2514e 778 len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
0d0bc036 779
46c2514e
TT		 780 namep = XNEWVEC (char, len);
781 snprintf (namep, len, "\"%s\"", name);
782 strname.text = (unsigned char *) namep;
783 strname.len = len - 1;
0d0bc036 784
b6baa67d 785 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
46c2514e
TT		 786 {
787 XDELETEVEC (namep);
788 return (const char *) cstr.text;
0d0bc036 789 }
0d0bc036
AH		 790
791 return namep;
0ba8a114
NS		 792}
793
0ba8a114
NS		 794/* Return the VAR_DECL for a const char array naming the current
795 function. If the VAR_DECL has not yet been created, create it
796 now. RID indicates how it should be formatted and IDENTIFIER_NODE
797 ID is its name (unfortunately C and C++ hold the RID values of
798 keywords in different places, so we can't derive RID from ID in
3ba09659
AH		 799 this language independent code. LOC is the location of the
800 function. */
0ba8a114
NS		 801
802tree
3ba09659 803fname_decl (location_t loc, unsigned int rid, tree id)
0ba8a114
NS		 804{
805 unsigned ix;
806 tree decl = NULL_TREE;
807
808 for (ix = 0; fname_vars[ix].decl; ix++)
809 if (fname_vars[ix].rid == rid)
810 break;
811
812 decl = *fname_vars[ix].decl;
813 if (!decl)
7da551a2 814 {
8d3e27d1
DJ		 815 /* If a tree is built here, it would normally have the lineno of
816 the current statement. Later this tree will be moved to the
817 beginning of the function and this line number will be wrong.
818 To avoid this problem set the lineno to 0 here; that prevents
4b7e68e7 819 it from appearing in the RTL. */
325c3691 820 tree stmts;
3c20847b 821 location_t saved_location = input_location;
3c20847b 822 input_location = UNKNOWN_LOCATION;
35b1a6fa 823
325c3691 824 stmts = push_stmt_list ();
c2255bc4 825 decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
325c3691
RH		 826 stmts = pop_stmt_list (stmts);
827 if (!IS_EMPTY_STMT (stmts))
828 saved_function_name_decls
829 = tree_cons (decl, stmts, saved_function_name_decls);
0ba8a114 830 *fname_vars[ix].decl = decl;
3c20847b 831 input_location = saved_location;
7da551a2 832 }
0ba8a114 833 if (!ix && !current_function_decl)
3ba09659 834 pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
6cce57b0 835
0ba8a114 836 return decl;
7da551a2
RS		 837}
838
b84a3874 839/* Given a STRING_CST, give it a suitable array-of-chars data type. */
b30f223b
RS		 840
841tree
35b1a6fa 842fix_string_type (tree value)
b30f223b 843{
b84a3874
RH		 844 int length = TREE_STRING_LENGTH (value);
845 int nchars;
c162c75e
MA		 846 tree e_type, i_type, a_type;
847
b57062ca 848 /* Compute the number of elements, for the array type. */
b6baa67d
KVH		 849 if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
850 {
851 nchars = length;
852 e_type = char_type_node;
853 }
854 else if (TREE_TYPE (value) == char16_array_type_node)
855 {
856 nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
857 e_type = char16_type_node;
858 }
859 else if (TREE_TYPE (value) == char32_array_type_node)
860 {
861 nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
862 e_type = char32_type_node;
863 }
864 else
865 {
866 nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
867 e_type = wchar_type_node;
868 }
b30f223b 869
89a42ac8
ZW		 870 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
871 limit in C++98 Annex B is very large (65536) and is not normative,
872 so we do not diagnose it (warn_overlength_strings is forced off
873 in c_common_post_options). */
874 if (warn_overlength_strings)
875 {
876 const int nchars_max = flag_isoc99 ? 4095 : 509;
877 const int relevant_std = flag_isoc99 ? 99 : 90;
878 if (nchars - 1 > nchars_max)
879 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
880 separate the %d from the 'C'. 'ISO' should not be
881 translated, but it may be moved after 'C%d' in languages
882 where modifiers follow nouns. */
509c9d60 883 pedwarn (input_location, OPT_Woverlength_strings,
fcf73884 884 "string length %qd is greater than the length %qd "
89a42ac8
ZW		 885 "ISO C%d compilers are required to support",
886 nchars - 1, nchars_max, relevant_std);
887 }
1326a48b 888
cfb10bd3
GDR		 889 /* Create the array type for the string constant. The ISO C++
890 standard says that a string literal has type `const char[N]' or
891 `const wchar_t[N]'. We use the same logic when invoked as a C
892 front-end with -Wwrite-strings.
893 ??? We should change the type of an expression depending on the
894 state of a warning flag. We should just be warning -- see how
895 this is handled in the C++ front-end for the deprecated implicit
896 conversion from string literals to `char*' or `wchar_t*'.
c162c75e
MA		 897
898 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
899 array type being the unqualified version of that type.
900 Therefore, if we are constructing an array of const char, we must
901 construct the matching unqualified array type first. The C front
902 end does not require this, but it does no harm, so we do it
903 unconditionally. */
7d60be94 904 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
c162c75e 905 a_type = build_array_type (e_type, i_type);
cfb10bd3 906 if (c_dialect_cxx() || warn_write_strings)
46df2823 907 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
d9cf7c82 908
c162c75e 909 TREE_TYPE (value) = a_type;
ccd4c832 910 TREE_CONSTANT (value) = 1;
3521b33c 911 TREE_READONLY (value) = 1;
b30f223b
RS		 912 TREE_STATIC (value) = 1;
913 return value;
914}
915\f
928c19bb
JM		 916/* Fully fold EXPR, an expression that was not folded (beyond integer
917 constant expressions and null pointer constants) when being built
918 up. If IN_INIT, this is in a static initializer and certain
919 changes are made to the folding done. Clear *MAYBE_CONST if
920 MAYBE_CONST is not NULL and EXPR is definitely not a constant
921 expression because it contains an evaluated operator (in C99) or an
922 operator outside of sizeof returning an integer constant (in C90)
923 not permitted in constant expressions, or because it contains an
924 evaluated arithmetic overflow. (*MAYBE_CONST should typically be
925 set to true by callers before calling this function.) Return the
926 folded expression. Function arguments have already been folded
927 before calling this function, as have the contents of SAVE_EXPR,
928 TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
929 C_MAYBE_CONST_EXPR. */
930
931tree
932c_fully_fold (tree expr, bool in_init, bool *maybe_const)
933{
934 tree ret;
8ce94e44 935 tree eptype = NULL_TREE;
928c19bb
JM		 936 bool dummy = true;
937 bool maybe_const_itself = true;
db3927fb 938 location_t loc = EXPR_LOCATION (expr);
928c19bb
JM		 939
940 /* This function is not relevant to C++ because C++ folds while
941 parsing, and may need changes to be correct for C++ when C++
942 stops folding while parsing. */
943 if (c_dialect_cxx ())
944 gcc_unreachable ();
945
946 if (!maybe_const)
947 maybe_const = &dummy;
8ce94e44
JM		 948 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
949 {
950 eptype = TREE_TYPE (expr);
951 expr = TREE_OPERAND (expr, 0);
952 }
928c19bb
JM		 953 ret = c_fully_fold_internal (expr, in_init, maybe_const,
954 &maybe_const_itself);
8ce94e44 955 if (eptype)
db3927fb 956 ret = fold_convert_loc (loc, eptype, ret);
928c19bb
JM		 957 *maybe_const &= maybe_const_itself;
958 return ret;
959}
960
961/* Internal helper for c_fully_fold. EXPR and IN_INIT are as for
962 c_fully_fold. *MAYBE_CONST_OPERANDS is cleared because of operands
963 not permitted, while *MAYBE_CONST_ITSELF is cleared because of
964 arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
965 both evaluated and unevaluated subexpressions while
966 *MAYBE_CONST_ITSELF is carried from only evaluated
967 subexpressions). */
968
969static tree
970c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
971 bool *maybe_const_itself)
972{
973 tree ret = expr;
974 enum tree_code code = TREE_CODE (expr);
975 enum tree_code_class kind = TREE_CODE_CLASS (code);
976 location_t loc = EXPR_LOCATION (expr);
977 tree op0, op1, op2, op3;
978 tree orig_op0, orig_op1, orig_op2;
979 bool op0_const = true, op1_const = true, op2_const = true;
980 bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
981 bool nowarning = TREE_NO_WARNING (expr);
f5178456 982 int unused_p;
928c19bb
JM		 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 /* Constants, declarations, statements, errors, SAVE_EXPRs and
991 anything else not counted as an expression cannot usefully be
992 folded further at this point. */
993 if (!IS_EXPR_CODE_CLASS (kind)
994 || kind == tcc_statement
995 || code == SAVE_EXPR)
996 return expr;
997
998 /* Operands of variable-length expressions (function calls) have
999 already been folded, as have __builtin_* function calls, and such
1000 expressions cannot occur in constant expressions. */
1001 if (kind == tcc_vl_exp)
1002 {
1003 *maybe_const_operands = false;
1004 ret = fold (expr);
1005 goto out;
1006 }
1007
1008 if (code == C_MAYBE_CONST_EXPR)
1009 {
1010 tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1011 tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1012 if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1013 *maybe_const_operands = false;
1014 if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1015 *maybe_const_itself = false;
1016 if (pre && !in_init)
1017 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1018 else
1019 ret = inner;
1020 goto out;
1021 }
1022
1023 /* Assignment, increment, decrement, function call and comma
1024 operators, and statement expressions, cannot occur in constant
1025 expressions if evaluated / outside of sizeof. (Function calls
1026 were handled above, though VA_ARG_EXPR is treated like a function
1027 call here, and statement expressions are handled through
1028 C_MAYBE_CONST_EXPR to avoid folding inside them.) */
1029 switch (code)
1030 {
1031 case MODIFY_EXPR:
1032 case PREDECREMENT_EXPR:
1033 case PREINCREMENT_EXPR:
1034 case POSTDECREMENT_EXPR:
1035 case POSTINCREMENT_EXPR:
1036 case COMPOUND_EXPR:
1037 *maybe_const_operands = false;
1038 break;
1039
1040 case VA_ARG_EXPR:
1041 case TARGET_EXPR:
1042 case BIND_EXPR:
1043 case OBJ_TYPE_REF:
1044 *maybe_const_operands = false;
1045 ret = fold (expr);
1046 goto out;
1047
1048 default:
1049 break;
1050 }
1051
1052 /* Fold individual tree codes as appropriate. */
1053 switch (code)
1054 {
1055 case COMPOUND_LITERAL_EXPR:
1056 /* Any non-constancy will have been marked in a containing
1057 C_MAYBE_CONST_EXPR; there is no more folding to do here. */
1058 goto out;
1059
1060 case COMPONENT_REF:
1061 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1062 op1 = TREE_OPERAND (expr, 1);
1063 op2 = TREE_OPERAND (expr, 2);
1064 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1065 maybe_const_itself);
e5a94231 1066 STRIP_TYPE_NOPS (op0);
928c19bb
JM		 1067 if (op0 != orig_op0)
1068 ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1069 if (ret != expr)
1070 {
1071 TREE_READONLY (ret) = TREE_READONLY (expr);
1072 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1073 }
1074 goto out;
1075
1076 case ARRAY_REF:
1077 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1078 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1079 op2 = TREE_OPERAND (expr, 2);
1080 op3 = TREE_OPERAND (expr, 3);
1081 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1082 maybe_const_itself);
e5a94231 1083 STRIP_TYPE_NOPS (op0);
928c19bb
JM		 1084 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1085 maybe_const_itself);
e5a94231 1086 STRIP_TYPE_NOPS (op1);
928c19bb
JM		 1087 op1 = decl_constant_value_for_optimization (op1);
1088 if (op0 != orig_op0 || op1 != orig_op1)
1089 ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1090 if (ret != expr)
1091 {
1092 TREE_READONLY (ret) = TREE_READONLY (expr);
1093 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1094 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1095 }
1096 ret = fold (ret);
1097 goto out;
1098
1099 case COMPOUND_EXPR:
1100 case MODIFY_EXPR:
1101 case PREDECREMENT_EXPR:
1102 case PREINCREMENT_EXPR:
1103 case POSTDECREMENT_EXPR:
1104 case POSTINCREMENT_EXPR:
1105 case PLUS_EXPR:
1106 case MINUS_EXPR:
1107 case MULT_EXPR:
1108 case POINTER_PLUS_EXPR:
1109 case TRUNC_DIV_EXPR:
1110 case CEIL_DIV_EXPR:
1111 case FLOOR_DIV_EXPR:
1112 case TRUNC_MOD_EXPR:
1113 case RDIV_EXPR:
1114 case EXACT_DIV_EXPR:
1115 case LSHIFT_EXPR:
1116 case RSHIFT_EXPR:
1117 case BIT_IOR_EXPR:
1118 case BIT_XOR_EXPR:
1119 case BIT_AND_EXPR:
1120 case LT_EXPR:
1121 case LE_EXPR:
1122 case GT_EXPR:
1123 case GE_EXPR:
1124 case EQ_EXPR:
1125 case NE_EXPR:
1126 case COMPLEX_EXPR:
1127 case TRUTH_AND_EXPR:
1128 case TRUTH_OR_EXPR:
1129 case TRUTH_XOR_EXPR:
1130 case UNORDERED_EXPR:
1131 case ORDERED_EXPR:
1132 case UNLT_EXPR:
1133 case UNLE_EXPR:
1134 case UNGT_EXPR:
1135 case UNGE_EXPR:
1136 case UNEQ_EXPR:
1137 /* Binary operations evaluating both arguments (increment and
1138 decrement are binary internally in GCC). */
1139 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1140 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1141 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1142 maybe_const_itself);
e5a94231 1143 STRIP_TYPE_NOPS (op0);
928c19bb
JM		 1144 if (code != MODIFY_EXPR
1145 && code != PREDECREMENT_EXPR
1146 && code != PREINCREMENT_EXPR
1147 && code != POSTDECREMENT_EXPR
1148 && code != POSTINCREMENT_EXPR)
1149 op0 = decl_constant_value_for_optimization (op0);
1150 /* The RHS of a MODIFY_EXPR was fully folded when building that
1151 expression for the sake of conversion warnings. */
1152 if (code != MODIFY_EXPR)
1153 op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1154 maybe_const_itself);
e5a94231 1155 STRIP_TYPE_NOPS (op1);
928c19bb
JM		 1156 op1 = decl_constant_value_for_optimization (op1);
1157 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1158 ret = in_init
db3927fb
AH		 1159 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1160 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
928c19bb
JM		 1161 else
1162 ret = fold (expr);
f5178456
RS		 1163 if (TREE_OVERFLOW_P (ret)
1164 && !TREE_OVERFLOW_P (op0)
1165 && !TREE_OVERFLOW_P (op1))
1166 overflow_warning (EXPR_LOCATION (expr), ret);
928c19bb
JM		 1167 goto out;
1168
1169 case INDIRECT_REF:
1170 case FIX_TRUNC_EXPR:
1171 case FLOAT_EXPR:
1172 CASE_CONVERT:
1173 case NON_LVALUE_EXPR:
1174 case NEGATE_EXPR:
1175 case BIT_NOT_EXPR:
1176 case TRUTH_NOT_EXPR:
1177 case ADDR_EXPR:
1178 case CONJ_EXPR:
1179 case REALPART_EXPR:
1180 case IMAGPART_EXPR:
1181 /* Unary operations. */
1182 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1183 op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1184 maybe_const_itself);
e5a94231 1185 STRIP_TYPE_NOPS (op0);
928c19bb
JM		 1186 if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1187 op0 = decl_constant_value_for_optimization (op0);
1188 if (op0 != orig_op0 || in_init)
1189 ret = in_init
db3927fb
AH		 1190 ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1191 : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
928c19bb
JM		 1192 else
1193 ret = fold (expr);
1194 if (code == INDIRECT_REF
1195 && ret != expr
1196 && TREE_CODE (ret) == INDIRECT_REF)
1197 {
1198 TREE_READONLY (ret) = TREE_READONLY (expr);
1199 TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1200 TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1201 }
f5178456
RS		 1202 switch (code)
1203 {
1204 case FIX_TRUNC_EXPR:
1205 case FLOAT_EXPR:
1206 CASE_CONVERT:
1207 /* Don't warn about explicit conversions. We will already
1208 have warned about suspect implicit conversions. */
1209 break;
1210
1211 default:
1212 if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1213 overflow_warning (EXPR_LOCATION (expr), ret);
1214 break;
1215 }
928c19bb
JM		 1216 goto out;
1217
1218 case TRUTH_ANDIF_EXPR:
1219 case TRUTH_ORIF_EXPR:
1220 /* Binary operations not necessarily evaluating both
1221 arguments. */
1222 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1223 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1224 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
e5a94231 1225 STRIP_TYPE_NOPS (op0);
f5178456
RS		 1226
1227 unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1228 ? truthvalue_false_node
1229 : truthvalue_true_node));
1230 c_inhibit_evaluation_warnings += unused_p;
928c19bb 1231 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
e5a94231 1232 STRIP_TYPE_NOPS (op1);
f5178456
RS		 1233 c_inhibit_evaluation_warnings -= unused_p;
1234
928c19bb
JM		 1235 if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1236 ret = in_init
db3927fb
AH		 1237 ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1238 : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
928c19bb
JM		 1239 else
1240 ret = fold (expr);
1241 *maybe_const_operands &= op0_const;
1242 *maybe_const_itself &= op0_const_self;
1243 if (!(flag_isoc99
1244 && op0_const
1245 && op0_const_self
1246 && (code == TRUTH_ANDIF_EXPR
1247 ? op0 == truthvalue_false_node
1248 : op0 == truthvalue_true_node)))
1249 *maybe_const_operands &= op1_const;
1250 if (!(op0_const
1251 && op0_const_self
1252 && (code == TRUTH_ANDIF_EXPR
1253 ? op0 == truthvalue_false_node
1254 : op0 == truthvalue_true_node)))
1255 *maybe_const_itself &= op1_const_self;
1256 goto out;
1257
1258 case COND_EXPR:
1259 orig_op0 = op0 = TREE_OPERAND (expr, 0);
1260 orig_op1 = op1 = TREE_OPERAND (expr, 1);
1261 orig_op2 = op2 = TREE_OPERAND (expr, 2);
1262 op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
f5178456 1263
e5a94231 1264 STRIP_TYPE_NOPS (op0);
f5178456 1265 c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
928c19bb 1266 op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
e5a94231 1267 STRIP_TYPE_NOPS (op1);
f5178456
RS		 1268 c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1269
1270 c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
928c19bb 1271 op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
e5a94231 1272 STRIP_TYPE_NOPS (op2);
f5178456
RS		 1273 c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1274
928c19bb 1275 if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
db3927fb 1276 ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
928c19bb
JM		 1277 else
1278 ret = fold (expr);
1279 *maybe_const_operands &= op0_const;
1280 *maybe_const_itself &= op0_const_self;
1281 if (!(flag_isoc99
1282 && op0_const
1283 && op0_const_self
1284 && op0 == truthvalue_false_node))
1285 *maybe_const_operands &= op1_const;
1286 if (!(op0_const
1287 && op0_const_self
1288 && op0 == truthvalue_false_node))
1289 *maybe_const_itself &= op1_const_self;
1290 if (!(flag_isoc99
1291 && op0_const
1292 && op0_const_self
1293 && op0 == truthvalue_true_node))
1294 *maybe_const_operands &= op2_const;
1295 if (!(op0_const
1296 && op0_const_self
1297 && op0 == truthvalue_true_node))
1298 *maybe_const_itself &= op2_const_self;
1299 goto out;
1300
8ce94e44
JM		 1301 case EXCESS_PRECISION_EXPR:
1302 /* Each case where an operand with excess precision may be
1303 encountered must remove the EXCESS_PRECISION_EXPR around
1304 inner operands and possibly put one around the whole
1305 expression or possibly convert to the semantic type (which
1306 c_fully_fold does); we cannot tell at this stage which is
1307 appropriate in any particular case. */
1308 gcc_unreachable ();
1309
928c19bb
JM		 1310 default:
1311 /* Various codes may appear through folding built-in functions
1312 and their arguments. */
1313 goto out;
1314 }
1315
1316 out:
1317 /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1318 have been done by this point, so remove them again. */
1319 nowarning |= TREE_NO_WARNING (ret);
1320 STRIP_TYPE_NOPS (ret);
1321 if (nowarning && !TREE_NO_WARNING (ret))
1322 {
1323 if (!CAN_HAVE_LOCATION_P (ret))
1324 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1325 TREE_NO_WARNING (ret) = 1;
1326 }
1327 if (ret != expr)
1328 protected_set_expr_location (ret, loc);
1329 return ret;
1330}
1331
1332/* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1333 return EXP. Otherwise, return either EXP or its known constant
1334 value (if it has one), but return EXP if EXP has mode BLKmode. ???
1335 Is the BLKmode test appropriate? */
1336
1337tree
1338decl_constant_value_for_optimization (tree exp)
1339{
1340 tree ret;
1341
1342 /* This function is only used by C, for c_fully_fold and other
1343 optimization, and may not be correct for C++. */
1344 if (c_dialect_cxx ())
1345 gcc_unreachable ();
1346
1347 if (!optimize
1348 || TREE_CODE (exp) != VAR_DECL
1349 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1350 || DECL_MODE (exp) == BLKmode)
1351 return exp;
1352
1353 ret = decl_constant_value (exp);
1354 /* Avoid unwanted tree sharing between the initializer and current
1355 function's body where the tree can be modified e.g. by the
1356 gimplifier. */
1357 if (ret != exp && TREE_STATIC (exp))
1358 ret = unshare_expr (ret);
1359 return ret;
1360}
1361
d74154d5
RS		 1362/* Print a warning if a constant expression had overflow in folding.
1363 Invoke this function on every expression that the language
1364 requires to be a constant expression.
1365 Note the ANSI C standard says it is erroneous for a
1366 constant expression to overflow. */
96571883
BK		 1367
1368void
35b1a6fa 1369constant_expression_warning (tree value)
393eda6a 1370{
b8698a0f 1371 if (warn_overflow && pedantic
393eda6a
MLI		 1372 && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1373 || TREE_CODE (value) == FIXED_CST
1374 || TREE_CODE (value) == VECTOR_CST
1375 || TREE_CODE (value) == COMPLEX_CST)
1376 && TREE_OVERFLOW (value))
509c9d60 1377 pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
393eda6a
MLI		 1378}
1379
1380/* The same as above but print an unconditional error. */
1381void
1382constant_expression_error (tree value)
96571883 1383{
c05f751c 1384 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
ab22c1fa 1385 || TREE_CODE (value) == FIXED_CST
69ef87e2 1386 || TREE_CODE (value) == VECTOR_CST
c05f751c 1387 || TREE_CODE (value) == COMPLEX_CST)
393eda6a
MLI		 1388 && TREE_OVERFLOW (value))
1389 error ("overflow in constant expression");
d74154d5
RS		 1390}
1391
59c0753d
MLI		 1392/* Print a warning if an expression had overflow in folding and its
1393 operands hadn't.
1394
d74154d5
RS		 1395 Invoke this function on every expression that
1396 (1) appears in the source code, and
59c0753d 1397 (2) is a constant expression that overflowed, and
d74154d5 1398 (3) is not already checked by convert_and_check;
59c0753d
MLI		 1399 however, do not invoke this function on operands of explicit casts
1400 or when the expression is the result of an operator and any operand
1401 already overflowed. */
d74154d5
RS		 1402
1403void
c2255bc4 1404overflow_warning (location_t loc, tree value)
d74154d5 1405{
7d882b83
ILT		 1406 if (c_inhibit_evaluation_warnings != 0)
1407 return;
59c0753d
MLI		 1408
1409 switch (TREE_CODE (value))
69ef87e2 1410 {
59c0753d 1411 case INTEGER_CST:
c2255bc4 1412 warning_at (loc, OPT_Woverflow, "integer overflow in expression");
59c0753d 1413 break;
b8698a0f 1414
59c0753d 1415 case REAL_CST:
c2255bc4
AH		 1416 warning_at (loc, OPT_Woverflow,
1417 "floating point overflow in expression");
59c0753d 1418 break;
b8698a0f 1419
ab22c1fa 1420 case FIXED_CST:
c2255bc4 1421 warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
ab22c1fa
CF		 1422 break;
1423
59c0753d 1424 case VECTOR_CST:
c2255bc4 1425 warning_at (loc, OPT_Woverflow, "vector overflow in expression");
59c0753d 1426 break;
b8698a0f 1427
59c0753d
MLI		 1428 case COMPLEX_CST:
1429 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
c2255bc4
AH		 1430 warning_at (loc, OPT_Woverflow,
1431 "complex integer overflow in expression");
59c0753d 1432 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
c2255bc4
AH		 1433 warning_at (loc, OPT_Woverflow,
1434 "complex floating point overflow in expression");
59c0753d
MLI		 1435 break;
1436
1437 default:
1438 break;
69ef87e2 1439 }
d74154d5
RS		 1440}
1441
ca409efd
MLI		 1442/* Warn about uses of logical || / && operator in a context where it
1443 is likely that the bitwise equivalent was intended by the
1444 programmer. We have seen an expression in which CODE is a binary
a243fb4a
MLI		 1445 operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1446 had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE. */
63a08740 1447void
a243fb4a 1448warn_logical_operator (location_t location, enum tree_code code, tree type,
b8698a0f 1449 enum tree_code code_left, tree op_left,
ca409efd 1450 enum tree_code ARG_UNUSED (code_right), tree op_right)
63a08740 1451{
a243fb4a
MLI		 1452 int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1453 int in0_p, in1_p, in_p;
1454 tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1455 bool strict_overflow_p = false;
1456
ca409efd
MLI		 1457 if (code != TRUTH_ANDIF_EXPR
1458 && code != TRUTH_AND_EXPR
1459 && code != TRUTH_ORIF_EXPR
1460 && code != TRUTH_OR_EXPR)
1461 return;
1462
1463 /* Warn if &&/|| are being used in a context where it is
1464 likely that the bitwise equivalent was intended by the
1465 programmer. That is, an expression such as op && MASK
1466 where op should not be any boolean expression, nor a
1467 constant, and mask seems to be a non-boolean integer constant. */
1468 if (!truth_value_p (code_left)
1469 && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1470 && !CONSTANT_CLASS_P (op_left)
1471 && !TREE_NO_WARNING (op_left)
1472 && TREE_CODE (op_right) == INTEGER_CST
1473 && !integer_zerop (op_right)
1474 && !integer_onep (op_right))
63a08740 1475 {
a243fb4a 1476 if (or_op)
ca409efd
MLI		 1477 warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1478 " applied to non-boolean constant");
1479 else
1480 warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1481 " applied to non-boolean constant");
1482 TREE_NO_WARNING (op_left) = true;
a243fb4a
MLI		 1483 return;
1484 }
1485
1486 /* We do not warn for constants because they are typical of macro
1487 expansions that test for features. */
1488 if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1489 return;
1490
1491 /* This warning only makes sense with logical operands. */
1492 if (!(truth_value_p (TREE_CODE (op_left))
1493 || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1494 || !(truth_value_p (TREE_CODE (op_right))
1495 || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1496 return;
1497
1498 lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1499 rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1500
1501 if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1502 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1503
1504 if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1505 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
b8698a0f 1506
a243fb4a
MLI		 1507 /* If this is an OR operation, invert both sides; we will invert
1508 again at the end. */
1509 if (or_op)
1510 in0_p = !in0_p, in1_p = !in1_p;
b8698a0f 1511
a243fb4a 1512 /* If both expressions are the same, if we can merge the ranges, and we
ae8af500
L		 1513 can build the range test, return it or it inverted. */
1514 if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
a243fb4a
MLI		 1515 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1516 in1_p, low1, high1)
db3927fb
AH		 1517 && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1518 type, lhs, in_p, low, high)))
a243fb4a
MLI		 1519 {
1520 if (TREE_CODE (tem) != INTEGER_CST)
1521 return;
1522
1523 if (or_op)
1524 warning_at (location, OPT_Wlogical_op,
1525 "logical %<or%> "
1526 "of collectively exhaustive tests is always true");
1527 else
1528 warning_at (location, OPT_Wlogical_op,
1529 "logical %<and%> "
1530 "of mutually exclusive tests is always false");
63a08740
DM		 1531 }
1532}
1533
1534
de9c56a4
RG		 1535/* Print a warning about casts that might indicate violation
1536 of strict aliasing rules if -Wstrict-aliasing is used and
3f0a2a47
DM		 1537 strict aliasing mode is in effect. OTYPE is the original
1538 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
de9c56a4 1539
79bedddc 1540bool
3f0a2a47 1541strict_aliasing_warning (tree otype, tree type, tree expr)
de9c56a4 1542{
255d3827
RG		 1543 /* Strip pointer conversion chains and get to the correct original type. */
1544 STRIP_NOPS (expr);
1545 otype = TREE_TYPE (expr);
1546
ac7ee6ad
RG		 1547 if (!(flag_strict_aliasing
1548 && POINTER_TYPE_P (type)
1549 && POINTER_TYPE_P (otype)
1550 && !VOID_TYPE_P (TREE_TYPE (type)))
1551 /* If the type we are casting to is a ref-all pointer
1552 dereferencing it is always valid. */
1553 || TYPE_REF_CAN_ALIAS_ALL (type))
79bedddc
SR		 1554 return false;
1555
1556 if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
de9c56a4 1557 && (DECL_P (TREE_OPERAND (expr, 0))
79bedddc 1558 || handled_component_p (TREE_OPERAND (expr, 0))))
de9c56a4
RG		 1559 {
1560 /* Casting the address of an object to non void pointer. Warn
1561 if the cast breaks type based aliasing. */
79bedddc
SR		 1562 if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1563 {
1564 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1565 "might break strict-aliasing rules");
1566 return true;
1567 }
de9c56a4
RG		 1568 else
1569 {
b8698a0f 1570 /* warn_strict_aliasing >= 3. This includes the default (3).
79bedddc 1571 Only warn if the cast is dereferenced immediately. */
4862826d 1572 alias_set_type set1 =
79bedddc 1573 get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
4862826d 1574 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
de9c56a4 1575
4653cae5
RG		 1576 if (set1 != set2 && set2 != 0
1577 && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
79bedddc
SR		 1578 {
1579 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1580 "pointer will break strict-aliasing rules");
1581 return true;
1582 }
1583 else if (warn_strict_aliasing == 2
836f7794 1584 && !alias_sets_must_conflict_p (set1, set2))
79bedddc
SR		 1585 {
1586 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1587 "pointer might break strict-aliasing rules");
1588 return true;
1589 }
de9c56a4
RG		 1590 }
1591 }
79bedddc
SR		 1592 else
1593 if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1594 {
1595 /* At this level, warn for any conversions, even if an address is
1596 not taken in the same statement. This will likely produce many
1597 false positives, but could be useful to pinpoint problems that
1598 are not revealed at higher levels. */
4862826d
ILT		 1599 alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1600 alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1601 if (!COMPLETE_TYPE_P (type)
836f7794 1602 || !alias_sets_must_conflict_p (set1, set2))
79bedddc
SR		 1603 {
1604 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1605 "pointer might break strict-aliasing rules");
1606 return true;
1607 }
1608 }
1609
1610 return false;
de9c56a4
RG		 1611}
1612
a1e45ff0
DM		 1613/* Warn for unlikely, improbable, or stupid DECL declarations
1614 of `main'. */
1615
1616void
1617check_main_parameter_types (tree decl)
1618{
1619 tree args;
1620 int argct = 0;
1621
1622 for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1623 args = TREE_CHAIN (args))
1624 {
1625 tree type = args ? TREE_VALUE (args) : 0;
1626
d8e1d619 1627 if (type == void_type_node || type == error_mark_node )
a1e45ff0
DM		 1628 break;
1629
1630 ++argct;
1631 switch (argct)
1632 {
1633 case 1:
1634 if (TYPE_MAIN_VARIANT (type) != integer_type_node)
b8698a0f 1635 pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
4003301d 1636 decl);
a1e45ff0
DM		 1637 break;
1638
1639 case 2:
1640 if (TREE_CODE (type) != POINTER_TYPE
1641 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1642 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1643 != char_type_node))
509c9d60 1644 pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
4003301d 1645 decl);
a1e45ff0
DM		 1646 break;
1647
1648 case 3:
1649 if (TREE_CODE (type) != POINTER_TYPE
1650 || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1651 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1652 != char_type_node))
509c9d60 1653 pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
4003301d 1654 "%<char **%>", decl);
a1e45ff0
DM		 1655 break;
1656 }
1657 }
1658
1659 /* It is intentional that this message does not mention the third
1660 argument because it's only mentioned in an appendix of the
1661 standard. */
1662 if (argct > 0 && (argct < 2 || argct > 3))
509c9d60 1663 pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
a1e45ff0
DM		 1664}
1665
f83c7f63
DJ		 1666/* True if pointers to distinct types T1 and T2 can be converted to
1667 each other without an explicit cast. Only returns true for opaque
1668 vector types. */
1669bool
1670vector_targets_convertible_p (const_tree t1, const_tree t2)
1671{
1672 if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
b6fc2cdb 1673 && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
f83c7f63
DJ		 1674 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1675 return true;
1676
1677 return false;
1678}
1679
00c8e9f6
MS		 1680/* True if vector types T1 and T2 can be converted to each other
1681 without an explicit cast. If EMIT_LAX_NOTE is true, and T1 and T2
1682 can only be converted with -flax-vector-conversions yet that is not
1683 in effect, emit a note telling the user about that option if such
1684 a note has not previously been emitted. */
1685bool
58f9752a 1686vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
cc27e657 1687{
00c8e9f6 1688 static bool emitted_lax_note = false;
14e765da
JM		 1689 bool convertible_lax;
1690
b6fc2cdb 1691 if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
14e765da
JM		 1692 && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1693 return true;
1694
1695 convertible_lax =
1696 (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1697 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1698 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1699 && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1700 == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
00c8e9f6
MS		 1701
1702 if (!convertible_lax || flag_lax_vector_conversions)
1703 return convertible_lax;
1704
1705 if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
cf7bc668 1706 && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
00c8e9f6
MS		 1707 return true;
1708
1709 if (emit_lax_note && !emitted_lax_note)
1710 {
1711 emitted_lax_note = true;
1f5b3869 1712 inform (input_location, "use -flax-vector-conversions to permit "
00c8e9f6
MS		 1713 "conversions between vectors with differing "
1714 "element types or numbers of subparts");
1715 }
1716
1717 return false;
cc27e657
PB		 1718}
1719
6715192c
MLI		 1720/* This is a helper function of build_binary_op.
1721
1722 For certain operations if both args were extended from the same
1723 smaller type, do the arithmetic in that type and then extend.
1724
1725 BITWISE indicates a bitwise operation.
1726 For them, this optimization is safe only if
1727 both args are zero-extended or both are sign-extended.
1728 Otherwise, we might change the result.
1729 Eg, (short)-1 | (unsigned short)-1 is (int)-1
b8698a0f 1730 but calculated in (unsigned short) it would be (unsigned short)-1.
6715192c
MLI		 1731*/
1732tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1733{
1734 int unsigned0, unsigned1;
1735 tree arg0, arg1;
1736 int uns;
1737 tree type;
1738
1739 /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
1740 excessive narrowing when we call get_narrower below. For
1741 example, suppose that OP0 is of unsigned int extended
1742 from signed char and that RESULT_TYPE is long long int.
1743 If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1744 like
b8698a0f 1745
6715192c
MLI		 1746 (long long int) (unsigned int) signed_char
1747
1748 which get_narrower would narrow down to
b8698a0f 1749
6715192c 1750 (unsigned int) signed char
b8698a0f 1751
6715192c
MLI		 1752 If we do not cast OP0 first, get_narrower would return
1753 signed_char, which is inconsistent with the case of the
1754 explicit cast. */
1755 op0 = convert (result_type, op0);
1756 op1 = convert (result_type, op1);
1757
1758 arg0 = get_narrower (op0, &unsigned0);
1759 arg1 = get_narrower (op1, &unsigned1);
1760
1761 /* UNS is 1 if the operation to be done is an unsigned one. */
1762 uns = TYPE_UNSIGNED (result_type);
1763
1764 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1765 but it *requires* conversion to FINAL_TYPE. */
b8698a0f 1766
6715192c
MLI		 1767 if ((TYPE_PRECISION (TREE_TYPE (op0))
1768 == TYPE_PRECISION (TREE_TYPE (arg0)))
1769 && TREE_TYPE (op0) != result_type)
1770 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1771 if ((TYPE_PRECISION (TREE_TYPE (op1))
1772 == TYPE_PRECISION (TREE_TYPE (arg1)))
1773 && TREE_TYPE (op1) != result_type)
1774 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
b8698a0f 1775
6715192c 1776 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
b8698a0f 1777
6715192c
MLI		 1778 /* For bitwise operations, signedness of nominal type
1779 does not matter. Consider only how operands were extended. */
1780 if (bitwise)
1781 uns = unsigned0;
b8698a0f 1782
6715192c
MLI		 1783 /* Note that in all three cases below we refrain from optimizing
1784 an unsigned operation on sign-extended args.
1785 That would not be valid. */
b8698a0f 1786
6715192c
MLI		 1787 /* Both args variable: if both extended in same way
1788 from same width, do it in that width.
1789 Do it unsigned if args were zero-extended. */
1790 if ((TYPE_PRECISION (TREE_TYPE (arg0))
1791 < TYPE_PRECISION (result_type))
1792 && (TYPE_PRECISION (TREE_TYPE (arg1))
1793 == TYPE_PRECISION (TREE_TYPE (arg0)))
1794 && unsigned0 == unsigned1
1795 && (unsigned0 || !uns))
1796 return c_common_signed_or_unsigned_type
1797 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1798
1799 else if (TREE_CODE (arg0) == INTEGER_CST
1800 && (unsigned1 || !uns)
1801 && (TYPE_PRECISION (TREE_TYPE (arg1))
1802 < TYPE_PRECISION (result_type))
1803 && (type
1804 = c_common_signed_or_unsigned_type (unsigned1,
1805 TREE_TYPE (arg1)))
1806 && !POINTER_TYPE_P (type)
1807 && int_fits_type_p (arg0, type))
1808 return type;
1809
1810 else if (TREE_CODE (arg1) == INTEGER_CST
1811 && (unsigned0 || !uns)
1812 && (TYPE_PRECISION (TREE_TYPE (arg0))
1813 < TYPE_PRECISION (result_type))
1814 && (type
1815 = c_common_signed_or_unsigned_type (unsigned0,
1816 TREE_TYPE (arg0)))
1817 && !POINTER_TYPE_P (type)
1818 && int_fits_type_p (arg1, type))
1819 return type;
1820
1821 return result_type;
1822}
1823
422c3a54 1824/* Warns if the conversion of EXPR to TYPE may alter a value.
07231d4f 1825 This is a helper function for warnings_for_convert_and_check. */
422c3a54
MLI		 1826
1827static void
1828conversion_warning (tree type, tree expr)
1829{
1830 bool give_warning = false;
1831
0011dedb
MLI		 1832 int i;
1833 const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
374035cb 1834 tree expr_type = TREE_TYPE (expr);
6312e84d
MLI		 1835 location_t loc = EXPR_HAS_LOCATION (expr)
1836 ? EXPR_LOCATION (expr) : input_location;
422c3a54 1837
7060db96
MLI		 1838 if (!warn_conversion && !warn_sign_conversion)
1839 return;
1840
0011dedb
MLI		 1841 /* If any operand is artificial, then this expression was generated
1842 by the compiler and we do not warn. */
1843 for (i = 0; i < expr_num_operands; i++)
1844 {
1845 tree op = TREE_OPERAND (expr, i);
1bfb8f51 1846 if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
0011dedb
MLI		 1847 return;
1848 }
1849
374035cb 1850 switch (TREE_CODE (expr))
422c3a54 1851 {
374035cb
MLI		 1852 case EQ_EXPR:
1853 case NE_EXPR:
1854 case LE_EXPR:
1855 case GE_EXPR:
1856 case LT_EXPR:
1857 case GT_EXPR:
1858 case TRUTH_ANDIF_EXPR:
1859 case TRUTH_ORIF_EXPR:
1860 case TRUTH_AND_EXPR:
1861 case TRUTH_OR_EXPR:
1862 case TRUTH_XOR_EXPR:
1863 case TRUTH_NOT_EXPR:
1864 /* Conversion from boolean to a signed:1 bit-field (which only
1865 can hold the values 0 and -1) doesn't lose information - but
1866 it does change the value. */
b8698a0f 1867 if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
6312e84d
MLI		 1868 warning_at (loc, OPT_Wconversion,
1869 "conversion to %qT from boolean expression", type);
374035cb
MLI		 1870 return;
1871
1872 case REAL_CST:
1873 case INTEGER_CST:
1874
422c3a54
MLI		 1875 /* Warn for real constant that is not an exact integer converted
1876 to integer type. */
374035cb 1877 if (TREE_CODE (expr_type) == REAL_TYPE
422c3a54
MLI		 1878 && TREE_CODE (type) == INTEGER_TYPE)
1879 {
374035cb 1880 if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
422c3a54
MLI		 1881 give_warning = true;
1882 }
91c41804 1883 /* Warn for an integer constant that does not fit into integer type. */
374035cb 1884 else if (TREE_CODE (expr_type) == INTEGER_TYPE
422c3a54 1885 && TREE_CODE (type) == INTEGER_TYPE
91c41804
RS		 1886 && !int_fits_type_p (expr, type))
1887 {
b8698a0f 1888 if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
374035cb 1889 && tree_int_cst_sgn (expr) < 0)
6312e84d
MLI		 1890 warning_at (loc, OPT_Wsign_conversion, "negative integer"
1891 " implicitly converted to unsigned type");
374035cb 1892 else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
6312e84d
MLI		 1893 warning_at (loc, OPT_Wsign_conversion, "conversion of unsigned"
1894 " constant value to negative integer");
7060db96
MLI		 1895 else
1896 give_warning = true;
91c41804 1897 }
422c3a54
MLI		 1898 else if (TREE_CODE (type) == REAL_TYPE)
1899 {
1900 /* Warn for an integer constant that does not fit into real type. */
374035cb 1901 if (TREE_CODE (expr_type) == INTEGER_TYPE)
422c3a54
MLI		 1902 {
1903 REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1904 if (!exact_real_truncate (TYPE_MODE (type), &a))
1905 give_warning = true;
1906 }
1907 /* Warn for a real constant that does not fit into a smaller
1908 real type. */
374035cb
MLI		 1909 else if (TREE_CODE (expr_type) == REAL_TYPE
1910 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
422c3a54
MLI		 1911 {
1912 REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1913 if (!exact_real_truncate (TYPE_MODE (type), &a))
1914 give_warning = true;
1915 }
1916 }
1917
1918 if (give_warning)
6312e84d
MLI		 1919 warning_at (loc, OPT_Wconversion,
1920 "conversion to %qT alters %qT constant value",
1921 type, expr_type);
374035cb
MLI		 1922
1923 return;
1924
1925 case COND_EXPR:
1926 {
1927 /* In case of COND_EXPR, if both operands are constants or
1928 COND_EXPR, then we do not care about the type of COND_EXPR,
1929 only about the conversion of each operand. */
1930 tree op1 = TREE_OPERAND (expr, 1);
1931 tree op2 = TREE_OPERAND (expr, 2);
1932
b8698a0f 1933 if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
374035cb
MLI		 1934 || TREE_CODE (op1) == COND_EXPR)
1935 && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1936 || TREE_CODE (op2) == COND_EXPR))
1937 {
1938 conversion_warning (type, op1);
1939 conversion_warning (type, op2);
1940 return;
1941 }
1942 /* Fall through. */
1943 }
1944
1945 default: /* 'expr' is not a constant. */
6715192c 1946
422c3a54 1947 /* Warn for real types converted to integer types. */
6715192c 1948 if (TREE_CODE (expr_type) == REAL_TYPE
422c3a54
MLI		 1949 && TREE_CODE (type) == INTEGER_TYPE)
1950 give_warning = true;
1951
6715192c 1952 else if (TREE_CODE (expr_type) == INTEGER_TYPE
422c3a54
MLI		 1953 && TREE_CODE (type) == INTEGER_TYPE)
1954 {
cfdaefec 1955 /* Don't warn about unsigned char y = 0xff, x = (int) y; */
c00e8b06 1956 expr = get_unwidened (expr, 0);
6715192c 1957 expr_type = TREE_TYPE (expr);
cfdaefec 1958
6715192c 1959 /* Don't warn for short y; short x = ((int)y & 0xff); */
b8698a0f
L		 1960 if (TREE_CODE (expr) == BIT_AND_EXPR
1961 || TREE_CODE (expr) == BIT_IOR_EXPR
6715192c
MLI		 1962 || TREE_CODE (expr) == BIT_XOR_EXPR)
1963 {
374035cb
MLI		 1964 /* If both args were extended from a shortest type,
1965 use that type if that is safe. */
b8698a0f
L		 1966 expr_type = shorten_binary_op (expr_type,
1967 TREE_OPERAND (expr, 0),
1968 TREE_OPERAND (expr, 1),
6715192c
MLI		 1969 /* bitwise */1);
1970
6715192c
MLI		 1971 if (TREE_CODE (expr) == BIT_AND_EXPR)
1972 {
1973 tree op0 = TREE_OPERAND (expr, 0);
1974 tree op1 = TREE_OPERAND (expr, 1);
9c591bd0
MLI		 1975 bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1976 bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1977
1978 /* If one of the operands is a non-negative constant
1979 that fits in the target type, then the type of the
1980 other operand does not matter. */
6715192c
MLI		 1981 if ((TREE_CODE (op0) == INTEGER_CST
1982 && int_fits_type_p (op0, c_common_signed_type (type))
1983 && int_fits_type_p (op0, c_common_unsigned_type (type)))
1984 || (TREE_CODE (op1) == INTEGER_CST
374035cb 1985 && int_fits_type_p (op1, c_common_signed_type (type))
b8698a0f 1986 && int_fits_type_p (op1,
374035cb 1987 c_common_unsigned_type (type))))
6715192c 1988 return;
9c591bd0
MLI		 1989 /* If constant is unsigned and fits in the target
1990 type, then the result will also fit. */
1991 else if ((TREE_CODE (op0) == INTEGER_CST
b8698a0f 1992 && unsigned0
9c591bd0
MLI		 1993 && int_fits_type_p (op0, type))
1994 || (TREE_CODE (op1) == INTEGER_CST
1995 && unsigned1
1996 && int_fits_type_p (op1, type)))
1997 return;
6715192c
MLI		 1998 }
1999 }
422c3a54 2000 /* Warn for integer types converted to smaller integer types. */
b8698a0f 2001 if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
7060db96
MLI		 2002 give_warning = true;
2003
2004 /* When they are the same width but different signedness,
2005 then the value may change. */
374035cb 2006 else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
6715192c 2007 && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
7060db96
MLI		 2008 /* Even when converted to a bigger type, if the type is
2009 unsigned but expr is signed, then negative values
2010 will be changed. */
6715192c 2011 || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
6312e84d
MLI		 2012 warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT "
2013 "may change the sign of the result",
2014 type, expr_type);
422c3a54
MLI		 2015 }
2016
2017 /* Warn for integer types converted to real types if and only if
2018 all the range of values of the integer type cannot be
2019 represented by the real type. */
6715192c 2020 else if (TREE_CODE (expr_type) == INTEGER_TYPE
422c3a54
MLI		 2021 && TREE_CODE (type) == REAL_TYPE)
2022 {
58076e21
MLI		 2023 tree type_low_bound, type_high_bound;
2024 REAL_VALUE_TYPE real_low_bound, real_high_bound;
2025
2026 /* Don't warn about char y = 0xff; float x = (int) y; */
2027 expr = get_unwidened (expr, 0);
2028 expr_type = TREE_TYPE (expr);
2029
2030 type_low_bound = TYPE_MIN_VALUE (expr_type);
2031 type_high_bound = TYPE_MAX_VALUE (expr_type);
2032 real_low_bound = real_value_from_int_cst (0, type_low_bound);
2033 real_high_bound = real_value_from_int_cst (0, type_high_bound);
422c3a54
MLI		 2034
2035 if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2036 || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2037 give_warning = true;
2038 }
2039
2040 /* Warn for real types converted to smaller real types. */
6715192c 2041 else if (TREE_CODE (expr_type) == REAL_TYPE
422c3a54 2042 && TREE_CODE (type) == REAL_TYPE
374035cb 2043 && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
422c3a54
MLI		 2044 give_warning = true;
2045
2046
2047 if (give_warning)
6312e84d
MLI		 2048 warning_at (loc, OPT_Wconversion,
2049 "conversion to %qT from %qT may alter its value",
2050 type, expr_type);
422c3a54
MLI		 2051 }
2052}
2053
07231d4f
MLI		 2054/* Produce warnings after a conversion. RESULT is the result of
2055 converting EXPR to TYPE. This is a helper function for
2056 convert_and_check and cp_convert_and_check. */
d74154d5 2057
07231d4f
MLI		 2058void
2059warnings_for_convert_and_check (tree type, tree expr, tree result)
d74154d5 2060{
91c41804
RS		 2061 if (TREE_CODE (expr) == INTEGER_CST
2062 && (TREE_CODE (type) == INTEGER_TYPE
2063 || TREE_CODE (type) == ENUMERAL_TYPE)
2064 && !int_fits_type_p (expr, type))
2065 {
422c3a54
MLI		 2066 /* Do not diagnose overflow in a constant expression merely
2067 because a conversion overflowed. */
91c41804 2068 if (TREE_OVERFLOW (result))
d95787e6
RS		 2069 TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2070
91c41804 2071 if (TYPE_UNSIGNED (type))
422c3a54 2072 {
91c41804
RS		 2073 /* This detects cases like converting -129 or 256 to
2074 unsigned char. */
2075 if (!int_fits_type_p (expr, c_common_signed_type (type)))
2076 warning (OPT_Woverflow,
2077 "large integer implicitly truncated to unsigned type");
7060db96 2078 else
91c41804
RS		 2079 conversion_warning (type, expr);
2080 }
b8698a0f 2081 else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
f73fe417
MLI		 2082 warning (OPT_Woverflow,
2083 "overflow in implicit constant conversion");
2084 /* No warning for converting 0x80000000 to int. */
2085 else if (pedantic
2086 && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2087 || TYPE_PRECISION (TREE_TYPE (expr))
2088 != TYPE_PRECISION (type)))
2089 warning (OPT_Woverflow,
2090 "overflow in implicit constant conversion");
2091
7060db96 2092 else
f73fe417 2093 conversion_warning (type, expr);
d74154d5 2094 }
ab22c1fa
CF		 2095 else if ((TREE_CODE (result) == INTEGER_CST
2096 || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
91c41804
RS		 2097 warning (OPT_Woverflow,
2098 "overflow in implicit constant conversion");
7060db96 2099 else
91c41804 2100 conversion_warning (type, expr);
07231d4f
MLI		 2101}
2102
2103
2104/* Convert EXPR to TYPE, warning about conversion problems with constants.
2105 Invoke this function on every expression that is converted implicitly,
2106 i.e. because of language rules and not because of an explicit cast. */
2107
2108tree
2109convert_and_check (tree type, tree expr)
2110{
2111 tree result;
8ce94e44
JM		 2112 tree expr_for_warning;
2113
2114 /* Convert from a value with possible excess precision rather than
2115 via the semantic type, but do not warn about values not fitting
2116 exactly in the semantic type. */
2117 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2118 {
2119 tree orig_type = TREE_TYPE (expr);
2120 expr = TREE_OPERAND (expr, 0);
2121 expr_for_warning = convert (orig_type, expr);
2122 if (orig_type == type)
2123 return expr_for_warning;
2124 }
2125 else
2126 expr_for_warning = expr;
07231d4f
MLI		 2127
2128 if (TREE_TYPE (expr) == type)
2129 return expr;
b8698a0f 2130
07231d4f
MLI		 2131 result = convert (type, expr);
2132
7d882b83
ILT		 2133 if (c_inhibit_evaluation_warnings == 0
2134 && !TREE_OVERFLOW_P (expr)
2135 && result != error_mark_node)
8ce94e44 2136 warnings_for_convert_and_check (type, expr_for_warning, result);
07231d4f 2137
91c41804 2138 return result;
96571883
BK		 2139}
2140\f
235cfbc4
BS		 2141/* A node in a list that describes references to variables (EXPR), which are
2142 either read accesses if WRITER is zero, or write accesses, in which case
2143 WRITER is the parent of EXPR. */
2144struct tlist
2145{
2146 struct tlist *next;
2147 tree expr, writer;
2148};
2149
2150/* Used to implement a cache the results of a call to verify_tree. We only
2151 use this for SAVE_EXPRs. */
2152struct tlist_cache
2153{
2154 struct tlist_cache *next;
2155 struct tlist *cache_before_sp;
2156 struct tlist *cache_after_sp;
2157 tree expr;
2683ed8d
BS		 2158};
2159
235cfbc4
BS		 2160/* Obstack to use when allocating tlist structures, and corresponding
2161 firstobj. */
2162static struct obstack tlist_obstack;
2163static char *tlist_firstobj = 0;
2164
2165/* Keep track of the identifiers we've warned about, so we can avoid duplicate
2166 warnings. */
2167static struct tlist *warned_ids;
2168/* SAVE_EXPRs need special treatment. We process them only once and then
2169 cache the results. */
2170static struct tlist_cache *save_expr_cache;
2171
35b1a6fa
AJ		 2172static void add_tlist (struct tlist **, struct tlist *, tree, int);
2173static void merge_tlist (struct tlist **, struct tlist *, int);
2174static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2175static int warning_candidate_p (tree);
1e4ae551 2176static bool candidate_equal_p (const_tree, const_tree);
35b1a6fa
AJ		 2177static void warn_for_collisions (struct tlist *);
2178static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2179static struct tlist *new_tlist (struct tlist *, tree, tree);
2683ed8d 2180
235cfbc4
BS		 2181/* Create a new struct tlist and fill in its fields. */
2182static struct tlist *
35b1a6fa 2183new_tlist (struct tlist *next, tree t, tree writer)
235cfbc4
BS		 2184{
2185 struct tlist *l;
5d038c4c 2186 l = XOBNEW (&tlist_obstack, struct tlist);
235cfbc4
BS		 2187 l->next = next;
2188 l->expr = t;
2189 l->writer = writer;
2190 return l;
2191}
2192
2193/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
2194 is nonnull, we ignore any node we find which has a writer equal to it. */
2195
2196static void
35b1a6fa 2197add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
235cfbc4
BS		 2198{
2199 while (add)
2200 {
2201 struct tlist *next = add->next;
3f75a254 2202 if (!copy)
235cfbc4 2203 add->next = *to;
1e4ae551 2204 if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
235cfbc4
BS		 2205 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2206 add = next;
2207 }
2208}
2209
2210/* Merge the nodes of ADD into TO. This merging process is done so that for
2211 each variable that already exists in TO, no new node is added; however if
2212 there is a write access recorded in ADD, and an occurrence on TO is only
2213 a read access, then the occurrence in TO will be modified to record the
2214 write. */
2683ed8d
BS		 2215
2216static void
35b1a6fa 2217merge_tlist (struct tlist **to, struct tlist *add, int copy)
235cfbc4
BS		 2218{
2219 struct tlist **end = to;
2220
2221 while (*end)
2222 end = &(*end)->next;
2223
2224 while (add)
2225 {
2226 int found = 0;
2227 struct tlist *tmp2;
2228 struct tlist *next = add->next;
2229
2230 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1e4ae551 2231 if (candidate_equal_p (tmp2->expr, add->expr))
235cfbc4
BS		 2232 {
2233 found = 1;
3f75a254 2234 if (!tmp2->writer)
235cfbc4
BS		 2235 tmp2->writer = add->writer;
2236 }
3f75a254 2237 if (!found)
235cfbc4
BS		 2238 {
2239 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2240 end = &(*end)->next;
2241 *end = 0;
2242 }
2243 add = next;
2244 }
2245}
2246
2247/* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
2248 references in list LIST conflict with it, excluding reads if ONLY writers
2249 is nonzero. */
2250
2251static void
35b1a6fa
AJ		 2252warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2253 int only_writes)
235cfbc4
BS		 2254{
2255 struct tlist *tmp;
2256
2257 /* Avoid duplicate warnings. */
2258 for (tmp = warned_ids; tmp; tmp = tmp->next)
1e4ae551 2259 if (candidate_equal_p (tmp->expr, written))
235cfbc4
BS		 2260 return;
2261
2262 while (list)
2263 {
1e4ae551
MLI		 2264 if (candidate_equal_p (list->expr, written)
2265 && !candidate_equal_p (list->writer, writer)
2266 && (!only_writes || list->writer))
235cfbc4
BS		 2267 {
2268 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
ca085fd7
MLI		 2269 warning_at (EXPR_HAS_LOCATION (writer)
2270 ? EXPR_LOCATION (writer) : input_location,
2271 OPT_Wsequence_point, "operation on %qE may be undefined",
2272 list->expr);
235cfbc4
BS		 2273 }
2274 list = list->next;
2275 }
2276}
2277
2278/* Given a list LIST of references to variables, find whether any of these
2279 can cause conflicts due to missing sequence points. */
2280
2281static void
35b1a6fa 2282warn_for_collisions (struct tlist *list)
235cfbc4
BS		 2283{
2284 struct tlist *tmp;
35b1a6fa 2285
235cfbc4
BS		 2286 for (tmp = list; tmp; tmp = tmp->next)
2287 {
2288 if (tmp->writer)
2289 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2290 }
2291}
2292
684d9f3b 2293/* Return nonzero if X is a tree that can be verified by the sequence point
235cfbc4
BS		 2294 warnings. */
2295static int
35b1a6fa 2296warning_candidate_p (tree x)
2683ed8d 2297{
1e4ae551
MLI		 2298 /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2299 (lvalue_p) crash on TRY/CATCH. */
2300 return !(DECL_P (x) && DECL_ARTIFICIAL (x))
2301 && TREE_TYPE (x) && !VOID_TYPE_P (TREE_TYPE (x)) && lvalue_p (x);
2302}
2303
2304/* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2305static bool
2306candidate_equal_p (const_tree x, const_tree y)
2307{
2308 return (x == y) || (x && y && operand_equal_p (x, y, 0));
235cfbc4 2309}
2683ed8d 2310
235cfbc4
BS		 2311/* Walk the tree X, and record accesses to variables. If X is written by the
2312 parent tree, WRITER is the parent.
2313 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
2314 expression or its only operand forces a sequence point, then everything up
2315 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
2316 in PNO_SP.
2317 Once we return, we will have emitted warnings if any subexpression before
2318 such a sequence point could be undefined. On a higher level, however, the
2319 sequence point may not be relevant, and we'll merge the two lists.
2320
2321 Example: (b++, a) + b;
2322 The call that processes the COMPOUND_EXPR will store the increment of B
2323 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
2324 processes the PLUS_EXPR will need to merge the two lists so that
2325 eventually, all accesses end up on the same list (and we'll warn about the
2326 unordered subexpressions b++ and b.
2327
2328 A note on merging. If we modify the former example so that our expression
2329 becomes
2330 (b++, b) + a
2331 care must be taken not simply to add all three expressions into the final
2332 PNO_SP list. The function merge_tlist takes care of that by merging the
2333 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2334 way, so that no more than one access to B is recorded. */
2683ed8d 2335
235cfbc4 2336static void
35b1a6fa
AJ		 2337verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2338 tree writer)
235cfbc4
BS		 2339{
2340 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2341 enum tree_code code;
6615c446 2342 enum tree_code_class cl;
2683ed8d 2343
f9e1917e
JM		 2344 /* X may be NULL if it is the operand of an empty statement expression
2345 ({ }). */
2346 if (x == NULL)
2347 return;
2348
235cfbc4
BS		 2349 restart:
2350 code = TREE_CODE (x);
e3a64162 2351 cl = TREE_CODE_CLASS (code);
2683ed8d 2352
235cfbc4 2353 if (warning_candidate_p (x))
1e4ae551 2354 *pno_sp = new_tlist (*pno_sp, x, writer);
235cfbc4
BS		 2355
2356 switch (code)
2357 {
52a84e42
BS		 2358 case CONSTRUCTOR:
2359 return;
2360
235cfbc4
BS		 2361 case COMPOUND_EXPR:
2362 case TRUTH_ANDIF_EXPR:
2363 case TRUTH_ORIF_EXPR:
2364 tmp_before = tmp_nosp = tmp_list3 = 0;
2365 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2366 warn_for_collisions (tmp_nosp);
2367 merge_tlist (pbefore_sp, tmp_before, 0);
2368 merge_tlist (pbefore_sp, tmp_nosp, 0);
2369 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2370 merge_tlist (pbefore_sp, tmp_list3, 0);
2371 return;
2372
2373 case COND_EXPR:
2374 tmp_before = tmp_list2 = 0;
2375 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2376 warn_for_collisions (tmp_list2);
2377 merge_tlist (pbefore_sp, tmp_before, 0);
2378 merge_tlist (pbefore_sp, tmp_list2, 1);
2379
2380 tmp_list3 = tmp_nosp = 0;
2381 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2382 warn_for_collisions (tmp_nosp);
2383 merge_tlist (pbefore_sp, tmp_list3, 0);
2384
2385 tmp_list3 = tmp_list2 = 0;
2386 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2387 warn_for_collisions (tmp_list2);
2388 merge_tlist (pbefore_sp, tmp_list3, 0);
2389 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2390 two first, to avoid warning for (a ? b++ : b++). */
2391 merge_tlist (&tmp_nosp, tmp_list2, 0);
2392 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2393 return;
2394
2683ed8d
BS		 2395 case PREDECREMENT_EXPR:
2396 case PREINCREMENT_EXPR:
2397 case POSTDECREMENT_EXPR:
2398 case POSTINCREMENT_EXPR:
235cfbc4
BS		 2399 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2400 return;
2401
2402 case MODIFY_EXPR:
2403 tmp_before = tmp_nosp = tmp_list3 = 0;
2404 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2405 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2406 /* Expressions inside the LHS are not ordered wrt. the sequence points
2407 in the RHS. Example:
2408 *a = (a++, 2)
2409 Despite the fact that the modification of "a" is in the before_sp
2410 list (tmp_before), it conflicts with the use of "a" in the LHS.
2411 We can handle this by adding the contents of tmp_list3
2412 to those of tmp_before, and redoing the collision warnings for that
2413 list. */
2414 add_tlist (&tmp_before, tmp_list3, x, 1);
2415 warn_for_collisions (tmp_before);
2416 /* Exclude the LHS itself here; we first have to merge it into the
2417 tmp_nosp list. This is done to avoid warning for "a = a"; if we
2418 didn't exclude the LHS, we'd get it twice, once as a read and once
2419 as a write. */
2420 add_tlist (pno_sp, tmp_list3, x, 0);
2421 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2422
2423 merge_tlist (pbefore_sp, tmp_before, 0);
2424 if (warning_candidate_p (TREE_OPERAND (x, 0)))
2425 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2426 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2427 return;
2683ed8d
BS		 2428
2429 case CALL_EXPR:
235cfbc4
BS		 2430 /* We need to warn about conflicts among arguments and conflicts between
2431 args and the function address. Side effects of the function address,
2432 however, are not ordered by the sequence point of the call. */
5039610b
SL		 2433 {
2434 call_expr_arg_iterator iter;
2435 tree arg;
b8698a0f 2436 tmp_before = tmp_nosp = 0;
5039610b
SL		 2437 verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2438 FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2439 {
2440 tmp_list2 = tmp_list3 = 0;
2441 verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2442 merge_tlist (&tmp_list3, tmp_list2, 0);
2443 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2444 }
2445 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2446 warn_for_collisions (tmp_before);
2447 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2448 return;
2449 }
2683ed8d
BS		 2450
2451 case TREE_LIST:
2452 /* Scan all the list, e.g. indices of multi dimensional array. */
2453 while (x)
2454 {
235cfbc4
BS		 2455 tmp_before = tmp_nosp = 0;
2456 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2457 merge_tlist (&tmp_nosp, tmp_before, 0);
2458 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2683ed8d
BS		 2459 x = TREE_CHAIN (x);
2460 }
235cfbc4 2461 return;
2683ed8d 2462
235cfbc4
BS		 2463 case SAVE_EXPR:
2464 {
2465 struct tlist_cache *t;
2466 for (t = save_expr_cache; t; t = t->next)
1e4ae551 2467 if (candidate_equal_p (t->expr, x))
235cfbc4 2468 break;
2683ed8d 2469
3f75a254 2470 if (!t)
2683ed8d 2471 {
5d038c4c 2472 t = XOBNEW (&tlist_obstack, struct tlist_cache);
235cfbc4
BS		 2473 t->next = save_expr_cache;
2474 t->expr = x;
2475 save_expr_cache = t;
2476
2477 tmp_before = tmp_nosp = 0;
2478 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2479 warn_for_collisions (tmp_nosp);
2480
2481 tmp_list3 = 0;
2482 while (tmp_nosp)
2483 {
2484 struct tlist *t = tmp_nosp;
2485 tmp_nosp = t->next;
2486 merge_tlist (&tmp_list3, t, 0);
2487 }
2488 t->cache_before_sp = tmp_before;
2489 t->cache_after_sp = tmp_list3;
2683ed8d 2490 }
235cfbc4
BS		 2491 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2492 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2493 return;
2494 }
2683ed8d 2495
528c22f4
MLI		 2496 case ADDR_EXPR:
2497 x = TREE_OPERAND (x, 0);
2498 if (DECL_P (x))
2499 return;
2500 writer = 0;
2501 goto restart;
2502
6615c446
JO		 2503 default:
2504 /* For other expressions, simply recurse on their operands.
c22cacf3 2505 Manual tail recursion for unary expressions.
6615c446
JO		 2506 Other non-expressions need not be processed. */
2507 if (cl == tcc_unary)
2508 {
6615c446
JO		 2509 x = TREE_OPERAND (x, 0);
2510 writer = 0;
2511 goto restart;
2512 }
2513 else if (IS_EXPR_CODE_CLASS (cl))
2514 {
2515 int lp;
5039610b 2516 int max = TREE_OPERAND_LENGTH (x);
6615c446
JO		 2517 for (lp = 0; lp < max; lp++)
2518 {
2519 tmp_before = tmp_nosp = 0;
2520 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2521 merge_tlist (&tmp_nosp, tmp_before, 0);
2522 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2523 }
2524 }
2525 return;
2683ed8d 2526 }
2683ed8d
BS		 2527}
2528
8d9afc4e 2529/* Try to warn for undefined behavior in EXPR due to missing sequence
2683ed8d
BS		 2530 points. */
2531
24e47c76 2532DEBUG_FUNCTION void
35b1a6fa 2533verify_sequence_points (tree expr)
2683ed8d 2534{
235cfbc4 2535 struct tlist *before_sp = 0, *after_sp = 0;
2683ed8d 2536
235cfbc4
BS		 2537 warned_ids = 0;
2538 save_expr_cache = 0;
2539 if (tlist_firstobj == 0)
2683ed8d 2540 {
235cfbc4 2541 gcc_obstack_init (&tlist_obstack);
28dab132 2542 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2683ed8d
BS		 2543 }
2544
235cfbc4
BS		 2545 verify_tree (expr, &before_sp, &after_sp, 0);
2546 warn_for_collisions (after_sp);
2547 obstack_free (&tlist_obstack, tlist_firstobj);
2683ed8d 2548}
b30f223b
RS		 2549\f
2550/* Validate the expression after `case' and apply default promotions. */
2551
a6c0a76c 2552static tree
35b1a6fa 2553check_case_value (tree value)
b30f223b
RS		 2554{
2555 if (value == NULL_TREE)
2556 return value;
2557
ed248cf7
JM		 2558 /* ??? Can we ever get nops here for a valid case value? We
2559 shouldn't for C. */
8493738b 2560 STRIP_TYPE_NOPS (value);
56cb9733
MM		 2561 /* In C++, the following is allowed:
2562
2563 const int i = 3;
2564 switch (...) { case i: ... }
2565
2566 So, we try to reduce the VALUE to a constant that way. */
37fa72e9 2567 if (c_dialect_cxx ())
56cb9733
MM		 2568 {
2569 value = decl_constant_value (value);
2570 STRIP_TYPE_NOPS (value);
2571 value = fold (value);
2572 }
b30f223b 2573
522ddfa2
JM		 2574 if (TREE_CODE (value) == INTEGER_CST)
2575 /* Promote char or short to int. */
2576 value = perform_integral_promotions (value);
2577 else if (value != error_mark_node)
b30f223b
RS		 2578 {
2579 error ("case label does not reduce to an integer constant");
2580 value = error_mark_node;
2581 }
b30f223b 2582
bc690db1
RS		 2583 constant_expression_warning (value);
2584
b30f223b
RS		 2585 return value;
2586}
2587\f
a6c0a76c 2588/* See if the case values LOW and HIGH are in the range of the original
89dbed81 2589 type (i.e. before the default conversion to int) of the switch testing
a6c0a76c
SB		 2590 expression.
2591 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2a7e31df 2592 the type before promoting it. CASE_LOW_P is a pointer to the lower
a6c0a76c
SB		 2593 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2594 if the case is not a case range.
2595 The caller has to make sure that we are not called with NULL for
89dbed81 2596 CASE_LOW_P (i.e. the default case).
0fa2e4df 2597 Returns true if the case label is in range of ORIG_TYPE (saturated or
a6c0a76c
SB		 2598 untouched) or false if the label is out of range. */
2599
2600static bool
2601check_case_bounds (tree type, tree orig_type,
2602 tree *case_low_p, tree *case_high_p)
2603{
2604 tree min_value, max_value;
2605 tree case_low = *case_low_p;
2606 tree case_high = case_high_p ? *case_high_p : case_low;
2607
2608 /* If there was a problem with the original type, do nothing. */
2609 if (orig_type == error_mark_node)
2610 return true;
2611
2612 min_value = TYPE_MIN_VALUE (orig_type);
2613 max_value = TYPE_MAX_VALUE (orig_type);
2614
2615 /* Case label is less than minimum for type. */
2616 if (tree_int_cst_compare (case_low, min_value) < 0
2617 && tree_int_cst_compare (case_high, min_value) < 0)
2618 {
d4ee4d25 2619 warning (0, "case label value is less than minimum value for type");
a6c0a76c
SB		 2620 return false;
2621 }
9f63daea 2622
a6c0a76c
SB		 2623 /* Case value is greater than maximum for type. */
2624 if (tree_int_cst_compare (case_low, max_value) > 0
2625 && tree_int_cst_compare (case_high, max_value) > 0)
2626 {
d4ee4d25 2627 warning (0, "case label value exceeds maximum value for type");
a6c0a76c
SB		 2628 return false;
2629 }
2630
2631 /* Saturate lower case label value to minimum. */
2632 if (tree_int_cst_compare (case_high, min_value) >= 0
2633 && tree_int_cst_compare (case_low, min_value) < 0)
2634 {
d4ee4d25 2635 warning (0, "lower value in case label range"
a6c0a76c
SB		 2636 " less than minimum value for type");
2637 case_low = min_value;
2638 }
9f63daea 2639
a6c0a76c
SB		 2640 /* Saturate upper case label value to maximum. */
2641 if (tree_int_cst_compare (case_low, max_value) <= 0
2642 && tree_int_cst_compare (case_high, max_value) > 0)
2643 {
d4ee4d25 2644 warning (0, "upper value in case label range"
a6c0a76c
SB		 2645 " exceeds maximum value for type");
2646 case_high = max_value;
2647 }
2648
2649 if (*case_low_p != case_low)
2650 *case_low_p = convert (type, case_low);
2651 if (case_high_p && *case_high_p != case_high)
2652 *case_high_p = convert (type, case_high);
2653
2654 return true;
2655}
2656\f
b30f223b
RS		 2657/* Return an integer type with BITS bits of precision,
2658 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2659
2660tree
35b1a6fa 2661c_common_type_for_size (unsigned int bits, int unsignedp)
b30f223b 2662{
a311b52c
JM		 2663 if (bits == TYPE_PRECISION (integer_type_node))
2664 return unsignedp ? unsigned_type_node : integer_type_node;
2665
3fc7e390 2666 if (bits == TYPE_PRECISION (signed_char_type_node))
b30f223b
RS		 2667 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2668
3fc7e390 2669 if (bits == TYPE_PRECISION (short_integer_type_node))
b30f223b
RS		 2670 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2671
3fc7e390 2672 if (bits == TYPE_PRECISION (long_integer_type_node))
b30f223b
RS		 2673 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2674
3fc7e390 2675 if (bits == TYPE_PRECISION (long_long_integer_type_node))
b30f223b
RS		 2676 return (unsignedp ? long_long_unsigned_type_node
2677 : long_long_integer_type_node);
2678
a6766312
KT		 2679 if (int128_integer_type_node
2680 && bits == TYPE_PRECISION (int128_integer_type_node))
2681 return (unsignedp ? int128_unsigned_type_node
2682 : int128_integer_type_node);
2683
835f9b4d
GRK		 2684 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2685 return (unsignedp ? widest_unsigned_literal_type_node
2686 : widest_integer_literal_type_node);
2687
3fc7e390
RS		 2688 if (bits <= TYPE_PRECISION (intQI_type_node))
2689 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2690
2691 if (bits <= TYPE_PRECISION (intHI_type_node))
2692 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2693
2694 if (bits <= TYPE_PRECISION (intSI_type_node))
2695 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2696
2697 if (bits <= TYPE_PRECISION (intDI_type_node))
2698 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2699
b30f223b
RS		 2700 return 0;
2701}
2702
ab22c1fa
CF		 2703/* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2704 that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2705 and saturating if SATP is nonzero, otherwise not saturating. */
2706
2707tree
2708c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2709 int unsignedp, int satp)
2710{
2711 enum machine_mode mode;
2712 if (ibit == 0)
2713 mode = unsignedp ? UQQmode : QQmode;
2714 else
2715 mode = unsignedp ? UHAmode : HAmode;
2716
2717 for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2718 if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2719 break;
2720
2721 if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2722 {
2723 sorry ("GCC cannot support operators with integer types and "
2724 "fixed-point types that have too many integral and "
2725 "fractional bits together");
2726 return 0;
2727 }
2728
2729 return c_common_type_for_mode (mode, satp);
2730}
2731
d1d3865f
ZW		 2732/* Used for communication between c_common_type_for_mode and
2733 c_register_builtin_type. */
2734static GTY(()) tree registered_builtin_types;
2735
b30f223b
RS		 2736/* Return a data type that has machine mode MODE.
2737 If the mode is an integer,
ab22c1fa
CF		 2738 then UNSIGNEDP selects between signed and unsigned types.
2739 If the mode is a fixed-point mode,
2740 then UNSIGNEDP selects between saturating and nonsaturating types. */
b30f223b
RS		 2741
2742tree
35b1a6fa 2743c_common_type_for_mode (enum machine_mode mode, int unsignedp)
b30f223b 2744{
d1d3865f
ZW		 2745 tree t;
2746
a311b52c
JM		 2747 if (mode == TYPE_MODE (integer_type_node))
2748 return unsignedp ? unsigned_type_node : integer_type_node;
2749
b30f223b
RS		 2750 if (mode == TYPE_MODE (signed_char_type_node))
2751 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2752
2753 if (mode == TYPE_MODE (short_integer_type_node))
2754 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2755
b30f223b
RS		 2756 if (mode == TYPE_MODE (long_integer_type_node))
2757 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2758
2759 if (mode == TYPE_MODE (long_long_integer_type_node))
2760 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2761
a6766312
KT		 2762 if (int128_integer_type_node
2763 && mode == TYPE_MODE (int128_integer_type_node))
2764 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2765
835f9b4d 2766 if (mode == TYPE_MODE (widest_integer_literal_type_node))
d125d268 2767 return unsignedp ? widest_unsigned_literal_type_node
6de9cd9a 2768 : widest_integer_literal_type_node;
835f9b4d 2769
0afeef64 2770 if (mode == QImode)
3fc7e390
RS		 2771 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2772
0afeef64 2773 if (mode == HImode)
3fc7e390
RS		 2774 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2775
0afeef64 2776 if (mode == SImode)
3fc7e390
RS		 2777 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2778
0afeef64 2779 if (mode == DImode)
3fc7e390
RS		 2780 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2781
21a9616b 2782#if HOST_BITS_PER_WIDE_INT >= 64
a6d7e156
JL		 2783 if (mode == TYPE_MODE (intTI_type_node))
2784 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
21a9616b 2785#endif
a6d7e156 2786
b30f223b
RS		 2787 if (mode == TYPE_MODE (float_type_node))
2788 return float_type_node;
2789
2790 if (mode == TYPE_MODE (double_type_node))
2791 return double_type_node;
2792
2793 if (mode == TYPE_MODE (long_double_type_node))
2794 return long_double_type_node;
2795
ff42324e
NS		 2796 if (mode == TYPE_MODE (void_type_node))
2797 return void_type_node;
9f63daea 2798
b30f223b 2799 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
19b3ffbc
DD		 2800 return (unsignedp
2801 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2802 : make_signed_type (GET_MODE_PRECISION (mode)));
b30f223b
RS		 2803
2804 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
19b3ffbc
DD		 2805 return (unsignedp
2806 ? make_unsigned_type (GET_MODE_PRECISION (mode))
2807 : make_signed_type (GET_MODE_PRECISION (mode)));
b30f223b 2808
7e7e470f
RH		 2809 if (COMPLEX_MODE_P (mode))
2810 {
2811 enum machine_mode inner_mode;
2812 tree inner_type;
2813
2814 if (mode == TYPE_MODE (complex_float_type_node))
2815 return complex_float_type_node;
2816 if (mode == TYPE_MODE (complex_double_type_node))
2817 return complex_double_type_node;
2818 if (mode == TYPE_MODE (complex_long_double_type_node))
2819 return complex_long_double_type_node;
2820
2821 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2822 return complex_integer_type_node;
2823
2824 inner_mode = GET_MODE_INNER (mode);
2825 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2826 if (inner_type != NULL_TREE)
2827 return build_complex_type (inner_type);
2828 }
2829 else if (VECTOR_MODE_P (mode))
4a5eab38
PB		 2830 {
2831 enum machine_mode inner_mode = GET_MODE_INNER (mode);
2832 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2833 if (inner_type != NULL_TREE)
2834 return build_vector_type_for_mode (inner_type, mode);
0afeef64 2835 }
4061f623 2836
9a8ce21f
JG		 2837 if (mode == TYPE_MODE (dfloat32_type_node))
2838 return dfloat32_type_node;
2839 if (mode == TYPE_MODE (dfloat64_type_node))
2840 return dfloat64_type_node;
2841 if (mode == TYPE_MODE (dfloat128_type_node))
2842 return dfloat128_type_node;
2843
ab22c1fa
CF		 2844 if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2845 {
2846 if (mode == TYPE_MODE (short_fract_type_node))
2847 return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2848 if (mode == TYPE_MODE (fract_type_node))
2849 return unsignedp ? sat_fract_type_node : fract_type_node;
2850 if (mode == TYPE_MODE (long_fract_type_node))
2851 return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2852 if (mode == TYPE_MODE (long_long_fract_type_node))
2853 return unsignedp ? sat_long_long_fract_type_node
2854 : long_long_fract_type_node;
2855
2856 if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2857 return unsignedp ? sat_unsigned_short_fract_type_node
2858 : unsigned_short_fract_type_node;
2859 if (mode == TYPE_MODE (unsigned_fract_type_node))
2860 return unsignedp ? sat_unsigned_fract_type_node
2861 : unsigned_fract_type_node;
2862 if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2863 return unsignedp ? sat_unsigned_long_fract_type_node
2864 : unsigned_long_fract_type_node;
2865 if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2866 return unsignedp ? sat_unsigned_long_long_fract_type_node
2867 : unsigned_long_long_fract_type_node;
2868
2869 if (mode == TYPE_MODE (short_accum_type_node))
2870 return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2871 if (mode == TYPE_MODE (accum_type_node))
2872 return unsignedp ? sat_accum_type_node : accum_type_node;
2873 if (mode == TYPE_MODE (long_accum_type_node))
2874 return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2875 if (mode == TYPE_MODE (long_long_accum_type_node))
2876 return unsignedp ? sat_long_long_accum_type_node
2877 : long_long_accum_type_node;
2878
2879 if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2880 return unsignedp ? sat_unsigned_short_accum_type_node
2881 : unsigned_short_accum_type_node;
2882 if (mode == TYPE_MODE (unsigned_accum_type_node))
2883 return unsignedp ? sat_unsigned_accum_type_node
2884 : unsigned_accum_type_node;
2885 if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2886 return unsignedp ? sat_unsigned_long_accum_type_node
2887 : unsigned_long_accum_type_node;
2888 if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2889 return unsignedp ? sat_unsigned_long_long_accum_type_node
2890 : unsigned_long_long_accum_type_node;
2891
2892 if (mode == QQmode)
2893 return unsignedp ? sat_qq_type_node : qq_type_node;
2894 if (mode == HQmode)
2895 return unsignedp ? sat_hq_type_node : hq_type_node;
2896 if (mode == SQmode)
2897 return unsignedp ? sat_sq_type_node : sq_type_node;
2898 if (mode == DQmode)
2899 return unsignedp ? sat_dq_type_node : dq_type_node;
2900 if (mode == TQmode)
2901 return unsignedp ? sat_tq_type_node : tq_type_node;
2902
2903 if (mode == UQQmode)
2904 return unsignedp ? sat_uqq_type_node : uqq_type_node;
2905 if (mode == UHQmode)
2906 return unsignedp ? sat_uhq_type_node : uhq_type_node;
2907 if (mode == USQmode)
2908 return unsignedp ? sat_usq_type_node : usq_type_node;
2909 if (mode == UDQmode)
2910 return unsignedp ? sat_udq_type_node : udq_type_node;
2911 if (mode == UTQmode)
2912 return unsignedp ? sat_utq_type_node : utq_type_node;
2913
2914 if (mode == HAmode)
2915 return unsignedp ? sat_ha_type_node : ha_type_node;
2916 if (mode == SAmode)
2917 return unsignedp ? sat_sa_type_node : sa_type_node;
2918 if (mode == DAmode)
2919 return unsignedp ? sat_da_type_node : da_type_node;
2920 if (mode == TAmode)
2921 return unsignedp ? sat_ta_type_node : ta_type_node;
2922
2923 if (mode == UHAmode)
2924 return unsignedp ? sat_uha_type_node : uha_type_node;
2925 if (mode == USAmode)
2926 return unsignedp ? sat_usa_type_node : usa_type_node;
2927 if (mode == UDAmode)
2928 return unsignedp ? sat_uda_type_node : uda_type_node;
2929 if (mode == UTAmode)
2930 return unsignedp ? sat_uta_type_node : uta_type_node;
2931 }
2932
d1d3865f
ZW		 2933 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2934 if (TYPE_MODE (TREE_VALUE (t)) == mode)
2935 return TREE_VALUE (t);
2936
b30f223b
RS		 2937 return 0;
2938}
693a6128 2939
12753674
RE		 2940tree
2941c_common_unsigned_type (tree type)
2942{
2943 return c_common_signed_or_unsigned_type (1, type);
2944}
2945
693a6128
GRK		 2946/* Return a signed type the same as TYPE in other respects. */
2947
2948tree
35b1a6fa 2949c_common_signed_type (tree type)
693a6128 2950{
ceef8ce4 2951 return c_common_signed_or_unsigned_type (0, type);
693a6128
GRK		 2952}
2953
2954/* Return a type the same as TYPE except unsigned or
2955 signed according to UNSIGNEDP. */
2956
2957tree
35b1a6fa 2958c_common_signed_or_unsigned_type (int unsignedp, tree type)
693a6128 2959{
c74a03d2 2960 tree type1;
693a6128 2961
c74a03d2
RAE		 2962 /* This block of code emulates the behavior of the old
2963 c_common_unsigned_type. In particular, it returns
2964 long_unsigned_type_node if passed a long, even when a int would
2965 have the same size. This is necessary for warnings to work
2966 correctly in archs where sizeof(int) == sizeof(long) */
2967
2968 type1 = TYPE_MAIN_VARIANT (type);
2969 if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2970 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2971 if (type1 == integer_type_node || type1 == unsigned_type_node)
2972 return unsignedp ? unsigned_type_node : integer_type_node;
2973 if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2974 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2975 if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2976 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2977 if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2978 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
a6766312
KT		 2979 if (int128_integer_type_node
2980 && (type1 == int128_integer_type_node
2981 || type1 == int128_unsigned_type_node))
2982 return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
c74a03d2
RAE		 2983 if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2984 return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2985#if HOST_BITS_PER_WIDE_INT >= 64
2986 if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2987 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2988#endif
2989 if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2990 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2991 if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2992 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2993 if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2994 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2995 if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2996 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2997
70d3fcab
AH		 2998#define C_COMMON_FIXED_TYPES(NAME) \
2999 if (type1 == short_ ## NAME ## _type_node \
3000 || type1 == unsigned_short_ ## NAME ## _type_node) \
3001 return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3002 : short_ ## NAME ## _type_node; \
3003 if (type1 == NAME ## _type_node \
3004 || type1 == unsigned_ ## NAME ## _type_node) \
3005 return unsignedp ? unsigned_ ## NAME ## _type_node \
3006 : NAME ## _type_node; \
3007 if (type1 == long_ ## NAME ## _type_node \
3008 || type1 == unsigned_long_ ## NAME ## _type_node) \
3009 return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3010 : long_ ## NAME ## _type_node; \
3011 if (type1 == long_long_ ## NAME ## _type_node \
3012 || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3013 return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3014 : long_long_ ## NAME ## _type_node;
3015
3016#define C_COMMON_FIXED_MODE_TYPES(NAME) \
3017 if (type1 == NAME ## _type_node \
3018 || type1 == u ## NAME ## _type_node) \
3019 return unsignedp ? u ## NAME ## _type_node \
3020 : NAME ## _type_node;
3021
3022#define C_COMMON_FIXED_TYPES_SAT(NAME) \
3023 if (type1 == sat_ ## short_ ## NAME ## _type_node \
3024 || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3025 return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3026 : sat_ ## short_ ## NAME ## _type_node; \
3027 if (type1 == sat_ ## NAME ## _type_node \
3028 || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3029 return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3030 : sat_ ## NAME ## _type_node; \
3031 if (type1 == sat_ ## long_ ## NAME ## _type_node \
3032 || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3033 return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3034 : sat_ ## long_ ## NAME ## _type_node; \
3035 if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3036 || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3037 return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3038 : sat_ ## long_long_ ## NAME ## _type_node;
3039
3040#define C_COMMON_FIXED_MODE_TYPES_SAT(NAME) \
3041 if (type1 == sat_ ## NAME ## _type_node \
3042 || type1 == sat_ ## u ## NAME ## _type_node) \
3043 return unsignedp ? sat_ ## u ## NAME ## _type_node \
3044 : sat_ ## NAME ## _type_node;
3045
3046 C_COMMON_FIXED_TYPES (fract);
3047 C_COMMON_FIXED_TYPES_SAT (fract);
3048 C_COMMON_FIXED_TYPES (accum);
3049 C_COMMON_FIXED_TYPES_SAT (accum);
3050
3051 C_COMMON_FIXED_MODE_TYPES (qq);
3052 C_COMMON_FIXED_MODE_TYPES (hq);
3053 C_COMMON_FIXED_MODE_TYPES (sq);
3054 C_COMMON_FIXED_MODE_TYPES (dq);
3055 C_COMMON_FIXED_MODE_TYPES (tq);
3056 C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3057 C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3058 C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3059 C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3060 C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3061 C_COMMON_FIXED_MODE_TYPES (ha);
3062 C_COMMON_FIXED_MODE_TYPES (sa);
3063 C_COMMON_FIXED_MODE_TYPES (da);
3064 C_COMMON_FIXED_MODE_TYPES (ta);
3065 C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3066 C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3067 C_COMMON_FIXED_MODE_TYPES_SAT (da);
3068 C_COMMON_FIXED_MODE_TYPES_SAT (ta);
ab22c1fa 3069
bc15d0ef
JM		 3070 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3071 the precision; they have precision set to match their range, but
3072 may use a wider mode to match an ABI. If we change modes, we may
3073 wind up with bad conversions. For INTEGER_TYPEs in C, must check
3074 the precision as well, so as to yield correct results for
3075 bit-field types. C++ does not have these separate bit-field
3076 types, and producing a signed or unsigned variant of an
3077 ENUMERAL_TYPE may cause other problems as well. */
3078
1e204133
RAE		 3079 if (!INTEGRAL_TYPE_P (type)
3080 || TYPE_UNSIGNED (type) == unsignedp)
3081 return type;
3082
bc15d0ef
JM		 3083#define TYPE_OK(node) \
3084 (TYPE_MODE (type) == TYPE_MODE (node) \
41b81065 3085 && TYPE_PRECISION (type) == TYPE_PRECISION (node))
bc15d0ef 3086 if (TYPE_OK (signed_char_type_node))
693a6128 3087 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
bc15d0ef 3088 if (TYPE_OK (integer_type_node))
693a6128 3089 return unsignedp ? unsigned_type_node : integer_type_node;
bc15d0ef 3090 if (TYPE_OK (short_integer_type_node))
693a6128 3091 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
bc15d0ef 3092 if (TYPE_OK (long_integer_type_node))
693a6128 3093 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
bc15d0ef 3094 if (TYPE_OK (long_long_integer_type_node))
693a6128
GRK		 3095 return (unsignedp ? long_long_unsigned_type_node
3096 : long_long_integer_type_node);
a6766312
KT		 3097 if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3098 return (unsignedp ? int128_unsigned_type_node
3099 : int128_integer_type_node);
bc15d0ef 3100 if (TYPE_OK (widest_integer_literal_type_node))
693a6128
GRK		 3101 return (unsignedp ? widest_unsigned_literal_type_node
3102 : widest_integer_literal_type_node);
4a063bec
RH		 3103
3104#if HOST_BITS_PER_WIDE_INT >= 64
bc15d0ef 3105 if (TYPE_OK (intTI_type_node))
4a063bec
RH		 3106 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3107#endif
bc15d0ef 3108 if (TYPE_OK (intDI_type_node))
4a063bec 3109 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
bc15d0ef 3110 if (TYPE_OK (intSI_type_node))
4a063bec 3111 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
bc15d0ef 3112 if (TYPE_OK (intHI_type_node))
4a063bec 3113 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
bc15d0ef 3114 if (TYPE_OK (intQI_type_node))
4a063bec 3115 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
bc15d0ef 3116#undef TYPE_OK
4a063bec 3117
41b81065 3118 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
693a6128 3119}
9649812a 3120
38a4afee
MM		 3121/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
3122
3123tree
3124c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3125{
3126 /* Extended integer types of the same width as a standard type have
3127 lesser rank, so those of the same width as int promote to int or
3128 unsigned int and are valid for printf formats expecting int or
3129 unsigned int. To avoid such special cases, avoid creating
3130 extended integer types for bit-fields if a standard integer type
3131 is available. */
3132 if (width == TYPE_PRECISION (integer_type_node))
3133 return unsignedp ? unsigned_type_node : integer_type_node;
3134 if (width == TYPE_PRECISION (signed_char_type_node))
3135 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3136 if (width == TYPE_PRECISION (short_integer_type_node))
3137 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3138 if (width == TYPE_PRECISION (long_integer_type_node))
3139 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3140 if (width == TYPE_PRECISION (long_long_integer_type_node))
3141 return (unsignedp ? long_long_unsigned_type_node
3142 : long_long_integer_type_node);
a6766312
KT		 3143 if (int128_integer_type_node
3144 && width == TYPE_PRECISION (int128_integer_type_node))
3145 return (unsignedp ? int128_unsigned_type_node
3146 : int128_integer_type_node);
38a4afee
MM		 3147 return build_nonstandard_integer_type (width, unsignedp);
3148}
3149
9649812a
MM		 3150/* The C version of the register_builtin_type langhook. */
3151
3152void
3153c_register_builtin_type (tree type, const char* name)
3154{
3155 tree decl;
3156
c2255bc4
AH		 3157 decl = build_decl (UNKNOWN_LOCATION,
3158 TYPE_DECL, get_identifier (name), type);
9649812a
MM		 3159 DECL_ARTIFICIAL (decl) = 1;
3160 if (!TYPE_NAME (type))
3161 TYPE_NAME (type) = decl;
3162 pushdecl (decl);
d1d3865f
ZW		 3163
3164 registered_builtin_types = tree_cons (0, type, registered_builtin_types);
9649812a 3165}
6acfe908 3166\f
78ef5b89 3167/* Print an error message for invalid operands to arith operation
ba47d38d
AH		 3168 CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3169 LOCATION is the location of the message. */
b30f223b
RS		 3170
3171void
ba47d38d
AH		 3172binary_op_error (location_t location, enum tree_code code,
3173 tree type0, tree type1)
b30f223b 3174{
b3694847 3175 const char *opname;
89c78d7d 3176
b30f223b
RS		 3177 switch (code)
3178 {
b30f223b
RS		 3179 case PLUS_EXPR:
3180 opname = "+"; break;
3181 case MINUS_EXPR:
3182 opname = "-"; break;
3183 case MULT_EXPR:
3184 opname = "*"; break;
3185 case MAX_EXPR:
3186 opname = "max"; break;
3187 case MIN_EXPR:
3188 opname = "min"; break;
3189 case EQ_EXPR:
3190 opname = "=="; break;
3191 case NE_EXPR:
3192 opname = "!="; break;
3193 case LE_EXPR:
3194 opname = "<="; break;
3195 case GE_EXPR:
3196 opname = ">="; break;
3197 case LT_EXPR:
3198 opname = "<"; break;
3199 case GT_EXPR:
3200 opname = ">"; break;
3201 case LSHIFT_EXPR:
3202 opname = "<<"; break;
3203 case RSHIFT_EXPR:
3204 opname = ">>"; break;
3205 case TRUNC_MOD_EXPR:
047de90b 3206 case FLOOR_MOD_EXPR:
b30f223b
RS		 3207 opname = "%"; break;
3208 case TRUNC_DIV_EXPR:
047de90b 3209 case FLOOR_DIV_EXPR:
b30f223b
RS		 3210 opname = "/"; break;
3211 case BIT_AND_EXPR:
3212 opname = "&"; break;
3213 case BIT_IOR_EXPR:
3214 opname = "|"; break;
3215 case TRUTH_ANDIF_EXPR:
3216 opname = "&&"; break;
3217 case TRUTH_ORIF_EXPR:
3218 opname = "||"; break;
3219 case BIT_XOR_EXPR:
3220 opname = "^"; break;
6d819282 3221 default:
37b2f290 3222 gcc_unreachable ();
b30f223b 3223 }
ba47d38d
AH		 3224 error_at (location,
3225 "invalid operands to binary %s (have %qT and %qT)", opname,
3226 type0, type1);
b30f223b
RS		 3227}
3228\f
3229/* Subroutine of build_binary_op, used for comparison operations.
3230 See if the operands have both been converted from subword integer types
3231 and, if so, perhaps change them both back to their original type.
94dccd9d
RS		 3232 This function is also responsible for converting the two operands
3233 to the proper common type for comparison.
b30f223b
RS		 3234
3235 The arguments of this function are all pointers to local variables
3236 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3237 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3238
3239 If this function returns nonzero, it means that the comparison has
3240 a constant value. What this function returns is an expression for
3241 that value. */
3242
3243tree
35b1a6fa
AJ		 3244shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3245 enum tree_code *rescode_ptr)
b30f223b 3246{
b3694847 3247 tree type;
b30f223b
RS		 3248 tree op0 = *op0_ptr;
3249 tree op1 = *op1_ptr;
3250 int unsignedp0, unsignedp1;
3251 int real1, real2;
3252 tree primop0, primop1;
3253 enum tree_code code = *rescode_ptr;
3254
3255 /* Throw away any conversions to wider types
3256 already present in the operands. */
3257
3258 primop0 = get_narrower (op0, &unsignedp0);
3259 primop1 = get_narrower (op1, &unsignedp1);
3260
3261 /* Handle the case that OP0 does not *contain* a conversion
3262 but it *requires* conversion to FINAL_TYPE. */
3263
3264 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
8df83eae 3265 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
b30f223b 3266 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
8df83eae 3267 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
b30f223b
RS		 3268
3269 /* If one of the operands must be floated, we cannot optimize. */
3270 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3271 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3272
3273 /* If first arg is constant, swap the args (changing operation
5af6001b
RK		 3274 so value is preserved), for canonicalization. Don't do this if
3275 the second arg is 0. */
b30f223b 3276
5af6001b 3277 if (TREE_CONSTANT (primop0)
ab22c1fa
CF		 3278 && !integer_zerop (primop1) && !real_zerop (primop1)
3279 && !fixed_zerop (primop1))
b30f223b 3280 {
b3694847
SS		 3281 tree tem = primop0;
3282 int temi = unsignedp0;
b30f223b
RS		 3283 primop0 = primop1;
3284 primop1 = tem;
3285 tem = op0;
3286 op0 = op1;
3287 op1 = tem;
3288 *op0_ptr = op0;
3289 *op1_ptr = op1;
3290 unsignedp0 = unsignedp1;
3291 unsignedp1 = temi;
3292 temi = real1;
3293 real1 = real2;
3294 real2 = temi;
3295
3296 switch (code)
3297 {
3298 case LT_EXPR:
3299 code = GT_EXPR;
3300 break;
3301 case GT_EXPR:
3302 code = LT_EXPR;
3303 break;
3304 case LE_EXPR:
3305 code = GE_EXPR;
3306 break;
3307 case GE_EXPR:
3308 code = LE_EXPR;
3309 break;
6d819282
MK		 3310 default:
3311 break;
b30f223b
RS		 3312 }
3313 *rescode_ptr = code;
3314 }
3315
3316 /* If comparing an integer against a constant more bits wide,
3317 maybe we can deduce a value of 1 or 0 independent of the data.
3318 Or else truncate the constant now
3319 rather than extend the variable at run time.
3320
3321 This is only interesting if the constant is the wider arg.
3322 Also, it is not safe if the constant is unsigned and the
3323 variable arg is signed, since in this case the variable
3324 would be sign-extended and then regarded as unsigned.
3325 Our technique fails in this case because the lowest/highest
3326 possible unsigned results don't follow naturally from the
3327 lowest/highest possible values of the variable operand.
3328 For just EQ_EXPR and NE_EXPR there is another technique that
3329 could be used: see if the constant can be faithfully represented
3330 in the other operand's type, by truncating it and reextending it
3331 and see if that preserves the constant's value. */
3332
3333 if (!real1 && !real2
ab22c1fa 3334 && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
b30f223b
RS		 3335 && TREE_CODE (primop1) == INTEGER_CST
3336 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3337 {
3338 int min_gt, max_gt, min_lt, max_lt;
3339 tree maxval, minval;
3340 /* 1 if comparison is nominally unsigned. */
8df83eae 3341 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
b30f223b
RS		 3342 tree val;
3343
ceef8ce4
NB		 3344 type = c_common_signed_or_unsigned_type (unsignedp0,
3345 TREE_TYPE (primop0));
8bbd5685 3346
b30f223b
RS		 3347 maxval = TYPE_MAX_VALUE (type);
3348 minval = TYPE_MIN_VALUE (type);
3349
3350 if (unsignedp && !unsignedp0)
ceef8ce4 3351 *restype_ptr = c_common_signed_type (*restype_ptr);
b30f223b
RS		 3352
3353 if (TREE_TYPE (primop1) != *restype_ptr)
fae1b38d 3354 {
af9c6659
NS		 3355 /* Convert primop1 to target type, but do not introduce
3356 additional overflow. We know primop1 is an int_cst. */
b8fca551 3357 primop1 = force_fit_type_double (*restype_ptr,
9589f23e
AS		 3358 tree_to_double_int (primop1),
3359 0, TREE_OVERFLOW (primop1));
fae1b38d 3360 }
b30f223b
RS		 3361 if (type != *restype_ptr)
3362 {
3363 minval = convert (*restype_ptr, minval);
3364 maxval = convert (*restype_ptr, maxval);
3365 }
3366
3367 if (unsignedp && unsignedp0)
3368 {
3369 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3370 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3371 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3372 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3373 }
3374 else
3375 {
3376 min_gt = INT_CST_LT (primop1, minval);
3377 max_gt = INT_CST_LT (primop1, maxval);
3378 min_lt = INT_CST_LT (minval, primop1);
3379 max_lt = INT_CST_LT (maxval, primop1);
3380 }
3381
3382 val = 0;
3383 /* This used to be a switch, but Genix compiler can't handle that. */
3384 if (code == NE_EXPR)
3385 {
3386 if (max_lt || min_gt)
de7df9eb 3387 val = truthvalue_true_node;
b30f223b
RS		 3388 }
3389 else if (code == EQ_EXPR)
3390 {
3391 if (max_lt || min_gt)
de7df9eb 3392 val = truthvalue_false_node;
b30f223b
RS		 3393 }
3394 else if (code == LT_EXPR)
3395 {
3396 if (max_lt)
de7df9eb 3397 val = truthvalue_true_node;
b30f223b 3398 if (!min_lt)
de7df9eb 3399 val = truthvalue_false_node;
b30f223b
RS		 3400 }
3401 else if (code == GT_EXPR)
3402 {
3403 if (min_gt)
de7df9eb 3404 val = truthvalue_true_node;
b30f223b 3405 if (!max_gt)
de7df9eb 3406 val = truthvalue_false_node;
b30f223b
RS		 3407 }
3408 else if (code == LE_EXPR)
3409 {
3410 if (!max_gt)
de7df9eb 3411 val = truthvalue_true_node;
b30f223b 3412 if (min_gt)
de7df9eb 3413 val = truthvalue_false_node;
b30f223b
RS		 3414 }
3415 else if (code == GE_EXPR)
3416 {
3417 if (!min_lt)
de7df9eb 3418 val = truthvalue_true_node;
b30f223b 3419 if (max_lt)
de7df9eb 3420 val = truthvalue_false_node;
b30f223b
RS		 3421 }
3422
3423 /* If primop0 was sign-extended and unsigned comparison specd,
3424 we did a signed comparison above using the signed type bounds.
3425 But the comparison we output must be unsigned.
3426
3427 Also, for inequalities, VAL is no good; but if the signed
3428 comparison had *any* fixed result, it follows that the
3429 unsigned comparison just tests the sign in reverse
3430 (positive values are LE, negative ones GE).
3431 So we can generate an unsigned comparison
3432 against an extreme value of the signed type. */
3433
3434 if (unsignedp && !unsignedp0)
3435 {
3436 if (val != 0)
3437 switch (code)
3438 {
3439 case LT_EXPR:
3440 case GE_EXPR:
3441 primop1 = TYPE_MIN_VALUE (type);
3442 val = 0;
3443 break;
3444
3445 case LE_EXPR:
3446 case GT_EXPR:
3447 primop1 = TYPE_MAX_VALUE (type);
3448 val = 0;
3449 break;
6d819282
MK		 3450
3451 default:
3452 break;
b30f223b 3453 }
12753674 3454 type = c_common_unsigned_type (type);
b30f223b
RS		 3455 }
3456
5c5b2283 3457 if (TREE_CODE (primop0) != INTEGER_CST)
b30f223b 3458 {
de7df9eb 3459 if (val == truthvalue_false_node)
f6aa72dd 3460 warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
de7df9eb 3461 if (val == truthvalue_true_node)
f6aa72dd 3462 warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
b30f223b
RS		 3463 }
3464
3465 if (val != 0)
3466 {
3467 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3468 if (TREE_SIDE_EFFECTS (primop0))
53fb4de3 3469 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
b30f223b
RS		 3470 return val;
3471 }
3472
3473 /* Value is not predetermined, but do the comparison
3474 in the type of the operand that is not constant.
3475 TYPE is already properly set. */
3476 }
9a8ce21f
JG		 3477
3478 /* If either arg is decimal float and the other is float, find the
3479 proper common type to use for comparison. */
3480 else if (real1 && real2
3481 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3482 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3483 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3484
b30f223b 3485 else if (real1 && real2
766f6c30
RS		 3486 && (TYPE_PRECISION (TREE_TYPE (primop0))
3487 == TYPE_PRECISION (TREE_TYPE (primop1))))
b30f223b
RS		 3488 type = TREE_TYPE (primop0);
3489
3490 /* If args' natural types are both narrower than nominal type
3491 and both extend in the same manner, compare them
3492 in the type of the wider arg.
3493 Otherwise must actually extend both to the nominal
3494 common type lest different ways of extending
3495 alter the result.
3496 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3497
3498 else if (unsignedp0 == unsignedp1 && real1 == real2
3499 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3500 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3501 {
3502 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
ceef8ce4 3503 type = c_common_signed_or_unsigned_type (unsignedp0
8df83eae 3504 || TYPE_UNSIGNED (*restype_ptr),
ceef8ce4 3505 type);
b30f223b
RS		 3506 /* Make sure shorter operand is extended the right way
3507 to match the longer operand. */
ceef8ce4
NB		 3508 primop0
3509 = convert (c_common_signed_or_unsigned_type (unsignedp0,
3510 TREE_TYPE (primop0)),
3511 primop0);
3512 primop1
3513 = convert (c_common_signed_or_unsigned_type (unsignedp1,
3514 TREE_TYPE (primop1)),
3515 primop1);
b30f223b
RS		 3516 }
3517 else
3518 {
3519 /* Here we must do the comparison on the nominal type
3520 using the args exactly as we received them. */
3521 type = *restype_ptr;
3522 primop0 = op0;
3523 primop1 = op1;
3524
3525 if (!real1 && !real2 && integer_zerop (primop1)
8df83eae 3526 && TYPE_UNSIGNED (*restype_ptr))
b30f223b
RS		 3527 {
3528 tree value = 0;
3529 switch (code)
3530 {
3531 case GE_EXPR:
f6aa72dd
MLI		 3532 /* All unsigned values are >= 0, so we warn. However,
3533 if OP0 is a constant that is >= 0, the signedness of
3534 the comparison isn't an issue, so suppress the
3535 warning. */
3536 if (warn_type_limits && !in_system_header
3f75a254
JM		 3537 && !(TREE_CODE (primop0) == INTEGER_CST
3538 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3539 primop0))))
b8698a0f 3540 warning (OPT_Wtype_limits,
f6aa72dd 3541 "comparison of unsigned expression >= 0 is always true");
de7df9eb 3542 value = truthvalue_true_node;
b30f223b
RS		 3543 break;
3544
3545 case LT_EXPR:
f6aa72dd 3546 if (warn_type_limits && !in_system_header
3f75a254
JM		 3547 && !(TREE_CODE (primop0) == INTEGER_CST
3548 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3549 primop0))))
b8698a0f 3550 warning (OPT_Wtype_limits,
f6aa72dd 3551 "comparison of unsigned expression < 0 is always false");
de7df9eb 3552 value = truthvalue_false_node;
6d819282
MK		 3553 break;
3554
3555 default:
3556 break;
b30f223b
RS		 3557 }
3558
3559 if (value != 0)
3560 {
3561 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3562 if (TREE_SIDE_EFFECTS (primop0))
53fb4de3
RS		 3563 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3564 primop0, value);
b30f223b
RS		 3565 return value;
3566 }
3567 }
3568 }
3569
3570 *op0_ptr = convert (type, primop0);
3571 *op1_ptr = convert (type, primop1);
3572
de7df9eb 3573 *restype_ptr = truthvalue_type_node;
b30f223b
RS		 3574
3575 return 0;
3576}
3577\f
7552da58
JJ		 3578/* Return a tree for the sum or difference (RESULTCODE says which)
3579 of pointer PTROP and integer INTOP. */
3580
3581tree
db3927fb
AH		 3582pointer_int_sum (location_t loc, enum tree_code resultcode,
3583 tree ptrop, tree intop)
7552da58 3584{
6ac01510 3585 tree size_exp, ret;
7552da58 3586
7552da58 3587 /* The result is a pointer of the same type that is being added. */
7552da58
JJ		 3588 tree result_type = TREE_TYPE (ptrop);
3589
3590 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3591 {
b8698a0f 3592 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
fcf73884 3593 "pointer of type %<void *%> used in arithmetic");
7552da58
JJ		 3594 size_exp = integer_one_node;
3595 }
3596 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3597 {
b8698a0f 3598 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
fcf73884 3599 "pointer to a function used in arithmetic");
7552da58
JJ		 3600 size_exp = integer_one_node;
3601 }
3602 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3603 {
b8698a0f 3604 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
fcf73884 3605 "pointer to member function used in arithmetic");
7552da58
JJ		 3606 size_exp = integer_one_node;
3607 }
7552da58
JJ		 3608 else
3609 size_exp = size_in_bytes (TREE_TYPE (result_type));
3610
6ac01510
ILT		 3611 /* We are manipulating pointer values, so we don't need to warn
3612 about relying on undefined signed overflow. We disable the
3613 warning here because we use integer types so fold won't know that
3614 they are really pointers. */
3615 fold_defer_overflow_warnings ();
3616
7552da58
JJ		 3617 /* If what we are about to multiply by the size of the elements
3618 contains a constant term, apply distributive law
3619 and multiply that constant term separately.
3620 This helps produce common subexpressions. */
7552da58 3621 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3f75a254 3622 && !TREE_CONSTANT (intop)
7552da58
JJ		 3623 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3624 && TREE_CONSTANT (size_exp)
3625 /* If the constant comes from pointer subtraction,
3626 skip this optimization--it would cause an error. */
3627 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3628 /* If the constant is unsigned, and smaller than the pointer size,
3629 then we must skip this optimization. This is because it could cause
3630 an overflow error if the constant is negative but INTOP is not. */
3f75a254 3631 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
7552da58
JJ		 3632 || (TYPE_PRECISION (TREE_TYPE (intop))
3633 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3634 {
3635 enum tree_code subcode = resultcode;
3636 tree int_type = TREE_TYPE (intop);
3637 if (TREE_CODE (intop) == MINUS_EXPR)
3638 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3639 /* Convert both subexpression types to the type of intop,
3640 because weird cases involving pointer arithmetic
3641 can result in a sum or difference with different type args. */
ba47d38d
AH		 3642 ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3643 subcode, ptrop,
7552da58
JJ		 3644 convert (int_type, TREE_OPERAND (intop, 1)), 1);
3645 intop = convert (int_type, TREE_OPERAND (intop, 0));
3646 }
3647
3648 /* Convert the integer argument to a type the same size as sizetype
3649 so the multiply won't overflow spuriously. */
7552da58 3650 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
8df83eae 3651 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
35b1a6fa 3652 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
8df83eae 3653 TYPE_UNSIGNED (sizetype)), intop);
7552da58
JJ		 3654
3655 /* Replace the integer argument with a suitable product by the object size.
9e9ef331
EB		 3656 Do this multiplication as signed, then convert to the appropriate type
3657 for the pointer operation and disregard an overflow that occured only
3658 because of the sign-extension change in the latter conversion. */
3659 {
3660 tree t = build_binary_op (loc,
3661 MULT_EXPR, intop,
3662 convert (TREE_TYPE (intop), size_exp), 1);
3663 intop = convert (sizetype, t);
3664 if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3665 intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3666 TREE_INT_CST_HIGH (intop));
3667 }
5be014d5 3668
280f1ffa 3669 /* Create the sum or difference. */
5be014d5 3670 if (resultcode == MINUS_EXPR)
db3927fb 3671 intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
7552da58 3672
db3927fb 3673 ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
6ac01510
ILT		 3674
3675 fold_undefer_and_ignore_overflow_warnings ();
3676
3677 return ret;
7552da58
JJ		 3678}
3679\f
e5a94231
JM		 3680/* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3681 and if NON_CONST is known not to be permitted in an evaluated part
3682 of a constant expression. */
3683
3684tree
3685c_wrap_maybe_const (tree expr, bool non_const)
3686{
3687 bool nowarning = TREE_NO_WARNING (expr);
3688 location_t loc = EXPR_LOCATION (expr);
3689
3690 /* This should never be called for C++. */
3691 if (c_dialect_cxx ())
3692 gcc_unreachable ();
3693
3694 /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING. */
3695 STRIP_TYPE_NOPS (expr);
3696 expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3697 C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3698 if (nowarning)
3699 TREE_NO_WARNING (expr) = 1;
3700 protected_set_expr_location (expr, loc);
3701
3702 return expr;
3703}
3704
928c19bb
JM		 3705/* Wrap a SAVE_EXPR around EXPR, if appropriate. Like save_expr, but
3706 for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3707 around the SAVE_EXPR if needed so that c_fully_fold does not need
3708 to look inside SAVE_EXPRs. */
3709
3710tree
3711c_save_expr (tree expr)
3712{
3713 bool maybe_const = true;
3714 if (c_dialect_cxx ())
3715 return save_expr (expr);
3716 expr = c_fully_fold (expr, false, &maybe_const);
3717 expr = save_expr (expr);
3718 if (!maybe_const)
e5a94231 3719 expr = c_wrap_maybe_const (expr, true);
928c19bb
JM		 3720 return expr;
3721}
3722
b3c6d2ea
ILT		 3723/* Return whether EXPR is a declaration whose address can never be
3724 NULL. */
3725
3726bool
58f9752a 3727decl_with_nonnull_addr_p (const_tree expr)
b3c6d2ea
ILT		 3728{
3729 return (DECL_P (expr)
3730 && (TREE_CODE (expr) == PARM_DECL
3731 || TREE_CODE (expr) == LABEL_DECL
3732 || !DECL_WEAK (expr)));
3733}
3734
b30f223b 3735/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
85498824
JM		 3736 or for an `if' or `while' statement or ?..: exp. It should already
3737 have been validated to be of suitable type; otherwise, a bad
3738 diagnostic may result.
b30f223b 3739
ba47d38d
AH		 3740 The EXPR is located at LOCATION.
3741
b30f223b
RS		 3742 This preparation consists of taking the ordinary
3743 representation of an expression expr and producing a valid tree
3744 boolean expression describing whether expr is nonzero. We could
de7df9eb 3745 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
b30f223b
RS		 3746 but we optimize comparisons, &&, ||, and !.
3747
de7df9eb 3748 The resulting type should always be `truthvalue_type_node'. */
b30f223b
RS		 3749
3750tree
ba47d38d 3751c_common_truthvalue_conversion (location_t location, tree expr)
b30f223b 3752{
b30f223b
RS		 3753 switch (TREE_CODE (expr))
3754 {
d1a7edaf 3755 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
6f312d18
ZW		 3756 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3757 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3758 case ORDERED_EXPR: case UNORDERED_EXPR:
90ec750d
RS		 3759 if (TREE_TYPE (expr) == truthvalue_type_node)
3760 return expr;
c2255bc4 3761 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
90ec750d 3762 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
c2255bc4 3763 goto ret;
90ec750d 3764
b30f223b
RS		 3765 case TRUTH_ANDIF_EXPR:
3766 case TRUTH_ORIF_EXPR:
3767 case TRUTH_AND_EXPR:
3768 case TRUTH_OR_EXPR:
9379fac9 3769 case TRUTH_XOR_EXPR:
90ec750d
RS		 3770 if (TREE_TYPE (expr) == truthvalue_type_node)
3771 return expr;
c2255bc4 3772 expr = build2 (TREE_CODE (expr), truthvalue_type_node,
b8698a0f 3773 c_common_truthvalue_conversion (location,
c2255bc4
AH		 3774 TREE_OPERAND (expr, 0)),
3775 c_common_truthvalue_conversion (location,
3776 TREE_OPERAND (expr, 1)));
3777 goto ret;
18c0f675 3778
18d00205 3779 case TRUTH_NOT_EXPR:
90ec750d
RS		 3780 if (TREE_TYPE (expr) == truthvalue_type_node)
3781 return expr;
c2255bc4
AH		 3782 expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3783 c_common_truthvalue_conversion (location,
3784 TREE_OPERAND (expr, 0)));
3785 goto ret;
18d00205 3786
b30f223b
RS		 3787 case ERROR_MARK:
3788 return expr;
3789
3790 case INTEGER_CST:
d95787e6
RS		 3791 return integer_zerop (expr) ? truthvalue_false_node
3792 : truthvalue_true_node;
b30f223b
RS		 3793
3794 case REAL_CST:
010c4d9c
RS		 3795 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3796 ? truthvalue_true_node
3797 : truthvalue_false_node;
b30f223b 3798
ab22c1fa
CF		 3799 case FIXED_CST:
3800 return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3801 &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3802 ? truthvalue_true_node
3803 : truthvalue_false_node;
3804
90ec750d 3805 case FUNCTION_DECL:
c9f9eb5d 3806 expr = build_unary_op (location, ADDR_EXPR, expr, 0);
90ec750d
RS		 3807 /* Fall through. */
3808
b30f223b 3809 case ADDR_EXPR:
1998463c 3810 {
f6f08360 3811 tree inner = TREE_OPERAND (expr, 0);
b3c6d2ea 3812 if (decl_with_nonnull_addr_p (inner))
1998463c 3813 {
b3c6d2ea 3814 /* Common Ada/Pascal programmer's mistake. */
ba47d38d
AH		 3815 warning_at (location,
3816 OPT_Waddress,
3817 "the address of %qD will always evaluate as %<true%>",
3818 inner);
1998463c
SB		 3819 return truthvalue_true_node;
3820 }
33766b66 3821 break;
1998463c 3822 }
b30f223b 3823
766f6c30 3824 case COMPLEX_EXPR:
c2255bc4 3825 expr = build_binary_op (EXPR_LOCATION (expr),
ba47d38d 3826 (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
b839fb3f 3827 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
ba47d38d
AH		 3828 c_common_truthvalue_conversion (location,
3829 TREE_OPERAND (expr, 0)),
3830 c_common_truthvalue_conversion (location,
3831 TREE_OPERAND (expr, 1)),
766f6c30 3832 0);
c2255bc4 3833 goto ret;
766f6c30 3834
b30f223b
RS		 3835 case NEGATE_EXPR:
3836 case ABS_EXPR:
3837 case FLOAT_EXPR:
8ce94e44 3838 case EXCESS_PRECISION_EXPR:
da7d8304 3839 /* These don't change whether an object is nonzero or zero. */
ba47d38d 3840 return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
b30f223b
RS		 3841
3842 case LROTATE_EXPR:
3843 case RROTATE_EXPR:
da7d8304 3844 /* These don't change whether an object is zero or nonzero, but
b30f223b
RS		 3845 we can't ignore them if their second arg has side-effects. */
3846 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
c2255bc4
AH		 3847 {
3848 expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
3849 TREE_OPERAND (expr, 1),
b8698a0f 3850 c_common_truthvalue_conversion
c2255bc4
AH		 3851 (location, TREE_OPERAND (expr, 0)));
3852 goto ret;
3853 }
b30f223b 3854 else
ba47d38d
AH		 3855 return c_common_truthvalue_conversion (location,
3856 TREE_OPERAND (expr, 0));
b57062ca 3857
b30f223b
RS		 3858 case COND_EXPR:
3859 /* Distribute the conversion into the arms of a COND_EXPR. */
928c19bb 3860 if (c_dialect_cxx ())
c2255bc4 3861 {
db3927fb 3862 expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
c2255bc4
AH		 3863 TREE_OPERAND (expr, 0),
3864 c_common_truthvalue_conversion (location,
3865 TREE_OPERAND (expr,
3866 1)),
3867 c_common_truthvalue_conversion (location,
3868 TREE_OPERAND (expr,
3869 2)));
3870 goto ret;
3871 }
928c19bb 3872 else
c2255bc4
AH		 3873 {
3874 /* Folding will happen later for C. */
3875 expr = build3 (COND_EXPR, truthvalue_type_node,
3876 TREE_OPERAND (expr, 0),
3877 c_common_truthvalue_conversion (location,
3878 TREE_OPERAND (expr, 1)),
3879 c_common_truthvalue_conversion (location,
3880 TREE_OPERAND (expr, 2)));
3881 goto ret;
3882 }
b30f223b 3883
1043771b 3884 CASE_CONVERT:
b30f223b
RS		 3885 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3886 since that affects how `default_conversion' will behave. */
3887 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3888 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3889 break;
b30f223b
RS		 3890 /* If this is widening the argument, we can ignore it. */
3891 if (TYPE_PRECISION (TREE_TYPE (expr))
3892 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
ba47d38d
AH		 3893 return c_common_truthvalue_conversion (location,
3894 TREE_OPERAND (expr, 0));
b30f223b
RS		 3895 break;
3896
e2aab13d 3897 case MODIFY_EXPR:
fbc8d2d3
ILT		 3898 if (!TREE_NO_WARNING (expr)
3899 && warn_parentheses)
3900 {
3901 warning (OPT_Wparentheses,
3902 "suggest parentheses around assignment used as truth value");
3903 TREE_NO_WARNING (expr) = 1;
3904 }
e2aab13d 3905 break;
b57062ca 3906
6d819282
MK		 3907 default:
3908 break;
b30f223b
RS		 3909 }
3910
f0b996c5 3911 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
f0b8d9aa 3912 {
928c19bb 3913 tree t = c_save_expr (expr);
c2255bc4 3914 expr = (build_binary_op
ba47d38d
AH		 3915 (EXPR_LOCATION (expr),
3916 (TREE_SIDE_EFFECTS (expr)
f0b8d9aa 3917 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
c9f9eb5d
AH		 3918 c_common_truthvalue_conversion
3919 (location,
3920 build_unary_op (location, REALPART_EXPR, t, 0)),
3921 c_common_truthvalue_conversion
3922 (location,
3923 build_unary_op (location, IMAGPART_EXPR, t, 0)),
f0b8d9aa 3924 0));
c2255bc4 3925 goto ret;
f0b8d9aa 3926 }
f0b996c5 3927
ab22c1fa
CF		 3928 if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3929 {
3930 tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3931 FCONST0 (TYPE_MODE
3932 (TREE_TYPE (expr))));
ca80e52b 3933 return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
ab22c1fa 3934 }
c2255bc4
AH		 3935 else
3936 return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
ab22c1fa 3937
c2255bc4
AH		 3938 ret:
3939 protected_set_expr_location (expr, location);
3940 return expr;
b30f223b
RS		 3941}
3942\f
9bc15050
RG		 3943static void def_builtin_1 (enum built_in_function fncode,
3944 const char *name,
3945 enum built_in_class fnclass,
3946 tree fntype, tree libtype,
3947 bool both_p, bool fallback_p, bool nonansi_p,
3948 tree fnattrs, bool implicit_p);
fc2aaf30 3949
3932261a
MM		 3950
3951/* Apply the TYPE_QUALS to the new DECL. */
3952
3953void
35b1a6fa 3954c_apply_type_quals_to_decl (int type_quals, tree decl)
3932261a 3955{
4b011bbf 3956 tree type = TREE_TYPE (decl);
9f63daea 3957
5a6159dd
AP		 3958 if (type == error_mark_node)
3959 return;
4b011bbf
JM		 3960
3961 if (((type_quals & TYPE_QUAL_CONST)
3962 || (type && TREE_CODE (type) == REFERENCE_TYPE))
3963 /* An object declared 'const' is only readonly after it is
3964 initialized. We don't have any way of expressing this currently,
3965 so we need to be conservative and unset TREE_READONLY for types
3966 with constructors. Otherwise aliasing code will ignore stores in
3967 an inline constructor. */
3968 && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3932261a
MM		 3969 TREE_READONLY (decl) = 1;
3970 if (type_quals & TYPE_QUAL_VOLATILE)
3971 {
3972 TREE_SIDE_EFFECTS (decl) = 1;
3973 TREE_THIS_VOLATILE (decl) = 1;
3974 }
6946bc60 3975 if (type_quals & TYPE_QUAL_RESTRICT)
3932261a 3976 {
4b011bbf
JM		 3977 while (type && TREE_CODE (type) == ARRAY_TYPE)
3978 /* Allow 'restrict' on arrays of pointers.
3979 FIXME currently we just ignore it. */
3980 type = TREE_TYPE (type);
3981 if (!type
3982 || !POINTER_TYPE_P (type)
3983 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
bda67431 3984 error ("invalid use of %<restrict%>");
3932261a
MM		 3985 }
3986}
3987
6de9cd9a
DN		 3988/* Hash function for the problem of multiple type definitions in
3989 different files. This must hash all types that will compare
3990 equal via comptypes to the same value. In practice it hashes
9cf737f8 3991 on some of the simple stuff and leaves the details to comptypes. */
6de9cd9a
DN		 3992
3993static hashval_t
3994c_type_hash (const void *p)
3995{
3996 int i = 0;
3997 int shift, size;
741ac903 3998 const_tree const t = (const_tree) p;
6de9cd9a
DN		 3999 tree t2;
4000 switch (TREE_CODE (t))
4001 {
8c27b7d4 4002 /* For pointers, hash on pointee type plus some swizzling. */
325c3691
RH		 4003 case POINTER_TYPE:
4004 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4005 /* Hash on number of elements and total size. */
4006 case ENUMERAL_TYPE:
4007 shift = 3;
4008 t2 = TYPE_VALUES (t);
4009 break;
4010 case RECORD_TYPE:
4011 shift = 0;
4012 t2 = TYPE_FIELDS (t);
4013 break;
4014 case QUAL_UNION_TYPE:
4015 shift = 1;
4016 t2 = TYPE_FIELDS (t);
4017 break;
4018 case UNION_TYPE:
4019 shift = 2;
4020 t2 = TYPE_FIELDS (t);
4021 break;
4022 default:
366de0ce 4023 gcc_unreachable ();
6de9cd9a 4024 }
910ad8de 4025 for (; t2; t2 = DECL_CHAIN (t2))
6de9cd9a 4026 i++;
6fc3c3c0
TT		 4027 /* We might have a VLA here. */
4028 if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4029 size = 0;
4030 else
4031 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
6de9cd9a
DN		 4032 return ((size << 24) | (i << shift));
4033}
4034
4fe52ce9
DJ		 4035static GTY((param_is (union tree_node))) htab_t type_hash_table;
4036
41472af8 4037/* Return the typed-based alias set for T, which may be an expression
3bdf5ad1 4038 or a type. Return -1 if we don't do anything special. */
41472af8 4039
4862826d 4040alias_set_type
35b1a6fa 4041c_common_get_alias_set (tree t)
41472af8 4042{
08bc2431 4043 tree u;
6de9cd9a 4044 PTR *slot;
35b1a6fa 4045
cb9c2485
JM		 4046 /* For VLAs, use the alias set of the element type rather than the
4047 default of alias set 0 for types compared structurally. */
4048 if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4049 {
4050 if (TREE_CODE (t) == ARRAY_TYPE)
4051 return get_alias_set (TREE_TYPE (t));
4052 return -1;
4053 }
4054
08bc2431
MM		 4055 /* Permit type-punning when accessing a union, provided the access
4056 is directly through the union. For example, this code does not
4057 permit taking the address of a union member and then storing
4058 through it. Even the type-punning allowed here is a GCC
4059 extension, albeit a common and useful one; the C standard says
4060 that such accesses have implementation-defined behavior. */
4061 for (u = t;
4062 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4063 u = TREE_OPERAND (u, 0))
4064 if (TREE_CODE (u) == COMPONENT_REF
4065 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4066 return 0;
ece32014 4067
74d86f4f 4068 /* That's all the expressions we handle specially. */
3f75a254 4069 if (!TYPE_P (t))
74d86f4f
RH		 4070 return -1;
4071
95bd1dd7 4072 /* The C standard guarantees that any object may be accessed via an
74d86f4f
RH		 4073 lvalue that has character type. */
4074 if (t == char_type_node
4075 || t == signed_char_type_node
4076 || t == unsigned_char_type_node)
3bdf5ad1 4077 return 0;
3932261a 4078
f824e5c3
RK		 4079 /* The C standard specifically allows aliasing between signed and
4080 unsigned variants of the same type. We treat the signed
4081 variant as canonical. */
8df83eae 4082 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
8f215dce 4083 {
ceef8ce4 4084 tree t1 = c_common_signed_type (t);
f824e5c3 4085
8f215dce
JJ		 4086 /* t1 == t can happen for boolean nodes which are always unsigned. */
4087 if (t1 != t)
4088 return get_alias_set (t1);
4089 }
3bdf5ad1 4090 else if (POINTER_TYPE_P (t))
02af3af6 4091 {
3bdf5ad1 4092 tree t1;
02af3af6
MS		 4093
4094 /* Unfortunately, there is no canonical form of a pointer type.
4095 In particular, if we have `typedef int I', then `int *', and
4096 `I *' are different types. So, we have to pick a canonical
4097 representative. We do this below.
d125d268 4098
b61148dd
MM		 4099 Technically, this approach is actually more conservative that
4100 it needs to be. In particular, `const int *' and `int *'
684d9f3b 4101 should be in different alias sets, according to the C and C++
b61148dd
MM		 4102 standard, since their types are not the same, and so,
4103 technically, an `int **' and `const int **' cannot point at
4104 the same thing.
4105
6de9cd9a 4106 But, the standard is wrong. In particular, this code is
b61148dd
MM		 4107 legal C++:
4108
c22cacf3
MS		 4109 int *ip;
4110 int **ipp = &ip;
4111 const int* const* cipp = ipp;
b61148dd 4112
6de9cd9a 4113 And, it doesn't make sense for that to be legal unless you
b61148dd
MM		 4114 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
4115 the pointed-to types. This issue has been reported to the
4116 C++ committee. */
12e1243e 4117 t1 = build_type_no_quals (t);
3bdf5ad1
RK		 4118 if (t1 != t)
4119 return get_alias_set (t1);
02af3af6 4120 }
ece32014 4121
6de9cd9a
DN		 4122 /* Handle the case of multiple type nodes referring to "the same" type,
4123 which occurs with IMA. These share an alias set. FIXME: Currently only
4124 C90 is handled. (In C99 type compatibility is not transitive, which
4125 complicates things mightily. The alias set splay trees can theoretically
4126 represent this, but insertion is tricky when you consider all the
4127 different orders things might arrive in.) */
4128
4129 if (c_language != clk_c || flag_isoc99)
4130 return -1;
4131
9cf737f8 4132 /* Save time if there's only one input file. */
d974312d 4133 if (num_in_fnames == 1)
6de9cd9a
DN		 4134 return -1;
4135
4136 /* Pointers need special handling if they point to any type that
4137 needs special handling (below). */
4138 if (TREE_CODE (t) == POINTER_TYPE)
4139 {
4140 tree t2;
4141 /* Find bottom type under any nested POINTERs. */
9f63daea 4142 for (t2 = TREE_TYPE (t);
762f7d9d
TT		 4143 TREE_CODE (t2) == POINTER_TYPE;
4144 t2 = TREE_TYPE (t2))
4145 ;
9f63daea 4146 if (TREE_CODE (t2) != RECORD_TYPE
762f7d9d
TT		 4147 && TREE_CODE (t2) != ENUMERAL_TYPE
4148 && TREE_CODE (t2) != QUAL_UNION_TYPE
4149 && TREE_CODE (t2) != UNION_TYPE)
4150 return -1;
6de9cd9a 4151 if (TYPE_SIZE (t2) == 0)
762f7d9d 4152 return -1;
6de9cd9a
DN		 4153 }
4154 /* These are the only cases that need special handling. */
9f63daea 4155 if (TREE_CODE (t) != RECORD_TYPE
6de9cd9a
DN		 4156 && TREE_CODE (t) != ENUMERAL_TYPE
4157 && TREE_CODE (t) != QUAL_UNION_TYPE
4158 && TREE_CODE (t) != UNION_TYPE
4159 && TREE_CODE (t) != POINTER_TYPE)
4160 return -1;
4161 /* Undefined? */
4162 if (TYPE_SIZE (t) == 0)
4163 return -1;
4164
9f63daea 4165 /* Look up t in hash table. Only one of the compatible types within each
6de9cd9a
DN		 4166 alias set is recorded in the table. */
4167 if (!type_hash_table)
4fe52ce9 4168 type_hash_table = htab_create_ggc (1021, c_type_hash,
6de9cd9a
DN		 4169 (htab_eq) lang_hooks.types_compatible_p,
4170 NULL);
4171 slot = htab_find_slot (type_hash_table, t, INSERT);
4172 if (*slot != NULL)
6a3203c8
AP		 4173 {
4174 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4175 return TYPE_ALIAS_SET ((tree)*slot);
4176 }
6de9cd9a
DN		 4177 else
4178 /* Our caller will assign and record (in t) a new alias set; all we need
4179 to do is remember t in the hash table. */
4180 *slot = t;
4181
3bdf5ad1 4182 return -1;
41472af8 4183}
0213a355 4184\f
c2255bc4
AH		 4185/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4186 the second parameter indicates which OPERATOR is being applied.
4187 The COMPLAIN flag controls whether we should diagnose possibly
4188 ill-formed constructs or not. LOC is the location of the SIZEOF or
4189 TYPEOF operator. */
03a08664 4190
0213a355 4191tree
c2255bc4
AH		 4192c_sizeof_or_alignof_type (location_t loc,
4193 tree type, bool is_sizeof, int complain)
0213a355 4194{
fa72b064
GDR		 4195 const char *op_name;
4196 tree value = NULL;
4197 enum tree_code type_code = TREE_CODE (type);
35b1a6fa 4198
03a08664 4199 op_name = is_sizeof ? "sizeof" : "__alignof__";
35b1a6fa 4200
fa72b064 4201 if (type_code == FUNCTION_TYPE)
0213a355 4202 {
03a08664 4203 if (is_sizeof)
fa72b064 4204 {
ea793912 4205 if (complain && (pedantic || warn_pointer_arith))
b8698a0f 4206 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
fcf73884 4207 "invalid application of %<sizeof%> to a function type");
5ade1ed2
DG		 4208 else if (!complain)
4209 return error_mark_node;
fa72b064
GDR		 4210 value = size_one_node;
4211 }
4212 else
4213 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4214 }
4215 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4216 {
35b1a6fa 4217 if (type_code == VOID_TYPE
ea793912 4218 && complain && (pedantic || warn_pointer_arith))
b8698a0f 4219 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
fcf73884 4220 "invalid application of %qs to a void type", op_name);
5ade1ed2
DG		 4221 else if (!complain)
4222 return error_mark_node;
fa72b064 4223 value = size_one_node;
0213a355 4224 }
0213a355
JM		 4225 else if (!COMPLETE_TYPE_P (type))
4226 {
ea793912 4227 if (complain)
c2255bc4
AH		 4228 error_at (loc, "invalid application of %qs to incomplete type %qT ",
4229 op_name, type);
cb6addf4 4230 return error_mark_node;
0213a355
JM		 4231 }
4232 else
fa72b064 4233 {
03a08664 4234 if (is_sizeof)
fa72b064 4235 /* Convert in case a char is more than one unit. */
db3927fb
AH		 4236 value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4237 size_int (TYPE_PRECISION (char_type_node)
4238 / BITS_PER_UNIT));
fa72b064 4239 else
a4e9ffe5 4240 value = size_int (TYPE_ALIGN_UNIT (type));
fa72b064 4241 }
0213a355 4242
fa72b064
GDR		 4243 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4244 TYPE_IS_SIZETYPE means that certain things (like overflow) will
4245 never happen. However, this node should really have type
4246 `size_t', which is just a typedef for an ordinary integer type. */
db3927fb 4247 value = fold_convert_loc (loc, size_type_node, value);
4094f4d2 4248 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
35b1a6fa 4249
fa72b064 4250 return value;
0213a355
JM		 4251}
4252
4253/* Implement the __alignof keyword: Return the minimum required
837edd5f
GK		 4254 alignment of EXPR, measured in bytes. For VAR_DECLs,
4255 FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
c2255bc4
AH		 4256 from an "aligned" __attribute__ specification). LOC is the
4257 location of the ALIGNOF operator. */
7f4edbcb 4258
0213a355 4259tree
c2255bc4 4260c_alignof_expr (location_t loc, tree expr)
0213a355
JM		 4261{
4262 tree t;
4263
837edd5f 4264 if (VAR_OR_FUNCTION_DECL_P (expr))
a4e9ffe5 4265 t = size_int (DECL_ALIGN_UNIT (expr));
35b1a6fa 4266
0213a355
JM		 4267 else if (TREE_CODE (expr) == COMPONENT_REF
4268 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4269 {
c2255bc4 4270 error_at (loc, "%<__alignof%> applied to a bit-field");
0213a355
JM		 4271 t = size_one_node;
4272 }
4273 else if (TREE_CODE (expr) == COMPONENT_REF
173bf5be 4274 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
a4e9ffe5 4275 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
35b1a6fa 4276
0213a355
JM		 4277 else if (TREE_CODE (expr) == INDIRECT_REF)
4278 {
4279 tree t = TREE_OPERAND (expr, 0);
4280 tree best = t;
4281 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
35b1a6fa 4282
1043771b 4283 while (CONVERT_EXPR_P (t)
173bf5be 4284 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
0213a355
JM		 4285 {
4286 int thisalign;
4287
4288 t = TREE_OPERAND (t, 0);
4289 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4290 if (thisalign > bestalign)
4291 best = t, bestalign = thisalign;
4292 }
c2255bc4 4293 return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
0213a355
JM		 4294 }
4295 else
c2255bc4 4296 return c_alignof (loc, TREE_TYPE (expr));
0213a355 4297
db3927fb 4298 return fold_convert_loc (loc, size_type_node, t);
0213a355
JM		 4299}
4300\f
df061a43
RS		 4301/* Handle C and C++ default attributes. */
4302
4303enum built_in_attribute
4304{
4305#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4306#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4307#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4308#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
df061a43
RS		 4309#include "builtin-attrs.def"
4310#undef DEF_ATTR_NULL_TREE
4311#undef DEF_ATTR_INT
4312#undef DEF_ATTR_IDENT
4313#undef DEF_ATTR_TREE_LIST
df061a43
RS		 4314 ATTR_LAST
4315};
4316
4317static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4318
35b1a6fa 4319static void c_init_attributes (void);
df061a43 4320
a0274e3e 4321enum c_builtin_type
7f4edbcb 4322{
10841285
MM		 4323#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4324#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4325#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4326#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4327#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4328#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
10a0d495 4329#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
a0274e3e
JJ		 4330#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4331#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
10841285
MM		 4332#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4333#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4334#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
08291658 4335#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
10a0d495
JJ		 4336#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4337#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4338 NAME,
10841285
MM		 4339#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4340#include "builtin-types.def"
4341#undef DEF_PRIMITIVE_TYPE
4342#undef DEF_FUNCTION_TYPE_0
4343#undef DEF_FUNCTION_TYPE_1
4344#undef DEF_FUNCTION_TYPE_2
4345#undef DEF_FUNCTION_TYPE_3
4346#undef DEF_FUNCTION_TYPE_4
10a0d495
JJ		 4347#undef DEF_FUNCTION_TYPE_5
4348#undef DEF_FUNCTION_TYPE_6
a0274e3e 4349#undef DEF_FUNCTION_TYPE_7
10841285
MM		 4350#undef DEF_FUNCTION_TYPE_VAR_0
4351#undef DEF_FUNCTION_TYPE_VAR_1
4352#undef DEF_FUNCTION_TYPE_VAR_2
08291658 4353#undef DEF_FUNCTION_TYPE_VAR_3
10a0d495
JJ		 4354#undef DEF_FUNCTION_TYPE_VAR_4
4355#undef DEF_FUNCTION_TYPE_VAR_5
10841285 4356#undef DEF_POINTER_TYPE
a0274e3e
JJ		 4357 BT_LAST
4358};
4359
4360typedef enum c_builtin_type builtin_type;
10841285 4361
a0274e3e
JJ		 4362/* A temporary array for c_common_nodes_and_builtins. Used in
4363 communication with def_fn_type. */
4364static tree builtin_types[(int) BT_LAST + 1];
10841285 4365
a0274e3e
JJ		 4366/* A helper function for c_common_nodes_and_builtins. Build function type
4367 for DEF with return type RET and N arguments. If VAR is true, then the
4368 function should be variadic after those N arguments.
4369
4370 Takes special care not to ICE if any of the types involved are
4371 error_mark_node, which indicates that said type is not in fact available
4372 (see builtin_type_for_size). In which case the function type as a whole
4373 should be error_mark_node. */
4374
4375static void
4376def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4377{
4378 tree args = NULL, t;
4379 va_list list;
4380 int i;
4381
4382 va_start (list, n);
4383 for (i = 0; i < n; ++i)
4384 {
d75d71e0 4385 builtin_type a = (builtin_type) va_arg (list, int);
a0274e3e
JJ		 4386 t = builtin_types[a];
4387 if (t == error_mark_node)
4388 goto egress;
4389 args = tree_cons (NULL_TREE, t, args);
4390 }
4391 va_end (list);
4392
4393 args = nreverse (args);
4394 if (!var)
4395 args = chainon (args, void_list_node);
4396
4397 t = builtin_types[ret];
4398 if (t == error_mark_node)
4399 goto egress;
4400 t = build_function_type (t, args);
4401
4402 egress:
4403 builtin_types[def] = t;
4404}
4405
c6d86fce
ILT		 4406/* Build builtin functions common to both C and C++ language
4407 frontends. */
4408
4409static void
4410c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4411{
4412#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4413 builtin_types[ENUM] = VALUE;
4414#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4415 def_fn_type (ENUM, RETURN, 0, 0);
4416#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4417 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4418#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4419 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4420#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4421 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4422#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4423 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4424#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4425 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4426#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4427 ARG6) \
4428 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4429#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4430 ARG6, ARG7) \
4431 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4432#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4433 def_fn_type (ENUM, RETURN, 1, 0);
4434#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4435 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4436#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4437 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4438#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4439 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4440#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4441 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4442#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4443 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4444#define DEF_POINTER_TYPE(ENUM, TYPE) \
4445 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4446
4447#include "builtin-types.def"
4448
4449#undef DEF_PRIMITIVE_TYPE
4450#undef DEF_FUNCTION_TYPE_1
4451#undef DEF_FUNCTION_TYPE_2
4452#undef DEF_FUNCTION_TYPE_3
4453#undef DEF_FUNCTION_TYPE_4
4454#undef DEF_FUNCTION_TYPE_5
4455#undef DEF_FUNCTION_TYPE_6
4456#undef DEF_FUNCTION_TYPE_VAR_0
4457#undef DEF_FUNCTION_TYPE_VAR_1
4458#undef DEF_FUNCTION_TYPE_VAR_2
4459#undef DEF_FUNCTION_TYPE_VAR_3
4460#undef DEF_FUNCTION_TYPE_VAR_4
4461#undef DEF_FUNCTION_TYPE_VAR_5
4462#undef DEF_POINTER_TYPE
4463 builtin_types[(int) BT_LAST] = NULL_TREE;
4464
4465 c_init_attributes ();
4466
4467#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4468 NONANSI_P, ATTRS, IMPLICIT, COND) \
4469 if (NAME && COND) \
4470 def_builtin_1 (ENUM, NAME, CLASS, \
4471 builtin_types[(int) TYPE], \
4472 builtin_types[(int) LIBTYPE], \
4473 BOTH_P, FALLBACK_P, NONANSI_P, \
4474 built_in_attributes[(int) ATTRS], IMPLICIT);
4475#include "builtins.def"
4476#undef DEF_BUILTIN
4477
8de7ef2a
UB		 4478 targetm.init_builtins ();
4479
384c400a 4480 build_common_builtin_nodes ();
c6d86fce 4481
c6d86fce
ILT		 4482 if (flag_mudflap)
4483 mudflap_init ();
4484}
4485
c1b61fca
JM		 4486/* Like get_identifier, but avoid warnings about null arguments when
4487 the argument may be NULL for targets where GCC lacks stdint.h type
4488 information. */
4489
4490static inline tree
4491c_get_ident (const char *id)
4492{
4493 return get_identifier (id);
4494}
4495
a0274e3e
JJ		 4496/* Build tree nodes and builtin functions common to both C and C++ language
4497 frontends. */
4498
4499void
4500c_common_nodes_and_builtins (void)
4501{
b6baa67d
KVH		 4502 int char16_type_size;
4503 int char32_type_size;
eaa7c03f
JM		 4504 int wchar_type_size;
4505 tree array_domain_type;
9f720c3e 4506 tree va_list_ref_type_node;
daf68dd7 4507 tree va_list_arg_type_node;
d3707adb 4508
eaa7c03f 4509 /* Define `int' and `char' first so that dbx will output them first. */
6496a589 4510 record_builtin_type (RID_INT, NULL, integer_type_node);
eaa7c03f
JM		 4511 record_builtin_type (RID_CHAR, "char", char_type_node);
4512
4513 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
4514 "unsigned long", "long long unsigned" and "unsigned short" were in C++
4515 but not C. Are the conditionals here needed? */
37fa72e9 4516 if (c_dialect_cxx ())
6496a589 4517 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
eaa7c03f
JM		 4518 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4519 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4520 record_builtin_type (RID_MAX, "long unsigned int",
4521 long_unsigned_type_node);
a6766312
KT		 4522 if (int128_integer_type_node != NULL_TREE)
4523 {
4524 record_builtin_type (RID_INT128, "__int128",
4525 int128_integer_type_node);
4526 record_builtin_type (RID_MAX, "__int128 unsigned",
4527 int128_unsigned_type_node);
4528 }
37fa72e9 4529 if (c_dialect_cxx ())
eaa7c03f
JM		 4530 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4531 record_builtin_type (RID_MAX, "long long int",
4532 long_long_integer_type_node);
4533 record_builtin_type (RID_MAX, "long long unsigned int",
4534 long_long_unsigned_type_node);
37fa72e9 4535 if (c_dialect_cxx ())
eaa7c03f
JM		 4536 record_builtin_type (RID_MAX, "long long unsigned",
4537 long_long_unsigned_type_node);
4538 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4539 record_builtin_type (RID_MAX, "short unsigned int",
4540 short_unsigned_type_node);
37fa72e9 4541 if (c_dialect_cxx ())
eaa7c03f
JM		 4542 record_builtin_type (RID_MAX, "unsigned short",
4543 short_unsigned_type_node);
4544
4545 /* Define both `signed char' and `unsigned char'. */
4546 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4547 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4548
b0c48229
NB		 4549 /* These are types that c_common_type_for_size and
4550 c_common_type_for_mode use. */
c2255bc4
AH		 4551 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4552 TYPE_DECL, NULL_TREE,
ae2bcd98 4553 intQI_type_node));
c2255bc4
AH		 4554 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4555 TYPE_DECL, NULL_TREE,
ae2bcd98 4556 intHI_type_node));
c2255bc4
AH		 4557 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4558 TYPE_DECL, NULL_TREE,
ae2bcd98 4559 intSI_type_node));
c2255bc4
AH		 4560 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4561 TYPE_DECL, NULL_TREE,
ae2bcd98 4562 intDI_type_node));
eaa7c03f 4563#if HOST_BITS_PER_WIDE_INT >= 64
1e1b8649 4564 if (targetm.scalar_mode_supported_p (TImode))
c2255bc4
AH		 4565 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4566 TYPE_DECL,
1e1b8649
AP		 4567 get_identifier ("__int128_t"),
4568 intTI_type_node));
eaa7c03f 4569#endif
c2255bc4
AH		 4570 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4571 TYPE_DECL, NULL_TREE,
ae2bcd98 4572 unsigned_intQI_type_node));
c2255bc4
AH		 4573 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4574 TYPE_DECL, NULL_TREE,
ae2bcd98 4575 unsigned_intHI_type_node));
c2255bc4
AH		 4576 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4577 TYPE_DECL, NULL_TREE,
ae2bcd98 4578 unsigned_intSI_type_node));
c2255bc4
AH		 4579 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4580 TYPE_DECL, NULL_TREE,
ae2bcd98 4581 unsigned_intDI_type_node));
eaa7c03f 4582#if HOST_BITS_PER_WIDE_INT >= 64
1e1b8649 4583 if (targetm.scalar_mode_supported_p (TImode))
c2255bc4
AH		 4584 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4585 TYPE_DECL,
1e1b8649
AP		 4586 get_identifier ("__uint128_t"),
4587 unsigned_intTI_type_node));
eaa7c03f
JM		 4588#endif
4589
4590 /* Create the widest literal types. */
4591 widest_integer_literal_type_node
4592 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
c2255bc4
AH		 4593 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4594 TYPE_DECL, NULL_TREE,
ae2bcd98 4595 widest_integer_literal_type_node));
eaa7c03f
JM		 4596
4597 widest_unsigned_literal_type_node
4598 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
c2255bc4
AH		 4599 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4600 TYPE_DECL, NULL_TREE,
ae2bcd98 4601 widest_unsigned_literal_type_node));
eaa7c03f
JM		 4602
4603 /* `unsigned long' is the standard type for sizeof.
4604 Note that stddef.h uses `unsigned long',
4605 and this must agree, even if long and int are the same size. */
c9f8536c 4606 size_type_node =
eaa7c03f 4607 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
c9f8536c
MM		 4608 signed_size_type_node = c_common_signed_type (size_type_node);
4609 set_sizetype (size_type_node);
eaa7c03f 4610
d1c38823
ZD		 4611 pid_type_node =
4612 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4613
eaa7c03f
JM		 4614 build_common_tree_nodes_2 (flag_short_double);
4615
6496a589
KG		 4616 record_builtin_type (RID_FLOAT, NULL, float_type_node);
4617 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
eaa7c03f
JM		 4618 record_builtin_type (RID_MAX, "long double", long_double_type_node);
4619
9a8ce21f
JG		 4620 /* Only supported decimal floating point extension if the target
4621 actually supports underlying modes. */
b8698a0f 4622 if (targetm.scalar_mode_supported_p (SDmode)
9a8ce21f
JG		 4623 && targetm.scalar_mode_supported_p (DDmode)
4624 && targetm.scalar_mode_supported_p (TDmode))
4625 {
4626 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4627 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4628 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4629 }
4630
ab22c1fa
CF		 4631 if (targetm.fixed_point_supported_p ())
4632 {
4633 record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4634 record_builtin_type (RID_FRACT, NULL, fract_type_node);
4635 record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4636 record_builtin_type (RID_MAX, "long long _Fract",
4637 long_long_fract_type_node);
4638 record_builtin_type (RID_MAX, "unsigned short _Fract",
4639 unsigned_short_fract_type_node);
4640 record_builtin_type (RID_MAX, "unsigned _Fract",
4641 unsigned_fract_type_node);
4642 record_builtin_type (RID_MAX, "unsigned long _Fract",
4643 unsigned_long_fract_type_node);
4644 record_builtin_type (RID_MAX, "unsigned long long _Fract",
4645 unsigned_long_long_fract_type_node);
4646 record_builtin_type (RID_MAX, "_Sat short _Fract",
4647 sat_short_fract_type_node);
4648 record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4649 record_builtin_type (RID_MAX, "_Sat long _Fract",
4650 sat_long_fract_type_node);
4651 record_builtin_type (RID_MAX, "_Sat long long _Fract",
4652 sat_long_long_fract_type_node);
4653 record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4654 sat_unsigned_short_fract_type_node);
4655 record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4656 sat_unsigned_fract_type_node);
4657 record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4658 sat_unsigned_long_fract_type_node);
4659 record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4660 sat_unsigned_long_long_fract_type_node);
4661 record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4662 record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4663 record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4664 record_builtin_type (RID_MAX, "long long _Accum",
4665 long_long_accum_type_node);
4666 record_builtin_type (RID_MAX, "unsigned short _Accum",
4667 unsigned_short_accum_type_node);
4668 record_builtin_type (RID_MAX, "unsigned _Accum",
4669 unsigned_accum_type_node);
4670 record_builtin_type (RID_MAX, "unsigned long _Accum",
4671 unsigned_long_accum_type_node);
4672 record_builtin_type (RID_MAX, "unsigned long long _Accum",
4673 unsigned_long_long_accum_type_node);
4674 record_builtin_type (RID_MAX, "_Sat short _Accum",
4675 sat_short_accum_type_node);
4676 record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4677 record_builtin_type (RID_MAX, "_Sat long _Accum",
4678 sat_long_accum_type_node);
4679 record_builtin_type (RID_MAX, "_Sat long long _Accum",
4680 sat_long_long_accum_type_node);
4681 record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4682 sat_unsigned_short_accum_type_node);
4683 record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4684 sat_unsigned_accum_type_node);
4685 record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4686 sat_unsigned_long_accum_type_node);
4687 record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4688 sat_unsigned_long_long_accum_type_node);
4689
4690 }
4691
c2255bc4
AH		 4692 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4693 TYPE_DECL,
ae2bcd98
RS		 4694 get_identifier ("complex int"),
4695 complex_integer_type_node));
c2255bc4
AH		 4696 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4697 TYPE_DECL,
ae2bcd98
RS		 4698 get_identifier ("complex float"),
4699 complex_float_type_node));
c2255bc4
AH		 4700 lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4701 TYPE_DECL,
ae2bcd98
RS		 4702 get_identifier ("complex double"),
4703 complex_double_type_node));
4704 lang_hooks.decls.pushdecl
c2255bc4
AH		 4705 (build_decl (UNKNOWN_LOCATION,
4706 TYPE_DECL, get_identifier ("complex long double"),
43577e6b 4707 complex_long_double_type_node));
eaa7c03f 4708
498c0f27
JJ		 4709 if (c_dialect_cxx ())
4710 /* For C++, make fileptr_type_node a distinct void * type until
4711 FILE type is defined. */
8dd16ecc 4712 fileptr_type_node = build_variant_type_copy (ptr_type_node);
498c0f27 4713
6496a589 4714 record_builtin_type (RID_VOID, NULL, void_type_node);
eaa7c03f 4715
06d40de8
DG		 4716 /* Set the TYPE_NAME for any variants that were built before
4717 record_builtin_type gave names to the built-in types. */
4718 {
4719 tree void_name = TYPE_NAME (void_type_node);
4720 TYPE_NAME (void_type_node) = NULL_TREE;
4721 TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4722 = void_name;
4723 TYPE_NAME (void_type_node) = void_name;
4724 }
4725
8c27b7d4 4726 /* This node must not be shared. */
4a90aeeb 4727 void_zero_node = make_node (INTEGER_CST);
10841285
MM		 4728 TREE_TYPE (void_zero_node) = void_type_node;
4729
eaa7c03f
JM		 4730 void_list_node = build_void_list_node ();
4731
4732 /* Make a type to be the domain of a few array types
4733 whose domains don't really matter.
4734 200 is small enough that it always fits in size_t
4735 and large enough that it can hold most function names for the
4736 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
4737 array_domain_type = build_index_type (size_int (200));
4738
4739 /* Make a type for arrays of characters.
4740 With luck nothing will ever really depend on the length of this
4741 array type. */
4742 char_array_type_node
4743 = build_array_type (char_type_node, array_domain_type);
4744
4745 /* Likewise for arrays of ints. */
4746 int_array_type_node
4747 = build_array_type (integer_type_node, array_domain_type);
4748
10841285
MM		 4749 string_type_node = build_pointer_type (char_type_node);
4750 const_string_type_node
4751 = build_pointer_type (build_qualified_type
4752 (char_type_node, TYPE_QUAL_CONST));
4753
eaa7c03f 4754 /* This is special for C++ so functions can be overloaded. */
a11eba95 4755 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
eaa7c03f
JM		 4756 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4757 wchar_type_size = TYPE_PRECISION (wchar_type_node);
207bf79d 4758 underlying_wchar_type_node = wchar_type_node;
37fa72e9 4759 if (c_dialect_cxx ())
eaa7c03f 4760 {
8df83eae 4761 if (TYPE_UNSIGNED (wchar_type_node))
eaa7c03f
JM		 4762 wchar_type_node = make_unsigned_type (wchar_type_size);
4763 else
4764 wchar_type_node = make_signed_type (wchar_type_size);
4765 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4766 }
eaa7c03f
JM		 4767
4768 /* This is for wide string constants. */
4769 wchar_array_type_node
4770 = build_array_type (wchar_type_node, array_domain_type);
4771
b6baa67d
KVH		 4772 /* Define 'char16_t'. */
4773 char16_type_node = get_identifier (CHAR16_TYPE);
4774 char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4775 char16_type_size = TYPE_PRECISION (char16_type_node);
4776 if (c_dialect_cxx ())
4777 {
4778 char16_type_node = make_unsigned_type (char16_type_size);
4779
4780 if (cxx_dialect == cxx0x)
4781 record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4782 }
4783
4784 /* This is for UTF-16 string constants. */
4785 char16_array_type_node
4786 = build_array_type (char16_type_node, array_domain_type);
4787
4788 /* Define 'char32_t'. */
4789 char32_type_node = get_identifier (CHAR32_TYPE);
4790 char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4791 char32_type_size = TYPE_PRECISION (char32_type_node);
4792 if (c_dialect_cxx ())
4793 {
4794 char32_type_node = make_unsigned_type (char32_type_size);
4795
4796 if (cxx_dialect == cxx0x)
4797 record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4798 }
4799
4800 /* This is for UTF-32 string constants. */
4801 char32_array_type_node
4802 = build_array_type (char32_type_node, array_domain_type);
4803
5fd8e536
JM		 4804 wint_type_node =
4805 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4806
4807 intmax_type_node =
4808 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4809 uintmax_type_node =
4810 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4811
207bf79d
JM		 4812 if (SIG_ATOMIC_TYPE)
4813 sig_atomic_type_node =
c1b61fca 4814 TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
207bf79d
JM		 4815 if (INT8_TYPE)
4816 int8_type_node =
c1b61fca 4817 TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
207bf79d
JM		 4818 if (INT16_TYPE)
4819 int16_type_node =
c1b61fca 4820 TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
207bf79d
JM		 4821 if (INT32_TYPE)
4822 int32_type_node =
c1b61fca 4823 TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
207bf79d
JM		 4824 if (INT64_TYPE)
4825 int64_type_node =
c1b61fca 4826 TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
207bf79d
JM		 4827 if (UINT8_TYPE)
4828 uint8_type_node =
c1b61fca 4829 TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
207bf79d
JM		 4830 if (UINT16_TYPE)
4831 uint16_type_node =
c1b61fca 4832 TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
207bf79d
JM		 4833 if (UINT32_TYPE)
4834 c_uint32_type_node =
c1b61fca 4835 TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
207bf79d
JM		 4836 if (UINT64_TYPE)
4837 c_uint64_type_node =
c1b61fca 4838 TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
207bf79d
JM		 4839 if (INT_LEAST8_TYPE)
4840 int_least8_type_node =
c1b61fca 4841 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
207bf79d
JM		 4842 if (INT_LEAST16_TYPE)
4843 int_least16_type_node =
c1b61fca 4844 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
207bf79d
JM		 4845 if (INT_LEAST32_TYPE)
4846 int_least32_type_node =
c1b61fca 4847 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
207bf79d
JM		 4848 if (INT_LEAST64_TYPE)
4849 int_least64_type_node =
c1b61fca 4850 TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
207bf79d
JM		 4851 if (UINT_LEAST8_TYPE)
4852 uint_least8_type_node =
c1b61fca 4853 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
207bf79d
JM		 4854 if (UINT_LEAST16_TYPE)
4855 uint_least16_type_node =
c1b61fca 4856 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
207bf79d
JM		 4857 if (UINT_LEAST32_TYPE)
4858 uint_least32_type_node =
c1b61fca 4859 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
207bf79d
JM		 4860 if (UINT_LEAST64_TYPE)
4861 uint_least64_type_node =
c1b61fca 4862 TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
207bf79d
JM		 4863 if (INT_FAST8_TYPE)
4864 int_fast8_type_node =
c1b61fca 4865 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
207bf79d
JM		 4866 if (INT_FAST16_TYPE)
4867 int_fast16_type_node =
c1b61fca 4868 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
207bf79d
JM		 4869 if (INT_FAST32_TYPE)
4870 int_fast32_type_node =
c1b61fca 4871 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
207bf79d
JM		 4872 if (INT_FAST64_TYPE)
4873 int_fast64_type_node =
c1b61fca 4874 TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
207bf79d
JM		 4875 if (UINT_FAST8_TYPE)
4876 uint_fast8_type_node =
c1b61fca 4877 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
207bf79d
JM		 4878 if (UINT_FAST16_TYPE)
4879 uint_fast16_type_node =
c1b61fca 4880 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
207bf79d
JM		 4881 if (UINT_FAST32_TYPE)
4882 uint_fast32_type_node =
c1b61fca 4883 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
207bf79d
JM		 4884 if (UINT_FAST64_TYPE)
4885 uint_fast64_type_node =
c1b61fca 4886 TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
207bf79d
JM		 4887 if (INTPTR_TYPE)
4888 intptr_type_node =
c1b61fca 4889 TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
207bf79d
JM		 4890 if (UINTPTR_TYPE)
4891 uintptr_type_node =
c1b61fca 4892 TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
207bf79d 4893
5fd8e536
JM		 4894 default_function_type = build_function_type (integer_type_node, NULL_TREE);
4895 ptrdiff_type_node
4896 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
12753674 4897 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5fd8e536 4898
ae2bcd98 4899 lang_hooks.decls.pushdecl
c2255bc4
AH		 4900 (build_decl (UNKNOWN_LOCATION,
4901 TYPE_DECL, get_identifier ("__builtin_va_list"),
43577e6b 4902 va_list_type_node));
38f8b050 4903 if (targetm.enum_va_list_p)
d4048208
KT		 4904 {
4905 int l;
4906 const char *pname;
4907 tree ptype;
35cbb299 4908
38f8b050 4909 for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
d4048208
KT		 4910 {
4911 lang_hooks.decls.pushdecl
4912 (build_decl (UNKNOWN_LOCATION,
4913 TYPE_DECL, get_identifier (pname),
4914 ptype));
4915
4916 }
4917 }
daf68dd7 4918
daf68dd7 4919 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
9f720c3e
GK		 4920 {
4921 va_list_arg_type_node = va_list_ref_type_node =
4922 build_pointer_type (TREE_TYPE (va_list_type_node));
4923 }
daf68dd7 4924 else
9f720c3e
GK		 4925 {
4926 va_list_arg_type_node = va_list_type_node;
4927 va_list_ref_type_node = build_reference_type (va_list_type_node);
4928 }
35b1a6fa 4929
c6d86fce
ILT		 4930 if (!flag_preprocess_only)
4931 c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4677862a 4932
5b47282c 4933 main_identifier_node = get_identifier ("main");
b2f97e4a
MM		 4934
4935 /* Create the built-in __null node. It is important that this is
4936 not shared. */
4937 null_node = make_node (INTEGER_CST);
4938 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
a0274e3e
JJ		 4939
4940 /* Since builtin_types isn't gc'ed, don't export these nodes. */
4941 memset (builtin_types, 0, sizeof (builtin_types));
7f4edbcb 4942}
d3707adb 4943
3b2db49f
MM		 4944/* The number of named compound-literals generated thus far. */
4945static GTY(()) int compound_literal_number;
4946
4947/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
4948
4949void
4950set_compound_literal_name (tree decl)
4951{
4952 char *name;
4953 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4954 compound_literal_number);
4955 compound_literal_number++;
4956 DECL_NAME (decl) = get_identifier (name);
4957}
4958
d3707adb 4959tree
c2255bc4 4960build_va_arg (location_t loc, tree expr, tree type)
d3707adb 4961{
c2255bc4
AH		 4962 expr = build1 (VA_ARG_EXPR, type, expr);
4963 SET_EXPR_LOCATION (expr, loc);
4964 return expr;
d3707adb 4965}
fc2aaf30
JM		 4966
4967
7d14c755
JM		 4968/* Linked list of disabled built-in functions. */
4969
4970typedef struct disabled_builtin
4971{
4972 const char *name;
4973 struct disabled_builtin *next;
4974} disabled_builtin;
4975static disabled_builtin *disabled_builtins = NULL;
4976
35b1a6fa 4977static bool builtin_function_disabled_p (const char *);
7d14c755
JM		 4978
4979/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
4980 begins with "__builtin_", give an error. */
4981
4982void
35b1a6fa 4983disable_builtin_function (const char *name)
7d14c755
JM		 4984{
4985 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
bda67431 4986 error ("cannot disable built-in function %qs", name);
7d14c755
JM		 4987 else
4988 {
1ad463f4
BI		 4989 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4990 new_disabled_builtin->name = name;
4991 new_disabled_builtin->next = disabled_builtins;
4992 disabled_builtins = new_disabled_builtin;
7d14c755
JM		 4993 }
4994}
4995
4996
4997/* Return true if the built-in function NAME has been disabled, false
4998 otherwise. */
4999
5000static bool
35b1a6fa 5001builtin_function_disabled_p (const char *name)
7d14c755
JM		 5002{
5003 disabled_builtin *p;
5004 for (p = disabled_builtins; p != NULL; p = p->next)
5005 {
5006 if (strcmp (name, p->name) == 0)
5007 return true;
5008 }
5009 return false;
5010}
5011
5012
9bc15050
RG		 5013/* Worker for DEF_BUILTIN.
5014 Possibly define a builtin function with one or two names.
5015 Does not declare a non-__builtin_ function if flag_no_builtin, or if
5016 nonansi_p and flag_no_nonansi_builtin. */
fc2aaf30 5017
9bc15050
RG		 5018static void
5019def_builtin_1 (enum built_in_function fncode,
5020 const char *name,
5021 enum built_in_class fnclass,
5022 tree fntype, tree libtype,
5023 bool both_p, bool fallback_p, bool nonansi_p,
5024 tree fnattrs, bool implicit_p)
fc2aaf30 5025{
9bc15050
RG		 5026 tree decl;
5027 const char *libname;
5028
a0274e3e
JJ		 5029 if (fntype == error_mark_node)
5030 return;
5031
9bc15050
RG		 5032 gcc_assert ((!both_p && !fallback_p)
5033 || !strncmp (name, "__builtin_",
5034 strlen ("__builtin_")));
5035
5036 libname = name + strlen ("__builtin_");
c79efc4d
RÁE		 5037 decl = add_builtin_function (name, fntype, fncode, fnclass,
5038 (fallback_p ? libname : NULL),
5039 fnattrs);
9bc15050
RG		 5040 if (both_p
5041 && !flag_no_builtin && !builtin_function_disabled_p (libname)
7d14c755 5042 && !(nonansi_p && flag_no_nonansi_builtin))
c79efc4d
RÁE		 5043 add_builtin_function (libname, libtype, fncode, fnclass,
5044 NULL, fnattrs);
7f685e17 5045
9bc15050
RG		 5046 built_in_decls[(int) fncode] = decl;
5047 if (implicit_p)
5048 implicit_built_in_decls[(int) fncode] = decl;
fc2aaf30 5049}
c530479e 5050\f
d72040f5
RH		 5051/* Nonzero if the type T promotes to int. This is (nearly) the
5052 integral promotions defined in ISO C99 6.3.1.1/2. */
5053
5054bool
58f9752a 5055c_promoting_integer_type_p (const_tree t)
d72040f5
RH		 5056{
5057 switch (TREE_CODE (t))
5058 {
5059 case INTEGER_TYPE:
5060 return (TYPE_MAIN_VARIANT (t) == char_type_node
5061 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5062 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5063 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
c6c04fca
RL		 5064 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5065 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
d72040f5
RH		 5066
5067 case ENUMERAL_TYPE:
5068 /* ??? Technically all enumerations not larger than an int
5069 promote to an int. But this is used along code paths
5070 that only want to notice a size change. */
5071 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5072
5073 case BOOLEAN_TYPE:
5074 return 1;
5075
5076 default:
5077 return 0;
5078 }
5079}
5080
c530479e
RH		 5081/* Return 1 if PARMS specifies a fixed number of parameters
5082 and none of their types is affected by default promotions. */
5083
5084int
58f9752a 5085self_promoting_args_p (const_tree parms)
c530479e 5086{
58f9752a 5087 const_tree t;
c530479e
RH		 5088 for (t = parms; t; t = TREE_CHAIN (t))
5089 {
b3694847 5090 tree type = TREE_VALUE (t);
7e8176d7 5091
694fea20
VR		 5092 if (type == error_mark_node)
5093 continue;
5094
c530479e
RH		 5095 if (TREE_CHAIN (t) == 0 && type != void_type_node)
5096 return 0;
5097
5098 if (type == 0)
5099 return 0;
5100
5101 if (TYPE_MAIN_VARIANT (type) == float_type_node)
5102 return 0;
5103
d72040f5 5104 if (c_promoting_integer_type_p (type))
c530479e
RH		 5105 return 0;
5106 }
5107 return 1;
5108}
5eda3d66 5109
12ea3302
GDR		 5110/* Recursively remove any '*' or '&' operator from TYPE. */
5111tree
5112strip_pointer_operator (tree t)
5113{
5114 while (POINTER_TYPE_P (t))
5115 t = TREE_TYPE (t);
5116 return t;
5117}
5118
ba992967
SP		 5119/* Recursively remove pointer or array type from TYPE. */
5120tree
5121strip_pointer_or_array_types (tree t)
5122{
5123 while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5124 t = TREE_TYPE (t);
5125 return t;
5126}
5127
8f17b5c5
MM		 5128/* Used to compare case labels. K1 and K2 are actually tree nodes
5129 representing case labels, or NULL_TREE for a `default' label.
5130 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5131 K2, and 0 if K1 and K2 are equal. */
5132
5133int
35b1a6fa 5134case_compare (splay_tree_key k1, splay_tree_key k2)
8f17b5c5
MM		 5135{
5136 /* Consider a NULL key (such as arises with a `default' label) to be
5137 smaller than anything else. */
5138 if (!k1)
5139 return k2 ? -1 : 0;
5140 else if (!k2)
5141 return k1 ? 1 : 0;
5142
5143 return tree_int_cst_compare ((tree) k1, (tree) k2);
5144}
5145
c2255bc4
AH		 5146/* Process a case label, located at LOC, for the range LOW_VALUE
5147 ... HIGH_VALUE. If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5148 then this case label is actually a `default' label. If only
5149 HIGH_VALUE is NULL_TREE, then case label was declared using the
5150 usual C/C++ syntax, rather than the GNU case range extension.
5151 CASES is a tree containing all the case ranges processed so far;
5152 COND is the condition for the switch-statement itself. Returns the
5153 CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5154 is created. */
8f17b5c5
MM		 5155
5156tree
c2255bc4 5157c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
a6c0a76c 5158 tree low_value, tree high_value)
8f17b5c5
MM		 5159{
5160 tree type;
5161 tree label;
5162 tree case_label;
5163 splay_tree_node node;
5164
5165 /* Create the LABEL_DECL itself. */
c2255bc4 5166 label = create_artificial_label (loc);
8f17b5c5
MM		 5167
5168 /* If there was an error processing the switch condition, bail now
5169 before we get more confused. */
5170 if (!cond || cond == error_mark_node)
6de9cd9a 5171 goto error_out;
8f17b5c5 5172
35b1a6fa
AJ		 5173 if ((low_value && TREE_TYPE (low_value)
5174 && POINTER_TYPE_P (TREE_TYPE (low_value)))
8f17b5c5
MM		 5175 || (high_value && TREE_TYPE (high_value)
5176 && POINTER_TYPE_P (TREE_TYPE (high_value))))
522ddfa2 5177 {
c2255bc4 5178 error_at (loc, "pointers are not permitted as case values");
522ddfa2
JM		 5179 goto error_out;
5180 }
8f17b5c5
MM		 5181
5182 /* Case ranges are a GNU extension. */
fcf73884 5183 if (high_value)
b8698a0f 5184 pedwarn (loc, OPT_pedantic,
fcf73884 5185 "range expressions in switch statements are non-standard");
8f17b5c5
MM		 5186
5187 type = TREE_TYPE (cond);
5188 if (low_value)
5189 {
5190 low_value = check_case_value (low_value);
5191 low_value = convert_and_check (type, low_value);
c0e22534
NS		 5192 if (low_value == error_mark_node)
5193 goto error_out;
8f17b5c5
MM		 5194 }
5195 if (high_value)
5196 {
5197 high_value = check_case_value (high_value);
5198 high_value = convert_and_check (type, high_value);
c0e22534
NS		 5199 if (high_value == error_mark_node)
5200 goto error_out;
8f17b5c5
MM		 5201 }
5202
c0e22534
NS		 5203 if (low_value && high_value)
5204 {
5205 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
c22cacf3
MS		 5206 really a case range, even though it was written that way.
5207 Remove the HIGH_VALUE to simplify later processing. */
c0e22534
NS		 5208 if (tree_int_cst_equal (low_value, high_value))
5209 high_value = NULL_TREE;
5210 else if (!tree_int_cst_lt (low_value, high_value))
c2255bc4 5211 warning_at (loc, 0, "empty range specified");
c0e22534 5212 }
8f17b5c5 5213
a6c0a76c
SB		 5214 /* See if the case is in range of the type of the original testing
5215 expression. If both low_value and high_value are out of range,
5216 don't insert the case label and return NULL_TREE. */
5217 if (low_value
3f75a254
JM		 5218 && !check_case_bounds (type, orig_type,
5219 &low_value, high_value ? &high_value : NULL))
a6c0a76c
SB		 5220 return NULL_TREE;
5221
8f17b5c5
MM		 5222 /* Look up the LOW_VALUE in the table of case labels we already
5223 have. */
5224 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5225 /* If there was not an exact match, check for overlapping ranges.
5226 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5227 that's a `default' label and the only overlap is an exact match. */
5228 if (!node && (low_value || high_value))
5229 {
5230 splay_tree_node low_bound;
5231 splay_tree_node high_bound;
5232
5233 /* Even though there wasn't an exact match, there might be an
5234 overlap between this case range and another case range.
5235 Since we've (inductively) not allowed any overlapping case
5236 ranges, we simply need to find the greatest low case label
5237 that is smaller that LOW_VALUE, and the smallest low case
5238 label that is greater than LOW_VALUE. If there is an overlap
5239 it will occur in one of these two ranges. */
5240 low_bound = splay_tree_predecessor (cases,
5241 (splay_tree_key) low_value);
5242 high_bound = splay_tree_successor (cases,
5243 (splay_tree_key) low_value);
5244
5245 /* Check to see if the LOW_BOUND overlaps. It is smaller than
5246 the LOW_VALUE, so there is no need to check unless the
5247 LOW_BOUND is in fact itself a case range. */
5248 if (low_bound
5249 && CASE_HIGH ((tree) low_bound->value)
5250 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5251 low_value) >= 0)
5252 node = low_bound;
5253 /* Check to see if the HIGH_BOUND overlaps. The low end of that
5254 range is bigger than the low end of the current range, so we
5255 are only interested if the current range is a real range, and
5256 not an ordinary case label. */
35b1a6fa 5257 else if (high_bound
8f17b5c5
MM		 5258 && high_value
5259 && (tree_int_cst_compare ((tree) high_bound->key,
5260 high_value)
5261 <= 0))
5262 node = high_bound;
5263 }
5264 /* If there was an overlap, issue an error. */
5265 if (node)
5266 {
8c161995 5267 tree duplicate = CASE_LABEL ((tree) node->value);
8f17b5c5
MM		 5268
5269 if (high_value)
5270 {
c2255bc4
AH		 5271 error_at (loc, "duplicate (or overlapping) case value");
5272 error_at (DECL_SOURCE_LOCATION (duplicate),
5273 "this is the first entry overlapping that value");
8f17b5c5
MM		 5274 }
5275 else if (low_value)
5276 {
c2255bc4
AH		 5277 error_at (loc, "duplicate case value") ;
5278 error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
8f17b5c5
MM		 5279 }
5280 else
5281 {
c2255bc4
AH		 5282 error_at (loc, "multiple default labels in one switch");
5283 error_at (DECL_SOURCE_LOCATION (duplicate),
5284 "this is the first default label");
8f17b5c5 5285 }
6de9cd9a 5286 goto error_out;
8f17b5c5
MM		 5287 }
5288
5289 /* Add a CASE_LABEL to the statement-tree. */
c2255bc4 5290 case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
8f17b5c5 5291 /* Register this case label in the splay tree. */
35b1a6fa 5292 splay_tree_insert (cases,
8f17b5c5
MM		 5293 (splay_tree_key) low_value,
5294 (splay_tree_value) case_label);
5295
5296 return case_label;
6de9cd9a
DN		 5297
5298 error_out:
9e14e18f 5299 /* Add a label so that the back-end doesn't think that the beginning of
6de9cd9a 5300 the switch is unreachable. Note that we do not add a case label, as
41806d92 5301 that just leads to duplicates and thence to failure later on. */
6de9cd9a
DN		 5302 if (!cases->root)
5303 {
c2255bc4
AH		 5304 tree t = create_artificial_label (loc);
5305 add_stmt (build_stmt (loc, LABEL_EXPR, t));
6de9cd9a
DN		 5306 }
5307 return error_mark_node;
5308}
5309
5310/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5311 Used to verify that case values match up with enumerator values. */
5312
5313static void
5314match_case_to_enum_1 (tree key, tree type, tree label)
5315{
5316 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5317
5318 /* ??? Not working too hard to print the double-word value.
5319 Should perhaps be done with %lwd in the diagnostic routines? */
5320 if (TREE_INT_CST_HIGH (key) == 0)
5321 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5322 TREE_INT_CST_LOW (key));
5323 else if (!TYPE_UNSIGNED (type)
5324 && TREE_INT_CST_HIGH (key) == -1
5325 && TREE_INT_CST_LOW (key) != 0)
5326 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5327 -TREE_INT_CST_LOW (key));
5328 else
5329 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3d57d7ce
DK		 5330 (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5331 (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
6de9cd9a
DN		 5332
5333 if (TYPE_NAME (type) == 0)
c5d75364
MLI		 5334 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5335 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5336 "case value %qs not in enumerated type",
5337 buf);
6de9cd9a 5338 else
c5d75364
MLI		 5339 warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5340 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5341 "case value %qs not in enumerated type %qT",
5342 buf, type);
6de9cd9a
DN		 5343}
5344
c782c2fe
RS		 5345/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5346 Used to verify that case values match up with enumerator values. */
5347
6de9cd9a
DN		 5348static int
5349match_case_to_enum (splay_tree_node node, void *data)
5350{
5351 tree label = (tree) node->value;
28dab132 5352 tree type = (tree) data;
6de9cd9a
DN		 5353
5354 /* Skip default case. */
5355 if (!CASE_LOW (label))
5356 return 0;
5357
c782c2fe 5358 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
6de9cd9a 5359 when we did our enum->case scan. Reset our scratch bit after. */
c782c2fe 5360 if (!CASE_LOW_SEEN (label))
6de9cd9a
DN		 5361 match_case_to_enum_1 (CASE_LOW (label), type, label);
5362 else
c782c2fe 5363 CASE_LOW_SEEN (label) = 0;
6de9cd9a 5364
c782c2fe
RS		 5365 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
5366 not set, that means that CASE_HIGH did not appear when we did our
5367 enum->case scan. Reset our scratch bit after. */
6de9cd9a
DN		 5368 if (CASE_HIGH (label))
5369 {
c782c2fe
RS		 5370 if (!CASE_HIGH_SEEN (label))
5371 match_case_to_enum_1 (CASE_HIGH (label), type, label);
5372 else
5373 CASE_HIGH_SEEN (label) = 0;
6de9cd9a
DN		 5374 }
5375
5376 return 0;
5377}
5378
fbc315db
ILT		 5379/* Handle -Wswitch*. Called from the front end after parsing the
5380 switch construct. */
5381/* ??? Should probably be somewhere generic, since other languages
5382 besides C and C++ would want this. At the moment, however, C/C++
5383 are the only tree-ssa languages that support enumerations at all,
5384 so the point is moot. */
6de9cd9a 5385
fbc315db
ILT		 5386void
5387c_do_switch_warnings (splay_tree cases, location_t switch_location,
5388 tree type, tree cond)
6de9cd9a 5389{
9f63daea 5390 splay_tree_node default_node;
c782c2fe
RS		 5391 splay_tree_node node;
5392 tree chain;
6de9cd9a
DN		 5393
5394 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5395 return;
5396
6de9cd9a 5397 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
44c21c7f 5398 if (!default_node)
fab922b1
MLI		 5399 warning_at (switch_location, OPT_Wswitch_default,
5400 "switch missing default case");
6de9cd9a 5401
c782c2fe
RS		 5402 /* From here on, we only care about about enumerated types. */
5403 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5404 return;
5405
cdb88468
ILT		 5406 /* From here on, we only care about -Wswitch and -Wswitch-enum. */
5407 if (!warn_switch_enum && !warn_switch)
c782c2fe
RS		 5408 return;
5409
cdb88468
ILT		 5410 /* Check the cases. Warn about case values which are not members of
5411 the enumerated type. For -Wswitch-enum, or for -Wswitch when
5412 there is no default case, check that exactly all enumeration
5413 literals are covered by the cases. */
5414
c782c2fe
RS		 5415 /* Clearing COND if it is not an integer constant simplifies
5416 the tests inside the loop below. */
5417 if (TREE_CODE (cond) != INTEGER_CST)
5418 cond = NULL_TREE;
5419
5420 /* The time complexity here is O(N*lg(N)) worst case, but for the
5421 common case of monotonically increasing enumerators, it is
5422 O(N), since the nature of the splay tree will keep the next
5423 element adjacent to the root at all times. */
6de9cd9a 5424
c782c2fe
RS		 5425 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5426 {
5427 tree value = TREE_VALUE (chain);
adf2edec
DG		 5428 if (TREE_CODE (value) == CONST_DECL)
5429 value = DECL_INITIAL (value);
c782c2fe
RS		 5430 node = splay_tree_lookup (cases, (splay_tree_key) value);
5431 if (node)
6de9cd9a 5432 {
c782c2fe
RS		 5433 /* Mark the CASE_LOW part of the case entry as seen. */
5434 tree label = (tree) node->value;
5435 CASE_LOW_SEEN (label) = 1;
5436 continue;
5437 }
5438
5439 /* Even though there wasn't an exact match, there might be a
fa10beec 5440 case range which includes the enumerator's value. */
c782c2fe
RS		 5441 node = splay_tree_predecessor (cases, (splay_tree_key) value);
5442 if (node && CASE_HIGH ((tree) node->value))
5443 {
5444 tree label = (tree) node->value;
5445 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5446 if (cmp >= 0)
6de9cd9a 5447 {
c782c2fe
RS		 5448 /* If we match the upper bound exactly, mark the CASE_HIGH
5449 part of the case entry as seen. */
5450 if (cmp == 0)
5451 CASE_HIGH_SEEN (label) = 1;
5452 continue;
6de9cd9a
DN		 5453 }
5454 }
5455
c782c2fe
RS		 5456 /* We've now determined that this enumerated literal isn't
5457 handled by the case labels of the switch statement. */
6de9cd9a 5458
c782c2fe
RS		 5459 /* If the switch expression is a constant, we only really care
5460 about whether that constant is handled by the switch. */
5461 if (cond && tree_int_cst_compare (cond, value))
5462 continue;
6de9cd9a 5463
683d6ff9 5464 /* If there is a default_node, the only relevant option is
cdb88468 5465 Wswitch-enum. Otherwise, if both are enabled then we prefer
683d6ff9
MLI		 5466 to warn using -Wswitch because -Wswitch is enabled by -Wall
5467 while -Wswitch-enum is explicit. */
cdb88468
ILT		 5468 warning_at (switch_location,
5469 (default_node || !warn_switch
5470 ? OPT_Wswitch_enum
5471 : OPT_Wswitch),
5472 "enumeration value %qE not handled in switch",
5473 TREE_PURPOSE (chain));
6de9cd9a 5474 }
c782c2fe
RS		 5475
5476 /* Warn if there are case expressions that don't correspond to
5477 enumerators. This can occur since C and C++ don't enforce
5478 type-checking of assignments to enumeration variables.
5479
5480 The time complexity here is now always O(N) worst case, since
5481 we should have marked both the lower bound and upper bound of
5482 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5483 above. This scan also resets those fields. */
683d6ff9 5484
c782c2fe 5485 splay_tree_foreach (cases, match_case_to_enum, type);
8f17b5c5
MM		 5486}
5487
6b665219 5488/* Finish an expression taking the address of LABEL (an
6a3799eb
AH		 5489 IDENTIFIER_NODE). Returns an expression for the address.
5490
5491 LOC is the location for the expression returned. */
15b732b2 5492
35b1a6fa 5493tree
6a3799eb 5494finish_label_address_expr (tree label, location_t loc)
15b732b2
NB		 5495{
5496 tree result;
5497
509c9d60 5498 pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
15b732b2 5499
6b665219
MM		 5500 if (label == error_mark_node)
5501 return error_mark_node;
5502
15b732b2
NB		 5503 label = lookup_label (label);
5504 if (label == NULL_TREE)
5505 result = null_pointer_node;
5506 else
5507 {
5508 TREE_USED (label) = 1;
5509 result = build1 (ADDR_EXPR, ptr_type_node, label);
5805e48d 5510 /* The current function is not necessarily uninlinable.
15b732b2
NB		 5511 Computed gotos are incompatible with inlining, but the value
5512 here could be used only in a diagnostic, for example. */
6a3799eb 5513 protected_set_expr_location (result, loc);
15b732b2
NB		 5514 }
5515
5516 return result;
5517}
19552aa5
JM		 5518\f
5519
5520/* Given a boolean expression ARG, return a tree representing an increment
5521 or decrement (as indicated by CODE) of ARG. The front end must check for
5522 invalid cases (e.g., decrement in C++). */
5523tree
35b1a6fa 5524boolean_increment (enum tree_code code, tree arg)
19552aa5
JM		 5525{
5526 tree val;
b5119fa1 5527 tree true_res = build_int_cst (TREE_TYPE (arg), 1);
37fa72e9 5528
19552aa5
JM		 5529 arg = stabilize_reference (arg);
5530 switch (code)
5531 {
5532 case PREINCREMENT_EXPR:
53fb4de3 5533 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
19552aa5
JM		 5534 break;
5535 case POSTINCREMENT_EXPR:
53fb4de3 5536 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
19552aa5 5537 arg = save_expr (arg);
53fb4de3
RS		 5538 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5539 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
19552aa5
JM		 5540 break;
5541 case PREDECREMENT_EXPR:
53fb4de3 5542 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
db3927fb 5543 invert_truthvalue_loc (input_location, arg));
19552aa5
JM		 5544 break;
5545 case POSTDECREMENT_EXPR:
53fb4de3 5546 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
db3927fb 5547 invert_truthvalue_loc (input_location, arg));
19552aa5 5548 arg = save_expr (arg);
53fb4de3
RS		 5549 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5550 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
19552aa5
JM		 5551 break;
5552 default:
366de0ce 5553 gcc_unreachable ();
19552aa5
JM		 5554 }
5555 TREE_SIDE_EFFECTS (val) = 1;
5556 return val;
5557}
03dc0325 5558\f
207bf79d
JM		 5559/* Built-in macros for stddef.h and stdint.h, that require macros
5560 defined in this file. */
460bd0e3 5561void
35b1a6fa 5562c_stddef_cpp_builtins(void)
3df89291 5563{
5279d739
ZW		 5564 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5565 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5566 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5567 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
85291069
JM		 5568 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5569 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
c466b2cd
KVH		 5570 builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5571 builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
207bf79d
JM		 5572 if (SIG_ATOMIC_TYPE)
5573 builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5574 if (INT8_TYPE)
5575 builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5576 if (INT16_TYPE)
5577 builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5578 if (INT32_TYPE)
5579 builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5580 if (INT64_TYPE)
5581 builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5582 if (UINT8_TYPE)
5583 builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5584 if (UINT16_TYPE)
5585 builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5586 if (UINT32_TYPE)
5587 builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5588 if (UINT64_TYPE)
5589 builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5590 if (INT_LEAST8_TYPE)
5591 builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5592 if (INT_LEAST16_TYPE)
5593 builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5594 if (INT_LEAST32_TYPE)
5595 builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5596 if (INT_LEAST64_TYPE)
5597 builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5598 if (UINT_LEAST8_TYPE)
5599 builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5600 if (UINT_LEAST16_TYPE)
5601 builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5602 if (UINT_LEAST32_TYPE)
5603 builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5604 if (UINT_LEAST64_TYPE)
5605 builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5606 if (INT_FAST8_TYPE)
5607 builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5608 if (INT_FAST16_TYPE)
5609 builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5610 if (INT_FAST32_TYPE)
5611 builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5612 if (INT_FAST64_TYPE)
5613 builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5614 if (UINT_FAST8_TYPE)
5615 builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5616 if (UINT_FAST16_TYPE)
5617 builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5618 if (UINT_FAST32_TYPE)
5619 builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5620 if (UINT_FAST64_TYPE)
5621 builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5622 if (INTPTR_TYPE)
5623 builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5624 if (UINTPTR_TYPE)
5625 builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
676997cf
RH		 5626}
5627
6431177a 5628static void
35b1a6fa 5629c_init_attributes (void)
6431177a
JM		 5630{
5631 /* Fill in the built_in_attributes array. */
4a90aeeb 5632#define DEF_ATTR_NULL_TREE(ENUM) \
6431177a 5633 built_in_attributes[(int) ENUM] = NULL_TREE;
4a90aeeb 5634#define DEF_ATTR_INT(ENUM, VALUE) \
7d60be94 5635 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
6431177a
JM		 5636#define DEF_ATTR_IDENT(ENUM, STRING) \
5637 built_in_attributes[(int) ENUM] = get_identifier (STRING);
5638#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5639 built_in_attributes[(int) ENUM] \
5640 = tree_cons (built_in_attributes[(int) PURPOSE], \
5641 built_in_attributes[(int) VALUE], \
5642 built_in_attributes[(int) CHAIN]);
6431177a
JM		 5643#include "builtin-attrs.def"
5644#undef DEF_ATTR_NULL_TREE
5645#undef DEF_ATTR_INT
5646#undef DEF_ATTR_IDENT
5647#undef DEF_ATTR_TREE_LIST
03dc0325 5648}
26f943fd 5649
943f82e7
JM		 5650/* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5651 identifier as an argument, so the front end shouldn't look it up. */
5652
5653bool
564a129d 5654attribute_takes_identifier_p (const_tree attr_id)
943f82e7 5655{
564a129d
JM		 5656 if (is_attribute_p ("mode", attr_id)
5657 || is_attribute_p ("format", attr_id)
5658 || is_attribute_p ("cleanup", attr_id))
5659 return true;
5660 else
5661 return targetm.attribute_takes_identifier_p (attr_id);
943f82e7
JM		 5662}
5663
349ae713
NB		 5664/* Attribute handlers common to C front ends. */
5665
5666/* Handle a "packed" attribute; arguments as in
5667 struct attribute_spec.handler. */
5668
5669static tree
e18476eb 5670handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
a742c759 5671 int flags, bool *no_add_attrs)
349ae713 5672{
c6e4cc53 5673 if (TYPE_P (*node))
349ae713
NB		 5674 {
5675 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
8dd16ecc 5676 *node = build_variant_type_copy (*node);
c6e4cc53 5677 TYPE_PACKED (*node) = 1;
349ae713
NB		 5678 }
5679 else if (TREE_CODE (*node) == FIELD_DECL)
646c0835 5680 {
2cd36c22
AN		 5681 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5682 /* Still pack bitfields. */
5683 && ! DECL_INITIAL (*node))
646c0835
NS		 5684 warning (OPT_Wattributes,
5685 "%qE attribute ignored for field of type %qT",
5686 name, TREE_TYPE (*node));
5687 else
5688 DECL_PACKED (*node) = 1;
5689 }
349ae713 5690 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
c6e4cc53
NS		 5691 used for DECL_REGISTER. It wouldn't mean anything anyway.
5692 We can't set DECL_PACKED on the type of a TYPE_DECL, because
5693 that changes what the typedef is typing. */
349ae713
NB		 5694 else
5695 {
5c498b10 5696 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5697 *no_add_attrs = true;
5698 }
5699
5700 return NULL_TREE;
5701}
5702
5703/* Handle a "nocommon" attribute; arguments as in
5704 struct attribute_spec.handler. */
5705
5706static tree
35b1a6fa 5707handle_nocommon_attribute (tree *node, tree name,
e18476eb
BI		 5708 tree ARG_UNUSED (args),
5709 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 5710{
5711 if (TREE_CODE (*node) == VAR_DECL)
5712 DECL_COMMON (*node) = 0;
5713 else
5714 {
5c498b10 5715 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5716 *no_add_attrs = true;
5717 }
5718
5719 return NULL_TREE;
5720}
5721
5722/* Handle a "common" attribute; arguments as in
5723 struct attribute_spec.handler. */
5724
5725static tree
e18476eb
BI		 5726handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5727 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 5728{
5729 if (TREE_CODE (*node) == VAR_DECL)
5730 DECL_COMMON (*node) = 1;
5731 else
5732 {
5c498b10 5733 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5734 *no_add_attrs = true;
5735 }
5736
5737 return NULL_TREE;
5738}
5739
5740/* Handle a "noreturn" attribute; arguments as in
5741 struct attribute_spec.handler. */
5742
5743static tree
e18476eb
BI		 5744handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5745 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 5746{
5747 tree type = TREE_TYPE (*node);
5748
5749 /* See FIXME comment in c_common_attribute_table. */
5750 if (TREE_CODE (*node) == FUNCTION_DECL)
5751 TREE_THIS_VOLATILE (*node) = 1;
5752 else if (TREE_CODE (type) == POINTER_TYPE
5753 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5754 TREE_TYPE (*node)
5755 = build_pointer_type
5756 (build_type_variant (TREE_TYPE (type),
c29726e2 5757 TYPE_READONLY (TREE_TYPE (type)), 1));
349ae713
NB		 5758 else
5759 {
5c498b10 5760 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5761 *no_add_attrs = true;
5762 }
5763
5764 return NULL_TREE;
5765}
5766
52bf96d2
JH		 5767/* Handle a "hot" and attribute; arguments as in
5768 struct attribute_spec.handler. */
5769
5770static tree
5771handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
ab442df7 5772 int ARG_UNUSED (flags), bool *no_add_attrs)
52bf96d2
JH		 5773{
5774 if (TREE_CODE (*node) == FUNCTION_DECL)
5775 {
5776 if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5777 {
5778 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5779 name, "cold");
5780 *no_add_attrs = true;
5781 }
5779e713
MM		 5782 /* Most of the rest of the hot processing is done later with
5783 lookup_attribute. */
52bf96d2
JH		 5784 }
5785 else
5786 {
5787 warning (OPT_Wattributes, "%qE attribute ignored", name);
5788 *no_add_attrs = true;
5789 }
5790
5791 return NULL_TREE;
5792}
5793/* Handle a "cold" and attribute; arguments as in
5794 struct attribute_spec.handler. */
5795
5796static tree
5797handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5798 int ARG_UNUSED (flags), bool *no_add_attrs)
5799{
5800 if (TREE_CODE (*node) == FUNCTION_DECL)
5801 {
5802 if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5803 {
5804 warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5805 name, "hot");
5806 *no_add_attrs = true;
5807 }
5779e713
MM		 5808 /* Most of the rest of the cold processing is done later with
5809 lookup_attribute. */
52bf96d2
JH		 5810 }
5811 else
5812 {
5813 warning (OPT_Wattributes, "%qE attribute ignored", name);
5814 *no_add_attrs = true;
5815 }
5816
5817 return NULL_TREE;
5818}
5819
349ae713
NB		 5820/* Handle a "noinline" attribute; arguments as in
5821 struct attribute_spec.handler. */
5822
5823static tree
35b1a6fa 5824handle_noinline_attribute (tree *node, tree name,
e18476eb
BI		 5825 tree ARG_UNUSED (args),
5826 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 5827{
5828 if (TREE_CODE (*node) == FUNCTION_DECL)
5829 DECL_UNINLINABLE (*node) = 1;
5830 else
5831 {
5c498b10 5832 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5833 *no_add_attrs = true;
5834 }
5835
5836 return NULL_TREE;
5837}
5838
86631ea3
MJ		 5839/* Handle a "noclone" attribute; arguments as in
5840 struct attribute_spec.handler. */
5841
5842static tree
5843handle_noclone_attribute (tree *node, tree name,
5844 tree ARG_UNUSED (args),
5845 int ARG_UNUSED (flags), bool *no_add_attrs)
5846{
5847 if (TREE_CODE (*node) != FUNCTION_DECL)
5848 {
5849 warning (OPT_Wattributes, "%qE attribute ignored", name);
5850 *no_add_attrs = true;
5851 }
5852
5853 return NULL_TREE;
5854}
5855
349ae713
NB		 5856/* Handle a "always_inline" attribute; arguments as in
5857 struct attribute_spec.handler. */
5858
5859static tree
35b1a6fa 5860handle_always_inline_attribute (tree *node, tree name,
e18476eb
BI		 5861 tree ARG_UNUSED (args),
5862 int ARG_UNUSED (flags),
a742c759 5863 bool *no_add_attrs)
349ae713
NB		 5864{
5865 if (TREE_CODE (*node) == FUNCTION_DECL)
5866 {
c536a6a7
RG		 5867 /* Set the attribute and mark it for disregarding inline
5868 limits. */
5869 DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
349ae713
NB		 5870 }
5871 else
5872 {
5c498b10 5873 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713 5874 *no_add_attrs = true;
4eb7fd83
JJ		 5875 }
5876
5877 return NULL_TREE;
5878}
5879
5880/* Handle a "gnu_inline" attribute; arguments as in
5881 struct attribute_spec.handler. */
5882
5883static tree
5884handle_gnu_inline_attribute (tree *node, tree name,
5885 tree ARG_UNUSED (args),
5886 int ARG_UNUSED (flags),
5887 bool *no_add_attrs)
5888{
5889 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5890 {
5891 /* Do nothing else, just set the attribute. We'll get at
5892 it later with lookup_attribute. */
5893 }
5894 else
5895 {
5896 warning (OPT_Wattributes, "%qE attribute ignored", name);
5897 *no_add_attrs = true;
349ae713
NB		 5898 }
5899
5900 return NULL_TREE;
5901}
5902
d752cfdb
JJ		 5903/* Handle an "artificial" attribute; arguments as in
5904 struct attribute_spec.handler. */
5905
5906static tree
5907handle_artificial_attribute (tree *node, tree name,
5908 tree ARG_UNUSED (args),
5909 int ARG_UNUSED (flags),
5910 bool *no_add_attrs)
5911{
5912 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5913 {
5914 /* Do nothing else, just set the attribute. We'll get at
5915 it later with lookup_attribute. */
5916 }
5917 else
5918 {
5919 warning (OPT_Wattributes, "%qE attribute ignored", name);
5920 *no_add_attrs = true;
5921 }
5922
5923 return NULL_TREE;
5924}
5925
0691d1d4
RG		 5926/* Handle a "flatten" attribute; arguments as in
5927 struct attribute_spec.handler. */
5928
5929static tree
5930handle_flatten_attribute (tree *node, tree name,
c22cacf3
MS		 5931 tree args ATTRIBUTE_UNUSED,
5932 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
0691d1d4
RG		 5933{
5934 if (TREE_CODE (*node) == FUNCTION_DECL)
5935 /* Do nothing else, just set the attribute. We'll get at
5936 it later with lookup_attribute. */
5937 ;
5938 else
5939 {
5940 warning (OPT_Wattributes, "%qE attribute ignored", name);
5941 *no_add_attrs = true;
5942 }
5943
5944 return NULL_TREE;
5945}
5946
d2af6a68
JJ		 5947/* Handle a "warning" or "error" attribute; arguments as in
5948 struct attribute_spec.handler. */
5949
5950static tree
5951handle_error_attribute (tree *node, tree name, tree args,
5952 int ARG_UNUSED (flags), bool *no_add_attrs)
5953{
5954 if (TREE_CODE (*node) == FUNCTION_DECL
5955 || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5956 /* Do nothing else, just set the attribute. We'll get at
5957 it later with lookup_attribute. */
5958 ;
5959 else
5960 {
5961 warning (OPT_Wattributes, "%qE attribute ignored", name);
5962 *no_add_attrs = true;
5963 }
5964
5965 return NULL_TREE;
5966}
0691d1d4 5967
349ae713
NB		 5968/* Handle a "used" attribute; arguments as in
5969 struct attribute_spec.handler. */
5970
5971static tree
e18476eb
BI		 5972handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5973 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713 5974{
d7ddbe24
RH		 5975 tree node = *pnode;
5976
5977 if (TREE_CODE (node) == FUNCTION_DECL
5978 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4d7d0451 5979 {
4d7d0451 5980 TREE_USED (node) = 1;
8e3e233b 5981 DECL_PRESERVE_P (node) = 1;
ebfbbdc5
JJ		 5982 if (TREE_CODE (node) == VAR_DECL)
5983 DECL_READ_P (node) = 1;
4d7d0451 5984 }
349ae713
NB		 5985 else
5986 {
5c498b10 5987 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 5988 *no_add_attrs = true;
5989 }
5990
5991 return NULL_TREE;
5992}
5993
5994/* Handle a "unused" attribute; arguments as in
5995 struct attribute_spec.handler. */
5996
5997static tree
e18476eb
BI		 5998handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5999 int flags, bool *no_add_attrs)
349ae713
NB		 6000{
6001 if (DECL_P (*node))
6002 {
6003 tree decl = *node;
6004
6005 if (TREE_CODE (decl) == PARM_DECL
6006 || TREE_CODE (decl) == VAR_DECL
6007 || TREE_CODE (decl) == FUNCTION_DECL
6008 || TREE_CODE (decl) == LABEL_DECL
6009 || TREE_CODE (decl) == TYPE_DECL)
ebfbbdc5
JJ		 6010 {
6011 TREE_USED (decl) = 1;
6012 if (TREE_CODE (decl) == VAR_DECL
6013 || TREE_CODE (decl) == PARM_DECL)
6014 DECL_READ_P (decl) = 1;
6015 }
349ae713
NB		 6016 else
6017 {
5c498b10 6018 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6019 *no_add_attrs = true;
6020 }
6021 }
6022 else
6023 {
6024 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
8dd16ecc 6025 *node = build_variant_type_copy (*node);
349ae713
NB		 6026 TREE_USED (*node) = 1;
6027 }
6028
6029 return NULL_TREE;
6030}
6031
ce91e74c
JH		 6032/* Handle a "externally_visible" attribute; arguments as in
6033 struct attribute_spec.handler. */
6034
6035static tree
6036handle_externally_visible_attribute (tree *pnode, tree name,
6037 tree ARG_UNUSED (args),
6038 int ARG_UNUSED (flags),
6039 bool *no_add_attrs)
6040{
6041 tree node = *pnode;
6042
343d4b27 6043 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
ce91e74c 6044 {
343d4b27
JJ		 6045 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6046 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6047 {
6048 warning (OPT_Wattributes,
6049 "%qE attribute have effect only on public objects", name);
6050 *no_add_attrs = true;
6051 }
ce91e74c 6052 }
ce91e74c
JH		 6053 else
6054 {
6055 warning (OPT_Wattributes, "%qE attribute ignored", name);
6056 *no_add_attrs = true;
6057 }
6058
6059 return NULL_TREE;
6060}
6061
349ae713
NB		 6062/* Handle a "const" attribute; arguments as in
6063 struct attribute_spec.handler. */
6064
6065static tree
e18476eb
BI		 6066handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6067 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 6068{
6069 tree type = TREE_TYPE (*node);
6070
6071 /* See FIXME comment on noreturn in c_common_attribute_table. */
6072 if (TREE_CODE (*node) == FUNCTION_DECL)
6073 TREE_READONLY (*node) = 1;
6074 else if (TREE_CODE (type) == POINTER_TYPE
6075 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6076 TREE_TYPE (*node)
6077 = build_pointer_type
6078 (build_type_variant (TREE_TYPE (type), 1,
6079 TREE_THIS_VOLATILE (TREE_TYPE (type))));
6080 else
6081 {
5c498b10 6082 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6083 *no_add_attrs = true;
6084 }
6085
6086 return NULL_TREE;
6087}
6088
6089/* Handle a "transparent_union" attribute; arguments as in
6090 struct attribute_spec.handler. */
6091
6092static tree
35b1a6fa 6093handle_transparent_union_attribute (tree *node, tree name,
e18476eb 6094 tree ARG_UNUSED (args), int flags,
a742c759 6095 bool *no_add_attrs)
349ae713 6096{
4009f2e7 6097 tree type;
52dd234b
RH		 6098
6099 *no_add_attrs = true;
349ae713 6100
4009f2e7
JM		 6101 if (TREE_CODE (*node) == TYPE_DECL)
6102 node = &TREE_TYPE (*node);
6103 type = *node;
349ae713 6104
52dd234b 6105 if (TREE_CODE (type) == UNION_TYPE)
349ae713 6106 {
52dd234b
RH		 6107 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6108 the code in finish_struct. */
349ae713 6109 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
52dd234b
RH		 6110 {
6111 if (TYPE_FIELDS (type) == NULL_TREE
6112 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6113 goto ignored;
6114
6115 /* A type variant isn't good enough, since we don't a cast
6116 to such a type removed as a no-op. */
6117 *node = type = build_duplicate_type (type);
6118 }
6119
ebf0bf7f 6120 TYPE_TRANSPARENT_AGGR (type) = 1;
52dd234b 6121 return NULL_TREE;
349ae713
NB		 6122 }
6123
52dd234b
RH		 6124 ignored:
6125 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6126 return NULL_TREE;
6127}
6128
fc8600f9
MM		 6129/* Subroutine of handle_{con,de}structor_attribute. Evaluate ARGS to
6130 get the requested priority for a constructor or destructor,
6131 possibly issuing diagnostics for invalid or reserved
6132 priorities. */
6133
6134static priority_type
6135get_priority (tree args, bool is_destructor)
6136{
6137 HOST_WIDE_INT pri;
b2f4bed8 6138 tree arg;
fc8600f9
MM		 6139
6140 if (!args)
6141 return DEFAULT_INIT_PRIORITY;
b8698a0f 6142
f6fc5c86
MM		 6143 if (!SUPPORTS_INIT_PRIORITY)
6144 {
6145 if (is_destructor)
6146 error ("destructor priorities are not supported");
6147 else
6148 error ("constructor priorities are not supported");
6149 return DEFAULT_INIT_PRIORITY;
6150 }
6151
b2f4bed8
MM		 6152 arg = TREE_VALUE (args);
6153 if (!host_integerp (arg, /*pos=*/0)
6154 || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
fc8600f9
MM		 6155 goto invalid;
6156
6157 pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6158 if (pri < 0 || pri > MAX_INIT_PRIORITY)
6159 goto invalid;
6160
6161 if (pri <= MAX_RESERVED_INIT_PRIORITY)
6162 {
6163 if (is_destructor)
6164 warning (0,
6165 "destructor priorities from 0 to %d are reserved "
b8698a0f 6166 "for the implementation",
fc8600f9
MM		 6167 MAX_RESERVED_INIT_PRIORITY);
6168 else
6169 warning (0,
6170 "constructor priorities from 0 to %d are reserved "
b8698a0f 6171 "for the implementation",
fc8600f9
MM		 6172 MAX_RESERVED_INIT_PRIORITY);
6173 }
6174 return pri;
6175
6176 invalid:
6177 if (is_destructor)
6178 error ("destructor priorities must be integers from 0 to %d inclusive",
6179 MAX_INIT_PRIORITY);
6180 else
6181 error ("constructor priorities must be integers from 0 to %d inclusive",
6182 MAX_INIT_PRIORITY);
6183 return DEFAULT_INIT_PRIORITY;
6184}
6185
349ae713
NB		 6186/* Handle a "constructor" attribute; arguments as in
6187 struct attribute_spec.handler. */
6188
6189static tree
fc8600f9 6190handle_constructor_attribute (tree *node, tree name, tree args,
e18476eb 6191 int ARG_UNUSED (flags),
a742c759 6192 bool *no_add_attrs)
349ae713
NB		 6193{
6194 tree decl = *node;
6195 tree type = TREE_TYPE (decl);
6196
6197 if (TREE_CODE (decl) == FUNCTION_DECL
6198 && TREE_CODE (type) == FUNCTION_TYPE
6199 && decl_function_context (decl) == 0)
6200 {
fc8600f9 6201 priority_type priority;
349ae713 6202 DECL_STATIC_CONSTRUCTOR (decl) = 1;
fc8600f9
MM		 6203 priority = get_priority (args, /*is_destructor=*/false);
6204 SET_DECL_INIT_PRIORITY (decl, priority);
349ae713
NB		 6205 TREE_USED (decl) = 1;
6206 }
6207 else
6208 {
5c498b10 6209 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6210 *no_add_attrs = true;
6211 }
6212
6213 return NULL_TREE;
6214}
6215
6216/* Handle a "destructor" attribute; arguments as in
6217 struct attribute_spec.handler. */
6218
6219static tree
fc8600f9 6220handle_destructor_attribute (tree *node, tree name, tree args,
e18476eb 6221 int ARG_UNUSED (flags),
a742c759 6222 bool *no_add_attrs)
349ae713
NB		 6223{
6224 tree decl = *node;
6225 tree type = TREE_TYPE (decl);
6226
6227 if (TREE_CODE (decl) == FUNCTION_DECL
6228 && TREE_CODE (type) == FUNCTION_TYPE
6229 && decl_function_context (decl) == 0)
6230 {
fc8600f9 6231 priority_type priority;
349ae713 6232 DECL_STATIC_DESTRUCTOR (decl) = 1;
fc8600f9
MM		 6233 priority = get_priority (args, /*is_destructor=*/true);
6234 SET_DECL_FINI_PRIORITY (decl, priority);
349ae713
NB		 6235 TREE_USED (decl) = 1;
6236 }
6237 else
6238 {
5c498b10 6239 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6240 *no_add_attrs = true;
6241 }
6242
6243 return NULL_TREE;
6244}
6245
4d451982
MLI		 6246/* Nonzero if the mode is a valid vector mode for this architecture.
6247 This returns nonzero even if there is no hardware support for the
6248 vector mode, but we can emulate with narrower modes. */
6249
6250static int
6251vector_mode_valid_p (enum machine_mode mode)
6252{
6253 enum mode_class mclass = GET_MODE_CLASS (mode);
6254 enum machine_mode innermode;
6255
6256 /* Doh! What's going on? */
6257 if (mclass != MODE_VECTOR_INT
6258 && mclass != MODE_VECTOR_FLOAT
6259 && mclass != MODE_VECTOR_FRACT
6260 && mclass != MODE_VECTOR_UFRACT
6261 && mclass != MODE_VECTOR_ACCUM
6262 && mclass != MODE_VECTOR_UACCUM)
6263 return 0;
6264
6265 /* Hardware support. Woo hoo! */
6266 if (targetm.vector_mode_supported_p (mode))
6267 return 1;
6268
6269 innermode = GET_MODE_INNER (mode);
6270
6271 /* We should probably return 1 if requesting V4DI and we have no DI,
6272 but we have V2DI, but this is probably very unlikely. */
6273
6274 /* If we have support for the inner mode, we can safely emulate it.
6275 We may not have V2DI, but me can emulate with a pair of DIs. */
6276 return targetm.scalar_mode_supported_p (innermode);
6277}
6278
6279
349ae713
NB		 6280/* Handle a "mode" attribute; arguments as in
6281 struct attribute_spec.handler. */
6282
6283static tree
e18476eb
BI		 6284handle_mode_attribute (tree *node, tree name, tree args,
6285 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 6286{
6287 tree type = *node;
88388a52 6288 tree ident = TREE_VALUE (args);
349ae713
NB		 6289
6290 *no_add_attrs = true;
6291
88388a52 6292 if (TREE_CODE (ident) != IDENTIFIER_NODE)
5c498b10 6293 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6294 else
6295 {
6296 int j;
88388a52 6297 const char *p = IDENTIFIER_POINTER (ident);
349ae713
NB		 6298 int len = strlen (p);
6299 enum machine_mode mode = VOIDmode;
6300 tree typefm;
6dd53648 6301 bool valid_mode;
349ae713
NB		 6302
6303 if (len > 4 && p[0] == '_' && p[1] == '_'
6304 && p[len - 1] == '_' && p[len - 2] == '_')
6305 {
28dab132 6306 char *newp = (char *) alloca (len - 1);
349ae713
NB		 6307
6308 strcpy (newp, &p[2]);
6309 newp[len - 4] = '\0';
6310 p = newp;
6311 }
6312
6313 /* Change this type to have a type with the specified mode.
6314 First check for the special modes. */
3f75a254 6315 if (!strcmp (p, "byte"))
349ae713
NB		 6316 mode = byte_mode;
6317 else if (!strcmp (p, "word"))
6318 mode = word_mode;
3f75a254 6319 else if (!strcmp (p, "pointer"))
349ae713 6320 mode = ptr_mode;
c7ff6e7a
AK		 6321 else if (!strcmp (p, "libgcc_cmp_return"))
6322 mode = targetm.libgcc_cmp_return_mode ();
6323 else if (!strcmp (p, "libgcc_shift_count"))
6324 mode = targetm.libgcc_shift_count_mode ();
7b0518e3
UW		 6325 else if (!strcmp (p, "unwind_word"))
6326 mode = targetm.unwind_word_mode ();
349ae713
NB		 6327 else
6328 for (j = 0; j < NUM_MACHINE_MODES; j++)
6329 if (!strcmp (p, GET_MODE_NAME (j)))
61f03aba
RH		 6330 {
6331 mode = (enum machine_mode) j;
6332 break;
6333 }
349ae713
NB		 6334
6335 if (mode == VOIDmode)
4a5eab38 6336 {
88388a52 6337 error ("unknown machine mode %qE", ident);
4a5eab38
PB		 6338 return NULL_TREE;
6339 }
6340
6dd53648
RH		 6341 valid_mode = false;
6342 switch (GET_MODE_CLASS (mode))
4a5eab38 6343 {
6dd53648
RH		 6344 case MODE_INT:
6345 case MODE_PARTIAL_INT:
6346 case MODE_FLOAT:
9a8ce21f 6347 case MODE_DECIMAL_FLOAT:
ab22c1fa
CF		 6348 case MODE_FRACT:
6349 case MODE_UFRACT:
6350 case MODE_ACCUM:
6351 case MODE_UACCUM:
6dd53648
RH		 6352 valid_mode = targetm.scalar_mode_supported_p (mode);
6353 break;
6354
6355 case MODE_COMPLEX_INT:
6356 case MODE_COMPLEX_FLOAT:
6357 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6358 break;
6359
6360 case MODE_VECTOR_INT:
6361 case MODE_VECTOR_FLOAT:
ab22c1fa
CF		 6362 case MODE_VECTOR_FRACT:
6363 case MODE_VECTOR_UFRACT:
6364 case MODE_VECTOR_ACCUM:
6365 case MODE_VECTOR_UACCUM:
5c498b10
DD		 6366 warning (OPT_Wattributes, "specifying vector types with "
6367 "__attribute__ ((mode)) is deprecated");
6368 warning (OPT_Wattributes,
6369 "use __attribute__ ((vector_size)) instead");
6dd53648
RH		 6370 valid_mode = vector_mode_valid_p (mode);
6371 break;
4a5eab38 6372
6dd53648
RH		 6373 default:
6374 break;
6375 }
6376 if (!valid_mode)
6377 {
9e637a26 6378 error ("unable to emulate %qs", p);
6dd53648
RH		 6379 return NULL_TREE;
6380 }
4a5eab38 6381
6dd53648 6382 if (POINTER_TYPE_P (type))
cb2a532e 6383 {
36c5e70a 6384 addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6dd53648
RH		 6385 tree (*fn)(tree, enum machine_mode, bool);
6386
36c5e70a 6387 if (!targetm.addr_space.valid_pointer_mode (mode, as))
cb2a532e 6388 {
9e637a26 6389 error ("invalid pointer mode %qs", p);
cb2a532e
AH		 6390 return NULL_TREE;
6391 }
6392
c22cacf3 6393 if (TREE_CODE (type) == POINTER_TYPE)
6dd53648 6394 fn = build_pointer_type_for_mode;
4977bab6 6395 else
6dd53648
RH		 6396 fn = build_reference_type_for_mode;
6397 typefm = fn (TREE_TYPE (type), mode, false);
cb2a532e 6398 }
6dd53648 6399 else
ab22c1fa
CF		 6400 {
6401 /* For fixed-point modes, we need to test if the signness of type
6402 and the machine mode are consistent. */
6403 if (ALL_FIXED_POINT_MODE_P (mode)
6404 && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6405 {
6406 error ("signness of type and machine mode %qs don't match", p);
6407 return NULL_TREE;
6408 }
6409 /* For fixed-point modes, we need to pass saturating info. */
6410 typefm = lang_hooks.types.type_for_mode (mode,
6411 ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6412 : TYPE_UNSIGNED (type));
6413 }
ec8465a5 6414
6dd53648
RH		 6415 if (typefm == NULL_TREE)
6416 {
61f03aba 6417 error ("no data type for mode %qs", p);
6dd53648
RH		 6418 return NULL_TREE;
6419 }
ec8465a5
RK		 6420 else if (TREE_CODE (type) == ENUMERAL_TYPE)
6421 {
6422 /* For enumeral types, copy the precision from the integer
6423 type returned above. If not an INTEGER_TYPE, we can't use
6424 this mode for this type. */
6425 if (TREE_CODE (typefm) != INTEGER_TYPE)
6426 {
61f03aba 6427 error ("cannot use mode %qs for enumeral types", p);
ec8465a5
RK		 6428 return NULL_TREE;
6429 }
6430
99db1ef0
RH		 6431 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6432 {
6433 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6434 typefm = type;
6435 }
6436 else
6437 {
6438 /* We cannot build a type variant, as there's code that assumes
6439 that TYPE_MAIN_VARIANT has the same mode. This includes the
6440 debug generators. Instead, create a subrange type. This
6441 results in all of the enumeral values being emitted only once
6442 in the original, and the subtype gets them by reference. */
6443 if (TYPE_UNSIGNED (type))
6444 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6445 else
6446 typefm = make_signed_type (TYPE_PRECISION (typefm));
6447 TREE_TYPE (typefm) = type;
6448 }
ec8465a5 6449 }
a2d36602
RH		 6450 else if (VECTOR_MODE_P (mode)
6451 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6452 : TREE_CODE (type) != TREE_CODE (typefm))
61f03aba
RH		 6453 {
6454 error ("mode %qs applied to inappropriate type", p);
6455 return NULL_TREE;
6456 }
6457
6dd53648 6458 *node = typefm;
349ae713
NB		 6459 }
6460
6461 return NULL_TREE;
6462}
6463
6464/* Handle a "section" attribute; arguments as in
6465 struct attribute_spec.handler. */
6466
6467static tree
e18476eb
BI		 6468handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6469 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 6470{
6471 tree decl = *node;
6472
6473 if (targetm.have_named_sections)
6474 {
9fb32434
CT		 6475 user_defined_section_attribute = true;
6476
349ae713
NB		 6477 if ((TREE_CODE (decl) == FUNCTION_DECL
6478 || TREE_CODE (decl) == VAR_DECL)
6479 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6480 {
6481 if (TREE_CODE (decl) == VAR_DECL
6482 && current_function_decl != NULL_TREE
3f75a254 6483 && !TREE_STATIC (decl))
349ae713 6484 {
b8698a0f 6485 error_at (DECL_SOURCE_LOCATION (decl),
c5d75364
MLI		 6486 "section attribute cannot be specified for "
6487 "local variables");
349ae713
NB		 6488 *no_add_attrs = true;
6489 }
6490
6491 /* The decl may have already been given a section attribute
6492 from a previous declaration. Ensure they match. */
6493 else if (DECL_SECTION_NAME (decl) != NULL_TREE
6494 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6495 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6496 {
dee15844
JM		 6497 error ("section of %q+D conflicts with previous declaration",
6498 *node);
349ae713
NB		 6499 *no_add_attrs = true;
6500 }
feb60f03
NS		 6501 else if (TREE_CODE (decl) == VAR_DECL
6502 && !targetm.have_tls && targetm.emutls.tmpl_section
6503 && DECL_THREAD_LOCAL_P (decl))
6504 {
6505 error ("section of %q+D cannot be overridden", *node);
6506 *no_add_attrs = true;
6507 }
349ae713
NB		 6508 else
6509 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6510 }
6511 else
6512 {
dee15844 6513 error ("section attribute not allowed for %q+D", *node);
349ae713
NB		 6514 *no_add_attrs = true;
6515 }
6516 }
6517 else
6518 {
c5d75364
MLI		 6519 error_at (DECL_SOURCE_LOCATION (*node),
6520 "section attributes are not supported for this target");
349ae713
NB		 6521 *no_add_attrs = true;
6522 }
6523
6524 return NULL_TREE;
6525}
6526
6527/* Handle a "aligned" attribute; arguments as in
6528 struct attribute_spec.handler. */
6529
6530static tree
e18476eb 6531handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
a742c759 6532 int flags, bool *no_add_attrs)
349ae713
NB		 6533{
6534 tree decl = NULL_TREE;
6535 tree *type = NULL;
6536 int is_type = 0;
6537 tree align_expr = (args ? TREE_VALUE (args)
6e4f1168 6538 : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
349ae713
NB		 6539 int i;
6540
6541 if (DECL_P (*node))
6542 {
6543 decl = *node;
6544 type = &TREE_TYPE (decl);
6545 is_type = TREE_CODE (*node) == TYPE_DECL;
6546 }
6547 else if (TYPE_P (*node))
6548 type = node, is_type = 1;
6549
349ae713
NB		 6550 if (TREE_CODE (align_expr) != INTEGER_CST)
6551 {
6552 error ("requested alignment is not a constant");
6553 *no_add_attrs = true;
6554 }
6555 else if ((i = tree_log2 (align_expr)) == -1)
6556 {
6557 error ("requested alignment is not a power of 2");
6558 *no_add_attrs = true;
6559 }
d9223014 6560 else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
349ae713
NB		 6561 {
6562 error ("requested alignment is too large");
6563 *no_add_attrs = true;
6564 }
6565 else if (is_type)
6566 {
0f559c16
JM		 6567 if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6568 /* OK, modify the type in place. */;
349ae713
NB		 6569 /* If we have a TYPE_DECL, then copy the type, so that we
6570 don't accidentally modify a builtin type. See pushdecl. */
0f559c16
JM		 6571 else if (decl && TREE_TYPE (decl) != error_mark_node
6572 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
349ae713
NB		 6573 {
6574 tree tt = TREE_TYPE (decl);
8dd16ecc 6575 *type = build_variant_type_copy (*type);
349ae713
NB		 6576 DECL_ORIGINAL_TYPE (decl) = tt;
6577 TYPE_NAME (*type) = decl;
6578 TREE_USED (*type) = TREE_USED (decl);
6579 TREE_TYPE (decl) = *type;
6580 }
0f559c16 6581 else
8dd16ecc 6582 *type = build_variant_type_copy (*type);
349ae713 6583
d9223014 6584 TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
349ae713
NB		 6585 TYPE_USER_ALIGN (*type) = 1;
6586 }
837edd5f 6587 else if (! VAR_OR_FUNCTION_DECL_P (decl)
349ae713
NB		 6588 && TREE_CODE (decl) != FIELD_DECL)
6589 {
dee15844 6590 error ("alignment may not be specified for %q+D", decl);
349ae713
NB		 6591 *no_add_attrs = true;
6592 }
837edd5f 6593 else if (TREE_CODE (decl) == FUNCTION_DECL
d9223014 6594 && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
837edd5f
GK		 6595 {
6596 if (DECL_USER_ALIGN (decl))
6597 error ("alignment for %q+D was previously specified as %d "
6598 "and may not be decreased", decl,
6599 DECL_ALIGN (decl) / BITS_PER_UNIT);
6600 else
6601 error ("alignment for %q+D must be at least %d", decl,
6602 DECL_ALIGN (decl) / BITS_PER_UNIT);
6603 *no_add_attrs = true;
6604 }
349ae713
NB		 6605 else
6606 {
d9223014 6607 DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
349ae713
NB		 6608 DECL_USER_ALIGN (decl) = 1;
6609 }
6610
6611 return NULL_TREE;
6612}
6613
6614/* Handle a "weak" attribute; arguments as in
6615 struct attribute_spec.handler. */
6616
6617static tree
55af93a8 6618handle_weak_attribute (tree *node, tree name,
e18476eb
BI		 6619 tree ARG_UNUSED (args),
6620 int ARG_UNUSED (flags),
6621 bool * ARG_UNUSED (no_add_attrs))
349ae713 6622{
55af93a8 6623 if (TREE_CODE (*node) == FUNCTION_DECL
6b4e94bc
RG		 6624 && DECL_DECLARED_INLINE_P (*node))
6625 {
6626 error ("inline function %q+D cannot be declared weak", *node);
6627 *no_add_attrs = true;
6628 }
6629 else if (TREE_CODE (*node) == FUNCTION_DECL
6630 || TREE_CODE (*node) == VAR_DECL)
55af93a8
DS		 6631 declare_weak (*node);
6632 else
6633 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6634
6635 return NULL_TREE;
6636}
6637
6638/* Handle an "alias" attribute; arguments as in
6639 struct attribute_spec.handler. */
6640
6641static tree
35b1a6fa 6642handle_alias_attribute (tree *node, tree name, tree args,
e18476eb 6643 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 6644{
6645 tree decl = *node;
6646
feab5a67
JM		 6647 if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6648 {
6649 warning (OPT_Wattributes, "%qE attribute ignored", name);
6650 *no_add_attrs = true;
6651 }
6652 else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
b8698a0f 6653 || (TREE_CODE (decl) != FUNCTION_DECL
a9b0b825
GK		 6654 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6655 /* A static variable declaration is always a tentative definition,
6656 but the alias is a non-tentative definition which overrides. */
b8698a0f 6657 || (TREE_CODE (decl) != FUNCTION_DECL
a9b0b825 6658 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
349ae713 6659 {
dee15844 6660 error ("%q+D defined both normally and as an alias", decl);
349ae713
NB		 6661 *no_add_attrs = true;
6662 }
f6a76b9f
RH		 6663
6664 /* Note that the very first time we process a nested declaration,
6665 decl_function_context will not be set. Indeed, *would* never
6666 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6667 we do below. After such frobbery, pushdecl would set the context.
6668 In any case, this is never what we want. */
6669 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
349ae713
NB		 6670 {
6671 tree id;
6672
6673 id = TREE_VALUE (args);
6674 if (TREE_CODE (id) != STRING_CST)
6675 {
40b97a2e 6676 error ("alias argument not a string");
349ae713
NB		 6677 *no_add_attrs = true;
6678 return NULL_TREE;
6679 }
6680 id = get_identifier (TREE_STRING_POINTER (id));
6681 /* This counts as a use of the object pointed to. */
6682 TREE_USED (id) = 1;
6683
6684 if (TREE_CODE (decl) == FUNCTION_DECL)
6685 DECL_INITIAL (decl) = error_mark_node;
6686 else
6de9cd9a 6687 {
a0203ca7
AO		 6688 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6689 DECL_EXTERNAL (decl) = 1;
6690 else
6691 DECL_EXTERNAL (decl) = 0;
6de9cd9a
DN		 6692 TREE_STATIC (decl) = 1;
6693 }
349ae713
NB		 6694 }
6695 else
6696 {
5c498b10 6697 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6698 *no_add_attrs = true;
6699 }
6700
6701 return NULL_TREE;
6702}
6703
a0203ca7
AO		 6704/* Handle a "weakref" attribute; arguments as in struct
6705 attribute_spec.handler. */
6706
6707static tree
6708handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6709 int flags, bool *no_add_attrs)
6710{
6711 tree attr = NULL_TREE;
6712
e1cf56b1
AO		 6713 /* We must ignore the attribute when it is associated with
6714 local-scoped decls, since attribute alias is ignored and many
6715 such symbols do not even have a DECL_WEAK field. */
e7b012c0
JJ		 6716 if (decl_function_context (*node)
6717 || current_function_decl
6718 || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
e1cf56b1
AO		 6719 {
6720 warning (OPT_Wattributes, "%qE attribute ignored", name);
6721 *no_add_attrs = true;
6722 return NULL_TREE;
6723 }
6724
a0203ca7
AO		 6725 /* The idea here is that `weakref("name")' mutates into `weakref,
6726 alias("name")', and weakref without arguments, in turn,
6727 implicitly adds weak. */
6728
6729 if (args)
6730 {
6731 attr = tree_cons (get_identifier ("alias"), args, attr);
6732 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6733
6734 *no_add_attrs = true;
a9b0b825
GK		 6735
6736 decl_attributes (node, attr, flags);
a0203ca7
AO		 6737 }
6738 else
6739 {
6740 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
c5d75364
MLI		 6741 error_at (DECL_SOURCE_LOCATION (*node),
6742 "weakref attribute must appear before alias attribute");
a0203ca7 6743
a9b0b825
GK		 6744 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6745 and that isn't supported; and because it wants to add it to
6746 the list of weak decls, which isn't helpful. */
6747 DECL_WEAK (*node) = 1;
a0203ca7
AO		 6748 }
6749
a0203ca7
AO		 6750 return NULL_TREE;
6751}
6752
349ae713
NB		 6753/* Handle an "visibility" attribute; arguments as in
6754 struct attribute_spec.handler. */
6755
6756static tree
35b1a6fa 6757handle_visibility_attribute (tree *node, tree name, tree args,
e18476eb 6758 int ARG_UNUSED (flags),
b9e75696 6759 bool *ARG_UNUSED (no_add_attrs))
349ae713
NB		 6760{
6761 tree decl = *node;
968b41a1 6762 tree id = TREE_VALUE (args);
b9e75696 6763 enum symbol_visibility vis;
349ae713 6764
d7afec4b
ND		 6765 if (TYPE_P (*node))
6766 {
b9e75696
JM		 6767 if (TREE_CODE (*node) == ENUMERAL_TYPE)
6768 /* OK */;
6769 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6770 {
6771 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6772 name);
6773 return NULL_TREE;
6774 }
6775 else if (TYPE_FIELDS (*node))
6776 {
6777 error ("%qE attribute ignored because %qT is already defined",
6778 name, *node);
6779 return NULL_TREE;
6780 }
d7afec4b 6781 }
3f75a254 6782 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
349ae713 6783 {
5c498b10 6784 warning (OPT_Wattributes, "%qE attribute ignored", name);
968b41a1 6785 return NULL_TREE;
349ae713 6786 }
349ae713 6787
968b41a1
MA		 6788 if (TREE_CODE (id) != STRING_CST)
6789 {
40b97a2e 6790 error ("visibility argument not a string");
968b41a1 6791 return NULL_TREE;
349ae713 6792 }
9f63daea 6793
d7afec4b
ND		 6794 /* If this is a type, set the visibility on the type decl. */
6795 if (TYPE_P (decl))
6796 {
6797 decl = TYPE_NAME (decl);
3f75a254 6798 if (!decl)
c22cacf3 6799 return NULL_TREE;
e8233ac2
AP		 6800 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6801 {
5c498b10 6802 warning (OPT_Wattributes, "%qE attribute ignored on types",
e8233ac2
AP		 6803 name);
6804 return NULL_TREE;
6805 }
d7afec4b 6806 }
349ae713 6807
968b41a1 6808 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
b9e75696 6809 vis = VISIBILITY_DEFAULT;
968b41a1 6810 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
b9e75696 6811 vis = VISIBILITY_INTERNAL;
968b41a1 6812 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
b9e75696 6813 vis = VISIBILITY_HIDDEN;
968b41a1 6814 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
b9e75696 6815 vis = VISIBILITY_PROTECTED;
968b41a1 6816 else
b9e75696
JM		 6817 {
6818 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6819 vis = VISIBILITY_DEFAULT;
6820 }
6821
6822 if (DECL_VISIBILITY_SPECIFIED (decl)
3a687f8b
MM		 6823 && vis != DECL_VISIBILITY (decl))
6824 {
6825 tree attributes = (TYPE_P (*node)
6826 ? TYPE_ATTRIBUTES (*node)
6827 : DECL_ATTRIBUTES (decl));
6828 if (lookup_attribute ("visibility", attributes))
6829 error ("%qD redeclared with different visibility", decl);
6830 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6831 && lookup_attribute ("dllimport", attributes))
6832 error ("%qD was declared %qs which implies default visibility",
6833 decl, "dllimport");
6834 else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6835 && lookup_attribute ("dllexport", attributes))
6836 error ("%qD was declared %qs which implies default visibility",
6837 decl, "dllexport");
6838 }
b9e75696
JM		 6839
6840 DECL_VISIBILITY (decl) = vis;
d7afec4b
ND		 6841 DECL_VISIBILITY_SPECIFIED (decl) = 1;
6842
b9e75696
JM		 6843 /* Go ahead and attach the attribute to the node as well. This is needed
6844 so we can determine whether we have VISIBILITY_DEFAULT because the
6845 visibility was not specified, or because it was explicitly overridden
6846 from the containing scope. */
968b41a1 6847
349ae713
NB		 6848 return NULL_TREE;
6849}
6850
b2ca3702
MM		 6851/* Determine the ELF symbol visibility for DECL, which is either a
6852 variable or a function. It is an error to use this function if a
6853 definition of DECL is not available in this translation unit.
6854 Returns true if the final visibility has been determined by this
6855 function; false if the caller is free to make additional
6856 modifications. */
6857
6858bool
6859c_determine_visibility (tree decl)
6860{
4094f4d2
NS		 6861 gcc_assert (TREE_CODE (decl) == VAR_DECL
6862 || TREE_CODE (decl) == FUNCTION_DECL);
b2ca3702
MM		 6863
6864 /* If the user explicitly specified the visibility with an
6865 attribute, honor that. DECL_VISIBILITY will have been set during
6866 the processing of the attribute. We check for an explicit
6867 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6868 to distinguish the use of an attribute from the use of a "#pragma
6869 GCC visibility push(...)"; in the latter case we still want other
6870 considerations to be able to overrule the #pragma. */
3a687f8b
MM		 6871 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6872 || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6873 && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6874 || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
b2ca3702
MM		 6875 return true;
6876
b9e75696
JM		 6877 /* Set default visibility to whatever the user supplied with
6878 visibility_specified depending on #pragma GCC visibility. */
6879 if (!DECL_VISIBILITY_SPECIFIED (decl))
6880 {
09812622
JJ		 6881 if (visibility_options.inpragma
6882 || DECL_VISIBILITY (decl) != default_visibility)
6883 {
6884 DECL_VISIBILITY (decl) = default_visibility;
6885 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6886 /* If visibility changed and DECL already has DECL_RTL, ensure
6887 symbol flags are updated. */
6888 if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
6889 || TREE_CODE (decl) == FUNCTION_DECL)
6890 && DECL_RTL_SET_P (decl))
6891 make_decl_rtl (decl);
6892 }
b9e75696 6893 }
b2ca3702
MM		 6894 return false;
6895}
6896
dce81a1a
JJ		 6897/* Handle an "tls_model" attribute; arguments as in
6898 struct attribute_spec.handler. */
6899
6900static tree
35b1a6fa 6901handle_tls_model_attribute (tree *node, tree name, tree args,
e18476eb 6902 int ARG_UNUSED (flags), bool *no_add_attrs)
dce81a1a 6903{
c2f7fa15 6904 tree id;
dce81a1a 6905 tree decl = *node;
c2f7fa15 6906 enum tls_model kind;
dce81a1a 6907
c2f7fa15
SB		 6908 *no_add_attrs = true;
6909
5006381c 6910 if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
dce81a1a 6911 {
5c498b10 6912 warning (OPT_Wattributes, "%qE attribute ignored", name);
c2f7fa15 6913 return NULL_TREE;
dce81a1a 6914 }
dce81a1a 6915
c2f7fa15
SB		 6916 kind = DECL_TLS_MODEL (decl);
6917 id = TREE_VALUE (args);
6918 if (TREE_CODE (id) != STRING_CST)
6919 {
6920 error ("tls_model argument not a string");
6921 return NULL_TREE;
dce81a1a
JJ		 6922 }
6923
c2f7fa15
SB		 6924 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6925 kind = TLS_MODEL_LOCAL_EXEC;
6926 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6927 kind = TLS_MODEL_INITIAL_EXEC;
6928 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6929 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6930 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6931 kind = TLS_MODEL_GLOBAL_DYNAMIC;
6932 else
6933 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6934
6935 DECL_TLS_MODEL (decl) = kind;
dce81a1a
JJ		 6936 return NULL_TREE;
6937}
6938
349ae713
NB		 6939/* Handle a "no_instrument_function" attribute; arguments as in
6940 struct attribute_spec.handler. */
6941
6942static tree
35b1a6fa 6943handle_no_instrument_function_attribute (tree *node, tree name,
e18476eb
BI		 6944 tree ARG_UNUSED (args),
6945 int ARG_UNUSED (flags),
a742c759 6946 bool *no_add_attrs)
349ae713
NB		 6947{
6948 tree decl = *node;
6949
6950 if (TREE_CODE (decl) != FUNCTION_DECL)
6951 {
c5d75364
MLI		 6952 error_at (DECL_SOURCE_LOCATION (decl),
6953 "%qE attribute applies only to functions", name);
349ae713
NB		 6954 *no_add_attrs = true;
6955 }
6956 else if (DECL_INITIAL (decl))
6957 {
c5d75364
MLI		 6958 error_at (DECL_SOURCE_LOCATION (decl),
6959 "can%'t set %qE attribute after definition", name);
349ae713
NB		 6960 *no_add_attrs = true;
6961 }
6962 else
6963 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6964
6965 return NULL_TREE;
6966}
6967
6968/* Handle a "malloc" attribute; arguments as in
6969 struct attribute_spec.handler. */
6970
6971static tree
e18476eb
BI		 6972handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6973 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713 6974{
3425638a
JM		 6975 if (TREE_CODE (*node) == FUNCTION_DECL
6976 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
349ae713 6977 DECL_IS_MALLOC (*node) = 1;
349ae713
NB		 6978 else
6979 {
5c498b10 6980 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 6981 *no_add_attrs = true;
6982 }
6983
6984 return NULL_TREE;
6985}
6986
51bc54a6
DM		 6987/* Handle a "alloc_size" attribute; arguments as in
6988 struct attribute_spec.handler. */
6989
6990static tree
6991handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6992 int ARG_UNUSED (flags), bool *no_add_attrs)
6993{
f3f75f69 6994 unsigned arg_count = type_num_arguments (*node);
51bc54a6
DM		 6995 for (; args; args = TREE_CHAIN (args))
6996 {
6997 tree position = TREE_VALUE (args);
6998
6999 if (TREE_CODE (position) != INTEGER_CST
b8698a0f 7000 || TREE_INT_CST_HIGH (position)
51bc54a6
DM		 7001 || TREE_INT_CST_LOW (position) < 1
7002 || TREE_INT_CST_LOW (position) > arg_count )
7003 {
b8698a0f 7004 warning (OPT_Wattributes,
51bc54a6
DM		 7005 "alloc_size parameter outside range");
7006 *no_add_attrs = true;
7007 return NULL_TREE;
7008 }
7009 }
7010 return NULL_TREE;
7011}
7012
0b7b376d
RG		 7013/* Handle a "fn spec" attribute; arguments as in
7014 struct attribute_spec.handler. */
7015
7016static tree
7017handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7018 tree args, int ARG_UNUSED (flags),
7019 bool *no_add_attrs ATTRIBUTE_UNUSED)
7020{
7021 gcc_assert (args
7022 && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7023 && !TREE_CHAIN (args));
7024 return NULL_TREE;
7025}
7026
6e9a3221
AN		 7027/* Handle a "returns_twice" attribute; arguments as in
7028 struct attribute_spec.handler. */
7029
7030static tree
7031handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7032 int ARG_UNUSED (flags), bool *no_add_attrs)
7033{
7034 if (TREE_CODE (*node) == FUNCTION_DECL)
7035 DECL_IS_RETURNS_TWICE (*node) = 1;
7036 else
7037 {
5c498b10 7038 warning (OPT_Wattributes, "%qE attribute ignored", name);
6e9a3221
AN		 7039 *no_add_attrs = true;
7040 }
7041
7042 return NULL_TREE;
7043}
7044
349ae713
NB		 7045/* Handle a "no_limit_stack" attribute; arguments as in
7046 struct attribute_spec.handler. */
7047
7048static tree
35b1a6fa 7049handle_no_limit_stack_attribute (tree *node, tree name,
e18476eb
BI		 7050 tree ARG_UNUSED (args),
7051 int ARG_UNUSED (flags),
a742c759 7052 bool *no_add_attrs)
349ae713
NB		 7053{
7054 tree decl = *node;
7055
7056 if (TREE_CODE (decl) != FUNCTION_DECL)
7057 {
c5d75364
MLI		 7058 error_at (DECL_SOURCE_LOCATION (decl),
7059 "%qE attribute applies only to functions", name);
349ae713
NB		 7060 *no_add_attrs = true;
7061 }
7062 else if (DECL_INITIAL (decl))
7063 {
c5d75364
MLI		 7064 error_at (DECL_SOURCE_LOCATION (decl),
7065 "can%'t set %qE attribute after definition", name);
349ae713
NB		 7066 *no_add_attrs = true;
7067 }
7068 else
7069 DECL_NO_LIMIT_STACK (decl) = 1;
7070
7071 return NULL_TREE;
7072}
7073
7074/* Handle a "pure" attribute; arguments as in
7075 struct attribute_spec.handler. */
7076
7077static tree
e18476eb
BI		 7078handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7079 int ARG_UNUSED (flags), bool *no_add_attrs)
349ae713
NB		 7080{
7081 if (TREE_CODE (*node) == FUNCTION_DECL)
becfd6e5 7082 DECL_PURE_P (*node) = 1;
349ae713
NB		 7083 /* ??? TODO: Support types. */
7084 else
7085 {
5c498b10 7086 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 7087 *no_add_attrs = true;
7088 }
7089
7090 return NULL_TREE;
7091}
7092
dcd6de6d
ZD		 7093/* Handle a "no vops" attribute; arguments as in
7094 struct attribute_spec.handler. */
7095
7096static tree
7097handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7098 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7099 bool *ARG_UNUSED (no_add_attrs))
7100{
7101 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7102 DECL_IS_NOVOPS (*node) = 1;
7103 return NULL_TREE;
7104}
7105
349ae713
NB		 7106/* Handle a "deprecated" attribute; arguments as in
7107 struct attribute_spec.handler. */
35b1a6fa 7108
349ae713 7109static tree
35b1a6fa 7110handle_deprecated_attribute (tree *node, tree name,
9b86d6bb 7111 tree args, int flags,
a742c759 7112 bool *no_add_attrs)
349ae713
NB		 7113{
7114 tree type = NULL_TREE;
7115 int warn = 0;
c51a1ba9 7116 tree what = NULL_TREE;
35b1a6fa 7117
9b86d6bb
L		 7118 if (!args)
7119 *no_add_attrs = true;
7120 else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7121 {
7122 error ("deprecated message is not a string");
7123 *no_add_attrs = true;
7124 }
7125
349ae713
NB		 7126 if (DECL_P (*node))
7127 {
7128 tree decl = *node;
7129 type = TREE_TYPE (decl);
35b1a6fa 7130
349ae713
NB		 7131 if (TREE_CODE (decl) == TYPE_DECL
7132 || TREE_CODE (decl) == PARM_DECL
7133 || TREE_CODE (decl) == VAR_DECL
7134 || TREE_CODE (decl) == FUNCTION_DECL
7135 || TREE_CODE (decl) == FIELD_DECL)
7136 TREE_DEPRECATED (decl) = 1;
7137 else
7138 warn = 1;
7139 }
7140 else if (TYPE_P (*node))
7141 {
7142 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
8dd16ecc 7143 *node = build_variant_type_copy (*node);
349ae713
NB		 7144 TREE_DEPRECATED (*node) = 1;
7145 type = *node;
7146 }
7147 else
7148 warn = 1;
35b1a6fa 7149
349ae713
NB		 7150 if (warn)
7151 {
7152 *no_add_attrs = true;
7153 if (type && TYPE_NAME (type))
7154 {
7155 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
c51a1ba9 7156 what = TYPE_NAME (*node);
349ae713
NB		 7157 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7158 && DECL_NAME (TYPE_NAME (type)))
c51a1ba9 7159 what = DECL_NAME (TYPE_NAME (type));
349ae713
NB		 7160 }
7161 if (what)
5c498b10 7162 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
349ae713 7163 else
5c498b10 7164 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 7165 }
7166
7167 return NULL_TREE;
7168}
7169
349ae713
NB		 7170/* Handle a "vector_size" attribute; arguments as in
7171 struct attribute_spec.handler. */
7172
7173static tree
35b1a6fa 7174handle_vector_size_attribute (tree *node, tree name, tree args,
e18476eb 7175 int ARG_UNUSED (flags),
a742c759 7176 bool *no_add_attrs)
349ae713
NB		 7177{
7178 unsigned HOST_WIDE_INT vecsize, nunits;
26277d41 7179 enum machine_mode orig_mode;
4a5eab38 7180 tree type = *node, new_type, size;
349ae713
NB		 7181
7182 *no_add_attrs = true;
7183
4a5eab38 7184 size = TREE_VALUE (args);
4a5eab38 7185
3f75a254 7186 if (!host_integerp (size, 1))
349ae713 7187 {
5c498b10 7188 warning (OPT_Wattributes, "%qE attribute ignored", name);
349ae713
NB		 7189 return NULL_TREE;
7190 }
7191
7192 /* Get the vector size (in bytes). */
4a5eab38 7193 vecsize = tree_low_cst (size, 1);
349ae713
NB		 7194
7195 /* We need to provide for vector pointers, vector arrays, and
7196 functions returning vectors. For example:
7197
7198 __attribute__((vector_size(16))) short *foo;
7199
7200 In this case, the mode is SI, but the type being modified is
7201 HI, so we need to look further. */
7202
7203 while (POINTER_TYPE_P (type)
7204 || TREE_CODE (type) == FUNCTION_TYPE
43dc123f 7205 || TREE_CODE (type) == METHOD_TYPE
270e749d
JJ		 7206 || TREE_CODE (type) == ARRAY_TYPE
7207 || TREE_CODE (type) == OFFSET_TYPE)
349ae713
NB		 7208 type = TREE_TYPE (type);
7209
7210 /* Get the mode of the type being modified. */
7211 orig_mode = TYPE_MODE (type);
7212
270e749d
JJ		 7213 if ((!INTEGRAL_TYPE_P (type)
7214 && !SCALAR_FLOAT_TYPE_P (type)
7215 && !FIXED_POINT_TYPE_P (type))
3d8bf70f 7216 || (!SCALAR_FLOAT_MODE_P (orig_mode)
ab22c1fa
CF		 7217 && GET_MODE_CLASS (orig_mode) != MODE_INT
7218 && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
e4e5261f
AP		 7219 || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7220 || TREE_CODE (type) == BOOLEAN_TYPE)
349ae713 7221 {
c51a1ba9 7222 error ("invalid vector type for attribute %qE", name);
349ae713
NB		 7223 return NULL_TREE;
7224 }
7225
ee8960e5
JJ		 7226 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7227 {
7228 error ("vector size not an integral multiple of component size");
7229 return NULL;
7230 }
7231
7232 if (vecsize == 0)
7233 {
7234 error ("zero vector size");
7235 return NULL;
7236 }
7237
349ae713
NB		 7238 /* Calculate how many units fit in the vector. */
7239 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
26277d41 7240 if (nunits & (nunits - 1))
349ae713 7241 {
26277d41 7242 error ("number of components of the vector not a power of two");
349ae713
NB		 7243 return NULL_TREE;
7244 }
7245
26277d41 7246 new_type = build_vector_type (type, nunits);
349ae713
NB		 7247
7248 /* Build back pointers if needed. */
5dc11954 7249 *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
349ae713
NB		 7250
7251 return NULL_TREE;
7252}
7253
b34c7881
JT		 7254/* Handle the "nonnull" attribute. */
7255static tree
e18476eb
BI		 7256handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7257 tree args, int ARG_UNUSED (flags),
a742c759 7258 bool *no_add_attrs)
b34c7881
JT		 7259{
7260 tree type = *node;
7261 unsigned HOST_WIDE_INT attr_arg_num;
7262
7263 /* If no arguments are specified, all pointer arguments should be
95bd1dd7 7264 non-null. Verify a full prototype is given so that the arguments
b34c7881 7265 will have the correct types when we actually check them later. */
3f75a254 7266 if (!args)
b34c7881 7267 {
3f75a254 7268 if (!TYPE_ARG_TYPES (type))
b34c7881
JT		 7269 {
7270 error ("nonnull attribute without arguments on a non-prototype");
6de9cd9a 7271 *no_add_attrs = true;
b34c7881
JT		 7272 }
7273 return NULL_TREE;
7274 }
7275
7276 /* Argument list specified. Verify that each argument number references
7277 a pointer argument. */
7278 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7279 {
7280 tree argument;
6de9cd9a 7281 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
b34c7881 7282
3f75a254 7283 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
b34c7881 7284 {
40b97a2e 7285 error ("nonnull argument has invalid operand number (argument %lu)",
b34c7881
JT		 7286 (unsigned long) attr_arg_num);
7287 *no_add_attrs = true;
7288 return NULL_TREE;
7289 }
7290
7291 argument = TYPE_ARG_TYPES (type);
7292 if (argument)
7293 {
7294 for (ck_num = 1; ; ck_num++)
7295 {
3f75a254 7296 if (!argument || ck_num == arg_num)
b34c7881
JT		 7297 break;
7298 argument = TREE_CHAIN (argument);
7299 }
7300
3f75a254 7301 if (!argument
b34c7881
JT		 7302 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7303 {
40b97a2e 7304 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
b34c7881
JT		 7305 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7306 *no_add_attrs = true;
7307 return NULL_TREE;
7308 }
7309
6de9cd9a 7310 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
b34c7881 7311 {
40b97a2e 7312 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
b34c7881
JT		 7313 (unsigned long) attr_arg_num, (unsigned long) arg_num);
7314 *no_add_attrs = true;
7315 return NULL_TREE;
7316 }
7317 }
7318 }
7319
7320 return NULL_TREE;
7321}
7322
7323/* Check the argument list of a function call for null in argument slots
94a0dd7b
SL		 7324 that are marked as requiring a non-null pointer argument. The NARGS
7325 arguments are passed in the array ARGARRAY.
7326*/
b34c7881
JT		 7327
7328static void
94a0dd7b 7329check_function_nonnull (tree attrs, int nargs, tree *argarray)
b34c7881 7330{
94a0dd7b
SL		 7331 tree a, args;
7332 int i;
b34c7881
JT		 7333
7334 for (a = attrs; a; a = TREE_CHAIN (a))
7335 {
7336 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7337 {
6de9cd9a 7338 args = TREE_VALUE (a);
b34c7881 7339
6de9cd9a
DN		 7340 /* Walk the argument list. If we encounter an argument number we
7341 should check for non-null, do it. If the attribute has no args,
7342 then every pointer argument is checked (in which case the check
b34c7881 7343 for pointer type is done in check_nonnull_arg). */
94a0dd7b 7344 for (i = 0; i < nargs; i++)
6de9cd9a 7345 {
94a0dd7b 7346 if (!args || nonnull_check_p (args, i + 1))
dfd0a3de 7347 check_function_arguments_recurse (check_nonnull_arg, NULL,
94a0dd7b
SL		 7348 argarray[i],
7349 i + 1);
6de9cd9a 7350 }
b34c7881
JT		 7351 }
7352 }
7353}
7354
254986c7 7355/* Check that the Nth argument of a function call (counting backwards
94a0dd7b
SL		 7356 from the end) is a (pointer)0. The NARGS arguments are passed in the
7357 array ARGARRAY. */
3d091dac
KG		 7358
7359static void
94a0dd7b 7360check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
3d091dac
KG		 7361{
7362 tree attr = lookup_attribute ("sentinel", attrs);
7363
7364 if (attr)
7365 {
94a0dd7b
SL		 7366 int len = 0;
7367 int pos = 0;
7368 tree sentinel;
c22cacf3 7369
94a0dd7b
SL		 7370 /* Skip over the named arguments. */
7371 while (typelist && len < nargs)
c22cacf3 7372 {
94a0dd7b
SL		 7373 typelist = TREE_CHAIN (typelist);
7374 len++;
7375 }
254986c7 7376
94a0dd7b
SL		 7377 if (TREE_VALUE (attr))
7378 {
7379 tree p = TREE_VALUE (TREE_VALUE (attr));
7380 pos = TREE_INT_CST_LOW (p);
7381 }
254986c7 7382
94a0dd7b
SL		 7383 /* The sentinel must be one of the varargs, i.e.
7384 in position >= the number of fixed arguments. */
7385 if ((nargs - 1 - pos) < len)
7386 {
7387 warning (OPT_Wformat,
7388 "not enough variable arguments to fit a sentinel");
7389 return;
3d091dac 7390 }
94a0dd7b
SL		 7391
7392 /* Validate the sentinel. */
7393 sentinel = argarray[nargs - 1 - pos];
7394 if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7395 || !integer_zerop (sentinel))
7396 /* Although __null (in C++) is only an integer we allow it
7397 nevertheless, as we are guaranteed that it's exactly
7398 as wide as a pointer, and we don't want to force
7399 users to cast the NULL they have written there.
7400 We warn with -Wstrict-null-sentinel, though. */
7401 && (warn_strict_null_sentinel || null_node != sentinel))
7402 warning (OPT_Wformat, "missing sentinel in function call");
3d091dac
KG		 7403 }
7404}
7405
b34c7881
JT		 7406/* Helper for check_function_nonnull; given a list of operands which
7407 must be non-null in ARGS, determine if operand PARAM_NUM should be
7408 checked. */
7409
7410static bool
35b1a6fa 7411nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
b34c7881 7412{
6de9cd9a 7413 unsigned HOST_WIDE_INT arg_num = 0;
b34c7881
JT		 7414
7415 for (; args; args = TREE_CHAIN (args))
7416 {
366de0ce
NS		 7417 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7418
7419 gcc_assert (found);
b34c7881
JT		 7420
7421 if (arg_num == param_num)
7422 return true;
7423 }
7424 return false;
7425}
7426
7427/* Check that the function argument PARAM (which is operand number
7428 PARAM_NUM) is non-null. This is called by check_function_nonnull
7429 via check_function_arguments_recurse. */
7430
7431static void
e18476eb 7432check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
35b1a6fa 7433 unsigned HOST_WIDE_INT param_num)
b34c7881
JT		 7434{
7435 /* Just skip checking the argument if it's not a pointer. This can
7436 happen if the "nonnull" attribute was given without an operand
7437 list (which means to check every pointer argument). */
7438
7439 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7440 return;
7441
7442 if (integer_zerop (param))
30480ec4
DD		 7443 warning (OPT_Wnonnull, "null argument where non-null required "
7444 "(argument %lu)", (unsigned long) param_num);
b34c7881
JT		 7445}
7446
7447/* Helper for nonnull attribute handling; fetch the operand number
7448 from the attribute argument list. */
7449
7450static bool
35b1a6fa 7451get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
b34c7881 7452{
f6d1c3a6 7453 /* Verify the arg number is a constant. */
b34c7881
JT		 7454 if (TREE_CODE (arg_num_expr) != INTEGER_CST
7455 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7456 return false;
7457
7458 *valp = TREE_INT_CST_LOW (arg_num_expr);
7459 return true;
7460}
39f2f3c8
RS		 7461
7462/* Handle a "nothrow" attribute; arguments as in
7463 struct attribute_spec.handler. */
7464
7465static tree
e18476eb
BI		 7466handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7467 int ARG_UNUSED (flags), bool *no_add_attrs)
39f2f3c8
RS		 7468{
7469 if (TREE_CODE (*node) == FUNCTION_DECL)
7470 TREE_NOTHROW (*node) = 1;
7471 /* ??? TODO: Support types. */
7472 else
7473 {
5c498b10 7474 warning (OPT_Wattributes, "%qE attribute ignored", name);
39f2f3c8
RS		 7475 *no_add_attrs = true;
7476 }
7477
7478 return NULL_TREE;
7479}
0bfa5f65
RH		 7480
7481/* Handle a "cleanup" attribute; arguments as in
7482 struct attribute_spec.handler. */
7483
7484static tree
35b1a6fa 7485handle_cleanup_attribute (tree *node, tree name, tree args,
e18476eb 7486 int ARG_UNUSED (flags), bool *no_add_attrs)
0bfa5f65
RH		 7487{
7488 tree decl = *node;
7489 tree cleanup_id, cleanup_decl;
7490
7491 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7492 for global destructors in C++. This requires infrastructure that
7493 we don't have generically at the moment. It's also not a feature
7494 we'd be missing too much, since we do have attribute constructor. */
7495 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7496 {
5c498b10 7497 warning (OPT_Wattributes, "%qE attribute ignored", name);
0bfa5f65
RH		 7498 *no_add_attrs = true;
7499 return NULL_TREE;
7500 }
7501
7502 /* Verify that the argument is a function in scope. */
7503 /* ??? We could support pointers to functions here as well, if
7504 that was considered desirable. */
7505 cleanup_id = TREE_VALUE (args);
7506 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7507 {
40b97a2e 7508 error ("cleanup argument not an identifier");
0bfa5f65
RH		 7509 *no_add_attrs = true;
7510 return NULL_TREE;
7511 }
10e6657a 7512 cleanup_decl = lookup_name (cleanup_id);
0bfa5f65
RH		 7513 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7514 {
40b97a2e 7515 error ("cleanup argument not a function");
0bfa5f65
RH		 7516 *no_add_attrs = true;
7517 return NULL_TREE;
7518 }
7519
35b1a6fa 7520 /* That the function has proper type is checked with the
0bfa5f65
RH		 7521 eventual call to build_function_call. */
7522
7523 return NULL_TREE;
7524}
72954a4f
JM		 7525
7526/* Handle a "warn_unused_result" attribute. No special handling. */
7527
7528static tree
7529handle_warn_unused_result_attribute (tree *node, tree name,
e18476eb
BI		 7530 tree ARG_UNUSED (args),
7531 int ARG_UNUSED (flags), bool *no_add_attrs)
72954a4f
JM		 7532{
7533 /* Ignore the attribute for functions not returning any value. */
7534 if (VOID_TYPE_P (TREE_TYPE (*node)))
7535 {
5c498b10 7536 warning (OPT_Wattributes, "%qE attribute ignored", name);
72954a4f
JM		 7537 *no_add_attrs = true;
7538 }
7539
7540 return NULL_TREE;
7541}
3d091dac
KG		 7542
7543/* Handle a "sentinel" attribute. */
7544
7545static tree
254986c7 7546handle_sentinel_attribute (tree *node, tree name, tree args,
3d091dac
KG		 7547 int ARG_UNUSED (flags), bool *no_add_attrs)
7548{
7549 tree params = TYPE_ARG_TYPES (*node);
7550
7551 if (!params)
7552 {
5c498b10
DD		 7553 warning (OPT_Wattributes,
7554 "%qE attribute requires prototypes with named arguments", name);
3d091dac 7555 *no_add_attrs = true;
3d091dac 7556 }
254986c7
KG		 7557 else
7558 {
7559 while (TREE_CHAIN (params))
7560 params = TREE_CHAIN (params);
3d091dac 7561
254986c7 7562 if (VOID_TYPE_P (TREE_VALUE (params)))
c22cacf3 7563 {
5c498b10
DD		 7564 warning (OPT_Wattributes,
7565 "%qE attribute only applies to variadic functions", name);
254986c7
KG		 7566 *no_add_attrs = true;
7567 }
7568 }
c22cacf3 7569
254986c7 7570 if (args)
3d091dac 7571 {
254986c7
KG		 7572 tree position = TREE_VALUE (args);
7573
254986c7 7574 if (TREE_CODE (position) != INTEGER_CST)
c22cacf3 7575 {
b8698a0f 7576 warning (OPT_Wattributes,
aa86a51b 7577 "requested position is not an integer constant");
254986c7
KG		 7578 *no_add_attrs = true;
7579 }
7580 else
c22cacf3 7581 {
254986c7
KG		 7582 if (tree_int_cst_lt (position, integer_zero_node))
7583 {
aa86a51b
DM		 7584 warning (OPT_Wattributes,
7585 "requested position is less than zero");
254986c7
KG		 7586 *no_add_attrs = true;
7587 }
7588 }
3d091dac 7589 }
c22cacf3 7590
3d091dac
KG		 7591 return NULL_TREE;
7592}
b5d32c25
KG		 7593
7594/* Handle a "type_generic" attribute. */
7595
7596static tree
7597handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7598 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7599 bool * ARG_UNUSED (no_add_attrs))
7600{
3bf5906b 7601 tree params;
b8698a0f 7602
3bf5906b
KG		 7603 /* Ensure we have a function type. */
7604 gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
b8698a0f 7605
3bf5906b
KG		 7606 params = TYPE_ARG_TYPES (*node);
7607 while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7608 params = TREE_CHAIN (params);
7609
7610 /* Ensure we have a variadic function. */
7611 gcc_assert (!params);
b5d32c25
KG		 7612
7613 return NULL_TREE;
7614}
ab442df7 7615
5779e713 7616/* Handle a "target" attribute. */
ab442df7
MM		 7617
7618static tree
5779e713 7619handle_target_attribute (tree *node, tree name, tree args, int flags,
ab442df7
MM		 7620 bool *no_add_attrs)
7621{
7622 /* Ensure we have a function type. */
7623 if (TREE_CODE (*node) != FUNCTION_DECL)
7624 {
7625 warning (OPT_Wattributes, "%qE attribute ignored", name);
7626 *no_add_attrs = true;
7627 }
ab442df7
MM		 7628 else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7629 flags))
7630 *no_add_attrs = true;
7631
7632 return NULL_TREE;
7633}
7634
7635/* Arguments being collected for optimization. */
7636typedef const char *const_char_p; /* For DEF_VEC_P. */
7637DEF_VEC_P(const_char_p);
7638DEF_VEC_ALLOC_P(const_char_p, gc);
7639static GTY(()) VEC(const_char_p, gc) *optimize_args;
7640
7641
7642/* Inner function to convert a TREE_LIST to argv string to parse the optimize
7643 options in ARGS. ATTR_P is true if this is for attribute(optimize), and
7644 false for #pragma GCC optimize. */
7645
7646bool
7647parse_optimize_options (tree args, bool attr_p)
7648{
7649 bool ret = true;
7650 unsigned opt_argc;
7651 unsigned i;
cbc19f39 7652 int saved_flag_strict_aliasing;
ab442df7 7653 const char **opt_argv;
6e2f1956
JM		 7654 struct cl_decoded_option *decoded_options;
7655 unsigned int decoded_options_count;
ab442df7
MM		 7656 tree ap;
7657
7658 /* Build up argv vector. Just in case the string is stored away, use garbage
7659 collected strings. */
7660 VEC_truncate (const_char_p, optimize_args, 0);
7661 VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7662
7663 for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7664 {
7665 tree value = TREE_VALUE (ap);
7666
7667 if (TREE_CODE (value) == INTEGER_CST)
7668 {
7669 char buffer[20];
7670 sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7671 VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7672 }
7673
7674 else if (TREE_CODE (value) == STRING_CST)
7675 {
7676 /* Split string into multiple substrings. */
7677 size_t len = TREE_STRING_LENGTH (value);
7678 char *p = ASTRDUP (TREE_STRING_POINTER (value));
7679 char *end = p + len;
7680 char *comma;
7681 char *next_p = p;
7682
7683 while (next_p != NULL)
7684 {
7685 size_t len2;
7686 char *q, *r;
7687
7688 p = next_p;
7689 comma = strchr (p, ',');
7690 if (comma)
7691 {
7692 len2 = comma - p;
7693 *comma = '\0';
7694 next_p = comma+1;
7695 }
7696 else
7697 {
7698 len2 = end - p;
7699 next_p = NULL;
7700 }
7701
a9429e29 7702 r = q = (char *) ggc_alloc_atomic (len2 + 3);
ab442df7
MM		 7703
7704 /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7705 options. */
7706 if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7707 {
7708 ret = false;
7709 if (attr_p)
7710 warning (OPT_Wattributes,
7711 "Bad option %s to optimize attribute.", p);
7712 else
7713 warning (OPT_Wpragmas,
7714 "Bad option %s to pragma attribute", p);
7715 continue;
7716 }
7717
7718 if (*p != '-')
7719 {
7720 *r++ = '-';
7721
7722 /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7723 itself is -Os, and any other switch begins with a -f. */
7724 if ((*p >= '0' && *p <= '9')
7725 || (p[0] == 's' && p[1] == '\0'))
7726 *r++ = 'O';
7727 else if (*p != 'O')
7728 *r++ = 'f';
7729 }
7730
7731 memcpy (r, p, len2);
7732 r[len2] = '\0';
7733 VEC_safe_push (const_char_p, gc, optimize_args, q);
7734 }
7735
7736 }
7737 }
7738
7739 opt_argc = VEC_length (const_char_p, optimize_args);
7740 opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7741
7742 for (i = 1; i < opt_argc; i++)
7743 opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7744
cbc19f39
JJ		 7745 saved_flag_strict_aliasing = flag_strict_aliasing;
7746
ab442df7 7747 /* Now parse the options. */
6e2f1956
JM		 7748 decode_options (opt_argc, opt_argv, &decoded_options,
7749 &decoded_options_count);
ab442df7 7750
2b7e2984
SE		 7751 targetm.override_options_after_change();
7752
cbc19f39
JJ		 7753 /* Don't allow changing -fstrict-aliasing. */
7754 flag_strict_aliasing = saved_flag_strict_aliasing;
7755
ab442df7
MM		 7756 VEC_truncate (const_char_p, optimize_args, 0);
7757 return ret;
7758}
7759
7760/* For handling "optimize" attribute. arguments as in
7761 struct attribute_spec.handler. */
7762
7763static tree
7764handle_optimize_attribute (tree *node, tree name, tree args,
7765 int ARG_UNUSED (flags), bool *no_add_attrs)
7766{
7767 /* Ensure we have a function type. */
7768 if (TREE_CODE (*node) != FUNCTION_DECL)
7769 {
7770 warning (OPT_Wattributes, "%qE attribute ignored", name);
7771 *no_add_attrs = true;
7772 }
7773 else
7774 {
7775 struct cl_optimization cur_opts;
7776 tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7777
7778 /* Save current options. */
7779 cl_optimization_save (&cur_opts);
7780
7781 /* If we previously had some optimization options, use them as the
7782 default. */
7783 if (old_opts)
7784 cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7785
7786 /* Parse options, and update the vector. */
7787 parse_optimize_options (args, true);
7788 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7789 = build_optimization_node ();
7790
7791 /* Restore current options. */
7792 cl_optimization_restore (&cur_opts);
7793 }
7794
7795 return NULL_TREE;
7796}
b34c7881 7797\f
94a0dd7b
SL		 7798/* Check for valid arguments being passed to a function.
7799 ATTRS is a list of attributes. There are NARGS arguments in the array
7800 ARGARRAY. TYPELIST is the list of argument types for the function.
7801 */
b34c7881 7802void
94a0dd7b 7803check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
b34c7881
JT		 7804{
7805 /* Check for null being passed in a pointer argument that must be
7806 non-null. We also need to do this if format checking is enabled. */
7807
7808 if (warn_nonnull)
94a0dd7b 7809 check_function_nonnull (attrs, nargs, argarray);
b34c7881
JT		 7810
7811 /* Check for errors in format strings. */
7812
7876a414 7813 if (warn_format || warn_missing_format_attribute)
94a0dd7b 7814 check_function_format (attrs, nargs, argarray);
7876a414
KG		 7815
7816 if (warn_format)
94a0dd7b 7817 check_function_sentinel (attrs, nargs, argarray, typelist);
b34c7881
JT		 7818}
7819
7820/* Generic argument checking recursion routine. PARAM is the argument to
7821 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
7822 once the argument is resolved. CTX is context for the callback. */
7823void
35b1a6fa
AJ		 7824check_function_arguments_recurse (void (*callback)
7825 (void *, tree, unsigned HOST_WIDE_INT),
7826 void *ctx, tree param,
7827 unsigned HOST_WIDE_INT param_num)
b34c7881 7828{
1043771b 7829 if (CONVERT_EXPR_P (param)
1344f9a3
JM		 7830 && (TYPE_PRECISION (TREE_TYPE (param))
7831 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
b34c7881
JT		 7832 {
7833 /* Strip coercion. */
7834 check_function_arguments_recurse (callback, ctx,
6de9cd9a 7835 TREE_OPERAND (param, 0), param_num);
b34c7881
JT		 7836 return;
7837 }
7838
7839 if (TREE_CODE (param) == CALL_EXPR)
7840 {
5039610b 7841 tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
b34c7881
JT		 7842 tree attrs;
7843 bool found_format_arg = false;
7844
7845 /* See if this is a call to a known internationalization function
7846 that modifies a format arg. Such a function may have multiple
7847 format_arg attributes (for example, ngettext). */
7848
7849 for (attrs = TYPE_ATTRIBUTES (type);
7850 attrs;
7851 attrs = TREE_CHAIN (attrs))
7852 if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7853 {
5039610b 7854 tree inner_arg;
b34c7881
JT		 7855 tree format_num_expr;
7856 int format_num;
7857 int i;
5039610b 7858 call_expr_arg_iterator iter;
b34c7881
JT		 7859
7860 /* Extract the argument number, which was previously checked
7861 to be valid. */
7862 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
b34c7881 7863
366de0ce
NS		 7864 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7865 && !TREE_INT_CST_HIGH (format_num_expr));
b34c7881
JT		 7866
7867 format_num = TREE_INT_CST_LOW (format_num_expr);
7868
5039610b
SL		 7869 for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7870 inner_arg != 0;
7871 inner_arg = next_call_expr_arg (&iter), i++)
b34c7881
JT		 7872 if (i == format_num)
7873 {
7874 check_function_arguments_recurse (callback, ctx,
5039610b 7875 inner_arg, param_num);
b34c7881
JT		 7876 found_format_arg = true;
7877 break;
7878 }
7879 }
7880
7881 /* If we found a format_arg attribute and did a recursive check,
7882 we are done with checking this argument. Otherwise, we continue
7883 and this will be considered a non-literal. */
7884 if (found_format_arg)
7885 return;
7886 }
7887
7888 if (TREE_CODE (param) == COND_EXPR)
7889 {
7890 /* Check both halves of the conditional expression. */
7891 check_function_arguments_recurse (callback, ctx,
6de9cd9a 7892 TREE_OPERAND (param, 1), param_num);
b34c7881 7893 check_function_arguments_recurse (callback, ctx,
6de9cd9a 7894 TREE_OPERAND (param, 2), param_num);
b34c7881
JT		 7895 return;
7896 }
7897
7898 (*callback) (ctx, param, param_num);
7899}
e2500fed 7900
a98c2819
MLI		 7901/* Checks for a builtin function FNDECL that the number of arguments
7902 NARGS against the required number REQUIRED and issues an error if
7903 there is a mismatch. Returns true if the number of arguments is
7904 correct, otherwise false. */
83322951
RG		 7905
7906static bool
a98c2819 7907builtin_function_validate_nargs (tree fndecl, int nargs, int required)
83322951
RG		 7908{
7909 if (nargs < required)
7910 {
a98c2819
MLI		 7911 error_at (input_location,
7912 "not enough arguments to function %qE", fndecl);
83322951
RG		 7913 return false;
7914 }
7915 else if (nargs > required)
7916 {
a98c2819
MLI		 7917 error_at (input_location,
7918 "too many arguments to function %qE", fndecl);
83322951
RG		 7919 return false;
7920 }
7921 return true;
7922}
7923
7924/* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7925 Returns false if there was an error, otherwise true. */
7926
7927bool
7928check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7929{
7930 if (!DECL_BUILT_IN (fndecl)
7931 || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7932 return true;
7933
7934 switch (DECL_FUNCTION_CODE (fndecl))
7935 {
7936 case BUILT_IN_CONSTANT_P:
a98c2819 7937 return builtin_function_validate_nargs (fndecl, nargs, 1);
83322951
RG		 7938
7939 case BUILT_IN_ISFINITE:
7940 case BUILT_IN_ISINF:
05f41289 7941 case BUILT_IN_ISINF_SIGN:
83322951
RG		 7942 case BUILT_IN_ISNAN:
7943 case BUILT_IN_ISNORMAL:
a98c2819 7944 if (builtin_function_validate_nargs (fndecl, nargs, 1))
83322951
RG		 7945 {
7946 if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7947 {
7948 error ("non-floating-point argument in call to "
7949 "function %qE", fndecl);
7950 return false;
7951 }
7952 return true;
7953 }
7954 return false;
7955
7956 case BUILT_IN_ISGREATER:
7957 case BUILT_IN_ISGREATEREQUAL:
7958 case BUILT_IN_ISLESS:
7959 case BUILT_IN_ISLESSEQUAL:
7960 case BUILT_IN_ISLESSGREATER:
7961 case BUILT_IN_ISUNORDERED:
a98c2819 7962 if (builtin_function_validate_nargs (fndecl, nargs, 2))
83322951
RG		 7963 {
7964 enum tree_code code0, code1;
7965 code0 = TREE_CODE (TREE_TYPE (args[0]));
7966 code1 = TREE_CODE (TREE_TYPE (args[1]));
7967 if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7968 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7969 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7970 {
7971 error ("non-floating-point arguments in call to "
7972 "function %qE", fndecl);
7973 return false;
7974 }
7975 return true;
7976 }
7977 return false;
7978
3bf5906b 7979 case BUILT_IN_FPCLASSIFY:
a98c2819 7980 if (builtin_function_validate_nargs (fndecl, nargs, 6))
3bf5906b
KG		 7981 {
7982 unsigned i;
b8698a0f 7983
3bf5906b
KG		 7984 for (i=0; i<5; i++)
7985 if (TREE_CODE (args[i]) != INTEGER_CST)
7986 {
7987 error ("non-const integer argument %u in call to function %qE",
7988 i+1, fndecl);
7989 return false;
7990 }
7991
7992 if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7993 {
7994 error ("non-floating-point argument in call to function %qE",
7995 fndecl);
7996 return false;
7997 }
7998 return true;
7999 }
8000 return false;
8001
83322951
RG		 8002 default:
8003 return true;
8004 }
8005}
8006
d07605f5
AP		 8007/* Function to help qsort sort FIELD_DECLs by name order. */
8008
8009int
8010field_decl_cmp (const void *x_p, const void *y_p)
8011{
28dab132
BI		 8012 const tree *const x = (const tree *const) x_p;
8013 const tree *const y = (const tree *const) y_p;
8014
d07605f5
AP		 8015 if (DECL_NAME (*x) == DECL_NAME (*y))
8016 /* A nontype is "greater" than a type. */
8017 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8018 if (DECL_NAME (*x) == NULL_TREE)
8019 return -1;
8020 if (DECL_NAME (*y) == NULL_TREE)
8021 return 1;
8022 if (DECL_NAME (*x) < DECL_NAME (*y))
8023 return -1;
8024 return 1;
8025}
8026
8027static struct {
8028 gt_pointer_operator new_value;
8029 void *cookie;
8030} resort_data;
8031
8032/* This routine compares two fields like field_decl_cmp but using the
8033pointer operator in resort_data. */
8034
8035static int
8036resort_field_decl_cmp (const void *x_p, const void *y_p)
8037{
28dab132
BI		 8038 const tree *const x = (const tree *const) x_p;
8039 const tree *const y = (const tree *const) y_p;
d07605f5
AP		 8040
8041 if (DECL_NAME (*x) == DECL_NAME (*y))
8042 /* A nontype is "greater" than a type. */
8043 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8044 if (DECL_NAME (*x) == NULL_TREE)
8045 return -1;
8046 if (DECL_NAME (*y) == NULL_TREE)
8047 return 1;
8048 {
8049 tree d1 = DECL_NAME (*x);
8050 tree d2 = DECL_NAME (*y);
8051 resort_data.new_value (&d1, resort_data.cookie);
8052 resort_data.new_value (&d2, resort_data.cookie);
8053 if (d1 < d2)
8054 return -1;
8055 }
8056 return 1;
8057}
8058
8059/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
8060
8061void
8062resort_sorted_fields (void *obj,
e18476eb 8063 void * ARG_UNUSED (orig_obj),
6de9cd9a
DN		 8064 gt_pointer_operator new_value,
8065 void *cookie)
d07605f5 8066{
e18476eb 8067 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
d07605f5
AP		 8068 resort_data.new_value = new_value;
8069 resort_data.cookie = cookie;
8070 qsort (&sf->elts[0], sf->len, sizeof (tree),
6de9cd9a 8071 resort_field_decl_cmp);
d07605f5
AP		 8072}
8073
0a3ee0fd
GDR		 8074/* Subroutine of c_parse_error.
8075 Return the result of concatenating LHS and RHS. RHS is really
8076 a string literal, its first character is indicated by RHS_START and
3292fb42 8077 RHS_SIZE is its length (including the terminating NUL character).
0a3ee0fd
GDR		 8078
8079 The caller is responsible for deleting the returned pointer. */
8080
8081static char *
8082catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8083{
8084 const int lhs_size = strlen (lhs);
8085 char *result = XNEWVEC (char, lhs_size + rhs_size);
8086 strncpy (result, lhs, lhs_size);
8087 strncpy (result + lhs_size, rhs_start, rhs_size);
8088 return result;
8089}
8090
4b794eaf 8091/* Issue the error given by GMSGID, indicating that it occurred before
4bb8ca28
MM		 8092 TOKEN, which had the associated VALUE. */
8093
8094void
b8698a0f 8095c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
cfc93532 8096 tree value, unsigned char token_flags)
4bb8ca28 8097{
0a3ee0fd
GDR		 8098#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8099
8100 char *message = NULL;
4bb8ca28 8101
cfc93532 8102 if (token_type == CPP_EOF)
4b794eaf 8103 message = catenate_messages (gmsgid, " at end of input");
b8698a0f
L		 8104 else if (token_type == CPP_CHAR
8105 || token_type == CPP_WCHAR
cfc93532
MLI		 8106 || token_type == CPP_CHAR16
8107 || token_type == CPP_CHAR32)
4bb8ca28
MM		 8108 {
8109 unsigned int val = TREE_INT_CST_LOW (value);
b6baa67d
KVH		 8110 const char *prefix;
8111
cfc93532 8112 switch (token_type)
b6baa67d
KVH		 8113 {
8114 default:
8115 prefix = "";
8116 break;
8117 case CPP_WCHAR:
8118 prefix = "L";
8119 break;
8120 case CPP_CHAR16:
8121 prefix = "u";
8122 break;
8123 case CPP_CHAR32:
8124 prefix = "U";
8125 break;
8126 }
8127
4bb8ca28 8128 if (val <= UCHAR_MAX && ISGRAPH (val))
c22cacf3 8129 message = catenate_messages (gmsgid, " before %s'%c'");
4bb8ca28 8130 else
c22cacf3 8131 message = catenate_messages (gmsgid, " before %s'\\x%x'");
0a3ee0fd 8132
b6baa67d 8133 error (message, prefix, val);
0a3ee0fd
GDR		 8134 free (message);
8135 message = NULL;
4bb8ca28 8136 }
b8698a0f
L		 8137 else if (token_type == CPP_STRING
8138 || token_type == CPP_WSTRING
cfc93532 8139 || token_type == CPP_STRING16
2c6e3f55
JJ		 8140 || token_type == CPP_STRING32
8141 || token_type == CPP_UTF8STRING)
4b794eaf 8142 message = catenate_messages (gmsgid, " before string constant");
cfc93532 8143 else if (token_type == CPP_NUMBER)
4b794eaf 8144 message = catenate_messages (gmsgid, " before numeric constant");
cfc93532 8145 else if (token_type == CPP_NAME)
0a3ee0fd 8146 {
4b794eaf 8147 message = catenate_messages (gmsgid, " before %qE");
c51a1ba9 8148 error (message, value);
0a3ee0fd
GDR		 8149 free (message);
8150 message = NULL;
8151 }
cfc93532 8152 else if (token_type == CPP_PRAGMA)
bc4071dd 8153 message = catenate_messages (gmsgid, " before %<#pragma%>");
cfc93532 8154 else if (token_type == CPP_PRAGMA_EOL)
bc4071dd 8155 message = catenate_messages (gmsgid, " before end of line");
cfc93532 8156 else if (token_type < N_TTYPES)
0a3ee0fd 8157 {
4b794eaf 8158 message = catenate_messages (gmsgid, " before %qs token");
cfc93532 8159 error (message, cpp_type2name (token_type, token_flags));
0a3ee0fd
GDR		 8160 free (message);
8161 message = NULL;
8162 }
4bb8ca28 8163 else
4b794eaf 8164 error (gmsgid);
0a3ee0fd
GDR		 8165
8166 if (message)
8167 {
8168 error (message);
8169 free (message);
8170 }
c22cacf3 8171#undef catenate_messages
4bb8ca28
MM		 8172}
8173
87cf0651
SB		 8174/* Mapping for cpp message reasons to the options that enable them. */
8175
8176struct reason_option_codes_t
8177{
8178 const int reason; /* cpplib message reason. */
8179 const int option_code; /* gcc option that controls this message. */
8180};
8181
8182static const struct reason_option_codes_t option_codes[] = {
8183 {CPP_W_DEPRECATED, OPT_Wdeprecated},
8184 {CPP_W_COMMENTS, OPT_Wcomments},
8185 {CPP_W_TRIGRAPHS, OPT_Wtrigraphs},
8186 {CPP_W_MULTICHAR, OPT_Wmultichar},
8187 {CPP_W_TRADITIONAL, OPT_Wtraditional},
8188 {CPP_W_LONG_LONG, OPT_Wlong_long},
8189 {CPP_W_ENDIF_LABELS, OPT_Wendif_labels},
8190 {CPP_W_VARIADIC_MACROS, OPT_Wvariadic_macros},
8191 {CPP_W_BUILTIN_MACRO_REDEFINED, OPT_Wbuiltin_macro_redefined},
8192 {CPP_W_UNDEF, OPT_Wundef},
8193 {CPP_W_UNUSED_MACROS, OPT_Wunused_macros},
8194 {CPP_W_CXX_OPERATOR_NAMES, OPT_Wc___compat},
8195 {CPP_W_NORMALIZE, OPT_Wnormalized_},
8196 {CPP_W_INVALID_PCH, OPT_Winvalid_pch},
8197 {CPP_W_WARNING_DIRECTIVE, OPT_Wcpp},
8198 {CPP_W_NONE, 0}
8199};
8200
8201/* Return the gcc option code associated with the reason for a cpp
8202 message, or 0 if none. */
8203
8204static int
8205c_option_controlling_cpp_error (int reason)
8206{
8207 const struct reason_option_codes_t *entry;
8208
8209 for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8210 {
8211 if (entry->reason == reason)
8212 return entry->option_code;
8213 }
8214 return 0;
8215}
8216
148e4216 8217/* Callback from cpp_error for PFILE to print diagnostics from the
87cf0651
SB		 8218 preprocessor. The diagnostic is of type LEVEL, with REASON set
8219 to the reason code if LEVEL is represents a warning, at location
148e4216
JM		 8220 LOCATION unless this is after lexing and the compiler's location
8221 should be used instead, with column number possibly overridden by
8222 COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8223 the arguments. Returns true if a diagnostic was emitted, false
8224 otherwise. */
8225
8226bool
87cf0651 8227c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
148e4216
JM		 8228 location_t location, unsigned int column_override,
8229 const char *msg, va_list *ap)
8230{
8231 diagnostic_info diagnostic;
8232 diagnostic_t dlevel;
5f0f4a3b 8233 bool save_warn_system_headers = global_dc->warn_system_headers;
148e4216
JM		 8234 bool ret;
8235
8236 switch (level)
8237 {
8238 case CPP_DL_WARNING_SYSHDR:
8239 if (flag_no_output)
8240 return false;
5f0f4a3b 8241 global_dc->warn_system_headers = 1;
148e4216
JM		 8242 /* Fall through. */
8243 case CPP_DL_WARNING:
8244 if (flag_no_output)
8245 return false;
8246 dlevel = DK_WARNING;
8247 break;
8248 case CPP_DL_PEDWARN:
8249 if (flag_no_output && !flag_pedantic_errors)
8250 return false;
8251 dlevel = DK_PEDWARN;
8252 break;
8253 case CPP_DL_ERROR:
8254 dlevel = DK_ERROR;
8255 break;
8256 case CPP_DL_ICE:
8257 dlevel = DK_ICE;
8258 break;
8259 case CPP_DL_NOTE:
8260 dlevel = DK_NOTE;
8261 break;
47580d22
JM		 8262 case CPP_DL_FATAL:
8263 dlevel = DK_FATAL;
8264 break;
148e4216
JM		 8265 default:
8266 gcc_unreachable ();
8267 }
8268 if (done_lexing)
8269 location = input_location;
8270 diagnostic_set_info_translated (&diagnostic, msg, ap,
8271 location, dlevel);
8272 if (column_override)
8273 diagnostic_override_column (&diagnostic, column_override);
87cf0651
SB		 8274 diagnostic_override_option_index (&diagnostic,
8275 c_option_controlling_cpp_error (reason));
148e4216
JM		 8276 ret = report_diagnostic (&diagnostic);
8277 if (level == CPP_DL_WARNING_SYSHDR)
5f0f4a3b 8278 global_dc->warn_system_headers = save_warn_system_headers;
148e4216
JM		 8279 return ret;
8280}
8281
c5ff069d
ZW		 8282/* Convert a character from the host to the target execution character
8283 set. cpplib handles this, mostly. */
8284
8285HOST_WIDE_INT
8286c_common_to_target_charset (HOST_WIDE_INT c)
8287{
8288 /* Character constants in GCC proper are sign-extended under -fsigned-char,
8289 zero-extended under -fno-signed-char. cpplib insists that characters
8290 and character constants are always unsigned. Hence we must convert
8291 back and forth. */
8292 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8293
8294 uc = cpp_host_to_exec_charset (parse_in, uc);
8295
8296 if (flag_signed_char)
8297 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8298 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8299 else
8300 return uc;
8301}
8302
ee8a6a3e 8303/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6d4d7b0e
PB		 8304 component references, with STOP_REF, or alternatively an INDIRECT_REF of
8305 NULL, at the bottom; much like the traditional rendering of offsetof as a
8306 macro. Returns the folded and properly cast result. */
ee8a6a3e
RH		 8307
8308static tree
6d4d7b0e 8309fold_offsetof_1 (tree expr, tree stop_ref)
ee8a6a3e
RH		 8310{
8311 enum tree_code code = PLUS_EXPR;
8312 tree base, off, t;
8313
6d4d7b0e
PB		 8314 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8315 return size_zero_node;
8316
ee8a6a3e
RH		 8317 switch (TREE_CODE (expr))
8318 {
8319 case ERROR_MARK:
8320 return expr;
8321
545b7d8c
VR		 8322 case VAR_DECL:
8323 error ("cannot apply %<offsetof%> to static data member %qD", expr);
8324 return error_mark_node;
8325
6d4d7b0e 8326 case CALL_EXPR:
8d5f60ac 8327 case TARGET_EXPR:
6d4d7b0e
PB		 8328 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8329 return error_mark_node;
8330
6d4d7b0e
PB		 8331 case NOP_EXPR:
8332 case INDIRECT_REF:
61c3c490
DS		 8333 if (!integer_zerop (TREE_OPERAND (expr, 0)))
8334 {
8335 error ("cannot apply %<offsetof%> to a non constant address");
8336 return error_mark_node;
8337 }
8338 return size_zero_node;
6d4d7b0e 8339
ee8a6a3e 8340 case COMPONENT_REF:
6d4d7b0e 8341 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
ee8a6a3e
RH		 8342 if (base == error_mark_node)
8343 return base;
8344
8345 t = TREE_OPERAND (expr, 1);
8346 if (DECL_C_BIT_FIELD (t))
8347 {
8348 error ("attempt to take address of bit-field structure "
c51a1ba9 8349 "member %qD", t);
ee8a6a3e
RH		 8350 return error_mark_node;
8351 }
db3927fb
AH		 8352 off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8353 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8354 1)
8355 / BITS_PER_UNIT));
ee8a6a3e
RH		 8356 break;
8357
8358 case ARRAY_REF:
6d4d7b0e 8359 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
ee8a6a3e
RH		 8360 if (base == error_mark_node)
8361 return base;
8362
8363 t = TREE_OPERAND (expr, 1);
8364 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8365 {
8366 code = MINUS_EXPR;
db3927fb 8367 t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
ee8a6a3e
RH		 8368 }
8369 t = convert (sizetype, t);
8370 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
61c3c490
DS		 8371
8372 /* Check if the offset goes beyond the upper bound of the array. */
d32599a6
JJ		 8373 if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8374 {
8375 tree upbound = array_ref_up_bound (expr);
8376 if (upbound != NULL_TREE
8377 && TREE_CODE (upbound) == INTEGER_CST
8378 && !tree_int_cst_equal (upbound,
8379 TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8380 {
8381 upbound = size_binop (PLUS_EXPR, upbound,
8382 build_int_cst (TREE_TYPE (upbound), 1));
8383 if (tree_int_cst_lt (upbound, t))
8384 {
8385 tree v;
8386
8387 for (v = TREE_OPERAND (expr, 0);
8388 TREE_CODE (v) == COMPONENT_REF;
8389 v = TREE_OPERAND (v, 0))
8390 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8391 == RECORD_TYPE)
8392 {
910ad8de
NF		 8393 tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8394 for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
d32599a6
JJ		 8395 if (TREE_CODE (fld_chain) == FIELD_DECL)
8396 break;
8397
8398 if (fld_chain)
8399 break;
8400 }
8401 /* Don't warn if the array might be considered a poor
8402 man's flexible array member with a very permissive
8403 definition thereof. */
8404 if (TREE_CODE (v) == ARRAY_REF
8405 || TREE_CODE (v) == COMPONENT_REF)
8406 warning (OPT_Warray_bounds,
8407 "index %E denotes an offset "
8408 "greater than size of %qT",
8409 t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8410 }
8411 }
8412 }
ee8a6a3e
RH		 8413 break;
8414
1916c916
VR		 8415 case COMPOUND_EXPR:
8416 /* Handle static members of volatile structs. */
8417 t = TREE_OPERAND (expr, 1);
8418 gcc_assert (TREE_CODE (t) == VAR_DECL);
8419 return fold_offsetof_1 (t, stop_ref);
8420
ee8a6a3e 8421 default:
366de0ce 8422 gcc_unreachable ();
ee8a6a3e
RH		 8423 }
8424
8425 return size_binop (code, base, off);
8426}
8427
8428tree
6d4d7b0e 8429fold_offsetof (tree expr, tree stop_ref)
ee8a6a3e
RH		 8430{
8431 /* Convert back from the internal sizetype to size_t. */
6d4d7b0e 8432 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
ee8a6a3e
RH		 8433}
8434
d166d4c3
AK		 8435/* Warn for A ?: C expressions (with B omitted) where A is a boolean
8436 expression, because B will always be true. */
8437
8438void
8439warn_for_omitted_condop (location_t location, tree cond)
8440{
8441 if (truth_value_p (TREE_CODE (cond)))
8442 warning_at (location, OPT_Wparentheses,
8443 "the omitted middle operand in ?: will always be %<true%>, "
8444 "suggest explicit middle operand");
8445}
8446
37dc0d8d 8447/* Print an error message for an invalid lvalue. USE says
5ae9ba3e
MM		 8448 how the lvalue is being used and so selects the error message. */
8449
37dc0d8d
JM		 8450void
8451lvalue_error (enum lvalue_use use)
5ae9ba3e 8452{
37dc0d8d 8453 switch (use)
5ae9ba3e 8454 {
37dc0d8d 8455 case lv_assign:
5d352b2d 8456 error ("lvalue required as left operand of assignment");
37dc0d8d
JM		 8457 break;
8458 case lv_increment:
5d352b2d 8459 error ("lvalue required as increment operand");
37dc0d8d
JM		 8460 break;
8461 case lv_decrement:
5d352b2d 8462 error ("lvalue required as decrement operand");
37dc0d8d
JM		 8463 break;
8464 case lv_addressof:
5d352b2d 8465 error ("lvalue required as unary %<&%> operand");
37dc0d8d
JM		 8466 break;
8467 case lv_asm:
5d352b2d 8468 error ("lvalue required in asm statement");
37dc0d8d
JM		 8469 break;
8470 default:
8471 gcc_unreachable ();
5ae9ba3e 8472 }
5ae9ba3e 8473}
aab038d5
RH		 8474\f
8475/* *PTYPE is an incomplete array. Complete it with a domain based on
8476 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8477 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8478 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
8479
8480int
8481complete_array_type (tree *ptype, tree initial_value, bool do_default)
8482{
8483 tree maxindex, type, main_type, elt, unqual_elt;
8484 int failure = 0, quals;
06d40de8 8485 hashval_t hashcode = 0;
aab038d5
RH		 8486
8487 maxindex = size_zero_node;
8488 if (initial_value)
8489 {
8490 if (TREE_CODE (initial_value) == STRING_CST)
8491 {
8492 int eltsize
8493 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8494 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8495 }
8496 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8497 {
4038c495 8498 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
aab038d5 8499
4038c495 8500 if (VEC_empty (constructor_elt, v))
aab038d5
RH		 8501 {
8502 if (pedantic)
8503 failure = 3;
8504 maxindex = integer_minus_one_node;
8505 }
8506 else
8507 {
8508 tree curindex;
4038c495
GB		 8509 unsigned HOST_WIDE_INT cnt;
8510 constructor_elt *ce;
cff7525f 8511 bool fold_p = false;
aab038d5 8512
4038c495 8513 if (VEC_index (constructor_elt, v, 0)->index)
db3927fb
AH		 8514 maxindex = fold_convert_loc (input_location, sizetype,
8515 VEC_index (constructor_elt,
8516 v, 0)->index);
aab038d5
RH		 8517 curindex = maxindex;
8518
4038c495
GB		 8519 for (cnt = 1;
8520 VEC_iterate (constructor_elt, v, cnt, ce);
8521 cnt++)
aab038d5 8522 {
cff7525f 8523 bool curfold_p = false;
4038c495 8524 if (ce->index)
cff7525f 8525 curindex = ce->index, curfold_p = true;
aab038d5 8526 else
cff7525f
JH		 8527 {
8528 if (fold_p)
8529 curindex = fold_convert (sizetype, curindex);
db3927fb
AH		 8530 curindex = size_binop (PLUS_EXPR, curindex,
8531 size_one_node);
cff7525f 8532 }
aab038d5 8533 if (tree_int_cst_lt (maxindex, curindex))
cff7525f 8534 maxindex = curindex, fold_p = curfold_p;
aab038d5 8535 }
cff7525f
JH		 8536 if (fold_p)
8537 maxindex = fold_convert (sizetype, maxindex);
aab038d5
RH		 8538 }
8539 }
8540 else
8541 {
8542 /* Make an error message unless that happened already. */
8543 if (initial_value != error_mark_node)
8544 failure = 1;
8545 }
8546 }
8547 else
8548 {
8549 failure = 2;
8550 if (!do_default)
8551 return failure;
8552 }
8553
8554 type = *ptype;
8555 elt = TREE_TYPE (type);
8556 quals = TYPE_QUALS (strip_array_types (elt));
8557 if (quals == 0)
8558 unqual_elt = elt;
8559 else
36c5e70a 8560 unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
aab038d5
RH		 8561
8562 /* Using build_distinct_type_copy and modifying things afterward instead
8563 of using build_array_type to create a new type preserves all of the
8564 TYPE_LANG_FLAG_? bits that the front end may have set. */
8565 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8566 TREE_TYPE (main_type) = unqual_elt;
8567 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8568 layout_type (main_type);
8569
06d40de8
DG		 8570 /* Make sure we have the canonical MAIN_TYPE. */
8571 hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
b8698a0f 8572 hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
06d40de8
DG		 8573 hashcode);
8574 main_type = type_hash_canon (hashcode, main_type);
8575
9ae165a0
DG		 8576 /* Fix the canonical type. */
8577 if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8578 || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8579 SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8580 else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8581 || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8582 != TYPE_DOMAIN (main_type)))
b8698a0f 8583 TYPE_CANONICAL (main_type)
9ae165a0
DG		 8584 = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8585 TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8586 else
8587 TYPE_CANONICAL (main_type) = main_type;
8588
aab038d5
RH		 8589 if (quals == 0)
8590 type = main_type;
8591 else
8592 type = c_build_qualified_type (main_type, quals);
8593
7bfcb402
JM		 8594 if (COMPLETE_TYPE_P (type)
8595 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8596 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8597 {
8598 error ("size of array is too large");
8599 /* If we proceed with the array type as it is, we'll eventually
8600 crash in tree_low_cst(). */
8601 type = error_mark_node;
8602 }
8603
aab038d5
RH		 8604 *ptype = type;
8605 return failure;
8606}
5ae9ba3e 8607
48ae6c13
RH		 8608\f
8609/* Used to help initialize the builtin-types.def table. When a type of
8610 the correct size doesn't exist, use error_mark_node instead of NULL.
8611 The later results in segfaults even when a decl using the type doesn't
8612 get invoked. */
8613
8614tree
8615builtin_type_for_size (int size, bool unsignedp)
8616{
8617 tree type = lang_hooks.types.type_for_size (size, unsignedp);
8618 return type ? type : error_mark_node;
8619}
8620
8621/* A helper function for resolve_overloaded_builtin in resolving the
8622 overloaded __sync_ builtins. Returns a positive power of 2 if the
8623 first operand of PARAMS is a pointer to a supported data type.
8624 Returns 0 if an error is encountered. */
8625
8626static int
bbbbb16a 8627sync_resolve_size (tree function, VEC(tree,gc) *params)
48ae6c13
RH		 8628{
8629 tree type;
8630 int size;
8631
bbbbb16a 8632 if (VEC_empty (tree, params))
48ae6c13
RH		 8633 {
8634 error ("too few arguments to function %qE", function);
8635 return 0;
8636 }
8637
bbbbb16a 8638 type = TREE_TYPE (VEC_index (tree, params, 0));
48ae6c13
RH		 8639 if (TREE_CODE (type) != POINTER_TYPE)
8640 goto incompatible;
8641
8642 type = TREE_TYPE (type);
8643 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8644 goto incompatible;
8645
8646 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
a0274e3e 8647 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
48ae6c13
RH		 8648 return size;
8649
8650 incompatible:
8651 error ("incompatible type for argument %d of %qE", 1, function);
8652 return 0;
8653}
8654
c22cacf3 8655/* A helper function for resolve_overloaded_builtin. Adds casts to
48ae6c13
RH		 8656 PARAMS to make arguments match up with those of FUNCTION. Drops
8657 the variadic arguments at the end. Returns false if some error
8658 was encountered; true on success. */
8659
8660static bool
bbbbb16a 8661sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
48ae6c13
RH		 8662{
8663 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8664 tree ptype;
bbbbb16a 8665 unsigned int parmnum;
48ae6c13
RH		 8666
8667 /* We've declared the implementation functions to use "volatile void *"
8668 as the pointer parameter, so we shouldn't get any complaints from the
8669 call to check_function_arguments what ever type the user used. */
8670 arg_types = TREE_CHAIN (arg_types);
bbbbb16a 8671 ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
48ae6c13
RH		 8672
8673 /* For the rest of the values, we need to cast these to FTYPE, so that we
8674 don't get warnings for passing pointer types, etc. */
bbbbb16a 8675 parmnum = 0;
48ae6c13
RH		 8676 while (arg_types != void_list_node)
8677 {
8678 tree val;
8679
bbbbb16a
ILT		 8680 ++parmnum;
8681 if (VEC_length (tree, params) <= parmnum)
48ae6c13
RH		 8682 {
8683 error ("too few arguments to function %qE", orig_function);
8684 return false;
8685 }
8686
8687 /* ??? Ideally for the first conversion we'd use convert_for_assignment
8688 so that we get warnings for anything that doesn't match the pointer
8689 type. This isn't portable across the C and C++ front ends atm. */
bbbbb16a 8690 val = VEC_index (tree, params, parmnum);
48ae6c13
RH		 8691 val = convert (ptype, val);
8692 val = convert (TREE_VALUE (arg_types), val);
bbbbb16a 8693 VEC_replace (tree, params, parmnum, val);
48ae6c13
RH		 8694
8695 arg_types = TREE_CHAIN (arg_types);
48ae6c13
RH		 8696 }
8697
8698 /* The definition of these primitives is variadic, with the remaining
8699 being "an optional list of variables protected by the memory barrier".
8700 No clue what that's supposed to mean, precisely, but we consider all
8701 call-clobbered variables to be protected so we're safe. */
bbbbb16a 8702 VEC_truncate (tree, params, parmnum + 1);
48ae6c13
RH		 8703
8704 return true;
8705}
8706
c22cacf3 8707/* A helper function for resolve_overloaded_builtin. Adds a cast to
48ae6c13
RH		 8708 RESULT to make it match the type of the first pointer argument in
8709 PARAMS. */
8710
8711static tree
bbbbb16a 8712sync_resolve_return (tree first_param, tree result)
48ae6c13 8713{
bbbbb16a 8714 tree ptype = TREE_TYPE (TREE_TYPE (first_param));
99db1ef0 8715 ptype = TYPE_MAIN_VARIANT (ptype);
48ae6c13
RH		 8716 return convert (ptype, result);
8717}
8718
8719/* Some builtin functions are placeholders for other expressions. This
8720 function should be called immediately after parsing the call expression
8721 before surrounding code has committed to the type of the expression.
8722
c2255bc4
AH		 8723 LOC is the location of the builtin call.
8724
48ae6c13
RH		 8725 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8726 PARAMS is the argument list for the call. The return value is non-null
8727 when expansion is complete, and null if normal processing should
8728 continue. */
8729
8730tree
c2255bc4 8731resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
48ae6c13
RH		 8732{
8733 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
58646b77
PB		 8734 switch (DECL_BUILT_IN_CLASS (function))
8735 {
8736 case BUILT_IN_NORMAL:
8737 break;
8738 case BUILT_IN_MD:
8739 if (targetm.resolve_overloaded_builtin)
c2255bc4 8740 return targetm.resolve_overloaded_builtin (loc, function, params);
58646b77 8741 else
c22cacf3 8742 return NULL_TREE;
58646b77
PB		 8743 default:
8744 return NULL_TREE;
8745 }
c22cacf3 8746
58646b77 8747 /* Handle BUILT_IN_NORMAL here. */
48ae6c13
RH		 8748 switch (orig_code)
8749 {
8750 case BUILT_IN_FETCH_AND_ADD_N:
8751 case BUILT_IN_FETCH_AND_SUB_N:
8752 case BUILT_IN_FETCH_AND_OR_N:
8753 case BUILT_IN_FETCH_AND_AND_N:
8754 case BUILT_IN_FETCH_AND_XOR_N:
8755 case BUILT_IN_FETCH_AND_NAND_N:
8756 case BUILT_IN_ADD_AND_FETCH_N:
8757 case BUILT_IN_SUB_AND_FETCH_N:
8758 case BUILT_IN_OR_AND_FETCH_N:
8759 case BUILT_IN_AND_AND_FETCH_N:
8760 case BUILT_IN_XOR_AND_FETCH_N:
8761 case BUILT_IN_NAND_AND_FETCH_N:
8762 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8763 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8764 case BUILT_IN_LOCK_TEST_AND_SET_N:
8765 case BUILT_IN_LOCK_RELEASE_N:
8766 {
8767 int n = sync_resolve_size (function, params);
bbbbb16a 8768 tree new_function, first_param, result;
48ae6c13
RH		 8769
8770 if (n == 0)
8771 return error_mark_node;
8772
8773 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8774 if (!sync_resolve_params (function, new_function, params))
8775 return error_mark_node;
8776
bbbbb16a 8777 first_param = VEC_index (tree, params, 0);
c2255bc4 8778 result = build_function_call_vec (loc, new_function, params, NULL);
48ae6c13
RH		 8779 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8780 && orig_code != BUILT_IN_LOCK_RELEASE_N)
bbbbb16a 8781 result = sync_resolve_return (first_param, result);
48ae6c13
RH		 8782
8783 return result;
8784 }
8785
8786 default:
58646b77 8787 return NULL_TREE;
48ae6c13
RH		 8788 }
8789}
8790
5bed876a
AH		 8791/* Ignoring their sign, return true if two scalar types are the same. */
8792bool
8793same_scalar_type_ignoring_signedness (tree t1, tree t2)
8794{
8795 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8796
ab22c1fa
CF		 8797 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8798 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8799 || c2 == FIXED_POINT_TYPE));
5bed876a
AH		 8800
8801 /* Equality works here because c_common_signed_type uses
8802 TYPE_MAIN_VARIANT. */
12753674
RE		 8803 return c_common_signed_type (t1)
8804 == c_common_signed_type (t2);
5bed876a
AH		 8805}
8806
104f8784
KG		 8807/* Check for missing format attributes on function pointers. LTYPE is
8808 the new type or left-hand side type. RTYPE is the old type or
8809 right-hand side type. Returns TRUE if LTYPE is missing the desired
8810 attribute. */
8811
8812bool
8813check_missing_format_attribute (tree ltype, tree rtype)
8814{
8815 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8816 tree ra;
8817
8818 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8819 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8820 break;
8821 if (ra)
8822 {
8823 tree la;
8824 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8825 if (is_attribute_p ("format", TREE_PURPOSE (la)))
8826 break;
8827 return !la;
8828 }
8829 else
8830 return false;
8831}
8832
ff6b6641
GDR		 8833/* Subscripting with type char is likely to lose on a machine where
8834 chars are signed. So warn on any machine, but optionally. Don't
8835 warn for unsigned char since that type is safe. Don't warn for
8836 signed char because anyone who uses that must have done so
8837 deliberately. Furthermore, we reduce the false positive load by
8838 warning only for non-constant value of type char. */
8839
8840void
8841warn_array_subscript_with_type_char (tree index)
8842{
8843 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8844 && TREE_CODE (index) != INTEGER_CST)
8845 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8846}
8847
2a67bec2
ILT		 8848/* Implement -Wparentheses for the unexpected C precedence rules, to
8849 cover cases like x + y << z which readers are likely to
8850 misinterpret. We have seen an expression in which CODE is a binary
100d537d
MLI		 8851 operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8852 before folding had CODE_LEFT and CODE_RIGHT. CODE_LEFT and
8853 CODE_RIGHT may be ERROR_MARK, which means that that side of the
8854 expression was not formed using a binary or unary operator, or it
8855 was enclosed in parentheses. */
2a67bec2
ILT		 8856
8857void
100d537d 8858warn_about_parentheses (enum tree_code code,
fb3e178a 8859 enum tree_code code_left, tree arg_left,
100d537d 8860 enum tree_code code_right, tree arg_right)
2a67bec2
ILT		 8861{
8862 if (!warn_parentheses)
8863 return;
8864
100d537d
MLI		 8865 /* This macro tests that the expression ARG with original tree code
8866 CODE appears to be a boolean expression. or the result of folding a
8867 boolean expression. */
8868#define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG) \
8869 (truth_value_p (TREE_CODE (ARG)) \
8870 || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE \
8871 /* Folding may create 0 or 1 integers from other expressions. */ \
8872 || ((CODE) != INTEGER_CST \
8873 && (integer_onep (ARG) || integer_zerop (ARG))))
8874
b8698a0f 8875 switch (code)
2a67bec2 8876 {
100d537d
MLI		 8877 case LSHIFT_EXPR:
8878 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
2a67bec2 8879 warning (OPT_Wparentheses,
100d537d
MLI		 8880 "suggest parentheses around %<+%> inside %<<<%>");
8881 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8882 warning (OPT_Wparentheses,
8883 "suggest parentheses around %<-%> inside %<<<%>");
8884 return;
2a67bec2 8885
100d537d
MLI		 8886 case RSHIFT_EXPR:
8887 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
2a67bec2 8888 warning (OPT_Wparentheses,
100d537d
MLI		 8889 "suggest parentheses around %<+%> inside %<>>%>");
8890 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8891 warning (OPT_Wparentheses,
8892 "suggest parentheses around %<-%> inside %<>>%>");
8893 return;
2a67bec2 8894
100d537d
MLI		 8895 case TRUTH_ORIF_EXPR:
8896 if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8897 warning (OPT_Wparentheses,
8898 "suggest parentheses around %<&&%> within %<||%>");
8899 return;
8900
8901 case BIT_IOR_EXPR:
2a67bec2
ILT		 8902 if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8903 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8904 || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8905 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8906 warning (OPT_Wparentheses,
100d537d 8907 "suggest parentheses around arithmetic in operand of %<|%>");
2a67bec2 8908 /* Check cases like x|y==z */
100d537d
MLI		 8909 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8910 || TREE_CODE_CLASS (code_right) == tcc_comparison)
2a67bec2 8911 warning (OPT_Wparentheses,
100d537d
MLI		 8912 "suggest parentheses around comparison in operand of %<|%>");
8913 /* Check cases like !x | y */
8914 else if (code_left == TRUTH_NOT_EXPR
8915 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
a231ffe5 8916 warning (OPT_Wparentheses, "suggest parentheses around operand of "
100d537d
MLI		 8917 "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8918 return;
2a67bec2 8919
100d537d 8920 case BIT_XOR_EXPR:
2a67bec2
ILT		 8921 if (code_left == BIT_AND_EXPR
8922 || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8923 || code_right == BIT_AND_EXPR
8924 || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8925 warning (OPT_Wparentheses,
100d537d 8926 "suggest parentheses around arithmetic in operand of %<^%>");
2a67bec2 8927 /* Check cases like x^y==z */
100d537d
MLI		 8928 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8929 || TREE_CODE_CLASS (code_right) == tcc_comparison)
2a67bec2 8930 warning (OPT_Wparentheses,
100d537d
MLI		 8931 "suggest parentheses around comparison in operand of %<^%>");
8932 return;
2a67bec2 8933
100d537d
MLI		 8934 case BIT_AND_EXPR:
8935 if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8936 warning (OPT_Wparentheses,
8937 "suggest parentheses around %<+%> in operand of %<&%>");
8938 else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
2a67bec2 8939 warning (OPT_Wparentheses,
100d537d 8940 "suggest parentheses around %<-%> in operand of %<&%>");
2a67bec2 8941 /* Check cases like x&y==z */
100d537d
MLI		 8942 else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8943 || TREE_CODE_CLASS (code_right) == tcc_comparison)
2a67bec2 8944 warning (OPT_Wparentheses,
100d537d
MLI		 8945 "suggest parentheses around comparison in operand of %<&%>");
8946 /* Check cases like !x & y */
8947 else if (code_left == TRUTH_NOT_EXPR
8948 && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
a231ffe5 8949 warning (OPT_Wparentheses, "suggest parentheses around operand of "
100d537d
MLI		 8950 "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8951 return;
2a67bec2 8952
100d537d 8953 case EQ_EXPR:
e7917d06
DM		 8954 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8955 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8956 warning (OPT_Wparentheses,
100d537d
MLI		 8957 "suggest parentheses around comparison in operand of %<==%>");
8958 return;
8959 case NE_EXPR:
8960 if (TREE_CODE_CLASS (code_left) == tcc_comparison
8961 || TREE_CODE_CLASS (code_right) == tcc_comparison)
8962 warning (OPT_Wparentheses,
8963 "suggest parentheses around comparison in operand of %<!=%>");
8964 return;
8965
8966 default:
8967 if (TREE_CODE_CLASS (code) == tcc_comparison
8968 && ((TREE_CODE_CLASS (code_left) == tcc_comparison
fb3e178a
JJ		 8969 && code_left != NE_EXPR && code_left != EQ_EXPR
8970 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
100d537d 8971 || (TREE_CODE_CLASS (code_right) == tcc_comparison
fb3e178a
JJ		 8972 && code_right != NE_EXPR && code_right != EQ_EXPR
8973 && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
100d537d 8974 warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
e7917d06 8975 "have their mathematical meaning");
100d537d 8976 return;
e7917d06 8977 }
100d537d 8978#undef NOT_A_BOOLEAN_EXPR_P
2a67bec2
ILT		 8979}
8980
c616e51b
MLI		 8981/* If LABEL (a LABEL_DECL) has not been used, issue a warning. */
8982
8983void
8984warn_for_unused_label (tree label)
8985{
8986 if (!TREE_USED (label))
8987 {
8988 if (DECL_INITIAL (label))
8989 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8990 else
8991 warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8992 }
8993}
ff6b6641 8994
1f1d5130
MS		 8995#ifndef TARGET_HAS_TARGETCM
8996struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8997#endif
8998
c9f9eb5d
AH		 8999/* Warn for division by zero according to the value of DIVISOR. LOC
9000 is the location of the division operator. */
2e9cb75e
MLI		 9001
9002void
c9f9eb5d 9003warn_for_div_by_zero (location_t loc, tree divisor)
2e9cb75e 9004{
ab22c1fa
CF		 9005 /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9006 about division by zero. Do not issue a warning if DIVISOR has a
2e9cb75e
MLI		 9007 floating-point type, since we consider 0.0/0.0 a valid way of
9008 generating a NaN. */
7d882b83 9009 if (c_inhibit_evaluation_warnings == 0
ab22c1fa 9010 && (integer_zerop (divisor) || fixed_zerop (divisor)))
c9f9eb5d 9011 warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
2e9cb75e
MLI		 9012}
9013
2d12797c
MLI		 9014/* Subroutine of build_binary_op. Give warnings for comparisons
9015 between signed and unsigned quantities that may fail. Do the
9016 checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9017 so that casts will be considered, but default promotions won't
ba47d38d
AH		 9018 be.
9019
9020 LOCATION is the location of the comparison operator.
2d12797c
MLI		 9021
9022 The arguments of this function map directly to local variables
9023 of build_binary_op. */
9024
b8698a0f 9025void
ba47d38d 9026warn_for_sign_compare (location_t location,
b8698a0f
L		 9027 tree orig_op0, tree orig_op1,
9028 tree op0, tree op1,
2d12797c
MLI		 9029 tree result_type, enum tree_code resultcode)
9030{
9031 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9032 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9033 int unsignedp0, unsignedp1;
b8698a0f 9034
2d12797c
MLI		 9035 /* In C++, check for comparison of different enum types. */
9036 if (c_dialect_cxx()
9037 && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9038 && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9039 && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
ead51d36 9040 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
2d12797c 9041 {
ba47d38d
AH		 9042 warning_at (location,
9043 OPT_Wsign_compare, "comparison between types %qT and %qT",
9044 TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
2d12797c
MLI		 9045 }
9046
9047 /* Do not warn if the comparison is being done in a signed type,
9048 since the signed type will only be chosen if it can represent
9049 all the values of the unsigned type. */
9050 if (!TYPE_UNSIGNED (result_type))
9051 /* OK */;
9052 /* Do not warn if both operands are unsigned. */
9053 else if (op0_signed == op1_signed)
9054 /* OK */;
9055 else
9056 {
ead51d36 9057 tree sop, uop, base_type;
2d12797c 9058 bool ovf;
ead51d36 9059
2d12797c
MLI		 9060 if (op0_signed)
9061 sop = orig_op0, uop = orig_op1;
b8698a0f 9062 else
2d12797c
MLI		 9063 sop = orig_op1, uop = orig_op0;
9064
b8698a0f 9065 STRIP_TYPE_NOPS (sop);
2d12797c 9066 STRIP_TYPE_NOPS (uop);
ead51d36
JJ		 9067 base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9068 ? TREE_TYPE (result_type) : result_type);
2d12797c
MLI		 9069
9070 /* Do not warn if the signed quantity is an unsuffixed integer
9071 literal (or some static constant expression involving such
9072 literals or a conditional expression involving such literals)
9073 and it is non-negative. */
9074 if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9075 /* OK */;
9076 /* Do not warn if the comparison is an equality operation, the
9077 unsigned quantity is an integral constant, and it would fit
9078 in the result if the result were signed. */
9079 else if (TREE_CODE (uop) == INTEGER_CST
9080 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
ead51d36 9081 && int_fits_type_p (uop, c_common_signed_type (base_type)))
2d12797c
MLI		 9082 /* OK */;
9083 /* In C, do not warn if the unsigned quantity is an enumeration
9084 constant and its maximum value would fit in the result if the
9085 result were signed. */
9086 else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9087 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9088 && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
ead51d36 9089 c_common_signed_type (base_type)))
2d12797c 9090 /* OK */;
b8698a0f 9091 else
ba47d38d 9092 warning_at (location,
b8698a0f 9093 OPT_Wsign_compare,
ba47d38d 9094 "comparison between signed and unsigned integer expressions");
2d12797c 9095 }
b8698a0f 9096
2d12797c
MLI		 9097 /* Warn if two unsigned values are being compared in a size larger
9098 than their original size, and one (and only one) is the result of
9099 a `~' operator. This comparison will always fail.
b8698a0f 9100
2d12797c
MLI		 9101 Also warn if one operand is a constant, and the constant does not
9102 have all bits set that are set in the ~ operand when it is
9103 extended. */
9104
9105 op0 = get_narrower (op0, &unsignedp0);
9106 op1 = get_narrower (op1, &unsignedp1);
b8698a0f 9107
2d12797c
MLI		 9108 if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9109 ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9110 {
9111 if (TREE_CODE (op0) == BIT_NOT_EXPR)
9112 op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9113 if (TREE_CODE (op1) == BIT_NOT_EXPR)
9114 op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9115
9116 if (host_integerp (op0, 0) || host_integerp (op1, 0))
9117 {
9118 tree primop;
9119 HOST_WIDE_INT constant, mask;
9120 int unsignedp;
9121 unsigned int bits;
b8698a0f 9122
2d12797c
MLI		 9123 if (host_integerp (op0, 0))
9124 {
9125 primop = op1;
9126 unsignedp = unsignedp1;
9127 constant = tree_low_cst (op0, 0);
9128 }
9129 else
9130 {
9131 primop = op0;
9132 unsignedp = unsignedp0;
9133 constant = tree_low_cst (op1, 0);
9134 }
b8698a0f 9135
2d12797c
MLI		 9136 bits = TYPE_PRECISION (TREE_TYPE (primop));
9137 if (bits < TYPE_PRECISION (result_type)
9138 && bits < HOST_BITS_PER_LONG && unsignedp)
9139 {
9140 mask = (~ (HOST_WIDE_INT) 0) << bits;
9141 if ((mask & constant) != mask)
9142 {
9143 if (constant == 0)
b8698a0f 9144 warning (OPT_Wsign_compare,
2d12797c
MLI		 9145 "promoted ~unsigned is always non-zero");
9146 else
b8698a0f 9147 warning_at (location, OPT_Wsign_compare,
ba47d38d 9148 "comparison of promoted ~unsigned with constant");
2d12797c
MLI		 9149 }
9150 }
9151 }
9152 else if (unsignedp0 && unsignedp1
9153 && (TYPE_PRECISION (TREE_TYPE (op0))
9154 < TYPE_PRECISION (result_type))
9155 && (TYPE_PRECISION (TREE_TYPE (op1))
9156 < TYPE_PRECISION (result_type)))
ba47d38d 9157 warning_at (location, OPT_Wsign_compare,
2d12797c
MLI		 9158 "comparison of promoted ~unsigned with unsigned");
9159 }
9160}
9161
d0940d56
DS		 9162/* Setup a TYPE_DECL node as a typedef representation.
9163
9164 X is a TYPE_DECL for a typedef statement. Create a brand new
9165 ..._TYPE node (which will be just a variant of the existing
9166 ..._TYPE node with identical properties) and then install X
9167 as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9168
9169 The whole point here is to end up with a situation where each
9170 and every ..._TYPE node the compiler creates will be uniquely
9171 associated with AT MOST one node representing a typedef name.
9172 This way, even though the compiler substitutes corresponding
9173 ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9174 early on, later parts of the compiler can always do the reverse
9175 translation and get back the corresponding typedef name. For
9176 example, given:
9177
9178 typedef struct S MY_TYPE;
9179 MY_TYPE object;
9180
9181 Later parts of the compiler might only know that `object' was of
9182 type `struct S' if it were not for code just below. With this
9183 code however, later parts of the compiler see something like:
9184
9185 struct S' == struct S
9186 typedef struct S' MY_TYPE;
9187 struct S' object;
9188
9189 And they can then deduce (from the node for type struct S') that
9190 the original object declaration was:
9191
9192 MY_TYPE object;
9193
9194 Being able to do this is important for proper support of protoize,
9195 and also for generating precise symbolic debugging information
9196 which takes full account of the programmer's (typedef) vocabulary.
9197
9198 Obviously, we don't want to generate a duplicate ..._TYPE node if
9199 the TYPE_DECL node that we are now processing really represents a
9200 standard built-in type. */
9201
9202void
9203set_underlying_type (tree x)
9204{
9205 if (x == error_mark_node)
9206 return;
9207 if (DECL_IS_BUILTIN (x))
9208 {
9209 if (TYPE_NAME (TREE_TYPE (x)) == 0)
9210 TYPE_NAME (TREE_TYPE (x)) = x;
9211 }
9212 else if (TREE_TYPE (x) != error_mark_node
9213 && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9214 {
9215 tree tt = TREE_TYPE (x);
9216 DECL_ORIGINAL_TYPE (x) = tt;
9217 tt = build_variant_type_copy (tt);
9218 TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9219 TYPE_NAME (tt) = x;
9220 TREE_USED (tt) = TREE_USED (x);
9221 TREE_TYPE (x) = tt;
9222 }
9223}
9224
b646ba3f
DS		 9225/* Record the types used by the current global variable declaration
9226 being parsed, so that we can decide later to emit their debug info.
9227 Those types are in types_used_by_cur_var_decl, and we are going to
9228 store them in the types_used_by_vars_hash hash table.
9229 DECL is the declaration of the global variable that has been parsed. */
9230
9231void
9232record_types_used_by_current_var_decl (tree decl)
9233{
9234 gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9235
bc87224e 9236 while (!VEC_empty (tree, types_used_by_cur_var_decl))
b646ba3f 9237 {
bc87224e
NF		 9238 tree type = VEC_pop (tree, types_used_by_cur_var_decl);
9239 types_used_by_var_decl_insert (type, decl);
b646ba3f
DS		 9240 }
9241}
9242
c166b898
ILT		 9243/* The C and C++ parsers both use vectors to hold function arguments.
9244 For efficiency, we keep a cache of unused vectors. This is the
9245 cache. */
9246
9247typedef VEC(tree,gc)* tree_gc_vec;
9248DEF_VEC_P(tree_gc_vec);
9249DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9250static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9251
9252/* Return a new vector from the cache. If the cache is empty,
9253 allocate a new vector. These vectors are GC'ed, so it is OK if the
9254 pointer is not released.. */
9255
9256VEC(tree,gc) *
9257make_tree_vector (void)
9258{
9259 if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9260 return VEC_pop (tree_gc_vec, tree_vector_cache);
9261 else
9262 {
9263 /* Passing 0 to VEC_alloc returns NULL, and our callers require
9264 that we always return a non-NULL value. The vector code uses
9265 4 when growing a NULL vector, so we do too. */
9266 return VEC_alloc (tree, gc, 4);
9267 }
9268}
9269
9270/* Release a vector of trees back to the cache. */
9271
9272void
9273release_tree_vector (VEC(tree,gc) *vec)
9274{
9275 if (vec != NULL)
9276 {
9277 VEC_truncate (tree, vec, 0);
9278 VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9279 }
9280}
9281
9282/* Get a new tree vector holding a single tree. */
9283
9284VEC(tree,gc) *
9285make_tree_vector_single (tree t)
9286{
9287 VEC(tree,gc) *ret = make_tree_vector ();
9288 VEC_quick_push (tree, ret, t);
9289 return ret;
9290}
9291
9292/* Get a new tree vector which is a copy of an existing one. */
9293
9294VEC(tree,gc) *
9295make_tree_vector_copy (const VEC(tree,gc) *orig)
9296{
9297 VEC(tree,gc) *ret;
9298 unsigned int ix;
9299 tree t;
9300
9301 ret = make_tree_vector ();
9302 VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
9303 for (ix = 0; VEC_iterate (tree, orig, ix, t); ++ix)
9304 VEC_quick_push (tree, ret, t);
9305 return ret;
9306}
9307
39dabefd 9308#include "gt-c-family-c-common.h"
Mirror of https://gcc.gnu.org/git/gcc.git