OSDN Git Service

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