OSDN Git Service

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