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