OSDN Git Service

PR c/46547
[pf3gnuchains/gcc-fork.git] / gcc / c-family / c-common.c
1 /* Subroutines shared by all languages that are variants of C.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "intl.h"
27 #include "tree.h"
28 #include "flags.h"
29 #include "output.h"
30 #include "c-pragma.h"
31 #include "ggc.h"
32 #include "c-common.h"
33 #include "tm_p.h"
34 #include "obstack.h"
35 #include "cpplib.h"
36 #include "target.h"
37 #include "langhooks.h"
38 #include "tree-inline.h"
39 #include "toplev.h"
40 #include "diagnostic.h"
41 #include "tree-iterator.h"
42 #include "hashtab.h"
43 #include "tree-mudflap.h"
44 #include "opts.h"
45 #include "cgraph.h"
46 #include "target-def.h"
47 #include "libfuncs.h"
48
49 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
50
51 /* The following symbols are subsumed in the c_global_trees array, and
52    listed here individually for documentation purposes.
53
54    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
55
56         tree short_integer_type_node;
57         tree long_integer_type_node;
58         tree long_long_integer_type_node;
59         tree int128_integer_type_node;
60
61         tree short_unsigned_type_node;
62         tree long_unsigned_type_node;
63         tree long_long_unsigned_type_node;
64         tree int128_unsigned_type_node;
65
66         tree truthvalue_type_node;
67         tree truthvalue_false_node;
68         tree truthvalue_true_node;
69
70         tree ptrdiff_type_node;
71
72         tree unsigned_char_type_node;
73         tree signed_char_type_node;
74         tree wchar_type_node;
75
76         tree char16_type_node;
77         tree char32_type_node;
78
79         tree float_type_node;
80         tree double_type_node;
81         tree long_double_type_node;
82
83         tree complex_integer_type_node;
84         tree complex_float_type_node;
85         tree complex_double_type_node;
86         tree complex_long_double_type_node;
87
88         tree dfloat32_type_node;
89         tree dfloat64_type_node;
90         tree_dfloat128_type_node;
91
92         tree intQI_type_node;
93         tree intHI_type_node;
94         tree intSI_type_node;
95         tree intDI_type_node;
96         tree intTI_type_node;
97
98         tree unsigned_intQI_type_node;
99         tree unsigned_intHI_type_node;
100         tree unsigned_intSI_type_node;
101         tree unsigned_intDI_type_node;
102         tree unsigned_intTI_type_node;
103
104         tree widest_integer_literal_type_node;
105         tree widest_unsigned_literal_type_node;
106
107    Nodes for types `void *' and `const void *'.
108
109         tree ptr_type_node, const_ptr_type_node;
110
111    Nodes for types `char *' and `const char *'.
112
113         tree string_type_node, const_string_type_node;
114
115    Type `char[SOMENUMBER]'.
116    Used when an array of char is needed and the size is irrelevant.
117
118         tree char_array_type_node;
119
120    Type `int[SOMENUMBER]' or something like it.
121    Used when an array of int needed and the size is irrelevant.
122
123         tree int_array_type_node;
124
125    Type `wchar_t[SOMENUMBER]' or something like it.
126    Used when a wide string literal is created.
127
128         tree wchar_array_type_node;
129
130    Type `char16_t[SOMENUMBER]' or something like it.
131    Used when a UTF-16 string literal is created.
132
133         tree char16_array_type_node;
134
135    Type `char32_t[SOMENUMBER]' or something like it.
136    Used when a UTF-32 string literal is created.
137
138         tree char32_array_type_node;
139
140    Type `int ()' -- used for implicit declaration of functions.
141
142         tree default_function_type;
143
144    A VOID_TYPE node, packaged in a TREE_LIST.
145
146         tree void_list_node;
147
148   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
149   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
150   VAR_DECLS, but C++ does.)
151
152         tree function_name_decl_node;
153         tree pretty_function_name_decl_node;
154         tree c99_function_name_decl_node;
155
156   Stack of nested function name VAR_DECLs.
157
158         tree saved_function_name_decls;
159
160 */
161
162 tree c_global_trees[CTI_MAX];
163 \f
164 /* Switches common to the C front ends.  */
165
166 /* Nonzero means don't output line number information.  */
167
168 char flag_no_line_commands;
169
170 /* Nonzero causes -E output not to be done, but directives such as
171    #define that have side effects are still obeyed.  */
172
173 char flag_no_output;
174
175 /* Nonzero means dump macros in some fashion.  */
176
177 char flag_dump_macros;
178
179 /* Nonzero means pass #include lines through to the output.  */
180
181 char flag_dump_includes;
182
183 /* Nonzero means process PCH files while preprocessing.  */
184
185 bool flag_pch_preprocess;
186
187 /* The file name to which we should write a precompiled header, or
188    NULL if no header will be written in this compile.  */
189
190 const char *pch_file;
191
192 /* Nonzero if an ISO standard was selected.  It rejects macros in the
193    user's namespace.  */
194 int flag_iso;
195
196 /* Warn about #pragma directives that are not recognized.  */
197
198 int warn_unknown_pragmas; /* Tri state variable.  */
199
200 /* Warn about format/argument anomalies in calls to formatted I/O functions
201    (*printf, *scanf, strftime, strfmon, etc.).  */
202
203 int warn_format;
204
205 /* C/ObjC language option variables.  */
206
207
208 /* Nonzero means allow type mismatches in conditional expressions;
209    just make their values `void'.  */
210
211 int flag_cond_mismatch;
212
213 /* Nonzero means enable C89 Amendment 1 features.  */
214
215 int flag_isoc94;
216
217 /* Nonzero means use the ISO C99 (or C1X) dialect of C.  */
218
219 int flag_isoc99;
220
221 /* Nonzero means use the ISO C1X dialect of C.  */
222
223 int flag_isoc1x;
224
225 /* Nonzero means that we have builtin functions, and main is an int.  */
226
227 int flag_hosted = 1;
228
229
230 /* ObjC language option variables.  */
231
232
233 /* Tells the compiler that this is a special run.  Do not perform any
234    compiling, instead we are to test some platform dependent features
235    and output a C header file with appropriate definitions.  */
236
237 int print_struct_values;
238
239 /* Tells the compiler what is the constant string class for ObjC.  */
240
241 const char *constant_string_class_name;
242
243
244 /* C++ language option variables.  */
245
246
247 /* Nonzero means generate separate instantiation control files and
248    juggle them at link time.  */
249
250 int flag_use_repository;
251
252 /* The C++ dialect being used. C++98 is the default.  */
253
254 enum cxx_dialect cxx_dialect = cxx98;
255
256 /* Maximum template instantiation depth.  This limit exists to limit the
257    time it takes to notice infinite template instantiations; the default
258    value of 1024 is likely to be in the next C++ standard.  */
259
260 int max_tinst_depth = 1024;
261
262
263
264 /* The elements of `ridpointers' are identifier nodes for the reserved
265    type names and storage classes.  It is indexed by a RID_... value.  */
266 tree *ridpointers;
267
268 tree (*make_fname_decl) (location_t, tree, int);
269
270 /* Nonzero means don't warn about problems that occur when the code is
271    executed.  */
272 int c_inhibit_evaluation_warnings;
273
274 /* Whether we are building a boolean conversion inside
275    convert_for_assignment, or some other late binary operation.  If
276    build_binary_op is called for C (from code shared by C and C++) in
277    this case, then the operands have already been folded and the
278    result will not be folded again, so C_MAYBE_CONST_EXPR should not
279    be generated.  */
280 bool in_late_binary_op;
281
282 /* Whether lexing has been completed, so subsequent preprocessor
283    errors should use the compiler's input_location.  */
284 bool done_lexing = false;
285
286 /* Information about how a function name is generated.  */
287 struct fname_var_t
288 {
289   tree *const decl;     /* pointer to the VAR_DECL.  */
290   const unsigned rid;   /* RID number for the identifier.  */
291   const int pretty;     /* How pretty is it? */
292 };
293
294 /* The three ways of getting then name of the current function.  */
295
296 const struct fname_var_t fname_vars[] =
297 {
298   /* C99 compliant __func__, must be first.  */
299   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
300   /* GCC __FUNCTION__ compliant.  */
301   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
302   /* GCC __PRETTY_FUNCTION__ compliant.  */
303   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
304   {NULL, 0, 0},
305 };
306
307 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
308 static tree check_case_value (tree);
309 static bool check_case_bounds (tree, tree, tree *, tree *);
310
311 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
312 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
313 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
314 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
315 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
316 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
317 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
318 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
319 static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
320 static tree handle_always_inline_attribute (tree *, tree, tree, int,
321                                             bool *);
322 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
323 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
324 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
325 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
326 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
327 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
328 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
329                                                  bool *);
330 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
331 static tree handle_transparent_union_attribute (tree *, tree, tree,
332                                                 int, bool *);
333 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
334 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
335 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
336 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
337 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
338 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
339 static tree handle_alias_ifunc_attribute (bool, tree *, tree, tree, bool *);
340 static tree handle_ifunc_attribute (tree *, tree, tree, int, bool *);
341 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
342 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
343 static tree handle_visibility_attribute (tree *, tree, tree, int,
344                                          bool *);
345 static tree handle_tls_model_attribute (tree *, tree, tree, int,
346                                         bool *);
347 static tree handle_no_instrument_function_attribute (tree *, tree,
348                                                      tree, int, bool *);
349 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
350 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
351 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
352                                              bool *);
353 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
354 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
355 static tree handle_deprecated_attribute (tree *, tree, tree, int,
356                                          bool *);
357 static tree handle_vector_size_attribute (tree *, tree, tree, int,
358                                           bool *);
359 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
360 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
361 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
362 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
363                                                  bool *);
364 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
365 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
366 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
367 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
368 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
369 static tree handle_no_split_stack_attribute (tree *, tree, tree, int, bool *);
370 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
371
372 static void check_function_nonnull (tree, int, tree *);
373 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
374 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
375 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
376 static int resort_field_decl_cmp (const void *, const void *);
377
378 /* Reserved words.  The third field is a mask: keywords are disabled
379    if they match the mask.
380
381    Masks for languages:
382    C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
383    C --std=c99: D_CXXONLY | D_OBJC
384    ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
385    C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
386    C++ --std=c0x: D_CONLY | D_OBJC
387    ObjC++ is like C++ except that D_OBJC is not set
388
389    If -fno-asm is used, D_ASM is added to the mask.  If
390    -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in
391    C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
392    In C with -Wc++-compat, we warn if D_CXXWARN is set.
393
394    Note the complication of the D_CXX_OBJC keywords.  These are
395    reserved words such as 'class'.  In C++, 'class' is a reserved
396    word.  In Objective-C++ it is too.  In Objective-C, it is a
397    reserved word too, but only if it follows an '@' sign.
398 */
399 const struct c_common_resword c_common_reswords[] =
400 {
401   { "_Bool",            RID_BOOL,      D_CONLY },
402   { "_Complex",         RID_COMPLEX,    0 },
403   { "_Imaginary",       RID_IMAGINARY, D_CONLY },
404   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
405   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
406   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
407   { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
408   { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
409   { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
410   { "_Static_assert",   RID_STATIC_ASSERT, D_CONLY },
411   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
412   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
413   { "__alignof",        RID_ALIGNOF,    0 },
414   { "__alignof__",      RID_ALIGNOF,    0 },
415   { "__asm",            RID_ASM,        0 },
416   { "__asm__",          RID_ASM,        0 },
417   { "__attribute",      RID_ATTRIBUTE,  0 },
418   { "__attribute__",    RID_ATTRIBUTE,  0 },
419   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
420   { "__builtin_offsetof", RID_OFFSETOF, 0 },
421   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
422   { "__builtin_va_arg", RID_VA_ARG,     0 },
423   { "__complex",        RID_COMPLEX,    0 },
424   { "__complex__",      RID_COMPLEX,    0 },
425   { "__const",          RID_CONST,      0 },
426   { "__const__",        RID_CONST,      0 },
427   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
428   { "__extension__",    RID_EXTENSION,  0 },
429   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
430   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
431   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
432   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
433   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
434   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
435   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
436   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
437   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
438   { "__int128",         RID_INT128,     0 },
439   { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },
440   { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },
441   { "__is_class",       RID_IS_CLASS,   D_CXXONLY },
442   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
443   { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },
444   { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },
445   { "__is_pod",         RID_IS_POD,     D_CXXONLY },
446   { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
447   { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
448   { "__is_trivial",     RID_IS_TRIVIAL, D_CXXONLY },
449   { "__is_union",       RID_IS_UNION,   D_CXXONLY },
450   { "__is_literal_type", RID_IS_LITERAL_TYPE, D_CXXONLY },
451   { "__imag",           RID_IMAGPART,   0 },
452   { "__imag__",         RID_IMAGPART,   0 },
453   { "__inline",         RID_INLINE,     0 },
454   { "__inline__",       RID_INLINE,     0 },
455   { "__label__",        RID_LABEL,      0 },
456   { "__null",           RID_NULL,       0 },
457   { "__real",           RID_REALPART,   0 },
458   { "__real__",         RID_REALPART,   0 },
459   { "__restrict",       RID_RESTRICT,   0 },
460   { "__restrict__",     RID_RESTRICT,   0 },
461   { "__signed",         RID_SIGNED,     0 },
462   { "__signed__",       RID_SIGNED,     0 },
463   { "__thread",         RID_THREAD,     0 },
464   { "__typeof",         RID_TYPEOF,     0 },
465   { "__typeof__",       RID_TYPEOF,     0 },
466   { "__volatile",       RID_VOLATILE,   0 },
467   { "__volatile__",     RID_VOLATILE,   0 },
468   { "alignof",          RID_ALIGNOF,    D_CXXONLY | D_CXX0X | D_CXXWARN },
469   { "asm",              RID_ASM,        D_ASM },
470   { "auto",             RID_AUTO,       0 },
471   { "bool",             RID_BOOL,       D_CXXONLY | D_CXXWARN },
472   { "break",            RID_BREAK,      0 },
473   { "case",             RID_CASE,       0 },
474   { "catch",            RID_CATCH,      D_CXX_OBJC | D_CXXWARN },
475   { "char",             RID_CHAR,       0 },
476   { "char16_t",         RID_CHAR16,     D_CXXONLY | D_CXX0X | D_CXXWARN },
477   { "char32_t",         RID_CHAR32,     D_CXXONLY | D_CXX0X | D_CXXWARN },
478   { "class",            RID_CLASS,      D_CXX_OBJC | D_CXXWARN },
479   { "const",            RID_CONST,      0 },
480   { "constexpr",        RID_CONSTEXPR,  D_CXXONLY | D_CXX0X | D_CXXWARN },
481   { "const_cast",       RID_CONSTCAST,  D_CXXONLY | D_CXXWARN },
482   { "continue",         RID_CONTINUE,   0 },
483   { "decltype",         RID_DECLTYPE,   D_CXXONLY | D_CXX0X | D_CXXWARN },
484   { "default",          RID_DEFAULT,    0 },
485   { "delete",           RID_DELETE,     D_CXXONLY | D_CXXWARN },
486   { "do",               RID_DO,         0 },
487   { "double",           RID_DOUBLE,     0 },
488   { "dynamic_cast",     RID_DYNCAST,    D_CXXONLY | D_CXXWARN },
489   { "else",             RID_ELSE,       0 },
490   { "enum",             RID_ENUM,       0 },
491   { "explicit",         RID_EXPLICIT,   D_CXXONLY | D_CXXWARN },
492   { "export",           RID_EXPORT,     D_CXXONLY | D_CXXWARN },
493   { "extern",           RID_EXTERN,     0 },
494   { "false",            RID_FALSE,      D_CXXONLY | D_CXXWARN },
495   { "float",            RID_FLOAT,      0 },
496   { "for",              RID_FOR,        0 },
497   { "friend",           RID_FRIEND,     D_CXXONLY | D_CXXWARN },
498   { "goto",             RID_GOTO,       0 },
499   { "if",               RID_IF,         0 },
500   { "inline",           RID_INLINE,     D_EXT89 },
501   { "int",              RID_INT,        0 },
502   { "long",             RID_LONG,       0 },
503   { "mutable",          RID_MUTABLE,    D_CXXONLY | D_CXXWARN },
504   { "namespace",        RID_NAMESPACE,  D_CXXONLY | D_CXXWARN },
505   { "new",              RID_NEW,        D_CXXONLY | D_CXXWARN },
506   { "noexcept",         RID_NOEXCEPT,   D_CXXONLY | D_CXX0X | D_CXXWARN },
507   { "nullptr",          RID_NULLPTR,    D_CXXONLY | D_CXX0X | D_CXXWARN },
508   { "operator",         RID_OPERATOR,   D_CXXONLY | D_CXXWARN },
509   { "private",          RID_PRIVATE,    D_CXX_OBJC | D_CXXWARN },
510   { "protected",        RID_PROTECTED,  D_CXX_OBJC | D_CXXWARN },
511   { "public",           RID_PUBLIC,     D_CXX_OBJC | D_CXXWARN },
512   { "register",         RID_REGISTER,   0 },
513   { "reinterpret_cast", RID_REINTCAST,  D_CXXONLY | D_CXXWARN },
514   { "restrict",         RID_RESTRICT,   D_CONLY | D_C99 },
515   { "return",           RID_RETURN,     0 },
516   { "short",            RID_SHORT,      0 },
517   { "signed",           RID_SIGNED,     0 },
518   { "sizeof",           RID_SIZEOF,     0 },
519   { "static",           RID_STATIC,     0 },
520   { "static_assert",    RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
521   { "static_cast",      RID_STATCAST,   D_CXXONLY | D_CXXWARN },
522   { "struct",           RID_STRUCT,     0 },
523   { "switch",           RID_SWITCH,     0 },
524   { "template",         RID_TEMPLATE,   D_CXXONLY | D_CXXWARN },
525   { "this",             RID_THIS,       D_CXXONLY | D_CXXWARN },
526   { "throw",            RID_THROW,      D_CXX_OBJC | D_CXXWARN },
527   { "true",             RID_TRUE,       D_CXXONLY | D_CXXWARN },
528   { "try",              RID_TRY,        D_CXX_OBJC | D_CXXWARN },
529   { "typedef",          RID_TYPEDEF,    0 },
530   { "typename",         RID_TYPENAME,   D_CXXONLY | D_CXXWARN },
531   { "typeid",           RID_TYPEID,     D_CXXONLY | D_CXXWARN },
532   { "typeof",           RID_TYPEOF,     D_ASM | D_EXT },
533   { "union",            RID_UNION,      0 },
534   { "unsigned",         RID_UNSIGNED,   0 },
535   { "using",            RID_USING,      D_CXXONLY | D_CXXWARN },
536   { "virtual",          RID_VIRTUAL,    D_CXXONLY | D_CXXWARN },
537   { "void",             RID_VOID,       0 },
538   { "volatile",         RID_VOLATILE,   0 },
539   { "wchar_t",          RID_WCHAR,      D_CXXONLY },
540   { "while",            RID_WHILE,      0 },
541   /* These Objective-C keywords are recognized only immediately after
542      an '@'.  */
543   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
544   { "defs",             RID_AT_DEFS,            D_OBJC },
545   { "encode",           RID_AT_ENCODE,          D_OBJC },
546   { "end",              RID_AT_END,             D_OBJC },
547   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
548   { "interface",        RID_AT_INTERFACE,       D_OBJC },
549   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
550   { "selector",         RID_AT_SELECTOR,        D_OBJC },
551   { "finally",          RID_AT_FINALLY,         D_OBJC },
552   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
553   { "optional",         RID_AT_OPTIONAL,        D_OBJC },
554   { "required",         RID_AT_REQUIRED,        D_OBJC },
555   { "property",         RID_AT_PROPERTY,        D_OBJC },
556   { "package",          RID_AT_PACKAGE,         D_OBJC },
557   { "synthesize",       RID_AT_SYNTHESIZE,      D_OBJC },
558   { "dynamic",          RID_AT_DYNAMIC,         D_OBJC },
559   /* These are recognized only in protocol-qualifier context
560      (see above) */
561   { "bycopy",           RID_BYCOPY,             D_OBJC },
562   { "byref",            RID_BYREF,              D_OBJC },
563   { "in",               RID_IN,                 D_OBJC },
564   { "inout",            RID_INOUT,              D_OBJC },
565   { "oneway",           RID_ONEWAY,             D_OBJC },
566   { "out",              RID_OUT,                D_OBJC },
567   /* These are recognized inside a property attribute list */
568   { "assign",           RID_ASSIGN,             D_OBJC }, 
569   { "copy",             RID_COPY,               D_OBJC }, 
570   { "getter",           RID_GETTER,             D_OBJC }, 
571   { "nonatomic",        RID_NONATOMIC,          D_OBJC }, 
572   { "readonly",         RID_READONLY,           D_OBJC }, 
573   { "readwrite",        RID_READWRITE,          D_OBJC }, 
574   { "retain",           RID_RETAIN,             D_OBJC }, 
575   { "setter",           RID_SETTER,             D_OBJC }, 
576 };
577
578 const unsigned int num_c_common_reswords =
579   sizeof c_common_reswords / sizeof (struct c_common_resword);
580
581 /* Table of machine-independent attributes common to all C-like languages.  */
582 const struct attribute_spec c_common_attribute_table[] =
583 {
584   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
585   { "packed",                 0, 0, false, false, false,
586                               handle_packed_attribute },
587   { "nocommon",               0, 0, true,  false, false,
588                               handle_nocommon_attribute },
589   { "common",                 0, 0, true,  false, false,
590                               handle_common_attribute },
591   /* FIXME: logically, noreturn attributes should be listed as
592      "false, true, true" and apply to function types.  But implementing this
593      would require all the places in the compiler that use TREE_THIS_VOLATILE
594      on a decl to identify non-returning functions to be located and fixed
595      to check the function type instead.  */
596   { "noreturn",               0, 0, true,  false, false,
597                               handle_noreturn_attribute },
598   { "volatile",               0, 0, true,  false, false,
599                               handle_noreturn_attribute },
600   { "noinline",               0, 0, true,  false, false,
601                               handle_noinline_attribute },
602   { "noclone",                0, 0, true,  false, false,
603                               handle_noclone_attribute },
604   { "leaf",                   0, 0, true,  false, false,
605                               handle_leaf_attribute },
606   { "always_inline",          0, 0, true,  false, false,
607                               handle_always_inline_attribute },
608   { "gnu_inline",             0, 0, true,  false, false,
609                               handle_gnu_inline_attribute },
610   { "artificial",             0, 0, true,  false, false,
611                               handle_artificial_attribute },
612   { "flatten",                0, 0, true,  false, false,
613                               handle_flatten_attribute },
614   { "used",                   0, 0, true,  false, false,
615                               handle_used_attribute },
616   { "unused",                 0, 0, false, false, false,
617                               handle_unused_attribute },
618   { "externally_visible",     0, 0, true,  false, false,
619                               handle_externally_visible_attribute },
620   /* The same comments as for noreturn attributes apply to const ones.  */
621   { "const",                  0, 0, true,  false, false,
622                               handle_const_attribute },
623   { "transparent_union",      0, 0, false, false, false,
624                               handle_transparent_union_attribute },
625   { "constructor",            0, 1, true,  false, false,
626                               handle_constructor_attribute },
627   { "destructor",             0, 1, true,  false, false,
628                               handle_destructor_attribute },
629   { "mode",                   1, 1, false,  true, false,
630                               handle_mode_attribute },
631   { "section",                1, 1, true,  false, false,
632                               handle_section_attribute },
633   { "aligned",                0, 1, false, false, false,
634                               handle_aligned_attribute },
635   { "weak",                   0, 0, true,  false, false,
636                               handle_weak_attribute },
637   { "ifunc",                  1, 1, true,  false, false,
638                               handle_ifunc_attribute },
639   { "alias",                  1, 1, true,  false, false,
640                               handle_alias_attribute },
641   { "weakref",                0, 1, true,  false, false,
642                               handle_weakref_attribute },
643   { "no_instrument_function", 0, 0, true,  false, false,
644                               handle_no_instrument_function_attribute },
645   { "malloc",                 0, 0, true,  false, false,
646                               handle_malloc_attribute },
647   { "returns_twice",          0, 0, true,  false, false,
648                               handle_returns_twice_attribute },
649   { "no_stack_limit",         0, 0, true,  false, false,
650                               handle_no_limit_stack_attribute },
651   { "pure",                   0, 0, true,  false, false,
652                               handle_pure_attribute },
653   /* For internal use (marking of builtins) only.  The name contains space
654      to prevent its usage in source code.  */
655   { "no vops",                0, 0, true,  false, false,
656                               handle_novops_attribute },
657   { "deprecated",             0, 1, false, false, false,
658                               handle_deprecated_attribute },
659   { "vector_size",            1, 1, false, true, false,
660                               handle_vector_size_attribute },
661   { "visibility",             1, 1, false, false, false,
662                               handle_visibility_attribute },
663   { "tls_model",              1, 1, true,  false, false,
664                               handle_tls_model_attribute },
665   { "nonnull",                0, -1, false, true, true,
666                               handle_nonnull_attribute },
667   { "nothrow",                0, 0, true,  false, false,
668                               handle_nothrow_attribute },
669   { "may_alias",              0, 0, false, true, false, NULL },
670   { "cleanup",                1, 1, true, false, false,
671                               handle_cleanup_attribute },
672   { "warn_unused_result",     0, 0, false, true, true,
673                               handle_warn_unused_result_attribute },
674   { "sentinel",               0, 1, false, true, true,
675                               handle_sentinel_attribute },
676   /* For internal use (marking of builtins) only.  The name contains space
677      to prevent its usage in source code.  */
678   { "type generic",           0, 0, false, true, true,
679                               handle_type_generic_attribute },
680   { "alloc_size",             1, 2, false, true, true,
681                               handle_alloc_size_attribute },
682   { "cold",                   0, 0, true,  false, false,
683                               handle_cold_attribute },
684   { "hot",                    0, 0, true,  false, false,
685                               handle_hot_attribute },
686   { "warning",                1, 1, true,  false, false,
687                               handle_error_attribute },
688   { "error",                  1, 1, true,  false, false,
689                               handle_error_attribute },
690   { "target",                 1, -1, true, false, false,
691                               handle_target_attribute },
692   { "optimize",               1, -1, true, false, false,
693                               handle_optimize_attribute },
694   { "no_split_stack",         0, 0, true,  false, false,
695                               handle_no_split_stack_attribute },
696   /* For internal use (marking of builtins and runtime functions) only.
697      The name contains space to prevent its usage in source code.  */
698   { "fn spec",                1, 1, false, true, true,
699                               handle_fnspec_attribute },
700   { NULL,                     0, 0, false, false, false, NULL }
701 };
702
703 /* Give the specifications for the format attributes, used by C and all
704    descendants.  */
705
706 const struct attribute_spec c_common_format_attribute_table[] =
707 {
708   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
709   { "format",                 3, 3, false, true,  true,
710                               handle_format_attribute },
711   { "format_arg",             1, 1, false, true,  true,
712                               handle_format_arg_attribute },
713   { NULL,                     0, 0, false, false, false, NULL }
714 };
715
716 /* Return identifier for address space AS.  */
717
718 const char *
719 c_addr_space_name (addr_space_t as)
720 {
721   int rid = RID_FIRST_ADDR_SPACE + as;
722   gcc_assert (ridpointers [rid]);
723   return IDENTIFIER_POINTER (ridpointers [rid]);
724 }
725
726 /* Push current bindings for the function name VAR_DECLS.  */
727
728 void
729 start_fname_decls (void)
730 {
731   unsigned ix;
732   tree saved = NULL_TREE;
733
734   for (ix = 0; fname_vars[ix].decl; ix++)
735     {
736       tree decl = *fname_vars[ix].decl;
737
738       if (decl)
739         {
740           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
741           *fname_vars[ix].decl = NULL_TREE;
742         }
743     }
744   if (saved || saved_function_name_decls)
745     /* Normally they'll have been NULL, so only push if we've got a
746        stack, or they are non-NULL.  */
747     saved_function_name_decls = tree_cons (saved, NULL_TREE,
748                                            saved_function_name_decls);
749 }
750
751 /* Finish up the current bindings, adding them into the current function's
752    statement tree.  This must be done _before_ finish_stmt_tree is called.
753    If there is no current function, we must be at file scope and no statements
754    are involved. Pop the previous bindings.  */
755
756 void
757 finish_fname_decls (void)
758 {
759   unsigned ix;
760   tree stmts = NULL_TREE;
761   tree stack = saved_function_name_decls;
762
763   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
764     append_to_statement_list (TREE_VALUE (stack), &stmts);
765
766   if (stmts)
767     {
768       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
769
770       if (TREE_CODE (*bodyp) == BIND_EXPR)
771         bodyp = &BIND_EXPR_BODY (*bodyp);
772
773       append_to_statement_list_force (*bodyp, &stmts);
774       *bodyp = stmts;
775     }
776
777   for (ix = 0; fname_vars[ix].decl; ix++)
778     *fname_vars[ix].decl = NULL_TREE;
779
780   if (stack)
781     {
782       /* We had saved values, restore them.  */
783       tree saved;
784
785       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
786         {
787           tree decl = TREE_PURPOSE (saved);
788           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
789
790           *fname_vars[ix].decl = decl;
791         }
792       stack = TREE_CHAIN (stack);
793     }
794   saved_function_name_decls = stack;
795 }
796
797 /* Return the text name of the current function, suitably prettified
798    by PRETTY_P.  Return string must be freed by caller.  */
799
800 const char *
801 fname_as_string (int pretty_p)
802 {
803   const char *name = "top level";
804   char *namep;
805   int vrb = 2, len;
806   cpp_string cstr = { 0, 0 }, strname;
807
808   if (!pretty_p)
809     {
810       name = "";
811       vrb = 0;
812     }
813
814   if (current_function_decl)
815     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
816
817   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
818
819   namep = XNEWVEC (char, len);
820   snprintf (namep, len, "\"%s\"", name);
821   strname.text = (unsigned char *) namep;
822   strname.len = len - 1;
823
824   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
825     {
826       XDELETEVEC (namep);
827       return (const char *) cstr.text;
828     }
829
830   return namep;
831 }
832
833 /* Return the VAR_DECL for a const char array naming the current
834    function. If the VAR_DECL has not yet been created, create it
835    now. RID indicates how it should be formatted and IDENTIFIER_NODE
836    ID is its name (unfortunately C and C++ hold the RID values of
837    keywords in different places, so we can't derive RID from ID in
838    this language independent code. LOC is the location of the
839    function.  */
840
841 tree
842 fname_decl (location_t loc, unsigned int rid, tree id)
843 {
844   unsigned ix;
845   tree decl = NULL_TREE;
846
847   for (ix = 0; fname_vars[ix].decl; ix++)
848     if (fname_vars[ix].rid == rid)
849       break;
850
851   decl = *fname_vars[ix].decl;
852   if (!decl)
853     {
854       /* If a tree is built here, it would normally have the lineno of
855          the current statement.  Later this tree will be moved to the
856          beginning of the function and this line number will be wrong.
857          To avoid this problem set the lineno to 0 here; that prevents
858          it from appearing in the RTL.  */
859       tree stmts;
860       location_t saved_location = input_location;
861       input_location = UNKNOWN_LOCATION;
862
863       stmts = push_stmt_list ();
864       decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
865       stmts = pop_stmt_list (stmts);
866       if (!IS_EMPTY_STMT (stmts))
867         saved_function_name_decls
868           = tree_cons (decl, stmts, saved_function_name_decls);
869       *fname_vars[ix].decl = decl;
870       input_location = saved_location;
871     }
872   if (!ix && !current_function_decl)
873     pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
874
875   return decl;
876 }
877
878 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
879
880 tree
881 fix_string_type (tree value)
882 {
883   int length = TREE_STRING_LENGTH (value);
884   int nchars;
885   tree e_type, i_type, a_type;
886
887   /* Compute the number of elements, for the array type.  */
888   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
889     {
890       nchars = length;
891       e_type = char_type_node;
892     }
893   else if (TREE_TYPE (value) == char16_array_type_node)
894     {
895       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
896       e_type = char16_type_node;
897     }
898   else if (TREE_TYPE (value) == char32_array_type_node)
899     {
900       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
901       e_type = char32_type_node;
902     }
903   else
904     {
905       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
906       e_type = wchar_type_node;
907     }
908
909   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
910      limit in C++98 Annex B is very large (65536) and is not normative,
911      so we do not diagnose it (warn_overlength_strings is forced off
912      in c_common_post_options).  */
913   if (warn_overlength_strings)
914     {
915       const int nchars_max = flag_isoc99 ? 4095 : 509;
916       const int relevant_std = flag_isoc99 ? 99 : 90;
917       if (nchars - 1 > nchars_max)
918         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
919            separate the %d from the 'C'.  'ISO' should not be
920            translated, but it may be moved after 'C%d' in languages
921            where modifiers follow nouns.  */
922         pedwarn (input_location, OPT_Woverlength_strings,
923                  "string length %qd is greater than the length %qd "
924                  "ISO C%d compilers are required to support",
925                  nchars - 1, nchars_max, relevant_std);
926     }
927
928   /* Create the array type for the string constant.  The ISO C++
929      standard says that a string literal has type `const char[N]' or
930      `const wchar_t[N]'.  We use the same logic when invoked as a C
931      front-end with -Wwrite-strings.
932      ??? We should change the type of an expression depending on the
933      state of a warning flag.  We should just be warning -- see how
934      this is handled in the C++ front-end for the deprecated implicit
935      conversion from string literals to `char*' or `wchar_t*'.
936
937      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
938      array type being the unqualified version of that type.
939      Therefore, if we are constructing an array of const char, we must
940      construct the matching unqualified array type first.  The C front
941      end does not require this, but it does no harm, so we do it
942      unconditionally.  */
943   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
944   a_type = build_array_type (e_type, i_type);
945   if (c_dialect_cxx() || warn_write_strings)
946     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
947
948   TREE_TYPE (value) = a_type;
949   TREE_CONSTANT (value) = 1;
950   TREE_READONLY (value) = 1;
951   TREE_STATIC (value) = 1;
952   return value;
953 }
954 \f
955 /* Fully fold EXPR, an expression that was not folded (beyond integer
956    constant expressions and null pointer constants) when being built
957    up.  If IN_INIT, this is in a static initializer and certain
958    changes are made to the folding done.  Clear *MAYBE_CONST if
959    MAYBE_CONST is not NULL and EXPR is definitely not a constant
960    expression because it contains an evaluated operator (in C99) or an
961    operator outside of sizeof returning an integer constant (in C90)
962    not permitted in constant expressions, or because it contains an
963    evaluated arithmetic overflow.  (*MAYBE_CONST should typically be
964    set to true by callers before calling this function.)  Return the
965    folded expression.  Function arguments have already been folded
966    before calling this function, as have the contents of SAVE_EXPR,
967    TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
968    C_MAYBE_CONST_EXPR.  */
969
970 tree
971 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
972 {
973   tree ret;
974   tree eptype = NULL_TREE;
975   bool dummy = true;
976   bool maybe_const_itself = true;
977   location_t loc = EXPR_LOCATION (expr);
978
979   /* This function is not relevant to C++ because C++ folds while
980      parsing, and may need changes to be correct for C++ when C++
981      stops folding while parsing.  */
982   if (c_dialect_cxx ())
983     gcc_unreachable ();
984
985   if (!maybe_const)
986     maybe_const = &dummy;
987   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
988     {
989       eptype = TREE_TYPE (expr);
990       expr = TREE_OPERAND (expr, 0);
991     }
992   ret = c_fully_fold_internal (expr, in_init, maybe_const,
993                                &maybe_const_itself);
994   if (eptype)
995     ret = fold_convert_loc (loc, eptype, ret);
996   *maybe_const &= maybe_const_itself;
997   return ret;
998 }
999
1000 /* Internal helper for c_fully_fold.  EXPR and IN_INIT are as for
1001    c_fully_fold.  *MAYBE_CONST_OPERANDS is cleared because of operands
1002    not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1003    arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1004    both evaluated and unevaluated subexpressions while
1005    *MAYBE_CONST_ITSELF is carried from only evaluated
1006    subexpressions).  */
1007
1008 static tree
1009 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1010                        bool *maybe_const_itself)
1011 {
1012   tree ret = expr;
1013   enum tree_code code = TREE_CODE (expr);
1014   enum tree_code_class kind = TREE_CODE_CLASS (code);
1015   location_t loc = EXPR_LOCATION (expr);
1016   tree op0, op1, op2, op3;
1017   tree orig_op0, orig_op1, orig_op2;
1018   bool op0_const = true, op1_const = true, op2_const = true;
1019   bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1020   bool nowarning = TREE_NO_WARNING (expr);
1021   int unused_p;
1022
1023   /* This function is not relevant to C++ because C++ folds while
1024      parsing, and may need changes to be correct for C++ when C++
1025      stops folding while parsing.  */
1026   if (c_dialect_cxx ())
1027     gcc_unreachable ();
1028
1029   /* Constants, declarations, statements, errors, SAVE_EXPRs and
1030      anything else not counted as an expression cannot usefully be
1031      folded further at this point.  */
1032   if (!IS_EXPR_CODE_CLASS (kind)
1033       || kind == tcc_statement
1034       || code == SAVE_EXPR)
1035     return expr;
1036
1037   /* Operands of variable-length expressions (function calls) have
1038      already been folded, as have __builtin_* function calls, and such
1039      expressions cannot occur in constant expressions.  */
1040   if (kind == tcc_vl_exp)
1041     {
1042       *maybe_const_operands = false;
1043       ret = fold (expr);
1044       goto out;
1045     }
1046
1047   if (code == C_MAYBE_CONST_EXPR)
1048     {
1049       tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1050       tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1051       if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1052         *maybe_const_operands = false;
1053       if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1054         *maybe_const_itself = false;
1055       if (pre && !in_init)
1056         ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1057       else
1058         ret = inner;
1059       goto out;
1060     }
1061
1062   /* Assignment, increment, decrement, function call and comma
1063      operators, and statement expressions, cannot occur in constant
1064      expressions if evaluated / outside of sizeof.  (Function calls
1065      were handled above, though VA_ARG_EXPR is treated like a function
1066      call here, and statement expressions are handled through
1067      C_MAYBE_CONST_EXPR to avoid folding inside them.)  */
1068   switch (code)
1069     {
1070     case MODIFY_EXPR:
1071     case PREDECREMENT_EXPR:
1072     case PREINCREMENT_EXPR:
1073     case POSTDECREMENT_EXPR:
1074     case POSTINCREMENT_EXPR:
1075     case COMPOUND_EXPR:
1076       *maybe_const_operands = false;
1077       break;
1078
1079     case VA_ARG_EXPR:
1080     case TARGET_EXPR:
1081     case BIND_EXPR:
1082     case OBJ_TYPE_REF:
1083       *maybe_const_operands = false;
1084       ret = fold (expr);
1085       goto out;
1086
1087     default:
1088       break;
1089     }
1090
1091   /* Fold individual tree codes as appropriate.  */
1092   switch (code)
1093     {
1094     case COMPOUND_LITERAL_EXPR:
1095       /* Any non-constancy will have been marked in a containing
1096          C_MAYBE_CONST_EXPR; there is no more folding to do here.  */
1097       goto out;
1098
1099     case COMPONENT_REF:
1100       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1101       op1 = TREE_OPERAND (expr, 1);
1102       op2 = TREE_OPERAND (expr, 2);
1103       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1104                                    maybe_const_itself);
1105       STRIP_TYPE_NOPS (op0);
1106       if (op0 != orig_op0)
1107         ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1108       if (ret != expr)
1109         {
1110           TREE_READONLY (ret) = TREE_READONLY (expr);
1111           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1112         }
1113       goto out;
1114
1115     case ARRAY_REF:
1116       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1117       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1118       op2 = TREE_OPERAND (expr, 2);
1119       op3 = TREE_OPERAND (expr, 3);
1120       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1121                                    maybe_const_itself);
1122       STRIP_TYPE_NOPS (op0);
1123       op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1124                                    maybe_const_itself);
1125       STRIP_TYPE_NOPS (op1);
1126       op1 = decl_constant_value_for_optimization (op1);
1127       if (op0 != orig_op0 || op1 != orig_op1)
1128         ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1129       if (ret != expr)
1130         {
1131           TREE_READONLY (ret) = TREE_READONLY (expr);
1132           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1133           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1134         }
1135       ret = fold (ret);
1136       goto out;
1137
1138     case COMPOUND_EXPR:
1139     case MODIFY_EXPR:
1140     case PREDECREMENT_EXPR:
1141     case PREINCREMENT_EXPR:
1142     case POSTDECREMENT_EXPR:
1143     case POSTINCREMENT_EXPR:
1144     case PLUS_EXPR:
1145     case MINUS_EXPR:
1146     case MULT_EXPR:
1147     case POINTER_PLUS_EXPR:
1148     case TRUNC_DIV_EXPR:
1149     case CEIL_DIV_EXPR:
1150     case FLOOR_DIV_EXPR:
1151     case TRUNC_MOD_EXPR:
1152     case RDIV_EXPR:
1153     case EXACT_DIV_EXPR:
1154     case LSHIFT_EXPR:
1155     case RSHIFT_EXPR:
1156     case BIT_IOR_EXPR:
1157     case BIT_XOR_EXPR:
1158     case BIT_AND_EXPR:
1159     case LT_EXPR:
1160     case LE_EXPR:
1161     case GT_EXPR:
1162     case GE_EXPR:
1163     case EQ_EXPR:
1164     case NE_EXPR:
1165     case COMPLEX_EXPR:
1166     case TRUTH_AND_EXPR:
1167     case TRUTH_OR_EXPR:
1168     case TRUTH_XOR_EXPR:
1169     case UNORDERED_EXPR:
1170     case ORDERED_EXPR:
1171     case UNLT_EXPR:
1172     case UNLE_EXPR:
1173     case UNGT_EXPR:
1174     case UNGE_EXPR:
1175     case UNEQ_EXPR:
1176       /* Binary operations evaluating both arguments (increment and
1177          decrement are binary internally in GCC).  */
1178       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1179       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1180       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1181                                    maybe_const_itself);
1182       STRIP_TYPE_NOPS (op0);
1183       if (code != MODIFY_EXPR
1184           && code != PREDECREMENT_EXPR
1185           && code != PREINCREMENT_EXPR
1186           && code != POSTDECREMENT_EXPR
1187           && code != POSTINCREMENT_EXPR)
1188         op0 = decl_constant_value_for_optimization (op0);
1189       /* The RHS of a MODIFY_EXPR was fully folded when building that
1190          expression for the sake of conversion warnings.  */
1191       if (code != MODIFY_EXPR)
1192         op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1193                                      maybe_const_itself);
1194       STRIP_TYPE_NOPS (op1);
1195       op1 = decl_constant_value_for_optimization (op1);
1196       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1197         ret = in_init
1198           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1199           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1200       else
1201         ret = fold (expr);
1202       if (TREE_OVERFLOW_P (ret)
1203           && !TREE_OVERFLOW_P (op0)
1204           && !TREE_OVERFLOW_P (op1))
1205         overflow_warning (EXPR_LOCATION (expr), ret);
1206       goto out;
1207
1208     case INDIRECT_REF:
1209     case FIX_TRUNC_EXPR:
1210     case FLOAT_EXPR:
1211     CASE_CONVERT:
1212     case NON_LVALUE_EXPR:
1213     case NEGATE_EXPR:
1214     case BIT_NOT_EXPR:
1215     case TRUTH_NOT_EXPR:
1216     case ADDR_EXPR:
1217     case CONJ_EXPR:
1218     case REALPART_EXPR:
1219     case IMAGPART_EXPR:
1220       /* Unary operations.  */
1221       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1222       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1223                                    maybe_const_itself);
1224       STRIP_TYPE_NOPS (op0);
1225       if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1226         op0 = decl_constant_value_for_optimization (op0);
1227       if (op0 != orig_op0 || in_init)
1228         ret = in_init
1229           ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1230           : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
1231       else
1232         ret = fold (expr);
1233       if (code == INDIRECT_REF
1234           && ret != expr
1235           && TREE_CODE (ret) == INDIRECT_REF)
1236         {
1237           TREE_READONLY (ret) = TREE_READONLY (expr);
1238           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1239           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1240         }
1241       switch (code)
1242         {
1243         case FIX_TRUNC_EXPR:
1244         case FLOAT_EXPR:
1245         CASE_CONVERT:
1246           /* Don't warn about explicit conversions.  We will already
1247              have warned about suspect implicit conversions.  */
1248           break;
1249
1250         default:
1251           if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1252             overflow_warning (EXPR_LOCATION (expr), ret);
1253           break;
1254         }
1255       goto out;
1256
1257     case TRUTH_ANDIF_EXPR:
1258     case TRUTH_ORIF_EXPR:
1259       /* Binary operations not necessarily evaluating both
1260          arguments.  */
1261       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1262       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1263       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1264       STRIP_TYPE_NOPS (op0);
1265
1266       unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1267                           ? truthvalue_false_node
1268                           : truthvalue_true_node));
1269       c_inhibit_evaluation_warnings += unused_p;
1270       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1271       STRIP_TYPE_NOPS (op1);
1272       c_inhibit_evaluation_warnings -= unused_p;
1273
1274       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1275         ret = in_init
1276           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1277           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1278       else
1279         ret = fold (expr);
1280       *maybe_const_operands &= op0_const;
1281       *maybe_const_itself &= op0_const_self;
1282       if (!(flag_isoc99
1283             && op0_const
1284             && op0_const_self
1285             && (code == TRUTH_ANDIF_EXPR
1286                 ? op0 == truthvalue_false_node
1287                 : op0 == truthvalue_true_node)))
1288         *maybe_const_operands &= op1_const;
1289       if (!(op0_const
1290             && op0_const_self
1291             && (code == TRUTH_ANDIF_EXPR
1292                 ? op0 == truthvalue_false_node
1293                 : op0 == truthvalue_true_node)))
1294         *maybe_const_itself &= op1_const_self;
1295       goto out;
1296
1297     case COND_EXPR:
1298       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1299       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1300       orig_op2 = op2 = TREE_OPERAND (expr, 2);
1301       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1302
1303       STRIP_TYPE_NOPS (op0);
1304       c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
1305       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1306       STRIP_TYPE_NOPS (op1);
1307       c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1308
1309       c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
1310       op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1311       STRIP_TYPE_NOPS (op2);
1312       c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1313
1314       if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1315         ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
1316       else
1317         ret = fold (expr);
1318       *maybe_const_operands &= op0_const;
1319       *maybe_const_itself &= op0_const_self;
1320       if (!(flag_isoc99
1321             && op0_const
1322             && op0_const_self
1323             && op0 == truthvalue_false_node))
1324         *maybe_const_operands &= op1_const;
1325       if (!(op0_const
1326             && op0_const_self
1327             && op0 == truthvalue_false_node))
1328         *maybe_const_itself &= op1_const_self;
1329       if (!(flag_isoc99
1330             && op0_const
1331             && op0_const_self
1332             && op0 == truthvalue_true_node))
1333         *maybe_const_operands &= op2_const;
1334       if (!(op0_const
1335             && op0_const_self
1336             && op0 == truthvalue_true_node))
1337         *maybe_const_itself &= op2_const_self;
1338       goto out;
1339
1340     case EXCESS_PRECISION_EXPR:
1341       /* Each case where an operand with excess precision may be
1342          encountered must remove the EXCESS_PRECISION_EXPR around
1343          inner operands and possibly put one around the whole
1344          expression or possibly convert to the semantic type (which
1345          c_fully_fold does); we cannot tell at this stage which is
1346          appropriate in any particular case.  */
1347       gcc_unreachable ();
1348
1349     default:
1350       /* Various codes may appear through folding built-in functions
1351          and their arguments.  */
1352       goto out;
1353     }
1354
1355  out:
1356   /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1357      have been done by this point, so remove them again.  */
1358   nowarning |= TREE_NO_WARNING (ret);
1359   STRIP_TYPE_NOPS (ret);
1360   if (nowarning && !TREE_NO_WARNING (ret))
1361     {
1362       if (!CAN_HAVE_LOCATION_P (ret))
1363         ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1364       TREE_NO_WARNING (ret) = 1;
1365     }
1366   if (ret != expr)
1367     protected_set_expr_location (ret, loc);
1368   return ret;
1369 }
1370
1371 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1372    return EXP.  Otherwise, return either EXP or its known constant
1373    value (if it has one), but return EXP if EXP has mode BLKmode.  ???
1374    Is the BLKmode test appropriate?  */
1375
1376 tree
1377 decl_constant_value_for_optimization (tree exp)
1378 {
1379   tree ret;
1380
1381   /* This function is only used by C, for c_fully_fold and other
1382      optimization, and may not be correct for C++.  */
1383   if (c_dialect_cxx ())
1384     gcc_unreachable ();
1385
1386   if (!optimize
1387       || TREE_CODE (exp) != VAR_DECL
1388       || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1389       || DECL_MODE (exp) == BLKmode)
1390     return exp;
1391
1392   ret = decl_constant_value (exp);
1393   /* Avoid unwanted tree sharing between the initializer and current
1394      function's body where the tree can be modified e.g. by the
1395      gimplifier.  */
1396   if (ret != exp && TREE_STATIC (exp))
1397     ret = unshare_expr (ret);
1398   return ret;
1399 }
1400
1401 /* Print a warning if a constant expression had overflow in folding.
1402    Invoke this function on every expression that the language
1403    requires to be a constant expression.
1404    Note the ANSI C standard says it is erroneous for a
1405    constant expression to overflow.  */
1406
1407 void
1408 constant_expression_warning (tree value)
1409 {
1410   if (warn_overflow && pedantic
1411       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1412           || TREE_CODE (value) == FIXED_CST
1413           || TREE_CODE (value) == VECTOR_CST
1414           || TREE_CODE (value) == COMPLEX_CST)
1415       && TREE_OVERFLOW (value))
1416     pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1417 }
1418
1419 /* The same as above but print an unconditional error.  */
1420 void
1421 constant_expression_error (tree value)
1422 {
1423   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1424        || TREE_CODE (value) == FIXED_CST
1425        || TREE_CODE (value) == VECTOR_CST
1426        || TREE_CODE (value) == COMPLEX_CST)
1427       && TREE_OVERFLOW (value))
1428     error ("overflow in constant expression");
1429 }
1430
1431 /* Print a warning if an expression had overflow in folding and its
1432    operands hadn't.
1433
1434    Invoke this function on every expression that
1435    (1) appears in the source code, and
1436    (2) is a constant expression that overflowed, and
1437    (3) is not already checked by convert_and_check;
1438    however, do not invoke this function on operands of explicit casts
1439    or when the expression is the result of an operator and any operand
1440    already overflowed.  */
1441
1442 void
1443 overflow_warning (location_t loc, tree value)
1444 {
1445   if (c_inhibit_evaluation_warnings != 0)
1446     return;
1447
1448   switch (TREE_CODE (value))
1449     {
1450     case INTEGER_CST:
1451       warning_at (loc, OPT_Woverflow, "integer overflow in expression");
1452       break;
1453
1454     case REAL_CST:
1455       warning_at (loc, OPT_Woverflow,
1456                   "floating point overflow in expression");
1457       break;
1458
1459     case FIXED_CST:
1460       warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
1461       break;
1462
1463     case VECTOR_CST:
1464       warning_at (loc, OPT_Woverflow, "vector overflow in expression");
1465       break;
1466
1467     case COMPLEX_CST:
1468       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1469         warning_at (loc, OPT_Woverflow,
1470                     "complex integer overflow in expression");
1471       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1472         warning_at (loc, OPT_Woverflow,
1473                     "complex floating point overflow in expression");
1474       break;
1475
1476     default:
1477       break;
1478     }
1479 }
1480
1481 /* Warn about uses of logical || / && operator in a context where it
1482    is likely that the bitwise equivalent was intended by the
1483    programmer.  We have seen an expression in which CODE is a binary
1484    operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1485    had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE.  */
1486 void
1487 warn_logical_operator (location_t location, enum tree_code code, tree type,
1488                        enum tree_code code_left, tree op_left,
1489                        enum tree_code ARG_UNUSED (code_right), tree op_right)
1490 {
1491   int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1492   int in0_p, in1_p, in_p;
1493   tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1494   bool strict_overflow_p = false;
1495
1496   if (code != TRUTH_ANDIF_EXPR
1497       && code != TRUTH_AND_EXPR
1498       && code != TRUTH_ORIF_EXPR
1499       && code != TRUTH_OR_EXPR)
1500     return;
1501
1502   /* Warn if &&/|| are being used in a context where it is
1503      likely that the bitwise equivalent was intended by the
1504      programmer. That is, an expression such as op && MASK
1505      where op should not be any boolean expression, nor a
1506      constant, and mask seems to be a non-boolean integer constant.  */
1507   if (!truth_value_p (code_left)
1508       && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1509       && !CONSTANT_CLASS_P (op_left)
1510       && !TREE_NO_WARNING (op_left)
1511       && TREE_CODE (op_right) == INTEGER_CST
1512       && !integer_zerop (op_right)
1513       && !integer_onep (op_right))
1514     {
1515       if (or_op)
1516         warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1517                     " applied to non-boolean constant");
1518       else
1519         warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1520                     " applied to non-boolean constant");
1521       TREE_NO_WARNING (op_left) = true;
1522       return;
1523     }
1524
1525   /* We do not warn for constants because they are typical of macro
1526      expansions that test for features.  */
1527   if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1528     return;
1529
1530   /* This warning only makes sense with logical operands.  */
1531   if (!(truth_value_p (TREE_CODE (op_left))
1532         || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1533       || !(truth_value_p (TREE_CODE (op_right))
1534            || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1535     return;
1536
1537   lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1538   rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1539
1540   if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1541     lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1542
1543   if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1544     rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
1545
1546   /* If this is an OR operation, invert both sides; we will invert
1547      again at the end.  */
1548   if (or_op)
1549     in0_p = !in0_p, in1_p = !in1_p;
1550
1551   /* If both expressions are the same, if we can merge the ranges, and we
1552      can build the range test, return it or it inverted.  */
1553   if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
1554       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1555                        in1_p, low1, high1)
1556       && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1557                                         type, lhs, in_p, low, high)))
1558     {
1559       if (TREE_CODE (tem) != INTEGER_CST)
1560         return;
1561
1562       if (or_op)
1563         warning_at (location, OPT_Wlogical_op,
1564                     "logical %<or%> "
1565                     "of collectively exhaustive tests is always true");
1566       else
1567         warning_at (location, OPT_Wlogical_op,
1568                     "logical %<and%> "
1569                     "of mutually exclusive tests is always false");
1570     }
1571 }
1572
1573
1574 /* Print a warning about casts that might indicate violation
1575    of strict aliasing rules if -Wstrict-aliasing is used and
1576    strict aliasing mode is in effect. OTYPE is the original
1577    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1578
1579 bool
1580 strict_aliasing_warning (tree otype, tree type, tree expr)
1581 {
1582   /* Strip pointer conversion chains and get to the correct original type.  */
1583   STRIP_NOPS (expr);
1584   otype = TREE_TYPE (expr);
1585
1586   if (!(flag_strict_aliasing
1587         && POINTER_TYPE_P (type)
1588         && POINTER_TYPE_P (otype)
1589         && !VOID_TYPE_P (TREE_TYPE (type)))
1590       /* If the type we are casting to is a ref-all pointer
1591          dereferencing it is always valid.  */
1592       || TYPE_REF_CAN_ALIAS_ALL (type))
1593     return false;
1594
1595   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1596       && (DECL_P (TREE_OPERAND (expr, 0))
1597           || handled_component_p (TREE_OPERAND (expr, 0))))
1598     {
1599       /* Casting the address of an object to non void pointer. Warn
1600          if the cast breaks type based aliasing.  */
1601       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1602         {
1603           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1604                    "might break strict-aliasing rules");
1605           return true;
1606         }
1607       else
1608         {
1609           /* warn_strict_aliasing >= 3.   This includes the default (3).
1610              Only warn if the cast is dereferenced immediately.  */
1611           alias_set_type set1 =
1612             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1613           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1614
1615           if (set1 != set2 && set2 != 0
1616               && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1617             {
1618               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1619                        "pointer will break strict-aliasing rules");
1620               return true;
1621             }
1622           else if (warn_strict_aliasing == 2
1623                    && !alias_sets_must_conflict_p (set1, set2))
1624             {
1625               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1626                        "pointer might break strict-aliasing rules");
1627               return true;
1628             }
1629         }
1630     }
1631   else
1632     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1633       {
1634         /* At this level, warn for any conversions, even if an address is
1635            not taken in the same statement.  This will likely produce many
1636            false positives, but could be useful to pinpoint problems that
1637            are not revealed at higher levels.  */
1638         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1639         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1640         if (!COMPLETE_TYPE_P (type)
1641             || !alias_sets_must_conflict_p (set1, set2))
1642           {
1643             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1644                      "pointer might break strict-aliasing rules");
1645             return true;
1646           }
1647       }
1648
1649   return false;
1650 }
1651
1652 /* Warn for unlikely, improbable, or stupid DECL declarations
1653    of `main'.  */
1654
1655 void
1656 check_main_parameter_types (tree decl)
1657 {
1658   tree args;
1659   int argct = 0;
1660
1661   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1662       args = TREE_CHAIN (args))
1663    {
1664      tree type = args ? TREE_VALUE (args) : 0;
1665
1666      if (type == void_type_node || type == error_mark_node )
1667        break;
1668
1669      ++argct;
1670      switch (argct)
1671        {
1672        case 1:
1673          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1674            pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1675                     decl);
1676          break;
1677
1678        case 2:
1679          if (TREE_CODE (type) != POINTER_TYPE
1680              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1681              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1682                  != char_type_node))
1683            pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1684                     decl);
1685          break;
1686
1687        case 3:
1688          if (TREE_CODE (type) != POINTER_TYPE
1689              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1690              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1691                  != char_type_node))
1692            pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1693                     "%<char **%>", decl);
1694          break;
1695        }
1696    }
1697
1698   /* It is intentional that this message does not mention the third
1699     argument because it's only mentioned in an appendix of the
1700     standard.  */
1701   if (argct > 0 && (argct < 2 || argct > 3))
1702     pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1703 }
1704
1705 /* True if pointers to distinct types T1 and T2 can be converted to
1706    each other without an explicit cast.  Only returns true for opaque
1707    vector types.  */
1708 bool
1709 vector_targets_convertible_p (const_tree t1, const_tree t2)
1710 {
1711   if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1712       && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1713       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1714     return true;
1715
1716   return false;
1717 }
1718
1719 /* True if vector types T1 and T2 can be converted to each other
1720    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1721    can only be converted with -flax-vector-conversions yet that is not
1722    in effect, emit a note telling the user about that option if such
1723    a note has not previously been emitted.  */
1724 bool
1725 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1726 {
1727   static bool emitted_lax_note = false;
1728   bool convertible_lax;
1729
1730   if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1731       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1732     return true;
1733
1734   convertible_lax =
1735     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1736      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1737          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1738      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1739          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1740
1741   if (!convertible_lax || flag_lax_vector_conversions)
1742     return convertible_lax;
1743
1744   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1745       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1746     return true;
1747
1748   if (emit_lax_note && !emitted_lax_note)
1749     {
1750       emitted_lax_note = true;
1751       inform (input_location, "use -flax-vector-conversions to permit "
1752               "conversions between vectors with differing "
1753               "element types or numbers of subparts");
1754     }
1755
1756   return false;
1757 }
1758
1759 /* This is a helper function of build_binary_op.
1760
1761    For certain operations if both args were extended from the same
1762    smaller type, do the arithmetic in that type and then extend.
1763
1764    BITWISE indicates a bitwise operation.
1765    For them, this optimization is safe only if
1766    both args are zero-extended or both are sign-extended.
1767    Otherwise, we might change the result.
1768    Eg, (short)-1 | (unsigned short)-1 is (int)-1
1769    but calculated in (unsigned short) it would be (unsigned short)-1.
1770 */
1771 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1772 {
1773   int unsigned0, unsigned1;
1774   tree arg0, arg1;
1775   int uns;
1776   tree type;
1777
1778   /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
1779      excessive narrowing when we call get_narrower below.  For
1780      example, suppose that OP0 is of unsigned int extended
1781      from signed char and that RESULT_TYPE is long long int.
1782      If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1783      like
1784
1785      (long long int) (unsigned int) signed_char
1786
1787      which get_narrower would narrow down to
1788
1789      (unsigned int) signed char
1790
1791      If we do not cast OP0 first, get_narrower would return
1792      signed_char, which is inconsistent with the case of the
1793      explicit cast.  */
1794   op0 = convert (result_type, op0);
1795   op1 = convert (result_type, op1);
1796
1797   arg0 = get_narrower (op0, &unsigned0);
1798   arg1 = get_narrower (op1, &unsigned1);
1799
1800   /* UNS is 1 if the operation to be done is an unsigned one.  */
1801   uns = TYPE_UNSIGNED (result_type);
1802
1803   /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1804      but it *requires* conversion to FINAL_TYPE.  */
1805
1806   if ((TYPE_PRECISION (TREE_TYPE (op0))
1807        == TYPE_PRECISION (TREE_TYPE (arg0)))
1808       && TREE_TYPE (op0) != result_type)
1809     unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1810   if ((TYPE_PRECISION (TREE_TYPE (op1))
1811        == TYPE_PRECISION (TREE_TYPE (arg1)))
1812       && TREE_TYPE (op1) != result_type)
1813     unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1814
1815   /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
1816
1817   /* For bitwise operations, signedness of nominal type
1818      does not matter.  Consider only how operands were extended.  */
1819   if (bitwise)
1820     uns = unsigned0;
1821
1822   /* Note that in all three cases below we refrain from optimizing
1823      an unsigned operation on sign-extended args.
1824      That would not be valid.  */
1825
1826   /* Both args variable: if both extended in same way
1827      from same width, do it in that width.
1828      Do it unsigned if args were zero-extended.  */
1829   if ((TYPE_PRECISION (TREE_TYPE (arg0))
1830        < TYPE_PRECISION (result_type))
1831       && (TYPE_PRECISION (TREE_TYPE (arg1))
1832           == TYPE_PRECISION (TREE_TYPE (arg0)))
1833       && unsigned0 == unsigned1
1834       && (unsigned0 || !uns))
1835     return c_common_signed_or_unsigned_type
1836       (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1837
1838   else if (TREE_CODE (arg0) == INTEGER_CST
1839            && (unsigned1 || !uns)
1840            && (TYPE_PRECISION (TREE_TYPE (arg1))
1841                < TYPE_PRECISION (result_type))
1842            && (type
1843                = c_common_signed_or_unsigned_type (unsigned1,
1844                                                    TREE_TYPE (arg1)))
1845            && !POINTER_TYPE_P (type)
1846            && int_fits_type_p (arg0, type))
1847     return type;
1848
1849   else if (TREE_CODE (arg1) == INTEGER_CST
1850            && (unsigned0 || !uns)
1851            && (TYPE_PRECISION (TREE_TYPE (arg0))
1852                < TYPE_PRECISION (result_type))
1853            && (type
1854                = c_common_signed_or_unsigned_type (unsigned0,
1855                                                    TREE_TYPE (arg0)))
1856            && !POINTER_TYPE_P (type)
1857            && int_fits_type_p (arg1, type))
1858     return type;
1859
1860   return result_type;
1861 }
1862
1863 /* Warns if the conversion of EXPR to TYPE may alter a value.
1864    This is a helper function for warnings_for_convert_and_check.  */
1865
1866 static void
1867 conversion_warning (tree type, tree expr)
1868 {
1869   bool give_warning = false;
1870
1871   int i;
1872   const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1873   tree expr_type = TREE_TYPE (expr);
1874   location_t loc = EXPR_LOC_OR_HERE (expr);
1875
1876   if (!warn_conversion && !warn_sign_conversion)
1877     return;
1878
1879   /* If any operand is artificial, then this expression was generated
1880      by the compiler and we do not warn.  */
1881   for (i = 0; i < expr_num_operands; i++)
1882     {
1883       tree op = TREE_OPERAND (expr, i);
1884       if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1885         return;
1886     }
1887
1888   switch (TREE_CODE (expr))
1889     {
1890     case EQ_EXPR:
1891     case NE_EXPR:
1892     case LE_EXPR:
1893     case GE_EXPR:
1894     case LT_EXPR:
1895     case GT_EXPR:
1896     case TRUTH_ANDIF_EXPR:
1897     case TRUTH_ORIF_EXPR:
1898     case TRUTH_AND_EXPR:
1899     case TRUTH_OR_EXPR:
1900     case TRUTH_XOR_EXPR:
1901     case TRUTH_NOT_EXPR:
1902       /* Conversion from boolean to a signed:1 bit-field (which only
1903          can hold the values 0 and -1) doesn't lose information - but
1904          it does change the value.  */
1905       if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1906         warning_at (loc, OPT_Wconversion,
1907                     "conversion to %qT from boolean expression", type);
1908       return;
1909
1910     case REAL_CST:
1911     case INTEGER_CST:
1912
1913       /* Warn for real constant that is not an exact integer converted
1914          to integer type.  */
1915       if (TREE_CODE (expr_type) == REAL_TYPE
1916           && TREE_CODE (type) == INTEGER_TYPE)
1917         {
1918           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1919             give_warning = true;
1920         }
1921       /* Warn for an integer constant that does not fit into integer type.  */
1922       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1923                && TREE_CODE (type) == INTEGER_TYPE
1924                && !int_fits_type_p (expr, type))
1925         {
1926           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1927               && tree_int_cst_sgn (expr) < 0)
1928             warning_at (loc, OPT_Wsign_conversion, "negative integer"
1929                         " implicitly converted to unsigned type");
1930           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1931             warning_at (loc, OPT_Wsign_conversion, "conversion of unsigned"
1932                         " constant value to negative integer");
1933           else
1934             give_warning = true;
1935         }
1936       else if (TREE_CODE (type) == REAL_TYPE)
1937         {
1938           /* Warn for an integer constant that does not fit into real type.  */
1939           if (TREE_CODE (expr_type) == INTEGER_TYPE)
1940             {
1941               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1942               if (!exact_real_truncate (TYPE_MODE (type), &a))
1943                 give_warning = true;
1944             }
1945           /* Warn for a real constant that does not fit into a smaller
1946              real type.  */
1947           else if (TREE_CODE (expr_type) == REAL_TYPE
1948                    && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1949             {
1950               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1951               if (!exact_real_truncate (TYPE_MODE (type), &a))
1952                 give_warning = true;
1953             }
1954         }
1955
1956       if (give_warning)
1957         warning_at (loc, OPT_Wconversion,
1958                     "conversion to %qT alters %qT constant value",
1959                     type, expr_type);
1960
1961       return;
1962
1963     case COND_EXPR:
1964       {
1965         /* In case of COND_EXPR, if both operands are constants or
1966            COND_EXPR, then we do not care about the type of COND_EXPR,
1967            only about the conversion of each operand.  */
1968         tree op1 = TREE_OPERAND (expr, 1);
1969         tree op2 = TREE_OPERAND (expr, 2);
1970
1971         if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
1972              || TREE_CODE (op1) == COND_EXPR)
1973             && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1974                 || TREE_CODE (op2) == COND_EXPR))
1975           {
1976             conversion_warning (type, op1);
1977             conversion_warning (type, op2);
1978             return;
1979           }
1980         /* Fall through.  */
1981       }
1982
1983     default: /* 'expr' is not a constant.  */
1984
1985       /* Warn for real types converted to integer types.  */
1986       if (TREE_CODE (expr_type) == REAL_TYPE
1987           && TREE_CODE (type) == INTEGER_TYPE)
1988         give_warning = true;
1989
1990       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1991                && TREE_CODE (type) == INTEGER_TYPE)
1992         {
1993           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
1994           expr = get_unwidened (expr, 0);
1995           expr_type = TREE_TYPE (expr);
1996
1997           /* Don't warn for short y; short x = ((int)y & 0xff);  */
1998           if (TREE_CODE (expr) == BIT_AND_EXPR
1999                 || TREE_CODE (expr) == BIT_IOR_EXPR
2000               || TREE_CODE (expr) == BIT_XOR_EXPR)
2001             {
2002               /* If both args were extended from a shortest type,
2003                  use that type if that is safe.  */
2004               expr_type = shorten_binary_op (expr_type,
2005                                              TREE_OPERAND (expr, 0),
2006                                              TREE_OPERAND (expr, 1),
2007                                              /* bitwise */1);
2008
2009               if (TREE_CODE (expr) == BIT_AND_EXPR)
2010                 {
2011                   tree op0 = TREE_OPERAND (expr, 0);
2012                   tree op1 = TREE_OPERAND (expr, 1);
2013                   bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2014                   bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2015
2016                   /* If one of the operands is a non-negative constant
2017                      that fits in the target type, then the type of the
2018                      other operand does not matter. */
2019                   if ((TREE_CODE (op0) == INTEGER_CST
2020                        && int_fits_type_p (op0, c_common_signed_type (type))
2021                        && int_fits_type_p (op0, c_common_unsigned_type (type)))
2022                       || (TREE_CODE (op1) == INTEGER_CST
2023                           && int_fits_type_p (op1, c_common_signed_type (type))
2024                           && int_fits_type_p (op1,
2025                                               c_common_unsigned_type (type))))
2026                     return;
2027                   /* If constant is unsigned and fits in the target
2028                      type, then the result will also fit.  */
2029                   else if ((TREE_CODE (op0) == INTEGER_CST
2030                             && unsigned0
2031                             && int_fits_type_p (op0, type))
2032                            || (TREE_CODE (op1) == INTEGER_CST
2033                                && unsigned1
2034                                && int_fits_type_p (op1, type)))
2035                     return;
2036                 }
2037             }
2038           /* Warn for integer types converted to smaller integer types.  */
2039           if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2040             give_warning = true;
2041
2042           /* When they are the same width but different signedness,
2043              then the value may change.  */
2044           else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2045                     && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2046                    /* Even when converted to a bigger type, if the type is
2047                       unsigned but expr is signed, then negative values
2048                       will be changed.  */
2049                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2050             warning_at (loc, OPT_Wsign_conversion, "conversion to %qT from %qT "
2051                         "may change the sign of the result",
2052                         type, expr_type);
2053         }
2054
2055       /* Warn for integer types converted to real types if and only if
2056          all the range of values of the integer type cannot be
2057          represented by the real type.  */
2058       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2059                && TREE_CODE (type) == REAL_TYPE)
2060         {
2061           tree type_low_bound, type_high_bound;
2062           REAL_VALUE_TYPE real_low_bound, real_high_bound;
2063
2064           /* Don't warn about char y = 0xff; float x = (int) y;  */
2065           expr = get_unwidened (expr, 0);
2066           expr_type = TREE_TYPE (expr);
2067
2068           type_low_bound = TYPE_MIN_VALUE (expr_type);
2069           type_high_bound = TYPE_MAX_VALUE (expr_type);
2070           real_low_bound = real_value_from_int_cst (0, type_low_bound);
2071           real_high_bound = real_value_from_int_cst (0, type_high_bound);
2072
2073           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2074               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2075             give_warning = true;
2076         }
2077
2078       /* Warn for real types converted to smaller real types.  */
2079       else if (TREE_CODE (expr_type) == REAL_TYPE
2080                && TREE_CODE (type) == REAL_TYPE
2081                && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2082         give_warning = true;
2083
2084
2085       if (give_warning)
2086         warning_at (loc, OPT_Wconversion,
2087                     "conversion to %qT from %qT may alter its value",
2088                     type, expr_type);
2089     }
2090 }
2091
2092 /* Produce warnings after a conversion. RESULT is the result of
2093    converting EXPR to TYPE.  This is a helper function for
2094    convert_and_check and cp_convert_and_check.  */
2095
2096 void
2097 warnings_for_convert_and_check (tree type, tree expr, tree result)
2098 {
2099   if (TREE_CODE (expr) == INTEGER_CST
2100       && (TREE_CODE (type) == INTEGER_TYPE
2101           || TREE_CODE (type) == ENUMERAL_TYPE)
2102       && !int_fits_type_p (expr, type))
2103     {
2104       /* Do not diagnose overflow in a constant expression merely
2105          because a conversion overflowed.  */
2106       if (TREE_OVERFLOW (result))
2107         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2108
2109       if (TYPE_UNSIGNED (type))
2110         {
2111           /* This detects cases like converting -129 or 256 to
2112              unsigned char.  */
2113           if (!int_fits_type_p (expr, c_common_signed_type (type)))
2114             warning (OPT_Woverflow,
2115                      "large integer implicitly truncated to unsigned type");
2116           else
2117             conversion_warning (type, expr);
2118         }
2119       else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2120         warning (OPT_Woverflow,
2121                  "overflow in implicit constant conversion");
2122       /* No warning for converting 0x80000000 to int.  */
2123       else if (pedantic
2124                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2125                    || TYPE_PRECISION (TREE_TYPE (expr))
2126                    != TYPE_PRECISION (type)))
2127         warning (OPT_Woverflow,
2128                  "overflow in implicit constant conversion");
2129
2130       else
2131         conversion_warning (type, expr);
2132     }
2133   else if ((TREE_CODE (result) == INTEGER_CST
2134             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2135     warning (OPT_Woverflow,
2136              "overflow in implicit constant conversion");
2137   else
2138     conversion_warning (type, expr);
2139 }
2140
2141
2142 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2143    Invoke this function on every expression that is converted implicitly,
2144    i.e. because of language rules and not because of an explicit cast.  */
2145
2146 tree
2147 convert_and_check (tree type, tree expr)
2148 {
2149   tree result;
2150   tree expr_for_warning;
2151
2152   /* Convert from a value with possible excess precision rather than
2153      via the semantic type, but do not warn about values not fitting
2154      exactly in the semantic type.  */
2155   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2156     {
2157       tree orig_type = TREE_TYPE (expr);
2158       expr = TREE_OPERAND (expr, 0);
2159       expr_for_warning = convert (orig_type, expr);
2160       if (orig_type == type)
2161         return expr_for_warning;
2162     }
2163   else
2164     expr_for_warning = expr;
2165
2166   if (TREE_TYPE (expr) == type)
2167     return expr;
2168
2169   result = convert (type, expr);
2170
2171   if (c_inhibit_evaluation_warnings == 0
2172       && !TREE_OVERFLOW_P (expr)
2173       && result != error_mark_node)
2174     warnings_for_convert_and_check (type, expr_for_warning, result);
2175
2176   return result;
2177 }
2178 \f
2179 /* A node in a list that describes references to variables (EXPR), which are
2180    either read accesses if WRITER is zero, or write accesses, in which case
2181    WRITER is the parent of EXPR.  */
2182 struct tlist
2183 {
2184   struct tlist *next;
2185   tree expr, writer;
2186 };
2187
2188 /* Used to implement a cache the results of a call to verify_tree.  We only
2189    use this for SAVE_EXPRs.  */
2190 struct tlist_cache
2191 {
2192   struct tlist_cache *next;
2193   struct tlist *cache_before_sp;
2194   struct tlist *cache_after_sp;
2195   tree expr;
2196 };
2197
2198 /* Obstack to use when allocating tlist structures, and corresponding
2199    firstobj.  */
2200 static struct obstack tlist_obstack;
2201 static char *tlist_firstobj = 0;
2202
2203 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2204    warnings.  */
2205 static struct tlist *warned_ids;
2206 /* SAVE_EXPRs need special treatment.  We process them only once and then
2207    cache the results.  */
2208 static struct tlist_cache *save_expr_cache;
2209
2210 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2211 static void merge_tlist (struct tlist **, struct tlist *, int);
2212 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2213 static int warning_candidate_p (tree);
2214 static bool candidate_equal_p (const_tree, const_tree);
2215 static void warn_for_collisions (struct tlist *);
2216 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2217 static struct tlist *new_tlist (struct tlist *, tree, tree);
2218
2219 /* Create a new struct tlist and fill in its fields.  */
2220 static struct tlist *
2221 new_tlist (struct tlist *next, tree t, tree writer)
2222 {
2223   struct tlist *l;
2224   l = XOBNEW (&tlist_obstack, struct tlist);
2225   l->next = next;
2226   l->expr = t;
2227   l->writer = writer;
2228   return l;
2229 }
2230
2231 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
2232    is nonnull, we ignore any node we find which has a writer equal to it.  */
2233
2234 static void
2235 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2236 {
2237   while (add)
2238     {
2239       struct tlist *next = add->next;
2240       if (!copy)
2241         add->next = *to;
2242       if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2243         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2244       add = next;
2245     }
2246 }
2247
2248 /* Merge the nodes of ADD into TO.  This merging process is done so that for
2249    each variable that already exists in TO, no new node is added; however if
2250    there is a write access recorded in ADD, and an occurrence on TO is only
2251    a read access, then the occurrence in TO will be modified to record the
2252    write.  */
2253
2254 static void
2255 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2256 {
2257   struct tlist **end = to;
2258
2259   while (*end)
2260     end = &(*end)->next;
2261
2262   while (add)
2263     {
2264       int found = 0;
2265       struct tlist *tmp2;
2266       struct tlist *next = add->next;
2267
2268       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2269         if (candidate_equal_p (tmp2->expr, add->expr))
2270           {
2271             found = 1;
2272             if (!tmp2->writer)
2273               tmp2->writer = add->writer;
2274           }
2275       if (!found)
2276         {
2277           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2278           end = &(*end)->next;
2279           *end = 0;
2280         }
2281       add = next;
2282     }
2283 }
2284
2285 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
2286    references in list LIST conflict with it, excluding reads if ONLY writers
2287    is nonzero.  */
2288
2289 static void
2290 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2291                        int only_writes)
2292 {
2293   struct tlist *tmp;
2294
2295   /* Avoid duplicate warnings.  */
2296   for (tmp = warned_ids; tmp; tmp = tmp->next)
2297     if (candidate_equal_p (tmp->expr, written))
2298       return;
2299
2300   while (list)
2301     {
2302       if (candidate_equal_p (list->expr, written)
2303           && !candidate_equal_p (list->writer, writer)
2304           && (!only_writes || list->writer))
2305         {
2306           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2307           warning_at (EXPR_LOC_OR_HERE (writer),
2308                       OPT_Wsequence_point, "operation on %qE may be undefined",
2309                       list->expr);
2310         }
2311       list = list->next;
2312     }
2313 }
2314
2315 /* Given a list LIST of references to variables, find whether any of these
2316    can cause conflicts due to missing sequence points.  */
2317
2318 static void
2319 warn_for_collisions (struct tlist *list)
2320 {
2321   struct tlist *tmp;
2322
2323   for (tmp = list; tmp; tmp = tmp->next)
2324     {
2325       if (tmp->writer)
2326         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2327     }
2328 }
2329
2330 /* Return nonzero if X is a tree that can be verified by the sequence point
2331    warnings.  */
2332 static int
2333 warning_candidate_p (tree x)
2334 {
2335   if (DECL_P (x) && DECL_ARTIFICIAL (x))
2336     return 0;
2337
2338   /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2339      (lvalue_p) crash on TRY/CATCH. */
2340   if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x)))
2341     return 0;
2342
2343   if (!lvalue_p (x))
2344     return 0;
2345
2346   /* No point to track non-const calls, they will never satisfy
2347      operand_equal_p.  */
2348   if (TREE_CODE (x) == CALL_EXPR && (call_expr_flags (x) & ECF_CONST) == 0)
2349     return 0;
2350
2351   if (TREE_CODE (x) == STRING_CST)
2352     return 0;
2353
2354   return 1;
2355 }
2356
2357 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2358 static bool
2359 candidate_equal_p (const_tree x, const_tree y)
2360 {
2361   return (x == y) || (x && y && operand_equal_p (x, y, 0));
2362 }
2363
2364 /* Walk the tree X, and record accesses to variables.  If X is written by the
2365    parent tree, WRITER is the parent.
2366    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
2367    expression or its only operand forces a sequence point, then everything up
2368    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
2369    in PNO_SP.
2370    Once we return, we will have emitted warnings if any subexpression before
2371    such a sequence point could be undefined.  On a higher level, however, the
2372    sequence point may not be relevant, and we'll merge the two lists.
2373
2374    Example: (b++, a) + b;
2375    The call that processes the COMPOUND_EXPR will store the increment of B
2376    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
2377    processes the PLUS_EXPR will need to merge the two lists so that
2378    eventually, all accesses end up on the same list (and we'll warn about the
2379    unordered subexpressions b++ and b.
2380
2381    A note on merging.  If we modify the former example so that our expression
2382    becomes
2383      (b++, b) + a
2384    care must be taken not simply to add all three expressions into the final
2385    PNO_SP list.  The function merge_tlist takes care of that by merging the
2386    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2387    way, so that no more than one access to B is recorded.  */
2388
2389 static void
2390 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2391              tree writer)
2392 {
2393   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2394   enum tree_code code;
2395   enum tree_code_class cl;
2396
2397   /* X may be NULL if it is the operand of an empty statement expression
2398      ({ }).  */
2399   if (x == NULL)
2400     return;
2401
2402  restart:
2403   code = TREE_CODE (x);
2404   cl = TREE_CODE_CLASS (code);
2405
2406   if (warning_candidate_p (x))
2407     *pno_sp = new_tlist (*pno_sp, x, writer);
2408
2409   switch (code)
2410     {
2411     case CONSTRUCTOR:
2412       return;
2413
2414     case COMPOUND_EXPR:
2415     case TRUTH_ANDIF_EXPR:
2416     case TRUTH_ORIF_EXPR:
2417       tmp_before = tmp_nosp = tmp_list3 = 0;
2418       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2419       warn_for_collisions (tmp_nosp);
2420       merge_tlist (pbefore_sp, tmp_before, 0);
2421       merge_tlist (pbefore_sp, tmp_nosp, 0);
2422       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2423       merge_tlist (pbefore_sp, tmp_list3, 0);
2424       return;
2425
2426     case COND_EXPR:
2427       tmp_before = tmp_list2 = 0;
2428       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2429       warn_for_collisions (tmp_list2);
2430       merge_tlist (pbefore_sp, tmp_before, 0);
2431       merge_tlist (pbefore_sp, tmp_list2, 1);
2432
2433       tmp_list3 = tmp_nosp = 0;
2434       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2435       warn_for_collisions (tmp_nosp);
2436       merge_tlist (pbefore_sp, tmp_list3, 0);
2437
2438       tmp_list3 = tmp_list2 = 0;
2439       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2440       warn_for_collisions (tmp_list2);
2441       merge_tlist (pbefore_sp, tmp_list3, 0);
2442       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2443          two first, to avoid warning for (a ? b++ : b++).  */
2444       merge_tlist (&tmp_nosp, tmp_list2, 0);
2445       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2446       return;
2447
2448     case PREDECREMENT_EXPR:
2449     case PREINCREMENT_EXPR:
2450     case POSTDECREMENT_EXPR:
2451     case POSTINCREMENT_EXPR:
2452       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2453       return;
2454
2455     case MODIFY_EXPR:
2456       tmp_before = tmp_nosp = tmp_list3 = 0;
2457       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2458       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2459       /* Expressions inside the LHS are not ordered wrt. the sequence points
2460          in the RHS.  Example:
2461            *a = (a++, 2)
2462          Despite the fact that the modification of "a" is in the before_sp
2463          list (tmp_before), it conflicts with the use of "a" in the LHS.
2464          We can handle this by adding the contents of tmp_list3
2465          to those of tmp_before, and redoing the collision warnings for that
2466          list.  */
2467       add_tlist (&tmp_before, tmp_list3, x, 1);
2468       warn_for_collisions (tmp_before);
2469       /* Exclude the LHS itself here; we first have to merge it into the
2470          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
2471          didn't exclude the LHS, we'd get it twice, once as a read and once
2472          as a write.  */
2473       add_tlist (pno_sp, tmp_list3, x, 0);
2474       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2475
2476       merge_tlist (pbefore_sp, tmp_before, 0);
2477       if (warning_candidate_p (TREE_OPERAND (x, 0)))
2478         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2479       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2480       return;
2481
2482     case CALL_EXPR:
2483       /* We need to warn about conflicts among arguments and conflicts between
2484          args and the function address.  Side effects of the function address,
2485          however, are not ordered by the sequence point of the call.  */
2486       {
2487         call_expr_arg_iterator iter;
2488         tree arg;
2489         tmp_before = tmp_nosp = 0;
2490         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2491         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2492           {
2493             tmp_list2 = tmp_list3 = 0;
2494             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2495             merge_tlist (&tmp_list3, tmp_list2, 0);
2496             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2497           }
2498         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2499         warn_for_collisions (tmp_before);
2500         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2501         return;
2502       }
2503
2504     case TREE_LIST:
2505       /* Scan all the list, e.g. indices of multi dimensional array.  */
2506       while (x)
2507         {
2508           tmp_before = tmp_nosp = 0;
2509           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2510           merge_tlist (&tmp_nosp, tmp_before, 0);
2511           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2512           x = TREE_CHAIN (x);
2513         }
2514       return;
2515
2516     case SAVE_EXPR:
2517       {
2518         struct tlist_cache *t;
2519         for (t = save_expr_cache; t; t = t->next)
2520           if (candidate_equal_p (t->expr, x))
2521             break;
2522
2523         if (!t)
2524           {
2525             t = XOBNEW (&tlist_obstack, struct tlist_cache);
2526             t->next = save_expr_cache;
2527             t->expr = x;
2528             save_expr_cache = t;
2529
2530             tmp_before = tmp_nosp = 0;
2531             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2532             warn_for_collisions (tmp_nosp);
2533
2534             tmp_list3 = 0;
2535             while (tmp_nosp)
2536               {
2537                 struct tlist *t = tmp_nosp;
2538                 tmp_nosp = t->next;
2539                 merge_tlist (&tmp_list3, t, 0);
2540               }
2541             t->cache_before_sp = tmp_before;
2542             t->cache_after_sp = tmp_list3;
2543           }
2544         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2545         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2546         return;
2547       }
2548
2549     case ADDR_EXPR:
2550       x = TREE_OPERAND (x, 0);
2551       if (DECL_P (x))
2552         return;
2553       writer = 0;
2554       goto restart;
2555
2556     default:
2557       /* For other expressions, simply recurse on their operands.
2558          Manual tail recursion for unary expressions.
2559          Other non-expressions need not be processed.  */
2560       if (cl == tcc_unary)
2561         {
2562           x = TREE_OPERAND (x, 0);
2563           writer = 0;
2564           goto restart;
2565         }
2566       else if (IS_EXPR_CODE_CLASS (cl))
2567         {
2568           int lp;
2569           int max = TREE_OPERAND_LENGTH (x);
2570           for (lp = 0; lp < max; lp++)
2571             {
2572               tmp_before = tmp_nosp = 0;
2573               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2574               merge_tlist (&tmp_nosp, tmp_before, 0);
2575               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2576             }
2577         }
2578       return;
2579     }
2580 }
2581
2582 /* Try to warn for undefined behavior in EXPR due to missing sequence
2583    points.  */
2584
2585 DEBUG_FUNCTION void
2586 verify_sequence_points (tree expr)
2587 {
2588   struct tlist *before_sp = 0, *after_sp = 0;
2589
2590   warned_ids = 0;
2591   save_expr_cache = 0;
2592   if (tlist_firstobj == 0)
2593     {
2594       gcc_obstack_init (&tlist_obstack);
2595       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2596     }
2597
2598   verify_tree (expr, &before_sp, &after_sp, 0);
2599   warn_for_collisions (after_sp);
2600   obstack_free (&tlist_obstack, tlist_firstobj);
2601 }
2602 \f
2603 /* Validate the expression after `case' and apply default promotions.  */
2604
2605 static tree
2606 check_case_value (tree value)
2607 {
2608   if (value == NULL_TREE)
2609     return value;
2610
2611   if (TREE_CODE (value) == INTEGER_CST)
2612     /* Promote char or short to int.  */
2613     value = perform_integral_promotions (value);
2614   else if (value != error_mark_node)
2615     {
2616       error ("case label does not reduce to an integer constant");
2617       value = error_mark_node;
2618     }
2619
2620   constant_expression_warning (value);
2621
2622   return value;
2623 }
2624 \f
2625 /* See if the case values LOW and HIGH are in the range of the original
2626    type (i.e. before the default conversion to int) of the switch testing
2627    expression.
2628    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2629    the type before promoting it.  CASE_LOW_P is a pointer to the lower
2630    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2631    if the case is not a case range.
2632    The caller has to make sure that we are not called with NULL for
2633    CASE_LOW_P (i.e. the default case).
2634    Returns true if the case label is in range of ORIG_TYPE (saturated or
2635    untouched) or false if the label is out of range.  */
2636
2637 static bool
2638 check_case_bounds (tree type, tree orig_type,
2639                    tree *case_low_p, tree *case_high_p)
2640 {
2641   tree min_value, max_value;
2642   tree case_low = *case_low_p;
2643   tree case_high = case_high_p ? *case_high_p : case_low;
2644
2645   /* If there was a problem with the original type, do nothing.  */
2646   if (orig_type == error_mark_node)
2647     return true;
2648
2649   min_value = TYPE_MIN_VALUE (orig_type);
2650   max_value = TYPE_MAX_VALUE (orig_type);
2651
2652   /* Case label is less than minimum for type.  */
2653   if (tree_int_cst_compare (case_low, min_value) < 0
2654       && tree_int_cst_compare (case_high, min_value) < 0)
2655     {
2656       warning (0, "case label value is less than minimum value for type");
2657       return false;
2658     }
2659
2660   /* Case value is greater than maximum for type.  */
2661   if (tree_int_cst_compare (case_low, max_value) > 0
2662       && tree_int_cst_compare (case_high, max_value) > 0)
2663     {
2664       warning (0, "case label value exceeds maximum value for type");
2665       return false;
2666     }
2667
2668   /* Saturate lower case label value to minimum.  */
2669   if (tree_int_cst_compare (case_high, min_value) >= 0
2670       && tree_int_cst_compare (case_low, min_value) < 0)
2671     {
2672       warning (0, "lower value in case label range"
2673                " less than minimum value for type");
2674       case_low = min_value;
2675     }
2676
2677   /* Saturate upper case label value to maximum.  */
2678   if (tree_int_cst_compare (case_low, max_value) <= 0
2679       && tree_int_cst_compare (case_high, max_value) > 0)
2680     {
2681       warning (0, "upper value in case label range"
2682                " exceeds maximum value for type");
2683       case_high = max_value;
2684     }
2685
2686   if (*case_low_p != case_low)
2687     *case_low_p = convert (type, case_low);
2688   if (case_high_p && *case_high_p != case_high)
2689     *case_high_p = convert (type, case_high);
2690
2691   return true;
2692 }
2693 \f
2694 /* Return an integer type with BITS bits of precision,
2695    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2696
2697 tree
2698 c_common_type_for_size (unsigned int bits, int unsignedp)
2699 {
2700   if (bits == TYPE_PRECISION (integer_type_node))
2701     return unsignedp ? unsigned_type_node : integer_type_node;
2702
2703   if (bits == TYPE_PRECISION (signed_char_type_node))
2704     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2705
2706   if (bits == TYPE_PRECISION (short_integer_type_node))
2707     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2708
2709   if (bits == TYPE_PRECISION (long_integer_type_node))
2710     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2711
2712   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2713     return (unsignedp ? long_long_unsigned_type_node
2714             : long_long_integer_type_node);
2715
2716   if (int128_integer_type_node
2717       && bits == TYPE_PRECISION (int128_integer_type_node))
2718     return (unsignedp ? int128_unsigned_type_node
2719             : int128_integer_type_node);
2720
2721   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2722     return (unsignedp ? widest_unsigned_literal_type_node
2723             : widest_integer_literal_type_node);
2724
2725   if (bits <= TYPE_PRECISION (intQI_type_node))
2726     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2727
2728   if (bits <= TYPE_PRECISION (intHI_type_node))
2729     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2730
2731   if (bits <= TYPE_PRECISION (intSI_type_node))
2732     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2733
2734   if (bits <= TYPE_PRECISION (intDI_type_node))
2735     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2736
2737   return 0;
2738 }
2739
2740 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2741    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2742    and saturating if SATP is nonzero, otherwise not saturating.  */
2743
2744 tree
2745 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2746                                     int unsignedp, int satp)
2747 {
2748   enum machine_mode mode;
2749   if (ibit == 0)
2750     mode = unsignedp ? UQQmode : QQmode;
2751   else
2752     mode = unsignedp ? UHAmode : HAmode;
2753
2754   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2755     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2756       break;
2757
2758   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2759     {
2760       sorry ("GCC cannot support operators with integer types and "
2761              "fixed-point types that have too many integral and "
2762              "fractional bits together");
2763       return 0;
2764     }
2765
2766   return c_common_type_for_mode (mode, satp);
2767 }
2768
2769 /* Used for communication between c_common_type_for_mode and
2770    c_register_builtin_type.  */
2771 static GTY(()) tree registered_builtin_types;
2772
2773 /* Return a data type that has machine mode MODE.
2774    If the mode is an integer,
2775    then UNSIGNEDP selects between signed and unsigned types.
2776    If the mode is a fixed-point mode,
2777    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2778
2779 tree
2780 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2781 {
2782   tree t;
2783
2784   if (mode == TYPE_MODE (integer_type_node))
2785     return unsignedp ? unsigned_type_node : integer_type_node;
2786
2787   if (mode == TYPE_MODE (signed_char_type_node))
2788     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2789
2790   if (mode == TYPE_MODE (short_integer_type_node))
2791     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2792
2793   if (mode == TYPE_MODE (long_integer_type_node))
2794     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2795
2796   if (mode == TYPE_MODE (long_long_integer_type_node))
2797     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2798
2799   if (int128_integer_type_node
2800       && mode == TYPE_MODE (int128_integer_type_node))
2801     return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2802
2803   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2804     return unsignedp ? widest_unsigned_literal_type_node
2805                      : widest_integer_literal_type_node;
2806
2807   if (mode == QImode)
2808     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2809
2810   if (mode == HImode)
2811     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2812
2813   if (mode == SImode)
2814     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2815
2816   if (mode == DImode)
2817     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2818
2819 #if HOST_BITS_PER_WIDE_INT >= 64
2820   if (mode == TYPE_MODE (intTI_type_node))
2821     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2822 #endif
2823
2824   if (mode == TYPE_MODE (float_type_node))
2825     return float_type_node;
2826
2827   if (mode == TYPE_MODE (double_type_node))
2828     return double_type_node;
2829
2830   if (mode == TYPE_MODE (long_double_type_node))
2831     return long_double_type_node;
2832
2833   if (mode == TYPE_MODE (void_type_node))
2834     return void_type_node;
2835
2836   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2837     return (unsignedp
2838             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2839             : make_signed_type (GET_MODE_PRECISION (mode)));
2840
2841   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2842     return (unsignedp
2843             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2844             : make_signed_type (GET_MODE_PRECISION (mode)));
2845
2846   if (COMPLEX_MODE_P (mode))
2847     {
2848       enum machine_mode inner_mode;
2849       tree inner_type;
2850
2851       if (mode == TYPE_MODE (complex_float_type_node))
2852         return complex_float_type_node;
2853       if (mode == TYPE_MODE (complex_double_type_node))
2854         return complex_double_type_node;
2855       if (mode == TYPE_MODE (complex_long_double_type_node))
2856         return complex_long_double_type_node;
2857
2858       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2859         return complex_integer_type_node;
2860
2861       inner_mode = GET_MODE_INNER (mode);
2862       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2863       if (inner_type != NULL_TREE)
2864         return build_complex_type (inner_type);
2865     }
2866   else if (VECTOR_MODE_P (mode))
2867     {
2868       enum machine_mode inner_mode = GET_MODE_INNER (mode);
2869       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2870       if (inner_type != NULL_TREE)
2871         return build_vector_type_for_mode (inner_type, mode);
2872     }
2873
2874   if (mode == TYPE_MODE (dfloat32_type_node))
2875     return dfloat32_type_node;
2876   if (mode == TYPE_MODE (dfloat64_type_node))
2877     return dfloat64_type_node;
2878   if (mode == TYPE_MODE (dfloat128_type_node))
2879     return dfloat128_type_node;
2880
2881   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2882     {
2883       if (mode == TYPE_MODE (short_fract_type_node))
2884         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2885       if (mode == TYPE_MODE (fract_type_node))
2886         return unsignedp ? sat_fract_type_node : fract_type_node;
2887       if (mode == TYPE_MODE (long_fract_type_node))
2888         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2889       if (mode == TYPE_MODE (long_long_fract_type_node))
2890         return unsignedp ? sat_long_long_fract_type_node
2891                          : long_long_fract_type_node;
2892
2893       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2894         return unsignedp ? sat_unsigned_short_fract_type_node
2895                          : unsigned_short_fract_type_node;
2896       if (mode == TYPE_MODE (unsigned_fract_type_node))
2897         return unsignedp ? sat_unsigned_fract_type_node
2898                          : unsigned_fract_type_node;
2899       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2900         return unsignedp ? sat_unsigned_long_fract_type_node
2901                          : unsigned_long_fract_type_node;
2902       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2903         return unsignedp ? sat_unsigned_long_long_fract_type_node
2904                          : unsigned_long_long_fract_type_node;
2905
2906       if (mode == TYPE_MODE (short_accum_type_node))
2907         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2908       if (mode == TYPE_MODE (accum_type_node))
2909         return unsignedp ? sat_accum_type_node : accum_type_node;
2910       if (mode == TYPE_MODE (long_accum_type_node))
2911         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2912       if (mode == TYPE_MODE (long_long_accum_type_node))
2913         return unsignedp ? sat_long_long_accum_type_node
2914                          : long_long_accum_type_node;
2915
2916       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2917         return unsignedp ? sat_unsigned_short_accum_type_node
2918                          : unsigned_short_accum_type_node;
2919       if (mode == TYPE_MODE (unsigned_accum_type_node))
2920         return unsignedp ? sat_unsigned_accum_type_node
2921                          : unsigned_accum_type_node;
2922       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2923         return unsignedp ? sat_unsigned_long_accum_type_node
2924                          : unsigned_long_accum_type_node;
2925       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2926         return unsignedp ? sat_unsigned_long_long_accum_type_node
2927                          : unsigned_long_long_accum_type_node;
2928
2929       if (mode == QQmode)
2930         return unsignedp ? sat_qq_type_node : qq_type_node;
2931       if (mode == HQmode)
2932         return unsignedp ? sat_hq_type_node : hq_type_node;
2933       if (mode == SQmode)
2934         return unsignedp ? sat_sq_type_node : sq_type_node;
2935       if (mode == DQmode)
2936         return unsignedp ? sat_dq_type_node : dq_type_node;
2937       if (mode == TQmode)
2938         return unsignedp ? sat_tq_type_node : tq_type_node;
2939
2940       if (mode == UQQmode)
2941         return unsignedp ? sat_uqq_type_node : uqq_type_node;
2942       if (mode == UHQmode)
2943         return unsignedp ? sat_uhq_type_node : uhq_type_node;
2944       if (mode == USQmode)
2945         return unsignedp ? sat_usq_type_node : usq_type_node;
2946       if (mode == UDQmode)
2947         return unsignedp ? sat_udq_type_node : udq_type_node;
2948       if (mode == UTQmode)
2949         return unsignedp ? sat_utq_type_node : utq_type_node;
2950
2951       if (mode == HAmode)
2952         return unsignedp ? sat_ha_type_node : ha_type_node;
2953       if (mode == SAmode)
2954         return unsignedp ? sat_sa_type_node : sa_type_node;
2955       if (mode == DAmode)
2956         return unsignedp ? sat_da_type_node : da_type_node;
2957       if (mode == TAmode)
2958         return unsignedp ? sat_ta_type_node : ta_type_node;
2959
2960       if (mode == UHAmode)
2961         return unsignedp ? sat_uha_type_node : uha_type_node;
2962       if (mode == USAmode)
2963         return unsignedp ? sat_usa_type_node : usa_type_node;
2964       if (mode == UDAmode)
2965         return unsignedp ? sat_uda_type_node : uda_type_node;
2966       if (mode == UTAmode)
2967         return unsignedp ? sat_uta_type_node : uta_type_node;
2968     }
2969
2970   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2971     if (TYPE_MODE (TREE_VALUE (t)) == mode)
2972       return TREE_VALUE (t);
2973
2974   return 0;
2975 }
2976
2977 tree
2978 c_common_unsigned_type (tree type)
2979 {
2980   return c_common_signed_or_unsigned_type (1, type);
2981 }
2982
2983 /* Return a signed type the same as TYPE in other respects.  */
2984
2985 tree
2986 c_common_signed_type (tree type)
2987 {
2988   return c_common_signed_or_unsigned_type (0, type);
2989 }
2990
2991 /* Return a type the same as TYPE except unsigned or
2992    signed according to UNSIGNEDP.  */
2993
2994 tree
2995 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2996 {
2997   tree type1;
2998
2999   /* This block of code emulates the behavior of the old
3000      c_common_unsigned_type. In particular, it returns
3001      long_unsigned_type_node if passed a long, even when a int would
3002      have the same size. This is necessary for warnings to work
3003      correctly in archs where sizeof(int) == sizeof(long) */
3004
3005   type1 = TYPE_MAIN_VARIANT (type);
3006   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3007     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3008   if (type1 == integer_type_node || type1 == unsigned_type_node)
3009     return unsignedp ? unsigned_type_node : integer_type_node;
3010   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3011     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3012   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3013     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3014   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3015     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3016   if (int128_integer_type_node
3017       && (type1 == int128_integer_type_node
3018           || type1 == int128_unsigned_type_node))
3019     return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
3020   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3021     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3022 #if HOST_BITS_PER_WIDE_INT >= 64
3023   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3024     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3025 #endif
3026   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3027     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3028   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3029     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3030   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3031     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3032   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3033     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3034
3035 #define C_COMMON_FIXED_TYPES(NAME)          \
3036   if (type1 == short_ ## NAME ## _type_node \
3037       || type1 == unsigned_short_ ## NAME ## _type_node) \
3038     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3039                      : short_ ## NAME ## _type_node; \
3040   if (type1 == NAME ## _type_node \
3041       || type1 == unsigned_ ## NAME ## _type_node) \
3042     return unsignedp ? unsigned_ ## NAME ## _type_node \
3043                      : NAME ## _type_node; \
3044   if (type1 == long_ ## NAME ## _type_node \
3045       || type1 == unsigned_long_ ## NAME ## _type_node) \
3046     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3047                      : long_ ## NAME ## _type_node; \
3048   if (type1 == long_long_ ## NAME ## _type_node \
3049       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3050     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3051                      : long_long_ ## NAME ## _type_node;
3052
3053 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3054   if (type1 == NAME ## _type_node \
3055       || type1 == u ## NAME ## _type_node) \
3056     return unsignedp ? u ## NAME ## _type_node \
3057                      : NAME ## _type_node;
3058
3059 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3060   if (type1 == sat_ ## short_ ## NAME ## _type_node \
3061       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3062     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3063                      : sat_ ## short_ ## NAME ## _type_node; \
3064   if (type1 == sat_ ## NAME ## _type_node \
3065       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3066     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3067                      : sat_ ## NAME ## _type_node; \
3068   if (type1 == sat_ ## long_ ## NAME ## _type_node \
3069       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3070     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3071                      : sat_ ## long_ ## NAME ## _type_node; \
3072   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3073       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3074     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3075                      : sat_ ## long_long_ ## NAME ## _type_node;
3076
3077 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
3078   if (type1 == sat_ ## NAME ## _type_node \
3079       || type1 == sat_ ## u ## NAME ## _type_node) \
3080     return unsignedp ? sat_ ## u ## NAME ## _type_node \
3081                      : sat_ ## NAME ## _type_node;
3082
3083   C_COMMON_FIXED_TYPES (fract);
3084   C_COMMON_FIXED_TYPES_SAT (fract);
3085   C_COMMON_FIXED_TYPES (accum);
3086   C_COMMON_FIXED_TYPES_SAT (accum);
3087
3088   C_COMMON_FIXED_MODE_TYPES (qq);
3089   C_COMMON_FIXED_MODE_TYPES (hq);
3090   C_COMMON_FIXED_MODE_TYPES (sq);
3091   C_COMMON_FIXED_MODE_TYPES (dq);
3092   C_COMMON_FIXED_MODE_TYPES (tq);
3093   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3094   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3095   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3096   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3097   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3098   C_COMMON_FIXED_MODE_TYPES (ha);
3099   C_COMMON_FIXED_MODE_TYPES (sa);
3100   C_COMMON_FIXED_MODE_TYPES (da);
3101   C_COMMON_FIXED_MODE_TYPES (ta);
3102   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3103   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3104   C_COMMON_FIXED_MODE_TYPES_SAT (da);
3105   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3106
3107   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3108      the precision; they have precision set to match their range, but
3109      may use a wider mode to match an ABI.  If we change modes, we may
3110      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
3111      the precision as well, so as to yield correct results for
3112      bit-field types.  C++ does not have these separate bit-field
3113      types, and producing a signed or unsigned variant of an
3114      ENUMERAL_TYPE may cause other problems as well.  */
3115
3116   if (!INTEGRAL_TYPE_P (type)
3117       || TYPE_UNSIGNED (type) == unsignedp)
3118     return type;
3119
3120 #define TYPE_OK(node)                                                       \
3121   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
3122    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3123   if (TYPE_OK (signed_char_type_node))
3124     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3125   if (TYPE_OK (integer_type_node))
3126     return unsignedp ? unsigned_type_node : integer_type_node;
3127   if (TYPE_OK (short_integer_type_node))
3128     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3129   if (TYPE_OK (long_integer_type_node))
3130     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3131   if (TYPE_OK (long_long_integer_type_node))
3132     return (unsignedp ? long_long_unsigned_type_node
3133             : long_long_integer_type_node);
3134   if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3135     return (unsignedp ? int128_unsigned_type_node
3136             : int128_integer_type_node);
3137   if (TYPE_OK (widest_integer_literal_type_node))
3138     return (unsignedp ? widest_unsigned_literal_type_node
3139             : widest_integer_literal_type_node);
3140
3141 #if HOST_BITS_PER_WIDE_INT >= 64
3142   if (TYPE_OK (intTI_type_node))
3143     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3144 #endif
3145   if (TYPE_OK (intDI_type_node))
3146     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3147   if (TYPE_OK (intSI_type_node))
3148     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3149   if (TYPE_OK (intHI_type_node))
3150     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3151   if (TYPE_OK (intQI_type_node))
3152     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3153 #undef TYPE_OK
3154
3155   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3156 }
3157
3158 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
3159
3160 tree
3161 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3162 {
3163   /* Extended integer types of the same width as a standard type have
3164      lesser rank, so those of the same width as int promote to int or
3165      unsigned int and are valid for printf formats expecting int or
3166      unsigned int.  To avoid such special cases, avoid creating
3167      extended integer types for bit-fields if a standard integer type
3168      is available.  */
3169   if (width == TYPE_PRECISION (integer_type_node))
3170     return unsignedp ? unsigned_type_node : integer_type_node;
3171   if (width == TYPE_PRECISION (signed_char_type_node))
3172     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3173   if (width == TYPE_PRECISION (short_integer_type_node))
3174     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3175   if (width == TYPE_PRECISION (long_integer_type_node))
3176     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3177   if (width == TYPE_PRECISION (long_long_integer_type_node))
3178     return (unsignedp ? long_long_unsigned_type_node
3179             : long_long_integer_type_node);
3180   if (int128_integer_type_node
3181       && width == TYPE_PRECISION (int128_integer_type_node))
3182     return (unsignedp ? int128_unsigned_type_node
3183             : int128_integer_type_node);
3184   return build_nonstandard_integer_type (width, unsignedp);
3185 }
3186
3187 /* The C version of the register_builtin_type langhook.  */
3188
3189 void
3190 c_register_builtin_type (tree type, const char* name)
3191 {
3192   tree decl;
3193
3194   decl = build_decl (UNKNOWN_LOCATION,
3195                      TYPE_DECL, get_identifier (name), type);
3196   DECL_ARTIFICIAL (decl) = 1;
3197   if (!TYPE_NAME (type))
3198     TYPE_NAME (type) = decl;
3199   pushdecl (decl);
3200
3201   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3202 }
3203 \f
3204 /* Print an error message for invalid operands to arith operation
3205    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3206    LOCATION is the location of the message.  */
3207
3208 void
3209 binary_op_error (location_t location, enum tree_code code,
3210                  tree type0, tree type1)
3211 {
3212   const char *opname;
3213
3214   switch (code)
3215     {
3216     case PLUS_EXPR:
3217       opname = "+"; break;
3218     case MINUS_EXPR:
3219       opname = "-"; break;
3220     case MULT_EXPR:
3221       opname = "*"; break;
3222     case MAX_EXPR:
3223       opname = "max"; break;
3224     case MIN_EXPR:
3225       opname = "min"; break;
3226     case EQ_EXPR:
3227       opname = "=="; break;
3228     case NE_EXPR:
3229       opname = "!="; break;
3230     case LE_EXPR:
3231       opname = "<="; break;
3232     case GE_EXPR:
3233       opname = ">="; break;
3234     case LT_EXPR:
3235       opname = "<"; break;
3236     case GT_EXPR:
3237       opname = ">"; break;
3238     case LSHIFT_EXPR:
3239       opname = "<<"; break;
3240     case RSHIFT_EXPR:
3241       opname = ">>"; break;
3242     case TRUNC_MOD_EXPR:
3243     case FLOOR_MOD_EXPR:
3244       opname = "%"; break;
3245     case TRUNC_DIV_EXPR:
3246     case FLOOR_DIV_EXPR:
3247       opname = "/"; break;
3248     case BIT_AND_EXPR:
3249       opname = "&"; break;
3250     case BIT_IOR_EXPR:
3251       opname = "|"; break;
3252     case TRUTH_ANDIF_EXPR:
3253       opname = "&&"; break;
3254     case TRUTH_ORIF_EXPR:
3255       opname = "||"; break;
3256     case BIT_XOR_EXPR:
3257       opname = "^"; break;
3258     default:
3259       gcc_unreachable ();
3260     }
3261   error_at (location,
3262             "invalid operands to binary %s (have %qT and %qT)", opname,
3263             type0, type1);
3264 }
3265 \f
3266 /* Subroutine of build_binary_op, used for comparison operations.
3267    See if the operands have both been converted from subword integer types
3268    and, if so, perhaps change them both back to their original type.
3269    This function is also responsible for converting the two operands
3270    to the proper common type for comparison.
3271
3272    The arguments of this function are all pointers to local variables
3273    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3274    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3275
3276    If this function returns nonzero, it means that the comparison has
3277    a constant value.  What this function returns is an expression for
3278    that value.  */
3279
3280 tree
3281 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3282                  enum tree_code *rescode_ptr)
3283 {
3284   tree type;
3285   tree op0 = *op0_ptr;
3286   tree op1 = *op1_ptr;
3287   int unsignedp0, unsignedp1;
3288   int real1, real2;
3289   tree primop0, primop1;
3290   enum tree_code code = *rescode_ptr;
3291
3292   /* Throw away any conversions to wider types
3293      already present in the operands.  */
3294
3295   primop0 = get_narrower (op0, &unsignedp0);
3296   primop1 = get_narrower (op1, &unsignedp1);
3297
3298   /* Handle the case that OP0 does not *contain* a conversion
3299      but it *requires* conversion to FINAL_TYPE.  */
3300
3301   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3302     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3303   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3304     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3305
3306   /* If one of the operands must be floated, we cannot optimize.  */
3307   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3308   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3309
3310   /* If first arg is constant, swap the args (changing operation
3311      so value is preserved), for canonicalization.  Don't do this if
3312      the second arg is 0.  */
3313
3314   if (TREE_CONSTANT (primop0)
3315       && !integer_zerop (primop1) && !real_zerop (primop1)
3316       && !fixed_zerop (primop1))
3317     {
3318       tree tem = primop0;
3319       int temi = unsignedp0;
3320       primop0 = primop1;
3321       primop1 = tem;
3322       tem = op0;
3323       op0 = op1;
3324       op1 = tem;
3325       *op0_ptr = op0;
3326       *op1_ptr = op1;
3327       unsignedp0 = unsignedp1;
3328       unsignedp1 = temi;