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