OSDN Git Service

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