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