gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* FIXME: Still need to include rtl.h here (via expr.h) in a front-end file.
  23    Pretend this is a back-end file.  */
  24 #undef IN_GCC_FRONTEND
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "intl.h"
  31 #include "tree.h"
  32 #include "flags.h"
  33 #include "output.h"
  34 #include "c-pragma.h"
  35 #include "ggc.h"
  36 #include "c-common.h"
  37 #include "tm_p.h"
  38 #include "obstack.h"
  39 #include "cpplib.h"
  40 #include "target.h"
  41 #include "langhooks.h"
  42 #include "tree-inline.h"
  43 #include "toplev.h"
  44 #include "diagnostic.h"
  45 #include "tree-iterator.h"
  46 #include "hashtab.h"
  47 #include "tree-mudflap.h"
  48 #include "opts.h"
  49 #include "cgraph.h"
  50 #include "target-def.h"
  51 #include "libfuncs.h"
  52
  53 #include "expr.h" /* For vector_mode_valid_p */
  54
  55 /* FIXME: Needed for TARGET_ENUM_VA_LIST, which should be a target hook.  */
  56 #include "tm_p.h"
  57
  58 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  59
  60 /* The following symbols are subsumed in the c_global_trees array, and
  61    listed here individually for documentation purposes.
  62
  63    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  64
  65         tree short_integer_type_node;
  66         tree long_integer_type_node;
  67         tree long_long_integer_type_node;
  68         tree int128_integer_type_node;
  69
  70         tree short_unsigned_type_node;
  71         tree long_unsigned_type_node;
  72         tree long_long_unsigned_type_node;
  73         tree int128_unsigned_type_node;
  74
  75         tree truthvalue_type_node;
  76         tree truthvalue_false_node;
  77         tree truthvalue_true_node;
  78
  79         tree ptrdiff_type_node;
  80
  81         tree unsigned_char_type_node;
  82         tree signed_char_type_node;
  83         tree wchar_type_node;
  84
  85         tree char16_type_node;
  86         tree char32_type_node;
  87
  88         tree float_type_node;
  89         tree double_type_node;
  90         tree long_double_type_node;
  91
  92         tree complex_integer_type_node;
  93         tree complex_float_type_node;
  94         tree complex_double_type_node;
  95         tree complex_long_double_type_node;
  96
  97         tree dfloat32_type_node;
  98         tree dfloat64_type_node;
  99         tree_dfloat128_type_node;
 100
 101         tree intQI_type_node;
 102         tree intHI_type_node;
 103         tree intSI_type_node;
 104         tree intDI_type_node;
 105         tree intTI_type_node;
 106
 107         tree unsigned_intQI_type_node;
 108         tree unsigned_intHI_type_node;
 109         tree unsigned_intSI_type_node;
 110         tree unsigned_intDI_type_node;
 111         tree unsigned_intTI_type_node;
 112
 113         tree widest_integer_literal_type_node;
 114         tree widest_unsigned_literal_type_node;
 115
 116    Nodes for types `void *' and `const void *'.
 117
 118         tree ptr_type_node, const_ptr_type_node;
 119
 120    Nodes for types `char *' and `const char *'.
 121
 122         tree string_type_node, const_string_type_node;
 123
 124    Type `char[SOMENUMBER]'.
 125    Used when an array of char is needed and the size is irrelevant.
 126
 127         tree char_array_type_node;
 128
 129    Type `int[SOMENUMBER]' or something like it.
 130    Used when an array of int needed and the size is irrelevant.
 131
 132         tree int_array_type_node;
 133
 134    Type `wchar_t[SOMENUMBER]' or something like it.
 135    Used when a wide string literal is created.
 136
 137         tree wchar_array_type_node;
 138
 139    Type `char16_t[SOMENUMBER]' or something like it.
 140    Used when a UTF-16 string literal is created.
 141
 142         tree char16_array_type_node;
 143
 144    Type `char32_t[SOMENUMBER]' or something like it.
 145    Used when a UTF-32 string literal is created.
 146
 147         tree char32_array_type_node;
 148
 149    Type `int ()' -- used for implicit declaration of functions.
 150
 151         tree default_function_type;
 152
 153    A VOID_TYPE node, packaged in a TREE_LIST.
 154
 155         tree void_list_node;
 156
 157   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 158   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 159   VAR_DECLS, but C++ does.)
 160
 161         tree function_name_decl_node;
 162         tree pretty_function_name_decl_node;
 163         tree c99_function_name_decl_node;
 164
 165   Stack of nested function name VAR_DECLs.
 166
 167         tree saved_function_name_decls;
 168
 169 */
 170
 171 tree c_global_trees[CTI_MAX];
 172 \f
 173 /* Switches common to the C front ends.  */
 174
 175 /* Nonzero if preprocessing only.  */
 176
 177 int flag_preprocess_only;
 178
 179 /* Nonzero means don't output line number information.  */
 180
 181 char flag_no_line_commands;
 182
 183 /* Nonzero causes -E output not to be done, but directives such as
 184    #define that have side effects are still obeyed.  */
 185
 186 char flag_no_output;
 187
 188 /* Nonzero means dump macros in some fashion.  */
 189
 190 char flag_dump_macros;
 191
 192 /* Nonzero means pass #include lines through to the output.  */
 193
 194 char flag_dump_includes;
 195
 196 /* Nonzero means process PCH files while preprocessing.  */
 197
 198 bool flag_pch_preprocess;
 199
 200 /* The file name to which we should write a precompiled header, or
 201    NULL if no header will be written in this compile.  */
 202
 203 const char *pch_file;
 204
 205 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 206    user's namespace.  */
 207 int flag_iso;
 208
 209 /* Nonzero if -undef was given.  It suppresses target built-in macros
 210    and assertions.  */
 211 int flag_undef;
 212
 213 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 214
 215 int flag_no_builtin;
 216
 217 /* Nonzero means don't recognize the non-ANSI builtin functions.
 218    -ansi sets this.  */
 219
 220 int flag_no_nonansi_builtin;
 221
 222 /* Nonzero means give `double' the same size as `float'.  */
 223
 224 int flag_short_double;
 225
 226 /* Nonzero means give `wchar_t' the same size as `short'.  */
 227
 228 int flag_short_wchar;
 229
 230 /* Nonzero means allow implicit conversions between vectors with
 231    differing numbers of subparts and/or differing element types.  */
 232 int flag_lax_vector_conversions;
 233
 234 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
 235 int flag_ms_extensions;
 236
 237 /* Nonzero means don't recognize the keyword `asm'.  */
 238
 239 int flag_no_asm;
 240
 241 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
 242
 243 int flag_signed_bitfields = 1;
 244
 245 /* Warn about #pragma directives that are not recognized.  */
 246
 247 int warn_unknown_pragmas; /* Tri state variable.  */
 248
 249 /* Warn about format/argument anomalies in calls to formatted I/O functions
 250    (*printf, *scanf, strftime, strfmon, etc.).  */
 251
 252 int warn_format;
 253
 254 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
 255    with GCC this doesn't matter as __null is guaranteed to have the right
 256    size.  */
 257
 258 int warn_strict_null_sentinel;
 259
 260 /* Zero means that faster, ...NonNil variants of objc_msgSend...
 261    calls will be used in ObjC; passing nil receivers to such calls
 262    will most likely result in crashes.  */
 263 int flag_nil_receivers = 1;
 264
 265 /* Nonzero means that code generation will be altered to support
 266    "zero-link" execution.  This currently affects ObjC only, but may
 267    affect other languages in the future.  */
 268 int flag_zero_link = 0;
 269
 270 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
 271    unit.  It will inform the ObjC runtime that class definition(s) herein
 272    contained are to replace one(s) previously loaded.  */
 273 int flag_replace_objc_classes = 0;
 274
 275 /* C/ObjC language option variables.  */
 276
 277
 278 /* Nonzero means allow type mismatches in conditional expressions;
 279    just make their values `void'.  */
 280
 281 int flag_cond_mismatch;
 282
 283 /* Nonzero means enable C89 Amendment 1 features.  */
 284
 285 int flag_isoc94;
 286
 287 /* Nonzero means use the ISO C99 (or C1X) dialect of C.  */
 288
 289 int flag_isoc99;
 290
 291 /* Nonzero means use the ISO C1X dialect of C.  */
 292
 293 int flag_isoc1x;
 294
 295 /* Nonzero means that we have builtin functions, and main is an int.  */
 296
 297 int flag_hosted = 1;
 298
 299
 300 /* ObjC language option variables.  */
 301
 302
 303 /* Open and close the file for outputting class declarations, if
 304    requested (ObjC).  */
 305
 306 int flag_gen_declaration;
 307
 308 /* Tells the compiler that this is a special run.  Do not perform any
 309    compiling, instead we are to test some platform dependent features
 310    and output a C header file with appropriate definitions.  */
 311
 312 int print_struct_values;
 313
 314 /* Tells the compiler what is the constant string class for ObjC.  */
 315
 316 const char *constant_string_class_name;
 317
 318
 319 /* C++ language option variables.  */
 320
 321
 322 /* Nonzero means don't recognize any extension keywords.  */
 323
 324 int flag_no_gnu_keywords;
 325
 326 /* Nonzero means do emit exported implementations of functions even if
 327    they can be inlined.  */
 328
 329 int flag_implement_inlines = 1;
 330
 331 /* Nonzero means that implicit instantiations will be emitted if needed.  */
 332
 333 int flag_implicit_templates = 1;
 334
 335 /* Nonzero means that implicit instantiations of inline templates will be
 336    emitted if needed, even if instantiations of non-inline templates
 337    aren't.  */
 338
 339 int flag_implicit_inline_templates = 1;
 340
 341 /* Nonzero means generate separate instantiation control files and
 342    juggle them at link time.  */
 343
 344 int flag_use_repository;
 345
 346 /* Nonzero if we want to issue diagnostics that the standard says are not
 347    required.  */
 348
 349 int flag_optional_diags = 1;
 350
 351 /* Nonzero means we should attempt to elide constructors when possible.  */
 352
 353 int flag_elide_constructors = 1;
 354
 355 /* Nonzero means that member functions defined in class scope are
 356    inline by default.  */
 357
 358 int flag_default_inline = 1;
 359
 360 /* Controls whether compiler generates 'type descriptor' that give
 361    run-time type information.  */
 362
 363 int flag_rtti = 1;
 364
 365 /* Nonzero if we want to conserve space in the .o files.  We do this
 366    by putting uninitialized data and runtime initialized data into
 367    .common instead of .data at the expense of not flagging multiple
 368    definitions.  */
 369
 370 int flag_conserve_space;
 371
 372 /* Nonzero if we want to obey access control semantics.  */
 373
 374 int flag_access_control = 1;
 375
 376 /* Nonzero if we want to check the return value of new and avoid calling
 377    constructors if it is a null pointer.  */
 378
 379 int flag_check_new;
 380
 381 /* The C++ dialect being used. C++98 is the default.  */
 382
 383 enum cxx_dialect cxx_dialect = cxx98;
 384
 385 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
 386    initialization variables.
 387    0: Old rules, set by -fno-for-scope.
 388    2: New ISO rules, set by -ffor-scope.
 389    1: Try to implement new ISO rules, but with backup compatibility
 390    (and warnings).  This is the default, for now.  */
 391
 392 int flag_new_for_scope = 1;
 393
 394 /* Nonzero if we want to emit defined symbols with common-like linkage as
 395    weak symbols where possible, in order to conform to C++ semantics.
 396    Otherwise, emit them as local symbols.  */
 397
 398 int flag_weak = 1;
 399
 400 /* 0 means we want the preprocessor to not emit line directives for
 401    the current working directory.  1 means we want it to do it.  -1
 402    means we should decide depending on whether debugging information
 403    is being emitted or not.  */
 404
 405 int flag_working_directory = -1;
 406
 407 /* Nonzero to use __cxa_atexit, rather than atexit, to register
 408    destructors for local statics and global objects.  '2' means it has been
 409    set nonzero as a default, not by a command-line flag.  */
 410
 411 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
 412
 413 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
 414    code.  '2' means it has not been set explicitly on the command line.  */
 415
 416 int flag_use_cxa_get_exception_ptr = 2;
 417
 418 /* Nonzero means to implement standard semantics for exception
 419    specifications, calling unexpected if an exception is thrown that
 420    doesn't match the specification.  Zero means to treat them as
 421    assertions and optimize accordingly, but not check them.  */
 422
 423 int flag_enforce_eh_specs = 1;
 424
 425 /* Nonzero means to generate thread-safe code for initializing local
 426    statics.  */
 427
 428 int flag_threadsafe_statics = 1;
 429
 430 /* Nonzero if we want to pretty-print template specializations as the
 431    template signature followed by the arguments.  */
 432
 433 int flag_pretty_templates = 1;
 434
 435 /* Maximum template instantiation depth.  This limit exists to limit the
 436    time it takes to notice infinite template instantiations; the default
 437    value of 1024 is likely to be in the next C++ standard.  */
 438
 439 int max_tinst_depth = 1024;
 440
 441
 442
 443 /* The elements of `ridpointers' are identifier nodes for the reserved
 444    type names and storage classes.  It is indexed by a RID_... value.  */
 445 tree *ridpointers;
 446
 447 tree (*make_fname_decl) (location_t, tree, int);
 448
 449 /* Nonzero means don't warn about problems that occur when the code is
 450    executed.  */
 451 int c_inhibit_evaluation_warnings;
 452
 453 /* Whether lexing has been completed, so subsequent preprocessor
 454    errors should use the compiler's input_location.  */
 455 bool done_lexing = false;
 456
 457 /* Information about how a function name is generated.  */
 458 struct fname_var_t
 459 {
 460   tree *const decl;     /* pointer to the VAR_DECL.  */
 461   const unsigned rid;   /* RID number for the identifier.  */
 462   const int pretty;     /* How pretty is it? */
 463 };
 464
 465 /* The three ways of getting then name of the current function.  */
 466
 467 const struct fname_var_t fname_vars[] =
 468 {
 469   /* C99 compliant __func__, must be first.  */
 470   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 471   /* GCC __FUNCTION__ compliant.  */
 472   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 473   /* GCC __PRETTY_FUNCTION__ compliant.  */
 474   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 475   {NULL, 0, 0},
 476 };
 477
 478 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
 479 static tree check_case_value (tree);
 480 static bool check_case_bounds (tree, tree, tree *, tree *);
 481
 482 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
 483 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
 484 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
 485 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
 486 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
 487 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
 488 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
 489 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
 490 static tree handle_always_inline_attribute (tree *, tree, tree, int,
 491                                             bool *);
 492 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
 493 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
 494 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
 495 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
 496 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
 497 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
 498 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
 499                                                  bool *);
 500 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
 501 static tree handle_transparent_union_attribute (tree *, tree, tree,
 502                                                 int, bool *);
 503 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
 504 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
 505 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
 506 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
 507 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
 508 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
 509 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
 510 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
 511 static tree handle_visibility_attribute (tree *, tree, tree, int,
 512                                          bool *);
 513 static tree handle_tls_model_attribute (tree *, tree, tree, int,
 514                                         bool *);
 515 static tree handle_no_instrument_function_attribute (tree *, tree,
 516                                                      tree, int, bool *);
 517 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
 518 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
 519 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
 520                                              bool *);
 521 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
 522 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
 523 static tree handle_deprecated_attribute (tree *, tree, tree, int,
 524                                          bool *);
 525 static tree handle_vector_size_attribute (tree *, tree, tree, int,
 526                                           bool *);
 527 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
 528 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
 529 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
 530 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
 531                                                  bool *);
 532 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
 533 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
 534 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
 535 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
 536 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
 537 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
 538
 539 static void check_function_nonnull (tree, int, tree *);
 540 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
 541 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
 542 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
 543 static int resort_field_decl_cmp (const void *, const void *);
 544
 545 /* Reserved words.  The third field is a mask: keywords are disabled
 546    if they match the mask.
 547
 548    Masks for languages:
 549    C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
 550    C --std=c99: D_CXXONLY | D_OBJC
 551    ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
 552    C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
 553    C++ --std=c0x: D_CONLY | D_OBJC
 554    ObjC++ is like C++ except that D_OBJC is not set
 555
 556    If -fno-asm is used, D_ASM is added to the mask.  If
 557    -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in
 558    C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
 559    In C with -Wc++-compat, we warn if D_CXXWARN is set.  */
 560
 561 const struct c_common_resword c_common_reswords[] =
 562 {
 563   { "_Bool",            RID_BOOL,      D_CONLY },
 564   { "_Complex",         RID_COMPLEX,    0 },
 565   { "_Imaginary",       RID_IMAGINARY, D_CONLY },
 566   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
 567   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
 568   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
 569   { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
 570   { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
 571   { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
 572   { "_Static_assert",   RID_STATIC_ASSERT, D_CONLY },
 573   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 574   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 575   { "__alignof",        RID_ALIGNOF,    0 },
 576   { "__alignof__",      RID_ALIGNOF,    0 },
 577   { "__asm",            RID_ASM,        0 },
 578   { "__asm__",          RID_ASM,        0 },
 579   { "__attribute",      RID_ATTRIBUTE,  0 },
 580   { "__attribute__",    RID_ATTRIBUTE,  0 },
 581   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
 582   { "__builtin_offsetof", RID_OFFSETOF, 0 },
 583   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
 584   { "__builtin_va_arg", RID_VA_ARG,     0 },
 585   { "__complex",        RID_COMPLEX,    0 },
 586   { "__complex__",      RID_COMPLEX,    0 },
 587   { "__const",          RID_CONST,      0 },
 588   { "__const__",        RID_CONST,      0 },
 589   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
 590   { "__extension__",    RID_EXTENSION,  0 },
 591   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
 592   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
 593   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
 594   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
 595   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
 596   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
 597   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
 598   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
 599   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
 600   { "__int128",         RID_INT128,     0 },
 601   { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },
 602   { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },
 603   { "__is_class",       RID_IS_CLASS,   D_CXXONLY },
 604   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
 605   { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },
 606   { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },
 607   { "__is_pod",         RID_IS_POD,     D_CXXONLY },
 608   { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
 609   { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
 610   { "__is_trivial",     RID_IS_TRIVIAL, D_CXXONLY },
 611   { "__is_union",       RID_IS_UNION,   D_CXXONLY },
 612   { "__imag",           RID_IMAGPART,   0 },
 613   { "__imag__",         RID_IMAGPART,   0 },
 614   { "__inline",         RID_INLINE,     0 },
 615   { "__inline__",       RID_INLINE,     0 },
 616   { "__label__",        RID_LABEL,      0 },
 617   { "__null",           RID_NULL,       0 },
 618   { "__real",           RID_REALPART,   0 },
 619   { "__real__",         RID_REALPART,   0 },
 620   { "__restrict",       RID_RESTRICT,   0 },
 621   { "__restrict__",     RID_RESTRICT,   0 },
 622   { "__signed",         RID_SIGNED,     0 },
 623   { "__signed__",       RID_SIGNED,     0 },
 624   { "__thread",         RID_THREAD,     0 },
 625   { "__typeof",         RID_TYPEOF,     0 },
 626   { "__typeof__",       RID_TYPEOF,     0 },
 627   { "__volatile",       RID_VOLATILE,   0 },
 628   { "__volatile__",     RID_VOLATILE,   0 },
 629   { "alignof",          RID_ALIGNOF,    D_CXXONLY | D_CXX0X | D_CXXWARN },
 630   { "asm",              RID_ASM,        D_ASM },
 631   { "auto",             RID_AUTO,       0 },
 632   { "bool",             RID_BOOL,       D_CXXONLY | D_CXXWARN },
 633   { "break",            RID_BREAK,      0 },
 634   { "case",             RID_CASE,       0 },
 635   { "catch",            RID_CATCH,      D_CXX_OBJC | D_CXXWARN },
 636   { "char",             RID_CHAR,       0 },
 637   { "char16_t",         RID_CHAR16,     D_CXXONLY | D_CXX0X | D_CXXWARN },
 638   { "char32_t",         RID_CHAR32,     D_CXXONLY | D_CXX0X | D_CXXWARN },
 639   { "class",            RID_CLASS,      D_CXX_OBJC | D_CXXWARN },
 640   { "const",            RID_CONST,      0 },
 641   { "constexpr",        RID_CONSTEXPR,  D_CXXONLY | D_CXX0X | D_CXXWARN },
 642   { "const_cast",       RID_CONSTCAST,  D_CXXONLY | D_CXXWARN },
 643   { "continue",         RID_CONTINUE,   0 },
 644   { "decltype",         RID_DECLTYPE,   D_CXXONLY | D_CXX0X | D_CXXWARN },
 645   { "default",          RID_DEFAULT,    0 },
 646   { "delete",           RID_DELETE,     D_CXXONLY | D_CXXWARN },
 647   { "do",               RID_DO,         0 },
 648   { "double",           RID_DOUBLE,     0 },
 649   { "dynamic_cast",     RID_DYNCAST,    D_CXXONLY | D_CXXWARN },
 650   { "else",             RID_ELSE,       0 },
 651   { "enum",             RID_ENUM,       0 },
 652   { "explicit",         RID_EXPLICIT,   D_CXXONLY | D_CXXWARN },
 653   { "export",           RID_EXPORT,     D_CXXONLY | D_CXXWARN },
 654   { "extern",           RID_EXTERN,     0 },
 655   { "false",            RID_FALSE,      D_CXXONLY | D_CXXWARN },
 656   { "float",            RID_FLOAT,      0 },
 657   { "for",              RID_FOR,        0 },
 658   { "friend",           RID_FRIEND,     D_CXXONLY | D_CXXWARN },
 659   { "goto",             RID_GOTO,       0 },
 660   { "if",               RID_IF,         0 },
 661   { "inline",           RID_INLINE,     D_EXT89 },
 662   { "int",              RID_INT,        0 },
 663   { "long",             RID_LONG,       0 },
 664   { "mutable",          RID_MUTABLE,    D_CXXONLY | D_CXXWARN },
 665   { "namespace",        RID_NAMESPACE,  D_CXXONLY | D_CXXWARN },
 666   { "new",              RID_NEW,        D_CXXONLY | D_CXXWARN },
 667   { "nullptr",          RID_NULLPTR,    D_CXXONLY | D_CXX0X | D_CXXWARN },
 668   { "operator",         RID_OPERATOR,   D_CXXONLY | D_CXXWARN },
 669   { "private",          RID_PRIVATE,    D_CXX_OBJC | D_CXXWARN },
 670   { "protected",        RID_PROTECTED,  D_CXX_OBJC | D_CXXWARN },
 671   { "public",           RID_PUBLIC,     D_CXX_OBJC | D_CXXWARN },
 672   { "register",         RID_REGISTER,   0 },
 673   { "reinterpret_cast", RID_REINTCAST,  D_CXXONLY | D_CXXWARN },
 674   { "restrict",         RID_RESTRICT,   D_CONLY | D_C99 },
 675   { "return",           RID_RETURN,     0 },
 676   { "short",            RID_SHORT,      0 },
 677   { "signed",           RID_SIGNED,     0 },
 678   { "sizeof",           RID_SIZEOF,     0 },
 679   { "static",           RID_STATIC,     0 },
 680   { "static_assert",    RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
 681   { "static_cast",      RID_STATCAST,   D_CXXONLY | D_CXXWARN },
 682   { "struct",           RID_STRUCT,     0 },
 683   { "switch",           RID_SWITCH,     0 },
 684   { "template",         RID_TEMPLATE,   D_CXXONLY | D_CXXWARN },
 685   { "this",             RID_THIS,       D_CXXONLY | D_CXXWARN },
 686   { "throw",            RID_THROW,      D_CXX_OBJC | D_CXXWARN },
 687   { "true",             RID_TRUE,       D_CXXONLY | D_CXXWARN },
 688   { "try",              RID_TRY,        D_CXX_OBJC | D_CXXWARN },
 689   { "typedef",          RID_TYPEDEF,    0 },
 690   { "typename",         RID_TYPENAME,   D_CXXONLY | D_CXXWARN },
 691   { "typeid",           RID_TYPEID,     D_CXXONLY | D_CXXWARN },
 692   { "typeof",           RID_TYPEOF,     D_ASM | D_EXT },
 693   { "union",            RID_UNION,      0 },
 694   { "unsigned",         RID_UNSIGNED,   0 },
 695   { "using",            RID_USING,      D_CXXONLY | D_CXXWARN },
 696   { "virtual",          RID_VIRTUAL,    D_CXXONLY | D_CXXWARN },
 697   { "void",             RID_VOID,       0 },
 698   { "volatile",         RID_VOLATILE,   0 },
 699   { "wchar_t",          RID_WCHAR,      D_CXXONLY },
 700   { "while",            RID_WHILE,      0 },
 701   /* These Objective-C keywords are recognized only immediately after
 702      an '@'.  */
 703   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
 704   { "defs",             RID_AT_DEFS,            D_OBJC },
 705   { "encode",           RID_AT_ENCODE,          D_OBJC },
 706   { "end",              RID_AT_END,             D_OBJC },
 707   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
 708   { "interface",        RID_AT_INTERFACE,       D_OBJC },
 709   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
 710   { "selector",         RID_AT_SELECTOR,        D_OBJC },
 711   { "finally",          RID_AT_FINALLY,         D_OBJC },
 712   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
 713   /* These are recognized only in protocol-qualifier context
 714      (see above) */
 715   { "bycopy",           RID_BYCOPY,             D_OBJC },
 716   { "byref",            RID_BYREF,              D_OBJC },
 717   { "in",               RID_IN,                 D_OBJC },
 718   { "inout",            RID_INOUT,              D_OBJC },
 719   { "oneway",           RID_ONEWAY,             D_OBJC },
 720   { "out",              RID_OUT,                D_OBJC },
 721 };
 722
 723 const unsigned int num_c_common_reswords =
 724   sizeof c_common_reswords / sizeof (struct c_common_resword);
 725
 726 /* Table of machine-independent attributes common to all C-like languages.  */
 727 const struct attribute_spec c_common_attribute_table[] =
 728 {
 729   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 730   { "packed",                 0, 0, false, false, false,
 731                               handle_packed_attribute },
 732   { "nocommon",               0, 0, true,  false, false,
 733                               handle_nocommon_attribute },
 734   { "common",                 0, 0, true,  false, false,
 735                               handle_common_attribute },
 736   /* FIXME: logically, noreturn attributes should be listed as
 737      "false, true, true" and apply to function types.  But implementing this
 738      would require all the places in the compiler that use TREE_THIS_VOLATILE
 739      on a decl to identify non-returning functions to be located and fixed
 740      to check the function type instead.  */
 741   { "noreturn",               0, 0, true,  false, false,
 742                               handle_noreturn_attribute },
 743   { "volatile",               0, 0, true,  false, false,
 744                               handle_noreturn_attribute },
 745   { "noinline",               0, 0, true,  false, false,
 746                               handle_noinline_attribute },
 747   { "noclone",                0, 0, true,  false, false,
 748                               handle_noclone_attribute },
 749   { "always_inline",          0, 0, true,  false, false,
 750                               handle_always_inline_attribute },
 751   { "gnu_inline",             0, 0, true,  false, false,
 752                               handle_gnu_inline_attribute },
 753   { "artificial",             0, 0, true,  false, false,
 754                               handle_artificial_attribute },
 755   { "flatten",                0, 0, true,  false, false,
 756                               handle_flatten_attribute },
 757   { "used",                   0, 0, true,  false, false,
 758                               handle_used_attribute },
 759   { "unused",                 0, 0, false, false, false,
 760                               handle_unused_attribute },
 761   { "externally_visible",     0, 0, true,  false, false,
 762                               handle_externally_visible_attribute },
 763   /* The same comments as for noreturn attributes apply to const ones.  */
 764   { "const",                  0, 0, true,  false, false,
 765                               handle_const_attribute },
 766   { "transparent_union",      0, 0, false, false, false,
 767                               handle_transparent_union_attribute },
 768   { "constructor",            0, 1, true,  false, false,
 769                               handle_constructor_attribute },
 770   { "destructor",             0, 1, true,  false, false,
 771                               handle_destructor_attribute },
 772   { "mode",                   1, 1, false,  true, false,
 773                               handle_mode_attribute },
 774   { "section",                1, 1, true,  false, false,
 775                               handle_section_attribute },
 776   { "aligned",                0, 1, false, false, false,
 777                               handle_aligned_attribute },
 778   { "weak",                   0, 0, true,  false, false,
 779                               handle_weak_attribute },
 780   { "alias",                  1, 1, true,  false, false,
 781                               handle_alias_attribute },
 782   { "weakref",                0, 1, true,  false, false,
 783                               handle_weakref_attribute },
 784   { "no_instrument_function", 0, 0, true,  false, false,
 785                               handle_no_instrument_function_attribute },
 786   { "malloc",                 0, 0, true,  false, false,
 787                               handle_malloc_attribute },
 788   { "returns_twice",          0, 0, true,  false, false,
 789                               handle_returns_twice_attribute },
 790   { "no_stack_limit",         0, 0, true,  false, false,
 791                               handle_no_limit_stack_attribute },
 792   { "pure",                   0, 0, true,  false, false,
 793                               handle_pure_attribute },
 794   /* For internal use (marking of builtins) only.  The name contains space
 795      to prevent its usage in source code.  */
 796   { "no vops",                0, 0, true,  false, false,
 797                               handle_novops_attribute },
 798   { "deprecated",             0, 1, false, false, false,
 799                               handle_deprecated_attribute },
 800   { "vector_size",            1, 1, false, true, false,
 801                               handle_vector_size_attribute },
 802   { "visibility",             1, 1, false, false, false,
 803                               handle_visibility_attribute },
 804   { "tls_model",              1, 1, true,  false, false,
 805                               handle_tls_model_attribute },
 806   { "nonnull",                0, -1, false, true, true,
 807                               handle_nonnull_attribute },
 808   { "nothrow",                0, 0, true,  false, false,
 809                               handle_nothrow_attribute },
 810   { "may_alias",              0, 0, false, true, false, NULL },
 811   { "cleanup",                1, 1, true, false, false,
 812                               handle_cleanup_attribute },
 813   { "warn_unused_result",     0, 0, false, true, true,
 814                               handle_warn_unused_result_attribute },
 815   { "sentinel",               0, 1, false, true, true,
 816                               handle_sentinel_attribute },
 817   /* For internal use (marking of builtins) only.  The name contains space
 818      to prevent its usage in source code.  */
 819   { "type generic",           0, 0, false, true, true,
 820                               handle_type_generic_attribute },
 821   { "alloc_size",             1, 2, false, true, true,
 822                               handle_alloc_size_attribute },
 823   { "cold",                   0, 0, true,  false, false,
 824                               handle_cold_attribute },
 825   { "hot",                    0, 0, true,  false, false,
 826                               handle_hot_attribute },
 827   { "warning",                1, 1, true,  false, false,
 828                               handle_error_attribute },
 829   { "error",                  1, 1, true,  false, false,
 830                               handle_error_attribute },
 831   { "target",                 1, -1, true, false, false,
 832                               handle_target_attribute },
 833   { "optimize",               1, -1, true, false, false,
 834                               handle_optimize_attribute },
 835   /* For internal use (marking of builtins and runtime functions) only.
 836      The name contains space to prevent its usage in source code.  */
 837   { "fn spec",                1, 1, false, true, true,
 838                               handle_fnspec_attribute },
 839   { NULL,                     0, 0, false, false, false, NULL }
 840 };
 841
 842 /* Give the specifications for the format attributes, used by C and all
 843    descendants.  */
 844
 845 const struct attribute_spec c_common_format_attribute_table[] =
 846 {
 847   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 848   { "format",                 3, 3, false, true,  true,
 849                               handle_format_attribute },
 850   { "format_arg",             1, 1, false, true,  true,
 851                               handle_format_arg_attribute },
 852   { NULL,                     0, 0, false, false, false, NULL }
 853 };
 854
 855 /* Return identifier for address space AS.  */
 856
 857 const char *
 858 c_addr_space_name (addr_space_t as)
 859 {
 860   int rid = RID_FIRST_ADDR_SPACE + as;
 861   gcc_assert (ridpointers [rid]);
 862   return IDENTIFIER_POINTER (ridpointers [rid]);
 863 }
 864
 865 /* Push current bindings for the function name VAR_DECLS.  */
 866
 867 void
 868 start_fname_decls (void)
 869 {
 870   unsigned ix;
 871   tree saved = NULL_TREE;
 872
 873   for (ix = 0; fname_vars[ix].decl; ix++)
 874     {
 875       tree decl = *fname_vars[ix].decl;
 876
 877       if (decl)
 878         {
 879           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
 880           *fname_vars[ix].decl = NULL_TREE;
 881         }
 882     }
 883   if (saved || saved_function_name_decls)
 884     /* Normally they'll have been NULL, so only push if we've got a
 885        stack, or they are non-NULL.  */
 886     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 887                                            saved_function_name_decls);
 888 }
 889
 890 /* Finish up the current bindings, adding them into the current function's
 891    statement tree.  This must be done _before_ finish_stmt_tree is called.
 892    If there is no current function, we must be at file scope and no statements
 893    are involved. Pop the previous bindings.  */
 894
 895 void
 896 finish_fname_decls (void)
 897 {
 898   unsigned ix;
 899   tree stmts = NULL_TREE;
 900   tree stack = saved_function_name_decls;
 901
 902   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 903     append_to_statement_list (TREE_VALUE (stack), &stmts);
 904
 905   if (stmts)
 906     {
 907       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
 908
 909       if (TREE_CODE (*bodyp) == BIND_EXPR)
 910         bodyp = &BIND_EXPR_BODY (*bodyp);
 911
 912       append_to_statement_list_force (*bodyp, &stmts);
 913       *bodyp = stmts;
 914     }
 915
 916   for (ix = 0; fname_vars[ix].decl; ix++)
 917     *fname_vars[ix].decl = NULL_TREE;
 918
 919   if (stack)
 920     {
 921       /* We had saved values, restore them.  */
 922       tree saved;
 923
 924       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 925         {
 926           tree decl = TREE_PURPOSE (saved);
 927           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 928
 929           *fname_vars[ix].decl = decl;
 930         }
 931       stack = TREE_CHAIN (stack);
 932     }
 933   saved_function_name_decls = stack;
 934 }
 935
 936 /* Return the text name of the current function, suitably prettified
 937    by PRETTY_P.  Return string must be freed by caller.  */
 938
 939 const char *
 940 fname_as_string (int pretty_p)
 941 {
 942   const char *name = "top level";
 943   char *namep;
 944   int vrb = 2, len;
 945   cpp_string cstr = { 0, 0 }, strname;
 946
 947   if (!pretty_p)
 948     {
 949       name = "";
 950       vrb = 0;
 951     }
 952
 953   if (current_function_decl)
 954     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
 955
 956   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
 957
 958   namep = XNEWVEC (char, len);
 959   snprintf (namep, len, "\"%s\"", name);
 960   strname.text = (unsigned char *) namep;
 961   strname.len = len - 1;
 962
 963   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
 964     {
 965       XDELETEVEC (namep);
 966       return (const char *) cstr.text;
 967     }
 968
 969   return namep;
 970 }
 971
 972 /* Return the VAR_DECL for a const char array naming the current
 973    function. If the VAR_DECL has not yet been created, create it
 974    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 975    ID is its name (unfortunately C and C++ hold the RID values of
 976    keywords in different places, so we can't derive RID from ID in
 977    this language independent code. LOC is the location of the
 978    function.  */
 979
 980 tree
 981 fname_decl (location_t loc, unsigned int rid, tree id)
 982 {
 983   unsigned ix;
 984   tree decl = NULL_TREE;
 985
 986   for (ix = 0; fname_vars[ix].decl; ix++)
 987     if (fname_vars[ix].rid == rid)
 988       break;
 989
 990   decl = *fname_vars[ix].decl;
 991   if (!decl)
 992     {
 993       /* If a tree is built here, it would normally have the lineno of
 994          the current statement.  Later this tree will be moved to the
 995          beginning of the function and this line number will be wrong.
 996          To avoid this problem set the lineno to 0 here; that prevents
 997          it from appearing in the RTL.  */
 998       tree stmts;
 999       location_t saved_location = input_location;
1000       input_location = UNKNOWN_LOCATION;
1001
1002       stmts = push_stmt_list ();
1003       decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
1004       stmts = pop_stmt_list (stmts);
1005       if (!IS_EMPTY_STMT (stmts))
1006         saved_function_name_decls
1007           = tree_cons (decl, stmts, saved_function_name_decls);
1008       *fname_vars[ix].decl = decl;
1009       input_location = saved_location;
1010     }
1011   if (!ix && !current_function_decl)
1012     pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1013
1014   return decl;
1015 }
1016
1017 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
1018
1019 tree
1020 fix_string_type (tree value)
1021 {
1022   int length = TREE_STRING_LENGTH (value);
1023   int nchars;
1024   tree e_type, i_type, a_type;
1025
1026   /* Compute the number of elements, for the array type.  */
1027   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1028     {
1029       nchars = length;
1030       e_type = char_type_node;
1031     }
1032   else if (TREE_TYPE (value) == char16_array_type_node)
1033     {
1034       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1035       e_type = char16_type_node;
1036     }
1037   else if (TREE_TYPE (value) == char32_array_type_node)
1038     {
1039       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1040       e_type = char32_type_node;
1041     }
1042   else
1043     {
1044       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1045       e_type = wchar_type_node;
1046     }
1047
1048   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
1049      limit in C++98 Annex B is very large (65536) and is not normative,
1050      so we do not diagnose it (warn_overlength_strings is forced off
1051      in c_common_post_options).  */
1052   if (warn_overlength_strings)
1053     {
1054       const int nchars_max = flag_isoc99 ? 4095 : 509;
1055       const int relevant_std = flag_isoc99 ? 99 : 90;
1056       if (nchars - 1 > nchars_max)
1057         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
1058            separate the %d from the 'C'.  'ISO' should not be
1059            translated, but it may be moved after 'C%d' in languages
1060            where modifiers follow nouns.  */
1061         pedwarn (input_location, OPT_Woverlength_strings,
1062                  "string length %qd is greater than the length %qd "
1063                  "ISO C%d compilers are required to support",
1064                  nchars - 1, nchars_max, relevant_std);
1065     }
1066
1067   /* Create the array type for the string constant.  The ISO C++
1068      standard says that a string literal has type `const char[N]' or
1069      `const wchar_t[N]'.  We use the same logic when invoked as a C
1070      front-end with -Wwrite-strings.
1071      ??? We should change the type of an expression depending on the
1072      state of a warning flag.  We should just be warning -- see how
1073      this is handled in the C++ front-end for the deprecated implicit
1074      conversion from string literals to `char*' or `wchar_t*'.
1075
1076      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1077      array type being the unqualified version of that type.
1078      Therefore, if we are constructing an array of const char, we must
1079      construct the matching unqualified array type first.  The C front
1080      end does not require this, but it does no harm, so we do it
1081      unconditionally.  */
1082   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1083   a_type = build_array_type (e_type, i_type);
1084   if (c_dialect_cxx() || warn_write_strings)
1085     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1086
1087   TREE_TYPE (value) = a_type;
1088   TREE_CONSTANT (value) = 1;
1089   TREE_READONLY (value) = 1;
1090   TREE_STATIC (value) = 1;
1091   return value;
1092 }
1093 \f
1094 /* Fully fold EXPR, an expression that was not folded (beyond integer
1095    constant expressions and null pointer constants) when being built
1096    up.  If IN_INIT, this is in a static initializer and certain
1097    changes are made to the folding done.  Clear *MAYBE_CONST if
1098    MAYBE_CONST is not NULL and EXPR is definitely not a constant
1099    expression because it contains an evaluated operator (in C99) or an
1100    operator outside of sizeof returning an integer constant (in C90)
1101    not permitted in constant expressions, or because it contains an
1102    evaluated arithmetic overflow.  (*MAYBE_CONST should typically be
1103    set to true by callers before calling this function.)  Return the
1104    folded expression.  Function arguments have already been folded
1105    before calling this function, as have the contents of SAVE_EXPR,
1106    TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1107    C_MAYBE_CONST_EXPR.  */
1108
1109 tree
1110 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1111 {
1112   tree ret;
1113   tree eptype = NULL_TREE;
1114   bool dummy = true;
1115   bool maybe_const_itself = true;
1116   location_t loc = EXPR_LOCATION (expr);
1117
1118   /* This function is not relevant to C++ because C++ folds while
1119      parsing, and may need changes to be correct for C++ when C++
1120      stops folding while parsing.  */
1121   if (c_dialect_cxx ())
1122     gcc_unreachable ();
1123
1124   if (!maybe_const)
1125     maybe_const = &dummy;
1126   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1127     {
1128       eptype = TREE_TYPE (expr);
1129       expr = TREE_OPERAND (expr, 0);
1130     }
1131   ret = c_fully_fold_internal (expr, in_init, maybe_const,
1132                                &maybe_const_itself);
1133   if (eptype)
1134     ret = fold_convert_loc (loc, eptype, ret);
1135   *maybe_const &= maybe_const_itself;
1136   return ret;
1137 }
1138
1139 /* Internal helper for c_fully_fold.  EXPR and IN_INIT are as for
1140    c_fully_fold.  *MAYBE_CONST_OPERANDS is cleared because of operands
1141    not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1142    arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1143    both evaluated and unevaluated subexpressions while
1144    *MAYBE_CONST_ITSELF is carried from only evaluated
1145    subexpressions).  */
1146
1147 static tree
1148 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1149                        bool *maybe_const_itself)
1150 {
1151   tree ret = expr;
1152   enum tree_code code = TREE_CODE (expr);
1153   enum tree_code_class kind = TREE_CODE_CLASS (code);
1154   location_t loc = EXPR_LOCATION (expr);
1155   tree op0, op1, op2, op3;
1156   tree orig_op0, orig_op1, orig_op2;
1157   bool op0_const = true, op1_const = true, op2_const = true;
1158   bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1159   bool nowarning = TREE_NO_WARNING (expr);
1160   int unused_p;
1161
1162   /* This function is not relevant to C++ because C++ folds while
1163      parsing, and may need changes to be correct for C++ when C++
1164      stops folding while parsing.  */
1165   if (c_dialect_cxx ())
1166     gcc_unreachable ();
1167
1168   /* Constants, declarations, statements, errors, SAVE_EXPRs and
1169      anything else not counted as an expression cannot usefully be
1170      folded further at this point.  */
1171   if (!IS_EXPR_CODE_CLASS (kind)
1172       || kind == tcc_statement
1173       || code == SAVE_EXPR)
1174     return expr;
1175
1176   /* Operands of variable-length expressions (function calls) have
1177      already been folded, as have __builtin_* function calls, and such
1178      expressions cannot occur in constant expressions.  */
1179   if (kind == tcc_vl_exp)
1180     {
1181       *maybe_const_operands = false;
1182       ret = fold (expr);
1183       goto out;
1184     }
1185
1186   if (code == C_MAYBE_CONST_EXPR)
1187     {
1188       tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1189       tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1190       if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1191         *maybe_const_operands = false;
1192       if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1193         *maybe_const_itself = false;
1194       if (pre && !in_init)
1195         ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1196       else
1197         ret = inner;
1198       goto out;
1199     }
1200
1201   /* Assignment, increment, decrement, function call and comma
1202      operators, and statement expressions, cannot occur in constant
1203      expressions if evaluated / outside of sizeof.  (Function calls
1204      were handled above, though VA_ARG_EXPR is treated like a function
1205      call here, and statement expressions are handled through
1206      C_MAYBE_CONST_EXPR to avoid folding inside them.)  */
1207   switch (code)
1208     {
1209     case MODIFY_EXPR:
1210     case PREDECREMENT_EXPR:
1211     case PREINCREMENT_EXPR:
1212     case POSTDECREMENT_EXPR:
1213     case POSTINCREMENT_EXPR:
1214     case COMPOUND_EXPR:
1215       *maybe_const_operands = false;
1216       break;
1217
1218     case VA_ARG_EXPR:
1219     case TARGET_EXPR:
1220     case BIND_EXPR:
1221     case OBJ_TYPE_REF:
1222       *maybe_const_operands = false;
1223       ret = fold (expr);
1224       goto out;
1225
1226     default:
1227       break;
1228     }
1229
1230   /* Fold individual tree codes as appropriate.  */
1231   switch (code)
1232     {
1233     case COMPOUND_LITERAL_EXPR:
1234       /* Any non-constancy will have been marked in a containing
1235          C_MAYBE_CONST_EXPR; there is no more folding to do here.  */
1236       goto out;
1237
1238     case COMPONENT_REF:
1239       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1240       op1 = TREE_OPERAND (expr, 1);
1241       op2 = TREE_OPERAND (expr, 2);
1242       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1243                                    maybe_const_itself);
1244       STRIP_TYPE_NOPS (op0);
1245       if (op0 != orig_op0)
1246         ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1247       if (ret != expr)
1248         {
1249           TREE_READONLY (ret) = TREE_READONLY (expr);
1250           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1251         }
1252       goto out;
1253
1254     case ARRAY_REF:
1255       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1256       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1257       op2 = TREE_OPERAND (expr, 2);
1258       op3 = TREE_OPERAND (expr, 3);
1259       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1260                                    maybe_const_itself);
1261       STRIP_TYPE_NOPS (op0);
1262       op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1263                                    maybe_const_itself);
1264       STRIP_TYPE_NOPS (op1);
1265       op1 = decl_constant_value_for_optimization (op1);
1266       if (op0 != orig_op0 || op1 != orig_op1)
1267         ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1268       if (ret != expr)
1269         {
1270           TREE_READONLY (ret) = TREE_READONLY (expr);
1271           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1272           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1273         }
1274       ret = fold (ret);
1275       goto out;
1276
1277     case COMPOUND_EXPR:
1278     case MODIFY_EXPR:
1279     case PREDECREMENT_EXPR:
1280     case PREINCREMENT_EXPR:
1281     case POSTDECREMENT_EXPR:
1282     case POSTINCREMENT_EXPR:
1283     case PLUS_EXPR:
1284     case MINUS_EXPR:
1285     case MULT_EXPR:
1286     case POINTER_PLUS_EXPR:
1287     case TRUNC_DIV_EXPR:
1288     case CEIL_DIV_EXPR:
1289     case FLOOR_DIV_EXPR:
1290     case TRUNC_MOD_EXPR:
1291     case RDIV_EXPR:
1292     case EXACT_DIV_EXPR:
1293     case LSHIFT_EXPR:
1294     case RSHIFT_EXPR:
1295     case BIT_IOR_EXPR:
1296     case BIT_XOR_EXPR:
1297     case BIT_AND_EXPR:
1298     case LT_EXPR:
1299     case LE_EXPR:
1300     case GT_EXPR:
1301     case GE_EXPR:
1302     case EQ_EXPR:
1303     case NE_EXPR:
1304     case COMPLEX_EXPR:
1305     case TRUTH_AND_EXPR:
1306     case TRUTH_OR_EXPR:
1307     case TRUTH_XOR_EXPR:
1308     case UNORDERED_EXPR:
1309     case ORDERED_EXPR:
1310     case UNLT_EXPR:
1311     case UNLE_EXPR:
1312     case UNGT_EXPR:
1313     case UNGE_EXPR:
1314     case UNEQ_EXPR:
1315       /* Binary operations evaluating both arguments (increment and
1316          decrement are binary internally in GCC).  */
1317       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1318       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1319       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1320                                    maybe_const_itself);
1321       STRIP_TYPE_NOPS (op0);
1322       if (code != MODIFY_EXPR
1323           && code != PREDECREMENT_EXPR
1324           && code != PREINCREMENT_EXPR
1325           && code != POSTDECREMENT_EXPR
1326           && code != POSTINCREMENT_EXPR)
1327         op0 = decl_constant_value_for_optimization (op0);
1328       /* The RHS of a MODIFY_EXPR was fully folded when building that
1329          expression for the sake of conversion warnings.  */
1330       if (code != MODIFY_EXPR)
1331         op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1332                                      maybe_const_itself);
1333       STRIP_TYPE_NOPS (op1);
1334       op1 = decl_constant_value_for_optimization (op1);
1335       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1336         ret = in_init
1337           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1338           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1339       else
1340         ret = fold (expr);
1341       if (TREE_OVERFLOW_P (ret)
1342           && !TREE_OVERFLOW_P (op0)
1343           && !TREE_OVERFLOW_P (op1))
1344         overflow_warning (EXPR_LOCATION (expr), ret);
1345       goto out;
1346
1347     case INDIRECT_REF:
1348     case FIX_TRUNC_EXPR:
1349     case FLOAT_EXPR:
1350     CASE_CONVERT:
1351     case NON_LVALUE_EXPR:
1352     case NEGATE_EXPR:
1353     case BIT_NOT_EXPR:
1354     case TRUTH_NOT_EXPR:
1355     case ADDR_EXPR:
1356     case CONJ_EXPR:
1357     case REALPART_EXPR:
1358     case IMAGPART_EXPR:
1359       /* Unary operations.  */
1360       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1361       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1362                                    maybe_const_itself);
1363       STRIP_TYPE_NOPS (op0);
1364       if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1365         op0 = decl_constant_value_for_optimization (op0);
1366       if (op0 != orig_op0 || in_init)
1367         ret = in_init
1368           ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1369           : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
1370       else
1371         ret = fold (expr);
1372       if (code == INDIRECT_REF
1373           && ret != expr
1374           && TREE_CODE (ret) == INDIRECT_REF)
1375         {
1376           TREE_READONLY (ret) = TREE_READONLY (expr);
1377           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1378           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1379         }
1380       switch (code)
1381         {
1382         case FIX_TRUNC_EXPR:
1383         case FLOAT_EXPR:
1384         CASE_CONVERT:
1385           /* Don't warn about explicit conversions.  We will already
1386              have warned about suspect implicit conversions.  */
1387           break;
1388
1389         default:
1390           if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1391             overflow_warning (EXPR_LOCATION (expr), ret);
1392           break;
1393         }
1394       goto out;
1395
1396     case TRUTH_ANDIF_EXPR:
1397     case TRUTH_ORIF_EXPR:
1398       /* Binary operations not necessarily evaluating both
1399          arguments.  */
1400       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1401       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1402       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1403       STRIP_TYPE_NOPS (op0);
1404
1405       unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1406                           ? truthvalue_false_node
1407                           : truthvalue_true_node));
1408       c_inhibit_evaluation_warnings += unused_p;
1409       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1410       STRIP_TYPE_NOPS (op1);
1411       c_inhibit_evaluation_warnings -= unused_p;
1412
1413       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1414         ret = in_init
1415           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1416           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1417       else
1418         ret = fold (expr);
1419       *maybe_const_operands &= op0_const;
1420       *maybe_const_itself &= op0_const_self;
1421       if (!(flag_isoc99
1422             && op0_const
1423             && op0_const_self
1424             && (code == TRUTH_ANDIF_EXPR
1425                 ? op0 == truthvalue_false_node
1426                 : op0 == truthvalue_true_node)))
1427         *maybe_const_operands &= op1_const;
1428       if (!(op0_const
1429             && op0_const_self
1430             && (code == TRUTH_ANDIF_EXPR
1431                 ? op0 == truthvalue_false_node
1432                 : op0 == truthvalue_true_node)))
1433         *maybe_const_itself &= op1_const_self;
1434       goto out;
1435
1436     case COND_EXPR:
1437       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1438       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1439       orig_op2 = op2 = TREE_OPERAND (expr, 2);
1440       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1441
1442       STRIP_TYPE_NOPS (op0);
1443       c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
1444       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1445       STRIP_TYPE_NOPS (op1);
1446       c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1447
1448       c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
1449       op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1450       STRIP_TYPE_NOPS (op2);
1451       c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1452
1453       if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1454         ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
1455       else
1456         ret = fold (expr);
1457       *maybe_const_operands &= op0_const;
1458       *maybe_const_itself &= op0_const_self;
1459       if (!(flag_isoc99
1460             && op0_const
1461             && op0_const_self
1462             && op0 == truthvalue_false_node))
1463         *maybe_const_operands &= op1_const;
1464       if (!(op0_const
1465             && op0_const_self
1466             && op0 == truthvalue_false_node))
1467         *maybe_const_itself &= op1_const_self;
1468       if (!(flag_isoc99
1469             && op0_const
1470             && op0_const_self
1471             && op0 == truthvalue_true_node))
1472         *maybe_const_operands &= op2_const;
1473       if (!(op0_const
1474             && op0_const_self
1475             && op0 == truthvalue_true_node))
1476         *maybe_const_itself &= op2_const_self;
1477       goto out;
1478
1479     case EXCESS_PRECISION_EXPR:
1480       /* Each case where an operand with excess precision may be
1481          encountered must remove the EXCESS_PRECISION_EXPR around
1482          inner operands and possibly put one around the whole
1483          expression or possibly convert to the semantic type (which
1484          c_fully_fold does); we cannot tell at this stage which is
1485          appropriate in any particular case.  */
1486       gcc_unreachable ();
1487
1488     default:
1489       /* Various codes may appear through folding built-in functions
1490          and their arguments.  */
1491       goto out;
1492     }
1493
1494  out:
1495   /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1496      have been done by this point, so remove them again.  */
1497   nowarning |= TREE_NO_WARNING (ret);
1498   STRIP_TYPE_NOPS (ret);
1499   if (nowarning && !TREE_NO_WARNING (ret))
1500     {
1501       if (!CAN_HAVE_LOCATION_P (ret))
1502         ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1503       TREE_NO_WARNING (ret) = 1;
1504     }
1505   if (ret != expr)
1506     protected_set_expr_location (ret, loc);
1507   return ret;
1508 }
1509
1510 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1511    return EXP.  Otherwise, return either EXP or its known constant
1512    value (if it has one), but return EXP if EXP has mode BLKmode.  ???
1513    Is the BLKmode test appropriate?  */
1514
1515 tree
1516 decl_constant_value_for_optimization (tree exp)
1517 {
1518   tree ret;
1519
1520   /* This function is only used by C, for c_fully_fold and other
1521      optimization, and may not be correct for C++.  */
1522   if (c_dialect_cxx ())
1523     gcc_unreachable ();
1524
1525   if (!optimize
1526       || TREE_CODE (exp) != VAR_DECL
1527       || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1528       || DECL_MODE (exp) == BLKmode)
1529     return exp;
1530
1531   ret = decl_constant_value (exp);
1532   /* Avoid unwanted tree sharing between the initializer and current
1533      function's body where the tree can be modified e.g. by the
1534      gimplifier.  */
1535   if (ret != exp && TREE_STATIC (exp))
1536     ret = unshare_expr (ret);
1537   return ret;
1538 }
1539
1540 /* Print a warning if a constant expression had overflow in folding.
1541    Invoke this function on every expression that the language
1542    requires to be a constant expression.
1543    Note the ANSI C standard says it is erroneous for a
1544    constant expression to overflow.  */
1545
1546 void
1547 constant_expression_warning (tree value)
1548 {
1549   if (warn_overflow && pedantic
1550       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1551           || TREE_CODE (value) == FIXED_CST
1552           || TREE_CODE (value) == VECTOR_CST
1553           || TREE_CODE (value) == COMPLEX_CST)
1554       && TREE_OVERFLOW (value))
1555     pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1556 }
1557
1558 /* The same as above but print an unconditional error.  */
1559 void
1560 constant_expression_error (tree value)
1561 {
1562   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1563        || TREE_CODE (value) == FIXED_CST
1564        || TREE_CODE (value) == VECTOR_CST
1565        || TREE_CODE (value) == COMPLEX_CST)
1566       && TREE_OVERFLOW (value))
1567     error ("overflow in constant expression");
1568 }
1569
1570 /* Print a warning if an expression had overflow in folding and its
1571    operands hadn't.
1572
1573    Invoke this function on every expression that
1574    (1) appears in the source code, and
1575    (2) is a constant expression that overflowed, and
1576    (3) is not already checked by convert_and_check;
1577    however, do not invoke this function on operands of explicit casts
1578    or when the expression is the result of an operator and any operand
1579    already overflowed.  */
1580
1581 void
1582 overflow_warning (location_t loc, tree value)
1583 {
1584   if (c_inhibit_evaluation_warnings != 0)
1585     return;
1586
1587   switch (TREE_CODE (value))
1588     {
1589     case INTEGER_CST:
1590       warning_at (loc, OPT_Woverflow, "integer overflow in expression");
1591       break;
1592
1593     case REAL_CST:
1594       warning_at (loc, OPT_Woverflow,
1595                   "floating point overflow in expression");
1596       break;
1597
1598     case FIXED_CST:
1599       warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
1600       break;
1601
1602     case VECTOR_CST:
1603       warning_at (loc, OPT_Woverflow, "vector overflow in expression");
1604       break;
1605
1606     case COMPLEX_CST:
1607       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1608         warning_at (loc, OPT_Woverflow,
1609                     "complex integer overflow in expression");
1610       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1611         warning_at (loc, OPT_Woverflow,
1612                     "complex floating point overflow in expression");
1613       break;
1614
1615     default:
1616       break;
1617     }
1618 }
1619
1620 /* Warn about uses of logical || / && operator in a context where it
1621    is likely that the bitwise equivalent was intended by the
1622    programmer.  We have seen an expression in which CODE is a binary
1623    operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1624    had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE.  */
1625 void
1626 warn_logical_operator (location_t location, enum tree_code code, tree type,
1627                        enum tree_code code_left, tree op_left,
1628                        enum tree_code ARG_UNUSED (code_right), tree op_right)
1629 {
1630   int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1631   int in0_p, in1_p, in_p;
1632   tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1633   bool strict_overflow_p = false;
1634
1635   if (code != TRUTH_ANDIF_EXPR
1636       && code != TRUTH_AND_EXPR
1637       && code != TRUTH_ORIF_EXPR
1638       && code != TRUTH_OR_EXPR)
1639     return;
1640
1641   /* Warn if &&/|| are being used in a context where it is
1642      likely that the bitwise equivalent was intended by the
1643      programmer. That is, an expression such as op && MASK
1644      where op should not be any boolean expression, nor a
1645      constant, and mask seems to be a non-boolean integer constant.  */
1646   if (!truth_value_p (code_left)
1647       && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1648       && !CONSTANT_CLASS_P (op_left)
1649       && !TREE_NO_WARNING (op_left)
1650       && TREE_CODE (op_right) == INTEGER_CST
1651       && !integer_zerop (op_right)
1652       && !integer_onep (op_right))
1653     {
1654       if (or_op)
1655         warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1656                     " applied to non-boolean constant");
1657       else
1658         warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1659                     " applied to non-boolean constant");
1660       TREE_NO_WARNING (op_left) = true;
1661       return;
1662     }
1663
1664   /* We do not warn for constants because they are typical of macro
1665      expansions that test for features.  */
1666   if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1667     return;
1668
1669   /* This warning only makes sense with logical operands.  */
1670   if (!(truth_value_p (TREE_CODE (op_left))
1671         || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1672       || !(truth_value_p (TREE_CODE (op_right))
1673            || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1674     return;
1675
1676   lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1677   rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1678
1679   if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1680     lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1681
1682   if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1683     rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
1684
1685   /* If this is an OR operation, invert both sides; we will invert
1686      again at the end.  */
1687   if (or_op)
1688     in0_p = !in0_p, in1_p = !in1_p;
1689
1690   /* If both expressions are the same, if we can merge the ranges, and we
1691      can build the range test, return it or it inverted.  */
1692   if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
1693       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1694                        in1_p, low1, high1)
1695       && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1696                                         type, lhs, in_p, low, high)))
1697     {
1698       if (TREE_CODE (tem) != INTEGER_CST)
1699         return;
1700
1701       if (or_op)
1702         warning_at (location, OPT_Wlogical_op,
1703                     "logical %<or%> "
1704                     "of collectively exhaustive tests is always true");
1705       else
1706         warning_at (location, OPT_Wlogical_op,
1707                     "logical %<and%> "
1708                     "of mutually exclusive tests is always false");
1709     }
1710 }
1711
1712
1713 /* Print a warning about casts that might indicate violation
1714    of strict aliasing rules if -Wstrict-aliasing is used and
1715    strict aliasing mode is in effect. OTYPE is the original
1716    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1717
1718 bool
1719 strict_aliasing_warning (tree otype, tree type, tree expr)
1720 {
1721   /* Strip pointer conversion chains and get to the correct original type.  */
1722   STRIP_NOPS (expr);
1723   otype = TREE_TYPE (expr);
1724
1725   if (!(flag_strict_aliasing
1726         && POINTER_TYPE_P (type)
1727         && POINTER_TYPE_P (otype)
1728         && !VOID_TYPE_P (TREE_TYPE (type)))
1729       /* If the type we are casting to is a ref-all pointer
1730          dereferencing it is always valid.  */
1731       || TYPE_REF_CAN_ALIAS_ALL (type))
1732     return false;
1733
1734   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1735       && (DECL_P (TREE_OPERAND (expr, 0))
1736           || handled_component_p (TREE_OPERAND (expr, 0))))
1737     {
1738       /* Casting the address of an object to non void pointer. Warn
1739          if the cast breaks type based aliasing.  */
1740       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1741         {
1742           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1743                    "might break strict-aliasing rules");
1744           return true;
1745         }
1746       else
1747         {
1748           /* warn_strict_aliasing >= 3.   This includes the default (3).
1749              Only warn if the cast is dereferenced immediately.  */
1750           alias_set_type set1 =
1751             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1752           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1753
1754           if (set1 != set2 && set2 != 0
1755               && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1756             {
1757               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1758                        "pointer will break strict-aliasing rules");
1759               return true;
1760             }
1761           else if (warn_strict_aliasing == 2
1762                    && !alias_sets_must_conflict_p (set1, set2))
1763             {
1764               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1765                        "pointer might break strict-aliasing rules");
1766               return true;
1767             }
1768         }
1769     }
1770   else
1771     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1772       {
1773         /* At this level, warn for any conversions, even if an address is
1774            not taken in the same statement.  This will likely produce many
1775            false positives, but could be useful to pinpoint problems that
1776            are not revealed at higher levels.  */
1777         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1778         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1779         if (!COMPLETE_TYPE_P (type)
1780             || !alias_sets_must_conflict_p (set1, set2))
1781           {
1782             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1783                      "pointer might break strict-aliasing rules");
1784             return true;
1785           }
1786       }
1787
1788   return false;
1789 }
1790
1791 /* Warn for unlikely, improbable, or stupid DECL declarations
1792    of `main'.  */
1793
1794 void
1795 check_main_parameter_types (tree decl)
1796 {
1797   tree args;
1798   int argct = 0;
1799
1800   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1801       args = TREE_CHAIN (args))
1802    {
1803      tree type = args ? TREE_VALUE (args) : 0;
1804
1805      if (type == void_type_node || type == error_mark_node )
1806        break;
1807
1808      ++argct;
1809      switch (argct)
1810        {
1811        case 1:
1812          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1813            pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1814                     decl);
1815          break;
1816
1817        case 2:
1818          if (TREE_CODE (type) != POINTER_TYPE
1819              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1820              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1821                  != char_type_node))
1822            pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1823                     decl);
1824          break;
1825
1826        case 3:
1827          if (TREE_CODE (type) != POINTER_TYPE
1828              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1829              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1830                  != char_type_node))
1831            pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1832                     "%<char **%>", decl);
1833          break;
1834        }
1835    }
1836
1837   /* It is intentional that this message does not mention the third
1838     argument because it's only mentioned in an appendix of the
1839     standard.  */
1840   if (argct > 0 && (argct < 2 || argct > 3))
1841     pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1842 }
1843
1844 /* True if pointers to distinct types T1 and T2 can be converted to
1845    each other without an explicit cast.  Only returns true for opaque
1846    vector types.  */
1847 bool
1848 vector_targets_convertible_p (const_tree t1, const_tree t2)
1849 {
1850   if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1851       && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1852       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1853     return true;
1854
1855   return false;
1856 }
1857
1858 /* True if vector types T1 and T2 can be converted to each other
1859    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1860    can only be converted with -flax-vector-conversions yet that is not
1861    in effect, emit a note telling the user about that option if such
1862    a note has not previously been emitted.  */
1863 bool
1864 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1865 {
1866   static bool emitted_lax_note = false;
1867   bool convertible_lax;
1868
1869   if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1870       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1871     return true;
1872
1873   convertible_lax =
1874     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1875      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1876          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1877      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1878          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1879
1880   if (!convertible_lax || flag_lax_vector_conversions)
1881     return convertible_lax;
1882
1883   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1884       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1885     return true;
1886
1887   if (emit_lax_note && !emitted_lax_note)
1888     {
1889       emitted_lax_note = true;
1890       inform (input_location, "use -flax-vector-conversions to permit "
1891               "conversions between vectors with differing "
1892               "element types or numbers of subparts");
1893     }
1894
1895   return false;
1896 }
1897
1898 /* This is a helper function of build_binary_op.
1899
1900    For certain operations if both args were extended from the same
1901    smaller type, do the arithmetic in that type and then extend.
1902
1903    BITWISE indicates a bitwise operation.
1904    For them, this optimization is safe only if
1905    both args are zero-extended or both are sign-extended.
1906    Otherwise, we might change the result.
1907    Eg, (short)-1 | (unsigned short)-1 is (int)-1
1908    but calculated in (unsigned short) it would be (unsigned short)-1.
1909 */
1910 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1911 {
1912   int unsigned0, unsigned1;
1913   tree arg0, arg1;
1914   int uns;
1915   tree type;
1916
1917   /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
1918      excessive narrowing when we call get_narrower below.  For
1919      example, suppose that OP0 is of unsigned int extended
1920      from signed char and that RESULT_TYPE is long long int.
1921      If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1922      like
1923
1924      (long long int) (unsigned int) signed_char
1925
1926      which get_narrower would narrow down to
1927
1928      (unsigned int) signed char
1929
1930      If we do not cast OP0 first, get_narrower would return
1931      signed_char, which is inconsistent with the case of the
1932      explicit cast.  */
1933   op0 = convert (result_type, op0);
1934   op1 = convert (result_type, op1);
1935
1936   arg0 = get_narrower (op0, &unsigned0);
1937   arg1 = get_narrower (op1, &unsigned1);
1938
1939   /* UNS is 1 if the operation to be done is an unsigned one.  */
1940   uns = TYPE_UNSIGNED (result_type);
1941
1942   /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1943      but it *requires* conversion to FINAL_TYPE.  */
1944
1945   if ((TYPE_PRECISION (TREE_TYPE (op0))
1946        == TYPE_PRECISION (TREE_TYPE (arg0)))
1947       && TREE_TYPE (op0) != result_type)
1948     unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1949   if ((TYPE_PRECISION (TREE_TYPE (op1))
1950        == TYPE_PRECISION (TREE_TYPE (arg1)))
1951       && TREE_TYPE (op1) != result_type)
1952     unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1953
1954   /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
1955
1956   /* For bitwise operations, signedness of nominal type
1957      does not matter.  Consider only how operands were extended.  */
1958   if (bitwise)
1959     uns = unsigned0;
1960
1961   /* Note that in all three cases below we refrain from optimizing
1962      an unsigned operation on sign-extended args.
1963      That would not be valid.  */
1964
1965   /* Both args variable: if both extended in same way
1966      from same width, do it in that width.
1967      Do it unsigned if args were zero-extended.  */
1968   if ((TYPE_PRECISION (TREE_TYPE (arg0))
1969        < TYPE_PRECISION (result_type))
1970       && (TYPE_PRECISION (TREE_TYPE (arg1))
1971           == TYPE_PRECISION (TREE_TYPE (arg0)))
1972       && unsigned0 == unsigned1
1973       && (unsigned0 || !uns))
1974     return c_common_signed_or_unsigned_type
1975       (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1976
1977   else if (TREE_CODE (arg0) == INTEGER_CST
1978            && (unsigned1 || !uns)
1979            && (TYPE_PRECISION (TREE_TYPE (arg1))
1980                < TYPE_PRECISION (result_type))
1981            && (type
1982                = c_common_signed_or_unsigned_type (unsigned1,
1983                                                    TREE_TYPE (arg1)))
1984            && !POINTER_TYPE_P (type)
1985            && int_fits_type_p (arg0, type))
1986     return type;
1987
1988   else if (TREE_CODE (arg1) == INTEGER_CST
1989            && (unsigned0 || !uns)
1990            && (TYPE_PRECISION (TREE_TYPE (arg0))
1991                < TYPE_PRECISION (result_type))
1992            && (type
1993                = c_common_signed_or_unsigned_type (unsigned0,
1994                                                    TREE_TYPE (arg0)))
1995            && !POINTER_TYPE_P (type)
1996            && int_fits_type_p (arg1, type))
1997     return type;
1998
1999   return result_type;
2000 }
2001
2002 /* Warns if the conversion of EXPR to TYPE may alter a value.
2003    This is a helper function for warnings_for_convert_and_check.  */
2004
2005 static void
2006 conversion_warning (tree type, tree expr)
2007 {
2008   bool give_warning = false;
2009
2010   int i;
2011   const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
2012   tree expr_type = TREE_TYPE (expr);
2013
2014   if (!warn_conversion && !warn_sign_conversion)
2015     return;
2016
2017   /* If any operand is artificial, then this expression was generated
2018      by the compiler and we do not warn.  */
2019   for (i = 0; i < expr_num_operands; i++)
2020     {
2021       tree op = TREE_OPERAND (expr, i);
2022       if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
2023         return;
2024     }
2025
2026   switch (TREE_CODE (expr))
2027     {
2028     case EQ_EXPR:
2029     case NE_EXPR:
2030     case LE_EXPR:
2031     case GE_EXPR:
2032     case LT_EXPR:
2033     case GT_EXPR:
2034     case TRUTH_ANDIF_EXPR:
2035     case TRUTH_ORIF_EXPR:
2036     case TRUTH_AND_EXPR:
2037     case TRUTH_OR_EXPR:
2038     case TRUTH_XOR_EXPR:
2039     case TRUTH_NOT_EXPR:
2040       /* Conversion from boolean to a signed:1 bit-field (which only
2041          can hold the values 0 and -1) doesn't lose information - but
2042          it does change the value.  */
2043       if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
2044         warning (OPT_Wconversion,
2045                  "conversion to %qT from boolean expression", type);
2046       return;
2047
2048     case REAL_CST:
2049     case INTEGER_CST:
2050
2051       /* Warn for real constant that is not an exact integer converted
2052          to integer type.  */
2053       if (TREE_CODE (expr_type) == REAL_TYPE
2054           && TREE_CODE (type) == INTEGER_TYPE)
2055         {
2056           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
2057             give_warning = true;
2058         }
2059       /* Warn for an integer constant that does not fit into integer type.  */
2060       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2061                && TREE_CODE (type) == INTEGER_TYPE
2062                && !int_fits_type_p (expr, type))
2063         {
2064           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
2065               && tree_int_cst_sgn (expr) < 0)
2066             warning (OPT_Wsign_conversion,
2067                      "negative integer implicitly converted to unsigned type");
2068           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
2069             warning (OPT_Wsign_conversion,  "conversion of unsigned constant "
2070                      "value to negative integer");
2071           else
2072             give_warning = true;
2073         }
2074       else if (TREE_CODE (type) == REAL_TYPE)
2075         {
2076           /* Warn for an integer constant that does not fit into real type.  */
2077           if (TREE_CODE (expr_type) == INTEGER_TYPE)
2078             {
2079               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
2080               if (!exact_real_truncate (TYPE_MODE (type), &a))
2081                 give_warning = true;
2082             }
2083           /* Warn for a real constant that does not fit into a smaller
2084              real type.  */
2085           else if (TREE_CODE (expr_type) == REAL_TYPE
2086                    && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2087             {
2088               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2089               if (!exact_real_truncate (TYPE_MODE (type), &a))
2090                 give_warning = true;
2091             }
2092         }
2093
2094       if (give_warning)
2095         warning (OPT_Wconversion,
2096                  "conversion to %qT alters %qT constant value",
2097                  type, expr_type);
2098
2099       return;
2100
2101     case COND_EXPR:
2102       {
2103         /* In case of COND_EXPR, if both operands are constants or
2104            COND_EXPR, then we do not care about the type of COND_EXPR,
2105            only about the conversion of each operand.  */
2106         tree op1 = TREE_OPERAND (expr, 1);
2107         tree op2 = TREE_OPERAND (expr, 2);
2108
2109         if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2110              || TREE_CODE (op1) == COND_EXPR)
2111             && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2112                 || TREE_CODE (op2) == COND_EXPR))
2113           {
2114             conversion_warning (type, op1);
2115             conversion_warning (type, op2);
2116             return;
2117           }
2118         /* Fall through.  */
2119       }
2120
2121     default: /* 'expr' is not a constant.  */
2122
2123       /* Warn for real types converted to integer types.  */
2124       if (TREE_CODE (expr_type) == REAL_TYPE
2125           && TREE_CODE (type) == INTEGER_TYPE)
2126         give_warning = true;
2127
2128       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2129                && TREE_CODE (type) == INTEGER_TYPE)
2130         {
2131           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
2132           expr = get_unwidened (expr, 0);
2133           expr_type = TREE_TYPE (expr);
2134
2135           /* Don't warn for short y; short x = ((int)y & 0xff);  */
2136           if (TREE_CODE (expr) == BIT_AND_EXPR
2137                 || TREE_CODE (expr) == BIT_IOR_EXPR
2138               || TREE_CODE (expr) == BIT_XOR_EXPR)
2139             {
2140               /* If both args were extended from a shortest type,
2141                  use that type if that is safe.  */
2142               expr_type = shorten_binary_op (expr_type,
2143                                              TREE_OPERAND (expr, 0),
2144                                              TREE_OPERAND (expr, 1),
2145                                              /* bitwise */1);
2146
2147               if (TREE_CODE (expr) == BIT_AND_EXPR)
2148                 {
2149                   tree op0 = TREE_OPERAND (expr, 0);
2150                   tree op1 = TREE_OPERAND (expr, 1);
2151                   bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2152                   bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2153
2154                   /* If one of the operands is a non-negative constant
2155                      that fits in the target type, then the type of the
2156                      other operand does not matter. */
2157                   if ((TREE_CODE (op0) == INTEGER_CST
2158                        && int_fits_type_p (op0, c_common_signed_type (type))
2159                        && int_fits_type_p (op0, c_common_unsigned_type (type)))
2160                       || (TREE_CODE (op1) == INTEGER_CST
2161                           && int_fits_type_p (op1, c_common_signed_type (type))
2162                           && int_fits_type_p (op1,
2163                                               c_common_unsigned_type (type))))
2164                     return;
2165                   /* If constant is unsigned and fits in the target
2166                      type, then the result will also fit.  */
2167                   else if ((TREE_CODE (op0) == INTEGER_CST
2168                             && unsigned0
2169                             && int_fits_type_p (op0, type))
2170                            || (TREE_CODE (op1) == INTEGER_CST
2171                                && unsigned1
2172                                && int_fits_type_p (op1, type)))
2173                     return;
2174                 }
2175             }
2176           /* Warn for integer types converted to smaller integer types.  */
2177           if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2178             give_warning = true;
2179
2180           /* When they are the same width but different signedness,
2181              then the value may change.  */
2182           else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2183                     && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2184                    /* Even when converted to a bigger type, if the type is
2185                       unsigned but expr is signed, then negative values
2186                       will be changed.  */
2187                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2188             warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2189                      "may change the sign of the result",
2190                      type, expr_type);
2191         }
2192
2193       /* Warn for integer types converted to real types if and only if
2194          all the range of values of the integer type cannot be
2195          represented by the real type.  */
2196       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2197                && TREE_CODE (type) == REAL_TYPE)
2198         {
2199           tree type_low_bound, type_high_bound;
2200           REAL_VALUE_TYPE real_low_bound, real_high_bound;
2201
2202           /* Don't warn about char y = 0xff; float x = (int) y;  */
2203           expr = get_unwidened (expr, 0);
2204           expr_type = TREE_TYPE (expr);
2205
2206           type_low_bound = TYPE_MIN_VALUE (expr_type);
2207           type_high_bound = TYPE_MAX_VALUE (expr_type);
2208           real_low_bound = real_value_from_int_cst (0, type_low_bound);
2209           real_high_bound = real_value_from_int_cst (0, type_high_bound);
2210
2211           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2212               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2213             give_warning = true;
2214         }
2215
2216       /* Warn for real types converted to smaller real types.  */
2217       else if (TREE_CODE (expr_type) == REAL_TYPE
2218                && TREE_CODE (type) == REAL_TYPE
2219                && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2220         give_warning = true;
2221
2222
2223       if (give_warning)
2224         warning (OPT_Wconversion,
2225                  "conversion to %qT from %qT may alter its value",
2226                  type, expr_type);
2227     }
2228 }
2229
2230 /* Produce warnings after a conversion. RESULT is the result of
2231    converting EXPR to TYPE.  This is a helper function for
2232    convert_and_check and cp_convert_and_check.  */
2233
2234 void
2235 warnings_for_convert_and_check (tree type, tree expr, tree result)
2236 {
2237   if (TREE_CODE (expr) == INTEGER_CST
2238       && (TREE_CODE (type) == INTEGER_TYPE
2239           || TREE_CODE (type) == ENUMERAL_TYPE)
2240       && !int_fits_type_p (expr, type))
2241     {
2242       /* Do not diagnose overflow in a constant expression merely
2243          because a conversion overflowed.  */
2244       if (TREE_OVERFLOW (result))
2245         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2246
2247       if (TYPE_UNSIGNED (type))
2248         {
2249           /* This detects cases like converting -129 or 256 to
2250              unsigned char.  */
2251           if (!int_fits_type_p (expr, c_common_signed_type (type)))
2252             warning (OPT_Woverflow,
2253                      "large integer implicitly truncated to unsigned type");
2254           else
2255             conversion_warning (type, expr);
2256         }
2257       else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2258         warning (OPT_Woverflow,
2259                  "overflow in implicit constant conversion");
2260       /* No warning for converting 0x80000000 to int.  */
2261       else if (pedantic
2262                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2263                    || TYPE_PRECISION (TREE_TYPE (expr))
2264                    != TYPE_PRECISION (type)))
2265         warning (OPT_Woverflow,
2266                  "overflow in implicit constant conversion");
2267
2268       else
2269         conversion_warning (type, expr);
2270     }
2271   else if ((TREE_CODE (result) == INTEGER_CST
2272             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2273     warning (OPT_Woverflow,
2274              "overflow in implicit constant conversion");
2275   else
2276     conversion_warning (type, expr);
2277 }
2278
2279
2280 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2281    Invoke this function on every expression that is converted implicitly,
2282    i.e. because of language rules and not because of an explicit cast.  */
2283
2284 tree
2285 convert_and_check (tree type, tree expr)
2286 {
2287   tree result;
2288   tree expr_for_warning;
2289
2290   /* Convert from a value with possible excess precision rather than
2291      via the semantic type, but do not warn about values not fitting
2292      exactly in the semantic type.  */
2293   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2294     {
2295       tree orig_type = TREE_TYPE (expr);
2296       expr = TREE_OPERAND (expr, 0);
2297       expr_for_warning = convert (orig_type, expr);
2298       if (orig_type == type)
2299         return expr_for_warning;
2300     }
2301   else
2302     expr_for_warning = expr;
2303
2304   if (TREE_TYPE (expr) == type)
2305     return expr;
2306
2307   result = convert (type, expr);
2308
2309   if (c_inhibit_evaluation_warnings == 0
2310       && !TREE_OVERFLOW_P (expr)
2311       && result != error_mark_node)
2312     warnings_for_convert_and_check (type, expr_for_warning, result);
2313
2314   return result;
2315 }
2316 \f
2317 /* A node in a list that describes references to variables (EXPR), which are
2318    either read accesses if WRITER is zero, or write accesses, in which case
2319    WRITER is the parent of EXPR.  */
2320 struct tlist
2321 {
2322   struct tlist *next;
2323   tree expr, writer;
2324 };
2325
2326 /* Used to implement a cache the results of a call to verify_tree.  We only
2327    use this for SAVE_EXPRs.  */
2328 struct tlist_cache
2329 {
2330   struct tlist_cache *next;
2331   struct tlist *cache_before_sp;
2332   struct tlist *cache_after_sp;
2333   tree expr;
2334 };
2335
2336 /* Obstack to use when allocating tlist structures, and corresponding
2337    firstobj.  */
2338 static struct obstack tlist_obstack;
2339 static char *tlist_firstobj = 0;
2340
2341 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2342    warnings.  */
2343 static struct tlist *warned_ids;
2344 /* SAVE_EXPRs need special treatment.  We process them only once and then
2345    cache the results.  */
2346 static struct tlist_cache *save_expr_cache;
2347
2348 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2349 static void merge_tlist (struct tlist **, struct tlist *, int);
2350 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2351 static int warning_candidate_p (tree);
2352 static bool candidate_equal_p (const_tree, const_tree);
2353 static void warn_for_collisions (struct tlist *);
2354 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2355 static struct tlist *new_tlist (struct tlist *, tree, tree);
2356
2357 /* Create a new struct tlist and fill in its fields.  */
2358 static struct tlist *
2359 new_tlist (struct tlist *next, tree t, tree writer)
2360 {
2361   struct tlist *l;
2362   l = XOBNEW (&tlist_obstack, struct tlist);
2363   l->next = next;
2364   l->expr = t;
2365   l->writer = writer;
2366   return l;
2367 }
2368
2369 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
2370    is nonnull, we ignore any node we find which has a writer equal to it.  */
2371
2372 static void
2373 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2374 {
2375   while (add)
2376     {
2377       struct tlist *next = add->next;
2378       if (!copy)
2379         add->next = *to;
2380       if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2381         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2382       add = next;
2383     }
2384 }
2385
2386 /* Merge the nodes of ADD into TO.  This merging process is done so that for
2387    each variable that already exists in TO, no new node is added; however if
2388    there is a write access recorded in ADD, and an occurrence on TO is only
2389    a read access, then the occurrence in TO will be modified to record the
2390    write.  */
2391
2392 static void
2393 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2394 {
2395   struct tlist **end = to;
2396
2397   while (*end)
2398     end = &(*end)->next;
2399
2400   while (add)
2401     {
2402       int found = 0;
2403       struct tlist *tmp2;
2404       struct tlist *next = add->next;
2405
2406       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2407         if (candidate_equal_p (tmp2->expr, add->expr))
2408           {
2409             found = 1;
2410             if (!tmp2->writer)
2411               tmp2->writer = add->writer;
2412           }
2413       if (!found)
2414         {
2415           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2416           end = &(*end)->next;
2417           *end = 0;
2418         }
2419       add = next;
2420     }
2421 }
2422
2423 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
2424    references in list LIST conflict with it, excluding reads if ONLY writers
2425    is nonzero.  */
2426
2427 static void
2428 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2429                        int only_writes)
2430 {
2431   struct tlist *tmp;
2432
2433   /* Avoid duplicate warnings.  */
2434   for (tmp = warned_ids; tmp; tmp = tmp->next)
2435     if (candidate_equal_p (tmp->expr, written))
2436       return;
2437
2438   while (list)
2439     {
2440       if (candidate_equal_p (list->expr, written)
2441           && !candidate_equal_p (list->writer, writer)
2442           && (!only_writes || list->writer))
2443         {
2444           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2445           warning_at (EXPR_HAS_LOCATION (writer)
2446                       ? EXPR_LOCATION (writer) : input_location,
2447                       OPT_Wsequence_point, "operation on %qE may be undefined",
2448                       list->expr);
2449         }
2450       list = list->next;
2451     }
2452 }
2453
2454 /* Given a list LIST of references to variables, find whether any of these
2455    can cause conflicts due to missing sequence points.  */
2456
2457 static void
2458 warn_for_collisions (struct tlist *list)
2459 {
2460   struct tlist *tmp;
2461
2462   for (tmp = list; tmp; tmp = tmp->next)
2463     {
2464       if (tmp->writer)
2465         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2466     }
2467 }
2468
2469 /* Return nonzero if X is a tree that can be verified by the sequence point
2470    warnings.  */
2471 static int
2472 warning_candidate_p (tree x)
2473 {
2474   /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2475      (lvalue_p) crash on TRY/CATCH. */
2476   return !(DECL_P (x) && DECL_ARTIFICIAL (x))
2477     && TREE_TYPE (x) && !VOID_TYPE_P (TREE_TYPE (x)) && lvalue_p (x);
2478 }
2479
2480 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2481 static bool
2482 candidate_equal_p (const_tree x, const_tree y)
2483 {
2484   return (x == y) || (x && y && operand_equal_p (x, y, 0));
2485 }
2486
2487 /* Walk the tree X, and record accesses to variables.  If X is written by the
2488    parent tree, WRITER is the parent.
2489    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
2490    expression or its only operand forces a sequence point, then everything up
2491    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
2492    in PNO_SP.
2493    Once we return, we will have emitted warnings if any subexpression before
2494    such a sequence point could be undefined.  On a higher level, however, the
2495    sequence point may not be relevant, and we'll merge the two lists.
2496
2497    Example: (b++, a) + b;
2498    The call that processes the COMPOUND_EXPR will store the increment of B
2499    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
2500    processes the PLUS_EXPR will need to merge the two lists so that
2501    eventually, all accesses end up on the same list (and we'll warn about the
2502    unordered subexpressions b++ and b.
2503
2504    A note on merging.  If we modify the former example so that our expression
2505    becomes
2506      (b++, b) + a
2507    care must be taken not simply to add all three expressions into the final
2508    PNO_SP list.  The function merge_tlist takes care of that by merging the
2509    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2510    way, so that no more than one access to B is recorded.  */
2511
2512 static void
2513 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2514              tree writer)
2515 {
2516   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2517   enum tree_code code;
2518   enum tree_code_class cl;
2519
2520   /* X may be NULL if it is the operand of an empty statement expression
2521      ({ }).  */
2522   if (x == NULL)
2523     return;
2524
2525  restart:
2526   code = TREE_CODE (x);
2527   cl = TREE_CODE_CLASS (code);
2528
2529   if (warning_candidate_p (x))
2530     *pno_sp = new_tlist (*pno_sp, x, writer);
2531
2532   switch (code)
2533     {
2534     case CONSTRUCTOR:
2535       return;
2536
2537     case COMPOUND_EXPR:
2538     case TRUTH_ANDIF_EXPR:
2539     case TRUTH_ORIF_EXPR:
2540       tmp_before = tmp_nosp = tmp_list3 = 0;
2541       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2542       warn_for_collisions (tmp_nosp);
2543       merge_tlist (pbefore_sp, tmp_before, 0);
2544       merge_tlist (pbefore_sp, tmp_nosp, 0);
2545       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2546       merge_tlist (pbefore_sp, tmp_list3, 0);
2547       return;
2548
2549     case COND_EXPR:
2550       tmp_before = tmp_list2 = 0;
2551       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2552       warn_for_collisions (tmp_list2);
2553       merge_tlist (pbefore_sp, tmp_before, 0);
2554       merge_tlist (pbefore_sp, tmp_list2, 1);
2555
2556       tmp_list3 = tmp_nosp = 0;
2557       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2558       warn_for_collisions (tmp_nosp);
2559       merge_tlist (pbefore_sp, tmp_list3, 0);
2560
2561       tmp_list3 = tmp_list2 = 0;
2562       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2563       warn_for_collisions (tmp_list2);
2564       merge_tlist (pbefore_sp, tmp_list3, 0);
2565       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2566          two first, to avoid warning for (a ? b++ : b++).  */
2567       merge_tlist (&tmp_nosp, tmp_list2, 0);
2568       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2569       return;
2570
2571     case PREDECREMENT_EXPR:
2572     case PREINCREMENT_EXPR:
2573     case POSTDECREMENT_EXPR:
2574     case POSTINCREMENT_EXPR:
2575       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2576       return;
2577
2578     case MODIFY_EXPR:
2579       tmp_before = tmp_nosp = tmp_list3 = 0;
2580       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2581       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2582       /* Expressions inside the LHS are not ordered wrt. the sequence points
2583          in the RHS.  Example:
2584            *a = (a++, 2)
2585          Despite the fact that the modification of "a" is in the before_sp
2586          list (tmp_before), it conflicts with the use of "a" in the LHS.
2587          We can handle this by adding the contents of tmp_list3
2588          to those of tmp_before, and redoing the collision warnings for that
2589          list.  */
2590       add_tlist (&tmp_before, tmp_list3, x, 1);
2591       warn_for_collisions (tmp_before);
2592       /* Exclude the LHS itself here; we first have to merge it into the
2593          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
2594          didn't exclude the LHS, we'd get it twice, once as a read and once
2595          as a write.  */
2596       add_tlist (pno_sp, tmp_list3, x, 0);
2597       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2598
2599       merge_tlist (pbefore_sp, tmp_before, 0);
2600       if (warning_candidate_p (TREE_OPERAND (x, 0)))
2601         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2602       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2603       return;
2604
2605     case CALL_EXPR:
2606       /* We need to warn about conflicts among arguments and conflicts between
2607          args and the function address.  Side effects of the function address,
2608          however, are not ordered by the sequence point of the call.  */
2609       {
2610         call_expr_arg_iterator iter;
2611         tree arg;
2612         tmp_before = tmp_nosp = 0;
2613         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2614         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2615           {
2616             tmp_list2 = tmp_list3 = 0;
2617             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2618             merge_tlist (&tmp_list3, tmp_list2, 0);
2619             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2620           }
2621         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2622         warn_for_collisions (tmp_before);
2623         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2624         return;
2625       }
2626
2627     case TREE_LIST:
2628       /* Scan all the list, e.g. indices of multi dimensional array.  */
2629       while (x)
2630         {
2631           tmp_before = tmp_nosp = 0;
2632           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2633           merge_tlist (&tmp_nosp, tmp_before, 0);
2634           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2635           x = TREE_CHAIN (x);
2636         }
2637       return;
2638
2639     case SAVE_EXPR:
2640       {
2641         struct tlist_cache *t;
2642         for (t = save_expr_cache; t; t = t->next)
2643           if (candidate_equal_p (t->expr, x))
2644             break;
2645
2646         if (!t)
2647           {
2648             t = XOBNEW (&tlist_obstack, struct tlist_cache);
2649             t->next = save_expr_cache;
2650             t->expr = x;
2651             save_expr_cache = t;
2652
2653             tmp_before = tmp_nosp = 0;
2654             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2655             warn_for_collisions (tmp_nosp);
2656
2657             tmp_list3 = 0;
2658             while (tmp_nosp)
2659               {
2660                 struct tlist *t = tmp_nosp;
2661                 tmp_nosp = t->next;
2662                 merge_tlist (&tmp_list3, t, 0);
2663               }
2664             t->cache_before_sp = tmp_before;
2665             t->cache_after_sp = tmp_list3;
2666           }
2667         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2668         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2669         return;
2670       }
2671
2672     case ADDR_EXPR:
2673       x = TREE_OPERAND (x, 0);
2674       if (DECL_P (x))
2675         return;
2676       writer = 0;
2677       goto restart;
2678
2679     default:
2680       /* For other expressions, simply recurse on their operands.
2681          Manual tail recursion for unary expressions.
2682          Other non-expressions need not be processed.  */
2683       if (cl == tcc_unary)
2684         {
2685           x = TREE_OPERAND (x, 0);
2686           writer = 0;
2687           goto restart;
2688         }
2689       else if (IS_EXPR_CODE_CLASS (cl))
2690         {
2691           int lp;
2692           int max = TREE_OPERAND_LENGTH (x);
2693           for (lp = 0; lp < max; lp++)
2694             {
2695               tmp_before = tmp_nosp = 0;
2696               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2697               merge_tlist (&tmp_nosp, tmp_before, 0);
2698               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2699             }
2700         }
2701       return;
2702     }
2703 }
2704
2705 /* Try to warn for undefined behavior in EXPR due to missing sequence
2706    points.  */
2707
2708 void
2709 verify_sequence_points (tree expr)
2710 {
2711   struct tlist *before_sp = 0, *after_sp = 0;
2712
2713   warned_ids = 0;
2714   save_expr_cache = 0;
2715   if (tlist_firstobj == 0)
2716     {
2717       gcc_obstack_init (&tlist_obstack);
2718       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2719     }
2720
2721   verify_tree (expr, &before_sp, &after_sp, 0);
2722   warn_for_collisions (after_sp);
2723   obstack_free (&tlist_obstack, tlist_firstobj);
2724 }
2725 \f
2726 /* Validate the expression after `case' and apply default promotions.  */
2727
2728 static tree
2729 check_case_value (tree value)
2730 {
2731   if (value == NULL_TREE)
2732     return value;
2733
2734   /* ??? Can we ever get nops here for a valid case value?  We
2735      shouldn't for C.  */
2736   STRIP_TYPE_NOPS (value);
2737   /* In C++, the following is allowed:
2738
2739        const int i = 3;
2740        switch (...) { case i: ... }
2741
2742      So, we try to reduce the VALUE to a constant that way.  */
2743   if (c_dialect_cxx ())
2744     {
2745       value = decl_constant_value (value);
2746       STRIP_TYPE_NOPS (value);
2747       value = fold (value);
2748     }
2749
2750   if (TREE_CODE (value) == INTEGER_CST)
2751     /* Promote char or short to int.  */
2752     value = perform_integral_promotions (value);
2753   else if (value != error_mark_node)
2754     {
2755       error ("case label does not reduce to an integer constant");
2756       value = error_mark_node;
2757     }
2758
2759   constant_expression_warning (value);
2760
2761   return value;
2762 }
2763 \f
2764 /* See if the case values LOW and HIGH are in the range of the original
2765    type (i.e. before the default conversion to int) of the switch testing
2766    expression.
2767    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2768    the type before promoting it.  CASE_LOW_P is a pointer to the lower
2769    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2770    if the case is not a case range.
2771    The caller has to make sure that we are not called with NULL for
2772    CASE_LOW_P (i.e. the default case).
2773    Returns true if the case label is in range of ORIG_TYPE (saturated or
2774    untouched) or false if the label is out of range.  */
2775
2776 static bool
2777 check_case_bounds (tree type, tree orig_type,
2778                    tree *case_low_p, tree *case_high_p)
2779 {
2780   tree min_value, max_value;
2781   tree case_low = *case_low_p;
2782   tree case_high = case_high_p ? *case_high_p : case_low;
2783
2784   /* If there was a problem with the original type, do nothing.  */
2785   if (orig_type == error_mark_node)
2786     return true;
2787
2788   min_value = TYPE_MIN_VALUE (orig_type);
2789   max_value = TYPE_MAX_VALUE (orig_type);
2790
2791   /* Case label is less than minimum for type.  */
2792   if (tree_int_cst_compare (case_low, min_value) < 0
2793       && tree_int_cst_compare (case_high, min_value) < 0)
2794     {
2795       warning (0, "case label value is less than minimum value for type");
2796       return false;
2797     }
2798
2799   /* Case value is greater than maximum for type.  */
2800   if (tree_int_cst_compare (case_low, max_value) > 0
2801       && tree_int_cst_compare (case_high, max_value) > 0)
2802     {
2803       warning (0, "case label value exceeds maximum value for type");
2804       return false;
2805     }
2806
2807   /* Saturate lower case label value to minimum.  */
2808   if (tree_int_cst_compare (case_high, min_value) >= 0
2809       && tree_int_cst_compare (case_low, min_value) < 0)
2810     {
2811       warning (0, "lower value in case label range"
2812                " less than minimum value for type");
2813       case_low = min_value;
2814     }
2815
2816   /* Saturate upper case label value to maximum.  */
2817   if (tree_int_cst_compare (case_low, max_value) <= 0
2818       && tree_int_cst_compare (case_high, max_value) > 0)
2819     {
2820       warning (0, "upper value in case label range"
2821                " exceeds maximum value for type");
2822       case_high = max_value;
2823     }
2824
2825   if (*case_low_p != case_low)
2826     *case_low_p = convert (type, case_low);
2827   if (case_high_p && *case_high_p != case_high)
2828     *case_high_p = convert (type, case_high);
2829
2830   return true;
2831 }
2832 \f
2833 /* Return an integer type with BITS bits of precision,
2834    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2835
2836 tree
2837 c_common_type_for_size (unsigned int bits, int unsignedp)
2838 {
2839   if (bits == TYPE_PRECISION (integer_type_node))
2840     return unsignedp ? unsigned_type_node : integer_type_node;
2841
2842   if (bits == TYPE_PRECISION (signed_char_type_node))
2843     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2844
2845   if (bits == TYPE_PRECISION (short_integer_type_node))
2846     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2847
2848   if (bits == TYPE_PRECISION (long_integer_type_node))
2849     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2850
2851   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2852     return (unsignedp ? long_long_unsigned_type_node
2853             : long_long_integer_type_node);
2854
2855   if (int128_integer_type_node
2856       && bits == TYPE_PRECISION (int128_integer_type_node))
2857     return (unsignedp ? int128_unsigned_type_node
2858             : int128_integer_type_node);
2859
2860   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2861     return (unsignedp ? widest_unsigned_literal_type_node
2862             : widest_integer_literal_type_node);
2863
2864   if (bits <= TYPE_PRECISION (intQI_type_node))
2865     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2866
2867   if (bits <= TYPE_PRECISION (intHI_type_node))
2868     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2869
2870   if (bits <= TYPE_PRECISION (intSI_type_node))
2871     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2872
2873   if (bits <= TYPE_PRECISION (intDI_type_node))
2874     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2875
2876   return 0;
2877 }
2878
2879 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2880    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2881    and saturating if SATP is nonzero, otherwise not saturating.  */
2882
2883 tree
2884 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2885                                     int unsignedp, int satp)
2886 {
2887   enum machine_mode mode;
2888   if (ibit == 0)
2889     mode = unsignedp ? UQQmode : QQmode;
2890   else
2891     mode = unsignedp ? UHAmode : HAmode;
2892
2893   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2894     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2895       break;
2896
2897   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2898     {
2899       sorry ("GCC cannot support operators with integer types and "
2900              "fixed-point types that have too many integral and "
2901              "fractional bits together");
2902       return 0;
2903     }
2904
2905   return c_common_type_for_mode (mode, satp);
2906 }
2907
2908 /* Used for communication between c_common_type_for_mode and
2909    c_register_builtin_type.  */
2910 static GTY(()) tree registered_builtin_types;
2911
2912 /* Return a data type that has machine mode MODE.
2913    If the mode is an integer,
2914    then UNSIGNEDP selects between signed and unsigned types.
2915    If the mode is a fixed-point mode,
2916    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2917
2918 tree
2919 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2920 {
2921   tree t;
2922
2923   if (mode == TYPE_MODE (integer_type_node))
2924     return unsignedp ? unsigned_type_node : integer_type_node;
2925
2926   if (mode == TYPE_MODE (signed_char_type_node))
2927     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2928
2929   if (mode == TYPE_MODE (short_integer_type_node))
2930     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2931
2932   if (mode == TYPE_MODE (long_integer_type_node))
2933     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2934
2935   if (mode == TYPE_MODE (long_long_integer_type_node))
2936     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2937
2938   if (int128_integer_type_node
2939       && mode == TYPE_MODE (int128_integer_type_node))
2940     return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
2941
2942   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2943     return unsignedp ? widest_unsigned_literal_type_node
2944                      : widest_integer_literal_type_node;
2945
2946   if (mode == QImode)
2947     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2948
2949   if (mode == HImode)
2950     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2951
2952   if (mode == SImode)
2953     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2954
2955   if (mode == DImode)
2956     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2957
2958 #if HOST_BITS_PER_WIDE_INT >= 64
2959   if (mode == TYPE_MODE (intTI_type_node))
2960     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2961 #endif
2962
2963   if (mode == TYPE_MODE (float_type_node))
2964     return float_type_node;
2965
2966   if (mode == TYPE_MODE (double_type_node))
2967     return double_type_node;
2968
2969   if (mode == TYPE_MODE (long_double_type_node))
2970     return long_double_type_node;
2971
2972   if (mode == TYPE_MODE (void_type_node))
2973     return void_type_node;
2974
2975   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2976     return (unsignedp
2977             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2978             : make_signed_type (GET_MODE_PRECISION (mode)));
2979
2980   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2981     return (unsignedp
2982             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2983             : make_signed_type (GET_MODE_PRECISION (mode)));
2984
2985   if (COMPLEX_MODE_P (mode))
2986     {
2987       enum machine_mode inner_mode;
2988       tree inner_type;
2989
2990       if (mode == TYPE_MODE (complex_float_type_node))
2991         return complex_float_type_node;
2992       if (mode == TYPE_MODE (complex_double_type_node))
2993         return complex_double_type_node;
2994       if (mode == TYPE_MODE (complex_long_double_type_node))
2995         return complex_long_double_type_node;
2996
2997       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2998         return complex_integer_type_node;
2999
3000       inner_mode = GET_MODE_INNER (mode);
3001       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3002       if (inner_type != NULL_TREE)
3003         return build_complex_type (inner_type);
3004     }
3005   else if (VECTOR_MODE_P (mode))
3006     {
3007       enum machine_mode inner_mode = GET_MODE_INNER (mode);
3008       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3009       if (inner_type != NULL_TREE)
3010         return build_vector_type_for_mode (inner_type, mode);
3011     }
3012
3013   if (mode == TYPE_MODE (dfloat32_type_node))
3014     return dfloat32_type_node;
3015   if (mode == TYPE_MODE (dfloat64_type_node))
3016     return dfloat64_type_node;
3017   if (mode == TYPE_MODE (dfloat128_type_node))
3018     return dfloat128_type_node;
3019
3020   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
3021     {
3022       if (mode == TYPE_MODE (short_fract_type_node))
3023         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
3024       if (mode == TYPE_MODE (fract_type_node))
3025         return unsignedp ? sat_fract_type_node : fract_type_node;
3026       if (mode == TYPE_MODE (long_fract_type_node))
3027         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
3028       if (mode == TYPE_MODE (long_long_fract_type_node))
3029         return unsignedp ? sat_long_long_fract_type_node
3030                          : long_long_fract_type_node;
3031
3032       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
3033         return unsignedp ? sat_unsigned_short_fract_type_node
3034                          : unsigned_short_fract_type_node;
3035       if (mode == TYPE_MODE (unsigned_fract_type_node))
3036         return unsignedp ? sat_unsigned_fract_type_node
3037                          : unsigned_fract_type_node;
3038       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
3039         return unsignedp ? sat_unsigned_long_fract_type_node
3040                          : unsigned_long_fract_type_node;
3041       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
3042         return unsignedp ? sat_unsigned_long_long_fract_type_node
3043                          : unsigned_long_long_fract_type_node;
3044
3045       if (mode == TYPE_MODE (short_accum_type_node))
3046         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
3047       if (mode == TYPE_MODE (accum_type_node))
3048         return unsignedp ? sat_accum_type_node : accum_type_node;
3049       if (mode == TYPE_MODE (long_accum_type_node))
3050         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
3051       if (mode == TYPE_MODE (long_long_accum_type_node))
3052         return unsignedp ? sat_long_long_accum_type_node
3053                          : long_long_accum_type_node;
3054
3055       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
3056         return unsignedp ? sat_unsigned_short_accum_type_node
3057                          : unsigned_short_accum_type_node;
3058       if (mode == TYPE_MODE (unsigned_accum_type_node))
3059         return unsignedp ? sat_unsigned_accum_type_node
3060                          : unsigned_accum_type_node;
3061       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
3062         return unsignedp ? sat_unsigned_long_accum_type_node
3063                          : unsigned_long_accum_type_node;
3064       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
3065         return unsignedp ? sat_unsigned_long_long_accum_type_node
3066                          : unsigned_long_long_accum_type_node;
3067
3068       if (mode == QQmode)
3069         return unsignedp ? sat_qq_type_node : qq_type_node;
3070       if (mode == HQmode)
3071         return unsignedp ? sat_hq_type_node : hq_type_node;
3072       if (mode == SQmode)
3073         return unsignedp ? sat_sq_type_node : sq_type_node;
3074       if (mode == DQmode)
3075         return unsignedp ? sat_dq_type_node : dq_type_node;
3076       if (mode == TQmode)
3077         return unsignedp ? sat_tq_type_node : tq_type_node;
3078
3079       if (mode == UQQmode)
3080         return unsignedp ? sat_uqq_type_node : uqq_type_node;
3081       if (mode == UHQmode)
3082         return unsignedp ? sat_uhq_type_node : uhq_type_node;
3083       if (mode == USQmode)
3084         return unsignedp ? sat_usq_type_node : usq_type_node;
3085       if (mode == UDQmode)
3086         return unsignedp ? sat_udq_type_node : udq_type_node;
3087       if (mode == UTQmode)
3088         return unsignedp ? sat_utq_type_node : utq_type_node;
3089
3090       if (mode == HAmode)
3091         return unsignedp ? sat_ha_type_node : ha_type_node;
3092       if (mode == SAmode)
3093         return unsignedp ? sat_sa_type_node : sa_type_node;
3094       if (mode == DAmode)
3095         return unsignedp ? sat_da_type_node : da_type_node;
3096       if (mode == TAmode)
3097         return unsignedp ? sat_ta_type_node : ta_type_node;
3098
3099       if (mode == UHAmode)
3100         return unsignedp ? sat_uha_type_node : uha_type_node;
3101       if (mode == USAmode)
3102         return unsignedp ? sat_usa_type_node : usa_type_node;
3103       if (mode == UDAmode)
3104         return unsignedp ? sat_uda_type_node : uda_type_node;
3105       if (mode == UTAmode)
3106         return unsignedp ? sat_uta_type_node : uta_type_node;
3107     }
3108
3109   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
3110     if (TYPE_MODE (TREE_VALUE (t)) == mode)
3111       return TREE_VALUE (t);
3112
3113   return 0;
3114 }
3115
3116 tree
3117 c_common_unsigned_type (tree type)
3118 {
3119   return c_common_signed_or_unsigned_type (1, type);
3120 }
3121
3122 /* Return a signed type the same as TYPE in other respects.  */
3123
3124 tree
3125 c_common_signed_type (tree type)
3126 {
3127   return c_common_signed_or_unsigned_type (0, type);
3128 }
3129
3130 /* Return a type the same as TYPE except unsigned or
3131    signed according to UNSIGNEDP.  */
3132
3133 tree
3134 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3135 {
3136   tree type1;
3137
3138   /* This block of code emulates the behavior of the old
3139      c_common_unsigned_type. In particular, it returns
3140      long_unsigned_type_node if passed a long, even when a int would
3141      have the same size. This is necessary for warnings to work
3142      correctly in archs where sizeof(int) == sizeof(long) */
3143
3144   type1 = TYPE_MAIN_VARIANT (type);
3145   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3146     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3147   if (type1 == integer_type_node || type1 == unsigned_type_node)
3148     return unsignedp ? unsigned_type_node : integer_type_node;
3149   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3150     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3151   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3152     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3153   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3154     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3155   if (int128_integer_type_node
3156       && (type1 == int128_integer_type_node
3157           || type1 == int128_unsigned_type_node))
3158     return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
3159   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3160     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3161 #if HOST_BITS_PER_WIDE_INT >= 64
3162   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3163     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3164 #endif
3165   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3166     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3167   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3168     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3169   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3170     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3171   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3172     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3173
3174 #define C_COMMON_FIXED_TYPES(NAME)          \
3175   if (type1 == short_ ## NAME ## _type_node \
3176       || type1 == unsigned_short_ ## NAME ## _type_node) \
3177     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3178                      : short_ ## NAME ## _type_node; \
3179   if (type1 == NAME ## _type_node \
3180       || type1 == unsigned_ ## NAME ## _type_node) \
3181     return unsignedp ? unsigned_ ## NAME ## _type_node \
3182                      : NAME ## _type_node; \
3183   if (type1 == long_ ## NAME ## _type_node \
3184       || type1 == unsigned_long_ ## NAME ## _type_node) \
3185     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3186                      : long_ ## NAME ## _type_node; \
3187   if (type1 == long_long_ ## NAME ## _type_node \
3188       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3189     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3190                      : long_long_ ## NAME ## _type_node;
3191
3192 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3193   if (type1 == NAME ## _type_node \
3194       || type1 == u ## NAME ## _type_node) \
3195     return unsignedp ? u ## NAME ## _type_node \
3196                      : NAME ## _type_node;
3197
3198 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3199   if (type1 == sat_ ## short_ ## NAME ## _type_node \
3200       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3201     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3202                      : sat_ ## short_ ## NAME ## _type_node; \
3203   if (type1 == sat_ ## NAME ## _type_node \
3204       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3205     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3206                      : sat_ ## NAME ## _type_node; \
3207   if (type1 == sat_ ## long_ ## NAME ## _type_node \
3208       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3209     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3210                      : sat_ ## long_ ## NAME ## _type_node; \
3211   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3212       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3213     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3214                      : sat_ ## long_long_ ## NAME ## _type_node;
3215
3216 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
3217   if (type1 == sat_ ## NAME ## _type_node \
3218       || type1 == sat_ ## u ## NAME ## _type_node) \
3219     return unsignedp ? sat_ ## u ## NAME ## _type_node \
3220                      : sat_ ## NAME ## _type_node;
3221
3222   C_COMMON_FIXED_TYPES (fract);
3223   C_COMMON_FIXED_TYPES_SAT (fract);
3224   C_COMMON_FIXED_TYPES (accum);
3225   C_COMMON_FIXED_TYPES_SAT (accum);
3226
3227   C_COMMON_FIXED_MODE_TYPES (qq);
3228   C_COMMON_FIXED_MODE_TYPES (hq);
3229   C_COMMON_FIXED_MODE_TYPES (sq);
3230   C_COMMON_FIXED_MODE_TYPES (dq);
3231   C_COMMON_FIXED_MODE_TYPES (tq);
3232   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3233   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3234   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3235   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3236   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3237   C_COMMON_FIXED_MODE_TYPES (ha);
3238   C_COMMON_FIXED_MODE_TYPES (sa);
3239   C_COMMON_FIXED_MODE_TYPES (da);
3240   C_COMMON_FIXED_MODE_TYPES (ta);
3241   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3242   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3243   C_COMMON_FIXED_MODE_TYPES_SAT (da);
3244   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3245
3246   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3247      the precision; they have precision set to match their range, but
3248      may use a wider mode to match an ABI.  If we change modes, we may
3249      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
3250      the precision as well, so as to yield correct results for
3251      bit-field types.  C++ does not have these separate bit-field
3252      types, and producing a signed or unsigned variant of an
3253      ENUMERAL_TYPE may cause other problems as well.  */
3254
3255   if (!INTEGRAL_TYPE_P (type)
3256       || TYPE_UNSIGNED (type) == unsignedp)
3257     return type;
3258
3259 #define TYPE_OK(node)                                                       \
3260   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
3261    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3262   if (TYPE_OK (signed_char_type_node))
3263     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3264   if (TYPE_OK (integer_type_node))
3265     return unsignedp ? unsigned_type_node : integer_type_node;
3266   if (TYPE_OK (short_integer_type_node))
3267     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3268   if (TYPE_OK (long_integer_type_node))
3269     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3270   if (TYPE_OK (long_long_integer_type_node))
3271     return (unsignedp ? long_long_unsigned_type_node
3272             : long_long_integer_type_node);
3273   if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3274     return (unsignedp ? int128_unsigned_type_node
3275             : int128_integer_type_node);
3276   if (TYPE_OK (widest_integer_literal_type_node))
3277     return (unsignedp ? widest_unsigned_literal_type_node
3278             : widest_integer_literal_type_node);
3279
3280 #if HOST_BITS_PER_WIDE_INT >= 64
3281   if (TYPE_OK (intTI_type_node))
3282     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3283 #endif
3284   if (TYPE_OK (intDI_type_node))
3285     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3286   if (TYPE_OK (intSI_type_node))
3287     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3288   if (TYPE_OK (intHI_type_node))
3289     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3290   if (TYPE_OK (intQI_type_node))
3291     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3292 #undef TYPE_OK
3293
3294   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3295 }
3296
3297 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
3298
3299 tree
3300 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3301 {
3302   /* Extended integer types of the same width as a standard type have
3303      lesser rank, so those of the same width as int promote to int or
3304      unsigned int and are valid for printf formats expecting int or
3305      unsigned int.  To avoid such special cases, avoid creating
3306      extended integer types for bit-fields if a standard integer type
3307      is available.  */
3308   if (width == TYPE_PRECISION (integer_type_node))
3309     return unsignedp ? unsigned_type_node : integer_type_node;
3310   if (width == TYPE_PRECISION (signed_char_type_node))
3311     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3312   if (width == TYPE_PRECISION (short_integer_type_node))
3313     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3314   if (width == TYPE_PRECISION (long_integer_type_node))
3315     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3316   if (width == TYPE_PRECISION (long_long_integer_type_node))
3317     return (unsignedp ? long_long_unsigned_type_node
3318             : long_long_integer_type_node);
3319   if (int128_integer_type_node
3320       && width == TYPE_PRECISION (int128_integer_type_node))
3321     return (unsignedp ? int128_unsigned_type_node
3322             : int128_integer_type_node);
3323   return build_nonstandard_integer_type (width, unsignedp);
3324 }
3325
3326 /* The C version of the register_builtin_type langhook.  */
3327
3328 void
3329 c_register_builtin_type (tree type, const char* name)
3330 {
3331   tree decl;
3332
3333   decl = build_decl (UNKNOWN_LOCATION,
3334                      TYPE_DECL, get_identifier (name), type);
3335   DECL_ARTIFICIAL (decl) = 1;
3336   if (!TYPE_NAME (type))
3337     TYPE_NAME (type) = decl;
3338   pushdecl (decl);
3339
3340   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3341 }
3342 \f
3343 /* Print an error message for invalid operands to arith operation
3344    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3345    LOCATION is the location of the message.  */
3346
3347 void
3348 binary_op_error (location_t location, enum tree_code code,
3349                  tree type0, tree type1)
3350 {
3351   const char *opname;
3352
3353   switch (code)
3354     {
3355     case PLUS_EXPR:
3356       opname = "+"; break;
3357     case MINUS_EXPR:
3358       opname = "-"; break;
3359     case MULT_EXPR:
3360       opname = "*"; break;
3361     case MAX_EXPR:
3362       opname = "max"; break;
3363     case MIN_EXPR:
3364       opname = "min"; break;
3365     case EQ_EXPR:
3366       opname = "=="; break;
3367     case NE_EXPR:
3368       opname = "!="; break;
3369     case LE_EXPR:
3370       opname = "<="; break;
3371     case GE_EXPR:
3372       opname = ">="; break;
3373     case LT_EXPR:
3374       opname = "<"; break;
3375     case GT_EXPR:
3376       opname = ">"; break;
3377     case LSHIFT_EXPR:
3378       opname = "<<"; break;
3379     case RSHIFT_EXPR:
3380       opname = ">>"; break;
3381     case TRUNC_MOD_EXPR:
3382     case FLOOR_MOD_EXPR:
3383       opname = "%"; break;
3384     case TRUNC_DIV_EXPR:
3385     case FLOOR_DIV_EXPR:
3386       opname = "/"; break;
3387     case BIT_AND_EXPR:
3388       opname = "&"; break;
3389     case BIT_IOR_EXPR:
3390       opname = "|"; break;
3391     case TRUTH_ANDIF_EXPR:
3392       opname = "&&"; break;
3393     case TRUTH_ORIF_EXPR:
3394       opname = "||"; break;
3395     case BIT_XOR_EXPR:
3396       opname = "^"; break;
3397     default:
3398       gcc_unreachable ();
3399     }
3400   error_at (location,
3401             "invalid operands to binary %s (have %qT and %qT)", opname,
3402             type0, type1);
3403 }
3404 \f
3405 /* Subroutine of build_binary_op, used for comparison operations.
3406    See if the operands have both been converted from subword integer types
3407    and, if so, perhaps change them both back to their original type.
3408    This function is also responsible for converting the two operands
3409    to the proper common type for comparison.
3410
3411    The arguments of this function are all pointers to local variables
3412    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3413    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3414
3415    If this function returns nonzero, it means that the comparison has
3416    a constant value.  What this function returns is an expression for
3417    that value.  */
3418
3419 tree
3420 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3421                  enum tree_code *rescode_ptr)
3422 {
3423   tree type;
3424   tree op0 = *op0_ptr;
3425   tree op1 = *op1_ptr;
3426   int unsignedp0, unsignedp1;
3427   int real1, real2;
3428   tree primop0, primop1;
3429   enum tree_code code = *rescode_ptr;
3430
3431   /* Throw away any conversions to wider types
3432      already present in the operands.  */
3433
3434   primop0 = get_narrower (op0, &unsignedp0);
3435   primop1 = get_narrower (op1, &unsignedp1);
3436
3437   /* Handle the case that OP0 does not *contain* a conversion
3438      but it *requires* conversion to FINAL_TYPE.  */
3439
3440   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3441     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3442   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3443     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3444
3445   /* If one of the operands must be floated, we cannot optimize.  */
3446   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3447   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3448
3449   /* If first arg is constant, swap the args (changing operation
3450      so value is preserved), for canonicalization.  Don't do this if
3451      the second arg is 0.  */
3452
3453   if (TREE_CONSTANT (primop0)
3454       && !integer_zerop (primop1) && !real_zerop (primop1)
3455       && !fixed_zerop (primop1))
3456     {
3457       tree tem = primop0;
3458       int temi = unsignedp0;
3459       primop0 = primop1;
3460       primop1 = tem;
3461       tem = op0;
3462       op0 = op1;
3463       op1 = tem;
3464       *op0_ptr = op0;
3465       *op1_ptr = op1;
3466       unsignedp0 = unsignedp1;
3467       unsignedp1 = temi;
3468       temi = real1;
3469       real1 = real2;
3470       real2 = temi;
3471
3472       switch (code)
3473         {
3474         case LT_EXPR:
3475           code = GT_EXPR;
3476           break;
3477         case GT_EXPR:
3478           code = LT_EXPR;
3479           break;
3480         case LE_EXPR:
3481           code = GE_EXPR;
3482           break;
3483         case GE_EXPR:
3484           code = LE_EXPR;
3485           break;
3486         default:
3487           break;
3488         }
3489       *rescode_ptr = code;
3490     }
3491
3492   /* If comparing an integer against a constant more bits wide,
3493      maybe we can deduce a value of 1 or 0 independent of the data.
3494      Or else truncate the constant now
3495      rather than extend the variable at run time.
3496
3497      This is only interesting if the constant is the wider arg.
3498      Also, it is not safe if the constant is unsigned and the
3499      variable arg is signed, since in this case the variable
3500      would be sign-extended and then regarded as unsigned.
3501      Our technique fails in this case because the lowest/highest
3502      possible unsigned results don't follow naturally from the
3503      lowest/highest possible values of the variable operand.
3504      For just EQ_EXPR and NE_EXPR there is another technique that
3505      could be used: see if the constant can be faithfully represented
3506      in the other operand's type, by truncating it and reextending it
3507      and see if that preserves the constant's value.  */
3508
3509   if (!real1 && !real2
3510       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3511       && TREE_CODE (primop1) == INTEGER_CST
3512       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3513     {
3514       int min_gt, max_gt, min_lt, max_lt;
3515       tree maxval, minval;
3516       /* 1 if comparison is nominally unsigned.  */
3517       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3518       tree val;
3519
3520       type = c_common_signed_or_unsigned_type (unsignedp0,
3521                                                TREE_TYPE (primop0));
3522
3523       maxval = TYPE_MAX_VALUE (type);
3524       minval = TYPE_MIN_VALUE (type);
3525
3526       if (unsignedp && !unsignedp0)
3527         *restype_ptr = c_common_signed_type (*restype_ptr);
3528
3529       if (TREE_TYPE (primop1) != *restype_ptr)
3530         {
3531           /* Convert primop1 to target type, but do not introduce
3532              additional overflow.  We know primop1 is an int_cst.  */
3533           primop1 = force_fit_type_double (*restype_ptr,
3534                                            TREE_INT_CST_LOW (primop1),
3535                                            TREE_INT_CST_HIGH (primop1), 0,
3536                                            TREE_OVERFLOW (primop1));
3537         }
3538       if (type != *restype_ptr)
3539         {
3540           minval = convert (*restype_ptr, minval);
3541           maxval = convert (*restype_ptr, maxval);
3542         }
3543
3544       if (unsignedp && unsignedp0)
3545         {
3546           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3547           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3548           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3549           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3550         }
3551       else
3552         {
3553           min_gt = INT_CST_LT (primop1, minval);
3554           max_gt = INT_CST_LT (primop1, maxval);
3555           min_lt = INT_CST_LT (minval, primop1);
3556           max_lt = INT_CST_LT (maxval, primop1);
3557         }
3558
3559       val = 0;
3560       /* This used to be a switch, but Genix compiler can't handle that.  */
3561       if (code == NE_EXPR)
3562         {
3563           if (max_lt || min_gt)
3564             val = truthvalue_true_node;
3565         }
3566       else if (code == EQ_EXPR)
3567         {
3568           if (max_lt || min_gt)
3569             val = truthvalue_false_node;
3570         }
3571       else if (code == LT_EXPR)
3572         {
3573           if (max_lt)
3574             val = truthvalue_true_node;
3575           if (!min_lt)
3576             val = truthvalue_false_node;
3577         }
3578       else if (code == GT_EXPR)
3579         {
3580           if (min_gt)
3581             val = truthvalue_true_node;
3582           if (!max_gt)
3583             val = truthvalue_false_node;
3584         }
3585       else if (code == LE_EXPR)
3586         {
3587           if (!max_gt)
3588             val = truthvalue_true_node;
3589           if (min_gt)
3590             val = truthvalue_false_node;
3591         }
3592       else if (code == GE_EXPR)
3593         {
3594           if (!min_lt)
3595             val = truthvalue_true_node;
3596           if (max_lt)
3597             val = truthvalue_false_node;
3598         }
3599
3600       /* If primop0 was sign-extended and unsigned comparison specd,
3601          we did a signed comparison above using the signed type bounds.
3602          But the comparison we output must be unsigned.
3603
3604          Also, for inequalities, VAL is no good; but if the signed
3605          comparison had *any* fixed result, it follows that the
3606          unsigned comparison just tests the sign in reverse
3607          (positive values are LE, negative ones GE).
3608          So we can generate an unsigned comparison
3609          against an extreme value of the signed type.  */
3610
3611       if (unsignedp && !unsignedp0)
3612         {
3613           if (val != 0)
3614             switch (code)
3615               {
3616               case LT_EXPR:
3617               case GE_EXPR:
3618                 primop1 = TYPE_MIN_VALUE (type);
3619                 val = 0;
3620                 break;
3621
3622               case LE_EXPR:
3623               case GT_EXPR:
3624                 primop1 = TYPE_MAX_VALUE (type);
3625                 val = 0;
3626                 break;
3627
3628               default:
3629                 break;
3630               }
3631           type = c_common_unsigned_type (type);
3632         }
3633
3634       if (TREE_CODE (primop0) != INTEGER_CST)
3635         {
3636           if (val == truthvalue_false_node)
3637             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3638           if (val == truthvalue_true_node)
3639             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3640         }
3641
3642       if (val != 0)
3643         {
3644           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3645           if (TREE_SIDE_EFFECTS (primop0))
3646             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3647           return val;
3648         }
3649
3650       /* Value is not predetermined, but do the comparison
3651          in the type of the operand that is not constant.
3652          TYPE is already properly set.  */
3653     }
3654
3655   /* If either arg is decimal float and the other is float, find the
3656      proper common type to use for comparison.  */
3657   else if (real1 && real2
3658            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3659                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3660     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3661
3662   else if (real1 && real2
3663            && (TYPE_PRECISION (TREE_TYPE (primop0))
3664                == TYPE_PRECISION (TREE_TYPE (primop1))))
3665     type = TREE_TYPE (primop0);
3666
3667   /* If args' natural types are both narrower than nominal type
3668      and both extend in the same manner, compare them
3669      in the type of the wider arg.
3670      Otherwise must actually extend both to the nominal
3671      common type lest different ways of extending
3672      alter the result.
3673      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
3674
3675   else if (unsignedp0 == unsignedp1 && real1 == real2
3676            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3677            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3678     {
3679       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3680       type = c_common_signed_or_unsigned_type (unsignedp0
3681                                                || TYPE_UNSIGNED (*restype_ptr),
3682                                                type);
3683       /* Make sure shorter operand is extended the right way
3684          to match the longer operand.  */
3685       primop0
3686         = convert (c_common_signed_or_unsigned_type (unsignedp0,
3687                                                      TREE_TYPE (primop0)),
3688                    primop0);
3689       primop1
3690         = convert (c_common_signed_or_unsigned_type (unsignedp1,
3691                                                      TREE_TYPE (primop1)),
3692                    primop1);
3693     }
3694   else
3695     {
3696       /* Here we must do the comparison on the nominal type
3697          using the args exactly as we received them.  */
3698       type = *restype_ptr;
3699       primop0 = op0;
3700       primop1 = op1;
3701
3702       if (!real1 && !real2 && integer_zerop (primop1)
3703           && TYPE_UNSIGNED (*restype_ptr))
3704         {
3705           tree value = 0;
3706           switch (code)
3707             {
3708             case GE_EXPR:
3709               /* All unsigned values are >= 0, so we warn.  However,
3710                  if OP0 is a constant that is >= 0, the signedness of
3711                  the comparison isn't an issue, so suppress the
3712                  warning.  */
3713               if (warn_type_limits && !in_system_header
3714                   && !(TREE_CODE (primop0) == INTEGER_CST
3715                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3716                                                    primop0))))
3717                 warning (OPT_Wtype_limits,
3718                          "comparison of unsigned expression >= 0 is always true");
3719               value = truthvalue_true_node;
3720               break;
3721
3722             case LT_EXPR:
3723               if (warn_type_limits && !in_system_header
3724                   && !(TREE_CODE (primop0) == INTEGER_CST
3725                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3726                                                    primop0))))
3727                 warning (OPT_Wtype_limits,
3728                          "comparison of unsigned expression < 0 is always false");
3729               value = truthvalue_false_node;
3730               break;
3731
3732             default:
3733               break;
3734             }
3735
3736           if (value != 0)
3737             {
3738               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3739               if (TREE_SIDE_EFFECTS (primop0))
3740                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3741                                primop0, value);
3742               return value;
3743             }
3744         }
3745     }
3746
3747   *op0_ptr = convert (type, primop0);
3748   *op1_ptr = convert (type, primop1);
3749
3750   *restype_ptr = truthvalue_type_node;
3751
3752   return 0;
3753 }
3754 \f
3755 /* Return a tree for the sum or difference (RESULTCODE says which)
3756    of pointer PTROP and integer INTOP.  */
3757
3758 tree
3759 pointer_int_sum (location_t loc, enum tree_code resultcode,
3760                  tree ptrop, tree intop)
3761 {
3762   tree size_exp, ret;
3763
3764   /* The result is a pointer of the same type that is being added.  */
3765   tree result_type = TREE_TYPE (ptrop);
3766
3767   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3768     {
3769       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3770                "pointer of type %<void *%> used in arithmetic");
3771       size_exp = integer_one_node;
3772     }
3773   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3774     {
3775       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3776                "pointer to a function used in arithmetic");
3777       size_exp = integer_one_node;
3778     }
3779   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3780     {
3781       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3782                "pointer to member function used in arithmetic");
3783       size_exp = integer_one_node;
3784     }
3785   else
3786     size_exp = size_in_bytes (TREE_TYPE (result_type));
3787
3788   /* We are manipulating pointer values, so we don't need to warn
3789      about relying on undefined signed overflow.  We disable the
3790      warning here because we use integer types so fold won't know that
3791      they are really pointers.  */
3792   fold_defer_overflow_warnings ();
3793
3794   /* If what we are about to multiply by the size of the elements
3795      contains a constant term, apply distributive law
3796      and multiply that constant term separately.
3797      This helps produce common subexpressions.  */
3798   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3799       && !TREE_CONSTANT (intop)
3800       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3801       && TREE_CONSTANT (size_exp)
3802       /* If the constant comes from pointer subtraction,
3803          skip this optimization--it would cause an error.  */
3804       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3805       /* If the constant is unsigned, and smaller than the pointer size,
3806          then we must skip this optimization.  This is because it could cause
3807          an overflow error if the constant is negative but INTOP is not.  */
3808       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3809           || (TYPE_PRECISION (TREE_TYPE (intop))
3810               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3811     {
3812       enum tree_code subcode = resultcode;
3813       tree int_type = TREE_TYPE (intop);
3814       if (TREE_CODE (intop) == MINUS_EXPR)
3815         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3816       /* Convert both subexpression types to the type of intop,
3817          because weird cases involving pointer arithmetic
3818          can result in a sum or difference with different type args.  */
3819       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3820                                subcode, ptrop,
3821                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3822       intop = convert (int_type, TREE_OPERAND (intop, 0));
3823     }
3824
3825   /* Convert the integer argument to a type the same size as sizetype
3826      so the multiply won't overflow spuriously.  */
3827   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3828       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3829     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3830                                              TYPE_UNSIGNED (sizetype)), intop);
3831
3832   /* Replace the integer argument with a suitable product by the object size.
3833      Do this multiplication as signed, then convert to the appropriate type
3834      for the pointer operation and disregard an overflow that occured only
3835      because of the sign-extension change in the latter conversion.  */
3836   {
3837     tree t = build_binary_op (loc,
3838                               MULT_EXPR, intop,
3839                               convert (TREE_TYPE (intop), size_exp), 1);
3840     intop = convert (sizetype, t);
3841     if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3842       intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3843                                   TREE_INT_CST_HIGH (intop));
3844   }
3845
3846   /* Create the sum or difference.  */
3847   if (resultcode == MINUS_EXPR)
3848     intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
3849
3850   ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
3851
3852   fold_undefer_and_ignore_overflow_warnings ();
3853
3854   return ret;
3855 }
3856 \f
3857 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3858    and if NON_CONST is known not to be permitted in an evaluated part
3859    of a constant expression.  */
3860
3861 tree
3862 c_wrap_maybe_const (tree expr, bool non_const)
3863 {
3864   bool nowarning = TREE_NO_WARNING (expr);
3865   location_t loc = EXPR_LOCATION (expr);
3866
3867   /* This should never be called for C++.  */
3868   if (c_dialect_cxx ())
3869     gcc_unreachable ();
3870
3871   /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING.  */
3872   STRIP_TYPE_NOPS (expr);
3873   expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3874   C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3875   if (nowarning)
3876     TREE_NO_WARNING (expr) = 1;
3877   protected_set_expr_location (expr, loc);
3878
3879   return expr;
3880 }
3881
3882 /* Wrap a SAVE_EXPR around EXPR, if appropriate.  Like save_expr, but
3883    for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3884    around the SAVE_EXPR if needed so that c_fully_fold does not need
3885    to look inside SAVE_EXPRs.  */
3886
3887 tree
3888 c_save_expr (tree expr)
3889 {
3890   bool maybe_const = true;
3891   if (c_dialect_cxx ())
3892     return save_expr (expr);
3893   expr = c_fully_fold (expr, false, &maybe_const);
3894   expr = save_expr (expr);
3895   if (!maybe_const)
3896     expr = c_wrap_maybe_const (expr, true);
3897   return expr;
3898 }
3899
3900 /* Return whether EXPR is a declaration whose address can never be
3901    NULL.  */
3902
3903 bool
3904 decl_with_nonnull_addr_p (const_tree expr)
3905 {
3906   return (DECL_P (expr)
3907           && (TREE_CODE (expr) == PARM_DECL
3908               || TREE_CODE (expr) == LABEL_DECL
3909               || !DECL_WEAK (expr)));
3910 }
3911
3912 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3913    or for an `if' or `while' statement or ?..: exp.  It should already
3914    have been validated to be of suitable type; otherwise, a bad
3915    diagnostic may result.
3916
3917    The EXPR is located at LOCATION.
3918
3919    This preparation consists of taking the ordinary
3920    representation of an expression expr and producing a valid tree
3921    boolean expression describing whether expr is nonzero.  We could
3922    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3923    but we optimize comparisons, &&, ||, and !.
3924
3925    The resulting type should always be `truthvalue_type_node'.  */
3926
3927 tree
3928 c_common_truthvalue_conversion (location_t location, tree expr)
3929 {
3930   switch (TREE_CODE (expr))
3931     {
3932     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3933     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3934     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3935     case ORDERED_EXPR: case UNORDERED_EXPR:
3936       if (TREE_TYPE (expr) == truthvalue_type_node)
3937         return expr;
3938       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3939                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3940       goto ret;
3941
3942     case TRUTH_ANDIF_EXPR:
3943     case TRUTH_ORIF_EXPR:
3944     case TRUTH_AND_EXPR:
3945     case TRUTH_OR_EXPR:
3946     case TRUTH_XOR_EXPR:
3947       if (TREE_TYPE (expr) == truthvalue_type_node)
3948         return expr;
3949       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3950                      c_common_truthvalue_conversion (location,
3951                                                      TREE_OPERAND (expr, 0)),
3952                      c_common_truthvalue_conversion (location,
3953                                                      TREE_OPERAND (expr, 1)));
3954       goto ret;
3955
3956     case TRUTH_NOT_EXPR:
3957       if (TREE_TYPE (expr) == truthvalue_type_node)
3958         return expr;
3959       expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3960                      c_common_truthvalue_conversion (location,
3961                                                      TREE_OPERAND (expr, 0)));
3962       goto ret;
3963
3964     case ERROR_MARK:
3965       return expr;
3966
3967     case INTEGER_CST:
3968       return integer_zerop (expr) ? truthvalue_false_node
3969                                   : truthvalue_true_node;
3970
3971     case REAL_CST:
3972       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3973              ? truthvalue_true_node
3974              : truthvalue_false_node;
3975
3976     case FIXED_CST:
3977       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3978                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3979              ? truthvalue_true_node
3980              : truthvalue_false_node;
3981
3982     case FUNCTION_DECL:
3983       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3984       /* Fall through.  */
3985
3986     case ADDR_EXPR:
3987       {
3988         tree inner = TREE_OPERAND (expr, 0);
3989         if (decl_with_nonnull_addr_p (inner))
3990           {
3991             /* Common Ada/Pascal programmer's mistake.  */
3992             warning_at (location,
3993                         OPT_Waddress,
3994                         "the address of %qD will always evaluate as %<true%>",
3995                         inner);
3996             return truthvalue_true_node;
3997           }
3998
3999         /* If we still have a decl, it is possible for its address to
4000            be NULL, so we cannot optimize.  */
4001         if (DECL_P (inner))
4002           {
4003             gcc_assert (DECL_WEAK (inner));
4004             break;
4005           }
4006
4007         if (TREE_SIDE_EFFECTS (inner))
4008           {
4009             expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
4010                            inner, truthvalue_true_node);
4011             goto ret;
4012           }
4013         else
4014           return truthvalue_true_node;
4015       }
4016
4017     case COMPLEX_EXPR:
4018       expr = build_binary_op (EXPR_LOCATION (expr),
4019                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4020                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4021                 c_common_truthvalue_conversion (location,
4022                                                 TREE_OPERAND (expr, 0)),
4023                 c_common_truthvalue_conversion (location,
4024                                                 TREE_OPERAND (expr, 1)),
4025                               0);
4026       goto ret;
4027
4028     case NEGATE_EXPR:
4029     case ABS_EXPR:
4030     case FLOAT_EXPR:
4031     case EXCESS_PRECISION_EXPR:
4032       /* These don't change whether an object is nonzero or zero.  */
4033       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4034
4035     case LROTATE_EXPR:
4036     case RROTATE_EXPR:
4037       /* These don't change whether an object is zero or nonzero, but
4038          we can't ignore them if their second arg has side-effects.  */
4039       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4040         {
4041           expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
4042                          TREE_OPERAND (expr, 1),
4043                          c_common_truthvalue_conversion
4044                          (location, TREE_OPERAND (expr, 0)));
4045           goto ret;
4046         }
4047       else
4048         return c_common_truthvalue_conversion (location,
4049                                                TREE_OPERAND (expr, 0));
4050
4051     case COND_EXPR:
4052       /* Distribute the conversion into the arms of a COND_EXPR.  */
4053       if (c_dialect_cxx ())
4054         {
4055           expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
4056                               TREE_OPERAND (expr, 0),
4057                               c_common_truthvalue_conversion (location,
4058                                                               TREE_OPERAND (expr,
4059                                                                             1)),
4060                               c_common_truthvalue_conversion (location,
4061                                                               TREE_OPERAND (expr,
4062                                                                             2)));
4063           goto ret;
4064         }
4065       else
4066         {
4067           /* Folding will happen later for C.  */
4068           expr = build3 (COND_EXPR, truthvalue_type_node,
4069                          TREE_OPERAND (expr, 0),
4070                          c_common_truthvalue_conversion (location,
4071                                                          TREE_OPERAND (expr, 1)),
4072                          c_common_truthvalue_conversion (location,
4073                                                          TREE_OPERAND (expr, 2)));
4074           goto ret;
4075         }
4076
4077     CASE_CONVERT:
4078       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4079          since that affects how `default_conversion' will behave.  */
4080       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4081           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4082         break;
4083       /* If this is widening the argument, we can ignore it.  */
4084       if (TYPE_PRECISION (TREE_TYPE (expr))
4085           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4086         return c_common_truthvalue_conversion (location,
4087                                                TREE_OPERAND (expr, 0));
4088       break;
4089
4090     case MODIFY_EXPR:
4091       if (!TREE_NO_WARNING (expr)
4092           && warn_parentheses)
4093         {
4094           warning (OPT_Wparentheses,
4095                    "suggest parentheses around assignment used as truth value");
4096           TREE_NO_WARNING (expr) = 1;
4097         }
4098       break;
4099
4100     default:
4101       break;
4102     }
4103
4104   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4105     {
4106       tree t = c_save_expr (expr);
4107       expr = (build_binary_op
4108               (EXPR_LOCATION (expr),
4109                (TREE_SIDE_EFFECTS (expr)
4110                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4111         c_common_truthvalue_conversion
4112                (location,
4113                 build_unary_op (location, REALPART_EXPR, t, 0)),
4114         c_common_truthvalue_conversion
4115                (location,
4116                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4117                0));
4118       goto ret;
4119     }
4120
4121   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4122     {
4123       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4124                                           FCONST0 (TYPE_MODE
4125                                                    (TREE_TYPE (expr))));
4126       return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
4127     }
4128   else
4129     return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
4130
4131  ret:
4132   protected_set_expr_location (expr, location);
4133   return expr;
4134 }
4135 \f
4136 static void def_builtin_1  (enum built_in_function fncode,
4137                             const char *name,
4138                             enum built_in_class fnclass,
4139                             tree fntype, tree libtype,
4140                             bool both_p, bool fallback_p, bool nonansi_p,
4141                             tree fnattrs, bool implicit_p);
4142
4143
4144 /* Apply the TYPE_QUALS to the new DECL.  */
4145
4146 void
4147 c_apply_type_quals_to_decl (int type_quals, tree decl)
4148 {
4149   tree type = TREE_TYPE (decl);
4150
4151   if (type == error_mark_node)
4152     return;
4153
4154   if (((type_quals & TYPE_QUAL_CONST)
4155        || (type && TREE_CODE (type) == REFERENCE_TYPE))
4156       /* An object declared 'const' is only readonly after it is
4157          initialized.  We don't have any way of expressing this currently,
4158          so we need to be conservative and unset TREE_READONLY for types
4159          with constructors.  Otherwise aliasing code will ignore stores in
4160          an inline constructor.  */
4161       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4162     TREE_READONLY (decl) = 1;
4163   if (type_quals & TYPE_QUAL_VOLATILE)
4164     {
4165       TREE_SIDE_EFFECTS (decl) = 1;
4166       TREE_THIS_VOLATILE (decl) = 1;
4167     }
4168   if (type_quals & TYPE_QUAL_RESTRICT)
4169     {
4170       while (type && TREE_CODE (type) == ARRAY_TYPE)
4171         /* Allow 'restrict' on arrays of pointers.
4172            FIXME currently we just ignore it.  */
4173         type = TREE_TYPE (type);
4174       if (!type
4175           || !POINTER_TYPE_P (type)
4176           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4177         error ("invalid use of %<restrict%>");
4178     }
4179 }
4180
4181 /* Hash function for the problem of multiple type definitions in
4182    different files.  This must hash all types that will compare
4183    equal via comptypes to the same value.  In practice it hashes
4184    on some of the simple stuff and leaves the details to comptypes.  */
4185
4186 static hashval_t
4187 c_type_hash (const void *p)
4188 {
4189   int i = 0;
4190   int shift, size;
4191   const_tree const t = (const_tree) p;
4192   tree t2;
4193   switch (TREE_CODE (t))
4194     {
4195     /* For pointers, hash on pointee type plus some swizzling.  */
4196     case POINTER_TYPE:
4197       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4198     /* Hash on number of elements and total size.  */
4199     case ENUMERAL_TYPE:
4200       shift = 3;
4201       t2 = TYPE_VALUES (t);
4202       break;
4203     case RECORD_TYPE:
4204       shift = 0;
4205       t2 = TYPE_FIELDS (t);
4206       break;
4207     case QUAL_UNION_TYPE:
4208       shift = 1;
4209       t2 = TYPE_FIELDS (t);
4210       break;
4211     case UNION_TYPE:
4212       shift = 2;
4213       t2 = TYPE_FIELDS (t);
4214       break;
4215     default:
4216       gcc_unreachable ();
4217     }
4218   for (; t2; t2 = TREE_CHAIN (t2))
4219     i++;
4220   /* We might have a VLA here.  */
4221   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4222     size = 0;
4223   else
4224     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4225   return ((size << 24) | (i << shift));
4226 }
4227
4228 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4229
4230 /* Return the typed-based alias set for T, which may be an expression
4231    or a type.  Return -1 if we don't do anything special.  */
4232
4233 alias_set_type
4234 c_common_get_alias_set (tree t)
4235 {
4236   tree u;
4237   PTR *slot;
4238
4239   /* For VLAs, use the alias set of the element type rather than the
4240      default of alias set 0 for types compared structurally.  */
4241   if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4242     {
4243       if (TREE_CODE (t) == ARRAY_TYPE)
4244         return get_alias_set (TREE_TYPE (t));
4245       return -1;
4246     }
4247
4248   /* Permit type-punning when accessing a union, provided the access
4249      is directly through the union.  For example, this code does not
4250      permit taking the address of a union member and then storing
4251      through it.  Even the type-punning allowed here is a GCC
4252      extension, albeit a common and useful one; the C standard says
4253      that such accesses have implementation-defined behavior.  */
4254   for (u = t;
4255        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4256        u = TREE_OPERAND (u, 0))
4257     if (TREE_CODE (u) == COMPONENT_REF
4258         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4259       return 0;
4260
4261   /* That's all the expressions we handle specially.  */
4262   if (!TYPE_P (t))
4263     return -1;
4264
4265   /* The C standard guarantees that any object may be accessed via an
4266      lvalue that has character type.  */
4267   if (t == char_type_node
4268       || t == signed_char_type_node
4269       || t == unsigned_char_type_node)
4270     return 0;
4271
4272   /* The C standard specifically allows aliasing between signed and
4273      unsigned variants of the same type.  We treat the signed
4274      variant as canonical.  */
4275   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4276     {
4277       tree t1 = c_common_signed_type (t);
4278
4279       /* t1 == t can happen for boolean nodes which are always unsigned.  */
4280       if (t1 != t)
4281         return get_alias_set (t1);
4282     }
4283   else if (POINTER_TYPE_P (t))
4284     {
4285       tree t1;
4286
4287       /* Unfortunately, there is no canonical form of a pointer type.
4288          In particular, if we have `typedef int I', then `int *', and
4289          `I *' are different types.  So, we have to pick a canonical
4290          representative.  We do this below.
4291
4292          Technically, this approach is actually more conservative that
4293          it needs to be.  In particular, `const int *' and `int *'
4294          should be in different alias sets, according to the C and C++
4295          standard, since their types are not the same, and so,
4296          technically, an `int **' and `const int **' cannot point at
4297          the same thing.
4298
4299          But, the standard is wrong.  In particular, this code is
4300          legal C++:
4301
4302             int *ip;
4303             int **ipp = &ip;
4304             const int* const* cipp = ipp;
4305
4306          And, it doesn't make sense for that to be legal unless you
4307          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
4308          the pointed-to types.  This issue has been reported to the
4309          C++ committee.  */
4310       t1 = build_type_no_quals (t);
4311       if (t1 != t)
4312         return get_alias_set (t1);
4313     }
4314
4315   /* Handle the case of multiple type nodes referring to "the same" type,
4316      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
4317      C90 is handled.  (In C99 type compatibility is not transitive, which
4318      complicates things mightily. The alias set splay trees can theoretically
4319      represent this, but insertion is tricky when you consider all the
4320      different orders things might arrive in.) */
4321
4322   if (c_language != clk_c || flag_isoc99)
4323     return -1;
4324
4325   /* Save time if there's only one input file.  */
4326   if (num_in_fnames == 1)
4327     return -1;
4328
4329   /* Pointers need special handling if they point to any type that
4330      needs special handling (below).  */
4331   if (TREE_CODE (t) == POINTER_TYPE)
4332     {
4333       tree t2;
4334       /* Find bottom type under any nested POINTERs.  */
4335       for (t2 = TREE_TYPE (t);
4336            TREE_CODE (t2) == POINTER_TYPE;
4337            t2 = TREE_TYPE (t2))
4338         ;
4339       if (TREE_CODE (t2) != RECORD_TYPE
4340           && TREE_CODE (t2) != ENUMERAL_TYPE
4341           && TREE_CODE (t2) != QUAL_UNION_TYPE
4342           && TREE_CODE (t2) != UNION_TYPE)
4343         return -1;
4344       if (TYPE_SIZE (t2) == 0)
4345         return -1;
4346     }
4347   /* These are the only cases that need special handling.  */
4348   if (TREE_CODE (t) != RECORD_TYPE
4349       && TREE_CODE (t) != ENUMERAL_TYPE
4350       && TREE_CODE (t) != QUAL_UNION_TYPE
4351       && TREE_CODE (t) != UNION_TYPE
4352       && TREE_CODE (t) != POINTER_TYPE)
4353     return -1;
4354   /* Undefined? */
4355   if (TYPE_SIZE (t) == 0)
4356     return -1;
4357
4358   /* Look up t in hash table.  Only one of the compatible types within each
4359      alias set is recorded in the table.  */
4360   if (!type_hash_table)
4361     type_hash_table = htab_create_ggc (1021, c_type_hash,
4362             (htab_eq) lang_hooks.types_compatible_p,
4363             NULL);
4364   slot = htab_find_slot (type_hash_table, t, INSERT);
4365   if (*slot != NULL)
4366     {
4367       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4368       return TYPE_ALIAS_SET ((tree)*slot);
4369     }
4370   else
4371     /* Our caller will assign and record (in t) a new alias set; all we need
4372        to do is remember t in the hash table.  */
4373     *slot = t;
4374
4375   return -1;
4376 }
4377 \f
4378 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4379    the second parameter indicates which OPERATOR is being applied.
4380    The COMPLAIN flag controls whether we should diagnose possibly
4381    ill-formed constructs or not.  LOC is the location of the SIZEOF or
4382    TYPEOF operator.  */
4383
4384 tree
4385 c_sizeof_or_alignof_type (location_t loc,
4386                           tree type, bool is_sizeof, int complain)
4387 {
4388   const char *op_name;
4389   tree value = NULL;
4390   enum tree_code type_code = TREE_CODE (type);
4391
4392   op_name = is_sizeof ? "sizeof" : "__alignof__";
4393
4394   if (type_code == FUNCTION_TYPE)
4395     {
4396       if (is_sizeof)
4397         {
4398           if (complain && (pedantic || warn_pointer_arith))
4399             pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4400                      "invalid application of %<sizeof%> to a function type");
4401           else if (!complain)
4402             return error_mark_node;
4403           value = size_one_node;
4404         }
4405       else
4406         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4407     }
4408   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4409     {
4410       if (type_code == VOID_TYPE
4411           && complain && (pedantic || warn_pointer_arith))
4412         pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4413                  "invalid application of %qs to a void type", op_name);
4414       else if (!complain)
4415         return error_mark_node;
4416       value = size_one_node;
4417     }
4418   else if (!COMPLETE_TYPE_P (type))
4419     {
4420       if (complain)
4421         error_at (loc, "invalid application of %qs to incomplete type %qT ",
4422                   op_name, type);
4423       return error_mark_node;
4424     }
4425   else
4426     {
4427       if (is_sizeof)
4428         /* Convert in case a char is more than one unit.  */
4429         value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4430                                 size_int (TYPE_PRECISION (char_type_node)
4431                                           / BITS_PER_UNIT));
4432       else
4433         value = size_int (TYPE_ALIGN_UNIT (type));
4434     }
4435
4436   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4437      TYPE_IS_SIZETYPE means that certain things (like overflow) will
4438      never happen.  However, this node should really have type
4439      `size_t', which is just a typedef for an ordinary integer type.  */
4440   value = fold_convert_loc (loc, size_type_node, value);
4441   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4442
4443   return value;
4444 }
4445
4446 /* Implement the __alignof keyword: Return the minimum required
4447    alignment of EXPR, measured in bytes.  For VAR_DECLs,
4448    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4449    from an "aligned" __attribute__ specification).  LOC is the
4450    location of the ALIGNOF operator.  */
4451
4452 tree
4453 c_alignof_expr (location_t loc, tree expr)
4454 {
4455   tree t;
4456
4457   if (VAR_OR_FUNCTION_DECL_P (expr))
4458     t = size_int (DECL_ALIGN_UNIT (expr));
4459
4460   else if (TREE_CODE (expr) == COMPONENT_REF
4461            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4462     {
4463       error_at (loc, "%<__alignof%> applied to a bit-field");
4464       t = size_one_node;
4465     }
4466   else if (TREE_CODE (expr) == COMPONENT_REF
4467            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4468     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4469
4470   else if (TREE_CODE (expr) == INDIRECT_REF)
4471     {
4472       tree t = TREE_OPERAND (expr, 0);
4473       tree best = t;
4474       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4475
4476       while (CONVERT_EXPR_P (t)
4477              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4478         {
4479           int thisalign;
4480
4481           t = TREE_OPERAND (t, 0);
4482           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4483           if (thisalign > bestalign)
4484             best = t, bestalign = thisalign;
4485         }
4486       return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
4487     }
4488   else
4489     return c_alignof (loc, TREE_TYPE (expr));
4490
4491   return fold_convert_loc (loc, size_type_node, t);
4492 }
4493 \f
4494 /* Handle C and C++ default attributes.  */
4495
4496 enum built_in_attribute
4497 {
4498 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4499 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4500 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4501 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4502 #include "builtin-attrs.def"
4503 #undef DEF_ATTR_NULL_TREE
4504 #undef DEF_ATTR_INT
4505 #undef DEF_ATTR_IDENT
4506 #undef DEF_ATTR_TREE_LIST
4507   ATTR_LAST
4508 };
4509
4510 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4511
4512 static void c_init_attributes (void);
4513
4514 enum c_builtin_type
4515 {
4516 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4517 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4518 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4519 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4520 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4521 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4522 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4523 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4524 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4525 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4526 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4527 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4528 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4529 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4530 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4531   NAME,
4532 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4533 #include "builtin-types.def"
4534 #undef DEF_PRIMITIVE_TYPE
4535 #undef DEF_FUNCTION_TYPE_0
4536 #undef DEF_FUNCTION_TYPE_1
4537 #undef DEF_FUNCTION_TYPE_2
4538 #undef DEF_FUNCTION_TYPE_3
4539 #undef DEF_FUNCTION_TYPE_4
4540 #undef DEF_FUNCTION_TYPE_5
4541 #undef DEF_FUNCTION_TYPE_6
4542 #undef DEF_FUNCTION_TYPE_7
4543 #undef DEF_FUNCTION_TYPE_VAR_0
4544 #undef DEF_FUNCTION_TYPE_VAR_1
4545 #undef DEF_FUNCTION_TYPE_VAR_2
4546 #undef DEF_FUNCTION_TYPE_VAR_3
4547 #undef DEF_FUNCTION_TYPE_VAR_4
4548 #undef DEF_FUNCTION_TYPE_VAR_5
4549 #undef DEF_POINTER_TYPE
4550   BT_LAST
4551 };
4552
4553 typedef enum c_builtin_type builtin_type;
4554
4555 /* A temporary array for c_common_nodes_and_builtins.  Used in
4556    communication with def_fn_type.  */
4557 static tree builtin_types[(int) BT_LAST + 1];
4558
4559 /* A helper function for c_common_nodes_and_builtins.  Build function type
4560    for DEF with return type RET and N arguments.  If VAR is true, then the
4561    function should be variadic after those N arguments.
4562
4563    Takes special care not to ICE if any of the types involved are
4564    error_mark_node, which indicates that said type is not in fact available
4565    (see builtin_type_for_size).  In which case the function type as a whole
4566    should be error_mark_node.  */
4567
4568 static void
4569 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4570 {
4571   tree args = NULL, t;
4572   va_list list;
4573   int i;
4574
4575   va_start (list, n);
4576   for (i = 0; i < n; ++i)
4577     {
4578       builtin_type a = (builtin_type) va_arg (list, int);
4579       t = builtin_types[a];
4580       if (t == error_mark_node)
4581         goto egress;
4582       args = tree_cons (NULL_TREE, t, args);
4583     }
4584   va_end (list);
4585
4586   args = nreverse (args);
4587   if (!var)
4588     args = chainon (args, void_list_node);
4589
4590   t = builtin_types[ret];
4591   if (t == error_mark_node)
4592     goto egress;
4593   t = build_function_type (t, args);
4594
4595  egress:
4596   builtin_types[def] = t;
4597 }
4598
4599 /* Build builtin functions common to both C and C++ language
4600    frontends.  */
4601
4602 static void
4603 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4604 {
4605 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4606   builtin_types[ENUM] = VALUE;
4607 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4608   def_fn_type (ENUM, RETURN, 0, 0);
4609 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4610   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4611 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4612   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4613 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4614   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4615 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4616   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4617 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4618   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4619 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4620                             ARG6)                                       \
4621   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4622 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4623                             ARG6, ARG7)                                 \
4624   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4625 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4626   def_fn_type (ENUM, RETURN, 1, 0);
4627 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4628   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4629 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4630   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4631 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4632   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4633 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4634   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4635 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4636   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4637 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4638   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4639
4640 #include "builtin-types.def"
4641
4642 #undef DEF_PRIMITIVE_TYPE
4643 #undef DEF_FUNCTION_TYPE_1
4644 #undef DEF_FUNCTION_TYPE_2
4645 #undef DEF_FUNCTION_TYPE_3
4646 #undef DEF_FUNCTION_TYPE_4
4647 #undef DEF_FUNCTION_TYPE_5
4648 #undef DEF_FUNCTION_TYPE_6
4649 #undef DEF_FUNCTION_TYPE_VAR_0
4650 #undef DEF_FUNCTION_TYPE_VAR_1
4651 #undef DEF_FUNCTION_TYPE_VAR_2
4652 #undef DEF_FUNCTION_TYPE_VAR_3
4653 #undef DEF_FUNCTION_TYPE_VAR_4
4654 #undef DEF_FUNCTION_TYPE_VAR_5
4655 #undef DEF_POINTER_TYPE
4656   builtin_types[(int) BT_LAST] = NULL_TREE;
4657
4658   c_init_attributes ();
4659
4660 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4661                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4662   if (NAME && COND)                                                     \
4663     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4664                    builtin_types[(int) TYPE],                           \
4665                    builtin_types[(int) LIBTYPE],                        \
4666                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4667                    built_in_attributes[(int) ATTRS], IMPLICIT);
4668 #include "builtins.def"
4669 #undef DEF_BUILTIN
4670
4671   targetm.init_builtins ();
4672
4673   build_common_builtin_nodes ();
4674
4675   if (flag_mudflap)
4676     mudflap_init ();
4677 }
4678
4679 /* Like get_identifier, but avoid warnings about null arguments when
4680    the argument may be NULL for targets where GCC lacks stdint.h type
4681    information.  */
4682
4683 static inline tree
4684 c_get_ident (const char *id)
4685 {
4686   return get_identifier (id);
4687 }
4688
4689 /* Build tree nodes and builtin functions common to both C and C++ language
4690    frontends.  */
4691
4692 void
4693 c_common_nodes_and_builtins (void)
4694 {
4695   int char16_type_size;
4696   int char32_type_size;
4697   int wchar_type_size;
4698   tree array_domain_type;
4699   tree va_list_ref_type_node;
4700   tree va_list_arg_type_node;
4701
4702   /* Define `int' and `char' first so that dbx will output them first.  */
4703   record_builtin_type (RID_INT, NULL, integer_type_node);
4704   record_builtin_type (RID_CHAR, "char", char_type_node);
4705
4706   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4707      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4708      but not C.  Are the conditionals here needed?  */
4709   if (c_dialect_cxx ())
4710     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4711   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4712   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4713   record_builtin_type (RID_MAX, "long unsigned int",
4714                        long_unsigned_type_node);
4715   if (int128_integer_type_node != NULL_TREE)
4716     {
4717       record_builtin_type (RID_INT128, "__int128",
4718                            int128_integer_type_node);
4719       record_builtin_type (RID_MAX, "__int128 unsigned",
4720                            int128_unsigned_type_node);
4721     }
4722   if (c_dialect_cxx ())
4723     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4724   record_builtin_type (RID_MAX, "long long int",
4725                        long_long_integer_type_node);
4726   record_builtin_type (RID_MAX, "long long unsigned int",
4727                        long_long_unsigned_type_node);
4728   if (c_dialect_cxx ())
4729     record_builtin_type (RID_MAX, "long long unsigned",
4730                          long_long_unsigned_type_node);
4731   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4732   record_builtin_type (RID_MAX, "short unsigned int",
4733                        short_unsigned_type_node);
4734   if (c_dialect_cxx ())
4735     record_builtin_type (RID_MAX, "unsigned short",
4736                          short_unsigned_type_node);
4737
4738   /* Define both `signed char' and `unsigned char'.  */
4739   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4740   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4741
4742   /* These are types that c_common_type_for_size and
4743      c_common_type_for_mode use.  */
4744   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4745                                          TYPE_DECL, NULL_TREE,
4746                                          intQI_type_node));
4747   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4748                                          TYPE_DECL, NULL_TREE,
4749                                          intHI_type_node));
4750   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4751                                          TYPE_DECL, NULL_TREE,
4752                                          intSI_type_node));
4753   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4754                                          TYPE_DECL, NULL_TREE,
4755                                          intDI_type_node));
4756 #if HOST_BITS_PER_WIDE_INT >= 64
4757   if (targetm.scalar_mode_supported_p (TImode))
4758     lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4759                                            TYPE_DECL,
4760                                            get_identifier ("__int128_t"),
4761                                            intTI_type_node));
4762 #endif
4763   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4764                                          TYPE_DECL, NULL_TREE,
4765                                          unsigned_intQI_type_node));
4766   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4767                                          TYPE_DECL, NULL_TREE,
4768                                          unsigned_intHI_type_node));
4769   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4770                                          TYPE_DECL, NULL_TREE,
4771                                          unsigned_intSI_type_node));
4772   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4773                                          TYPE_DECL, NULL_TREE,
4774                                          unsigned_intDI_type_node));
4775 #if HOST_BITS_PER_WIDE_INT >= 64
4776   if (targetm.scalar_mode_supported_p (TImode))
4777     lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4778                                            TYPE_DECL,
4779                                            get_identifier ("__uint128_t"),
4780                                            unsigned_intTI_type_node));
4781 #endif
4782
4783   /* Create the widest literal types.  */
4784   widest_integer_literal_type_node
4785     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4786   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4787                                          TYPE_DECL, NULL_TREE,
4788                                          widest_integer_literal_type_node));
4789
4790   widest_unsigned_literal_type_node
4791     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4792   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4793                                          TYPE_DECL, NULL_TREE,
4794                                          widest_unsigned_literal_type_node));
4795
4796   /* `unsigned long' is the standard type for sizeof.
4797      Note that stddef.h uses `unsigned long',
4798      and this must agree, even if long and int are the same size.  */
4799   size_type_node =
4800     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4801   signed_size_type_node = c_common_signed_type (size_type_node);
4802   set_sizetype (size_type_node);
4803
4804   pid_type_node =
4805     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4806
4807   build_common_tree_nodes_2 (flag_short_double);
4808
4809   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4810   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4811   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4812
4813   /* Only supported decimal floating point extension if the target
4814      actually supports underlying modes. */
4815   if (targetm.scalar_mode_supported_p (SDmode)
4816       && targetm.scalar_mode_supported_p (DDmode)
4817       && targetm.scalar_mode_supported_p (TDmode))
4818     {
4819       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4820       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4821       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4822     }
4823
4824   if (targetm.fixed_point_supported_p ())
4825     {
4826       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4827       record_builtin_type (RID_FRACT, NULL, fract_type_node);
4828       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4829       record_builtin_type (RID_MAX, "long long _Fract",
4830                            long_long_fract_type_node);
4831       record_builtin_type (RID_MAX, "unsigned short _Fract",
4832                            unsigned_short_fract_type_node);
4833       record_builtin_type (RID_MAX, "unsigned _Fract",
4834                            unsigned_fract_type_node);
4835       record_builtin_type (RID_MAX, "unsigned long _Fract",
4836                            unsigned_long_fract_type_node);
4837       record_builtin_type (RID_MAX, "unsigned long long _Fract",
4838                            unsigned_long_long_fract_type_node);
4839       record_builtin_type (RID_MAX, "_Sat short _Fract",
4840                            sat_short_fract_type_node);
4841       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4842       record_builtin_type (RID_MAX, "_Sat long _Fract",
4843                            sat_long_fract_type_node);
4844       record_builtin_type (RID_MAX, "_Sat long long _Fract",
4845                            sat_long_long_fract_type_node);
4846       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4847                            sat_unsigned_short_fract_type_node);
4848       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4849                            sat_unsigned_fract_type_node);
4850       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4851                            sat_unsigned_long_fract_type_node);
4852       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4853                            sat_unsigned_long_long_fract_type_node);
4854       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4855       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4856       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4857       record_builtin_type (RID_MAX, "long long _Accum",
4858                            long_long_accum_type_node);
4859       record_builtin_type (RID_MAX, "unsigned short _Accum",
4860                            unsigned_short_accum_type_node);
4861       record_builtin_type (RID_MAX, "unsigned _Accum",
4862                            unsigned_accum_type_node);
4863       record_builtin_type (RID_MAX, "unsigned long _Accum",
4864                            unsigned_long_accum_type_node);
4865       record_builtin_type (RID_MAX, "unsigned long long _Accum",
4866                            unsigned_long_long_accum_type_node);
4867       record_builtin_type (RID_MAX, "_Sat short _Accum",
4868                            sat_short_accum_type_node);
4869       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4870       record_builtin_type (RID_MAX, "_Sat long _Accum",
4871                            sat_long_accum_type_node);
4872       record_builtin_type (RID_MAX, "_Sat long long _Accum",
4873                           sat_long_long_accum_type_node);
4874       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4875                            sat_unsigned_short_accum_type_node);
4876       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4877                            sat_unsigned_accum_type_node);
4878       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4879                            sat_unsigned_long_accum_type_node);
4880       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4881                            sat_unsigned_long_long_accum_type_node);
4882
4883     }
4884
4885   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4886                                          TYPE_DECL,
4887                                          get_identifier ("complex int"),
4888                                          complex_integer_type_node));
4889   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4890                                          TYPE_DECL,
4891                                          get_identifier ("complex float"),
4892                                          complex_float_type_node));
4893   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4894                                          TYPE_DECL,
4895                                          get_identifier ("complex double"),
4896                                          complex_double_type_node));
4897   lang_hooks.decls.pushdecl
4898     (build_decl (UNKNOWN_LOCATION,
4899                  TYPE_DECL, get_identifier ("complex long double"),
4900                  complex_long_double_type_node));
4901
4902   if (c_dialect_cxx ())
4903     /* For C++, make fileptr_type_node a distinct void * type until
4904        FILE type is defined.  */
4905     fileptr_type_node = build_variant_type_copy (ptr_type_node);
4906
4907   record_builtin_type (RID_VOID, NULL, void_type_node);
4908
4909   /* Set the TYPE_NAME for any variants that were built before
4910      record_builtin_type gave names to the built-in types. */
4911   {
4912     tree void_name = TYPE_NAME (void_type_node);
4913     TYPE_NAME (void_type_node) = NULL_TREE;
4914     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4915       = void_name;
4916     TYPE_NAME (void_type_node) = void_name;
4917   }
4918
4919   /* This node must not be shared.  */
4920   void_zero_node = make_node (INTEGER_CST);
4921   TREE_TYPE (void_zero_node) = void_type_node;
4922
4923   void_list_node = build_void_list_node ();
4924
4925   /* Make a type to be the domain of a few array types
4926      whose domains don't really matter.
4927      200 is small enough that it always fits in size_t
4928      and large enough that it can hold most function names for the
4929      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
4930   array_domain_type = build_index_type (size_int (200));
4931
4932   /* Make a type for arrays of characters.
4933      With luck nothing will ever really depend on the length of this
4934      array type.  */
4935   char_array_type_node
4936     = build_array_type (char_type_node, array_domain_type);
4937
4938   /* Likewise for arrays of ints.  */
4939   int_array_type_node
4940     = build_array_type (integer_type_node, array_domain_type);
4941
4942   string_type_node = build_pointer_type (char_type_node);
4943   const_string_type_node
4944     = build_pointer_type (build_qualified_type
4945                           (char_type_node, TYPE_QUAL_CONST));
4946
4947   /* This is special for C++ so functions can be overloaded.  */
4948   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4949   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4950   wchar_type_size = TYPE_PRECISION (wchar_type_node);
4951   underlying_wchar_type_node = wchar_type_node;
4952   if (c_dialect_cxx ())
4953     {
4954       if (TYPE_UNSIGNED (wchar_type_node))
4955         wchar_type_node = make_unsigned_type (wchar_type_size);
4956       else
4957         wchar_type_node = make_signed_type (wchar_type_size);
4958       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4959     }
4960
4961   /* This is for wide string constants.  */
4962   wchar_array_type_node
4963     = build_array_type (wchar_type_node, array_domain_type);
4964
4965   /* Define 'char16_t'.  */
4966   char16_type_node = get_identifier (CHAR16_TYPE);
4967   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4968   char16_type_size = TYPE_PRECISION (char16_type_node);
4969   if (c_dialect_cxx ())
4970     {
4971       char16_type_node = make_unsigned_type (char16_type_size);
4972
4973       if (cxx_dialect == cxx0x)
4974         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4975     }
4976
4977   /* This is for UTF-16 string constants.  */
4978   char16_array_type_node
4979     = build_array_type (char16_type_node, array_domain_type);
4980
4981   /* Define 'char32_t'.  */
4982   char32_type_node = get_identifier (CHAR32_TYPE);
4983   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4984   char32_type_size = TYPE_PRECISION (char32_type_node);
4985   if (c_dialect_cxx ())
4986     {
4987       char32_type_node = make_unsigned_type (char32_type_size);
4988
4989       if (cxx_dialect == cxx0x)
4990         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4991     }
4992
4993   /* This is for UTF-32 string constants.  */
4994   char32_array_type_node
4995     = build_array_type (char32_type_node, array_domain_type);
4996
4997   wint_type_node =
4998     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4999
5000   intmax_type_node =
5001     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
5002   uintmax_type_node =
5003     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
5004
5005   if (SIG_ATOMIC_TYPE)
5006     sig_atomic_type_node =
5007       TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
5008   if (INT8_TYPE)
5009     int8_type_node =
5010       TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
5011   if (INT16_TYPE)
5012     int16_type_node =
5013       TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
5014   if (INT32_TYPE)
5015     int32_type_node =
5016       TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
5017   if (INT64_TYPE)
5018     int64_type_node =
5019       TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
5020   if (UINT8_TYPE)
5021     uint8_type_node =
5022       TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
5023   if (UINT16_TYPE)
5024     uint16_type_node =
5025       TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
5026   if (UINT32_TYPE)
5027     c_uint32_type_node =
5028       TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
5029   if (UINT64_TYPE)
5030     c_uint64_type_node =
5031       TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
5032   if (INT_LEAST8_TYPE)
5033     int_least8_type_node =
5034       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
5035   if (INT_LEAST16_TYPE)
5036     int_least16_type_node =
5037       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
5038   if (INT_LEAST32_TYPE)
5039     int_least32_type_node =
5040       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
5041   if (INT_LEAST64_TYPE)
5042     int_least64_type_node =
5043       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
5044   if (UINT_LEAST8_TYPE)
5045     uint_least8_type_node =
5046       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
5047   if (UINT_LEAST16_TYPE)
5048     uint_least16_type_node =
5049       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
5050   if (UINT_LEAST32_TYPE)
5051     uint_least32_type_node =
5052       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
5053   if (UINT_LEAST64_TYPE)
5054     uint_least64_type_node =
5055       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
5056   if (INT_FAST8_TYPE)
5057     int_fast8_type_node =
5058       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
5059   if (INT_FAST16_TYPE)
5060     int_fast16_type_node =
5061       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
5062   if (INT_FAST32_TYPE)
5063     int_fast32_type_node =
5064       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
5065   if (INT_FAST64_TYPE)
5066     int_fast64_type_node =
5067       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5068   if (UINT_FAST8_TYPE)
5069     uint_fast8_type_node =
5070       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5071   if (UINT_FAST16_TYPE)
5072     uint_fast16_type_node =
5073       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5074   if (UINT_FAST32_TYPE)
5075     uint_fast32_type_node =
5076       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5077   if (UINT_FAST64_TYPE)
5078     uint_fast64_type_node =
5079       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5080   if (INTPTR_TYPE)
5081     intptr_type_node =
5082       TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5083   if (UINTPTR_TYPE)
5084     uintptr_type_node =
5085       TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5086
5087   default_function_type = build_function_type (integer_type_node, NULL_TREE);
5088   ptrdiff_type_node
5089     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5090   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5091
5092   lang_hooks.decls.pushdecl
5093     (build_decl (UNKNOWN_LOCATION,
5094                  TYPE_DECL, get_identifier ("__builtin_va_list"),
5095                  va_list_type_node));
5096   if (targetm.enum_va_list)
5097     {
5098       int l;
5099       const char *pname;
5100       tree ptype;
5101
5102       for (l = 0; targetm.enum_va_list (l, &pname, &ptype); ++l)
5103         {
5104           lang_hooks.decls.pushdecl
5105             (build_decl (UNKNOWN_LOCATION,
5106                          TYPE_DECL, get_identifier (pname),
5107                          ptype));
5108
5109         }
5110     }
5111
5112   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5113     {
5114       va_list_arg_type_node = va_list_ref_type_node =
5115         build_pointer_type (TREE_TYPE (va_list_type_node));
5116     }
5117   else
5118     {
5119       va_list_arg_type_node = va_list_type_node;
5120       va_list_ref_type_node = build_reference_type (va_list_type_node);
5121     }
5122
5123   if (!flag_preprocess_only)
5124     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5125
5126   main_identifier_node = get_identifier ("main");
5127
5128   /* Create the built-in __null node.  It is important that this is
5129      not shared.  */
5130   null_node = make_node (INTEGER_CST);
5131   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5132
5133   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
5134   memset (builtin_types, 0, sizeof (builtin_types));
5135 }
5136
5137 /* The number of named compound-literals generated thus far.  */
5138 static GTY(()) int compound_literal_number;
5139
5140 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
5141
5142 void
5143 set_compound_literal_name (tree decl)
5144 {
5145   char *name;
5146   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5147                            compound_literal_number);
5148   compound_literal_number++;
5149   DECL_NAME (decl) = get_identifier (name);
5150 }
5151
5152 tree
5153 build_va_arg (location_t loc, tree expr, tree type)
5154 {
5155   expr = build1 (VA_ARG_EXPR, type, expr);
5156   SET_EXPR_LOCATION (expr, loc);
5157   return expr;
5158 }
5159
5160
5161 /* Linked list of disabled built-in functions.  */
5162
5163 typedef struct disabled_builtin
5164 {
5165   const char *name;
5166   struct disabled_builtin *next;
5167 } disabled_builtin;
5168 static disabled_builtin *disabled_builtins = NULL;
5169
5170 static bool builtin_function_disabled_p (const char *);
5171
5172 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
5173    begins with "__builtin_", give an error.  */
5174
5175 void
5176 disable_builtin_function (const char *name)
5177 {
5178   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5179     error ("cannot disable built-in function %qs", name);
5180   else
5181     {
5182       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5183       new_disabled_builtin->name = name;
5184       new_disabled_builtin->next = disabled_builtins;
5185       disabled_builtins = new_disabled_builtin;
5186     }
5187 }
5188
5189
5190 /* Return true if the built-in function NAME has been disabled, false
5191    otherwise.  */
5192
5193 static bool
5194 builtin_function_disabled_p (const char *name)
5195 {
5196   disabled_builtin *p;
5197   for (p = disabled_builtins; p != NULL; p = p->next)
5198     {
5199       if (strcmp (name, p->name) == 0)
5200         return true;
5201     }
5202   return false;
5203 }
5204
5205
5206 /* Worker for DEF_BUILTIN.
5207    Possibly define a builtin function with one or two names.
5208    Does not declare a non-__builtin_ function if flag_no_builtin, or if
5209    nonansi_p and flag_no_nonansi_builtin.  */
5210
5211 static void
5212 def_builtin_1 (enum built_in_function fncode,
5213                const char *name,
5214                enum built_in_class fnclass,
5215                tree fntype, tree libtype,
5216                bool both_p, bool fallback_p, bool nonansi_p,
5217                tree fnattrs, bool implicit_p)
5218 {
5219   tree decl;
5220   const char *libname;
5221
5222   if (fntype == error_mark_node)
5223     return;
5224
5225   gcc_assert ((!both_p && !fallback_p)
5226               || !strncmp (name, "__builtin_",
5227                            strlen ("__builtin_")));
5228
5229   libname = name + strlen ("__builtin_");
5230   decl = add_builtin_function (name, fntype, fncode, fnclass,
5231                                (fallback_p ? libname : NULL),
5232                                fnattrs);
5233   if (both_p
5234       && !flag_no_builtin && !builtin_function_disabled_p (libname)
5235       && !(nonansi_p && flag_no_nonansi_builtin))
5236     add_builtin_function (libname, libtype, fncode, fnclass,
5237                           NULL, fnattrs);
5238
5239   built_in_decls[(int) fncode] = decl;
5240   if (implicit_p)
5241     implicit_built_in_decls[(int) fncode] = decl;
5242 }
5243 \f
5244 /* Nonzero if the type T promotes to int.  This is (nearly) the
5245    integral promotions defined in ISO C99 6.3.1.1/2.  */
5246
5247 bool
5248 c_promoting_integer_type_p (const_tree t)
5249 {
5250   switch (TREE_CODE (t))
5251     {
5252     case INTEGER_TYPE:
5253       return (TYPE_MAIN_VARIANT (t) == char_type_node
5254               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5255               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5256               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5257               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5258               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5259
5260     case ENUMERAL_TYPE:
5261       /* ??? Technically all enumerations not larger than an int
5262          promote to an int.  But this is used along code paths
5263          that only want to notice a size change.  */
5264       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5265
5266     case BOOLEAN_TYPE:
5267       return 1;
5268
5269     default:
5270       return 0;
5271     }
5272 }
5273
5274 /* Return 1 if PARMS specifies a fixed number of parameters
5275    and none of their types is affected by default promotions.  */
5276
5277 int
5278 self_promoting_args_p (const_tree parms)
5279 {
5280   const_tree t;
5281   for (t = parms; t; t = TREE_CHAIN (t))
5282     {
5283       tree type = TREE_VALUE (t);
5284
5285       if (type == error_mark_node)
5286         continue;
5287
5288       if (TREE_CHAIN (t) == 0 && type != void_type_node)
5289         return 0;
5290
5291       if (type == 0)
5292         return 0;
5293
5294       if (TYPE_MAIN_VARIANT (type) == float_type_node)
5295         return 0;
5296
5297       if (c_promoting_integer_type_p (type))
5298         return 0;
5299     }
5300   return 1;
5301 }
5302
5303 /* Recursively remove any '*' or '&' operator from TYPE.  */
5304 tree
5305 strip_pointer_operator (tree t)
5306 {
5307   while (POINTER_TYPE_P (t))
5308     t = TREE_TYPE (t);
5309   return t;
5310 }
5311
5312 /* Recursively remove pointer or array type from TYPE. */
5313 tree
5314 strip_pointer_or_array_types (tree t)
5315 {
5316   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5317     t = TREE_TYPE (t);
5318   return t;
5319 }
5320
5321 /* Used to compare case labels.  K1 and K2 are actually tree nodes
5322    representing case labels, or NULL_TREE for a `default' label.
5323    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5324    K2, and 0 if K1 and K2 are equal.  */
5325
5326 int
5327 case_compare (splay_tree_key k1, splay_tree_key k2)
5328 {
5329   /* Consider a NULL key (such as arises with a `default' label) to be
5330      smaller than anything else.  */
5331   if (!k1)
5332     return k2 ? -1 : 0;
5333   else if (!k2)
5334     return k1 ? 1 : 0;
5335
5336   return tree_int_cst_compare ((tree) k1, (tree) k2);
5337 }
5338
5339 /* Process a case label, located at LOC, for the range LOW_VALUE
5340    ... HIGH_VALUE.  If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5341    then this case label is actually a `default' label.  If only
5342    HIGH_VALUE is NULL_TREE, then case label was declared using the
5343    usual C/C++ syntax, rather than the GNU case range extension.
5344    CASES is a tree containing all the case ranges processed so far;
5345    COND is the condition for the switch-statement itself.  Returns the
5346    CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5347    is created.  */
5348
5349 tree
5350 c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
5351                   tree low_value, tree high_value)
5352 {
5353   tree type;
5354   tree label;
5355   tree case_label;
5356   splay_tree_node node;
5357
5358   /* Create the LABEL_DECL itself.  */
5359   label = create_artificial_label (loc);
5360
5361   /* If there was an error processing the switch condition, bail now
5362      before we get more confused.  */
5363   if (!cond || cond == error_mark_node)
5364     goto error_out;
5365
5366   if ((low_value && TREE_TYPE (low_value)
5367        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5368       || (high_value && TREE_TYPE (high_value)
5369           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5370     {
5371       error_at (loc, "pointers are not permitted as case values");
5372       goto error_out;
5373     }
5374
5375   /* Case ranges are a GNU extension.  */
5376   if (high_value)
5377     pedwarn (loc, OPT_pedantic,
5378              "range expressions in switch statements are non-standard");
5379
5380   type = TREE_TYPE (cond);
5381   if (low_value)
5382     {
5383       low_value = check_case_value (low_value);
5384       low_value = convert_and_check (type, low_value);
5385       if (low_value == error_mark_node)
5386         goto error_out;
5387     }
5388   if (high_value)
5389     {
5390       high_value = check_case_value (high_value);
5391       high_value = convert_and_check (type, high_value);
5392       if (high_value == error_mark_node)
5393         goto error_out;
5394     }
5395
5396   if (low_value && high_value)
5397     {
5398       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5399          really a case range, even though it was written that way.
5400          Remove the HIGH_VALUE to simplify later processing.  */
5401       if (tree_int_cst_equal (low_value, high_value))
5402         high_value = NULL_TREE;
5403       else if (!tree_int_cst_lt (low_value, high_value))
5404         warning_at (loc, 0, "empty range specified");
5405     }
5406
5407   /* See if the case is in range of the type of the original testing
5408      expression.  If both low_value and high_value are out of range,
5409      don't insert the case label and return NULL_TREE.  */
5410   if (low_value
5411       && !check_case_bounds (type, orig_type,
5412                              &low_value, high_value ? &high_value : NULL))
5413     return NULL_TREE;
5414
5415   /* Look up the LOW_VALUE in the table of case labels we already
5416      have.  */
5417   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5418   /* If there was not an exact match, check for overlapping ranges.
5419      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5420      that's a `default' label and the only overlap is an exact match.  */
5421   if (!node && (low_value || high_value))
5422     {
5423       splay_tree_node low_bound;
5424       splay_tree_node high_bound;
5425
5426       /* Even though there wasn't an exact match, there might be an
5427          overlap between this case range and another case range.
5428          Since we've (inductively) not allowed any overlapping case
5429          ranges, we simply need to find the greatest low case label
5430          that is smaller that LOW_VALUE, and the smallest low case
5431          label that is greater than LOW_VALUE.  If there is an overlap
5432          it will occur in one of these two ranges.  */
5433       low_bound = splay_tree_predecessor (cases,
5434                                           (splay_tree_key) low_value);
5435       high_bound = splay_tree_successor (cases,
5436                                          (splay_tree_key) low_value);
5437
5438       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5439          the LOW_VALUE, so there is no need to check unless the
5440          LOW_BOUND is in fact itself a case range.  */
5441       if (low_bound
5442           && CASE_HIGH ((tree) low_bound->value)
5443           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5444                                     low_value) >= 0)
5445         node = low_bound;
5446       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5447          range is bigger than the low end of the current range, so we
5448          are only interested if the current range is a real range, and
5449          not an ordinary case label.  */
5450       else if (high_bound
5451                && high_value
5452                && (tree_int_cst_compare ((tree) high_bound->key,
5453                                          high_value)
5454                    <= 0))
5455         node = high_bound;
5456     }
5457   /* If there was an overlap, issue an error.  */
5458   if (node)
5459     {
5460       tree duplicate = CASE_LABEL ((tree) node->value);
5461
5462       if (high_value)
5463         {
5464           error_at (loc, "duplicate (or overlapping) case value");
5465           error_at (DECL_SOURCE_LOCATION (duplicate),
5466                     "this is the first entry overlapping that value");
5467         }
5468       else if (low_value)
5469         {
5470           error_at (loc, "duplicate case value") ;
5471           error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
5472         }
5473       else
5474         {
5475           error_at (loc, "multiple default labels in one switch");
5476           error_at (DECL_SOURCE_LOCATION (duplicate),
5477                     "this is the first default label");
5478         }
5479       goto error_out;
5480     }
5481
5482   /* Add a CASE_LABEL to the statement-tree.  */
5483   case_label = add_stmt (build_case_label (loc, low_value, high_value, label));
5484   /* Register this case label in the splay tree.  */
5485   splay_tree_insert (cases,
5486                      (splay_tree_key) low_value,
5487                      (splay_tree_value) case_label);
5488
5489   return case_label;
5490
5491  error_out:
5492   /* Add a label so that the back-end doesn't think that the beginning of
5493      the switch is unreachable.  Note that we do not add a case label, as
5494      that just leads to duplicates and thence to failure later on.  */
5495   if (!cases->root)
5496     {
5497       tree t = create_artificial_label (loc);
5498       add_stmt (build_stmt (loc, LABEL_EXPR, t));
5499     }
5500   return error_mark_node;
5501 }
5502
5503 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5504    Used to verify that case values match up with enumerator values.  */
5505
5506 static void
5507 match_case_to_enum_1 (tree key, tree type, tree label)
5508 {
5509   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5510
5511   /* ??? Not working too hard to print the double-word value.
5512      Should perhaps be done with %lwd in the diagnostic routines?  */
5513   if (TREE_INT_CST_HIGH (key) == 0)
5514     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5515               TREE_INT_CST_LOW (key));
5516   else if (!TYPE_UNSIGNED (type)
5517            && TREE_INT_CST_HIGH (key) == -1
5518            && TREE_INT_CST_LOW (key) != 0)
5519     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5520               -TREE_INT_CST_LOW (key));
5521   else
5522     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5523               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5524               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5525
5526   if (TYPE_NAME (type) == 0)
5527     warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5528                 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5529                 "case value %qs not in enumerated type",
5530                 buf);
5531   else
5532     warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5533                 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5534                 "case value %qs not in enumerated type %qT",
5535                 buf, type);
5536 }
5537
5538 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5539    Used to verify that case values match up with enumerator values.  */
5540
5541 static int
5542 match_case_to_enum (splay_tree_node node, void *data)
5543 {
5544   tree label = (tree) node->value;
5545   tree type = (tree) data;
5546
5547   /* Skip default case.  */
5548   if (!CASE_LOW (label))
5549     return 0;
5550
5551   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5552      when we did our enum->case scan.  Reset our scratch bit after.  */
5553   if (!CASE_LOW_SEEN (label))
5554     match_case_to_enum_1 (CASE_LOW (label), type, label);
5555   else
5556     CASE_LOW_SEEN (label) = 0;
5557
5558   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
5559      not set, that means that CASE_HIGH did not appear when we did our
5560      enum->case scan.  Reset our scratch bit after.  */
5561   if (CASE_HIGH (label))
5562     {
5563       if (!CASE_HIGH_SEEN (label))
5564         match_case_to_enum_1 (CASE_HIGH (label), type, label);
5565       else
5566         CASE_HIGH_SEEN (label) = 0;
5567     }
5568
5569   return 0;
5570 }
5571
5572 /* Handle -Wswitch*.  Called from the front end after parsing the
5573    switch construct.  */
5574 /* ??? Should probably be somewhere generic, since other languages
5575    besides C and C++ would want this.  At the moment, however, C/C++
5576    are the only tree-ssa languages that support enumerations at all,
5577    so the point is moot.  */
5578
5579 void
5580 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5581                       tree type, tree cond)
5582 {
5583   splay_tree_node default_node;
5584   splay_tree_node node;
5585   tree chain;
5586
5587   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5588     return;
5589
5590   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5591   if (!default_node)
5592     warning_at (switch_location, OPT_Wswitch_default,
5593                 "switch missing default case");
5594
5595   /* From here on, we only care about about enumerated types.  */
5596   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5597     return;
5598
5599   /* From here on, we only care about -Wswitch and -Wswitch-enum.  */
5600   if (!warn_switch_enum && !warn_switch)
5601     return;
5602
5603   /* Check the cases.  Warn about case values which are not members of
5604      the enumerated type.  For -Wswitch-enum, or for -Wswitch when
5605      there is no default case, check that exactly all enumeration
5606      literals are covered by the cases.  */
5607
5608   /* Clearing COND if it is not an integer constant simplifies
5609      the tests inside the loop below.  */
5610   if (TREE_CODE (cond) != INTEGER_CST)
5611     cond = NULL_TREE;
5612
5613   /* The time complexity here is O(N*lg(N)) worst case, but for the
5614       common case of monotonically increasing enumerators, it is
5615       O(N), since the nature of the splay tree will keep the next
5616       element adjacent to the root at all times.  */
5617
5618   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5619     {
5620       tree value = TREE_VALUE (chain);
5621       if (TREE_CODE (value) == CONST_DECL)
5622         value = DECL_INITIAL (value);
5623       node = splay_tree_lookup (cases, (splay_tree_key) value);
5624       if (node)
5625         {
5626           /* Mark the CASE_LOW part of the case entry as seen.  */
5627           tree label = (tree) node->value;
5628           CASE_LOW_SEEN (label) = 1;
5629           continue;
5630         }
5631
5632       /* Even though there wasn't an exact match, there might be a
5633          case range which includes the enumerator's value.  */
5634       node = splay_tree_predecessor (cases, (splay_tree_key) value);
5635       if (node && CASE_HIGH ((tree) node->value))
5636         {
5637           tree label = (tree) node->value;
5638           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5639           if (cmp >= 0)
5640             {
5641               /* If we match the upper bound exactly, mark the CASE_HIGH
5642                  part of the case entry as seen.  */
5643               if (cmp == 0)
5644                 CASE_HIGH_SEEN (label) = 1;
5645               continue;
5646             }
5647         }
5648
5649       /* We've now determined that this enumerated literal isn't
5650          handled by the case labels of the switch statement.  */
5651
5652       /* If the switch expression is a constant, we only really care
5653          about whether that constant is handled by the switch.  */
5654       if (cond && tree_int_cst_compare (cond, value))
5655         continue;
5656
5657       /* If there is a default_node, the only relevant option is
5658          Wswitch-enum.  Otherwise, if both are enabled then we prefer
5659          to warn using -Wswitch because -Wswitch is enabled by -Wall
5660          while -Wswitch-enum is explicit.  */
5661       warning_at (switch_location,
5662                   (default_node || !warn_switch
5663                    ? OPT_Wswitch_enum
5664                    : OPT_Wswitch),
5665                   "enumeration value %qE not handled in switch",
5666                   TREE_PURPOSE (chain));
5667     }
5668
5669   /* Warn if there are case expressions that don't correspond to
5670      enumerators.  This can occur since C and C++ don't enforce
5671      type-checking of assignments to enumeration variables.
5672
5673      The time complexity here is now always O(N) worst case, since
5674      we should have marked both the lower bound and upper bound of
5675      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5676      above.  This scan also resets those fields.  */
5677
5678   splay_tree_foreach (cases, match_case_to_enum, type);
5679 }
5680
5681 /* Finish an expression taking the address of LABEL (an
5682    IDENTIFIER_NODE).  Returns an expression for the address.
5683
5684    LOC is the location for the expression returned.  */
5685
5686 tree
5687 finish_label_address_expr (tree label, location_t loc)
5688 {
5689   tree result;
5690
5691   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5692
5693   if (label == error_mark_node)
5694     return error_mark_node;
5695
5696   label = lookup_label (label);
5697   if (label == NULL_TREE)
5698     result = null_pointer_node;
5699   else
5700     {
5701       TREE_USED (label) = 1;
5702       result = build1 (ADDR_EXPR, ptr_type_node, label);
5703       /* The current function is not necessarily uninlinable.
5704          Computed gotos are incompatible with inlining, but the value
5705          here could be used only in a diagnostic, for example.  */
5706       protected_set_expr_location (result, loc);
5707     }
5708
5709   return result;
5710 }
5711 \f
5712
5713 /* Given a boolean expression ARG, return a tree representing an increment
5714    or decrement (as indicated by CODE) of ARG.  The front end must check for
5715    invalid cases (e.g., decrement in C++).  */
5716 tree
5717 boolean_increment (enum tree_code code, tree arg)
5718 {
5719   tree val;
5720   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5721
5722   arg = stabilize_reference (arg);
5723   switch (code)
5724     {
5725     case PREINCREMENT_EXPR:
5726       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5727       break;
5728     case POSTINCREMENT_EXPR:
5729       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5730       arg = save_expr (arg);
5731       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5732       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5733       break;
5734     case PREDECREMENT_EXPR:
5735       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5736                     invert_truthvalue_loc (input_location, arg));
5737       break;
5738     case POSTDECREMENT_EXPR:
5739       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5740                     invert_truthvalue_loc (input_location, arg));
5741       arg = save_expr (arg);
5742       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5743       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5744       break;
5745     default:
5746       gcc_unreachable ();
5747     }
5748   TREE_SIDE_EFFECTS (val) = 1;
5749   return val;
5750 }
5751 \f
5752 /* Built-in macros for stddef.h and stdint.h, that require macros
5753    defined in this file.  */
5754 void
5755 c_stddef_cpp_builtins(void)
5756 {
5757   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5758   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5759   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5760   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5761   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5762   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5763   builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5764   builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5765   if (SIG_ATOMIC_TYPE)
5766     builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5767   if (INT8_TYPE)
5768     builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5769   if (INT16_TYPE)
5770     builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5771   if (INT32_TYPE)
5772     builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5773   if (INT64_TYPE)
5774     builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5775   if (UINT8_TYPE)
5776     builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5777   if (UINT16_TYPE)
5778     builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5779   if (UINT32_TYPE)
5780     builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5781   if (UINT64_TYPE)
5782     builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5783   if (INT_LEAST8_TYPE)
5784     builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5785   if (INT_LEAST16_TYPE)
5786     builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5787   if (INT_LEAST32_TYPE)
5788     builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5789   if (INT_LEAST64_TYPE)
5790     builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5791   if (UINT_LEAST8_TYPE)
5792     builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5793   if (UINT_LEAST16_TYPE)
5794     builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5795   if (UINT_LEAST32_TYPE)
5796     builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5797   if (UINT_LEAST64_TYPE)
5798     builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5799   if (INT_FAST8_TYPE)
5800     builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5801   if (INT_FAST16_TYPE)
5802     builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5803   if (INT_FAST32_TYPE)
5804     builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5805   if (INT_FAST64_TYPE)
5806     builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5807   if (UINT_FAST8_TYPE)
5808     builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5809   if (UINT_FAST16_TYPE)
5810     builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5811   if (UINT_FAST32_TYPE)
5812     builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5813   if (UINT_FAST64_TYPE)
5814     builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5815   if (INTPTR_TYPE)
5816     builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5817   if (UINTPTR_TYPE)
5818     builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5819 }
5820
5821 static void
5822 c_init_attributes (void)
5823 {
5824   /* Fill in the built_in_attributes array.  */
5825 #define DEF_ATTR_NULL_TREE(ENUM)                                \
5826   built_in_attributes[(int) ENUM] = NULL_TREE;
5827 #define DEF_ATTR_INT(ENUM, VALUE)                               \
5828   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5829 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
5830   built_in_attributes[(int) ENUM] = get_identifier (STRING);
5831 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5832   built_in_attributes[(int) ENUM]                       \
5833     = tree_cons (built_in_attributes[(int) PURPOSE],    \
5834                  built_in_attributes[(int) VALUE],      \
5835                  built_in_attributes[(int) CHAIN]);
5836 #include "builtin-attrs.def"
5837 #undef DEF_ATTR_NULL_TREE
5838 #undef DEF_ATTR_INT
5839 #undef DEF_ATTR_IDENT
5840 #undef DEF_ATTR_TREE_LIST
5841 }
5842
5843 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5844    identifier as an argument, so the front end shouldn't look it up.  */
5845
5846 bool
5847 attribute_takes_identifier_p (const_tree attr_id)
5848 {
5849   if (is_attribute_p ("mode", attr_id)
5850       || is_attribute_p ("format", attr_id)
5851       || is_attribute_p ("cleanup", attr_id))
5852     return true;
5853   else
5854     return targetm.attribute_takes_identifier_p (attr_id);
5855 }
5856
5857 /* Attribute handlers common to C front ends.  */
5858
5859 /* Handle a "packed" attribute; arguments as in
5860    struct attribute_spec.handler.  */
5861
5862 static tree
5863 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5864                          int flags, bool *no_add_attrs)
5865 {
5866   if (TYPE_P (*node))
5867     {
5868       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5869         *node = build_variant_type_copy (*node);
5870       TYPE_PACKED (*node) = 1;
5871     }
5872   else if (TREE_CODE (*node) == FIELD_DECL)
5873     {
5874       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5875           /* Still pack bitfields.  */
5876           && ! DECL_INITIAL (*node))
5877         warning (OPT_Wattributes,
5878                  "%qE attribute ignored for field of type %qT",
5879                  name, TREE_TYPE (*node));
5880       else
5881         DECL_PACKED (*node) = 1;
5882     }
5883   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5884      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5885      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5886      that changes what the typedef is typing.  */
5887   else
5888     {
5889       warning (OPT_Wattributes, "%qE attribute ignored", name);
5890       *no_add_attrs = true;
5891     }
5892
5893   return NULL_TREE;
5894 }
5895
5896 /* Handle a "nocommon" attribute; arguments as in
5897    struct attribute_spec.handler.  */
5898
5899 static tree
5900 handle_nocommon_attribute (tree *node, tree name,
5901                            tree ARG_UNUSED (args),
5902                            int ARG_UNUSED (flags), bool *no_add_attrs)
5903 {
5904   if (TREE_CODE (*node) == VAR_DECL)
5905     DECL_COMMON (*node) = 0;
5906   else
5907     {
5908       warning (OPT_Wattributes, "%qE attribute ignored", name);
5909       *no_add_attrs = true;
5910     }
5911
5912   return NULL_TREE;
5913 }
5914
5915 /* Handle a "common" attribute; arguments as in
5916    struct attribute_spec.handler.  */
5917
5918 static tree
5919 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5920                          int ARG_UNUSED (flags), bool *no_add_attrs)
5921 {
5922   if (TREE_CODE (*node) == VAR_DECL)
5923     DECL_COMMON (*node) = 1;
5924   else
5925     {
5926       warning (OPT_Wattributes, "%qE attribute ignored", name);
5927       *no_add_attrs = true;
5928     }
5929
5930   return NULL_TREE;
5931 }
5932
5933 /* Handle a "noreturn" attribute; arguments as in
5934    struct attribute_spec.handler.  */
5935
5936 static tree
5937 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5938                            int ARG_UNUSED (flags), bool *no_add_attrs)
5939 {
5940   tree type = TREE_TYPE (*node);
5941
5942   /* See FIXME comment in c_common_attribute_table.  */
5943   if (TREE_CODE (*node) == FUNCTION_DECL)
5944     TREE_THIS_VOLATILE (*node) = 1;
5945   else if (TREE_CODE (type) == POINTER_TYPE
5946            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5947     TREE_TYPE (*node)
5948       = build_pointer_type
5949         (build_type_variant (TREE_TYPE (type),
5950                              TYPE_READONLY (TREE_TYPE (type)), 1));
5951   else
5952     {
5953       warning (OPT_Wattributes, "%qE attribute ignored", name);
5954       *no_add_attrs = true;
5955     }
5956
5957   return NULL_TREE;
5958 }
5959
5960 /* Handle a "hot" and attribute; arguments as in
5961    struct attribute_spec.handler.  */
5962
5963 static tree
5964 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5965                       int ARG_UNUSED (flags), bool *no_add_attrs)
5966 {
5967   if (TREE_CODE (*node) == FUNCTION_DECL)
5968     {
5969       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5970         {
5971           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5972                    name, "cold");
5973           *no_add_attrs = true;
5974         }
5975       /* Most of the rest of the hot processing is done later with
5976          lookup_attribute.  */
5977     }
5978   else
5979     {
5980       warning (OPT_Wattributes, "%qE attribute ignored", name);
5981       *no_add_attrs = true;
5982     }
5983
5984   return NULL_TREE;
5985 }
5986 /* Handle a "cold" and attribute; arguments as in
5987    struct attribute_spec.handler.  */
5988
5989 static tree
5990 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5991                        int ARG_UNUSED (flags), bool *no_add_attrs)
5992 {
5993   if (TREE_CODE (*node) == FUNCTION_DECL)
5994     {
5995       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5996         {
5997           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5998                    name, "hot");
5999           *no_add_attrs = true;
6000         }
6001       /* Most of the rest of the cold processing is done later with
6002          lookup_attribute.  */
6003     }
6004   else
6005     {
6006       warning (OPT_Wattributes, "%qE attribute ignored", name);
6007       *no_add_attrs = true;
6008     }
6009
6010   return NULL_TREE;
6011 }
6012
6013 /* Handle a "noinline" attribute; arguments as in
6014    struct attribute_spec.handler.  */
6015
6016 static tree
6017 handle_noinline_attribute (tree *node, tree name,
6018                            tree ARG_UNUSED (args),
6019                            int ARG_UNUSED (flags), bool *no_add_attrs)
6020 {
6021   if (TREE_CODE (*node) == FUNCTION_DECL)
6022     DECL_UNINLINABLE (*node) = 1;
6023   else
6024     {
6025       warning (OPT_Wattributes, "%qE attribute ignored", name);
6026       *no_add_attrs = true;
6027     }
6028
6029   return NULL_TREE;
6030 }
6031
6032 /* Handle a "noclone" attribute; arguments as in
6033    struct attribute_spec.handler.  */
6034
6035 static tree
6036 handle_noclone_attribute (tree *node, tree name,
6037                           tree ARG_UNUSED (args),
6038                           int ARG_UNUSED (flags), bool *no_add_attrs)
6039 {
6040   if (TREE_CODE (*node) != FUNCTION_DECL)
6041     {
6042       warning (OPT_Wattributes, "%qE attribute ignored", name);
6043       *no_add_attrs = true;
6044     }
6045
6046   return NULL_TREE;
6047 }
6048
6049 /* Handle a "always_inline" attribute; arguments as in
6050    struct attribute_spec.handler.  */
6051
6052 static tree
6053 handle_always_inline_attribute (tree *node, tree name,
6054                                 tree ARG_UNUSED (args),
6055                                 int ARG_UNUSED (flags),
6056                                 bool *no_add_attrs)
6057 {
6058   if (TREE_CODE (*node) == FUNCTION_DECL)
6059     {
6060       /* Set the attribute and mark it for disregarding inline
6061          limits.  */
6062       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6063     }
6064   else
6065     {
6066       warning (OPT_Wattributes, "%qE attribute ignored", name);
6067       *no_add_attrs = true;
6068     }
6069
6070   return NULL_TREE;
6071 }
6072
6073 /* Handle a "gnu_inline" attribute; arguments as in
6074    struct attribute_spec.handler.  */
6075
6076 static tree
6077 handle_gnu_inline_attribute (tree *node, tree name,
6078                              tree ARG_UNUSED (args),
6079                              int ARG_UNUSED (flags),
6080                              bool *no_add_attrs)
6081 {
6082   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6083     {
6084       /* Do nothing else, just set the attribute.  We'll get at
6085          it later with lookup_attribute.  */
6086     }
6087   else
6088     {
6089       warning (OPT_Wattributes, "%qE attribute ignored", name);
6090       *no_add_attrs = true;
6091     }
6092
6093   return NULL_TREE;
6094 }
6095
6096 /* Handle an "artificial" attribute; arguments as in
6097    struct attribute_spec.handler.  */
6098
6099 static tree
6100 handle_artificial_attribute (tree *node, tree name,
6101                              tree ARG_UNUSED (args),
6102                              int ARG_UNUSED (flags),
6103                              bool *no_add_attrs)
6104 {
6105   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6106     {
6107       /* Do nothing else, just set the attribute.  We'll get at
6108          it later with lookup_attribute.  */
6109     }
6110   else
6111     {
6112       warning (OPT_Wattributes, "%qE attribute ignored", name);
6113       *no_add_attrs = true;
6114     }
6115
6116   return NULL_TREE;
6117 }
6118
6119 /* Handle a "flatten" attribute; arguments as in
6120    struct attribute_spec.handler.  */
6121
6122 static tree
6123 handle_flatten_attribute (tree *node, tree name,
6124                           tree args ATTRIBUTE_UNUSED,
6125                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6126 {
6127   if (TREE_CODE (*node) == FUNCTION_DECL)
6128     /* Do nothing else, just set the attribute.  We'll get at
6129        it later with lookup_attribute.  */
6130     ;
6131   else
6132     {
6133       warning (OPT_Wattributes, "%qE attribute ignored", name);
6134       *no_add_attrs = true;
6135     }
6136
6137   return NULL_TREE;
6138 }
6139
6140 /* Handle a "warning" or "error" attribute; arguments as in
6141    struct attribute_spec.handler.  */
6142
6143 static tree
6144 handle_error_attribute (tree *node, tree name, tree args,
6145                         int ARG_UNUSED (flags), bool *no_add_attrs)
6146 {
6147   if (TREE_CODE (*node) == FUNCTION_DECL
6148       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6149     /* Do nothing else, just set the attribute.  We'll get at
6150        it later with lookup_attribute.  */
6151     ;
6152   else
6153     {
6154       warning (OPT_Wattributes, "%qE attribute ignored", name);
6155       *no_add_attrs = true;
6156     }
6157
6158   return NULL_TREE;
6159 }
6160
6161 /* Handle a "used" attribute; arguments as in
6162    struct attribute_spec.handler.  */
6163
6164 static tree
6165 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6166                        int ARG_UNUSED (flags), bool *no_add_attrs)
6167 {
6168   tree node = *pnode;
6169
6170   if (TREE_CODE (node) == FUNCTION_DECL
6171       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6172     {
6173       TREE_USED (node) = 1;
6174       DECL_PRESERVE_P (node) = 1;
6175       if (TREE_CODE (node) == VAR_DECL)
6176         DECL_READ_P (node) = 1;
6177     }
6178   else
6179     {
6180       warning (OPT_Wattributes, "%qE attribute ignored", name);
6181       *no_add_attrs = true;
6182     }
6183
6184   return NULL_TREE;
6185 }
6186
6187 /* Handle a "unused" attribute; arguments as in
6188    struct attribute_spec.handler.  */
6189
6190 static tree
6191 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6192                          int flags, bool *no_add_attrs)
6193 {
6194   if (DECL_P (*node))
6195     {
6196       tree decl = *node;
6197
6198       if (TREE_CODE (decl) == PARM_DECL
6199           || TREE_CODE (decl) == VAR_DECL
6200           || TREE_CODE (decl) == FUNCTION_DECL
6201           || TREE_CODE (decl) == LABEL_DECL
6202           || TREE_CODE (decl) == TYPE_DECL)
6203         {
6204           TREE_USED (decl) = 1;
6205           if (TREE_CODE (decl) == VAR_DECL
6206               || TREE_CODE (decl) == PARM_DECL)
6207             DECL_READ_P (decl) = 1;
6208         }
6209       else
6210         {
6211           warning (OPT_Wattributes, "%qE attribute ignored", name);
6212           *no_add_attrs = true;
6213         }
6214     }
6215   else
6216     {
6217       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6218         *node = build_variant_type_copy (*node);
6219       TREE_USED (*node) = 1;
6220     }
6221
6222   return NULL_TREE;
6223 }
6224
6225 /* Handle a "externally_visible" attribute; arguments as in
6226    struct attribute_spec.handler.  */
6227
6228 static tree
6229 handle_externally_visible_attribute (tree *pnode, tree name,
6230                                      tree ARG_UNUSED (args),
6231                                      int ARG_UNUSED (flags),
6232                                      bool *no_add_attrs)
6233 {
6234   tree node = *pnode;
6235
6236   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6237     {
6238       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6239            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6240         {
6241           warning (OPT_Wattributes,
6242                    "%qE attribute have effect only on public objects", name);
6243           *no_add_attrs = true;
6244         }
6245     }
6246   else
6247     {
6248       warning (OPT_Wattributes, "%qE attribute ignored", name);
6249       *no_add_attrs = true;
6250     }
6251
6252   return NULL_TREE;
6253 }
6254
6255 /* Handle a "const" attribute; arguments as in
6256    struct attribute_spec.handler.  */
6257
6258 static tree
6259 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6260                         int ARG_UNUSED (flags), bool *no_add_attrs)
6261 {
6262   tree type = TREE_TYPE (*node);
6263
6264   /* See FIXME comment on noreturn in c_common_attribute_table.  */
6265   if (TREE_CODE (*node) == FUNCTION_DECL)
6266     TREE_READONLY (*node) = 1;
6267   else if (TREE_CODE (type) == POINTER_TYPE
6268            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6269     TREE_TYPE (*node)
6270       = build_pointer_type
6271         (build_type_variant (TREE_TYPE (type), 1,
6272                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
6273   else
6274     {
6275       warning (OPT_Wattributes, "%qE attribute ignored", name);
6276       *no_add_attrs = true;
6277     }
6278
6279   return NULL_TREE;
6280 }
6281
6282 /* Handle a "transparent_union" attribute; arguments as in
6283    struct attribute_spec.handler.  */
6284
6285 static tree
6286 handle_transparent_union_attribute (tree *node, tree name,
6287                                     tree ARG_UNUSED (args), int flags,
6288                                     bool *no_add_attrs)
6289 {
6290   tree type;
6291
6292   *no_add_attrs = true;
6293
6294   if (TREE_CODE (*node) == TYPE_DECL)
6295     node = &TREE_TYPE (*node);
6296   type = *node;
6297
6298   if (TREE_CODE (type) == UNION_TYPE)
6299     {
6300       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6301          the code in finish_struct.  */
6302       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6303         {
6304           if (TYPE_FIELDS (type) == NULL_TREE
6305               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6306             goto ignored;
6307
6308           /* A type variant isn't good enough, since we don't a cast
6309              to such a type removed as a no-op.  */
6310           *node = type = build_duplicate_type (type);
6311         }
6312
6313       TYPE_TRANSPARENT_AGGR (type) = 1;
6314       return NULL_TREE;
6315     }
6316
6317  ignored:
6318   warning (OPT_Wattributes, "%qE attribute ignored", name);
6319   return NULL_TREE;
6320 }
6321
6322 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
6323    get the requested priority for a constructor or destructor,
6324    possibly issuing diagnostics for invalid or reserved
6325    priorities.  */
6326
6327 static priority_type
6328 get_priority (tree args, bool is_destructor)
6329 {
6330   HOST_WIDE_INT pri;
6331   tree arg;
6332
6333   if (!args)
6334     return DEFAULT_INIT_PRIORITY;
6335
6336   if (!SUPPORTS_INIT_PRIORITY)
6337     {
6338       if (is_destructor)
6339         error ("destructor priorities are not supported");
6340       else
6341         error ("constructor priorities are not supported");
6342       return DEFAULT_INIT_PRIORITY;
6343     }
6344
6345   arg = TREE_VALUE (args);
6346   if (!host_integerp (arg, /*pos=*/0)
6347       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6348     goto invalid;
6349
6350   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6351   if (pri < 0 || pri > MAX_INIT_PRIORITY)
6352     goto invalid;
6353
6354   if (pri <= MAX_RESERVED_INIT_PRIORITY)
6355     {
6356       if (is_destructor)
6357         warning (0,
6358                  "destructor priorities from 0 to %d are reserved "
6359                  "for the implementation",
6360                  MAX_RESERVED_INIT_PRIORITY);
6361       else
6362         warning (0,
6363                  "constructor priorities from 0 to %d are reserved "
6364                  "for the implementation",
6365                  MAX_RESERVED_INIT_PRIORITY);
6366     }
6367   return pri;
6368
6369  invalid:
6370   if (is_destructor)
6371     error ("destructor priorities must be integers from 0 to %d inclusive",
6372            MAX_INIT_PRIORITY);
6373   else
6374     error ("constructor priorities must be integers from 0 to %d inclusive",
6375            MAX_INIT_PRIORITY);
6376   return DEFAULT_INIT_PRIORITY;
6377 }
6378
6379 /* Handle a "constructor" attribute; arguments as in
6380    struct attribute_spec.handler.  */
6381
6382 static tree
6383 handle_constructor_attribute (tree *node, tree name, tree args,
6384                               int ARG_UNUSED (flags),
6385                               bool *no_add_attrs)
6386 {
6387   tree decl = *node;
6388   tree type = TREE_TYPE (decl);
6389
6390   if (TREE_CODE (decl) == FUNCTION_DECL
6391       && TREE_CODE (type) == FUNCTION_TYPE
6392       && decl_function_context (decl) == 0)
6393     {
6394       priority_type priority;
6395       DECL_STATIC_CONSTRUCTOR (decl) = 1;
6396       priority = get_priority (args, /*is_destructor=*/false);
6397       SET_DECL_INIT_PRIORITY (decl, priority);
6398       TREE_USED (decl) = 1;
6399     }
6400   else
6401     {
6402       warning (OPT_Wattributes, "%qE attribute ignored", name);
6403       *no_add_attrs = true;
6404     }
6405
6406   return NULL_TREE;
6407 }
6408
6409 /* Handle a "destructor" attribute; arguments as in
6410    struct attribute_spec.handler.  */
6411
6412 static tree
6413 handle_destructor_attribute (tree *node, tree name, tree args,
6414                              int ARG_UNUSED (flags),
6415                              bool *no_add_attrs)
6416 {
6417   tree decl = *node;
6418   tree type = TREE_TYPE (decl);
6419
6420   if (TREE_CODE (decl) == FUNCTION_DECL
6421       && TREE_CODE (type) == FUNCTION_TYPE
6422       && decl_function_context (decl) == 0)
6423     {
6424       priority_type priority;
6425       DECL_STATIC_DESTRUCTOR (decl) = 1;
6426       priority = get_priority (args, /*is_destructor=*/true);
6427       SET_DECL_FINI_PRIORITY (decl, priority);
6428       TREE_USED (decl) = 1;
6429     }
6430   else
6431     {
6432       warning (OPT_Wattributes, "%qE attribute ignored", name);
6433       *no_add_attrs = true;
6434     }
6435
6436   return NULL_TREE;
6437 }
6438
6439 /* Handle a "mode" attribute; arguments as in
6440    struct attribute_spec.handler.  */
6441
6442 static tree
6443 handle_mode_attribute (tree *node, tree name, tree args,
6444                        int ARG_UNUSED (flags), bool *no_add_attrs)
6445 {
6446   tree type = *node;
6447   tree ident = TREE_VALUE (args);
6448
6449   *no_add_attrs = true;
6450
6451   if (TREE_CODE (ident) != IDENTIFIER_NODE)
6452     warning (OPT_Wattributes, "%qE attribute ignored", name);
6453   else
6454     {
6455       int j;
6456       const char *p = IDENTIFIER_POINTER (ident);
6457       int len = strlen (p);
6458       enum machine_mode mode = VOIDmode;
6459       tree typefm;
6460       bool valid_mode;
6461
6462       if (len > 4 && p[0] == '_' && p[1] == '_'
6463           && p[len - 1] == '_' && p[len - 2] == '_')
6464         {
6465           char *newp = (char *) alloca (len - 1);
6466
6467           strcpy (newp, &p[2]);
6468           newp[len - 4] = '\0';
6469           p = newp;
6470         }
6471
6472       /* Change this type to have a type with the specified mode.
6473          First check for the special modes.  */
6474       if (!strcmp (p, "byte"))
6475         mode = byte_mode;
6476       else if (!strcmp (p, "word"))
6477         mode = word_mode;
6478       else if (!strcmp (p, "pointer"))
6479         mode = ptr_mode;
6480       else if (!strcmp (p, "libgcc_cmp_return"))
6481         mode = targetm.libgcc_cmp_return_mode ();
6482       else if (!strcmp (p, "libgcc_shift_count"))
6483         mode = targetm.libgcc_shift_count_mode ();
6484       else if (!strcmp (p, "unwind_word"))
6485         mode = targetm.unwind_word_mode ();
6486       else
6487         for (j = 0; j < NUM_MACHINE_MODES; j++)
6488           if (!strcmp (p, GET_MODE_NAME (j)))
6489             {
6490               mode = (enum machine_mode) j;
6491               break;
6492             }
6493
6494       if (mode == VOIDmode)
6495         {
6496           error ("unknown machine mode %qE", ident);
6497           return NULL_TREE;
6498         }
6499
6500       valid_mode = false;
6501       switch (GET_MODE_CLASS (mode))
6502         {
6503         case MODE_INT:
6504         case MODE_PARTIAL_INT:
6505         case MODE_FLOAT:
6506         case MODE_DECIMAL_FLOAT:
6507         case MODE_FRACT:
6508         case MODE_UFRACT:
6509         case MODE_ACCUM:
6510         case MODE_UACCUM:
6511           valid_mode = targetm.scalar_mode_supported_p (mode);
6512           break;
6513
6514         case MODE_COMPLEX_INT:
6515         case MODE_COMPLEX_FLOAT:
6516           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6517           break;
6518
6519         case MODE_VECTOR_INT:
6520         case MODE_VECTOR_FLOAT:
6521         case MODE_VECTOR_FRACT:
6522         case MODE_VECTOR_UFRACT:
6523         case MODE_VECTOR_ACCUM:
6524         case MODE_VECTOR_UACCUM:
6525           warning (OPT_Wattributes, "specifying vector types with "
6526                    "__attribute__ ((mode)) is deprecated");
6527           warning (OPT_Wattributes,
6528                    "use __attribute__ ((vector_size)) instead");
6529           valid_mode = vector_mode_valid_p (mode);
6530           break;
6531
6532         default:
6533           break;
6534         }
6535       if (!valid_mode)
6536         {
6537           error ("unable to emulate %qs", p);
6538           return NULL_TREE;
6539         }
6540
6541       if (POINTER_TYPE_P (type))
6542         {
6543           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6544           tree (*fn)(tree, enum machine_mode, bool);
6545
6546           if (!targetm.addr_space.valid_pointer_mode (mode, as))
6547             {
6548               error ("invalid pointer mode %qs", p);
6549               return NULL_TREE;
6550             }
6551
6552           if (TREE_CODE (type) == POINTER_TYPE)
6553             fn = build_pointer_type_for_mode;
6554           else
6555             fn = build_reference_type_for_mode;
6556           typefm = fn (TREE_TYPE (type), mode, false);
6557         }
6558       else
6559         {
6560           /* For fixed-point modes, we need to test if the signness of type
6561              and the machine mode are consistent.  */
6562           if (ALL_FIXED_POINT_MODE_P (mode)
6563               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6564             {
6565               error ("signness of type and machine mode %qs don't match", p);
6566               return NULL_TREE;
6567             }
6568           /* For fixed-point modes, we need to pass saturating info.  */
6569           typefm = lang_hooks.types.type_for_mode (mode,
6570                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6571                                                       : TYPE_UNSIGNED (type));
6572         }
6573
6574       if (typefm == NULL_TREE)
6575         {
6576           error ("no data type for mode %qs", p);
6577           return NULL_TREE;
6578         }
6579       else if (TREE_CODE (type) == ENUMERAL_TYPE)
6580         {
6581           /* For enumeral types, copy the precision from the integer
6582              type returned above.  If not an INTEGER_TYPE, we can't use
6583              this mode for this type.  */
6584           if (TREE_CODE (typefm) != INTEGER_TYPE)
6585             {
6586               error ("cannot use mode %qs for enumeral types", p);
6587               return NULL_TREE;
6588             }
6589
6590           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6591             {
6592               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6593               typefm = type;
6594             }
6595           else
6596             {
6597               /* We cannot build a type variant, as there's code that assumes
6598                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
6599                  debug generators.  Instead, create a subrange type.  This
6600                  results in all of the enumeral values being emitted only once
6601                  in the original, and the subtype gets them by reference.  */
6602               if (TYPE_UNSIGNED (type))
6603                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6604               else
6605                 typefm = make_signed_type (TYPE_PRECISION (typefm));
6606               TREE_TYPE (typefm) = type;
6607             }
6608         }
6609       else if (VECTOR_MODE_P (mode)
6610                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6611                : TREE_CODE (type) != TREE_CODE (typefm))
6612         {
6613           error ("mode %qs applied to inappropriate type", p);
6614           return NULL_TREE;
6615         }
6616
6617       *node = typefm;
6618     }
6619
6620   return NULL_TREE;
6621 }
6622
6623 /* Handle a "section" attribute; arguments as in
6624    struct attribute_spec.handler.  */
6625
6626 static tree
6627 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6628                           int ARG_UNUSED (flags), bool *no_add_attrs)
6629 {
6630   tree decl = *node;
6631
6632   if (targetm.have_named_sections)
6633     {
6634       user_defined_section_attribute = true;
6635
6636       if ((TREE_CODE (decl) == FUNCTION_DECL
6637            || TREE_CODE (decl) == VAR_DECL)
6638           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6639         {
6640           if (TREE_CODE (decl) == VAR_DECL
6641               && current_function_decl != NULL_TREE
6642               && !TREE_STATIC (decl))
6643             {
6644               error_at (DECL_SOURCE_LOCATION (decl),
6645                         "section attribute cannot be specified for "
6646                         "local variables");
6647               *no_add_attrs = true;
6648             }
6649
6650           /* The decl may have already been given a section attribute
6651              from a previous declaration.  Ensure they match.  */
6652           else if (DECL_SECTION_NAME (decl) != NULL_TREE
6653                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6654                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6655             {
6656               error ("section of %q+D conflicts with previous declaration",
6657                      *node);
6658               *no_add_attrs = true;
6659             }
6660           else if (TREE_CODE (decl) == VAR_DECL
6661                    && !targetm.have_tls && targetm.emutls.tmpl_section
6662                    && DECL_THREAD_LOCAL_P (decl))
6663             {
6664               error ("section of %q+D cannot be overridden", *node);
6665               *no_add_attrs = true;
6666             }
6667           else
6668             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6669         }
6670       else
6671         {
6672           error ("section attribute not allowed for %q+D", *node);
6673           *no_add_attrs = true;
6674         }
6675     }
6676   else
6677     {
6678       error_at (DECL_SOURCE_LOCATION (*node),
6679                 "section attributes are not supported for this target");
6680       *no_add_attrs = true;
6681     }
6682
6683   return NULL_TREE;
6684 }
6685
6686 /* Handle a "aligned" attribute; arguments as in
6687    struct attribute_spec.handler.  */
6688
6689 static tree
6690 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6691                           int flags, bool *no_add_attrs)
6692 {
6693   tree decl = NULL_TREE;
6694   tree *type = NULL;
6695   int is_type = 0;
6696   tree align_expr = (args ? TREE_VALUE (args)
6697                      : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6698   int i;
6699
6700   if (DECL_P (*node))
6701     {
6702       decl = *node;
6703       type = &TREE_TYPE (decl);
6704       is_type = TREE_CODE (*node) == TYPE_DECL;
6705     }
6706   else if (TYPE_P (*node))
6707     type = node, is_type = 1;
6708
6709   if (TREE_CODE (align_expr) != INTEGER_CST)
6710     {
6711       error ("requested alignment is not a constant");
6712       *no_add_attrs = true;
6713     }
6714   else if ((i = tree_log2 (align_expr)) == -1)
6715     {
6716       error ("requested alignment is not a power of 2");
6717       *no_add_attrs = true;
6718     }
6719   else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6720     {
6721       error ("requested alignment is too large");
6722       *no_add_attrs = true;
6723     }
6724   else if (is_type)
6725     {
6726       if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6727         /* OK, modify the type in place.  */;
6728       /* If we have a TYPE_DECL, then copy the type, so that we
6729          don't accidentally modify a builtin type.  See pushdecl.  */
6730       else if (decl && TREE_TYPE (decl) != error_mark_node
6731                && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6732         {
6733           tree tt = TREE_TYPE (decl);
6734           *type = build_variant_type_copy (*type);
6735           DECL_ORIGINAL_TYPE (decl) = tt;
6736           TYPE_NAME (*type) = decl;
6737           TREE_USED (*type) = TREE_USED (decl);
6738           TREE_TYPE (decl) = *type;
6739         }
6740       else
6741         *type = build_variant_type_copy (*type);
6742
6743       TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6744       TYPE_USER_ALIGN (*type) = 1;
6745     }
6746   else if (! VAR_OR_FUNCTION_DECL_P (decl)
6747            && TREE_CODE (decl) != FIELD_DECL)
6748     {
6749       error ("alignment may not be specified for %q+D", decl);
6750       *no_add_attrs = true;
6751     }
6752   else if (TREE_CODE (decl) == FUNCTION_DECL
6753            && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6754     {
6755       if (DECL_USER_ALIGN (decl))
6756         error ("alignment for %q+D was previously specified as %d "
6757                "and may not be decreased", decl,
6758                DECL_ALIGN (decl) / BITS_PER_UNIT);
6759       else
6760         error ("alignment for %q+D must be at least %d", decl,
6761                DECL_ALIGN (decl) / BITS_PER_UNIT);
6762       *no_add_attrs = true;
6763     }
6764   else
6765     {
6766       DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6767       DECL_USER_ALIGN (decl) = 1;
6768     }
6769
6770   return NULL_TREE;
6771 }
6772
6773 /* Handle a "weak" attribute; arguments as in
6774    struct attribute_spec.handler.  */
6775
6776 static tree
6777 handle_weak_attribute (tree *node, tree name,
6778                        tree ARG_UNUSED (args),
6779                        int ARG_UNUSED (flags),
6780                        bool * ARG_UNUSED (no_add_attrs))
6781 {
6782   if (TREE_CODE (*node) == FUNCTION_DECL
6783       && DECL_DECLARED_INLINE_P (*node))
6784     {
6785       error ("inline function %q+D cannot be declared weak", *node);
6786       *no_add_attrs = true;
6787     }
6788   else if (TREE_CODE (*node) == FUNCTION_DECL
6789            || TREE_CODE (*node) == VAR_DECL)
6790     declare_weak (*node);
6791   else
6792     warning (OPT_Wattributes, "%qE attribute ignored", name);
6793
6794   return NULL_TREE;
6795 }
6796
6797 /* Handle an "alias" attribute; arguments as in
6798    struct attribute_spec.handler.  */
6799
6800 static tree
6801 handle_alias_attribute (tree *node, tree name, tree args,
6802                         int ARG_UNUSED (flags), bool *no_add_attrs)
6803 {
6804   tree decl = *node;
6805
6806   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6807     {
6808       warning (OPT_Wattributes, "%qE attribute ignored", name);
6809       *no_add_attrs = true;
6810     }
6811   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6812       || (TREE_CODE (decl) != FUNCTION_DECL
6813           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6814       /* A static variable declaration is always a tentative definition,
6815          but the alias is a non-tentative definition which overrides.  */
6816       || (TREE_CODE (decl) != FUNCTION_DECL
6817           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6818     {
6819       error ("%q+D defined both normally and as an alias", decl);
6820       *no_add_attrs = true;
6821     }
6822
6823   /* Note that the very first time we process a nested declaration,
6824      decl_function_context will not be set.  Indeed, *would* never
6825      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6826      we do below.  After such frobbery, pushdecl would set the context.
6827      In any case, this is never what we want.  */
6828   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6829     {
6830       tree id;
6831
6832       id = TREE_VALUE (args);
6833       if (TREE_CODE (id) != STRING_CST)
6834         {
6835           error ("alias argument not a string");
6836           *no_add_attrs = true;
6837           return NULL_TREE;
6838         }
6839       id = get_identifier (TREE_STRING_POINTER (id));
6840       /* This counts as a use of the object pointed to.  */
6841       TREE_USED (id) = 1;
6842
6843       if (TREE_CODE (decl) == FUNCTION_DECL)
6844         DECL_INITIAL (decl) = error_mark_node;
6845       else
6846         {
6847           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6848             DECL_EXTERNAL (decl) = 1;
6849           else
6850             DECL_EXTERNAL (decl) = 0;
6851           TREE_STATIC (decl) = 1;
6852         }
6853     }
6854   else
6855     {
6856       warning (OPT_Wattributes, "%qE attribute ignored", name);
6857       *no_add_attrs = true;
6858     }
6859
6860   return NULL_TREE;
6861 }
6862
6863 /* Handle a "weakref" attribute; arguments as in struct
6864    attribute_spec.handler.  */
6865
6866 static tree
6867 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6868                           int flags, bool *no_add_attrs)
6869 {
6870   tree attr = NULL_TREE;
6871
6872   /* We must ignore the attribute when it is associated with
6873      local-scoped decls, since attribute alias is ignored and many
6874      such symbols do not even have a DECL_WEAK field.  */
6875   if (decl_function_context (*node)
6876       || current_function_decl
6877       || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6878     {
6879       warning (OPT_Wattributes, "%qE attribute ignored", name);
6880       *no_add_attrs = true;
6881       return NULL_TREE;
6882     }
6883
6884   /* The idea here is that `weakref("name")' mutates into `weakref,
6885      alias("name")', and weakref without arguments, in turn,
6886      implicitly adds weak. */
6887
6888   if (args)
6889     {
6890       attr = tree_cons (get_identifier ("alias"), args, attr);
6891       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6892
6893       *no_add_attrs = true;
6894
6895       decl_attributes (node, attr, flags);
6896     }
6897   else
6898     {
6899       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6900         error_at (DECL_SOURCE_LOCATION (*node),
6901                   "weakref attribute must appear before alias attribute");
6902
6903       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6904          and that isn't supported; and because it wants to add it to
6905          the list of weak decls, which isn't helpful.  */
6906       DECL_WEAK (*node) = 1;
6907     }
6908
6909   return NULL_TREE;
6910 }
6911
6912 /* Handle an "visibility" attribute; arguments as in
6913    struct attribute_spec.handler.  */
6914
6915 static tree
6916 handle_visibility_attribute (tree *node, tree name, tree args,
6917                              int ARG_UNUSED (flags),
6918                              bool *ARG_UNUSED (no_add_attrs))
6919 {
6920   tree decl = *node;
6921   tree id = TREE_VALUE (args);
6922   enum symbol_visibility vis;
6923
6924   if (TYPE_P (*node))
6925     {
6926       if (TREE_CODE (*node) == ENUMERAL_TYPE)
6927         /* OK */;
6928       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6929         {
6930           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6931                    name);
6932           return NULL_TREE;
6933         }
6934       else if (TYPE_FIELDS (*node))
6935         {
6936           error ("%qE attribute ignored because %qT is already defined",
6937                  name, *node);
6938           return NULL_TREE;
6939         }
6940     }
6941   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6942     {
6943       warning (OPT_Wattributes, "%qE attribute ignored", name);
6944       return NULL_TREE;
6945     }
6946
6947   if (TREE_CODE (id) != STRING_CST)
6948     {
6949       error ("visibility argument not a string");
6950       return NULL_TREE;
6951     }
6952
6953   /*  If this is a type, set the visibility on the type decl.  */
6954   if (TYPE_P (decl))
6955     {
6956       decl = TYPE_NAME (decl);
6957       if (!decl)
6958         return NULL_TREE;
6959       if (TREE_CODE (decl) == IDENTIFIER_NODE)
6960         {
6961            warning (OPT_Wattributes, "%qE attribute ignored on types",
6962                     name);
6963            return NULL_TREE;
6964         }
6965     }
6966
6967   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6968     vis = VISIBILITY_DEFAULT;
6969   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6970     vis = VISIBILITY_INTERNAL;
6971   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6972     vis = VISIBILITY_HIDDEN;
6973   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6974     vis = VISIBILITY_PROTECTED;
6975   else
6976     {
6977       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6978       vis = VISIBILITY_DEFAULT;
6979     }
6980
6981   if (DECL_VISIBILITY_SPECIFIED (decl)
6982       && vis != DECL_VISIBILITY (decl))
6983     {
6984       tree attributes = (TYPE_P (*node)
6985                          ? TYPE_ATTRIBUTES (*node)
6986                          : DECL_ATTRIBUTES (decl));
6987       if (lookup_attribute ("visibility", attributes))
6988         error ("%qD redeclared with different visibility", decl);
6989       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6990                && lookup_attribute ("dllimport", attributes))
6991         error ("%qD was declared %qs which implies default visibility",
6992                decl, "dllimport");
6993       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6994                && lookup_attribute ("dllexport", attributes))
6995         error ("%qD was declared %qs which implies default visibility",
6996                decl, "dllexport");
6997     }
6998
6999   DECL_VISIBILITY (decl) = vis;
7000   DECL_VISIBILITY_SPECIFIED (decl) = 1;
7001
7002   /* Go ahead and attach the attribute to the node as well.  This is needed
7003      so we can determine whether we have VISIBILITY_DEFAULT because the
7004      visibility was not specified, or because it was explicitly overridden
7005      from the containing scope.  */
7006
7007   return NULL_TREE;
7008 }
7009
7010 /* Determine the ELF symbol visibility for DECL, which is either a
7011    variable or a function.  It is an error to use this function if a
7012    definition of DECL is not available in this translation unit.
7013    Returns true if the final visibility has been determined by this
7014    function; false if the caller is free to make additional
7015    modifications.  */
7016
7017 bool
7018 c_determine_visibility (tree decl)
7019 {
7020   gcc_assert (TREE_CODE (decl) == VAR_DECL
7021               || TREE_CODE (decl) == FUNCTION_DECL);
7022
7023   /* If the user explicitly specified the visibility with an
7024      attribute, honor that.  DECL_VISIBILITY will have been set during
7025      the processing of the attribute.  We check for an explicit
7026      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
7027      to distinguish the use of an attribute from the use of a "#pragma
7028      GCC visibility push(...)"; in the latter case we still want other
7029      considerations to be able to overrule the #pragma.  */
7030   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
7031       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7032           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
7033               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
7034     return true;
7035
7036   /* Set default visibility to whatever the user supplied with
7037      visibility_specified depending on #pragma GCC visibility.  */
7038   if (!DECL_VISIBILITY_SPECIFIED (decl))
7039     {
7040       if (visibility_options.inpragma
7041           || DECL_VISIBILITY (decl) != default_visibility)
7042         {
7043           DECL_VISIBILITY (decl) = default_visibility;
7044           DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
7045           /* If visibility changed and DECL already has DECL_RTL, ensure
7046              symbol flags are updated.  */
7047           if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
7048                || TREE_CODE (decl) == FUNCTION_DECL)
7049               && DECL_RTL_SET_P (decl))
7050             make_decl_rtl (decl);
7051         }
7052     }
7053   return false;
7054 }
7055
7056 /* Handle an "tls_model" attribute; arguments as in
7057    struct attribute_spec.handler.  */
7058
7059 static tree
7060 handle_tls_model_attribute (tree *node, tree name, tree args,
7061                             int ARG_UNUSED (flags), bool *no_add_attrs)
7062 {
7063   tree id;
7064   tree decl = *node;
7065   enum tls_model kind;
7066
7067   *no_add_attrs = true;
7068
7069   if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7070     {
7071       warning (OPT_Wattributes, "%qE attribute ignored", name);
7072       return NULL_TREE;
7073     }
7074
7075   kind = DECL_TLS_MODEL (decl);
7076   id = TREE_VALUE (args);
7077   if (TREE_CODE (id) != STRING_CST)
7078     {
7079       error ("tls_model argument not a string");
7080       return NULL_TREE;
7081     }
7082
7083   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7084     kind = TLS_MODEL_LOCAL_EXEC;
7085   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7086     kind = TLS_MODEL_INITIAL_EXEC;
7087   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7088     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7089   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7090     kind = TLS_MODEL_GLOBAL_DYNAMIC;
7091   else
7092     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7093
7094   DECL_TLS_MODEL (decl) = kind;
7095   return NULL_TREE;
7096 }
7097
7098 /* Handle a "no_instrument_function" attribute; arguments as in
7099    struct attribute_spec.handler.  */
7100
7101 static tree
7102 handle_no_instrument_function_attribute (tree *node, tree name,
7103                                          tree ARG_UNUSED (args),
7104                                          int ARG_UNUSED (flags),
7105                                          bool *no_add_attrs)
7106 {
7107   tree decl = *node;
7108
7109   if (TREE_CODE (decl) != FUNCTION_DECL)
7110     {
7111       error_at (DECL_SOURCE_LOCATION (decl),
7112                 "%qE attribute applies only to functions", name);
7113       *no_add_attrs = true;
7114     }
7115   else if (DECL_INITIAL (decl))
7116     {
7117       error_at (DECL_SOURCE_LOCATION (decl),
7118                 "can%'t set %qE attribute after definition", name);
7119       *no_add_attrs = true;
7120     }
7121   else
7122     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7123
7124   return NULL_TREE;
7125 }
7126
7127 /* Handle a "malloc" attribute; arguments as in
7128    struct attribute_spec.handler.  */
7129
7130 static tree
7131 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7132                          int ARG_UNUSED (flags), bool *no_add_attrs)
7133 {
7134   if (TREE_CODE (*node) == FUNCTION_DECL
7135       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7136     DECL_IS_MALLOC (*node) = 1;
7137   else
7138     {
7139       warning (OPT_Wattributes, "%qE attribute ignored", name);
7140       *no_add_attrs = true;
7141     }
7142
7143   return NULL_TREE;
7144 }
7145
7146 /* Handle a "alloc_size" attribute; arguments as in
7147    struct attribute_spec.handler.  */
7148
7149 static tree
7150 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7151                              int ARG_UNUSED (flags), bool *no_add_attrs)
7152 {
7153   unsigned arg_count = type_num_arguments (*node);
7154   for (; args; args = TREE_CHAIN (args))
7155     {
7156       tree position = TREE_VALUE (args);
7157
7158       if (TREE_CODE (position) != INTEGER_CST
7159           || TREE_INT_CST_HIGH (position)
7160           || TREE_INT_CST_LOW (position) < 1
7161           || TREE_INT_CST_LOW (position) > arg_count )
7162         {
7163           warning (OPT_Wattributes,
7164                    "alloc_size parameter outside range");
7165           *no_add_attrs = true;
7166           return NULL_TREE;
7167         }
7168     }
7169   return NULL_TREE;
7170 }
7171
7172 /* Handle a "fn spec" attribute; arguments as in
7173    struct attribute_spec.handler.  */
7174
7175 static tree
7176 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7177                          tree args, int ARG_UNUSED (flags),
7178                          bool *no_add_attrs ATTRIBUTE_UNUSED)
7179 {
7180   gcc_assert (args
7181               && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7182               && !TREE_CHAIN (args));
7183   return NULL_TREE;
7184 }
7185
7186 /* Handle a "returns_twice" attribute; arguments as in
7187    struct attribute_spec.handler.  */
7188
7189 static tree
7190 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7191                          int ARG_UNUSED (flags), bool *no_add_attrs)
7192 {
7193   if (TREE_CODE (*node) == FUNCTION_DECL)
7194     DECL_IS_RETURNS_TWICE (*node) = 1;
7195   else
7196     {
7197       warning (OPT_Wattributes, "%qE attribute ignored", name);
7198       *no_add_attrs = true;
7199     }
7200
7201   return NULL_TREE;
7202 }
7203
7204 /* Handle a "no_limit_stack" attribute; arguments as in
7205    struct attribute_spec.handler.  */
7206
7207 static tree
7208 handle_no_limit_stack_attribute (tree *node, tree name,
7209                                  tree ARG_UNUSED (args),
7210                                  int ARG_UNUSED (flags),
7211                                  bool *no_add_attrs)
7212 {
7213   tree decl = *node;
7214
7215   if (TREE_CODE (decl) != FUNCTION_DECL)
7216     {
7217       error_at (DECL_SOURCE_LOCATION (decl),
7218              "%qE attribute applies only to functions", name);
7219       *no_add_attrs = true;
7220     }
7221   else if (DECL_INITIAL (decl))
7222     {
7223       error_at (DECL_SOURCE_LOCATION (decl),
7224                 "can%'t set %qE attribute after definition", name);
7225       *no_add_attrs = true;
7226     }
7227   else
7228     DECL_NO_LIMIT_STACK (decl) = 1;
7229
7230   return NULL_TREE;
7231 }
7232
7233 /* Handle a "pure" attribute; arguments as in
7234    struct attribute_spec.handler.  */
7235
7236 static tree
7237 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7238                        int ARG_UNUSED (flags), bool *no_add_attrs)
7239 {
7240   if (TREE_CODE (*node) == FUNCTION_DECL)
7241     DECL_PURE_P (*node) = 1;
7242   /* ??? TODO: Support types.  */
7243   else
7244     {
7245       warning (OPT_Wattributes, "%qE attribute ignored", name);
7246       *no_add_attrs = true;
7247     }
7248
7249   return NULL_TREE;
7250 }
7251
7252 /* Handle a "no vops" attribute; arguments as in
7253    struct attribute_spec.handler.  */
7254
7255 static tree
7256 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7257                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7258                          bool *ARG_UNUSED (no_add_attrs))
7259 {
7260   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7261   DECL_IS_NOVOPS (*node) = 1;
7262   return NULL_TREE;
7263 }
7264
7265 /* Handle a "deprecated" attribute; arguments as in
7266    struct attribute_spec.handler.  */
7267
7268 static tree
7269 handle_deprecated_attribute (tree *node, tree name,
7270                              tree args, int flags,
7271                              bool *no_add_attrs)
7272 {
7273   tree type = NULL_TREE;
7274   int warn = 0;
7275   tree what = NULL_TREE;
7276
7277   if (!args)
7278     *no_add_attrs = true;
7279   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7280     {
7281       error ("deprecated message is not a string");
7282       *no_add_attrs = true;
7283     }
7284
7285   if (DECL_P (*node))
7286     {
7287       tree decl = *node;
7288       type = TREE_TYPE (decl);
7289
7290       if (TREE_CODE (decl) == TYPE_DECL
7291           || TREE_CODE (decl) == PARM_DECL
7292           || TREE_CODE (decl) == VAR_DECL
7293           || TREE_CODE (decl) == FUNCTION_DECL
7294           || TREE_CODE (decl) == FIELD_DECL)
7295         TREE_DEPRECATED (decl) = 1;
7296       else
7297         warn = 1;
7298     }
7299   else if (TYPE_P (*node))
7300     {
7301       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7302         *node = build_variant_type_copy (*node);
7303       TREE_DEPRECATED (*node) = 1;
7304       type = *node;
7305     }
7306   else
7307     warn = 1;
7308
7309   if (warn)
7310     {
7311       *no_add_attrs = true;
7312       if (type && TYPE_NAME (type))
7313         {
7314           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7315             what = TYPE_NAME (*node);
7316           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7317                    && DECL_NAME (TYPE_NAME (type)))
7318             what = DECL_NAME (TYPE_NAME (type));
7319         }
7320       if (what)
7321         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7322       else
7323         warning (OPT_Wattributes, "%qE attribute ignored", name);
7324     }
7325
7326   return NULL_TREE;
7327 }
7328
7329 /* Handle a "vector_size" attribute; arguments as in
7330    struct attribute_spec.handler.  */
7331
7332 static tree
7333 handle_vector_size_attribute (tree *node, tree name, tree args,
7334                               int ARG_UNUSED (flags),
7335                               bool *no_add_attrs)
7336 {
7337   unsigned HOST_WIDE_INT vecsize, nunits;
7338   enum machine_mode orig_mode;
7339   tree type = *node, new_type, size;
7340
7341   *no_add_attrs = true;
7342
7343   size = TREE_VALUE (args);
7344
7345   if (!host_integerp (size, 1))
7346     {
7347       warning (OPT_Wattributes, "%qE attribute ignored", name);
7348       return NULL_TREE;
7349     }
7350
7351   /* Get the vector size (in bytes).  */
7352   vecsize = tree_low_cst (size, 1);
7353
7354   /* We need to provide for vector pointers, vector arrays, and
7355      functions returning vectors.  For example:
7356
7357        __attribute__((vector_size(16))) short *foo;
7358
7359      In this case, the mode is SI, but the type being modified is
7360      HI, so we need to look further.  */
7361
7362   while (POINTER_TYPE_P (type)
7363          || TREE_CODE (type) == FUNCTION_TYPE
7364          || TREE_CODE (type) == METHOD_TYPE
7365          || TREE_CODE (type) == ARRAY_TYPE
7366          || TREE_CODE (type) == OFFSET_TYPE)
7367     type = TREE_TYPE (type);
7368
7369   /* Get the mode of the type being modified.  */
7370   orig_mode = TYPE_MODE (type);
7371
7372   if ((!INTEGRAL_TYPE_P (type)
7373        && !SCALAR_FLOAT_TYPE_P (type)
7374        && !FIXED_POINT_TYPE_P (type))
7375       || (!SCALAR_FLOAT_MODE_P (orig_mode)
7376           && GET_MODE_CLASS (orig_mode) != MODE_INT
7377           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7378       || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7379       || TREE_CODE (type) == BOOLEAN_TYPE)
7380     {
7381       error ("invalid vector type for attribute %qE", name);
7382       return NULL_TREE;
7383     }
7384
7385   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7386     {
7387       error ("vector size not an integral multiple of component size");
7388       return NULL;
7389     }
7390
7391   if (vecsize == 0)
7392     {
7393       error ("zero vector size");
7394       return NULL;
7395     }
7396
7397   /* Calculate how many units fit in the vector.  */
7398   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7399   if (nunits & (nunits - 1))
7400     {
7401       error ("number of components of the vector not a power of two");
7402       return NULL_TREE;
7403     }
7404
7405   new_type = build_vector_type (type, nunits);
7406
7407   /* Build back pointers if needed.  */
7408   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7409
7410   return NULL_TREE;
7411 }
7412
7413 /* Handle the "nonnull" attribute.  */
7414 static tree
7415 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7416                           tree args, int ARG_UNUSED (flags),
7417                           bool *no_add_attrs)
7418 {
7419   tree type = *node;
7420   unsigned HOST_WIDE_INT attr_arg_num;
7421
7422   /* If no arguments are specified, all pointer arguments should be
7423      non-null.  Verify a full prototype is given so that the arguments
7424      will have the correct types when we actually check them later.  */
7425   if (!args)
7426     {
7427       if (!TYPE_ARG_TYPES (type))
7428         {
7429           error ("nonnull attribute without arguments on a non-prototype");
7430           *no_add_attrs = true;
7431         }
7432       return NULL_TREE;
7433     }
7434
7435   /* Argument list specified.  Verify that each argument number references
7436      a pointer argument.  */
7437   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7438     {
7439       tree argument;
7440       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7441
7442       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7443         {
7444           error ("nonnull argument has invalid operand number (argument %lu)",
7445                  (unsigned long) attr_arg_num);
7446           *no_add_attrs = true;
7447           return NULL_TREE;
7448         }
7449
7450       argument = TYPE_ARG_TYPES (type);
7451       if (argument)
7452         {
7453           for (ck_num = 1; ; ck_num++)
7454             {
7455               if (!argument || ck_num == arg_num)
7456                 break;
7457               argument = TREE_CHAIN (argument);
7458             }
7459
7460           if (!argument
7461               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7462             {
7463               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7464                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
7465               *no_add_attrs = true;
7466               return NULL_TREE;
7467             }
7468
7469           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7470             {
7471               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7472                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
7473               *no_add_attrs = true;
7474               return NULL_TREE;
7475             }
7476         }
7477     }
7478
7479   return NULL_TREE;
7480 }
7481
7482 /* Check the argument list of a function call for null in argument slots
7483    that are marked as requiring a non-null pointer argument.  The NARGS
7484    arguments are passed in the array ARGARRAY.
7485 */
7486
7487 static void
7488 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7489 {
7490   tree a, args;
7491   int i;
7492
7493   for (a = attrs; a; a = TREE_CHAIN (a))
7494     {
7495       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7496         {
7497           args = TREE_VALUE (a);
7498
7499           /* Walk the argument list.  If we encounter an argument number we
7500              should check for non-null, do it.  If the attribute has no args,
7501              then every pointer argument is checked (in which case the check
7502              for pointer type is done in check_nonnull_arg).  */
7503           for (i = 0; i < nargs; i++)
7504             {
7505               if (!args || nonnull_check_p (args, i + 1))
7506                 check_function_arguments_recurse (check_nonnull_arg, NULL,
7507                                                   argarray[i],
7508                                                   i + 1);
7509             }
7510         }
7511     }
7512 }
7513
7514 /* Check that the Nth argument of a function call (counting backwards
7515    from the end) is a (pointer)0.  The NARGS arguments are passed in the
7516    array ARGARRAY.  */
7517
7518 static void
7519 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7520 {
7521   tree attr = lookup_attribute ("sentinel", attrs);
7522
7523   if (attr)
7524     {
7525       int len = 0;
7526       int pos = 0;
7527       tree sentinel;
7528
7529       /* Skip over the named arguments.  */
7530       while (typelist && len < nargs)
7531         {
7532           typelist = TREE_CHAIN (typelist);
7533           len++;
7534         }
7535
7536       if (TREE_VALUE (attr))
7537         {
7538           tree p = TREE_VALUE (TREE_VALUE (attr));
7539           pos = TREE_INT_CST_LOW (p);
7540         }
7541
7542       /* The sentinel must be one of the varargs, i.e.
7543          in position >= the number of fixed arguments.  */
7544       if ((nargs - 1 - pos) < len)
7545         {
7546           warning (OPT_Wformat,
7547                    "not enough variable arguments to fit a sentinel");
7548           return;
7549         }
7550
7551       /* Validate the sentinel.  */
7552       sentinel = argarray[nargs - 1 - pos];
7553       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7554            || !integer_zerop (sentinel))
7555           /* Although __null (in C++) is only an integer we allow it
7556              nevertheless, as we are guaranteed that it's exactly
7557              as wide as a pointer, and we don't want to force
7558              users to cast the NULL they have written there.
7559              We warn with -Wstrict-null-sentinel, though.  */
7560           && (warn_strict_null_sentinel || null_node != sentinel))
7561         warning (OPT_Wformat, "missing sentinel in function call");
7562     }
7563 }
7564
7565 /* Helper for check_function_nonnull; given a list of operands which
7566    must be non-null in ARGS, determine if operand PARAM_NUM should be
7567    checked.  */
7568
7569 static bool
7570 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7571 {
7572   unsigned HOST_WIDE_INT arg_num = 0;
7573
7574   for (; args; args = TREE_CHAIN (args))
7575     {
7576       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7577
7578       gcc_assert (found);
7579
7580       if (arg_num == param_num)
7581         return true;
7582     }
7583   return false;
7584 }
7585
7586 /* Check that the function argument PARAM (which is operand number
7587    PARAM_NUM) is non-null.  This is called by check_function_nonnull
7588    via check_function_arguments_recurse.  */
7589
7590 static void
7591 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7592                    unsigned HOST_WIDE_INT param_num)
7593 {
7594   /* Just skip checking the argument if it's not a pointer.  This can
7595      happen if the "nonnull" attribute was given without an operand
7596      list (which means to check every pointer argument).  */
7597
7598   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7599     return;
7600
7601   if (integer_zerop (param))
7602     warning (OPT_Wnonnull, "null argument where non-null required "
7603              "(argument %lu)", (unsigned long) param_num);
7604 }
7605
7606 /* Helper for nonnull attribute handling; fetch the operand number
7607    from the attribute argument list.  */
7608
7609 static bool
7610 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7611 {
7612   /* Verify the arg number is a constant.  */
7613   if (TREE_CODE (arg_num_expr) != INTEGER_CST
7614       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7615     return false;
7616
7617   *valp = TREE_INT_CST_LOW (arg_num_expr);
7618   return true;
7619 }
7620
7621 /* Handle a "nothrow" attribute; arguments as in
7622    struct attribute_spec.handler.  */
7623
7624 static tree
7625 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7626                           int ARG_UNUSED (flags), bool *no_add_attrs)
7627 {
7628   if (TREE_CODE (*node) == FUNCTION_DECL)
7629     TREE_NOTHROW (*node) = 1;
7630   /* ??? TODO: Support types.  */
7631   else
7632     {
7633       warning (OPT_Wattributes, "%qE attribute ignored", name);
7634       *no_add_attrs = true;
7635     }
7636
7637   return NULL_TREE;
7638 }
7639
7640 /* Handle a "cleanup" attribute; arguments as in
7641    struct attribute_spec.handler.  */
7642
7643 static tree
7644 handle_cleanup_attribute (tree *node, tree name, tree args,
7645                           int ARG_UNUSED (flags), bool *no_add_attrs)
7646 {
7647   tree decl = *node;
7648   tree cleanup_id, cleanup_decl;
7649
7650   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7651      for global destructors in C++.  This requires infrastructure that
7652      we don't have generically at the moment.  It's also not a feature
7653      we'd be missing too much, since we do have attribute constructor.  */
7654   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7655     {
7656       warning (OPT_Wattributes, "%qE attribute ignored", name);
7657       *no_add_attrs = true;
7658       return NULL_TREE;
7659     }
7660
7661   /* Verify that the argument is a function in scope.  */
7662   /* ??? We could support pointers to functions here as well, if
7663      that was considered desirable.  */
7664   cleanup_id = TREE_VALUE (args);
7665   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7666     {
7667       error ("cleanup argument not an identifier");
7668       *no_add_attrs = true;
7669       return NULL_TREE;
7670     }
7671   cleanup_decl = lookup_name (cleanup_id);
7672   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7673     {
7674       error ("cleanup argument not a function");
7675       *no_add_attrs = true;
7676       return NULL_TREE;
7677     }
7678
7679   /* That the function has proper type is checked with the
7680      eventual call to build_function_call.  */
7681
7682   return NULL_TREE;
7683 }
7684
7685 /* Handle a "warn_unused_result" attribute.  No special handling.  */
7686
7687 static tree
7688 handle_warn_unused_result_attribute (tree *node, tree name,
7689                                tree ARG_UNUSED (args),
7690                                int ARG_UNUSED (flags), bool *no_add_attrs)
7691 {
7692   /* Ignore the attribute for functions not returning any value.  */
7693   if (VOID_TYPE_P (TREE_TYPE (*node)))
7694     {
7695       warning (OPT_Wattributes, "%qE attribute ignored", name);
7696       *no_add_attrs = true;
7697     }
7698
7699   return NULL_TREE;
7700 }
7701
7702 /* Handle a "sentinel" attribute.  */
7703
7704 static tree
7705 handle_sentinel_attribute (tree *node, tree name, tree args,
7706                            int ARG_UNUSED (flags), bool *no_add_attrs)
7707 {
7708   tree params = TYPE_ARG_TYPES (*node);
7709
7710   if (!params)
7711     {
7712       warning (OPT_Wattributes,
7713                "%qE attribute requires prototypes with named arguments", name);
7714       *no_add_attrs = true;
7715     }
7716   else
7717     {
7718       while (TREE_CHAIN (params))
7719         params = TREE_CHAIN (params);
7720
7721       if (VOID_TYPE_P (TREE_VALUE (params)))
7722         {
7723           warning (OPT_Wattributes,
7724                    "%qE attribute only applies to variadic functions", name);
7725           *no_add_attrs = true;
7726         }
7727     }
7728
7729   if (args)
7730     {
7731       tree position = TREE_VALUE (args);
7732
7733       if (TREE_CODE (position) != INTEGER_CST)
7734         {
7735           warning (OPT_Wattributes,
7736                    "requested position is not an integer constant");
7737           *no_add_attrs = true;
7738         }
7739       else
7740         {
7741           if (tree_int_cst_lt (position, integer_zero_node))
7742             {
7743               warning (OPT_Wattributes,
7744                        "requested position is less than zero");
7745               *no_add_attrs = true;
7746             }
7747         }
7748     }
7749
7750   return NULL_TREE;
7751 }
7752
7753 /* Handle a "type_generic" attribute.  */
7754
7755 static tree
7756 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7757                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7758                                bool * ARG_UNUSED (no_add_attrs))
7759 {
7760   tree params;
7761
7762   /* Ensure we have a function type.  */
7763   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7764
7765   params = TYPE_ARG_TYPES (*node);
7766   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7767     params = TREE_CHAIN (params);
7768
7769   /* Ensure we have a variadic function.  */
7770   gcc_assert (!params);
7771
7772   return NULL_TREE;
7773 }
7774
7775 /* Handle a "target" attribute.  */
7776
7777 static tree
7778 handle_target_attribute (tree *node, tree name, tree args, int flags,
7779                          bool *no_add_attrs)
7780 {
7781   /* Ensure we have a function type.  */
7782   if (TREE_CODE (*node) != FUNCTION_DECL)
7783     {
7784       warning (OPT_Wattributes, "%qE attribute ignored", name);
7785       *no_add_attrs = true;
7786     }
7787   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7788                                                       flags))
7789     *no_add_attrs = true;
7790
7791   return NULL_TREE;
7792 }
7793
7794 /* Arguments being collected for optimization.  */
7795 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
7796 DEF_VEC_P(const_char_p);
7797 DEF_VEC_ALLOC_P(const_char_p, gc);
7798 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7799
7800
7801 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7802    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
7803    false for #pragma GCC optimize.  */
7804
7805 bool
7806 parse_optimize_options (tree args, bool attr_p)
7807 {
7808   bool ret = true;
7809   unsigned opt_argc;
7810   unsigned i;
7811   int saved_flag_strict_aliasing;
7812   const char **opt_argv;
7813   tree ap;
7814
7815   /* Build up argv vector.  Just in case the string is stored away, use garbage
7816      collected strings.  */
7817   VEC_truncate (const_char_p, optimize_args, 0);
7818   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7819
7820   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7821     {
7822       tree value = TREE_VALUE (ap);
7823
7824       if (TREE_CODE (value) == INTEGER_CST)
7825         {
7826           char buffer[20];
7827           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7828           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7829         }
7830
7831       else if (TREE_CODE (value) == STRING_CST)
7832         {
7833           /* Split string into multiple substrings.  */
7834           size_t len = TREE_STRING_LENGTH (value);
7835           char *p = ASTRDUP (TREE_STRING_POINTER (value));
7836           char *end = p + len;
7837           char *comma;
7838           char *next_p = p;
7839
7840           while (next_p != NULL)
7841             {
7842               size_t len2;
7843               char *q, *r;
7844
7845               p = next_p;
7846               comma = strchr (p, ',');
7847               if (comma)
7848                 {
7849                   len2 = comma - p;
7850                   *comma = '\0';
7851                   next_p = comma+1;
7852                 }
7853               else
7854                 {
7855                   len2 = end - p;
7856                   next_p = NULL;
7857                 }
7858
7859               r = q = (char *) ggc_alloc (len2 + 3);
7860
7861               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7862                  options.  */
7863               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7864                 {
7865                   ret = false;
7866                   if (attr_p)
7867                     warning (OPT_Wattributes,
7868                              "Bad option %s to optimize attribute.", p);
7869                   else
7870                     warning (OPT_Wpragmas,
7871                              "Bad option %s to pragma attribute", p);
7872                   continue;
7873                 }
7874
7875               if (*p != '-')
7876                 {
7877                   *r++ = '-';
7878
7879                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7880                      itself is -Os, and any other switch begins with a -f.  */
7881                   if ((*p >= '0' && *p <= '9')
7882                       || (p[0] == 's' && p[1] == '\0'))
7883                     *r++ = 'O';
7884                   else if (*p != 'O')
7885                     *r++ = 'f';
7886                 }
7887
7888               memcpy (r, p, len2);
7889               r[len2] = '\0';
7890               VEC_safe_push (const_char_p, gc, optimize_args, q);
7891             }
7892
7893         }
7894     }
7895
7896   opt_argc = VEC_length (const_char_p, optimize_args);
7897   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7898
7899   for (i = 1; i < opt_argc; i++)
7900     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7901
7902   saved_flag_strict_aliasing = flag_strict_aliasing;
7903
7904   /* Now parse the options.  */
7905   decode_options (opt_argc, opt_argv);
7906
7907   targetm.override_options_after_change();
7908
7909   /* Don't allow changing -fstrict-aliasing.  */
7910   flag_strict_aliasing = saved_flag_strict_aliasing;
7911
7912   VEC_truncate (const_char_p, optimize_args, 0);
7913   return ret;
7914 }
7915
7916 /* For handling "optimize" attribute. arguments as in
7917    struct attribute_spec.handler.  */
7918
7919 static tree
7920 handle_optimize_attribute (tree *node, tree name, tree args,
7921                            int ARG_UNUSED (flags), bool *no_add_attrs)
7922 {
7923   /* Ensure we have a function type.  */
7924   if (TREE_CODE (*node) != FUNCTION_DECL)
7925     {
7926       warning (OPT_Wattributes, "%qE attribute ignored", name);
7927       *no_add_attrs = true;
7928     }
7929   else
7930     {
7931       struct cl_optimization cur_opts;
7932       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7933
7934       /* Save current options.  */
7935       cl_optimization_save (&cur_opts);
7936
7937       /* If we previously had some optimization options, use them as the
7938          default.  */
7939       if (old_opts)
7940         cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7941
7942       /* Parse options, and update the vector.  */
7943       parse_optimize_options (args, true);
7944       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7945         = build_optimization_node ();
7946
7947       /* Restore current options.  */
7948       cl_optimization_restore (&cur_opts);
7949     }
7950
7951   return NULL_TREE;
7952 }
7953 \f
7954 /* Check for valid arguments being passed to a function.
7955    ATTRS is a list of attributes.  There are NARGS arguments in the array
7956    ARGARRAY.  TYPELIST is the list of argument types for the function.
7957  */
7958 void
7959 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7960 {
7961   /* Check for null being passed in a pointer argument that must be
7962      non-null.  We also need to do this if format checking is enabled.  */
7963
7964   if (warn_nonnull)
7965     check_function_nonnull (attrs, nargs, argarray);
7966
7967   /* Check for errors in format strings.  */
7968
7969   if (warn_format || warn_missing_format_attribute)
7970     check_function_format (attrs, nargs, argarray);
7971
7972   if (warn_format)
7973     check_function_sentinel (attrs, nargs, argarray, typelist);
7974 }
7975
7976 /* Generic argument checking recursion routine.  PARAM is the argument to
7977    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
7978    once the argument is resolved.  CTX is context for the callback.  */
7979 void
7980 check_function_arguments_recurse (void (*callback)
7981                                   (void *, tree, unsigned HOST_WIDE_INT),
7982                                   void *ctx, tree param,
7983                                   unsigned HOST_WIDE_INT param_num)
7984 {
7985   if (CONVERT_EXPR_P (param)
7986       && (TYPE_PRECISION (TREE_TYPE (param))
7987           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7988     {
7989       /* Strip coercion.  */
7990       check_function_arguments_recurse (callback, ctx,
7991                                         TREE_OPERAND (param, 0), param_num);
7992       return;
7993     }
7994
7995   if (TREE_CODE (param) == CALL_EXPR)
7996     {
7997       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7998       tree attrs;
7999       bool found_format_arg = false;
8000
8001       /* See if this is a call to a known internationalization function
8002          that modifies a format arg.  Such a function may have multiple
8003          format_arg attributes (for example, ngettext).  */
8004
8005       for (attrs = TYPE_ATTRIBUTES (type);
8006            attrs;
8007            attrs = TREE_CHAIN (attrs))
8008         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
8009           {
8010             tree inner_arg;
8011             tree format_num_expr;
8012             int format_num;
8013             int i;
8014             call_expr_arg_iterator iter;
8015
8016             /* Extract the argument number, which was previously checked
8017                to be valid.  */
8018             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
8019
8020             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
8021                         && !TREE_INT_CST_HIGH (format_num_expr));
8022
8023             format_num = TREE_INT_CST_LOW (format_num_expr);
8024
8025             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
8026                  inner_arg != 0;
8027                  inner_arg = next_call_expr_arg (&iter), i++)
8028               if (i == format_num)
8029                 {
8030                   check_function_arguments_recurse (callback, ctx,
8031                                                     inner_arg, param_num);
8032                   found_format_arg = true;
8033                   break;
8034                 }
8035           }
8036
8037       /* If we found a format_arg attribute and did a recursive check,
8038          we are done with checking this argument.  Otherwise, we continue
8039          and this will be considered a non-literal.  */
8040       if (found_format_arg)
8041         return;
8042     }
8043
8044   if (TREE_CODE (param) == COND_EXPR)
8045     {
8046       /* Check both halves of the conditional expression.  */
8047       check_function_arguments_recurse (callback, ctx,
8048                                         TREE_OPERAND (param, 1), param_num);
8049       check_function_arguments_recurse (callback, ctx,
8050                                         TREE_OPERAND (param, 2), param_num);
8051       return;
8052     }
8053
8054   (*callback) (ctx, param, param_num);
8055 }
8056
8057 /* Checks for a builtin function FNDECL that the number of arguments
8058    NARGS against the required number REQUIRED and issues an error if
8059    there is a mismatch.  Returns true if the number of arguments is
8060    correct, otherwise false.  */
8061
8062 static bool
8063 builtin_function_validate_nargs (tree fndecl, int nargs, int required)
8064 {
8065   if (nargs < required)
8066     {
8067       error_at (input_location,
8068                 "not enough arguments to function %qE", fndecl);
8069       return false;
8070     }
8071   else if (nargs > required)
8072     {
8073       error_at (input_location,
8074                 "too many arguments to function %qE", fndecl);
8075       return false;
8076     }
8077   return true;
8078 }
8079
8080 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8081    Returns false if there was an error, otherwise true.  */
8082
8083 bool
8084 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8085 {
8086   if (!DECL_BUILT_IN (fndecl)
8087       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8088     return true;
8089
8090   switch (DECL_FUNCTION_CODE (fndecl))
8091     {
8092     case BUILT_IN_CONSTANT_P:
8093       return builtin_function_validate_nargs (fndecl, nargs, 1);
8094
8095     case BUILT_IN_ISFINITE:
8096     case BUILT_IN_ISINF:
8097     case BUILT_IN_ISINF_SIGN:
8098     case BUILT_IN_ISNAN:
8099     case BUILT_IN_ISNORMAL:
8100       if (builtin_function_validate_nargs (fndecl, nargs, 1))
8101         {
8102           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8103             {
8104               error ("non-floating-point argument in call to "
8105                      "function %qE", fndecl);
8106               return false;
8107             }
8108           return true;
8109         }
8110       return false;
8111
8112     case BUILT_IN_ISGREATER:
8113     case BUILT_IN_ISGREATEREQUAL:
8114     case BUILT_IN_ISLESS:
8115     case BUILT_IN_ISLESSEQUAL:
8116     case BUILT_IN_ISLESSGREATER:
8117     case BUILT_IN_ISUNORDERED:
8118       if (builtin_function_validate_nargs (fndecl, nargs, 2))
8119         {
8120           enum tree_code code0, code1;
8121           code0 = TREE_CODE (TREE_TYPE (args[0]));
8122           code1 = TREE_CODE (TREE_TYPE (args[1]));
8123           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8124                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8125                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8126             {
8127               error ("non-floating-point arguments in call to "
8128                      "function %qE", fndecl);
8129               return false;
8130             }
8131           return true;
8132         }
8133       return false;
8134
8135     case BUILT_IN_FPCLASSIFY:
8136       if (builtin_function_validate_nargs (fndecl, nargs, 6))
8137         {
8138           unsigned i;
8139
8140           for (i=0; i<5; i++)
8141             if (TREE_CODE (args[i]) != INTEGER_CST)
8142               {
8143                 error ("non-const integer argument %u in call to function %qE",
8144                        i+1, fndecl);
8145                 return false;
8146               }
8147
8148           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8149             {
8150               error ("non-floating-point argument in call to function %qE",
8151                      fndecl);
8152               return false;
8153             }
8154           return true;
8155         }
8156       return false;
8157
8158     default:
8159       return true;
8160     }
8161 }
8162
8163 /* Function to help qsort sort FIELD_DECLs by name order.  */
8164
8165 int
8166 field_decl_cmp (const void *x_p, const void *y_p)
8167 {
8168   const tree *const x = (const tree *const) x_p;
8169   const tree *const y = (const tree *const) y_p;
8170
8171   if (DECL_NAME (*x) == DECL_NAME (*y))
8172     /* A nontype is "greater" than a type.  */
8173     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8174   if (DECL_NAME (*x) == NULL_TREE)
8175     return -1;
8176   if (DECL_NAME (*y) == NULL_TREE)
8177     return 1;
8178   if (DECL_NAME (*x) < DECL_NAME (*y))
8179     return -1;
8180   return 1;
8181 }
8182
8183 static struct {
8184   gt_pointer_operator new_value;
8185   void *cookie;
8186 } resort_data;
8187
8188 /* This routine compares two fields like field_decl_cmp but using the
8189 pointer operator in resort_data.  */
8190
8191 static int
8192 resort_field_decl_cmp (const void *x_p, const void *y_p)
8193 {
8194   const tree *const x = (const tree *const) x_p;
8195   const tree *const y = (const tree *const) y_p;
8196
8197   if (DECL_NAME (*x) == DECL_NAME (*y))
8198     /* A nontype is "greater" than a type.  */
8199     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8200   if (DECL_NAME (*x) == NULL_TREE)
8201     return -1;
8202   if (DECL_NAME (*y) == NULL_TREE)
8203     return 1;
8204   {
8205     tree d1 = DECL_NAME (*x);
8206     tree d2 = DECL_NAME (*y);
8207     resort_data.new_value (&d1, resort_data.cookie);
8208     resort_data.new_value (&d2, resort_data.cookie);
8209     if (d1 < d2)
8210       return -1;
8211   }
8212   return 1;
8213 }
8214
8215 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
8216
8217 void
8218 resort_sorted_fields (void *obj,
8219                       void * ARG_UNUSED (orig_obj),
8220                       gt_pointer_operator new_value,
8221                       void *cookie)
8222 {
8223   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8224   resort_data.new_value = new_value;
8225   resort_data.cookie = cookie;
8226   qsort (&sf->elts[0], sf->len, sizeof (tree),
8227          resort_field_decl_cmp);
8228 }
8229
8230 /* Subroutine of c_parse_error.
8231    Return the result of concatenating LHS and RHS. RHS is really
8232    a string literal, its first character is indicated by RHS_START and
8233    RHS_SIZE is its length (including the terminating NUL character).
8234
8235    The caller is responsible for deleting the returned pointer.  */
8236
8237 static char *
8238 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8239 {
8240   const int lhs_size = strlen (lhs);
8241   char *result = XNEWVEC (char, lhs_size + rhs_size);
8242   strncpy (result, lhs, lhs_size);
8243   strncpy (result + lhs_size, rhs_start, rhs_size);
8244   return result;
8245 }
8246
8247 /* Issue the error given by GMSGID, indicating that it occurred before
8248    TOKEN, which had the associated VALUE.  */
8249
8250 void
8251 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8252                tree value, unsigned char token_flags)
8253 {
8254 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8255
8256   char *message = NULL;
8257
8258   if (token_type == CPP_EOF)
8259     message = catenate_messages (gmsgid, " at end of input");
8260   else if (token_type == CPP_CHAR
8261            || token_type == CPP_WCHAR
8262            || token_type == CPP_CHAR16
8263            || token_type == CPP_CHAR32)
8264     {
8265       unsigned int val = TREE_INT_CST_LOW (value);
8266       const char *prefix;
8267
8268       switch (token_type)
8269         {
8270         default:
8271           prefix = "";
8272           break;
8273         case CPP_WCHAR:
8274           prefix = "L";
8275           break;
8276         case CPP_CHAR16:
8277           prefix = "u";
8278           break;
8279         case CPP_CHAR32:
8280           prefix = "U";
8281           break;
8282         }
8283
8284       if (val <= UCHAR_MAX && ISGRAPH (val))
8285         message = catenate_messages (gmsgid, " before %s'%c'");
8286       else
8287         message = catenate_messages (gmsgid, " before %s'\\x%x'");
8288
8289       error (message, prefix, val);
8290       free (message);
8291       message = NULL;
8292     }
8293   else if (token_type == CPP_STRING
8294            || token_type == CPP_WSTRING
8295            || token_type == CPP_STRING16
8296            || token_type == CPP_STRING32
8297            || token_type == CPP_UTF8STRING)
8298     message = catenate_messages (gmsgid, " before string constant");
8299   else if (token_type == CPP_NUMBER)
8300     message = catenate_messages (gmsgid, " before numeric constant");
8301   else if (token_type == CPP_NAME)
8302     {
8303       message = catenate_messages (gmsgid, " before %qE");
8304       error (message, value);
8305       free (message);
8306       message = NULL;
8307     }
8308   else if (token_type == CPP_PRAGMA)
8309     message = catenate_messages (gmsgid, " before %<#pragma%>");
8310   else if (token_type == CPP_PRAGMA_EOL)
8311     message = catenate_messages (gmsgid, " before end of line");
8312   else if (token_type < N_TTYPES)
8313     {
8314       message = catenate_messages (gmsgid, " before %qs token");
8315       error (message, cpp_type2name (token_type, token_flags));
8316       free (message);
8317       message = NULL;
8318     }
8319   else
8320     error (gmsgid);
8321
8322   if (message)
8323     {
8324       error (message);
8325       free (message);
8326     }
8327 #undef catenate_messages
8328 }
8329
8330 /* Mapping for cpp message reasons to the options that enable them.  */
8331
8332 struct reason_option_codes_t
8333 {
8334   const int reason;             /* cpplib message reason.  */
8335   const int option_code;        /* gcc option that controls this message.  */
8336 };
8337
8338 static const struct reason_option_codes_t option_codes[] = {
8339   {CPP_W_DEPRECATED,                    OPT_Wdeprecated},
8340   {CPP_W_COMMENTS,                      OPT_Wcomments},
8341   {CPP_W_TRIGRAPHS,                     OPT_Wtrigraphs},
8342   {CPP_W_MULTICHAR,                     OPT_Wmultichar},
8343   {CPP_W_TRADITIONAL,                   OPT_Wtraditional},
8344   {CPP_W_LONG_LONG,                     OPT_Wlong_long},
8345   {CPP_W_ENDIF_LABELS,                  OPT_Wendif_labels},
8346   {CPP_W_VARIADIC_MACROS,               OPT_Wvariadic_macros},
8347   {CPP_W_BUILTIN_MACRO_REDEFINED,       OPT_Wbuiltin_macro_redefined},
8348   {CPP_W_UNDEF,                         OPT_Wundef},
8349   {CPP_W_UNUSED_MACROS,                 OPT_Wunused_macros},
8350   {CPP_W_CXX_OPERATOR_NAMES,            OPT_Wc___compat},
8351   {CPP_W_NORMALIZE,                     OPT_Wnormalized_},
8352   {CPP_W_INVALID_PCH,                   OPT_Winvalid_pch},
8353   {CPP_W_WARNING_DIRECTIVE,             OPT_Wcpp},
8354   {CPP_W_NONE,                          0}
8355 };
8356
8357 /* Return the gcc option code associated with the reason for a cpp
8358    message, or 0 if none.  */
8359
8360 static int
8361 c_option_controlling_cpp_error (int reason)
8362 {
8363   const struct reason_option_codes_t *entry;
8364
8365   for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8366     {
8367       if (entry->reason == reason)
8368         return entry->option_code;
8369     }
8370   return 0;
8371 }
8372
8373 /* Callback from cpp_error for PFILE to print diagnostics from the
8374    preprocessor.  The diagnostic is of type LEVEL, with REASON set
8375    to the reason code if LEVEL is represents a warning, at location
8376    LOCATION unless this is after lexing and the compiler's location
8377    should be used instead, with column number possibly overridden by
8378    COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8379    the arguments.  Returns true if a diagnostic was emitted, false
8380    otherwise.  */
8381
8382 bool
8383 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
8384              location_t location, unsigned int column_override,
8385              const char *msg, va_list *ap)
8386 {
8387   diagnostic_info diagnostic;
8388   diagnostic_t dlevel;
8389   bool save_warn_system_headers = global_dc->warn_system_headers;
8390   bool ret;
8391
8392   switch (level)
8393     {
8394     case CPP_DL_WARNING_SYSHDR:
8395       if (flag_no_output)
8396         return false;
8397       global_dc->warn_system_headers = 1;
8398       /* Fall through.  */
8399     case CPP_DL_WARNING:
8400       if (flag_no_output)
8401         return false;
8402       dlevel = DK_WARNING;
8403       break;
8404     case CPP_DL_PEDWARN:
8405       if (flag_no_output && !flag_pedantic_errors)
8406         return false;
8407       dlevel = DK_PEDWARN;
8408       break;
8409     case CPP_DL_ERROR:
8410       dlevel = DK_ERROR;
8411       break;
8412     case CPP_DL_ICE:
8413       dlevel = DK_ICE;
8414       break;
8415     case CPP_DL_NOTE:
8416       dlevel = DK_NOTE;
8417       break;
8418     case CPP_DL_FATAL:
8419       dlevel = DK_FATAL;
8420       break;
8421     default:
8422       gcc_unreachable ();
8423     }
8424   if (done_lexing)
8425     location = input_location;
8426   diagnostic_set_info_translated (&diagnostic, msg, ap,
8427                                   location, dlevel);
8428   if (column_override)
8429     diagnostic_override_column (&diagnostic, column_override);
8430   diagnostic_override_option_index (&diagnostic,
8431                                     c_option_controlling_cpp_error (reason));
8432   ret = report_diagnostic (&diagnostic);
8433   if (level == CPP_DL_WARNING_SYSHDR)
8434     global_dc->warn_system_headers = save_warn_system_headers;
8435   return ret;
8436 }
8437
8438 /* Convert a character from the host to the target execution character
8439    set.  cpplib handles this, mostly.  */
8440
8441 HOST_WIDE_INT
8442 c_common_to_target_charset (HOST_WIDE_INT c)
8443 {
8444   /* Character constants in GCC proper are sign-extended under -fsigned-char,
8445      zero-extended under -fno-signed-char.  cpplib insists that characters
8446      and character constants are always unsigned.  Hence we must convert
8447      back and forth.  */
8448   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8449
8450   uc = cpp_host_to_exec_charset (parse_in, uc);
8451
8452   if (flag_signed_char)
8453     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8454                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8455   else
8456     return uc;
8457 }
8458
8459 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
8460    component references, with STOP_REF, or alternatively an INDIRECT_REF of
8461    NULL, at the bottom; much like the traditional rendering of offsetof as a
8462    macro.  Returns the folded and properly cast result.  */
8463
8464 static tree
8465 fold_offsetof_1 (tree expr, tree stop_ref)
8466 {
8467   enum tree_code code = PLUS_EXPR;
8468   tree base, off, t;
8469
8470   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8471     return size_zero_node;
8472
8473   switch (TREE_CODE (expr))
8474     {
8475     case ERROR_MARK:
8476       return expr;
8477
8478     case VAR_DECL:
8479       error ("cannot apply %<offsetof%> to static data member %qD", expr);
8480       return error_mark_node;
8481
8482     case CALL_EXPR:
8483     case TARGET_EXPR:
8484       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8485       return error_mark_node;
8486
8487     case NOP_EXPR:
8488     case INDIRECT_REF:
8489       if (!integer_zerop (TREE_OPERAND (expr, 0)))
8490         {
8491           error ("cannot apply %<offsetof%> to a non constant address");
8492           return error_mark_node;
8493         }
8494       return size_zero_node;
8495
8496     case COMPONENT_REF:
8497       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8498       if (base == error_mark_node)
8499         return base;
8500
8501       t = TREE_OPERAND (expr, 1);
8502       if (DECL_C_BIT_FIELD (t))
8503         {
8504           error ("attempt to take address of bit-field structure "
8505                  "member %qD", t);
8506           return error_mark_node;
8507         }
8508       off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8509                             size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8510                                                     1)
8511                                       / BITS_PER_UNIT));
8512       break;
8513
8514     case ARRAY_REF:
8515       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8516       if (base == error_mark_node)
8517         return base;
8518
8519       t = TREE_OPERAND (expr, 1);
8520       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8521         {
8522           code = MINUS_EXPR;
8523           t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
8524         }
8525       t = convert (sizetype, t);
8526       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8527
8528       /* Check if the offset goes beyond the upper bound of the array.  */
8529       if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8530         {
8531           tree upbound = array_ref_up_bound (expr);
8532           if (upbound != NULL_TREE
8533               && TREE_CODE (upbound) == INTEGER_CST
8534               && !tree_int_cst_equal (upbound,
8535                                       TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8536             {
8537               upbound = size_binop (PLUS_EXPR, upbound,
8538                                     build_int_cst (TREE_TYPE (upbound), 1));
8539               if (tree_int_cst_lt (upbound, t))
8540                 {
8541                   tree v;
8542
8543                   for (v = TREE_OPERAND (expr, 0);
8544                        TREE_CODE (v) == COMPONENT_REF;
8545                        v = TREE_OPERAND (v, 0))
8546                     if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8547                         == RECORD_TYPE)
8548                       {
8549                         tree fld_chain = TREE_CHAIN (TREE_OPERAND (v, 1));
8550                         for (; fld_chain; fld_chain = TREE_CHAIN (fld_chain))
8551                           if (TREE_CODE (fld_chain) == FIELD_DECL)
8552                             break;
8553
8554                         if (fld_chain)
8555                           break;
8556                       }
8557                   /* Don't warn if the array might be considered a poor
8558                      man's flexible array member with a very permissive
8559                      definition thereof.  */
8560                   if (TREE_CODE (v) == ARRAY_REF
8561                       || TREE_CODE (v) == COMPONENT_REF)
8562                     warning (OPT_Warray_bounds,
8563                              "index %E denotes an offset "
8564                              "greater than size of %qT",
8565                              t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8566                 }
8567             }
8568         }
8569       break;
8570
8571     case COMPOUND_EXPR:
8572       /* Handle static members of volatile structs.  */
8573       t = TREE_OPERAND (expr, 1);
8574       gcc_assert (TREE_CODE (t) == VAR_DECL);
8575       return fold_offsetof_1 (t, stop_ref);
8576
8577     default:
8578       gcc_unreachable ();
8579     }
8580
8581   return size_binop (code, base, off);
8582 }
8583
8584 tree
8585 fold_offsetof (tree expr, tree stop_ref)
8586 {
8587   /* Convert back from the internal sizetype to size_t.  */
8588   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8589 }
8590
8591 /* Print an error message for an invalid lvalue.  USE says
8592    how the lvalue is being used and so selects the error message.  */
8593
8594 void
8595 lvalue_error (enum lvalue_use use)
8596 {
8597   switch (use)
8598     {
8599     case lv_assign:
8600       error ("lvalue required as left operand of assignment");
8601       break;
8602     case lv_increment:
8603       error ("lvalue required as increment operand");
8604       break;
8605     case lv_decrement:
8606       error ("lvalue required as decrement operand");
8607       break;
8608     case lv_addressof:
8609       error ("lvalue required as unary %<&%> operand");
8610       break;
8611     case lv_asm:
8612       error ("lvalue required in asm statement");
8613       break;
8614     default:
8615       gcc_unreachable ();
8616     }
8617 }
8618 \f
8619 /* *PTYPE is an incomplete array.  Complete it with a domain based on
8620    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8621    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8622    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
8623
8624 int
8625 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8626 {
8627   tree maxindex, type, main_type, elt, unqual_elt;
8628   int failure = 0, quals;
8629   hashval_t hashcode = 0;
8630
8631   maxindex = size_zero_node;
8632   if (initial_value)
8633     {
8634       if (TREE_CODE (initial_value) == STRING_CST)
8635         {
8636           int eltsize
8637             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8638           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8639         }
8640       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8641         {
8642           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8643
8644           if (VEC_empty (constructor_elt, v))
8645             {
8646               if (pedantic)
8647                 failure = 3;
8648               maxindex = integer_minus_one_node;
8649             }
8650           else
8651             {
8652               tree curindex;
8653               unsigned HOST_WIDE_INT cnt;
8654               constructor_elt *ce;
8655               bool fold_p = false;
8656
8657               if (VEC_index (constructor_elt, v, 0)->index)
8658                 maxindex = fold_convert_loc (input_location, sizetype,
8659                                              VEC_index (constructor_elt,
8660                                                         v, 0)->index);
8661               curindex = maxindex;
8662
8663               for (cnt = 1;
8664                    VEC_iterate (constructor_elt, v, cnt, ce);
8665                    cnt++)
8666                 {
8667                   bool curfold_p = false;
8668                   if (ce->index)
8669                     curindex = ce->index, curfold_p = true;
8670                   else
8671                     {
8672                       if (fold_p)
8673                         curindex = fold_convert (sizetype, curindex);
8674                       curindex = size_binop (PLUS_EXPR, curindex,
8675                                              size_one_node);
8676                     }
8677                   if (tree_int_cst_lt (maxindex, curindex))
8678                     maxindex = curindex, fold_p = curfold_p;
8679                 }
8680                if (fold_p)
8681                  maxindex = fold_convert (sizetype, maxindex);
8682             }
8683         }
8684       else
8685         {
8686           /* Make an error message unless that happened already.  */
8687           if (initial_value != error_mark_node)
8688             failure = 1;
8689         }
8690     }
8691   else
8692     {
8693       failure = 2;
8694       if (!do_default)
8695         return failure;
8696     }
8697
8698   type = *ptype;
8699   elt = TREE_TYPE (type);
8700   quals = TYPE_QUALS (strip_array_types (elt));
8701   if (quals == 0)
8702     unqual_elt = elt;
8703   else
8704     unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
8705
8706   /* Using build_distinct_type_copy and modifying things afterward instead
8707      of using build_array_type to create a new type preserves all of the
8708      TYPE_LANG_FLAG_? bits that the front end may have set.  */
8709   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8710   TREE_TYPE (main_type) = unqual_elt;
8711   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8712   layout_type (main_type);
8713
8714   /* Make sure we have the canonical MAIN_TYPE. */
8715   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8716   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8717                                     hashcode);
8718   main_type = type_hash_canon (hashcode, main_type);
8719
8720   /* Fix the canonical type.  */
8721   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8722       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8723     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8724   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8725            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8726                != TYPE_DOMAIN (main_type)))
8727     TYPE_CANONICAL (main_type)
8728       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8729                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8730   else
8731     TYPE_CANONICAL (main_type) = main_type;
8732
8733   if (quals == 0)
8734     type = main_type;
8735   else
8736     type = c_build_qualified_type (main_type, quals);
8737
8738   if (COMPLETE_TYPE_P (type)
8739       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8740       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8741     {
8742       error ("size of array is too large");
8743       /* If we proceed with the array type as it is, we'll eventually
8744          crash in tree_low_cst().  */
8745       type = error_mark_node;
8746     }
8747
8748   *ptype = type;
8749   return failure;
8750 }
8751
8752 \f
8753 /* Used to help initialize the builtin-types.def table.  When a type of
8754    the correct size doesn't exist, use error_mark_node instead of NULL.
8755    The later results in segfaults even when a decl using the type doesn't
8756    get invoked.  */
8757
8758 tree
8759 builtin_type_for_size (int size, bool unsignedp)
8760 {
8761   tree type = lang_hooks.types.type_for_size (size, unsignedp);
8762   return type ? type : error_mark_node;
8763 }
8764
8765 /* A helper function for resolve_overloaded_builtin in resolving the
8766    overloaded __sync_ builtins.  Returns a positive power of 2 if the
8767    first operand of PARAMS is a pointer to a supported data type.
8768    Returns 0 if an error is encountered.  */
8769
8770 static int
8771 sync_resolve_size (tree function, VEC(tree,gc) *params)
8772 {
8773   tree type;
8774   int size;
8775
8776   if (VEC_empty (tree, params))
8777     {
8778       error ("too few arguments to function %qE", function);
8779       return 0;
8780     }
8781
8782   type = TREE_TYPE (VEC_index (tree, params, 0));
8783   if (TREE_CODE (type) != POINTER_TYPE)
8784     goto incompatible;
8785
8786   type = TREE_TYPE (type);
8787   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8788     goto incompatible;
8789
8790   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8791   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8792     return size;
8793
8794  incompatible:
8795   error ("incompatible type for argument %d of %qE", 1, function);
8796   return 0;
8797 }
8798
8799 /* A helper function for resolve_overloaded_builtin.  Adds casts to
8800    PARAMS to make arguments match up with those of FUNCTION.  Drops
8801    the variadic arguments at the end.  Returns false if some error
8802    was encountered; true on success.  */
8803
8804 static bool
8805 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8806 {
8807   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8808   tree ptype;
8809   unsigned int parmnum;
8810
8811   /* We've declared the implementation functions to use "volatile void *"
8812      as the pointer parameter, so we shouldn't get any complaints from the
8813      call to check_function_arguments what ever type the user used.  */
8814   arg_types = TREE_CHAIN (arg_types);
8815   ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8816
8817   /* For the rest of the values, we need to cast these to FTYPE, so that we
8818      don't get warnings for passing pointer types, etc.  */
8819   parmnum = 0;
8820   while (arg_types != void_list_node)
8821     {
8822       tree val;
8823
8824       ++parmnum;
8825       if (VEC_length (tree, params) <= parmnum)
8826         {
8827           error ("too few arguments to function %qE", orig_function);
8828           return false;
8829         }
8830
8831       /* ??? Ideally for the first conversion we'd use convert_for_assignment
8832          so that we get warnings for anything that doesn't match the pointer
8833          type.  This isn't portable across the C and C++ front ends atm.  */
8834       val = VEC_index (tree, params, parmnum);
8835       val = convert (ptype, val);
8836       val = convert (TREE_VALUE (arg_types), val);
8837       VEC_replace (tree, params, parmnum, val);
8838
8839       arg_types = TREE_CHAIN (arg_types);
8840     }
8841
8842   /* The definition of these primitives is variadic, with the remaining
8843      being "an optional list of variables protected by the memory barrier".
8844      No clue what that's supposed to mean, precisely, but we consider all
8845      call-clobbered variables to be protected so we're safe.  */
8846   VEC_truncate (tree, params, parmnum + 1);
8847
8848   return true;
8849 }
8850
8851 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
8852    RESULT to make it match the type of the first pointer argument in
8853    PARAMS.  */
8854
8855 static tree
8856 sync_resolve_return (tree first_param, tree result)
8857 {
8858   tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8859   ptype = TYPE_MAIN_VARIANT (ptype);
8860   return convert (ptype, result);
8861 }
8862
8863 /* Some builtin functions are placeholders for other expressions.  This
8864    function should be called immediately after parsing the call expression
8865    before surrounding code has committed to the type of the expression.
8866
8867    LOC is the location of the builtin call.
8868
8869    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8870    PARAMS is the argument list for the call.  The return value is non-null
8871    when expansion is complete, and null if normal processing should
8872    continue.  */
8873
8874 tree
8875 resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
8876 {
8877   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8878   switch (DECL_BUILT_IN_CLASS (function))
8879     {
8880     case BUILT_IN_NORMAL:
8881       break;
8882     case BUILT_IN_MD:
8883       if (targetm.resolve_overloaded_builtin)
8884         return targetm.resolve_overloaded_builtin (loc, function, params);
8885       else
8886         return NULL_TREE;
8887     default:
8888       return NULL_TREE;
8889     }
8890
8891   /* Handle BUILT_IN_NORMAL here.  */
8892   switch (orig_code)
8893     {
8894     case BUILT_IN_FETCH_AND_ADD_N:
8895     case BUILT_IN_FETCH_AND_SUB_N:
8896     case BUILT_IN_FETCH_AND_OR_N:
8897     case BUILT_IN_FETCH_AND_AND_N:
8898     case BUILT_IN_FETCH_AND_XOR_N:
8899     case BUILT_IN_FETCH_AND_NAND_N:
8900     case BUILT_IN_ADD_AND_FETCH_N:
8901     case BUILT_IN_SUB_AND_FETCH_N:
8902     case BUILT_IN_OR_AND_FETCH_N:
8903     case BUILT_IN_AND_AND_FETCH_N:
8904     case BUILT_IN_XOR_AND_FETCH_N:
8905     case BUILT_IN_NAND_AND_FETCH_N:
8906     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8907     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8908     case BUILT_IN_LOCK_TEST_AND_SET_N:
8909     case BUILT_IN_LOCK_RELEASE_N:
8910       {
8911         int n = sync_resolve_size (function, params);
8912         tree new_function, first_param, result;
8913
8914         if (n == 0)
8915           return error_mark_node;
8916
8917         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8918         if (!sync_resolve_params (function, new_function, params))
8919           return error_mark_node;
8920
8921         first_param = VEC_index (tree, params, 0);
8922         result = build_function_call_vec (loc, new_function, params, NULL);
8923         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8924             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8925           result = sync_resolve_return (first_param, result);
8926
8927         return result;
8928       }
8929
8930     default:
8931       return NULL_TREE;
8932     }
8933 }
8934
8935 /* Ignoring their sign, return true if two scalar types are the same.  */
8936 bool
8937 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8938 {
8939   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8940
8941   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8942               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8943                   || c2 == FIXED_POINT_TYPE));
8944
8945   /* Equality works here because c_common_signed_type uses
8946      TYPE_MAIN_VARIANT.  */
8947   return c_common_signed_type (t1)
8948     == c_common_signed_type (t2);
8949 }
8950
8951 /* Check for missing format attributes on function pointers.  LTYPE is
8952    the new type or left-hand side type.  RTYPE is the old type or
8953    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8954    attribute.  */
8955
8956 bool
8957 check_missing_format_attribute (tree ltype, tree rtype)
8958 {
8959   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8960   tree ra;
8961
8962   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8963     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8964       break;
8965   if (ra)
8966     {
8967       tree la;
8968       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8969         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8970           break;
8971       return !la;
8972     }
8973   else
8974     return false;
8975 }
8976
8977 /* Subscripting with type char is likely to lose on a machine where
8978    chars are signed.  So warn on any machine, but optionally.  Don't
8979    warn for unsigned char since that type is safe.  Don't warn for
8980    signed char because anyone who uses that must have done so
8981    deliberately. Furthermore, we reduce the false positive load by
8982    warning only for non-constant value of type char.  */
8983
8984 void
8985 warn_array_subscript_with_type_char (tree index)
8986 {
8987   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8988       && TREE_CODE (index) != INTEGER_CST)
8989     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8990 }
8991
8992 /* Implement -Wparentheses for the unexpected C precedence rules, to
8993    cover cases like x + y << z which readers are likely to
8994    misinterpret.  We have seen an expression in which CODE is a binary
8995    operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8996    before folding had CODE_LEFT and CODE_RIGHT.  CODE_LEFT and
8997    CODE_RIGHT may be ERROR_MARK, which means that that side of the
8998    expression was not formed using a binary or unary operator, or it
8999    was enclosed in parentheses.  */
9000
9001 void
9002 warn_about_parentheses (enum tree_code code,
9003                         enum tree_code code_left, tree arg_left,
9004                         enum tree_code code_right, tree arg_right)
9005 {
9006   if (!warn_parentheses)
9007     return;
9008
9009   /* This macro tests that the expression ARG with original tree code
9010      CODE appears to be a boolean expression. or the result of folding a
9011      boolean expression.  */
9012 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG)                             \
9013         (truth_value_p (TREE_CODE (ARG))                                    \
9014          || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE                     \
9015          /* Folding may create 0 or 1 integers from other expressions.  */  \
9016          || ((CODE) != INTEGER_CST                                          \
9017              && (integer_onep (ARG) || integer_zerop (ARG))))
9018
9019   switch (code)
9020     {
9021     case LSHIFT_EXPR:
9022       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9023         warning (OPT_Wparentheses,
9024                  "suggest parentheses around %<+%> inside %<<<%>");
9025       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9026         warning (OPT_Wparentheses,
9027                  "suggest parentheses around %<-%> inside %<<<%>");
9028       return;
9029
9030     case RSHIFT_EXPR:
9031       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9032         warning (OPT_Wparentheses,
9033                  "suggest parentheses around %<+%> inside %<>>%>");
9034       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9035         warning (OPT_Wparentheses,
9036                  "suggest parentheses around %<-%> inside %<>>%>");
9037       return;
9038
9039     case TRUTH_ORIF_EXPR:
9040       if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9041         warning (OPT_Wparentheses,
9042                  "suggest parentheses around %<&&%> within %<||%>");
9043       return;
9044
9045     case BIT_IOR_EXPR:
9046       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9047           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9048           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9049           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9050         warning (OPT_Wparentheses,
9051                  "suggest parentheses around arithmetic in operand of %<|%>");
9052       /* Check cases like x|y==z */
9053       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9054                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9055         warning (OPT_Wparentheses,
9056                  "suggest parentheses around comparison in operand of %<|%>");
9057       /* Check cases like !x | y */
9058       else if (code_left == TRUTH_NOT_EXPR
9059                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9060         warning (OPT_Wparentheses, "suggest parentheses around operand of "
9061                  "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9062       return;
9063
9064     case BIT_XOR_EXPR:
9065       if (code_left == BIT_AND_EXPR
9066           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9067           || code_right == BIT_AND_EXPR
9068           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9069         warning (OPT_Wparentheses,
9070                  "suggest parentheses around arithmetic in operand of %<^%>");
9071       /* Check cases like x^y==z */
9072       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9073                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9074         warning (OPT_Wparentheses,
9075                  "suggest parentheses around comparison in operand of %<^%>");
9076       return;
9077
9078     case BIT_AND_EXPR:
9079       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9080         warning (OPT_Wparentheses,
9081                  "suggest parentheses around %<+%> in operand of %<&%>");
9082       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9083         warning (OPT_Wparentheses,
9084                  "suggest parentheses around %<-%> in operand of %<&%>");
9085       /* Check cases like x&y==z */
9086       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9087                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9088         warning (OPT_Wparentheses,
9089                  "suggest parentheses around comparison in operand of %<&%>");
9090       /* Check cases like !x & y */
9091       else if (code_left == TRUTH_NOT_EXPR
9092                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9093         warning (OPT_Wparentheses, "suggest parentheses around operand of "
9094                  "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9095       return;
9096
9097     case EQ_EXPR:
9098       if (TREE_CODE_CLASS (code_left) == tcc_comparison
9099           || TREE_CODE_CLASS (code_right) == tcc_comparison)
9100         warning (OPT_Wparentheses,
9101                  "suggest parentheses around comparison in operand of %<==%>");
9102       return;
9103     case NE_EXPR:
9104       if (TREE_CODE_CLASS (code_left) == tcc_comparison
9105           || TREE_CODE_CLASS (code_right) == tcc_comparison)
9106         warning (OPT_Wparentheses,
9107                  "suggest parentheses around comparison in operand of %<!=%>");
9108       return;
9109
9110     default:
9111       if (TREE_CODE_CLASS (code) == tcc_comparison
9112            && ((TREE_CODE_CLASS (code_left) == tcc_comparison
9113                 && code_left != NE_EXPR && code_left != EQ_EXPR
9114                 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
9115                || (TREE_CODE_CLASS (code_right) == tcc_comparison
9116                    && code_right != NE_EXPR && code_right != EQ_EXPR
9117                    && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9118         warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9119                  "have their mathematical meaning");
9120       return;
9121     }
9122 #undef NOT_A_BOOLEAN_EXPR_P
9123 }
9124
9125 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
9126
9127 void
9128 warn_for_unused_label (tree label)
9129 {
9130   if (!TREE_USED (label))
9131     {
9132       if (DECL_INITIAL (label))
9133         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9134       else
9135         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9136     }
9137 }
9138
9139 #ifndef TARGET_HAS_TARGETCM
9140 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9141 #endif
9142
9143 /* Warn for division by zero according to the value of DIVISOR.  LOC
9144    is the location of the division operator.  */
9145
9146 void
9147 warn_for_div_by_zero (location_t loc, tree divisor)
9148 {
9149   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9150      about division by zero.  Do not issue a warning if DIVISOR has a
9151      floating-point type, since we consider 0.0/0.0 a valid way of
9152      generating a NaN.  */
9153   if (c_inhibit_evaluation_warnings == 0
9154       && (integer_zerop (divisor) || fixed_zerop (divisor)))
9155     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9156 }
9157
9158 /* Subroutine of build_binary_op. Give warnings for comparisons
9159    between signed and unsigned quantities that may fail. Do the
9160    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9161    so that casts will be considered, but default promotions won't
9162    be.
9163
9164    LOCATION is the location of the comparison operator.
9165
9166    The arguments of this function map directly to local variables
9167    of build_binary_op.  */
9168
9169 void
9170 warn_for_sign_compare (location_t location,
9171                        tree orig_op0, tree orig_op1,
9172                        tree op0, tree op1,
9173                        tree result_type, enum tree_code resultcode)
9174 {
9175   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9176   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9177   int unsignedp0, unsignedp1;
9178
9179   /* In C++, check for comparison of different enum types.  */
9180   if (c_dialect_cxx()
9181       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9182       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9183       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9184          != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9185     {
9186       warning_at (location,
9187                   OPT_Wsign_compare, "comparison between types %qT and %qT",
9188                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9189     }
9190
9191   /* Do not warn if the comparison is being done in a signed type,
9192      since the signed type will only be chosen if it can represent
9193      all the values of the unsigned type.  */
9194   if (!TYPE_UNSIGNED (result_type))
9195     /* OK */;
9196   /* Do not warn if both operands are unsigned.  */
9197   else if (op0_signed == op1_signed)
9198     /* OK */;
9199   else
9200     {
9201       tree sop, uop, base_type;
9202       bool ovf;
9203
9204       if (op0_signed)
9205         sop = orig_op0, uop = orig_op1;
9206       else
9207         sop = orig_op1, uop = orig_op0;
9208
9209       STRIP_TYPE_NOPS (sop);
9210       STRIP_TYPE_NOPS (uop);
9211       base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9212                    ? TREE_TYPE (result_type) : result_type);
9213
9214       /* Do not warn if the signed quantity is an unsuffixed integer
9215          literal (or some static constant expression involving such
9216          literals or a conditional expression involving such literals)
9217          and it is non-negative.  */
9218       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9219         /* OK */;
9220       /* Do not warn if the comparison is an equality operation, the
9221          unsigned quantity is an integral constant, and it would fit
9222          in the result if the result were signed.  */
9223       else if (TREE_CODE (uop) == INTEGER_CST
9224                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9225                && int_fits_type_p (uop, c_common_signed_type (base_type)))
9226         /* OK */;
9227       /* In C, do not warn if the unsigned quantity is an enumeration
9228          constant and its maximum value would fit in the result if the
9229          result were signed.  */
9230       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9231                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9232                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9233                                    c_common_signed_type (base_type)))
9234         /* OK */;
9235       else
9236         warning_at (location,
9237                     OPT_Wsign_compare,
9238                     "comparison between signed and unsigned integer expressions");
9239     }
9240
9241   /* Warn if two unsigned values are being compared in a size larger
9242      than their original size, and one (and only one) is the result of
9243      a `~' operator.  This comparison will always fail.
9244
9245      Also warn if one operand is a constant, and the constant does not
9246      have all bits set that are set in the ~ operand when it is
9247      extended.  */
9248
9249   op0 = get_narrower (op0, &unsignedp0);
9250   op1 = get_narrower (op1, &unsignedp1);
9251
9252   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9253       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9254     {
9255       if (TREE_CODE (op0) == BIT_NOT_EXPR)
9256         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9257       if (TREE_CODE (op1) == BIT_NOT_EXPR)
9258         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9259
9260       if (host_integerp (op0, 0) || host_integerp (op1, 0))
9261         {
9262           tree primop;
9263           HOST_WIDE_INT constant, mask;
9264           int unsignedp;
9265           unsigned int bits;
9266
9267           if (host_integerp (op0, 0))
9268             {
9269               primop = op1;
9270               unsignedp = unsignedp1;
9271               constant = tree_low_cst (op0, 0);
9272             }
9273           else
9274             {
9275               primop = op0;
9276               unsignedp = unsignedp0;
9277               constant = tree_low_cst (op1, 0);
9278             }
9279
9280           bits = TYPE_PRECISION (TREE_TYPE (primop));
9281           if (bits < TYPE_PRECISION (result_type)
9282               && bits < HOST_BITS_PER_LONG && unsignedp)
9283             {
9284               mask = (~ (HOST_WIDE_INT) 0) << bits;
9285               if ((mask & constant) != mask)
9286                 {
9287                   if (constant == 0)
9288                     warning (OPT_Wsign_compare,
9289                              "promoted ~unsigned is always non-zero");
9290                   else
9291                     warning_at (location, OPT_Wsign_compare,
9292                                 "comparison of promoted ~unsigned with constant");
9293                 }
9294             }
9295         }
9296       else if (unsignedp0 && unsignedp1
9297                && (TYPE_PRECISION (TREE_TYPE (op0))
9298                    < TYPE_PRECISION (result_type))
9299                && (TYPE_PRECISION (TREE_TYPE (op1))
9300                    < TYPE_PRECISION (result_type)))
9301         warning_at (location, OPT_Wsign_compare,
9302                  "comparison of promoted ~unsigned with unsigned");
9303     }
9304 }
9305
9306 /* Setup a TYPE_DECL node as a typedef representation.
9307
9308    X is a TYPE_DECL for a typedef statement.  Create a brand new
9309    ..._TYPE node (which will be just a variant of the existing
9310    ..._TYPE node with identical properties) and then install X
9311    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9312
9313    The whole point here is to end up with a situation where each
9314    and every ..._TYPE node the compiler creates will be uniquely
9315    associated with AT MOST one node representing a typedef name.
9316    This way, even though the compiler substitutes corresponding
9317    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9318    early on, later parts of the compiler can always do the reverse
9319    translation and get back the corresponding typedef name.  For
9320    example, given:
9321
9322         typedef struct S MY_TYPE;
9323         MY_TYPE object;
9324
9325    Later parts of the compiler might only know that `object' was of
9326    type `struct S' if it were not for code just below.  With this
9327    code however, later parts of the compiler see something like:
9328
9329         struct S' == struct S
9330         typedef struct S' MY_TYPE;
9331         struct S' object;
9332
9333     And they can then deduce (from the node for type struct S') that
9334     the original object declaration was:
9335
9336                 MY_TYPE object;
9337
9338     Being able to do this is important for proper support of protoize,
9339     and also for generating precise symbolic debugging information
9340     which takes full account of the programmer's (typedef) vocabulary.
9341
9342     Obviously, we don't want to generate a duplicate ..._TYPE node if
9343     the TYPE_DECL node that we are now processing really represents a
9344     standard built-in type.  */
9345
9346 void
9347 set_underlying_type (tree x)
9348 {
9349   if (x == error_mark_node)
9350     return;
9351   if (DECL_IS_BUILTIN (x))
9352     {
9353       if (TYPE_NAME (TREE_TYPE (x)) == 0)
9354         TYPE_NAME (TREE_TYPE (x)) = x;
9355     }
9356   else if (TREE_TYPE (x) != error_mark_node
9357            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9358     {
9359       tree tt = TREE_TYPE (x);
9360       DECL_ORIGINAL_TYPE (x) = tt;
9361       tt = build_variant_type_copy (tt);
9362       TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9363       TYPE_NAME (tt) = x;
9364       TREE_USED (tt) = TREE_USED (x);
9365       TREE_TYPE (x) = tt;
9366     }
9367 }
9368
9369 /* Returns true if X is a typedef decl.  */
9370
9371 bool
9372 is_typedef_decl (tree x)
9373 {
9374   return (x && TREE_CODE (x) == TYPE_DECL
9375           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9376 }
9377
9378 /* Record the types used by the current global variable declaration
9379    being parsed, so that we can decide later to emit their debug info.
9380    Those types are in types_used_by_cur_var_decl, and we are going to
9381    store them in the types_used_by_vars_hash hash table.
9382    DECL is the declaration of the global variable that has been parsed.  */
9383
9384 void
9385 record_types_used_by_current_var_decl (tree decl)
9386 {
9387   gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9388
9389   if (types_used_by_cur_var_decl)
9390     {
9391       tree node;
9392       for (node = types_used_by_cur_var_decl;
9393            node;
9394            node = TREE_CHAIN (node))
9395       {
9396         tree type = TREE_PURPOSE (node);
9397         types_used_by_var_decl_insert (type, decl);
9398       }
9399       types_used_by_cur_var_decl = NULL;
9400     }
9401 }
9402
9403 /* The C and C++ parsers both use vectors to hold function arguments.
9404    For efficiency, we keep a cache of unused vectors.  This is the
9405    cache.  */
9406
9407 typedef VEC(tree,gc)* tree_gc_vec;
9408 DEF_VEC_P(tree_gc_vec);
9409 DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9410 static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9411
9412 /* Return a new vector from the cache.  If the cache is empty,
9413    allocate a new vector.  These vectors are GC'ed, so it is OK if the
9414    pointer is not released..  */
9415
9416 VEC(tree,gc) *
9417 make_tree_vector (void)
9418 {
9419   if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9420     return VEC_pop (tree_gc_vec, tree_vector_cache);
9421   else
9422     {
9423       /* Passing 0 to VEC_alloc returns NULL, and our callers require
9424          that we always return a non-NULL value.  The vector code uses
9425          4 when growing a NULL vector, so we do too.  */
9426       return VEC_alloc (tree, gc, 4);
9427     }
9428 }
9429
9430 /* Release a vector of trees back to the cache.  */
9431
9432 void
9433 release_tree_vector (VEC(tree,gc) *vec)
9434 {
9435   if (vec != NULL)
9436     {
9437       VEC_truncate (tree, vec, 0);
9438       VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9439     }
9440 }
9441
9442 /* Get a new tree vector holding a single tree.  */
9443
9444 VEC(tree,gc) *
9445 make_tree_vector_single (tree t)
9446 {
9447   VEC(tree,gc) *ret = make_tree_vector ();
9448   VEC_quick_push (tree, ret, t);
9449   return ret;
9450 }
9451
9452 /* Get a new tree vector which is a copy of an existing one.  */
9453
9454 VEC(tree,gc) *
9455 make_tree_vector_copy (const VEC(tree,gc) *orig)
9456 {
9457   VEC(tree,gc) *ret;
9458   unsigned int ix;
9459   tree t;
9460
9461   ret = make_tree_vector ();
9462   VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
9463   for (ix = 0; VEC_iterate (tree, orig, ix, t); ++ix)
9464     VEC_quick_push (tree, ret, t);
9465   return ret;
9466 }
9467
9468 #include "gt-c-common.h"