Upgrade GCC from 4.4.6-RELEASE to 4.4.7 snapshot 2011-10-25
[dragonfly.git] / contrib / gcc-4.4 / 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 "diagnostic.h"
37 #include "tm_p.h"
38 #include "obstack.h"
39 #include "cpplib.h"
40 #include "target.h"
41 #include "langhooks.h"
42 #include "tree-inline.h"
43 #include "c-tree.h"
44 #include "toplev.h"
45 #include "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 /* Information about how a function name is generated.  */
501 struct fname_var_t
502 {
503   tree *const decl;     /* pointer to the VAR_DECL.  */
504   const unsigned rid;   /* RID number for the identifier.  */
505   const int pretty;     /* How pretty is it? */
506 };
507
508 /* The three ways of getting then name of the current function.  */
509
510 const struct fname_var_t fname_vars[] =
511 {
512   /* C99 compliant __func__, must be first.  */
513   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
514   /* GCC __FUNCTION__ compliant.  */
515   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
516   /* GCC __PRETTY_FUNCTION__ compliant.  */
517   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
518   {NULL, 0, 0},
519 };
520
521 static tree check_case_value (tree);
522 static bool check_case_bounds (tree, tree, tree *, tree *);
523
524 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
525 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
526 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_always_inline_attribute (tree *, tree, tree, int,
532                                             bool *);
533 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
534 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
535 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
536 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
537 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
538 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
539 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
540                                                  bool *);
541 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
542 static tree handle_transparent_union_attribute (tree *, tree, tree,
543                                                 int, bool *);
544 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
545 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
546 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
547 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
548 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
549 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
550 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
551 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
552 static tree handle_visibility_attribute (tree *, tree, tree, int,
553                                          bool *);
554 static tree handle_tls_model_attribute (tree *, tree, tree, int,
555                                         bool *);
556 static tree handle_no_instrument_function_attribute (tree *, tree,
557                                                      tree, int, bool *);
558 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
559 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
560 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
561                                              bool *);
562 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
563 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
564 static tree handle_deprecated_attribute (tree *, tree, tree, int,
565                                          bool *);
566 static tree handle_vector_size_attribute (tree *, tree, tree, int,
567                                           bool *);
568 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
569 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
570 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
571 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
572                                                  bool *);
573 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
574 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
575 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
576 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
577 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
578
579 static void check_function_nonnull (tree, int, tree *);
580 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
581 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
582 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
583 static int resort_field_decl_cmp (const void *, const void *);
584
585 /* Reserved words.  The third field is a mask: keywords are disabled
586    if they match the mask.
587
588    Masks for languages:
589    C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
590    C --std=c99: D_CXXONLY | D_OBJC
591    ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
592    C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
593    C++ --std=c0x: D_CONLY | D_OBJC
594    ObjC++ is like C++ except that D_OBJC is not set
595
596    If -fno-asm is used, D_ASM is added to the mask.  If
597    -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in
598    C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
599    In C with -Wc++-compat, we warn if D_CXXWARN is set.  */
600
601 const struct c_common_resword c_common_reswords[] =
602 {
603   { "_Bool",            RID_BOOL,      D_CONLY },
604   { "_Complex",         RID_COMPLEX,    0 },
605   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
606   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
607   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
608   { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
609   { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
610   { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
611   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
612   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
613   { "__alignof",        RID_ALIGNOF,    0 },
614   { "__alignof__",      RID_ALIGNOF,    0 },
615   { "__asm",            RID_ASM,        0 },
616   { "__asm__",          RID_ASM,        0 },
617   { "__attribute",      RID_ATTRIBUTE,  0 },
618   { "__attribute__",    RID_ATTRIBUTE,  0 },
619   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
620   { "__builtin_offsetof", RID_OFFSETOF, 0 },
621   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
622   { "__builtin_va_arg", RID_VA_ARG,     0 },
623   { "__complex",        RID_COMPLEX,    0 },
624   { "__complex__",      RID_COMPLEX,    0 },
625   { "__const",          RID_CONST,      0 },
626   { "__const__",        RID_CONST,      0 },
627   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
628   { "__extension__",    RID_EXTENSION,  0 },
629   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
630   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
631   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
632   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
633   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
634   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
635   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
636   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
637   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
638   { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },
639   { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },
640   { "__is_class",       RID_IS_CLASS,   D_CXXONLY },
641   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
642   { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },
643   { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },
644   { "__is_pod",         RID_IS_POD,     D_CXXONLY },
645   { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
646   { "__is_union",       RID_IS_UNION,   D_CXXONLY },
647   { "__imag",           RID_IMAGPART,   0 },
648   { "__imag__",         RID_IMAGPART,   0 },
649   { "__inline",         RID_INLINE,     0 },
650   { "__inline__",       RID_INLINE,     0 },
651   { "__label__",        RID_LABEL,      0 },
652   { "__null",           RID_NULL,       0 },
653   { "__real",           RID_REALPART,   0 },
654   { "__real__",         RID_REALPART,   0 },
655   { "__restrict",       RID_RESTRICT,   0 },
656   { "__restrict__",     RID_RESTRICT,   0 },
657   { "__signed",         RID_SIGNED,     0 },
658   { "__signed__",       RID_SIGNED,     0 },
659   { "__thread",         RID_THREAD,     0 },
660   { "__typeof",         RID_TYPEOF,     0 },
661   { "__typeof__",       RID_TYPEOF,     0 },
662   { "__volatile",       RID_VOLATILE,   0 },
663   { "__volatile__",     RID_VOLATILE,   0 },
664   { "asm",              RID_ASM,        D_ASM },
665   { "auto",             RID_AUTO,       0 },
666   { "bool",             RID_BOOL,       D_CXXONLY | D_CXXWARN },
667   { "break",            RID_BREAK,      0 },
668   { "case",             RID_CASE,       0 },
669   { "catch",            RID_CATCH,      D_CXX_OBJC | D_CXXWARN },
670   { "char",             RID_CHAR,       0 },
671   { "char16_t",         RID_CHAR16,     D_CXXONLY | D_CXX0X | D_CXXWARN },
672   { "char32_t",         RID_CHAR32,     D_CXXONLY | D_CXX0X | D_CXXWARN },
673   { "class",            RID_CLASS,      D_CXX_OBJC | D_CXXWARN },
674   { "const",            RID_CONST,      0 },
675   { "const_cast",       RID_CONSTCAST,  D_CXXONLY | D_CXXWARN },
676   { "continue",         RID_CONTINUE,   0 },
677   { "decltype",         RID_DECLTYPE,   D_CXXONLY | D_CXX0X | D_CXXWARN },
678   { "default",          RID_DEFAULT,    0 },
679   { "delete",           RID_DELETE,     D_CXXONLY | D_CXXWARN },
680   { "do",               RID_DO,         0 },
681   { "double",           RID_DOUBLE,     0 },
682   { "dynamic_cast",     RID_DYNCAST,    D_CXXONLY | D_CXXWARN },
683   { "else",             RID_ELSE,       0 },
684   { "enum",             RID_ENUM,       0 },
685   { "explicit",         RID_EXPLICIT,   D_CXXONLY | D_CXXWARN },
686   { "export",           RID_EXPORT,     D_CXXONLY | D_CXXWARN },
687   { "extern",           RID_EXTERN,     0 },
688   { "false",            RID_FALSE,      D_CXXONLY | D_CXXWARN },
689   { "float",            RID_FLOAT,      0 },
690   { "for",              RID_FOR,        0 },
691   { "friend",           RID_FRIEND,     D_CXXONLY | D_CXXWARN },
692   { "goto",             RID_GOTO,       0 },
693   { "if",               RID_IF,         0 },
694   { "inline",           RID_INLINE,     D_EXT89 },
695   { "int",              RID_INT,        0 },
696   { "long",             RID_LONG,       0 },
697   { "mutable",          RID_MUTABLE,    D_CXXONLY | D_CXXWARN },
698   { "namespace",        RID_NAMESPACE,  D_CXXONLY | D_CXXWARN },
699   { "new",              RID_NEW,        D_CXXONLY | D_CXXWARN },
700   { "operator",         RID_OPERATOR,   D_CXXONLY | D_CXXWARN },
701   { "private",          RID_PRIVATE,    D_CXX_OBJC | D_CXXWARN },
702   { "protected",        RID_PROTECTED,  D_CXX_OBJC | D_CXXWARN },
703   { "public",           RID_PUBLIC,     D_CXX_OBJC | D_CXXWARN },
704   { "register",         RID_REGISTER,   0 },
705   { "reinterpret_cast", RID_REINTCAST,  D_CXXONLY | D_CXXWARN },
706   { "restrict",         RID_RESTRICT,   D_CONLY | D_C99 },
707   { "return",           RID_RETURN,     0 },
708   { "short",            RID_SHORT,      0 },
709   { "signed",           RID_SIGNED,     0 },
710   { "sizeof",           RID_SIZEOF,     0 },
711   { "static",           RID_STATIC,     0 },
712   { "static_assert",    RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
713   { "static_cast",      RID_STATCAST,   D_CXXONLY | D_CXXWARN },
714   { "struct",           RID_STRUCT,     0 },
715   { "switch",           RID_SWITCH,     0 },
716   { "template",         RID_TEMPLATE,   D_CXXONLY | D_CXXWARN },
717   { "this",             RID_THIS,       D_CXXONLY | D_CXXWARN },
718   { "throw",            RID_THROW,      D_CXX_OBJC | D_CXXWARN },
719   { "true",             RID_TRUE,       D_CXXONLY | D_CXXWARN },
720   { "try",              RID_TRY,        D_CXX_OBJC | D_CXXWARN },
721   { "typedef",          RID_TYPEDEF,    0 },
722   { "typename",         RID_TYPENAME,   D_CXXONLY | D_CXXWARN },
723   { "typeid",           RID_TYPEID,     D_CXXONLY | D_CXXWARN },
724   { "typeof",           RID_TYPEOF,     D_ASM | D_EXT },
725   { "union",            RID_UNION,      0 },
726   { "unsigned",         RID_UNSIGNED,   0 },
727   { "using",            RID_USING,      D_CXXONLY | D_CXXWARN },
728   { "virtual",          RID_VIRTUAL,    D_CXXONLY | D_CXXWARN },
729   { "void",             RID_VOID,       0 },
730   { "volatile",         RID_VOLATILE,   0 },
731   { "wchar_t",          RID_WCHAR,      D_CXXONLY },
732   { "while",            RID_WHILE,      0 },
733   /* These Objective-C keywords are recognized only immediately after
734      an '@'.  */
735   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
736   { "defs",             RID_AT_DEFS,            D_OBJC },
737   { "encode",           RID_AT_ENCODE,          D_OBJC },
738   { "end",              RID_AT_END,             D_OBJC },
739   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
740   { "interface",        RID_AT_INTERFACE,       D_OBJC },
741   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
742   { "selector",         RID_AT_SELECTOR,        D_OBJC },
743   { "finally",          RID_AT_FINALLY,         D_OBJC },
744   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
745   /* These are recognized only in protocol-qualifier context
746      (see above) */
747   { "bycopy",           RID_BYCOPY,             D_OBJC },
748   { "byref",            RID_BYREF,              D_OBJC },
749   { "in",               RID_IN,                 D_OBJC },
750   { "inout",            RID_INOUT,              D_OBJC },
751   { "oneway",           RID_ONEWAY,             D_OBJC },
752   { "out",              RID_OUT,                D_OBJC },
753 };
754
755 const unsigned int num_c_common_reswords =
756   sizeof c_common_reswords / sizeof (struct c_common_resword);
757
758 /* Table of machine-independent attributes common to all C-like languages.  */
759 const struct attribute_spec c_common_attribute_table[] =
760 {
761   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
762   { "packed",                 0, 0, false, false, false,
763                               handle_packed_attribute },
764   { "nocommon",               0, 0, true,  false, false,
765                               handle_nocommon_attribute },
766   { "common",                 0, 0, true,  false, false,
767                               handle_common_attribute },
768   /* FIXME: logically, noreturn attributes should be listed as
769      "false, true, true" and apply to function types.  But implementing this
770      would require all the places in the compiler that use TREE_THIS_VOLATILE
771      on a decl to identify non-returning functions to be located and fixed
772      to check the function type instead.  */
773   { "noreturn",               0, 0, true,  false, false,
774                               handle_noreturn_attribute },
775   { "volatile",               0, 0, true,  false, false,
776                               handle_noreturn_attribute },
777   { "noinline",               0, 0, true,  false, false,
778                               handle_noinline_attribute },
779   { "always_inline",          0, 0, true,  false, false,
780                               handle_always_inline_attribute },
781   { "gnu_inline",             0, 0, true,  false, false,
782                               handle_gnu_inline_attribute },
783   { "artificial",             0, 0, true,  false, false,
784                               handle_artificial_attribute },
785   { "flatten",                0, 0, true,  false, false,
786                               handle_flatten_attribute },
787   { "used",                   0, 0, true,  false, false,
788                               handle_used_attribute },
789   { "unused",                 0, 0, false, false, false,
790                               handle_unused_attribute },
791   { "externally_visible",     0, 0, true,  false, false,
792                               handle_externally_visible_attribute },
793   /* The same comments as for noreturn attributes apply to const ones.  */
794   { "const",                  0, 0, true,  false, false,
795                               handle_const_attribute },
796   { "transparent_union",      0, 0, false, false, false,
797                               handle_transparent_union_attribute },
798   { "constructor",            0, 1, true,  false, false,
799                               handle_constructor_attribute },
800   { "destructor",             0, 1, true,  false, false,
801                               handle_destructor_attribute },
802   { "mode",                   1, 1, false,  true, false,
803                               handle_mode_attribute },
804   { "section",                1, 1, true,  false, false,
805                               handle_section_attribute },
806   { "aligned",                0, 1, false, false, false,
807                               handle_aligned_attribute },
808   { "weak",                   0, 0, true,  false, false,
809                               handle_weak_attribute },
810   { "alias",                  1, 1, true,  false, false,
811                               handle_alias_attribute },
812   { "weakref",                0, 1, true,  false, false,
813                               handle_weakref_attribute },
814   { "no_instrument_function", 0, 0, true,  false, false,
815                               handle_no_instrument_function_attribute },
816   { "malloc",                 0, 0, true,  false, false,
817                               handle_malloc_attribute },
818   { "returns_twice",          0, 0, true,  false, false,
819                               handle_returns_twice_attribute },
820   { "no_stack_limit",         0, 0, true,  false, false,
821                               handle_no_limit_stack_attribute },
822   { "pure",                   0, 0, true,  false, false,
823                               handle_pure_attribute },
824   /* For internal use (marking of builtins) only.  The name contains space
825      to prevent its usage in source code.  */
826   { "no vops",                0, 0, true,  false, false,
827                               handle_novops_attribute },
828   { "deprecated",             0, 0, false, false, false,
829                               handle_deprecated_attribute },
830   { "vector_size",            1, 1, false, true, false,
831                               handle_vector_size_attribute },
832   { "visibility",             1, 1, false, false, false,
833                               handle_visibility_attribute },
834   { "tls_model",              1, 1, true,  false, false,
835                               handle_tls_model_attribute },
836   { "nonnull",                0, -1, false, true, true,
837                               handle_nonnull_attribute },
838   { "nothrow",                0, 0, true,  false, false,
839                               handle_nothrow_attribute },
840   { "may_alias",              0, 0, false, true, false, NULL },
841   { "cleanup",                1, 1, true, false, false,
842                               handle_cleanup_attribute },
843   { "warn_unused_result",     0, 0, false, true, true,
844                               handle_warn_unused_result_attribute },
845   { "sentinel",               0, 1, false, true, true,
846                               handle_sentinel_attribute },
847   /* For internal use (marking of builtins) only.  The name contains space
848      to prevent its usage in source code.  */
849   { "type generic",           0, 0, false, true, true,
850                               handle_type_generic_attribute },
851   { "alloc_size",             1, 2, false, true, true,
852                               handle_alloc_size_attribute },
853   { "cold",                   0, 0, true,  false, false,
854                               handle_cold_attribute },
855   { "hot",                    0, 0, true,  false, false,
856                               handle_hot_attribute },
857   { "warning",                1, 1, true,  false, false,
858                               handle_error_attribute },
859   { "error",                  1, 1, true,  false, false,
860                               handle_error_attribute },
861   { "target",                 1, -1, true, false, false,
862                               handle_target_attribute },
863   { "optimize",               1, -1, true, false, false,
864                               handle_optimize_attribute },
865   { NULL,                     0, 0, false, false, false, NULL }
866 };
867
868 /* Give the specifications for the format attributes, used by C and all
869    descendants.  */
870
871 const struct attribute_spec c_common_format_attribute_table[] =
872 {
873   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
874   { "format",                 3, 3, false, true,  true,
875                               handle_format_attribute },
876   { "format_arg",             1, 1, false, true,  true,
877                               handle_format_arg_attribute },
878   { NULL,                     0, 0, false, false, false, NULL }
879 };
880
881 /* Push current bindings for the function name VAR_DECLS.  */
882
883 void
884 start_fname_decls (void)
885 {
886   unsigned ix;
887   tree saved = NULL_TREE;
888
889   for (ix = 0; fname_vars[ix].decl; ix++)
890     {
891       tree decl = *fname_vars[ix].decl;
892
893       if (decl)
894         {
895           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
896           *fname_vars[ix].decl = NULL_TREE;
897         }
898     }
899   if (saved || saved_function_name_decls)
900     /* Normally they'll have been NULL, so only push if we've got a
901        stack, or they are non-NULL.  */
902     saved_function_name_decls = tree_cons (saved, NULL_TREE,
903                                            saved_function_name_decls);
904 }
905
906 /* Finish up the current bindings, adding them into the current function's
907    statement tree.  This must be done _before_ finish_stmt_tree is called.
908    If there is no current function, we must be at file scope and no statements
909    are involved. Pop the previous bindings.  */
910
911 void
912 finish_fname_decls (void)
913 {
914   unsigned ix;
915   tree stmts = NULL_TREE;
916   tree stack = saved_function_name_decls;
917
918   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
919     append_to_statement_list (TREE_VALUE (stack), &stmts);
920
921   if (stmts)
922     {
923       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
924
925       if (TREE_CODE (*bodyp) == BIND_EXPR)
926         bodyp = &BIND_EXPR_BODY (*bodyp);
927
928       append_to_statement_list_force (*bodyp, &stmts);
929       *bodyp = stmts;
930     }
931
932   for (ix = 0; fname_vars[ix].decl; ix++)
933     *fname_vars[ix].decl = NULL_TREE;
934
935   if (stack)
936     {
937       /* We had saved values, restore them.  */
938       tree saved;
939
940       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
941         {
942           tree decl = TREE_PURPOSE (saved);
943           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
944
945           *fname_vars[ix].decl = decl;
946         }
947       stack = TREE_CHAIN (stack);
948     }
949   saved_function_name_decls = stack;
950 }
951
952 /* Return the text name of the current function, suitably prettified
953    by PRETTY_P.  Return string must be freed by caller.  */
954
955 const char *
956 fname_as_string (int pretty_p)
957 {
958   const char *name = "top level";
959   char *namep;
960   int vrb = 2, len;
961   cpp_string cstr = { 0, 0 }, strname;
962
963   if (!pretty_p)
964     {
965       name = "";
966       vrb = 0;
967     }
968
969   if (current_function_decl)
970     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
971
972   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
973
974   namep = XNEWVEC (char, len);
975   snprintf (namep, len, "\"%s\"", name);
976   strname.text = (unsigned char *) namep;
977   strname.len = len - 1;
978
979   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
980     {
981       XDELETEVEC (namep);
982       return (const char *) cstr.text;
983     }
984
985   return namep;
986 }
987
988 /* Return the VAR_DECL for a const char array naming the current
989    function. If the VAR_DECL has not yet been created, create it
990    now. RID indicates how it should be formatted and IDENTIFIER_NODE
991    ID is its name (unfortunately C and C++ hold the RID values of
992    keywords in different places, so we can't derive RID from ID in
993    this language independent code. LOC is the location of the
994    function.  */
995
996 tree
997 fname_decl (location_t loc, unsigned int rid, tree id)
998 {
999   unsigned ix;
1000   tree decl = NULL_TREE;
1001
1002   for (ix = 0; fname_vars[ix].decl; ix++)
1003     if (fname_vars[ix].rid == rid)
1004       break;
1005
1006   decl = *fname_vars[ix].decl;
1007   if (!decl)
1008     {
1009       /* If a tree is built here, it would normally have the lineno of
1010          the current statement.  Later this tree will be moved to the
1011          beginning of the function and this line number will be wrong.
1012          To avoid this problem set the lineno to 0 here; that prevents
1013          it from appearing in the RTL.  */
1014       tree stmts;
1015       location_t saved_location = input_location;
1016       input_location = UNKNOWN_LOCATION;
1017
1018       stmts = push_stmt_list ();
1019       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1020       stmts = pop_stmt_list (stmts);
1021       if (!IS_EMPTY_STMT (stmts))
1022         saved_function_name_decls
1023           = tree_cons (decl, stmts, saved_function_name_decls);
1024       *fname_vars[ix].decl = decl;
1025       input_location = saved_location;
1026     }
1027   if (!ix && !current_function_decl)
1028     pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1029
1030   return decl;
1031 }
1032
1033 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
1034
1035 tree
1036 fix_string_type (tree value)
1037 {
1038   int length = TREE_STRING_LENGTH (value);
1039   int nchars;
1040   tree e_type, i_type, a_type;
1041
1042   /* Compute the number of elements, for the array type.  */
1043   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1044     {
1045       nchars = length;
1046       e_type = char_type_node;
1047     }
1048   else if (TREE_TYPE (value) == char16_array_type_node)
1049     {
1050       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1051       e_type = char16_type_node;
1052     }
1053   else if (TREE_TYPE (value) == char32_array_type_node)
1054     {
1055       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1056       e_type = char32_type_node;
1057     }
1058   else
1059     {
1060       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1061       e_type = wchar_type_node;
1062     }
1063
1064   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
1065      limit in C++98 Annex B is very large (65536) and is not normative,
1066      so we do not diagnose it (warn_overlength_strings is forced off
1067      in c_common_post_options).  */
1068   if (warn_overlength_strings)
1069     {
1070       const int nchars_max = flag_isoc99 ? 4095 : 509;
1071       const int relevant_std = flag_isoc99 ? 99 : 90;
1072       if (nchars - 1 > nchars_max)
1073         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
1074            separate the %d from the 'C'.  'ISO' should not be
1075            translated, but it may be moved after 'C%d' in languages
1076            where modifiers follow nouns.  */
1077         pedwarn (input_location, OPT_Woverlength_strings,
1078                  "string length %qd is greater than the length %qd "
1079                  "ISO C%d compilers are required to support",
1080                  nchars - 1, nchars_max, relevant_std);
1081     }
1082
1083   /* Create the array type for the string constant.  The ISO C++
1084      standard says that a string literal has type `const char[N]' or
1085      `const wchar_t[N]'.  We use the same logic when invoked as a C
1086      front-end with -Wwrite-strings.
1087      ??? We should change the type of an expression depending on the
1088      state of a warning flag.  We should just be warning -- see how
1089      this is handled in the C++ front-end for the deprecated implicit
1090      conversion from string literals to `char*' or `wchar_t*'.
1091
1092      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1093      array type being the unqualified version of that type.
1094      Therefore, if we are constructing an array of const char, we must
1095      construct the matching unqualified array type first.  The C front
1096      end does not require this, but it does no harm, so we do it
1097      unconditionally.  */
1098   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1099   a_type = build_array_type (e_type, i_type);
1100   if (c_dialect_cxx() || warn_write_strings)
1101     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1102
1103   TREE_TYPE (value) = a_type;
1104   TREE_CONSTANT (value) = 1;
1105   TREE_READONLY (value) = 1;
1106   TREE_STATIC (value) = 1;
1107   return value;
1108 }
1109 \f
1110 /* Print a warning if a constant expression had overflow in folding.
1111    Invoke this function on every expression that the language
1112    requires to be a constant expression.
1113    Note the ANSI C standard says it is erroneous for a
1114    constant expression to overflow.  */
1115
1116 void
1117 constant_expression_warning (tree value)
1118 {
1119   if (warn_overflow && pedantic 
1120       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1121           || TREE_CODE (value) == FIXED_CST
1122           || TREE_CODE (value) == VECTOR_CST
1123           || TREE_CODE (value) == COMPLEX_CST)
1124       && TREE_OVERFLOW (value))
1125     pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1126 }
1127
1128 /* The same as above but print an unconditional error.  */
1129 void
1130 constant_expression_error (tree value)
1131 {
1132   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1133        || TREE_CODE (value) == FIXED_CST
1134        || TREE_CODE (value) == VECTOR_CST
1135        || TREE_CODE (value) == COMPLEX_CST)
1136       && TREE_OVERFLOW (value))
1137     error ("overflow in constant expression");
1138 }
1139
1140 /* Print a warning if an expression had overflow in folding and its
1141    operands hadn't.
1142
1143    Invoke this function on every expression that
1144    (1) appears in the source code, and
1145    (2) is a constant expression that overflowed, and
1146    (3) is not already checked by convert_and_check;
1147    however, do not invoke this function on operands of explicit casts
1148    or when the expression is the result of an operator and any operand
1149    already overflowed.  */
1150
1151 void
1152 overflow_warning (tree value)
1153 {
1154   if (skip_evaluation) return;
1155
1156   switch (TREE_CODE (value))
1157     {
1158     case INTEGER_CST:
1159       warning (OPT_Woverflow, "integer overflow in expression");
1160       break;
1161       
1162     case REAL_CST:
1163       warning (OPT_Woverflow, "floating point overflow in expression");
1164       break;
1165       
1166     case FIXED_CST:
1167       warning (OPT_Woverflow, "fixed-point overflow in expression");
1168       break;
1169
1170     case VECTOR_CST:
1171       warning (OPT_Woverflow, "vector overflow in expression");
1172       break;
1173       
1174     case COMPLEX_CST:
1175       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1176         warning (OPT_Woverflow, "complex integer overflow in expression");
1177       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1178         warning (OPT_Woverflow, "complex floating point overflow in expression");
1179       break;
1180
1181     default:
1182       break;
1183     }
1184 }
1185
1186
1187 /* Warn about use of a logical || / && operator being used in a
1188    context where it is likely that the bitwise equivalent was intended
1189    by the programmer. CODE is the TREE_CODE of the operator, ARG1
1190    and ARG2 the arguments.  */
1191
1192 void
1193 warn_logical_operator (enum tree_code code, tree arg1, tree
1194     arg2)
1195 {
1196   switch (code)
1197     {
1198       case TRUTH_ANDIF_EXPR:
1199       case TRUTH_ORIF_EXPR:
1200       case TRUTH_OR_EXPR:
1201       case TRUTH_AND_EXPR:
1202         if (!TREE_NO_WARNING (arg1)
1203             && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1204             && !CONSTANT_CLASS_P (arg1)
1205             && TREE_CODE (arg2) == INTEGER_CST
1206             && !integer_zerop (arg2))
1207           {
1208             warning (OPT_Wlogical_op,
1209                      "logical %<%s%> with non-zero constant "
1210                      "will always evaluate as true",
1211                      ((code == TRUTH_ANDIF_EXPR)
1212                       || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1213             TREE_NO_WARNING (arg1) = true;
1214           }
1215         break;
1216       default:
1217         break;
1218     }
1219 }
1220
1221
1222 /* Print a warning about casts that might indicate violation
1223    of strict aliasing rules if -Wstrict-aliasing is used and
1224    strict aliasing mode is in effect. OTYPE is the original
1225    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1226
1227 bool
1228 strict_aliasing_warning (tree otype, tree type, tree expr)
1229 {
1230   if (!(flag_strict_aliasing
1231         && POINTER_TYPE_P (type)
1232         && POINTER_TYPE_P (otype)
1233         && !VOID_TYPE_P (TREE_TYPE (type)))
1234       /* If the type we are casting to is a ref-all pointer
1235          dereferencing it is always valid.  */
1236       || TYPE_REF_CAN_ALIAS_ALL (type))
1237     return false;
1238
1239   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1240       && (DECL_P (TREE_OPERAND (expr, 0))
1241           || handled_component_p (TREE_OPERAND (expr, 0))))
1242     {
1243       /* Casting the address of an object to non void pointer. Warn
1244          if the cast breaks type based aliasing.  */
1245       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1246         {
1247           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1248                    "might break strict-aliasing rules");
1249           return true;
1250         }
1251       else
1252         {
1253           /* warn_strict_aliasing >= 3.   This includes the default (3).  
1254              Only warn if the cast is dereferenced immediately.  */
1255           alias_set_type set1 =
1256             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1257           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1258
1259           if (set1 != set2 && set2 != 0
1260               && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1261             {
1262               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1263                        "pointer will break strict-aliasing rules");
1264               return true;
1265             }
1266           else if (warn_strict_aliasing == 2
1267                    && !alias_sets_must_conflict_p (set1, set2))
1268             {
1269               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1270                        "pointer might break strict-aliasing rules");
1271               return true;
1272             }
1273         }
1274     }
1275   else
1276     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1277       {
1278         /* At this level, warn for any conversions, even if an address is
1279            not taken in the same statement.  This will likely produce many
1280            false positives, but could be useful to pinpoint problems that
1281            are not revealed at higher levels.  */
1282         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1283         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1284         if (!COMPLETE_TYPE_P (type)
1285             || !alias_sets_must_conflict_p (set1, set2))
1286           {
1287             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1288                      "pointer might break strict-aliasing rules");
1289             return true;
1290           }
1291       }
1292
1293   return false;
1294 }
1295
1296 /* Warn for unlikely, improbable, or stupid DECL declarations
1297    of `main'.  */
1298
1299 void
1300 check_main_parameter_types (tree decl)
1301 {
1302   tree args;
1303   int argct = 0;
1304
1305   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1306       args = TREE_CHAIN (args))
1307    {
1308      tree type = args ? TREE_VALUE (args) : 0;
1309
1310      if (type == void_type_node || type == error_mark_node )
1311        break;
1312
1313      ++argct;
1314      switch (argct)
1315        {
1316        case 1:
1317          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1318            pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>", 
1319                     decl);
1320          break;
1321
1322        case 2:
1323          if (TREE_CODE (type) != POINTER_TYPE
1324              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1325              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1326                  != char_type_node))
1327            pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1328                     decl);
1329          break;
1330
1331        case 3:
1332          if (TREE_CODE (type) != POINTER_TYPE
1333              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1334              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1335                  != char_type_node))
1336            pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1337                     "%<char **%>", decl);
1338          break;
1339        }
1340    }
1341
1342   /* It is intentional that this message does not mention the third
1343     argument because it's only mentioned in an appendix of the
1344     standard.  */
1345   if (argct > 0 && (argct < 2 || argct > 3))
1346     pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1347 }
1348
1349 /* True if pointers to distinct types T1 and T2 can be converted to
1350    each other without an explicit cast.  Only returns true for opaque
1351    vector types.  */
1352 bool
1353 vector_targets_convertible_p (const_tree t1, const_tree t2)
1354 {
1355   if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1356       && (targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1357       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1358     return true;
1359
1360   return false;
1361 }
1362
1363 /* True if vector types T1 and T2 can be converted to each other
1364    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1365    can only be converted with -flax-vector-conversions yet that is not
1366    in effect, emit a note telling the user about that option if such
1367    a note has not previously been emitted.  */
1368 bool
1369 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1370 {
1371   static bool emitted_lax_note = false;
1372   bool convertible_lax;
1373
1374   if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1375       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1376     return true;
1377
1378   convertible_lax =
1379     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1380      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1381          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1382      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1383          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1384
1385   if (!convertible_lax || flag_lax_vector_conversions)
1386     return convertible_lax;
1387
1388   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1389       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1390     return true;
1391
1392   if (emit_lax_note && !emitted_lax_note)
1393     {
1394       emitted_lax_note = true;
1395       inform (input_location, "use -flax-vector-conversions to permit "
1396               "conversions between vectors with differing "
1397               "element types or numbers of subparts");
1398     }
1399
1400   return false;
1401 }
1402
1403 /* This is a helper function of build_binary_op.
1404
1405    For certain operations if both args were extended from the same
1406    smaller type, do the arithmetic in that type and then extend.
1407
1408    BITWISE indicates a bitwise operation.
1409    For them, this optimization is safe only if
1410    both args are zero-extended or both are sign-extended.
1411    Otherwise, we might change the result.
1412    Eg, (short)-1 | (unsigned short)-1 is (int)-1
1413    but calculated in (unsigned short) it would be (unsigned short)-1.  
1414 */
1415 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1416 {
1417   int unsigned0, unsigned1;
1418   tree arg0, arg1;
1419   int uns;
1420   tree type;
1421
1422   /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
1423      excessive narrowing when we call get_narrower below.  For
1424      example, suppose that OP0 is of unsigned int extended
1425      from signed char and that RESULT_TYPE is long long int.
1426      If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1427      like
1428      
1429      (long long int) (unsigned int) signed_char
1430
1431      which get_narrower would narrow down to
1432      
1433      (unsigned int) signed char
1434      
1435      If we do not cast OP0 first, get_narrower would return
1436      signed_char, which is inconsistent with the case of the
1437      explicit cast.  */
1438   op0 = convert (result_type, op0);
1439   op1 = convert (result_type, op1);
1440
1441   arg0 = get_narrower (op0, &unsigned0);
1442   arg1 = get_narrower (op1, &unsigned1);
1443
1444   /* UNS is 1 if the operation to be done is an unsigned one.  */
1445   uns = TYPE_UNSIGNED (result_type);
1446
1447   /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1448      but it *requires* conversion to FINAL_TYPE.  */
1449   
1450   if ((TYPE_PRECISION (TREE_TYPE (op0))
1451        == TYPE_PRECISION (TREE_TYPE (arg0)))
1452       && TREE_TYPE (op0) != result_type)
1453     unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1454   if ((TYPE_PRECISION (TREE_TYPE (op1))
1455        == TYPE_PRECISION (TREE_TYPE (arg1)))
1456       && TREE_TYPE (op1) != result_type)
1457     unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1458   
1459   /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
1460   
1461   /* For bitwise operations, signedness of nominal type
1462      does not matter.  Consider only how operands were extended.  */
1463   if (bitwise)
1464     uns = unsigned0;
1465   
1466   /* Note that in all three cases below we refrain from optimizing
1467      an unsigned operation on sign-extended args.
1468      That would not be valid.  */
1469   
1470   /* Both args variable: if both extended in same way
1471      from same width, do it in that width.
1472      Do it unsigned if args were zero-extended.  */
1473   if ((TYPE_PRECISION (TREE_TYPE (arg0))
1474        < TYPE_PRECISION (result_type))
1475       && (TYPE_PRECISION (TREE_TYPE (arg1))
1476           == TYPE_PRECISION (TREE_TYPE (arg0)))
1477       && unsigned0 == unsigned1
1478       && (unsigned0 || !uns))
1479     return c_common_signed_or_unsigned_type
1480       (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1481
1482   else if (TREE_CODE (arg0) == INTEGER_CST
1483            && (unsigned1 || !uns)
1484            && (TYPE_PRECISION (TREE_TYPE (arg1))
1485                < TYPE_PRECISION (result_type))
1486            && (type
1487                = c_common_signed_or_unsigned_type (unsigned1,
1488                                                    TREE_TYPE (arg1)))
1489            && !POINTER_TYPE_P (type)
1490            && int_fits_type_p (arg0, type))
1491     return type;
1492
1493   else if (TREE_CODE (arg1) == INTEGER_CST
1494            && (unsigned0 || !uns)
1495            && (TYPE_PRECISION (TREE_TYPE (arg0))
1496                < TYPE_PRECISION (result_type))
1497            && (type
1498                = c_common_signed_or_unsigned_type (unsigned0,
1499                                                    TREE_TYPE (arg0)))
1500            && !POINTER_TYPE_P (type)
1501            && int_fits_type_p (arg1, type))
1502     return type;
1503
1504   return result_type;
1505 }
1506
1507 /* Warns if the conversion of EXPR to TYPE may alter a value.
1508    This is a helper function for warnings_for_convert_and_check.  */
1509
1510 static void
1511 conversion_warning (tree type, tree expr)
1512 {
1513   bool give_warning = false;
1514
1515   int i;
1516   const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1517   tree expr_type = TREE_TYPE (expr);
1518
1519   if (!warn_conversion && !warn_sign_conversion)
1520     return;
1521
1522   /* If any operand is artificial, then this expression was generated
1523      by the compiler and we do not warn.  */
1524   for (i = 0; i < expr_num_operands; i++)
1525     {
1526       tree op = TREE_OPERAND (expr, i);
1527       if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1528         return;
1529     }
1530
1531   switch (TREE_CODE (expr))
1532     {
1533     case EQ_EXPR:
1534     case NE_EXPR:
1535     case LE_EXPR:
1536     case GE_EXPR:
1537     case LT_EXPR:
1538     case GT_EXPR:
1539     case TRUTH_ANDIF_EXPR:
1540     case TRUTH_ORIF_EXPR:
1541     case TRUTH_AND_EXPR:
1542     case TRUTH_OR_EXPR:
1543     case TRUTH_XOR_EXPR:
1544     case TRUTH_NOT_EXPR:
1545       /* Conversion from boolean to a signed:1 bit-field (which only
1546          can hold the values 0 and -1) doesn't lose information - but
1547          it does change the value.  */
1548       if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type)) 
1549         warning (OPT_Wconversion,
1550                  "conversion to %qT from boolean expression", type);
1551       return;
1552
1553     case REAL_CST:
1554     case INTEGER_CST:
1555
1556       /* Warn for real constant that is not an exact integer converted
1557          to integer type.  */
1558       if (TREE_CODE (expr_type) == REAL_TYPE
1559           && TREE_CODE (type) == INTEGER_TYPE)
1560         {
1561           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1562             give_warning = true;
1563         }
1564       /* Warn for an integer constant that does not fit into integer type.  */
1565       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1566                && TREE_CODE (type) == INTEGER_TYPE
1567                && !int_fits_type_p (expr, type))
1568         {
1569           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type) 
1570               && tree_int_cst_sgn (expr) < 0)
1571             warning (OPT_Wsign_conversion,
1572                      "negative integer implicitly converted to unsigned type");
1573           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1574             warning (OPT_Wsign_conversion,  "conversion of unsigned constant "
1575                      "value to negative integer");
1576           else
1577             give_warning = true;
1578         }
1579       else if (TREE_CODE (type) == REAL_TYPE)
1580         {
1581           /* Warn for an integer constant that does not fit into real type.  */
1582           if (TREE_CODE (expr_type) == INTEGER_TYPE)
1583             {
1584               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1585               if (!exact_real_truncate (TYPE_MODE (type), &a))
1586                 give_warning = true;
1587             }
1588           /* Warn for a real constant that does not fit into a smaller
1589              real type.  */
1590           else if (TREE_CODE (expr_type) == REAL_TYPE
1591                    && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1592             {
1593               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
1594               if (!exact_real_truncate (TYPE_MODE (type), &a))
1595                 give_warning = true;
1596             }
1597         }
1598
1599       if (give_warning)
1600         warning (OPT_Wconversion,
1601                  "conversion to %qT alters %qT constant value",
1602                  type, expr_type);
1603
1604       return;
1605
1606     case COND_EXPR:
1607       {
1608         /* In case of COND_EXPR, if both operands are constants or
1609            COND_EXPR, then we do not care about the type of COND_EXPR,
1610            only about the conversion of each operand.  */
1611         tree op1 = TREE_OPERAND (expr, 1);
1612         tree op2 = TREE_OPERAND (expr, 2);
1613
1614         if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST 
1615              || TREE_CODE (op1) == COND_EXPR)
1616             && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
1617                 || TREE_CODE (op2) == COND_EXPR))
1618           {
1619             conversion_warning (type, op1);
1620             conversion_warning (type, op2);
1621             return;
1622           }
1623         /* Fall through.  */
1624       }
1625
1626     default: /* 'expr' is not a constant.  */
1627
1628       /* Warn for real types converted to integer types.  */
1629       if (TREE_CODE (expr_type) == REAL_TYPE
1630           && TREE_CODE (type) == INTEGER_TYPE)
1631         give_warning = true;
1632
1633       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1634                && TREE_CODE (type) == INTEGER_TYPE)
1635         {
1636           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
1637           expr = get_unwidened (expr, 0);
1638           expr_type = TREE_TYPE (expr);
1639
1640           /* Don't warn for short y; short x = ((int)y & 0xff);  */
1641           if (TREE_CODE (expr) == BIT_AND_EXPR 
1642                 || TREE_CODE (expr) == BIT_IOR_EXPR 
1643               || TREE_CODE (expr) == BIT_XOR_EXPR)
1644             {
1645               /* If both args were extended from a shortest type,
1646                  use that type if that is safe.  */
1647               expr_type = shorten_binary_op (expr_type, 
1648                                              TREE_OPERAND (expr, 0), 
1649                                              TREE_OPERAND (expr, 1), 
1650                                              /* bitwise */1);
1651
1652               if (TREE_CODE (expr) == BIT_AND_EXPR)
1653                 {
1654                   tree op0 = TREE_OPERAND (expr, 0);
1655                   tree op1 = TREE_OPERAND (expr, 1);
1656                   bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1657                   bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1658
1659                   /* If one of the operands is a non-negative constant
1660                      that fits in the target type, then the type of the
1661                      other operand does not matter. */
1662                   if ((TREE_CODE (op0) == INTEGER_CST
1663                        && int_fits_type_p (op0, c_common_signed_type (type))
1664                        && int_fits_type_p (op0, c_common_unsigned_type (type)))
1665                       || (TREE_CODE (op1) == INTEGER_CST
1666                           && int_fits_type_p (op1, c_common_signed_type (type))
1667                           && int_fits_type_p (op1, 
1668                                               c_common_unsigned_type (type))))
1669                     return;
1670                   /* If constant is unsigned and fits in the target
1671                      type, then the result will also fit.  */
1672                   else if ((TREE_CODE (op0) == INTEGER_CST
1673                             && unsigned0 
1674                             && int_fits_type_p (op0, type))
1675                            || (TREE_CODE (op1) == INTEGER_CST
1676                                && unsigned1
1677                                && int_fits_type_p (op1, type)))
1678                     return;
1679                 }
1680             }
1681           /* Warn for integer types converted to smaller integer types.  */
1682           if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type)) 
1683             give_warning = true;
1684
1685           /* When they are the same width but different signedness,
1686              then the value may change.  */
1687           else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
1688                     && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
1689                    /* Even when converted to a bigger type, if the type is
1690                       unsigned but expr is signed, then negative values
1691                       will be changed.  */
1692                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
1693             warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
1694                      "may change the sign of the result",
1695                      type, expr_type);
1696         }
1697
1698       /* Warn for integer types converted to real types if and only if
1699          all the range of values of the integer type cannot be
1700          represented by the real type.  */
1701       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1702                && TREE_CODE (type) == REAL_TYPE)
1703         {
1704           tree type_low_bound = TYPE_MIN_VALUE (expr_type);
1705           tree type_high_bound = TYPE_MAX_VALUE (expr_type);
1706           REAL_VALUE_TYPE real_low_bound 
1707             = real_value_from_int_cst (0, type_low_bound);
1708           REAL_VALUE_TYPE real_high_bound 
1709             = real_value_from_int_cst (0, type_high_bound);
1710
1711           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
1712               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
1713             give_warning = true;
1714         }
1715
1716       /* Warn for real types converted to smaller real types.  */
1717       else if (TREE_CODE (expr_type) == REAL_TYPE
1718                && TREE_CODE (type) == REAL_TYPE
1719                && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1720         give_warning = true;
1721
1722
1723       if (give_warning)
1724         warning (OPT_Wconversion,
1725                  "conversion to %qT from %qT may alter its value",
1726                  type, expr_type);
1727     }
1728 }
1729
1730 /* Produce warnings after a conversion. RESULT is the result of
1731    converting EXPR to TYPE.  This is a helper function for
1732    convert_and_check and cp_convert_and_check.  */
1733
1734 void
1735 warnings_for_convert_and_check (tree type, tree expr, tree result)
1736 {
1737   if (TREE_CODE (expr) == INTEGER_CST
1738       && (TREE_CODE (type) == INTEGER_TYPE
1739           || TREE_CODE (type) == ENUMERAL_TYPE)
1740       && !int_fits_type_p (expr, type))
1741     {
1742       /* Do not diagnose overflow in a constant expression merely
1743          because a conversion overflowed.  */
1744       if (TREE_OVERFLOW (result))
1745         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
1746
1747       if (TYPE_UNSIGNED (type))
1748         {
1749           /* This detects cases like converting -129 or 256 to
1750              unsigned char.  */
1751           if (!int_fits_type_p (expr, c_common_signed_type (type)))
1752             warning (OPT_Woverflow,
1753                      "large integer implicitly truncated to unsigned type");
1754           else
1755             conversion_warning (type, expr);
1756         }
1757       else if (!int_fits_type_p (expr, c_common_unsigned_type (type))) 
1758         warning (OPT_Woverflow,
1759                  "overflow in implicit constant conversion");
1760       /* No warning for converting 0x80000000 to int.  */
1761       else if (pedantic
1762                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
1763                    || TYPE_PRECISION (TREE_TYPE (expr))
1764                    != TYPE_PRECISION (type)))
1765         warning (OPT_Woverflow,
1766                  "overflow in implicit constant conversion");
1767
1768       else
1769         conversion_warning (type, expr);
1770     }
1771   else if ((TREE_CODE (result) == INTEGER_CST
1772             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
1773     warning (OPT_Woverflow,
1774              "overflow in implicit constant conversion");
1775   else
1776     conversion_warning (type, expr);
1777 }
1778
1779
1780 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1781    Invoke this function on every expression that is converted implicitly,
1782    i.e. because of language rules and not because of an explicit cast.  */
1783
1784 tree
1785 convert_and_check (tree type, tree expr)
1786 {
1787   tree result;
1788
1789   if (TREE_TYPE (expr) == type)
1790     return expr;
1791   
1792   result = convert (type, expr);
1793
1794   if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
1795     warnings_for_convert_and_check (type, expr, result);
1796
1797   return result;
1798 }
1799 \f
1800 /* A node in a list that describes references to variables (EXPR), which are
1801    either read accesses if WRITER is zero, or write accesses, in which case
1802    WRITER is the parent of EXPR.  */
1803 struct tlist
1804 {
1805   struct tlist *next;
1806   tree expr, writer;
1807 };
1808
1809 /* Used to implement a cache the results of a call to verify_tree.  We only
1810    use this for SAVE_EXPRs.  */
1811 struct tlist_cache
1812 {
1813   struct tlist_cache *next;
1814   struct tlist *cache_before_sp;
1815   struct tlist *cache_after_sp;
1816   tree expr;
1817 };
1818
1819 /* Obstack to use when allocating tlist structures, and corresponding
1820    firstobj.  */
1821 static struct obstack tlist_obstack;
1822 static char *tlist_firstobj = 0;
1823
1824 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1825    warnings.  */
1826 static struct tlist *warned_ids;
1827 /* SAVE_EXPRs need special treatment.  We process them only once and then
1828    cache the results.  */
1829 static struct tlist_cache *save_expr_cache;
1830
1831 static void add_tlist (struct tlist **, struct tlist *, tree, int);
1832 static void merge_tlist (struct tlist **, struct tlist *, int);
1833 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1834 static int warning_candidate_p (tree);
1835 static void warn_for_collisions (struct tlist *);
1836 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1837 static struct tlist *new_tlist (struct tlist *, tree, tree);
1838
1839 /* Create a new struct tlist and fill in its fields.  */
1840 static struct tlist *
1841 new_tlist (struct tlist *next, tree t, tree writer)
1842 {
1843   struct tlist *l;
1844   l = XOBNEW (&tlist_obstack, struct tlist);
1845   l->next = next;
1846   l->expr = t;
1847   l->writer = writer;
1848   return l;
1849 }
1850
1851 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1852    is nonnull, we ignore any node we find which has a writer equal to it.  */
1853
1854 static void
1855 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1856 {
1857   while (add)
1858     {
1859       struct tlist *next = add->next;
1860       if (!copy)
1861         add->next = *to;
1862       if (!exclude_writer || add->writer != exclude_writer)
1863         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1864       add = next;
1865     }
1866 }
1867
1868 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1869    each variable that already exists in TO, no new node is added; however if
1870    there is a write access recorded in ADD, and an occurrence on TO is only
1871    a read access, then the occurrence in TO will be modified to record the
1872    write.  */
1873
1874 static void
1875 merge_tlist (struct tlist **to, struct tlist *add, int copy)
1876 {
1877   struct tlist **end = to;
1878
1879   while (*end)
1880     end = &(*end)->next;
1881
1882   while (add)
1883     {
1884       int found = 0;
1885       struct tlist *tmp2;
1886       struct tlist *next = add->next;
1887
1888       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1889         if (tmp2->expr == add->expr)
1890           {
1891             found = 1;
1892             if (!tmp2->writer)
1893               tmp2->writer = add->writer;
1894           }
1895       if (!found)
1896         {
1897           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1898           end = &(*end)->next;
1899           *end = 0;
1900         }
1901       add = next;
1902     }
1903 }
1904
1905 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1906    references in list LIST conflict with it, excluding reads if ONLY writers
1907    is nonzero.  */
1908
1909 static void
1910 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1911                        int only_writes)
1912 {
1913   struct tlist *tmp;
1914
1915   /* Avoid duplicate warnings.  */
1916   for (tmp = warned_ids; tmp; tmp = tmp->next)
1917     if (tmp->expr == written)
1918       return;
1919
1920   while (list)
1921     {
1922       if (list->expr == written
1923           && list->writer != writer
1924           && (!only_writes || list->writer)
1925           && DECL_NAME (list->expr))
1926         {
1927           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1928           warning_at (EXPR_HAS_LOCATION (writer)
1929                       ? EXPR_LOCATION (writer) : input_location,
1930                       OPT_Wsequence_point, "operation on %qE may be undefined",
1931                       list->expr);
1932         }
1933       list = list->next;
1934     }
1935 }
1936
1937 /* Given a list LIST of references to variables, find whether any of these
1938    can cause conflicts due to missing sequence points.  */
1939
1940 static void
1941 warn_for_collisions (struct tlist *list)
1942 {
1943   struct tlist *tmp;
1944
1945   for (tmp = list; tmp; tmp = tmp->next)
1946     {
1947       if (tmp->writer)
1948         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1949     }
1950 }
1951
1952 /* Return nonzero if X is a tree that can be verified by the sequence point
1953    warnings.  */
1954 static int
1955 warning_candidate_p (tree x)
1956 {
1957   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1958 }
1959
1960 /* Walk the tree X, and record accesses to variables.  If X is written by the
1961    parent tree, WRITER is the parent.
1962    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1963    expression or its only operand forces a sequence point, then everything up
1964    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1965    in PNO_SP.
1966    Once we return, we will have emitted warnings if any subexpression before
1967    such a sequence point could be undefined.  On a higher level, however, the
1968    sequence point may not be relevant, and we'll merge the two lists.
1969
1970    Example: (b++, a) + b;
1971    The call that processes the COMPOUND_EXPR will store the increment of B
1972    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1973    processes the PLUS_EXPR will need to merge the two lists so that
1974    eventually, all accesses end up on the same list (and we'll warn about the
1975    unordered subexpressions b++ and b.
1976
1977    A note on merging.  If we modify the former example so that our expression
1978    becomes
1979      (b++, b) + a
1980    care must be taken not simply to add all three expressions into the final
1981    PNO_SP list.  The function merge_tlist takes care of that by merging the
1982    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1983    way, so that no more than one access to B is recorded.  */
1984
1985 static void
1986 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1987              tree writer)
1988 {
1989   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1990   enum tree_code code;
1991   enum tree_code_class cl;
1992
1993   /* X may be NULL if it is the operand of an empty statement expression
1994      ({ }).  */
1995   if (x == NULL)
1996     return;
1997
1998  restart:
1999   code = TREE_CODE (x);
2000   cl = TREE_CODE_CLASS (code);
2001
2002   if (warning_candidate_p (x))
2003     {
2004       *pno_sp = new_tlist (*pno_sp, x, writer);
2005       return;
2006     }
2007
2008   switch (code)
2009     {
2010     case CONSTRUCTOR:
2011       return;
2012
2013     case COMPOUND_EXPR:
2014     case TRUTH_ANDIF_EXPR:
2015     case TRUTH_ORIF_EXPR:
2016       tmp_before = tmp_nosp = tmp_list3 = 0;
2017       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2018       warn_for_collisions (tmp_nosp);
2019       merge_tlist (pbefore_sp, tmp_before, 0);
2020       merge_tlist (pbefore_sp, tmp_nosp, 0);
2021       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2022       merge_tlist (pbefore_sp, tmp_list3, 0);
2023       return;
2024
2025     case COND_EXPR:
2026       tmp_before = tmp_list2 = 0;
2027       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2028       warn_for_collisions (tmp_list2);
2029       merge_tlist (pbefore_sp, tmp_before, 0);
2030       merge_tlist (pbefore_sp, tmp_list2, 1);
2031
2032       tmp_list3 = tmp_nosp = 0;
2033       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2034       warn_for_collisions (tmp_nosp);
2035       merge_tlist (pbefore_sp, tmp_list3, 0);
2036
2037       tmp_list3 = tmp_list2 = 0;
2038       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2039       warn_for_collisions (tmp_list2);
2040       merge_tlist (pbefore_sp, tmp_list3, 0);
2041       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2042          two first, to avoid warning for (a ? b++ : b++).  */
2043       merge_tlist (&tmp_nosp, tmp_list2, 0);
2044       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2045       return;
2046
2047     case PREDECREMENT_EXPR:
2048     case PREINCREMENT_EXPR:
2049     case POSTDECREMENT_EXPR:
2050     case POSTINCREMENT_EXPR:
2051       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2052       return;
2053
2054     case MODIFY_EXPR:
2055       tmp_before = tmp_nosp = tmp_list3 = 0;
2056       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2057       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2058       /* Expressions inside the LHS are not ordered wrt. the sequence points
2059          in the RHS.  Example:
2060            *a = (a++, 2)
2061          Despite the fact that the modification of "a" is in the before_sp
2062          list (tmp_before), it conflicts with the use of "a" in the LHS.
2063          We can handle this by adding the contents of tmp_list3
2064          to those of tmp_before, and redoing the collision warnings for that
2065          list.  */
2066       add_tlist (&tmp_before, tmp_list3, x, 1);
2067       warn_for_collisions (tmp_before);
2068       /* Exclude the LHS itself here; we first have to merge it into the
2069          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
2070          didn't exclude the LHS, we'd get it twice, once as a read and once
2071          as a write.  */
2072       add_tlist (pno_sp, tmp_list3, x, 0);
2073       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2074
2075       merge_tlist (pbefore_sp, tmp_before, 0);
2076       if (warning_candidate_p (TREE_OPERAND (x, 0)))
2077         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2078       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2079       return;
2080
2081     case CALL_EXPR:
2082       /* We need to warn about conflicts among arguments and conflicts between
2083          args and the function address.  Side effects of the function address,
2084          however, are not ordered by the sequence point of the call.  */
2085       {
2086         call_expr_arg_iterator iter;
2087         tree arg;
2088         tmp_before = tmp_nosp = 0; 
2089         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2090         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2091           {
2092             tmp_list2 = tmp_list3 = 0;
2093             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2094             merge_tlist (&tmp_list3, tmp_list2, 0);
2095             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2096           }
2097         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2098         warn_for_collisions (tmp_before);
2099         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2100         return;
2101       }
2102
2103     case TREE_LIST:
2104       /* Scan all the list, e.g. indices of multi dimensional array.  */
2105       while (x)
2106         {
2107           tmp_before = tmp_nosp = 0;
2108           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2109           merge_tlist (&tmp_nosp, tmp_before, 0);
2110           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2111           x = TREE_CHAIN (x);
2112         }
2113       return;
2114
2115     case SAVE_EXPR:
2116       {
2117         struct tlist_cache *t;
2118         for (t = save_expr_cache; t; t = t->next)
2119           if (t->expr == x)
2120             break;
2121
2122         if (!t)
2123           {
2124             t = XOBNEW (&tlist_obstack, struct tlist_cache);
2125             t->next = save_expr_cache;
2126             t->expr = x;
2127             save_expr_cache = t;
2128
2129             tmp_before = tmp_nosp = 0;
2130             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2131             warn_for_collisions (tmp_nosp);
2132
2133             tmp_list3 = 0;
2134             while (tmp_nosp)
2135               {
2136                 struct tlist *t = tmp_nosp;
2137                 tmp_nosp = t->next;
2138                 merge_tlist (&tmp_list3, t, 0);
2139               }
2140             t->cache_before_sp = tmp_before;
2141             t->cache_after_sp = tmp_list3;
2142           }
2143         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2144         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2145         return;
2146       }
2147
2148     case ADDR_EXPR:
2149       x = TREE_OPERAND (x, 0);
2150       if (DECL_P (x))
2151         return;
2152       writer = 0;
2153       goto restart;
2154
2155     default:
2156       /* For other expressions, simply recurse on their operands.
2157          Manual tail recursion for unary expressions.
2158          Other non-expressions need not be processed.  */
2159       if (cl == tcc_unary)
2160         {
2161           x = TREE_OPERAND (x, 0);
2162           writer = 0;
2163           goto restart;
2164         }
2165       else if (IS_EXPR_CODE_CLASS (cl))
2166         {
2167           int lp;
2168           int max = TREE_OPERAND_LENGTH (x);
2169           for (lp = 0; lp < max; lp++)
2170             {
2171               tmp_before = tmp_nosp = 0;
2172               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2173               merge_tlist (&tmp_nosp, tmp_before, 0);
2174               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2175             }
2176         }
2177       return;
2178     }
2179 }
2180
2181 /* Try to warn for undefined behavior in EXPR due to missing sequence
2182    points.  */
2183
2184 void
2185 verify_sequence_points (tree expr)
2186 {
2187   struct tlist *before_sp = 0, *after_sp = 0;
2188
2189   warned_ids = 0;
2190   save_expr_cache = 0;
2191   if (tlist_firstobj == 0)
2192     {
2193       gcc_obstack_init (&tlist_obstack);
2194       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2195     }
2196
2197   verify_tree (expr, &before_sp, &after_sp, 0);
2198   warn_for_collisions (after_sp);
2199   obstack_free (&tlist_obstack, tlist_firstobj);
2200 }
2201 \f
2202 /* Validate the expression after `case' and apply default promotions.  */
2203
2204 static tree
2205 check_case_value (tree value)
2206 {
2207   if (value == NULL_TREE)
2208     return value;
2209
2210   /* ??? Can we ever get nops here for a valid case value?  We
2211      shouldn't for C.  */
2212   STRIP_TYPE_NOPS (value);
2213   /* In C++, the following is allowed:
2214
2215        const int i = 3;
2216        switch (...) { case i: ... }
2217
2218      So, we try to reduce the VALUE to a constant that way.  */
2219   if (c_dialect_cxx ())
2220     {
2221       value = decl_constant_value (value);
2222       STRIP_TYPE_NOPS (value);
2223       value = fold (value);
2224     }
2225
2226   if (TREE_CODE (value) == INTEGER_CST)
2227     /* Promote char or short to int.  */
2228     value = perform_integral_promotions (value);
2229   else if (value != error_mark_node)
2230     {
2231       error ("case label does not reduce to an integer constant");
2232       value = error_mark_node;
2233     }
2234
2235   constant_expression_warning (value);
2236
2237   return value;
2238 }
2239 \f
2240 /* See if the case values LOW and HIGH are in the range of the original
2241    type (i.e. before the default conversion to int) of the switch testing
2242    expression.
2243    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2244    the type before promoting it.  CASE_LOW_P is a pointer to the lower
2245    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2246    if the case is not a case range.
2247    The caller has to make sure that we are not called with NULL for
2248    CASE_LOW_P (i.e. the default case).
2249    Returns true if the case label is in range of ORIG_TYPE (saturated or
2250    untouched) or false if the label is out of range.  */
2251
2252 static bool
2253 check_case_bounds (tree type, tree orig_type,
2254                    tree *case_low_p, tree *case_high_p)
2255 {
2256   tree min_value, max_value;
2257   tree case_low = *case_low_p;
2258   tree case_high = case_high_p ? *case_high_p : case_low;
2259
2260   /* If there was a problem with the original type, do nothing.  */
2261   if (orig_type == error_mark_node)
2262     return true;
2263
2264   min_value = TYPE_MIN_VALUE (orig_type);
2265   max_value = TYPE_MAX_VALUE (orig_type);
2266
2267   /* Case label is less than minimum for type.  */
2268   if (tree_int_cst_compare (case_low, min_value) < 0
2269       && tree_int_cst_compare (case_high, min_value) < 0)
2270     {
2271       warning (0, "case label value is less than minimum value for type");
2272       return false;
2273     }
2274
2275   /* Case value is greater than maximum for type.  */
2276   if (tree_int_cst_compare (case_low, max_value) > 0
2277       && tree_int_cst_compare (case_high, max_value) > 0)
2278     {
2279       warning (0, "case label value exceeds maximum value for type");
2280       return false;
2281     }
2282
2283   /* Saturate lower case label value to minimum.  */
2284   if (tree_int_cst_compare (case_high, min_value) >= 0
2285       && tree_int_cst_compare (case_low, min_value) < 0)
2286     {
2287       warning (0, "lower value in case label range"
2288                " less than minimum value for type");
2289       case_low = min_value;
2290     }
2291
2292   /* Saturate upper case label value to maximum.  */
2293   if (tree_int_cst_compare (case_low, max_value) <= 0
2294       && tree_int_cst_compare (case_high, max_value) > 0)
2295     {
2296       warning (0, "upper value in case label range"
2297                " exceeds maximum value for type");
2298       case_high = max_value;
2299     }
2300
2301   if (*case_low_p != case_low)
2302     *case_low_p = convert (type, case_low);
2303   if (case_high_p && *case_high_p != case_high)
2304     *case_high_p = convert (type, case_high);
2305
2306   return true;
2307 }
2308 \f
2309 /* Return an integer type with BITS bits of precision,
2310    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2311
2312 tree
2313 c_common_type_for_size (unsigned int bits, int unsignedp)
2314 {
2315   if (bits == TYPE_PRECISION (integer_type_node))
2316     return unsignedp ? unsigned_type_node : integer_type_node;
2317
2318   if (bits == TYPE_PRECISION (signed_char_type_node))
2319     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2320
2321   if (bits == TYPE_PRECISION (short_integer_type_node))
2322     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2323
2324   if (bits == TYPE_PRECISION (long_integer_type_node))
2325     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2326
2327   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2328     return (unsignedp ? long_long_unsigned_type_node
2329             : long_long_integer_type_node);
2330
2331   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2332     return (unsignedp ? widest_unsigned_literal_type_node
2333             : widest_integer_literal_type_node);
2334
2335   if (bits <= TYPE_PRECISION (intQI_type_node))
2336     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2337
2338   if (bits <= TYPE_PRECISION (intHI_type_node))
2339     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2340
2341   if (bits <= TYPE_PRECISION (intSI_type_node))
2342     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2343
2344   if (bits <= TYPE_PRECISION (intDI_type_node))
2345     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2346
2347   return 0;
2348 }
2349
2350 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2351    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2352    and saturating if SATP is nonzero, otherwise not saturating.  */
2353
2354 tree
2355 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2356                                     int unsignedp, int satp)
2357 {
2358   enum machine_mode mode;
2359   if (ibit == 0)
2360     mode = unsignedp ? UQQmode : QQmode;
2361   else
2362     mode = unsignedp ? UHAmode : HAmode;
2363
2364   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2365     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2366       break;
2367
2368   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2369     {
2370       sorry ("GCC cannot support operators with integer types and "
2371              "fixed-point types that have too many integral and "
2372              "fractional bits together");
2373       return 0;
2374     }
2375
2376   return c_common_type_for_mode (mode, satp);
2377 }
2378
2379 /* Used for communication between c_common_type_for_mode and
2380    c_register_builtin_type.  */
2381 static GTY(()) tree registered_builtin_types;
2382
2383 /* Return a data type that has machine mode MODE.
2384    If the mode is an integer,
2385    then UNSIGNEDP selects between signed and unsigned types.
2386    If the mode is a fixed-point mode,
2387    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2388
2389 tree
2390 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2391 {
2392   tree t;
2393
2394   if (mode == TYPE_MODE (integer_type_node))
2395     return unsignedp ? unsigned_type_node : integer_type_node;
2396
2397   if (mode == TYPE_MODE (signed_char_type_node))
2398     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2399
2400   if (mode == TYPE_MODE (short_integer_type_node))
2401     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2402
2403   if (mode == TYPE_MODE (long_integer_type_node))
2404     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2405
2406   if (mode == TYPE_MODE (long_long_integer_type_node))
2407     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2408
2409   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2410     return unsignedp ? widest_unsigned_literal_type_node
2411                      : widest_integer_literal_type_node;
2412
2413   if (mode == QImode)
2414     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2415
2416   if (mode == HImode)
2417     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2418
2419   if (mode == SImode)
2420     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2421
2422   if (mode == DImode)
2423     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2424
2425 #if HOST_BITS_PER_WIDE_INT >= 64
2426   if (mode == TYPE_MODE (intTI_type_node))
2427     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2428 #endif
2429
2430   if (mode == TYPE_MODE (float_type_node))
2431     return float_type_node;
2432
2433   if (mode == TYPE_MODE (double_type_node))
2434     return double_type_node;
2435
2436   if (mode == TYPE_MODE (long_double_type_node))
2437     return long_double_type_node;
2438
2439   if (mode == TYPE_MODE (void_type_node))
2440     return void_type_node;
2441
2442   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2443     return (unsignedp
2444             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2445             : make_signed_type (GET_MODE_PRECISION (mode)));
2446
2447   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2448     return (unsignedp
2449             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2450             : make_signed_type (GET_MODE_PRECISION (mode)));
2451
2452   if (COMPLEX_MODE_P (mode))
2453     {
2454       enum machine_mode inner_mode;
2455       tree inner_type;
2456
2457       if (mode == TYPE_MODE (complex_float_type_node))
2458         return complex_float_type_node;
2459       if (mode == TYPE_MODE (complex_double_type_node))
2460         return complex_double_type_node;
2461       if (mode == TYPE_MODE (complex_long_double_type_node))
2462         return complex_long_double_type_node;
2463
2464       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2465         return complex_integer_type_node;
2466
2467       inner_mode = GET_MODE_INNER (mode);
2468       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2469       if (inner_type != NULL_TREE)
2470         return build_complex_type (inner_type);
2471     }
2472   else if (VECTOR_MODE_P (mode))
2473     {
2474       enum machine_mode inner_mode = GET_MODE_INNER (mode);
2475       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2476       if (inner_type != NULL_TREE)
2477         return build_vector_type_for_mode (inner_type, mode);
2478     }
2479
2480   if (mode == TYPE_MODE (dfloat32_type_node))
2481     return dfloat32_type_node;
2482   if (mode == TYPE_MODE (dfloat64_type_node))
2483     return dfloat64_type_node;
2484   if (mode == TYPE_MODE (dfloat128_type_node))
2485     return dfloat128_type_node;
2486
2487   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2488     {
2489       if (mode == TYPE_MODE (short_fract_type_node))
2490         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2491       if (mode == TYPE_MODE (fract_type_node))
2492         return unsignedp ? sat_fract_type_node : fract_type_node;
2493       if (mode == TYPE_MODE (long_fract_type_node))
2494         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2495       if (mode == TYPE_MODE (long_long_fract_type_node))
2496         return unsignedp ? sat_long_long_fract_type_node
2497                          : long_long_fract_type_node;
2498
2499       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2500         return unsignedp ? sat_unsigned_short_fract_type_node
2501                          : unsigned_short_fract_type_node;
2502       if (mode == TYPE_MODE (unsigned_fract_type_node))
2503         return unsignedp ? sat_unsigned_fract_type_node
2504                          : unsigned_fract_type_node;
2505       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2506         return unsignedp ? sat_unsigned_long_fract_type_node
2507                          : unsigned_long_fract_type_node;
2508       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2509         return unsignedp ? sat_unsigned_long_long_fract_type_node
2510                          : unsigned_long_long_fract_type_node;
2511
2512       if (mode == TYPE_MODE (short_accum_type_node))
2513         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2514       if (mode == TYPE_MODE (accum_type_node))
2515         return unsignedp ? sat_accum_type_node : accum_type_node;
2516       if (mode == TYPE_MODE (long_accum_type_node))
2517         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2518       if (mode == TYPE_MODE (long_long_accum_type_node))
2519         return unsignedp ? sat_long_long_accum_type_node
2520                          : long_long_accum_type_node;
2521
2522       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2523         return unsignedp ? sat_unsigned_short_accum_type_node
2524                          : unsigned_short_accum_type_node;
2525       if (mode == TYPE_MODE (unsigned_accum_type_node))
2526         return unsignedp ? sat_unsigned_accum_type_node
2527                          : unsigned_accum_type_node;
2528       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2529         return unsignedp ? sat_unsigned_long_accum_type_node
2530                          : unsigned_long_accum_type_node;
2531       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2532         return unsignedp ? sat_unsigned_long_long_accum_type_node
2533                          : unsigned_long_long_accum_type_node;
2534
2535       if (mode == QQmode)
2536         return unsignedp ? sat_qq_type_node : qq_type_node;
2537       if (mode == HQmode)
2538         return unsignedp ? sat_hq_type_node : hq_type_node;
2539       if (mode == SQmode)
2540         return unsignedp ? sat_sq_type_node : sq_type_node;
2541       if (mode == DQmode)
2542         return unsignedp ? sat_dq_type_node : dq_type_node;
2543       if (mode == TQmode)
2544         return unsignedp ? sat_tq_type_node : tq_type_node;
2545
2546       if (mode == UQQmode)
2547         return unsignedp ? sat_uqq_type_node : uqq_type_node;
2548       if (mode == UHQmode)
2549         return unsignedp ? sat_uhq_type_node : uhq_type_node;
2550       if (mode == USQmode)
2551         return unsignedp ? sat_usq_type_node : usq_type_node;
2552       if (mode == UDQmode)
2553         return unsignedp ? sat_udq_type_node : udq_type_node;
2554       if (mode == UTQmode)
2555         return unsignedp ? sat_utq_type_node : utq_type_node;
2556
2557       if (mode == HAmode)
2558         return unsignedp ? sat_ha_type_node : ha_type_node;
2559       if (mode == SAmode)
2560         return unsignedp ? sat_sa_type_node : sa_type_node;
2561       if (mode == DAmode)
2562         return unsignedp ? sat_da_type_node : da_type_node;
2563       if (mode == TAmode)
2564         return unsignedp ? sat_ta_type_node : ta_type_node;
2565
2566       if (mode == UHAmode)
2567         return unsignedp ? sat_uha_type_node : uha_type_node;
2568       if (mode == USAmode)
2569         return unsignedp ? sat_usa_type_node : usa_type_node;
2570       if (mode == UDAmode)
2571         return unsignedp ? sat_uda_type_node : uda_type_node;
2572       if (mode == UTAmode)
2573         return unsignedp ? sat_uta_type_node : uta_type_node;
2574     }
2575
2576   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2577     if (TYPE_MODE (TREE_VALUE (t)) == mode)
2578       return TREE_VALUE (t);
2579
2580   return 0;
2581 }
2582
2583 tree
2584 c_common_unsigned_type (tree type)
2585 {
2586   return c_common_signed_or_unsigned_type (1, type);
2587 }
2588
2589 /* Return a signed type the same as TYPE in other respects.  */
2590
2591 tree
2592 c_common_signed_type (tree type)
2593 {
2594   return c_common_signed_or_unsigned_type (0, type);
2595 }
2596
2597 /* Return a type the same as TYPE except unsigned or
2598    signed according to UNSIGNEDP.  */
2599
2600 tree
2601 c_common_signed_or_unsigned_type (int unsignedp, tree type)
2602 {
2603   tree type1;
2604
2605   /* This block of code emulates the behavior of the old
2606      c_common_unsigned_type. In particular, it returns
2607      long_unsigned_type_node if passed a long, even when a int would
2608      have the same size. This is necessary for warnings to work
2609      correctly in archs where sizeof(int) == sizeof(long) */
2610
2611   type1 = TYPE_MAIN_VARIANT (type);
2612   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
2613     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2614   if (type1 == integer_type_node || type1 == unsigned_type_node)
2615     return unsignedp ? unsigned_type_node : integer_type_node;
2616   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2617     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2618   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2619     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2620   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
2621     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2622   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
2623     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
2624 #if HOST_BITS_PER_WIDE_INT >= 64
2625   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2626     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2627 #endif
2628   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2629     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2630   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2631     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2632   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2633     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2634   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2635     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2636
2637 #define C_COMMON_FIXED_TYPES(NAME)          \
2638   if (type1 == short_ ## NAME ## _type_node \
2639       || type1 == unsigned_short_ ## NAME ## _type_node) \
2640     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2641                      : short_ ## NAME ## _type_node; \
2642   if (type1 == NAME ## _type_node \
2643       || type1 == unsigned_ ## NAME ## _type_node) \
2644     return unsignedp ? unsigned_ ## NAME ## _type_node \
2645                      : NAME ## _type_node; \
2646   if (type1 == long_ ## NAME ## _type_node \
2647       || type1 == unsigned_long_ ## NAME ## _type_node) \
2648     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2649                      : long_ ## NAME ## _type_node; \
2650   if (type1 == long_long_ ## NAME ## _type_node \
2651       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2652     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2653                      : long_long_ ## NAME ## _type_node;
2654
2655 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
2656   if (type1 == NAME ## _type_node \
2657       || type1 == u ## NAME ## _type_node) \
2658     return unsignedp ? u ## NAME ## _type_node \
2659                      : NAME ## _type_node;
2660
2661 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
2662   if (type1 == sat_ ## short_ ## NAME ## _type_node \
2663       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2664     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2665                      : sat_ ## short_ ## NAME ## _type_node; \
2666   if (type1 == sat_ ## NAME ## _type_node \
2667       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2668     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2669                      : sat_ ## NAME ## _type_node; \
2670   if (type1 == sat_ ## long_ ## NAME ## _type_node \
2671       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2672     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2673                      : sat_ ## long_ ## NAME ## _type_node; \
2674   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2675       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2676     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2677                      : sat_ ## long_long_ ## NAME ## _type_node;
2678
2679 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
2680   if (type1 == sat_ ## NAME ## _type_node \
2681       || type1 == sat_ ## u ## NAME ## _type_node) \
2682     return unsignedp ? sat_ ## u ## NAME ## _type_node \
2683                      : sat_ ## NAME ## _type_node;
2684
2685   C_COMMON_FIXED_TYPES (fract);
2686   C_COMMON_FIXED_TYPES_SAT (fract);
2687   C_COMMON_FIXED_TYPES (accum);
2688   C_COMMON_FIXED_TYPES_SAT (accum);
2689
2690   C_COMMON_FIXED_MODE_TYPES (qq);
2691   C_COMMON_FIXED_MODE_TYPES (hq);
2692   C_COMMON_FIXED_MODE_TYPES (sq);
2693   C_COMMON_FIXED_MODE_TYPES (dq);
2694   C_COMMON_FIXED_MODE_TYPES (tq);
2695   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
2696   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
2697   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
2698   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
2699   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
2700   C_COMMON_FIXED_MODE_TYPES (ha);
2701   C_COMMON_FIXED_MODE_TYPES (sa);
2702   C_COMMON_FIXED_MODE_TYPES (da);
2703   C_COMMON_FIXED_MODE_TYPES (ta);
2704   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
2705   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
2706   C_COMMON_FIXED_MODE_TYPES_SAT (da);
2707   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
2708
2709   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2710      the precision; they have precision set to match their range, but
2711      may use a wider mode to match an ABI.  If we change modes, we may
2712      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
2713      the precision as well, so as to yield correct results for
2714      bit-field types.  C++ does not have these separate bit-field
2715      types, and producing a signed or unsigned variant of an
2716      ENUMERAL_TYPE may cause other problems as well.  */
2717
2718   if (!INTEGRAL_TYPE_P (type)
2719       || TYPE_UNSIGNED (type) == unsignedp)
2720     return type;
2721
2722 #define TYPE_OK(node)                                                       \
2723   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
2724    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2725   if (TYPE_OK (signed_char_type_node))
2726     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2727   if (TYPE_OK (integer_type_node))
2728     return unsignedp ? unsigned_type_node : integer_type_node;
2729   if (TYPE_OK (short_integer_type_node))
2730     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2731   if (TYPE_OK (long_integer_type_node))
2732     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2733   if (TYPE_OK (long_long_integer_type_node))
2734     return (unsignedp ? long_long_unsigned_type_node
2735             : long_long_integer_type_node);
2736   if (TYPE_OK (widest_integer_literal_type_node))
2737     return (unsignedp ? widest_unsigned_literal_type_node
2738             : widest_integer_literal_type_node);
2739
2740 #if HOST_BITS_PER_WIDE_INT >= 64
2741   if (TYPE_OK (intTI_type_node))
2742     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2743 #endif
2744   if (TYPE_OK (intDI_type_node))
2745     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2746   if (TYPE_OK (intSI_type_node))
2747     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2748   if (TYPE_OK (intHI_type_node))
2749     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2750   if (TYPE_OK (intQI_type_node))
2751     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2752 #undef TYPE_OK
2753
2754   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2755 }
2756
2757 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
2758
2759 tree
2760 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
2761 {
2762   /* Extended integer types of the same width as a standard type have
2763      lesser rank, so those of the same width as int promote to int or
2764      unsigned int and are valid for printf formats expecting int or
2765      unsigned int.  To avoid such special cases, avoid creating
2766      extended integer types for bit-fields if a standard integer type
2767      is available.  */
2768   if (width == TYPE_PRECISION (integer_type_node))
2769     return unsignedp ? unsigned_type_node : integer_type_node;
2770   if (width == TYPE_PRECISION (signed_char_type_node))
2771     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2772   if (width == TYPE_PRECISION (short_integer_type_node))
2773     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2774   if (width == TYPE_PRECISION (long_integer_type_node))
2775     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2776   if (width == TYPE_PRECISION (long_long_integer_type_node))
2777     return (unsignedp ? long_long_unsigned_type_node
2778             : long_long_integer_type_node);
2779   return build_nonstandard_integer_type (width, unsignedp);
2780 }
2781
2782 /* The C version of the register_builtin_type langhook.  */
2783
2784 void
2785 c_register_builtin_type (tree type, const char* name)
2786 {
2787   tree decl;
2788
2789   decl = build_decl (TYPE_DECL, get_identifier (name), type);
2790   DECL_ARTIFICIAL (decl) = 1;
2791   if (!TYPE_NAME (type))
2792     TYPE_NAME (type) = decl;
2793   pushdecl (decl);
2794
2795   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
2796 }
2797 \f
2798 /* Print an error message for invalid operands to arith operation
2799    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
2800    LOCATION is the location of the message.  */
2801
2802 void
2803 binary_op_error (location_t location, enum tree_code code,
2804                  tree type0, tree type1)
2805 {
2806   const char *opname;
2807
2808   switch (code)
2809     {
2810     case PLUS_EXPR:
2811       opname = "+"; break;
2812     case MINUS_EXPR:
2813       opname = "-"; break;
2814     case MULT_EXPR:
2815       opname = "*"; break;
2816     case MAX_EXPR:
2817       opname = "max"; break;
2818     case MIN_EXPR:
2819       opname = "min"; break;
2820     case EQ_EXPR:
2821       opname = "=="; break;
2822     case NE_EXPR:
2823       opname = "!="; break;
2824     case LE_EXPR:
2825       opname = "<="; break;
2826     case GE_EXPR:
2827       opname = ">="; break;
2828     case LT_EXPR:
2829       opname = "<"; break;
2830     case GT_EXPR:
2831       opname = ">"; break;
2832     case LSHIFT_EXPR:
2833       opname = "<<"; break;
2834     case RSHIFT_EXPR:
2835       opname = ">>"; break;
2836     case TRUNC_MOD_EXPR:
2837     case FLOOR_MOD_EXPR:
2838       opname = "%"; break;
2839     case TRUNC_DIV_EXPR:
2840     case FLOOR_DIV_EXPR:
2841       opname = "/"; break;
2842     case BIT_AND_EXPR:
2843       opname = "&"; break;
2844     case BIT_IOR_EXPR:
2845       opname = "|"; break;
2846     case TRUTH_ANDIF_EXPR:
2847       opname = "&&"; break;
2848     case TRUTH_ORIF_EXPR:
2849       opname = "||"; break;
2850     case BIT_XOR_EXPR:
2851       opname = "^"; break;
2852     default:
2853       gcc_unreachable ();
2854     }
2855   error_at (location,
2856             "invalid operands to binary %s (have %qT and %qT)", opname,
2857             type0, type1);
2858 }
2859 \f
2860 /* Subroutine of build_binary_op, used for comparison operations.
2861    See if the operands have both been converted from subword integer types
2862    and, if so, perhaps change them both back to their original type.
2863    This function is also responsible for converting the two operands
2864    to the proper common type for comparison.
2865
2866    The arguments of this function are all pointers to local variables
2867    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2868    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2869
2870    If this function returns nonzero, it means that the comparison has
2871    a constant value.  What this function returns is an expression for
2872    that value.  */
2873
2874 tree
2875 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2876                  enum tree_code *rescode_ptr)
2877 {
2878   tree type;
2879   tree op0 = *op0_ptr;
2880   tree op1 = *op1_ptr;
2881   int unsignedp0, unsignedp1;
2882   int real1, real2;
2883   tree primop0, primop1;
2884   enum tree_code code = *rescode_ptr;
2885
2886   /* Throw away any conversions to wider types
2887      already present in the operands.  */
2888
2889   primop0 = get_narrower (op0, &unsignedp0);
2890   primop1 = get_narrower (op1, &unsignedp1);
2891
2892   /* Handle the case that OP0 does not *contain* a conversion
2893      but it *requires* conversion to FINAL_TYPE.  */
2894
2895   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2896     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2897   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2898     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2899
2900   /* If one of the operands must be floated, we cannot optimize.  */
2901   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2902   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2903
2904   /* If first arg is constant, swap the args (changing operation
2905      so value is preserved), for canonicalization.  Don't do this if
2906      the second arg is 0.  */
2907
2908   if (TREE_CONSTANT (primop0)
2909       && !integer_zerop (primop1) && !real_zerop (primop1)
2910       && !fixed_zerop (primop1))
2911     {
2912       tree tem = primop0;
2913       int temi = unsignedp0;
2914       primop0 = primop1;
2915       primop1 = tem;
2916       tem = op0;
2917       op0 = op1;
2918       op1 = tem;
2919       *op0_ptr = op0;
2920       *op1_ptr = op1;
2921       unsignedp0 = unsignedp1;
2922       unsignedp1 = temi;
2923       temi = real1;
2924       real1 = real2;
2925       real2 = temi;
2926
2927       switch (code)
2928         {
2929         case LT_EXPR:
2930           code = GT_EXPR;
2931           break;
2932         case GT_EXPR:
2933           code = LT_EXPR;
2934           break;
2935         case LE_EXPR:
2936           code = GE_EXPR;
2937           break;
2938         case GE_EXPR:
2939           code = LE_EXPR;
2940           break;
2941         default:
2942           break;
2943         }
2944       *rescode_ptr = code;
2945     }
2946
2947   /* If comparing an integer against a constant more bits wide,
2948      maybe we can deduce a value of 1 or 0 independent of the data.
2949      Or else truncate the constant now
2950      rather than extend the variable at run time.
2951
2952      This is only interesting if the constant is the wider arg.
2953      Also, it is not safe if the constant is unsigned and the
2954      variable arg is signed, since in this case the variable
2955      would be sign-extended and then regarded as unsigned.
2956      Our technique fails in this case because the lowest/highest
2957      possible unsigned results don't follow naturally from the
2958      lowest/highest possible values of the variable operand.
2959      For just EQ_EXPR and NE_EXPR there is another technique that
2960      could be used: see if the constant can be faithfully represented
2961      in the other operand's type, by truncating it and reextending it
2962      and see if that preserves the constant's value.  */
2963
2964   if (!real1 && !real2
2965       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
2966       && TREE_CODE (primop1) == INTEGER_CST
2967       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2968     {
2969       int min_gt, max_gt, min_lt, max_lt;
2970       tree maxval, minval;
2971       /* 1 if comparison is nominally unsigned.  */
2972       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2973       tree val;
2974
2975       type = c_common_signed_or_unsigned_type (unsignedp0,
2976                                                TREE_TYPE (primop0));
2977
2978       maxval = TYPE_MAX_VALUE (type);
2979       minval = TYPE_MIN_VALUE (type);
2980
2981       if (unsignedp && !unsignedp0)
2982         *restype_ptr = c_common_signed_type (*restype_ptr);
2983
2984       if (TREE_TYPE (primop1) != *restype_ptr)
2985         {
2986           /* Convert primop1 to target type, but do not introduce
2987              additional overflow.  We know primop1 is an int_cst.  */
2988           primop1 = force_fit_type_double (*restype_ptr,
2989                                            TREE_INT_CST_LOW (primop1),
2990                                            TREE_INT_CST_HIGH (primop1), 0,
2991                                            TREE_OVERFLOW (primop1));
2992         }
2993       if (type != *restype_ptr)
2994         {
2995           minval = convert (*restype_ptr, minval);
2996           maxval = convert (*restype_ptr, maxval);
2997         }
2998
2999       if (unsignedp && unsignedp0)
3000         {
3001           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3002           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3003           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3004           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3005         }
3006       else
3007         {
3008           min_gt = INT_CST_LT (primop1, minval);
3009           max_gt = INT_CST_LT (primop1, maxval);
3010           min_lt = INT_CST_LT (minval, primop1);
3011           max_lt = INT_CST_LT (maxval, primop1);
3012         }
3013
3014       val = 0;
3015       /* This used to be a switch, but Genix compiler can't handle that.  */
3016       if (code == NE_EXPR)
3017         {
3018           if (max_lt || min_gt)
3019             val = truthvalue_true_node;
3020         }
3021       else if (code == EQ_EXPR)
3022         {
3023           if (max_lt || min_gt)
3024             val = truthvalue_false_node;
3025         }
3026       else if (code == LT_EXPR)
3027         {
3028           if (max_lt)
3029             val = truthvalue_true_node;
3030           if (!min_lt)
3031             val = truthvalue_false_node;
3032         }
3033       else if (code == GT_EXPR)
3034         {
3035           if (min_gt)
3036             val = truthvalue_true_node;
3037           if (!max_gt)
3038             val = truthvalue_false_node;
3039         }
3040       else if (code == LE_EXPR)
3041         {
3042           if (!max_gt)
3043             val = truthvalue_true_node;
3044           if (min_gt)
3045             val = truthvalue_false_node;
3046         }
3047       else if (code == GE_EXPR)
3048         {
3049           if (!min_lt)
3050             val = truthvalue_true_node;
3051           if (max_lt)
3052             val = truthvalue_false_node;
3053         }
3054
3055       /* If primop0 was sign-extended and unsigned comparison specd,
3056          we did a signed comparison above using the signed type bounds.
3057          But the comparison we output must be unsigned.
3058
3059          Also, for inequalities, VAL is no good; but if the signed
3060          comparison had *any* fixed result, it follows that the
3061          unsigned comparison just tests the sign in reverse
3062          (positive values are LE, negative ones GE).
3063          So we can generate an unsigned comparison
3064          against an extreme value of the signed type.  */
3065
3066       if (unsignedp && !unsignedp0)
3067         {
3068           if (val != 0)
3069             switch (code)
3070               {
3071               case LT_EXPR:
3072               case GE_EXPR:
3073                 primop1 = TYPE_MIN_VALUE (type);
3074                 val = 0;
3075                 break;
3076
3077               case LE_EXPR:
3078               case GT_EXPR:
3079                 primop1 = TYPE_MAX_VALUE (type);
3080                 val = 0;
3081                 break;
3082
3083               default:
3084                 break;
3085               }
3086           type = c_common_unsigned_type (type);
3087         }
3088
3089       if (TREE_CODE (primop0) != INTEGER_CST)
3090         {
3091           if (val == truthvalue_false_node)
3092             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3093           if (val == truthvalue_true_node)
3094             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3095         }
3096
3097       if (val != 0)
3098         {
3099           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3100           if (TREE_SIDE_EFFECTS (primop0))
3101             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3102           return val;
3103         }
3104
3105       /* Value is not predetermined, but do the comparison
3106          in the type of the operand that is not constant.
3107          TYPE is already properly set.  */
3108     }
3109
3110   /* If either arg is decimal float and the other is float, find the
3111      proper common type to use for comparison.  */
3112   else if (real1 && real2
3113            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3114                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3115     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3116
3117   else if (real1 && real2
3118            && (TYPE_PRECISION (TREE_TYPE (primop0))
3119                == TYPE_PRECISION (TREE_TYPE (primop1))))
3120     type = TREE_TYPE (primop0);
3121
3122   /* If args' natural types are both narrower than nominal type
3123      and both extend in the same manner, compare them
3124      in the type of the wider arg.
3125      Otherwise must actually extend both to the nominal
3126      common type lest different ways of extending
3127      alter the result.
3128      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
3129
3130   else if (unsignedp0 == unsignedp1 && real1 == real2
3131            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3132            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3133     {
3134       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3135       type = c_common_signed_or_unsigned_type (unsignedp0
3136                                                || TYPE_UNSIGNED (*restype_ptr),
3137                                                type);
3138       /* Make sure shorter operand is extended the right way
3139          to match the longer operand.  */
3140       primop0
3141         = convert (c_common_signed_or_unsigned_type (unsignedp0,
3142                                                      TREE_TYPE (primop0)),
3143                    primop0);
3144       primop1
3145         = convert (c_common_signed_or_unsigned_type (unsignedp1,
3146                                                      TREE_TYPE (primop1)),
3147                    primop1);
3148     }
3149   else
3150     {
3151       /* Here we must do the comparison on the nominal type
3152          using the args exactly as we received them.  */
3153       type = *restype_ptr;
3154       primop0 = op0;
3155       primop1 = op1;
3156
3157       if (!real1 && !real2 && integer_zerop (primop1)
3158           && TYPE_UNSIGNED (*restype_ptr))
3159         {
3160           tree value = 0;
3161           switch (code)
3162             {
3163             case GE_EXPR:
3164               /* All unsigned values are >= 0, so we warn.  However,
3165                  if OP0 is a constant that is >= 0, the signedness of
3166                  the comparison isn't an issue, so suppress the
3167                  warning.  */
3168               if (warn_type_limits && !in_system_header
3169                   && !(TREE_CODE (primop0) == INTEGER_CST
3170                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3171                                                    primop0))))
3172                 warning (OPT_Wtype_limits, 
3173                          "comparison of unsigned expression >= 0 is always true");
3174               value = truthvalue_true_node;
3175               break;
3176
3177             case LT_EXPR:
3178               if (warn_type_limits && !in_system_header
3179                   && !(TREE_CODE (primop0) == INTEGER_CST
3180                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3181                                                    primop0))))
3182                 warning (OPT_Wtype_limits, 
3183                          "comparison of unsigned expression < 0 is always false");
3184               value = truthvalue_false_node;
3185               break;
3186
3187             default:
3188               break;
3189             }
3190
3191           if (value != 0)
3192             {
3193               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3194               if (TREE_SIDE_EFFECTS (primop0))
3195                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3196                                primop0, value);
3197               return value;
3198             }
3199         }
3200     }
3201
3202   *op0_ptr = convert (type, primop0);
3203   *op1_ptr = convert (type, primop1);
3204
3205   *restype_ptr = truthvalue_type_node;
3206
3207   return 0;
3208 }
3209 \f
3210 /* Return a tree for the sum or difference (RESULTCODE says which)
3211    of pointer PTROP and integer INTOP.  */
3212
3213 tree
3214 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
3215 {
3216   tree size_exp, ret;
3217
3218   /* The result is a pointer of the same type that is being added.  */
3219   tree result_type = TREE_TYPE (ptrop);
3220
3221   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3222     {
3223       pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
3224                "pointer of type %<void *%> used in arithmetic");
3225       size_exp = integer_one_node;
3226     }
3227   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3228     {
3229       pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
3230                "pointer to a function used in arithmetic");
3231       size_exp = integer_one_node;
3232     }
3233   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3234     {
3235       pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
3236                "pointer to member function used in arithmetic");
3237       size_exp = integer_one_node;
3238     }
3239   else
3240     size_exp = size_in_bytes (TREE_TYPE (result_type));
3241
3242   /* We are manipulating pointer values, so we don't need to warn
3243      about relying on undefined signed overflow.  We disable the
3244      warning here because we use integer types so fold won't know that
3245      they are really pointers.  */
3246   fold_defer_overflow_warnings ();
3247
3248   /* If what we are about to multiply by the size of the elements
3249      contains a constant term, apply distributive law
3250      and multiply that constant term separately.
3251      This helps produce common subexpressions.  */
3252   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3253       && !TREE_CONSTANT (intop)
3254       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3255       && TREE_CONSTANT (size_exp)
3256       /* If the constant comes from pointer subtraction,
3257          skip this optimization--it would cause an error.  */
3258       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3259       /* If the constant is unsigned, and smaller than the pointer size,
3260          then we must skip this optimization.  This is because it could cause
3261          an overflow error if the constant is negative but INTOP is not.  */
3262       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3263           || (TYPE_PRECISION (TREE_TYPE (intop))
3264               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3265     {
3266       enum tree_code subcode = resultcode;
3267       tree int_type = TREE_TYPE (intop);
3268       if (TREE_CODE (intop) == MINUS_EXPR)
3269         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3270       /* Convert both subexpression types to the type of intop,
3271          because weird cases involving pointer arithmetic
3272          can result in a sum or difference with different type args.  */
3273       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3274                                subcode, ptrop,
3275                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3276       intop = convert (int_type, TREE_OPERAND (intop, 0));
3277     }
3278
3279   /* Convert the integer argument to a type the same size as sizetype
3280      so the multiply won't overflow spuriously.  */
3281   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3282       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3283     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3284                                              TYPE_UNSIGNED (sizetype)), intop);
3285
3286   /* Replace the integer argument with a suitable product by the object size.
3287      Do this multiplication as signed, then convert to the appropriate
3288      type for the pointer operation.  */
3289   intop = convert (sizetype,
3290                    build_binary_op (EXPR_LOCATION (intop),
3291                                     MULT_EXPR, intop,
3292                                     convert (TREE_TYPE (intop), size_exp), 1));
3293
3294   /* Create the sum or difference.  */
3295   if (resultcode == MINUS_EXPR)
3296     intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3297
3298   ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3299
3300   fold_undefer_and_ignore_overflow_warnings ();
3301
3302   return ret;
3303 }
3304 \f
3305 /* Return whether EXPR is a declaration whose address can never be
3306    NULL.  */
3307
3308 bool
3309 decl_with_nonnull_addr_p (const_tree expr)
3310 {
3311   return (DECL_P (expr)
3312           && (TREE_CODE (expr) == PARM_DECL
3313               || TREE_CODE (expr) == LABEL_DECL
3314               || !DECL_WEAK (expr)));
3315 }
3316
3317 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3318    or for an `if' or `while' statement or ?..: exp.  It should already
3319    have been validated to be of suitable type; otherwise, a bad
3320    diagnostic may result.
3321
3322    The EXPR is located at LOCATION.
3323
3324    This preparation consists of taking the ordinary
3325    representation of an expression expr and producing a valid tree
3326    boolean expression describing whether expr is nonzero.  We could
3327    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3328    but we optimize comparisons, &&, ||, and !.
3329
3330    The resulting type should always be `truthvalue_type_node'.  */
3331
3332 tree
3333 c_common_truthvalue_conversion (location_t location, tree expr)
3334 {
3335   switch (TREE_CODE (expr))
3336     {
3337     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3338     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3339     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3340     case ORDERED_EXPR: case UNORDERED_EXPR:
3341       if (TREE_TYPE (expr) == truthvalue_type_node)
3342         return expr;
3343       return build2 (TREE_CODE (expr), truthvalue_type_node,
3344                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3345
3346     case TRUTH_ANDIF_EXPR:
3347     case TRUTH_ORIF_EXPR:
3348     case TRUTH_AND_EXPR:
3349     case TRUTH_OR_EXPR:
3350     case TRUTH_XOR_EXPR:
3351       if (TREE_TYPE (expr) == truthvalue_type_node)
3352         return expr;
3353       return build2 (TREE_CODE (expr), truthvalue_type_node,
3354                  c_common_truthvalue_conversion (location, 
3355                                                  TREE_OPERAND (expr, 0)),
3356                  c_common_truthvalue_conversion (location,
3357                                                  TREE_OPERAND (expr, 1)));
3358
3359     case TRUTH_NOT_EXPR:
3360       if (TREE_TYPE (expr) == truthvalue_type_node)
3361         return expr;
3362       return build1 (TREE_CODE (expr), truthvalue_type_node,
3363                  c_common_truthvalue_conversion (location,
3364                                                  TREE_OPERAND (expr, 0)));
3365
3366     case ERROR_MARK:
3367       return expr;
3368
3369     case INTEGER_CST:
3370       return integer_zerop (expr) ? truthvalue_false_node
3371                                   : truthvalue_true_node;
3372
3373     case REAL_CST:
3374       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3375              ? truthvalue_true_node
3376              : truthvalue_false_node;
3377
3378     case FIXED_CST:
3379       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3380                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3381              ? truthvalue_true_node
3382              : truthvalue_false_node;
3383
3384     case FUNCTION_DECL:
3385       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3386       /* Fall through.  */
3387
3388     case ADDR_EXPR:
3389       {
3390         tree inner = TREE_OPERAND (expr, 0);
3391         if (decl_with_nonnull_addr_p (inner))
3392           {
3393             /* Common Ada/Pascal programmer's mistake.  */
3394             warning_at (location,
3395                         OPT_Waddress,
3396                         "the address of %qD will always evaluate as %<true%>",
3397                         inner);
3398             return truthvalue_true_node;
3399           }
3400         break;
3401       }
3402
3403     case COMPLEX_EXPR:
3404       return build_binary_op (EXPR_LOCATION (expr),
3405                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3406                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3407                 c_common_truthvalue_conversion (location,
3408                                                 TREE_OPERAND (expr, 0)),
3409                 c_common_truthvalue_conversion (location,
3410                                                 TREE_OPERAND (expr, 1)),
3411                               0);
3412
3413     case NEGATE_EXPR:
3414     case ABS_EXPR:
3415     case FLOAT_EXPR:
3416       /* These don't change whether an object is nonzero or zero.  */
3417       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3418
3419     case LROTATE_EXPR:
3420     case RROTATE_EXPR:
3421       /* These don't change whether an object is zero or nonzero, but
3422          we can't ignore them if their second arg has side-effects.  */
3423       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3424         return build2 (COMPOUND_EXPR, truthvalue_type_node,
3425                        TREE_OPERAND (expr, 1),
3426                        c_common_truthvalue_conversion 
3427                         (location, TREE_OPERAND (expr, 0)));
3428       else
3429         return c_common_truthvalue_conversion (location,
3430                                                TREE_OPERAND (expr, 0));
3431
3432     case COND_EXPR:
3433       {
3434         tree op1 = TREE_OPERAND (expr, 1);
3435         tree op2 = TREE_OPERAND (expr, 2);
3436         /* In C++ one of the arms might have void type if it is throw.  */
3437         if (!VOID_TYPE_P (TREE_TYPE (op1)))
3438           op1 = c_common_truthvalue_conversion (location, op1);
3439         if (!VOID_TYPE_P (TREE_TYPE (op2)))
3440           op2 = c_common_truthvalue_conversion (location, op2);
3441         /* Distribute the conversion into the arms of a COND_EXPR.  */
3442         return fold_build3 (COND_EXPR, truthvalue_type_node,
3443                             TREE_OPERAND (expr, 0), op1, op2);
3444       }
3445
3446     CASE_CONVERT:
3447       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3448          since that affects how `default_conversion' will behave.  */
3449       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3450           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3451         break;
3452       /* If this is widening the argument, we can ignore it.  */
3453       if (TYPE_PRECISION (TREE_TYPE (expr))
3454           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3455         return c_common_truthvalue_conversion (location,
3456                                                TREE_OPERAND (expr, 0));
3457       break;
3458
3459     case MODIFY_EXPR:
3460       if (!TREE_NO_WARNING (expr)
3461           && warn_parentheses)
3462         {
3463           warning (OPT_Wparentheses,
3464                    "suggest parentheses around assignment used as truth value");
3465           TREE_NO_WARNING (expr) = 1;
3466         }
3467       break;
3468
3469     default:
3470       break;
3471     }
3472
3473   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3474     {
3475       tree t = save_expr (expr);
3476       return (build_binary_op
3477               (EXPR_LOCATION (expr),
3478                (TREE_SIDE_EFFECTS (expr)
3479                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3480         c_common_truthvalue_conversion
3481                (location,
3482                 build_unary_op (location, REALPART_EXPR, t, 0)),
3483         c_common_truthvalue_conversion
3484                (location,
3485                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3486                0));
3487     }
3488
3489   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3490     {
3491       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3492                                           FCONST0 (TYPE_MODE
3493                                                    (TREE_TYPE (expr))));
3494       return build_binary_op (EXPR_LOCATION (expr),
3495                               NE_EXPR, expr, fixed_zero_node, 1);
3496     }
3497
3498   return build_binary_op (EXPR_LOCATION (expr),
3499                           NE_EXPR, expr, integer_zero_node, 1);
3500 }
3501 \f
3502 static void def_builtin_1  (enum built_in_function fncode,
3503                             const char *name,
3504                             enum built_in_class fnclass,
3505                             tree fntype, tree libtype,
3506                             bool both_p, bool fallback_p, bool nonansi_p,
3507                             tree fnattrs, bool implicit_p);
3508
3509
3510 /* Apply the TYPE_QUALS to the new DECL.  */
3511
3512 void
3513 c_apply_type_quals_to_decl (int type_quals, tree decl)
3514 {
3515   tree type = TREE_TYPE (decl);
3516
3517   if (type == error_mark_node)
3518     return;
3519
3520   if (((type_quals & TYPE_QUAL_CONST)
3521        || (type && TREE_CODE (type) == REFERENCE_TYPE))
3522       /* An object declared 'const' is only readonly after it is
3523          initialized.  We don't have any way of expressing this currently,
3524          so we need to be conservative and unset TREE_READONLY for types
3525          with constructors.  Otherwise aliasing code will ignore stores in
3526          an inline constructor.  */
3527       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3528     TREE_READONLY (decl) = 1;
3529   if (type_quals & TYPE_QUAL_VOLATILE)
3530     {
3531       TREE_SIDE_EFFECTS (decl) = 1;
3532       TREE_THIS_VOLATILE (decl) = 1;
3533     }
3534   if (type_quals & TYPE_QUAL_RESTRICT)
3535     {
3536       while (type && TREE_CODE (type) == ARRAY_TYPE)
3537         /* Allow 'restrict' on arrays of pointers.
3538            FIXME currently we just ignore it.  */
3539         type = TREE_TYPE (type);
3540       if (!type
3541           || !POINTER_TYPE_P (type)
3542           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3543         error ("invalid use of %<restrict%>");
3544       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3545         /* Indicate we need to make a unique alias set for this pointer.
3546            We can't do it here because it might be pointing to an
3547            incomplete type.  */
3548         DECL_POINTER_ALIAS_SET (decl) = -2;
3549     }
3550 }
3551
3552 /* Hash function for the problem of multiple type definitions in
3553    different files.  This must hash all types that will compare
3554    equal via comptypes to the same value.  In practice it hashes
3555    on some of the simple stuff and leaves the details to comptypes.  */
3556
3557 static hashval_t
3558 c_type_hash (const void *p)
3559 {
3560   int i = 0;
3561   int shift, size;
3562   const_tree const t = (const_tree) p;
3563   tree t2;
3564   switch (TREE_CODE (t))
3565     {
3566     /* For pointers, hash on pointee type plus some swizzling.  */
3567     case POINTER_TYPE:
3568       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3569     /* Hash on number of elements and total size.  */
3570     case ENUMERAL_TYPE:
3571       shift = 3;
3572       t2 = TYPE_VALUES (t);
3573       break;
3574     case RECORD_TYPE:
3575       shift = 0;
3576       t2 = TYPE_FIELDS (t);
3577       break;
3578     case QUAL_UNION_TYPE:
3579       shift = 1;
3580       t2 = TYPE_FIELDS (t);
3581       break;
3582     case UNION_TYPE:
3583       shift = 2;
3584       t2 = TYPE_FIELDS (t);
3585       break;
3586     default:
3587       gcc_unreachable ();
3588     }
3589   for (; t2; t2 = TREE_CHAIN (t2))
3590     i++;
3591   /* We might have a VLA here.  */
3592   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3593     size = 0;
3594   else
3595     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3596   return ((size << 24) | (i << shift));
3597 }
3598
3599 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3600
3601 /* Return the typed-based alias set for T, which may be an expression
3602    or a type.  Return -1 if we don't do anything special.  */
3603
3604 alias_set_type
3605 c_common_get_alias_set (tree t)
3606 {
3607   tree u;
3608   PTR *slot;
3609
3610   /* Permit type-punning when accessing a union, provided the access
3611      is directly through the union.  For example, this code does not
3612      permit taking the address of a union member and then storing
3613      through it.  Even the type-punning allowed here is a GCC
3614      extension, albeit a common and useful one; the C standard says
3615      that such accesses have implementation-defined behavior.  */
3616   for (u = t;
3617        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3618        u = TREE_OPERAND (u, 0))
3619     if (TREE_CODE (u) == COMPONENT_REF
3620         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3621       return 0;
3622
3623   /* That's all the expressions we handle specially.  */
3624   if (!TYPE_P (t))
3625     return -1;
3626
3627   /* The C standard guarantees that any object may be accessed via an
3628      lvalue that has character type.  */
3629   if (t == char_type_node
3630       || t == signed_char_type_node
3631       || t == unsigned_char_type_node)
3632     return 0;
3633
3634   /* The C standard specifically allows aliasing between signed and
3635      unsigned variants of the same type.  We treat the signed
3636      variant as canonical.  */
3637   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3638     {
3639       tree t1 = c_common_signed_type (t);
3640
3641       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3642       if (t1 != t)
3643         return get_alias_set (t1);
3644     }
3645   else if (POINTER_TYPE_P (t))
3646     {
3647       tree t1;
3648
3649       /* Unfortunately, there is no canonical form of a pointer type.
3650          In particular, if we have `typedef int I', then `int *', and
3651          `I *' are different types.  So, we have to pick a canonical
3652          representative.  We do this below.
3653
3654          Technically, this approach is actually more conservative that
3655          it needs to be.  In particular, `const int *' and `int *'
3656          should be in different alias sets, according to the C and C++
3657          standard, since their types are not the same, and so,
3658          technically, an `int **' and `const int **' cannot point at
3659          the same thing.
3660
3661          But, the standard is wrong.  In particular, this code is
3662          legal C++:
3663
3664             int *ip;
3665             int **ipp = &ip;
3666             const int* const* cipp = ipp;
3667
3668          And, it doesn't make sense for that to be legal unless you
3669          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3670          the pointed-to types.  This issue has been reported to the
3671          C++ committee.  */
3672       t1 = build_type_no_quals (t);
3673       if (t1 != t)
3674         return get_alias_set (t1);
3675     }
3676
3677   /* Handle the case of multiple type nodes referring to "the same" type,
3678      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
3679      C90 is handled.  (In C99 type compatibility is not transitive, which
3680      complicates things mightily. The alias set splay trees can theoretically
3681      represent this, but insertion is tricky when you consider all the
3682      different orders things might arrive in.) */
3683
3684   if (c_language != clk_c || flag_isoc99)
3685     return -1;
3686
3687   /* Save time if there's only one input file.  */
3688   if (num_in_fnames == 1)
3689     return -1;
3690
3691   /* Pointers need special handling if they point to any type that
3692      needs special handling (below).  */
3693   if (TREE_CODE (t) == POINTER_TYPE)
3694     {
3695       tree t2;
3696       /* Find bottom type under any nested POINTERs.  */
3697       for (t2 = TREE_TYPE (t);
3698            TREE_CODE (t2) == POINTER_TYPE;
3699            t2 = TREE_TYPE (t2))
3700         ;
3701       if (TREE_CODE (t2) != RECORD_TYPE
3702           && TREE_CODE (t2) != ENUMERAL_TYPE
3703           && TREE_CODE (t2) != QUAL_UNION_TYPE
3704           && TREE_CODE (t2) != UNION_TYPE)
3705         return -1;
3706       if (TYPE_SIZE (t2) == 0)
3707         return -1;
3708     }
3709   /* These are the only cases that need special handling.  */
3710   if (TREE_CODE (t) != RECORD_TYPE
3711       && TREE_CODE (t) != ENUMERAL_TYPE
3712       && TREE_CODE (t) != QUAL_UNION_TYPE
3713       && TREE_CODE (t) != UNION_TYPE
3714       && TREE_CODE (t) != POINTER_TYPE)
3715     return -1;
3716   /* Undefined? */
3717   if (TYPE_SIZE (t) == 0)
3718     return -1;
3719
3720   /* Look up t in hash table.  Only one of the compatible types within each
3721      alias set is recorded in the table.  */
3722   if (!type_hash_table)
3723     type_hash_table = htab_create_ggc (1021, c_type_hash,
3724             (htab_eq) lang_hooks.types_compatible_p,
3725             NULL);
3726   slot = htab_find_slot (type_hash_table, t, INSERT);
3727   if (*slot != NULL)
3728     {
3729       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3730       return TYPE_ALIAS_SET ((tree)*slot);
3731     }
3732   else
3733     /* Our caller will assign and record (in t) a new alias set; all we need
3734        to do is remember t in the hash table.  */
3735     *slot = t;
3736
3737   return -1;
3738 }
3739 \f
3740 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3741    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
3742    flag controls whether we should diagnose possibly ill-formed
3743    constructs or not.  */
3744
3745 tree
3746 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3747 {
3748   const char *op_name;
3749   tree value = NULL;
3750   enum tree_code type_code = TREE_CODE (type);
3751
3752   op_name = is_sizeof ? "sizeof" : "__alignof__";
3753
3754   if (type_code == FUNCTION_TYPE)
3755     {
3756       if (is_sizeof)
3757         {
3758           if (complain && (pedantic || warn_pointer_arith))
3759             pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
3760                      "invalid application of %<sizeof%> to a function type");
3761           else if (!complain)
3762             return error_mark_node;
3763           value = size_one_node;
3764         }
3765       else
3766         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3767     }
3768   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3769     {
3770       if (type_code == VOID_TYPE
3771           && complain && (pedantic || warn_pointer_arith))
3772         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
3773                  "invalid application of %qs to a void type", op_name);
3774       else if (!complain)
3775         return error_mark_node;
3776       value = size_one_node;
3777     }
3778   else if (!COMPLETE_TYPE_P (type))
3779     {
3780       if (complain)
3781         error ("invalid application of %qs to incomplete type %qT ",
3782                op_name, type);
3783       value = size_zero_node;
3784     }
3785   else
3786     {
3787       if (is_sizeof)
3788         /* Convert in case a char is more than one unit.  */
3789         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3790                             size_int (TYPE_PRECISION (char_type_node)
3791                                       / BITS_PER_UNIT));
3792       else
3793         value = size_int (TYPE_ALIGN_UNIT (type));
3794     }
3795
3796   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3797      TYPE_IS_SIZETYPE means that certain things (like overflow) will
3798      never happen.  However, this node should really have type
3799      `size_t', which is just a typedef for an ordinary integer type.  */
3800   value = fold_convert (size_type_node, value);
3801   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3802
3803   return value;
3804 }
3805
3806 /* Implement the __alignof keyword: Return the minimum required
3807    alignment of EXPR, measured in bytes.  For VAR_DECLs,
3808    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3809    from an "aligned" __attribute__ specification).  */
3810
3811 tree
3812 c_alignof_expr (tree expr)
3813 {
3814   tree t;
3815
3816   if (VAR_OR_FUNCTION_DECL_P (expr))
3817     t = size_int (DECL_ALIGN_UNIT (expr));
3818
3819   else if (TREE_CODE (expr) == COMPONENT_REF
3820            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3821     {
3822       error ("%<__alignof%> applied to a bit-field");
3823       t = size_one_node;
3824     }
3825   else if (TREE_CODE (expr) == COMPONENT_REF
3826            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3827     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3828
3829   else if (TREE_CODE (expr) == INDIRECT_REF)
3830     {
3831       tree t = TREE_OPERAND (expr, 0);
3832       tree best = t;
3833       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3834
3835       while (CONVERT_EXPR_P (t)
3836              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3837         {
3838           int thisalign;
3839
3840           t = TREE_OPERAND (t, 0);
3841           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3842           if (thisalign > bestalign)
3843             best = t, bestalign = thisalign;
3844         }
3845       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3846     }
3847   else
3848     return c_alignof (TREE_TYPE (expr));
3849
3850   return fold_convert (size_type_node, t);
3851 }
3852 \f
3853 /* Handle C and C++ default attributes.  */
3854
3855 enum built_in_attribute
3856 {
3857 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3858 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3859 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3860 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3861 #include "builtin-attrs.def"
3862 #undef DEF_ATTR_NULL_TREE
3863 #undef DEF_ATTR_INT
3864 #undef DEF_ATTR_IDENT
3865 #undef DEF_ATTR_TREE_LIST
3866   ATTR_LAST
3867 };
3868
3869 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3870
3871 static void c_init_attributes (void);
3872
3873 enum c_builtin_type
3874 {
3875 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3876 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3877 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3878 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3879 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3880 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3881 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3882 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3883 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3884 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3885 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3886 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3887 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3888 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3889 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3890   NAME,
3891 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3892 #include "builtin-types.def"
3893 #undef DEF_PRIMITIVE_TYPE
3894 #undef DEF_FUNCTION_TYPE_0
3895 #undef DEF_FUNCTION_TYPE_1
3896 #undef DEF_FUNCTION_TYPE_2
3897 #undef DEF_FUNCTION_TYPE_3
3898 #undef DEF_FUNCTION_TYPE_4
3899 #undef DEF_FUNCTION_TYPE_5
3900 #undef DEF_FUNCTION_TYPE_6
3901 #undef DEF_FUNCTION_TYPE_7
3902 #undef DEF_FUNCTION_TYPE_VAR_0
3903 #undef DEF_FUNCTION_TYPE_VAR_1
3904 #undef DEF_FUNCTION_TYPE_VAR_2
3905 #undef DEF_FUNCTION_TYPE_VAR_3
3906 #undef DEF_FUNCTION_TYPE_VAR_4
3907 #undef DEF_FUNCTION_TYPE_VAR_5
3908 #undef DEF_POINTER_TYPE
3909   BT_LAST
3910 };
3911
3912 typedef enum c_builtin_type builtin_type;
3913
3914 /* A temporary array for c_common_nodes_and_builtins.  Used in
3915    communication with def_fn_type.  */
3916 static tree builtin_types[(int) BT_LAST + 1];
3917
3918 /* A helper function for c_common_nodes_and_builtins.  Build function type
3919    for DEF with return type RET and N arguments.  If VAR is true, then the
3920    function should be variadic after those N arguments.
3921
3922    Takes special care not to ICE if any of the types involved are
3923    error_mark_node, which indicates that said type is not in fact available
3924    (see builtin_type_for_size).  In which case the function type as a whole
3925    should be error_mark_node.  */
3926
3927 static void
3928 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3929 {
3930   tree args = NULL, t;
3931   va_list list;
3932   int i;
3933
3934   va_start (list, n);
3935   for (i = 0; i < n; ++i)
3936     {
3937       builtin_type a = (builtin_type) va_arg (list, int);
3938       t = builtin_types[a];
3939       if (t == error_mark_node)
3940         goto egress;
3941       args = tree_cons (NULL_TREE, t, args);
3942     }
3943   va_end (list);
3944
3945   args = nreverse (args);
3946   if (!var)
3947     args = chainon (args, void_list_node);
3948
3949   t = builtin_types[ret];
3950   if (t == error_mark_node)
3951     goto egress;
3952   t = build_function_type (t, args);
3953
3954  egress:
3955   builtin_types[def] = t;
3956 }
3957
3958 /* Build builtin functions common to both C and C++ language
3959    frontends.  */
3960
3961 static void
3962 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
3963 {
3964 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3965   builtin_types[ENUM] = VALUE;
3966 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3967   def_fn_type (ENUM, RETURN, 0, 0);
3968 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3969   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3970 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3971   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3972 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3973   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3974 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3975   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3976 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3977   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3978 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3979                             ARG6)                                       \
3980   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3981 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3982                             ARG6, ARG7)                                 \
3983   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3984 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3985   def_fn_type (ENUM, RETURN, 1, 0);
3986 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3987   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3988 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3989   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3990 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3991   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3992 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3993   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3994 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3995   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3996 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3997   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3998
3999 #include "builtin-types.def"
4000
4001 #undef DEF_PRIMITIVE_TYPE
4002 #undef DEF_FUNCTION_TYPE_1
4003 #undef DEF_FUNCTION_TYPE_2
4004 #undef DEF_FUNCTION_TYPE_3
4005 #undef DEF_FUNCTION_TYPE_4
4006 #undef DEF_FUNCTION_TYPE_5
4007 #undef DEF_FUNCTION_TYPE_6
4008 #undef DEF_FUNCTION_TYPE_VAR_0
4009 #undef DEF_FUNCTION_TYPE_VAR_1
4010 #undef DEF_FUNCTION_TYPE_VAR_2
4011 #undef DEF_FUNCTION_TYPE_VAR_3
4012 #undef DEF_FUNCTION_TYPE_VAR_4
4013 #undef DEF_FUNCTION_TYPE_VAR_5
4014 #undef DEF_POINTER_TYPE
4015   builtin_types[(int) BT_LAST] = NULL_TREE;
4016
4017   c_init_attributes ();
4018
4019 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4020                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4021   if (NAME && COND)                                                     \
4022     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4023                    builtin_types[(int) TYPE],                           \
4024                    builtin_types[(int) LIBTYPE],                        \
4025                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4026                    built_in_attributes[(int) ATTRS], IMPLICIT);
4027 #include "builtins.def"
4028 #undef DEF_BUILTIN
4029
4030   targetm.init_builtins ();
4031
4032   build_common_builtin_nodes ();
4033
4034   if (flag_mudflap)
4035     mudflap_init ();
4036 }
4037
4038 /* Build tree nodes and builtin functions common to both C and C++ language
4039    frontends.  */
4040
4041 void
4042 c_common_nodes_and_builtins (void)
4043 {
4044   int char16_type_size;
4045   int char32_type_size;
4046   int wchar_type_size;
4047   tree array_domain_type;
4048   tree va_list_ref_type_node;
4049   tree va_list_arg_type_node;
4050
4051   /* Define `int' and `char' first so that dbx will output them first.  */
4052   record_builtin_type (RID_INT, NULL, integer_type_node);
4053   record_builtin_type (RID_CHAR, "char", char_type_node);
4054
4055   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4056      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4057      but not C.  Are the conditionals here needed?  */
4058   if (c_dialect_cxx ())
4059     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4060   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4061   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4062   record_builtin_type (RID_MAX, "long unsigned int",
4063                        long_unsigned_type_node);
4064   if (c_dialect_cxx ())
4065     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4066   record_builtin_type (RID_MAX, "long long int",
4067                        long_long_integer_type_node);
4068   record_builtin_type (RID_MAX, "long long unsigned int",
4069                        long_long_unsigned_type_node);
4070   if (c_dialect_cxx ())
4071     record_builtin_type (RID_MAX, "long long unsigned",
4072                          long_long_unsigned_type_node);
4073   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4074   record_builtin_type (RID_MAX, "short unsigned int",
4075                        short_unsigned_type_node);
4076   if (c_dialect_cxx ())
4077     record_builtin_type (RID_MAX, "unsigned short",
4078                          short_unsigned_type_node);
4079
4080   /* Define both `signed char' and `unsigned char'.  */
4081   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4082   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4083
4084   /* These are types that c_common_type_for_size and
4085      c_common_type_for_mode use.  */
4086   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4087                                          intQI_type_node));
4088   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4089                                          intHI_type_node));
4090   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4091                                          intSI_type_node));
4092   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4093                                          intDI_type_node));
4094 #if HOST_BITS_PER_WIDE_INT >= 64
4095   if (targetm.scalar_mode_supported_p (TImode))
4096     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4097                                            get_identifier ("__int128_t"),
4098                                            intTI_type_node));
4099 #endif
4100   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4101                                          unsigned_intQI_type_node));
4102   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4103                                          unsigned_intHI_type_node));
4104   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4105                                          unsigned_intSI_type_node));
4106   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4107                                          unsigned_intDI_type_node));
4108 #if HOST_BITS_PER_WIDE_INT >= 64
4109   if (targetm.scalar_mode_supported_p (TImode))
4110     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4111                                            get_identifier ("__uint128_t"),
4112                                            unsigned_intTI_type_node));
4113 #endif
4114
4115   /* Create the widest literal types.  */
4116   widest_integer_literal_type_node
4117     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4118   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4119                                          widest_integer_literal_type_node));
4120
4121   widest_unsigned_literal_type_node
4122     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4123   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4124                                          widest_unsigned_literal_type_node));
4125
4126   /* `unsigned long' is the standard type for sizeof.
4127      Note that stddef.h uses `unsigned long',
4128      and this must agree, even if long and int are the same size.  */
4129   size_type_node =
4130     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4131   signed_size_type_node = c_common_signed_type (size_type_node);
4132   set_sizetype (size_type_node);
4133
4134   pid_type_node =
4135     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4136
4137   build_common_tree_nodes_2 (flag_short_double);
4138
4139   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4140   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4141   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4142
4143   /* Only supported decimal floating point extension if the target
4144      actually supports underlying modes. */
4145   if (targetm.scalar_mode_supported_p (SDmode) 
4146       && targetm.scalar_mode_supported_p (DDmode)
4147       && targetm.scalar_mode_supported_p (TDmode))
4148     {