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 (op && 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       if (TREE_CODE (value) == CONST_DECL)
4932         value = DECL_INITIAL (value);
4933       node = splay_tree_lookup (cases, (splay_tree_key) value);
4934       if (node)
4935         {
4936           /* Mark the CASE_LOW part of the case entry as seen.  */
4937           tree label = (tree) node->value;
4938           CASE_LOW_SEEN (label) = 1;
4939           continue;
4940         }
4941
4942       /* Even though there wasn't an exact match, there might be a
4943          case range which includes the enumerator's value.  */
4944       node = splay_tree_predecessor (cases, (splay_tree_key) value);
4945       if (node && CASE_HIGH ((tree) node->value))
4946         {
4947           tree label = (tree) node->value;
4948           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4949           if (cmp >= 0)
4950             {
4951               /* If we match the upper bound exactly, mark the CASE_HIGH
4952                  part of the case entry as seen.  */
4953               if (cmp == 0)
4954                 CASE_HIGH_SEEN (label) = 1;
4955               continue;
4956             }
4957         }
4958
4959       /* We've now determined that this enumerated literal isn't
4960          handled by the case labels of the switch statement.  */
4961
4962       /* If the switch expression is a constant, we only really care
4963          about whether that constant is handled by the switch.  */
4964       if (cond && tree_int_cst_compare (cond, value))
4965         continue;
4966
4967       /* If there is a default_node, the only relevant option is
4968          Wswitch-enum. Otherwise, if both are enabled then we prefer
4969          to warn using -Wswitch because -Wswitch is enabled by -Wall
4970          while -Wswitch-enum is explicit.  */
4971       warning ((default_node || !warn_switch)
4972                ? OPT_Wswitch_enum : OPT_Wswitch,
4973                "%Henumeration value %qE not handled in switch",
4974                &switch_location, TREE_PURPOSE (chain));
4975     }
4976
4977   /* Warn if there are case expressions that don't correspond to
4978      enumerators.  This can occur since C and C++ don't enforce
4979      type-checking of assignments to enumeration variables.
4980
4981      The time complexity here is now always O(N) worst case, since
4982      we should have marked both the lower bound and upper bound of
4983      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4984      above.  This scan also resets those fields.  */
4985
4986   /* If there is a default_node, the only relevant option is
4987      Wswitch-enum. Otherwise, if both are enabled then we prefer
4988      to warn using -Wswitch because -Wswitch is enabled by -Wall
4989      while -Wswitch-enum is explicit.  */
4990   saved_warn_switch = warn_switch;
4991   if (default_node)
4992     warn_switch = 0;
4993   splay_tree_foreach (cases, match_case_to_enum, type);
4994   warn_switch = saved_warn_switch;
4995
4996 }
4997
4998 /* Finish an expression taking the address of LABEL (an
4999    IDENTIFIER_NODE).  Returns an expression for the address.  */
5000
5001 tree
5002 finish_label_address_expr (tree label)
5003 {
5004   tree result;
5005
5006   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5007
5008   if (label == error_mark_node)
5009     return error_mark_node;
5010
5011   label = lookup_label (label);
5012   if (label == NULL_TREE)
5013     result = null_pointer_node;
5014   else
5015     {
5016       TREE_USED (label) = 1;
5017       result = build1 (ADDR_EXPR, ptr_type_node, label);
5018       /* The current function in not necessarily uninlinable.
5019          Computed gotos are incompatible with inlining, but the value
5020          here could be used only in a diagnostic, for example.  */
5021     }
5022
5023   return result;
5024 }
5025
5026 /* Hook used by expand_expr to expand language-specific tree codes.  */
5027 /* The only things that should go here are bits needed to expand
5028    constant initializers.  Everything else should be handled by the
5029    gimplification routines.  */
5030
5031 rtx
5032 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
5033                int modifiera /* Actually enum expand_modifier.  */,
5034                rtx *alt_rtl)
5035 {
5036   enum expand_modifier modifier = (enum expand_modifier) modifiera;
5037   switch (TREE_CODE (exp))
5038     {
5039     case COMPOUND_LITERAL_EXPR:
5040       {
5041         /* Initialize the anonymous variable declared in the compound
5042            literal, then return the variable.  */
5043         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5044         emit_local_var (decl);
5045         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5046       }
5047
5048     default:
5049       gcc_unreachable ();
5050     }
5051 }
5052
5053 /* Hook used by staticp to handle language-specific tree codes.  */
5054
5055 tree
5056 c_staticp (tree exp)
5057 {
5058   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5059           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5060           ? exp : NULL);
5061 }
5062 \f
5063
5064 /* Given a boolean expression ARG, return a tree representing an increment
5065    or decrement (as indicated by CODE) of ARG.  The front end must check for
5066    invalid cases (e.g., decrement in C++).  */
5067 tree
5068 boolean_increment (enum tree_code code, tree arg)
5069 {
5070   tree val;
5071   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5072
5073   arg = stabilize_reference (arg);
5074   switch (code)
5075     {
5076     case PREINCREMENT_EXPR:
5077       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5078       break;
5079     case POSTINCREMENT_EXPR:
5080       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5081       arg = save_expr (arg);
5082       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5083       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5084       break;
5085     case PREDECREMENT_EXPR:
5086       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5087                     invert_truthvalue (arg));
5088       break;
5089     case POSTDECREMENT_EXPR:
5090       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5091                     invert_truthvalue (arg));
5092       arg = save_expr (arg);
5093       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5094       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5095       break;
5096     default:
5097       gcc_unreachable ();
5098     }
5099   TREE_SIDE_EFFECTS (val) = 1;
5100   return val;
5101 }
5102 \f
5103 /* Built-in macros for stddef.h, that require macros defined in this
5104    file.  */
5105 void
5106 c_stddef_cpp_builtins(void)
5107 {
5108   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5109   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5110   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5111   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5112   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5113   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5114   builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5115   builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5116 }
5117
5118 static void
5119 c_init_attributes (void)
5120 {
5121   /* Fill in the built_in_attributes array.  */
5122 #define DEF_ATTR_NULL_TREE(ENUM)                                \
5123   built_in_attributes[(int) ENUM] = NULL_TREE;
5124 #define DEF_ATTR_INT(ENUM, VALUE)                               \
5125   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5126 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
5127   built_in_attributes[(int) ENUM] = get_identifier (STRING);
5128 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5129   built_in_attributes[(int) ENUM]                       \
5130     = tree_cons (built_in_attributes[(int) PURPOSE],    \
5131                  built_in_attributes[(int) VALUE],      \
5132                  built_in_attributes[(int) CHAIN]);
5133 #include "builtin-attrs.def"
5134 #undef DEF_ATTR_NULL_TREE
5135 #undef DEF_ATTR_INT
5136 #undef DEF_ATTR_IDENT
5137 #undef DEF_ATTR_TREE_LIST
5138 }
5139
5140 /* Attribute handlers common to C front ends.  */
5141
5142 /* Handle a "packed" attribute; arguments as in
5143    struct attribute_spec.handler.  */
5144
5145 static tree
5146 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5147                          int flags, bool *no_add_attrs)
5148 {
5149   if (TYPE_P (*node))
5150     {
5151       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5152         *node = build_variant_type_copy (*node);
5153       TYPE_PACKED (*node) = 1;
5154     }
5155   else if (TREE_CODE (*node) == FIELD_DECL)
5156     {
5157       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
5158         warning (OPT_Wattributes,
5159                  "%qE attribute ignored for field of type %qT",
5160                  name, TREE_TYPE (*node));
5161       else
5162         DECL_PACKED (*node) = 1;
5163     }
5164   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5165      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5166      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5167      that changes what the typedef is typing.  */
5168   else
5169     {
5170       warning (OPT_Wattributes, "%qE attribute ignored", name);
5171       *no_add_attrs = true;
5172     }
5173
5174   return NULL_TREE;
5175 }
5176
5177 /* Handle a "nocommon" attribute; arguments as in
5178    struct attribute_spec.handler.  */
5179
5180 static tree
5181 handle_nocommon_attribute (tree *node, tree name,
5182                            tree ARG_UNUSED (args),
5183                            int ARG_UNUSED (flags), bool *no_add_attrs)
5184 {
5185   if (TREE_CODE (*node) == VAR_DECL)
5186     DECL_COMMON (*node) = 0;
5187   else
5188     {
5189       warning (OPT_Wattributes, "%qE attribute ignored", name);
5190       *no_add_attrs = true;
5191     }
5192
5193   return NULL_TREE;
5194 }
5195
5196 /* Handle a "common" attribute; arguments as in
5197    struct attribute_spec.handler.  */
5198
5199 static tree
5200 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5201                          int ARG_UNUSED (flags), bool *no_add_attrs)
5202 {
5203   if (TREE_CODE (*node) == VAR_DECL)
5204     DECL_COMMON (*node) = 1;
5205   else
5206     {
5207       warning (OPT_Wattributes, "%qE attribute ignored", name);
5208       *no_add_attrs = true;
5209     }
5210
5211   return NULL_TREE;
5212 }
5213
5214 /* Handle a "noreturn" attribute; arguments as in
5215    struct attribute_spec.handler.  */
5216
5217 static tree
5218 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5219                            int ARG_UNUSED (flags), bool *no_add_attrs)
5220 {
5221   tree type = TREE_TYPE (*node);
5222
5223   /* See FIXME comment in c_common_attribute_table.  */
5224   if (TREE_CODE (*node) == FUNCTION_DECL)
5225     TREE_THIS_VOLATILE (*node) = 1;
5226   else if (TREE_CODE (type) == POINTER_TYPE
5227            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5228     TREE_TYPE (*node)
5229       = build_pointer_type
5230         (build_type_variant (TREE_TYPE (type),
5231                              TYPE_READONLY (TREE_TYPE (type)), 1));
5232   else
5233     {
5234       warning (OPT_Wattributes, "%qE attribute ignored", name);
5235       *no_add_attrs = true;
5236     }
5237
5238   return NULL_TREE;
5239 }
5240
5241 /* Handle a "hot" and attribute; arguments as in
5242    struct attribute_spec.handler.  */
5243
5244 static tree
5245 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5246                       int ARG_UNUSED (flags), bool *no_add_attrs)
5247 {
5248   if (TREE_CODE (*node) == FUNCTION_DECL)
5249     {
5250       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5251         {
5252           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5253                    name, "cold");
5254           *no_add_attrs = true;
5255         }
5256       else
5257         {
5258           tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
5259
5260           /* If we are not at -O3, but are optimizing, turn on -O3
5261              optimizations just for this one function.  */
5262           if (((optimize > 0 && optimize < 3) || optimize_size)
5263               && targetm.target_option.hot_attribute_sets_optimization
5264               && (!old_opts || old_opts == optimization_default_node))
5265             {
5266               /* Create the hot optimization node if needed.  */
5267               if (!optimization_hot_node)
5268                 {
5269                   struct cl_optimization current_options;
5270                   static const char *os_argv[] = { NULL, "-O3", NULL };
5271
5272                   cl_optimization_save (&current_options);
5273                   decode_options (2, os_argv);
5274                   optimization_hot_node = build_optimization_node ();
5275                   cl_optimization_restore (&current_options);
5276                 }
5277
5278               DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
5279                 = optimization_hot_node;
5280             }
5281           /* Most of the rest of the hot processing is done later with
5282              lookup_attribute.  */
5283         }
5284     }
5285   else
5286     {
5287       warning (OPT_Wattributes, "%qE attribute ignored", name);
5288       *no_add_attrs = true;
5289     }
5290
5291   return NULL_TREE;
5292 }
5293 /* Handle a "cold" and attribute; arguments as in
5294    struct attribute_spec.handler.  */
5295
5296 static tree
5297 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5298                        int ARG_UNUSED (flags), bool *no_add_attrs)
5299 {
5300   if (TREE_CODE (*node) == FUNCTION_DECL)
5301     {
5302       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5303         {
5304           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5305                    name, "hot");
5306           *no_add_attrs = true;
5307         }
5308       else
5309         {
5310           tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
5311
5312           /* If we are optimizing, but not optimizing for space, turn on -Os
5313              optimizations just for this one function.  */
5314           if (optimize && !optimize_size
5315               && targetm.target_option.cold_attribute_sets_optimization
5316               && (!old_opts || old_opts == optimization_default_node))
5317             {
5318               /* Create the cold optimization node if needed.  */
5319               if (!optimization_cold_node)
5320                 {
5321                   struct cl_optimization current_options;
5322                   static const char *os_argv[] = { NULL, "-Os", NULL };
5323
5324                   cl_optimization_save (&current_options);
5325                   decode_options (2, os_argv);
5326                   optimization_cold_node = build_optimization_node ();
5327                   cl_optimization_restore (&current_options);
5328                 }
5329
5330               DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
5331                 = optimization_cold_node;
5332             }
5333           /* Most of the rest of the cold processing is done later with
5334              lookup_attribute.  */
5335         }
5336     }
5337   else
5338     {
5339       warning (OPT_Wattributes, "%qE attribute ignored", name);
5340       *no_add_attrs = true;
5341     }
5342
5343   return NULL_TREE;
5344 }
5345
5346 /* Handle a "noinline" attribute; arguments as in
5347    struct attribute_spec.handler.  */
5348
5349 static tree
5350 handle_noinline_attribute (tree *node, tree name,
5351                            tree ARG_UNUSED (args),
5352                            int ARG_UNUSED (flags), bool *no_add_attrs)
5353 {
5354   if (TREE_CODE (*node) == FUNCTION_DECL)
5355     DECL_UNINLINABLE (*node) = 1;
5356   else
5357     {
5358       warning (OPT_Wattributes, "%qE attribute ignored", name);
5359       *no_add_attrs = true;
5360     }
5361
5362   return NULL_TREE;
5363 }
5364
5365 /* Handle a "always_inline" attribute; arguments as in
5366    struct attribute_spec.handler.  */
5367
5368 static tree
5369 handle_always_inline_attribute (tree *node, tree name,
5370                                 tree ARG_UNUSED (args),
5371                                 int ARG_UNUSED (flags),
5372                                 bool *no_add_attrs)
5373 {
5374   if (TREE_CODE (*node) == FUNCTION_DECL)
5375     {
5376       /* Set the attribute and mark it for disregarding inline
5377          limits.  */
5378       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5379     }
5380   else
5381     {
5382       warning (OPT_Wattributes, "%qE attribute ignored", name);
5383       *no_add_attrs = true;
5384     }
5385
5386   return NULL_TREE;
5387 }
5388
5389 /* Handle a "gnu_inline" attribute; arguments as in
5390    struct attribute_spec.handler.  */
5391
5392 static tree
5393 handle_gnu_inline_attribute (tree *node, tree name,
5394                              tree ARG_UNUSED (args),
5395                              int ARG_UNUSED (flags),
5396                              bool *no_add_attrs)
5397 {
5398   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5399     {
5400       /* Do nothing else, just set the attribute.  We'll get at
5401          it later with lookup_attribute.  */
5402     }
5403   else
5404     {
5405       warning (OPT_Wattributes, "%qE attribute ignored", name);
5406       *no_add_attrs = true;
5407     }
5408
5409   return NULL_TREE;
5410 }
5411
5412 /* Handle an "artificial" attribute; arguments as in
5413    struct attribute_spec.handler.  */
5414
5415 static tree
5416 handle_artificial_attribute (tree *node, tree name,
5417                              tree ARG_UNUSED (args),
5418                              int ARG_UNUSED (flags),
5419                              bool *no_add_attrs)
5420 {
5421   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5422     {
5423       /* Do nothing else, just set the attribute.  We'll get at
5424          it later with lookup_attribute.  */
5425     }
5426   else
5427     {
5428       warning (OPT_Wattributes, "%qE attribute ignored", name);
5429       *no_add_attrs = true;
5430     }
5431
5432   return NULL_TREE;
5433 }
5434
5435 /* Handle a "flatten" attribute; arguments as in
5436    struct attribute_spec.handler.  */
5437
5438 static tree
5439 handle_flatten_attribute (tree *node, tree name,
5440                           tree args ATTRIBUTE_UNUSED,
5441                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5442 {
5443   if (TREE_CODE (*node) == FUNCTION_DECL)
5444     /* Do nothing else, just set the attribute.  We'll get at
5445        it later with lookup_attribute.  */
5446     ;
5447   else
5448     {
5449       warning (OPT_Wattributes, "%qE attribute ignored", name);
5450       *no_add_attrs = true;
5451     }
5452
5453   return NULL_TREE;
5454 }
5455
5456 /* Handle a "warning" or "error" attribute; arguments as in
5457    struct attribute_spec.handler.  */
5458
5459 static tree
5460 handle_error_attribute (tree *node, tree name, tree args,
5461                         int ARG_UNUSED (flags), bool *no_add_attrs)
5462 {
5463   if (TREE_CODE (*node) == FUNCTION_DECL
5464       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5465     /* Do nothing else, just set the attribute.  We'll get at
5466        it later with lookup_attribute.  */
5467     ;
5468   else
5469     {
5470       warning (OPT_Wattributes, "%qE attribute ignored", name);
5471       *no_add_attrs = true;
5472     }
5473
5474   return NULL_TREE;
5475 }
5476
5477 /* Handle a "used" attribute; arguments as in
5478    struct attribute_spec.handler.  */
5479
5480 static tree
5481 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5482                        int ARG_UNUSED (flags), bool *no_add_attrs)
5483 {
5484   tree node = *pnode;
5485
5486   if (TREE_CODE (node) == FUNCTION_DECL
5487       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5488     {
5489       TREE_USED (node) = 1;
5490       DECL_PRESERVE_P (node) = 1;
5491     }
5492   else
5493     {
5494       warning (OPT_Wattributes, "%qE attribute ignored", name);
5495       *no_add_attrs = true;
5496     }
5497
5498   return NULL_TREE;
5499 }
5500
5501 /* Handle a "unused" attribute; arguments as in
5502    struct attribute_spec.handler.  */
5503
5504 static tree
5505 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5506                          int flags, bool *no_add_attrs)
5507 {
5508   if (DECL_P (*node))
5509     {
5510       tree decl = *node;
5511
5512       if (TREE_CODE (decl) == PARM_DECL
5513           || TREE_CODE (decl) == VAR_DECL
5514           || TREE_CODE (decl) == FUNCTION_DECL
5515           || TREE_CODE (decl) == LABEL_DECL
5516           || TREE_CODE (decl) == TYPE_DECL)
5517         TREE_USED (decl) = 1;
5518       else
5519         {
5520           warning (OPT_Wattributes, "%qE attribute ignored", name);
5521           *no_add_attrs = true;
5522         }
5523     }
5524   else
5525     {
5526       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5527         *node = build_variant_type_copy (*node);
5528       TREE_USED (*node) = 1;
5529     }
5530
5531   return NULL_TREE;
5532 }
5533
5534 /* Handle a "externally_visible" attribute; arguments as in
5535    struct attribute_spec.handler.  */
5536
5537 static tree
5538 handle_externally_visible_attribute (tree *pnode, tree name,
5539                                      tree ARG_UNUSED (args),
5540                                      int ARG_UNUSED (flags),
5541                                      bool *no_add_attrs)
5542 {
5543   tree node = *pnode;
5544
5545   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5546     {
5547       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5548            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5549         {
5550           warning (OPT_Wattributes,
5551                    "%qE attribute have effect only on public objects", name);
5552           *no_add_attrs = true;
5553         }
5554     }
5555   else
5556     {
5557       warning (OPT_Wattributes, "%qE attribute ignored", name);
5558       *no_add_attrs = true;
5559     }
5560
5561   return NULL_TREE;
5562 }
5563
5564 /* Handle a "const" attribute; arguments as in
5565    struct attribute_spec.handler.  */
5566
5567 static tree
5568 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5569                         int ARG_UNUSED (flags), bool *no_add_attrs)
5570 {
5571   tree type = TREE_TYPE (*node);
5572
5573   /* See FIXME comment on noreturn in c_common_attribute_table.  */
5574   if (TREE_CODE (*node) == FUNCTION_DECL)
5575     TREE_READONLY (*node) = 1;
5576   else if (TREE_CODE (type) == POINTER_TYPE
5577            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5578     TREE_TYPE (*node)
5579       = build_pointer_type
5580         (build_type_variant (TREE_TYPE (type), 1,
5581                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
5582   else
5583     {
5584       warning (OPT_Wattributes, "%qE attribute ignored", name);
5585       *no_add_attrs = true;
5586     }
5587
5588   return NULL_TREE;
5589 }
5590
5591 /* Handle a "transparent_union" attribute; arguments as in
5592    struct attribute_spec.handler.  */
5593
5594 static tree
5595 handle_transparent_union_attribute (tree *node, tree name,
5596                                     tree ARG_UNUSED (args), int flags,
5597                                     bool *no_add_attrs)
5598 {
5599   tree type;
5600
5601   *no_add_attrs = true;
5602
5603   if (TREE_CODE (*node) == TYPE_DECL)
5604     node = &TREE_TYPE (*node);
5605   type = *node;
5606
5607   if (TREE_CODE (type) == UNION_TYPE)
5608     {
5609       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5610          the code in finish_struct.  */
5611       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5612         {
5613           if (TYPE_FIELDS (type) == NULL_TREE
5614               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5615             goto ignored;
5616
5617           /* A type variant isn't good enough, since we don't a cast
5618              to such a type removed as a no-op.  */
5619           *node = type = build_duplicate_type (type);
5620         }
5621
5622       TYPE_TRANSPARENT_UNION (type) = 1;
5623       return NULL_TREE;
5624     }
5625
5626  ignored:
5627   warning (OPT_Wattributes, "%qE attribute ignored", name);
5628   return NULL_TREE;
5629 }
5630
5631 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
5632    get the requested priority for a constructor or destructor,
5633    possibly issuing diagnostics for invalid or reserved
5634    priorities.  */
5635
5636 static priority_type
5637 get_priority (tree args, bool is_destructor)
5638 {
5639   HOST_WIDE_INT pri;
5640   tree arg;
5641
5642   if (!args)
5643     return DEFAULT_INIT_PRIORITY;
5644
5645   if (!SUPPORTS_INIT_PRIORITY)
5646     {
5647       if (is_destructor)
5648         error ("destructor priorities are not supported");
5649       else
5650         error ("constructor priorities are not supported");
5651       return DEFAULT_INIT_PRIORITY;
5652     }
5653
5654   arg = TREE_VALUE (args);
5655   if (!host_integerp (arg, /*pos=*/0)
5656       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5657     goto invalid;
5658
5659   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5660   if (pri < 0 || pri > MAX_INIT_PRIORITY)
5661     goto invalid;
5662
5663   if (pri <= MAX_RESERVED_INIT_PRIORITY)
5664     {
5665       if (is_destructor)
5666         warning (0,
5667                  "destructor priorities from 0 to %d are reserved "
5668                  "for the implementation",
5669                  MAX_RESERVED_INIT_PRIORITY);
5670       else
5671         warning (0,
5672                  "constructor priorities from 0 to %d are reserved "
5673                  "for the implementation",
5674                  MAX_RESERVED_INIT_PRIORITY);
5675     }
5676   return pri;
5677
5678  invalid:
5679   if (is_destructor)
5680     error ("destructor priorities must be integers from 0 to %d inclusive",
5681            MAX_INIT_PRIORITY);
5682   else
5683     error ("constructor priorities must be integers from 0 to %d inclusive",
5684            MAX_INIT_PRIORITY);
5685   return DEFAULT_INIT_PRIORITY;
5686 }
5687
5688 /* Handle a "constructor" attribute; arguments as in
5689    struct attribute_spec.handler.  */
5690
5691 static tree
5692 handle_constructor_attribute (tree *node, tree name, tree args,
5693                               int ARG_UNUSED (flags),
5694                               bool *no_add_attrs)
5695 {
5696   tree decl = *node;
5697   tree type = TREE_TYPE (decl);
5698
5699   if (TREE_CODE (decl) == FUNCTION_DECL
5700       && TREE_CODE (type) == FUNCTION_TYPE
5701       && decl_function_context (decl) == 0)
5702     {
5703       priority_type priority;
5704       DECL_STATIC_CONSTRUCTOR (decl) = 1;
5705       priority = get_priority (args, /*is_destructor=*/false);
5706       SET_DECL_INIT_PRIORITY (decl, priority);
5707       TREE_USED (decl) = 1;
5708     }
5709   else
5710     {
5711       warning (OPT_Wattributes, "%qE attribute ignored", name);
5712       *no_add_attrs = true;
5713     }
5714
5715   return NULL_TREE;
5716 }
5717
5718 /* Handle a "destructor" attribute; arguments as in
5719    struct attribute_spec.handler.  */
5720
5721 static tree
5722 handle_destructor_attribute (tree *node, tree name, tree args,
5723                              int ARG_UNUSED (flags),
5724                              bool *no_add_attrs)
5725 {
5726   tree decl = *node;
5727   tree type = TREE_TYPE (decl);
5728
5729   if (TREE_CODE (decl) == FUNCTION_DECL
5730       && TREE_CODE (type) == FUNCTION_TYPE
5731       && decl_function_context (decl) == 0)
5732     {
5733       priority_type priority;
5734       DECL_STATIC_DESTRUCTOR (decl) = 1;
5735       priority = get_priority (args, /*is_destructor=*/true);
5736       SET_DECL_FINI_PRIORITY (decl, priority);
5737       TREE_USED (decl) = 1;
5738     }
5739   else
5740     {
5741       warning (OPT_Wattributes, "%qE attribute ignored", name);
5742       *no_add_attrs = true;
5743     }
5744
5745   return NULL_TREE;
5746 }
5747
5748 /* Handle a "mode" attribute; arguments as in
5749    struct attribute_spec.handler.  */
5750
5751 static tree
5752 handle_mode_attribute (tree *node, tree name, tree args,
5753                        int ARG_UNUSED (flags), bool *no_add_attrs)
5754 {
5755   tree type = *node;
5756
5757   *no_add_attrs = true;
5758
5759   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5760     warning (OPT_Wattributes, "%qE attribute ignored", name);
5761   else
5762     {
5763       int j;
5764       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5765       int len = strlen (p);
5766       enum machine_mode mode = VOIDmode;
5767       tree typefm;
5768       bool valid_mode;
5769
5770       if (len > 4 && p[0] == '_' && p[1] == '_'
5771           && p[len - 1] == '_' && p[len - 2] == '_')
5772         {
5773           char *newp = (char *) alloca (len - 1);
5774
5775           strcpy (newp, &p[2]);
5776           newp[len - 4] = '\0';
5777           p = newp;
5778         }
5779
5780       /* Change this type to have a type with the specified mode.
5781          First check for the special modes.  */
5782       if (!strcmp (p, "byte"))
5783         mode = byte_mode;
5784       else if (!strcmp (p, "word"))
5785         mode = word_mode;
5786       else if (!strcmp (p, "pointer"))
5787         mode = ptr_mode;
5788       else if (!strcmp (p, "libgcc_cmp_return"))
5789         mode = targetm.libgcc_cmp_return_mode ();
5790       else if (!strcmp (p, "libgcc_shift_count"))
5791         mode = targetm.libgcc_shift_count_mode ();
5792       else if (!strcmp (p, "unwind_word"))
5793         mode = targetm.unwind_word_mode ();
5794       else
5795         for (j = 0; j < NUM_MACHINE_MODES; j++)
5796           if (!strcmp (p, GET_MODE_NAME (j)))
5797             {
5798               mode = (enum machine_mode) j;
5799               break;
5800             }
5801
5802       if (mode == VOIDmode)
5803         {
5804           error ("unknown machine mode %qs", p);
5805           return NULL_TREE;
5806         }
5807
5808       valid_mode = false;
5809       switch (GET_MODE_CLASS (mode))
5810         {
5811         case MODE_INT:
5812         case MODE_PARTIAL_INT:
5813         case MODE_FLOAT:
5814         case MODE_DECIMAL_FLOAT:
5815         case MODE_FRACT:
5816         case MODE_UFRACT:
5817         case MODE_ACCUM:
5818         case MODE_UACCUM:
5819           valid_mode = targetm.scalar_mode_supported_p (mode);
5820           break;
5821
5822         case MODE_COMPLEX_INT:
5823         case MODE_COMPLEX_FLOAT:
5824           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5825           break;
5826
5827         case MODE_VECTOR_INT:
5828         case MODE_VECTOR_FLOAT:
5829         case MODE_VECTOR_FRACT:
5830         case MODE_VECTOR_UFRACT:
5831         case MODE_VECTOR_ACCUM:
5832         case MODE_VECTOR_UACCUM:
5833           warning (OPT_Wattributes, "specifying vector types with "
5834                    "__attribute__ ((mode)) is deprecated");
5835           warning (OPT_Wattributes,
5836                    "use __attribute__ ((vector_size)) instead");
5837           valid_mode = vector_mode_valid_p (mode);
5838           break;
5839
5840         default:
5841           break;
5842         }
5843       if (!valid_mode)
5844         {
5845           error ("unable to emulate %qs", p);
5846           return NULL_TREE;
5847         }
5848
5849       if (POINTER_TYPE_P (type))
5850         {
5851           tree (*fn)(tree, enum machine_mode, bool);
5852
5853           if (!targetm.valid_pointer_mode (mode))
5854             {
5855               error ("invalid pointer mode %qs", p);
5856               return NULL_TREE;
5857             }
5858
5859           if (TREE_CODE (type) == POINTER_TYPE)
5860             fn = build_pointer_type_for_mode;
5861           else
5862             fn = build_reference_type_for_mode;
5863           typefm = fn (TREE_TYPE (type), mode, false);
5864         }
5865       else
5866         {
5867           /* For fixed-point modes, we need to test if the signness of type
5868              and the machine mode are consistent.  */
5869           if (ALL_FIXED_POINT_MODE_P (mode)
5870               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5871             {
5872               error ("signness of type and machine mode %qs don't match", p);
5873               return NULL_TREE;
5874             }
5875           /* For fixed-point modes, we need to pass saturating info.  */
5876           typefm = lang_hooks.types.type_for_mode (mode,
5877                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5878                                                       : TYPE_UNSIGNED (type));
5879         }
5880
5881       if (typefm == NULL_TREE)
5882         {
5883           error ("no data type for mode %qs", p);
5884           return NULL_TREE;
5885         }
5886       else if (TREE_CODE (type) == ENUMERAL_TYPE)
5887         {
5888           /* For enumeral types, copy the precision from the integer
5889              type returned above.  If not an INTEGER_TYPE, we can't use
5890              this mode for this type.  */
5891           if (TREE_CODE (typefm) != INTEGER_TYPE)
5892             {
5893               error ("cannot use mode %qs for enumeral types", p);
5894               return NULL_TREE;
5895             }
5896
5897           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5898             {
5899               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5900               typefm = type;
5901             }
5902           else
5903             {
5904               /* We cannot build a type variant, as there's code that assumes
5905                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
5906                  debug generators.  Instead, create a subrange type.  This
5907                  results in all of the enumeral values being emitted only once
5908                  in the original, and the subtype gets them by reference.  */
5909               if (TYPE_UNSIGNED (type))
5910                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5911               else
5912                 typefm = make_signed_type (TYPE_PRECISION (typefm));
5913               TREE_TYPE (typefm) = type;
5914             }
5915         }
5916       else if (VECTOR_MODE_P (mode)
5917                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5918                : TREE_CODE (type) != TREE_CODE (typefm))
5919         {
5920           error ("mode %qs applied to inappropriate type", p);
5921           return NULL_TREE;
5922         }
5923
5924       *node = typefm;
5925     }
5926
5927   return NULL_TREE;
5928 }
5929
5930 /* Handle a "section" attribute; arguments as in
5931    struct attribute_spec.handler.  */
5932
5933 static tree
5934 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5935                           int ARG_UNUSED (flags), bool *no_add_attrs)
5936 {
5937   tree decl = *node;
5938
5939   if (targetm.have_named_sections)
5940     {
5941       user_defined_section_attribute = true;
5942
5943       if ((TREE_CODE (decl) == FUNCTION_DECL
5944            || TREE_CODE (decl) == VAR_DECL)
5945           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5946         {
5947           if (TREE_CODE (decl) == VAR_DECL
5948               && current_function_decl != NULL_TREE
5949               && !TREE_STATIC (decl))
5950             {
5951               error ("%Jsection attribute cannot be specified for "
5952                      "local variables", decl);
5953               *no_add_attrs = true;
5954             }
5955
5956           /* The decl may have already been given a section attribute
5957              from a previous declaration.  Ensure they match.  */
5958           else if (DECL_SECTION_NAME (decl) != NULL_TREE
5959                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5960                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5961             {
5962               error ("section of %q+D conflicts with previous declaration",
5963                      *node);
5964               *no_add_attrs = true;
5965             }
5966           else if (TREE_CODE (decl) == VAR_DECL
5967                    && !targetm.have_tls && targetm.emutls.tmpl_section
5968                    && DECL_THREAD_LOCAL_P (decl))
5969             {
5970               error ("section of %q+D cannot be overridden", *node);
5971               *no_add_attrs = true;
5972             }
5973           else
5974             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5975         }
5976       else
5977         {
5978           error ("section attribute not allowed for %q+D", *node);
5979           *no_add_attrs = true;
5980         }
5981     }
5982   else
5983     {
5984       error ("%Jsection attributes are not supported for this target", *node);
5985       *no_add_attrs = true;
5986     }
5987
5988   return NULL_TREE;
5989 }
5990
5991 /* Handle a "aligned" attribute; arguments as in
5992    struct attribute_spec.handler.  */
5993
5994 static tree
5995 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5996                           int flags, bool *no_add_attrs)
5997 {
5998   tree decl = NULL_TREE;
5999   tree *type = NULL;
6000   int is_type = 0;
6001   tree align_expr = (args ? TREE_VALUE (args)
6002                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
6003   int i;
6004
6005   if (DECL_P (*node))
6006     {
6007       decl = *node;
6008       type = &TREE_TYPE (decl);
6009       is_type = TREE_CODE (*node) == TYPE_DECL;
6010     }
6011   else if (TYPE_P (*node))
6012     type = node, is_type = 1;
6013
6014   if (TREE_CODE (align_expr) != INTEGER_CST)
6015     {
6016       error ("requested alignment is not a constant");
6017       *no_add_attrs = true;
6018     }
6019   else if ((i = tree_log2 (align_expr)) == -1)
6020     {
6021       error ("requested alignment is not a power of 2");
6022       *no_add_attrs = true;
6023     }
6024   else if (i > HOST_BITS_PER_INT - 2)
6025     {
6026       error ("requested alignment is too large");
6027       *no_add_attrs = true;
6028     }
6029   else if (is_type)
6030     {
6031       /* If we have a TYPE_DECL, then copy the type, so that we
6032          don't accidentally modify a builtin type.  See pushdecl.  */
6033       if (decl && TREE_TYPE (decl) != error_mark_node
6034           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6035         {
6036           tree tt = TREE_TYPE (decl);
6037           *type = build_variant_type_copy (*type);
6038           DECL_ORIGINAL_TYPE (decl) = tt;
6039           TYPE_NAME (*type) = decl;
6040           TREE_USED (*type) = TREE_USED (decl);
6041           TREE_TYPE (decl) = *type;
6042         }
6043       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6044         *type = build_variant_type_copy (*type);
6045
6046       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
6047       TYPE_USER_ALIGN (*type) = 1;
6048     }
6049   else if (! VAR_OR_FUNCTION_DECL_P (decl)
6050            && TREE_CODE (decl) != FIELD_DECL)
6051     {
6052       error ("alignment may not be specified for %q+D", decl);
6053       *no_add_attrs = true;
6054     }
6055   else if (TREE_CODE (decl) == FUNCTION_DECL
6056            && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
6057     {
6058       if (DECL_USER_ALIGN (decl))
6059         error ("alignment for %q+D was previously specified as %d "
6060                "and may not be decreased", decl,
6061                DECL_ALIGN (decl) / BITS_PER_UNIT);
6062       else
6063         error ("alignment for %q+D must be at least %d", decl,
6064                DECL_ALIGN (decl) / BITS_PER_UNIT);
6065       *no_add_attrs = true;
6066     }
6067   else
6068     {
6069       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
6070       DECL_USER_ALIGN (decl) = 1;
6071     }
6072
6073   return NULL_TREE;
6074 }
6075
6076 /* Handle a "weak" attribute; arguments as in
6077    struct attribute_spec.handler.  */
6078
6079 static tree
6080 handle_weak_attribute (tree *node, tree name,
6081                        tree ARG_UNUSED (args),
6082                        int ARG_UNUSED (flags),
6083                        bool * ARG_UNUSED (no_add_attrs))
6084 {
6085   if (TREE_CODE (*node) == FUNCTION_DECL
6086       && DECL_DECLARED_INLINE_P (*node))
6087     {
6088       error ("inline function %q+D cannot be declared weak", *node);
6089       *no_add_attrs = true;
6090     }
6091   else if (TREE_CODE (*node) == FUNCTION_DECL
6092            || TREE_CODE (*node) == VAR_DECL)
6093     declare_weak (*node);
6094   else
6095     warning (OPT_Wattributes, "%qE attribute ignored", name);
6096
6097   return NULL_TREE;
6098 }
6099
6100 /* Handle an "alias" attribute; arguments as in
6101    struct attribute_spec.handler.  */
6102
6103 static tree
6104 handle_alias_attribute (tree *node, tree name, tree args,
6105                         int ARG_UNUSED (flags), bool *no_add_attrs)
6106 {
6107   tree decl = *node;
6108
6109   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6110       || (TREE_CODE (decl) != FUNCTION_DECL
6111           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6112       /* A static variable declaration is always a tentative definition,
6113          but the alias is a non-tentative definition which overrides.  */
6114       || (TREE_CODE (decl) != FUNCTION_DECL
6115           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6116     {
6117       error ("%q+D defined both normally and as an alias", decl);
6118       *no_add_attrs = true;
6119     }
6120
6121   /* Note that the very first time we process a nested declaration,
6122      decl_function_context will not be set.  Indeed, *would* never
6123      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6124      we do below.  After such frobbery, pushdecl would set the context.
6125      In any case, this is never what we want.  */
6126   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6127     {
6128       tree id;
6129
6130       id = TREE_VALUE (args);
6131       if (TREE_CODE (id) != STRING_CST)
6132         {
6133           error ("alias argument not a string");
6134           *no_add_attrs = true;
6135           return NULL_TREE;
6136         }
6137       id = get_identifier (TREE_STRING_POINTER (id));
6138       /* This counts as a use of the object pointed to.  */
6139       TREE_USED (id) = 1;
6140
6141       if (TREE_CODE (decl) == FUNCTION_DECL)
6142         DECL_INITIAL (decl) = error_mark_node;
6143       else
6144         {
6145           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6146             DECL_EXTERNAL (decl) = 1;
6147           else
6148             DECL_EXTERNAL (decl) = 0;
6149           TREE_STATIC (decl) = 1;
6150         }
6151     }
6152   else
6153     {
6154       warning (OPT_Wattributes, "%qE attribute ignored", name);
6155       *no_add_attrs = true;
6156     }
6157
6158   return NULL_TREE;
6159 }
6160
6161 /* Handle a "weakref" attribute; arguments as in struct
6162    attribute_spec.handler.  */
6163
6164 static tree
6165 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6166                           int flags, bool *no_add_attrs)
6167 {
6168   tree attr = NULL_TREE;
6169
6170   /* We must ignore the attribute when it is associated with
6171      local-scoped decls, since attribute alias is ignored and many
6172      such symbols do not even have a DECL_WEAK field.  */
6173   if (decl_function_context (*node) || current_function_decl)
6174     {
6175       warning (OPT_Wattributes, "%qE attribute ignored", name);
6176       *no_add_attrs = true;
6177       return NULL_TREE;
6178     }
6179
6180   /* The idea here is that `weakref("name")' mutates into `weakref,
6181      alias("name")', and weakref without arguments, in turn,
6182      implicitly adds weak. */
6183
6184   if (args)
6185     {
6186       attr = tree_cons (get_identifier ("alias"), args, attr);
6187       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6188
6189       *no_add_attrs = true;
6190
6191       decl_attributes (node, attr, flags);
6192     }
6193   else
6194     {
6195       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6196         error ("%Jweakref attribute must appear before alias attribute",
6197                *node);
6198
6199       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6200          and that isn't supported; and because it wants to add it to
6201          the list of weak decls, which isn't helpful.  */
6202       DECL_WEAK (*node) = 1;
6203     }
6204
6205   return NULL_TREE;
6206 }
6207
6208 /* Handle an "visibility" attribute; arguments as in
6209    struct attribute_spec.handler.  */
6210
6211 static tree
6212 handle_visibility_attribute (tree *node, tree name, tree args,
6213                              int ARG_UNUSED (flags),
6214                              bool *ARG_UNUSED (no_add_attrs))
6215 {
6216   tree decl = *node;
6217   tree id = TREE_VALUE (args);
6218   enum symbol_visibility vis;
6219
6220   if (TYPE_P (*node))
6221     {
6222       if (TREE_CODE (*node) == ENUMERAL_TYPE)
6223         /* OK */;
6224       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6225         {
6226           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6227                    name);
6228           return NULL_TREE;
6229         }
6230       else if (TYPE_FIELDS (*node))
6231         {
6232           error ("%qE attribute ignored because %qT is already defined",
6233                  name, *node);
6234           return NULL_TREE;
6235         }
6236     }
6237   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6238     {
6239       warning (OPT_Wattributes, "%qE attribute ignored", name);
6240       return NULL_TREE;
6241     }
6242
6243   if (TREE_CODE (id) != STRING_CST)
6244     {
6245       error ("visibility argument not a string");
6246       return NULL_TREE;
6247     }
6248
6249   /*  If this is a type, set the visibility on the type decl.  */
6250   if (TYPE_P (decl))
6251     {
6252       decl = TYPE_NAME (decl);
6253       if (!decl)
6254         return NULL_TREE;
6255       if (TREE_CODE (decl) == IDENTIFIER_NODE)
6256         {
6257            warning (OPT_Wattributes, "%qE attribute ignored on types",
6258                     name);
6259            return NULL_TREE;
6260         }
6261     }
6262
6263   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6264     vis = VISIBILITY_DEFAULT;
6265   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6266     vis = VISIBILITY_INTERNAL;
6267   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6268     vis = VISIBILITY_HIDDEN;
6269   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6270     vis = VISIBILITY_PROTECTED;
6271   else
6272     {
6273       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6274       vis = VISIBILITY_DEFAULT;
6275     }
6276
6277   if (DECL_VISIBILITY_SPECIFIED (decl)
6278       && vis != DECL_VISIBILITY (decl))
6279     {
6280       tree attributes = (TYPE_P (*node)
6281                          ? TYPE_ATTRIBUTES (*node)
6282                          : DECL_ATTRIBUTES (decl));
6283       if (lookup_attribute ("visibility", attributes))
6284         error ("%qD redeclared with different visibility", decl);
6285       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6286                && lookup_attribute ("dllimport", attributes))
6287         error ("%qD was declared %qs which implies default visibility",
6288                decl, "dllimport");
6289       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6290                && lookup_attribute ("dllexport", attributes))
6291         error ("%qD was declared %qs which implies default visibility",
6292                decl, "dllexport");
6293     }
6294
6295   DECL_VISIBILITY (decl) = vis;
6296   DECL_VISIBILITY_SPECIFIED (decl) = 1;
6297
6298   /* Go ahead and attach the attribute to the node as well.  This is needed
6299      so we can determine whether we have VISIBILITY_DEFAULT because the
6300      visibility was not specified, or because it was explicitly overridden
6301      from the containing scope.  */
6302
6303   return NULL_TREE;
6304 }
6305
6306 /* Determine the ELF symbol visibility for DECL, which is either a
6307    variable or a function.  It is an error to use this function if a
6308    definition of DECL is not available in this translation unit.
6309    Returns true if the final visibility has been determined by this
6310    function; false if the caller is free to make additional
6311    modifications.  */
6312
6313 bool
6314 c_determine_visibility (tree decl)
6315 {
6316   gcc_assert (TREE_CODE (decl) == VAR_DECL
6317               || TREE_CODE (decl) == FUNCTION_DECL);
6318
6319   /* If the user explicitly specified the visibility with an
6320      attribute, honor that.  DECL_VISIBILITY will have been set during
6321      the processing of the attribute.  We check for an explicit
6322      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6323      to distinguish the use of an attribute from the use of a "#pragma
6324      GCC visibility push(...)"; in the latter case we still want other
6325      considerations to be able to overrule the #pragma.  */
6326   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6327       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6328           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6329               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6330     return true;
6331
6332   /* Set default visibility to whatever the user supplied with
6333      visibility_specified depending on #pragma GCC visibility.  */
6334   if (!DECL_VISIBILITY_SPECIFIED (decl))
6335     {
6336       DECL_VISIBILITY (decl) = default_visibility;
6337       DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6338     }
6339   return false;
6340 }
6341
6342 /* Handle an "tls_model" attribute; arguments as in
6343    struct attribute_spec.handler.  */
6344
6345 static tree
6346 handle_tls_model_attribute (tree *node, tree name, tree args,
6347                             int ARG_UNUSED (flags), bool *no_add_attrs)
6348 {
6349   tree id;
6350   tree decl = *node;
6351   enum tls_model kind;
6352
6353   *no_add_attrs = true;
6354
6355   if (!DECL_THREAD_LOCAL_P (decl))
6356     {
6357       warning (OPT_Wattributes, "%qE attribute ignored", name);
6358       return NULL_TREE;
6359     }
6360
6361   kind = DECL_TLS_MODEL (decl);
6362   id = TREE_VALUE (args);
6363   if (TREE_CODE (id) != STRING_CST)
6364     {
6365       error ("tls_model argument not a string");
6366       return NULL_TREE;
6367     }
6368
6369   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6370     kind = TLS_MODEL_LOCAL_EXEC;
6371   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6372     kind = TLS_MODEL_INITIAL_EXEC;
6373   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6374     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6375   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6376     kind = TLS_MODEL_GLOBAL_DYNAMIC;
6377   else
6378     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6379
6380   DECL_TLS_MODEL (decl) = kind;
6381   return NULL_TREE;
6382 }
6383
6384 /* Handle a "no_instrument_function" attribute; arguments as in
6385    struct attribute_spec.handler.  */
6386
6387 static tree
6388 handle_no_instrument_function_attribute (tree *node, tree name,
6389                                          tree ARG_UNUSED (args),
6390                                          int ARG_UNUSED (flags),
6391                                          bool *no_add_attrs)
6392 {
6393   tree decl = *node;
6394
6395   if (TREE_CODE (decl) != FUNCTION_DECL)
6396     {
6397       error ("%J%qE attribute applies only to functions", decl, name);
6398       *no_add_attrs = true;
6399     }
6400   else if (DECL_INITIAL (decl))
6401     {
6402       error ("%Jcan%'t set %qE attribute after definition", decl, name);
6403       *no_add_attrs = true;
6404     }
6405   else
6406     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6407
6408   return NULL_TREE;
6409 }
6410
6411 /* Handle a "malloc" attribute; arguments as in
6412    struct attribute_spec.handler.  */
6413
6414 static tree
6415 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6416                          int ARG_UNUSED (flags), bool *no_add_attrs)
6417 {
6418   if (TREE_CODE (*node) == FUNCTION_DECL
6419       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6420     DECL_IS_MALLOC (*node) = 1;
6421   else
6422     {
6423       warning (OPT_Wattributes, "%qE attribute ignored", name);
6424       *no_add_attrs = true;
6425     }
6426
6427   return NULL_TREE;
6428 }
6429
6430 /* Handle a "alloc_size" attribute; arguments as in
6431    struct attribute_spec.handler.  */
6432
6433 static tree
6434 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6435                              int ARG_UNUSED (flags), bool *no_add_attrs)
6436 {
6437   unsigned arg_count = type_num_arguments (*node);
6438   for (; args; args = TREE_CHAIN (args))
6439     {
6440       tree position = TREE_VALUE (args);
6441
6442       if (TREE_CODE (position) != INTEGER_CST
6443           || TREE_INT_CST_HIGH (position)
6444           || TREE_INT_CST_LOW (position) < 1
6445           || TREE_INT_CST_LOW (position) > arg_count )
6446         {
6447           warning (OPT_Wattributes,
6448                    "alloc_size parameter outside range");
6449           *no_add_attrs = true;
6450           return NULL_TREE;
6451         }
6452     }
6453   return NULL_TREE;
6454 }
6455
6456 /* Handle a "returns_twice" attribute; arguments as in
6457    struct attribute_spec.handler.  */
6458
6459 static tree
6460 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6461                          int ARG_UNUSED (flags), bool *no_add_attrs)
6462 {
6463   if (TREE_CODE (*node) == FUNCTION_DECL)
6464     DECL_IS_RETURNS_TWICE (*node) = 1;
6465   else
6466     {
6467       warning (OPT_Wattributes, "%qE attribute ignored", name);
6468       *no_add_attrs = true;
6469     }
6470
6471   return NULL_TREE;
6472 }
6473
6474 /* Handle a "no_limit_stack" attribute; arguments as in
6475    struct attribute_spec.handler.  */
6476
6477 static tree
6478 handle_no_limit_stack_attribute (tree *node, tree name,
6479                                  tree ARG_UNUSED (args),
6480                                  int ARG_UNUSED (flags),
6481                                  bool *no_add_attrs)
6482 {
6483   tree decl = *node;
6484
6485   if (TREE_CODE (decl) != FUNCTION_DECL)
6486     {
6487       error ("%J%qE attribute applies only to functions", decl, name);
6488       *no_add_attrs = true;
6489     }
6490   else if (DECL_INITIAL (decl))
6491     {
6492       error ("%Jcan%'t set %qE attribute after definition", decl, name);
6493       *no_add_attrs = true;
6494     }
6495   else
6496     DECL_NO_LIMIT_STACK (decl) = 1;
6497
6498   return NULL_TREE;
6499 }
6500
6501 /* Handle a "pure" attribute; arguments as in
6502    struct attribute_spec.handler.  */
6503
6504 static tree
6505 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6506                        int ARG_UNUSED (flags), bool *no_add_attrs)
6507 {
6508   if (TREE_CODE (*node) == FUNCTION_DECL)
6509     DECL_PURE_P (*node) = 1;
6510   /* ??? TODO: Support types.  */
6511   else
6512     {
6513       warning (OPT_Wattributes, "%qE attribute ignored", name);
6514       *no_add_attrs = true;
6515     }
6516
6517   return NULL_TREE;
6518 }
6519
6520 /* Handle a "no vops" attribute; arguments as in
6521    struct attribute_spec.handler.  */
6522
6523 static tree
6524 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6525                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6526                          bool *ARG_UNUSED (no_add_attrs))
6527 {
6528   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6529   DECL_IS_NOVOPS (*node) = 1;
6530   return NULL_TREE;
6531 }
6532
6533 /* Handle a "deprecated" attribute; arguments as in
6534    struct attribute_spec.handler.  */
6535
6536 static tree
6537 handle_deprecated_attribute (tree *node, tree name,
6538                              tree ARG_UNUSED (args), int flags,
6539                              bool *no_add_attrs)
6540 {
6541   tree type = NULL_TREE;
6542   int warn = 0;
6543   tree what = NULL_TREE;
6544
6545   if (DECL_P (*node))
6546     {
6547       tree decl = *node;
6548       type = TREE_TYPE (decl);
6549
6550       if (TREE_CODE (decl) == TYPE_DECL
6551           || TREE_CODE (decl) == PARM_DECL
6552           || TREE_CODE (decl) == VAR_DECL
6553           || TREE_CODE (decl) == FUNCTION_DECL
6554           || TREE_CODE (decl) == FIELD_DECL)
6555         TREE_DEPRECATED (decl) = 1;
6556       else
6557         warn = 1;
6558     }
6559   else if (TYPE_P (*node))
6560     {
6561       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6562         *node = build_variant_type_copy (*node);
6563       TREE_DEPRECATED (*node) = 1;
6564       type = *node;
6565     }
6566   else
6567     warn = 1;
6568
6569   if (warn)
6570     {
6571       *no_add_attrs = true;
6572       if (type && TYPE_NAME (type))
6573         {
6574           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6575             what = TYPE_NAME (*node);
6576           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6577                    && DECL_NAME (TYPE_NAME (type)))
6578             what = DECL_NAME (TYPE_NAME (type));
6579         }
6580       if (what)
6581         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6582       else
6583         warning (OPT_Wattributes, "%qE attribute ignored", name);
6584     }
6585
6586   return NULL_TREE;
6587 }
6588
6589 /* Handle a "vector_size" attribute; arguments as in
6590    struct attribute_spec.handler.  */
6591
6592 static tree
6593 handle_vector_size_attribute (tree *node, tree name, tree args,
6594                               int ARG_UNUSED (flags),
6595                               bool *no_add_attrs)
6596 {
6597   unsigned HOST_WIDE_INT vecsize, nunits;
6598   enum machine_mode orig_mode;
6599   tree type = *node, new_type, size;
6600
6601   *no_add_attrs = true;
6602
6603   size = TREE_VALUE (args);
6604
6605   if (!host_integerp (size, 1))
6606     {
6607       warning (OPT_Wattributes, "%qE attribute ignored", name);
6608       return NULL_TREE;
6609     }
6610
6611   /* Get the vector size (in bytes).  */
6612   vecsize = tree_low_cst (size, 1);
6613
6614   /* We need to provide for vector pointers, vector arrays, and
6615      functions returning vectors.  For example:
6616
6617        __attribute__((vector_size(16))) short *foo;
6618
6619      In this case, the mode is SI, but the type being modified is
6620      HI, so we need to look further.  */
6621
6622   while (POINTER_TYPE_P (type)
6623          || TREE_CODE (type) == FUNCTION_TYPE
6624          || TREE_CODE (type) == METHOD_TYPE
6625          || TREE_CODE (type) == ARRAY_TYPE
6626          || TREE_CODE (type) == OFFSET_TYPE)
6627     type = TREE_TYPE (type);
6628
6629   /* Get the mode of the type being modified.  */
6630   orig_mode = TYPE_MODE (type);
6631
6632   if ((!INTEGRAL_TYPE_P (type)
6633        && !SCALAR_FLOAT_TYPE_P (type)
6634        && !FIXED_POINT_TYPE_P (type))
6635       || (!SCALAR_FLOAT_MODE_P (orig_mode)
6636           && GET_MODE_CLASS (orig_mode) != MODE_INT
6637           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6638       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
6639     {
6640       error ("invalid vector type for attribute %qE", name);
6641       return NULL_TREE;
6642     }
6643
6644   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6645     {
6646       error ("vector size not an integral multiple of component size");
6647       return NULL;
6648     }
6649
6650   if (vecsize == 0)
6651     {
6652       error ("zero vector size");
6653       return NULL;
6654     }
6655
6656   /* Calculate how many units fit in the vector.  */
6657   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6658   if (nunits & (nunits - 1))
6659     {
6660       error ("number of components of the vector not a power of two");
6661       return NULL_TREE;
6662     }
6663
6664   new_type = build_vector_type (type, nunits);
6665
6666   /* Build back pointers if needed.  */
6667   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6668
6669   return NULL_TREE;
6670 }
6671
6672 /* Handle the "nonnull" attribute.  */
6673 static tree
6674 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6675                           tree args, int ARG_UNUSED (flags),
6676                           bool *no_add_attrs)
6677 {
6678   tree type = *node;
6679   unsigned HOST_WIDE_INT attr_arg_num;
6680
6681   /* If no arguments are specified, all pointer arguments should be
6682      non-null.  Verify a full prototype is given so that the arguments
6683      will have the correct types when we actually check them later.  */
6684   if (!args)
6685     {
6686       if (!TYPE_ARG_TYPES (type))
6687         {
6688           error ("nonnull attribute without arguments on a non-prototype");
6689           *no_add_attrs = true;
6690         }
6691       return NULL_TREE;
6692     }
6693
6694   /* Argument list specified.  Verify that each argument number references
6695      a pointer argument.  */
6696   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6697     {
6698       tree argument;
6699       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6700
6701       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6702         {
6703           error ("nonnull argument has invalid operand number (argument %lu)",
6704                  (unsigned long) attr_arg_num);
6705           *no_add_attrs = true;
6706           return NULL_TREE;
6707         }
6708
6709       argument = TYPE_ARG_TYPES (type);
6710       if (argument)
6711         {
6712           for (ck_num = 1; ; ck_num++)
6713             {
6714               if (!argument || ck_num == arg_num)
6715                 break;
6716               argument = TREE_CHAIN (argument);
6717             }
6718
6719           if (!argument
6720               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6721             {
6722               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6723                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
6724               *no_add_attrs = true;
6725               return NULL_TREE;
6726             }
6727
6728           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6729             {
6730               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6731                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
6732               *no_add_attrs = true;
6733               return NULL_TREE;
6734             }
6735         }
6736     }
6737
6738   return NULL_TREE;
6739 }
6740
6741 /* Check the argument list of a function call for null in argument slots
6742    that are marked as requiring a non-null pointer argument.  The NARGS
6743    arguments are passed in the array ARGARRAY.
6744 */
6745
6746 static void
6747 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6748 {
6749   tree a, args;
6750   int i;
6751
6752   for (a = attrs; a; a = TREE_CHAIN (a))
6753     {
6754       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6755         {
6756           args = TREE_VALUE (a);
6757
6758           /* Walk the argument list.  If we encounter an argument number we
6759              should check for non-null, do it.  If the attribute has no args,
6760              then every pointer argument is checked (in which case the check
6761              for pointer type is done in check_nonnull_arg).  */
6762           for (i = 0; i < nargs; i++)
6763             {
6764               if (!args || nonnull_check_p (args, i + 1))
6765                 check_function_arguments_recurse (check_nonnull_arg, NULL,
6766                                                   argarray[i],
6767                                                   i + 1);
6768             }
6769         }
6770     }
6771 }
6772
6773 /* Check that the Nth argument of a function call (counting backwards
6774    from the end) is a (pointer)0.  The NARGS arguments are passed in the
6775    array ARGARRAY.  */
6776
6777 static void
6778 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6779 {
6780   tree attr = lookup_attribute ("sentinel", attrs);
6781
6782   if (attr)
6783     {
6784       int len = 0;
6785       int pos = 0;
6786       tree sentinel;
6787
6788       /* Skip over the named arguments.  */
6789       while (typelist && len < nargs)
6790         {
6791           typelist = TREE_CHAIN (typelist);
6792           len++;
6793         }
6794
6795       if (TREE_VALUE (attr))
6796         {
6797           tree p = TREE_VALUE (TREE_VALUE (attr));
6798           pos = TREE_INT_CST_LOW (p);
6799         }
6800
6801       /* The sentinel must be one of the varargs, i.e.
6802          in position >= the number of fixed arguments.  */
6803       if ((nargs - 1 - pos) < len)
6804         {
6805           warning (OPT_Wformat,
6806                    "not enough variable arguments to fit a sentinel");
6807           return;
6808         }
6809
6810       /* Validate the sentinel.  */
6811       sentinel = argarray[nargs - 1 - pos];
6812       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6813            || !integer_zerop (sentinel))
6814           /* Although __null (in C++) is only an integer we allow it
6815              nevertheless, as we are guaranteed that it's exactly
6816              as wide as a pointer, and we don't want to force
6817              users to cast the NULL they have written there.
6818              We warn with -Wstrict-null-sentinel, though.  */
6819           && (warn_strict_null_sentinel || null_node != sentinel))
6820         warning (OPT_Wformat, "missing sentinel in function call");
6821     }
6822 }
6823
6824 /* Helper for check_function_nonnull; given a list of operands which
6825    must be non-null in ARGS, determine if operand PARAM_NUM should be
6826    checked.  */
6827
6828 static bool
6829 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6830 {
6831   unsigned HOST_WIDE_INT arg_num = 0;
6832
6833   for (; args; args = TREE_CHAIN (args))
6834     {
6835       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6836
6837       gcc_assert (found);
6838
6839       if (arg_num == param_num)
6840         return true;
6841     }
6842   return false;
6843 }
6844
6845 /* Check that the function argument PARAM (which is operand number
6846    PARAM_NUM) is non-null.  This is called by check_function_nonnull
6847    via check_function_arguments_recurse.  */
6848
6849 static void
6850 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6851                    unsigned HOST_WIDE_INT param_num)
6852 {
6853   /* Just skip checking the argument if it's not a pointer.  This can
6854      happen if the "nonnull" attribute was given without an operand
6855      list (which means to check every pointer argument).  */
6856
6857   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6858     return;
6859
6860   if (integer_zerop (param))
6861     warning (OPT_Wnonnull, "null argument where non-null required "
6862              "(argument %lu)", (unsigned long) param_num);
6863 }
6864
6865 /* Helper for nonnull attribute handling; fetch the operand number
6866    from the attribute argument list.  */
6867
6868 static bool
6869 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6870 {
6871   /* Verify the arg number is a constant.  */
6872   if (TREE_CODE (arg_num_expr) != INTEGER_CST
6873       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6874     return false;
6875
6876   *valp = TREE_INT_CST_LOW (arg_num_expr);
6877   return true;
6878 }
6879
6880 /* Handle a "nothrow" attribute; arguments as in
6881    struct attribute_spec.handler.  */
6882
6883 static tree
6884 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6885                           int ARG_UNUSED (flags), bool *no_add_attrs)
6886 {
6887   if (TREE_CODE (*node) == FUNCTION_DECL)
6888     TREE_NOTHROW (*node) = 1;
6889   /* ??? TODO: Support types.  */
6890   else
6891     {
6892       warning (OPT_Wattributes, "%qE attribute ignored", name);
6893       *no_add_attrs = true;
6894     }
6895
6896   return NULL_TREE;
6897 }
6898
6899 /* Handle a "cleanup" attribute; arguments as in
6900    struct attribute_spec.handler.  */
6901
6902 static tree
6903 handle_cleanup_attribute (tree *node, tree name, tree args,
6904                           int ARG_UNUSED (flags), bool *no_add_attrs)
6905 {
6906   tree decl = *node;
6907   tree cleanup_id, cleanup_decl;
6908
6909   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6910      for global destructors in C++.  This requires infrastructure that
6911      we don't have generically at the moment.  It's also not a feature
6912      we'd be missing too much, since we do have attribute constructor.  */
6913   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6914     {
6915       warning (OPT_Wattributes, "%qE attribute ignored", name);
6916       *no_add_attrs = true;
6917       return NULL_TREE;
6918     }
6919
6920   /* Verify that the argument is a function in scope.  */
6921   /* ??? We could support pointers to functions here as well, if
6922      that was considered desirable.  */
6923   cleanup_id = TREE_VALUE (args);
6924   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6925     {
6926       error ("cleanup argument not an identifier");
6927       *no_add_attrs = true;
6928       return NULL_TREE;
6929     }
6930   cleanup_decl = lookup_name (cleanup_id);
6931   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6932     {
6933       error ("cleanup argument not a function");
6934       *no_add_attrs = true;
6935       return NULL_TREE;
6936     }
6937
6938   /* That the function has proper type is checked with the
6939      eventual call to build_function_call.  */
6940
6941   return NULL_TREE;
6942 }
6943
6944 /* Handle a "warn_unused_result" attribute.  No special handling.  */
6945
6946 static tree
6947 handle_warn_unused_result_attribute (tree *node, tree name,
6948                                tree ARG_UNUSED (args),
6949                                int ARG_UNUSED (flags), bool *no_add_attrs)
6950 {
6951   /* Ignore the attribute for functions not returning any value.  */
6952   if (VOID_TYPE_P (TREE_TYPE (*node)))
6953     {
6954       warning (OPT_Wattributes, "%qE attribute ignored", name);
6955       *no_add_attrs = true;
6956     }
6957
6958   return NULL_TREE;
6959 }
6960
6961 /* Handle a "sentinel" attribute.  */
6962
6963 static tree
6964 handle_sentinel_attribute (tree *node, tree name, tree args,
6965                            int ARG_UNUSED (flags), bool *no_add_attrs)
6966 {
6967   tree params = TYPE_ARG_TYPES (*node);
6968
6969   if (!params)
6970     {
6971       warning (OPT_Wattributes,
6972                "%qE attribute requires prototypes with named arguments", name);
6973       *no_add_attrs = true;
6974     }
6975   else
6976     {
6977       while (TREE_CHAIN (params))
6978         params = TREE_CHAIN (params);
6979
6980       if (VOID_TYPE_P (TREE_VALUE (params)))
6981         {
6982           warning (OPT_Wattributes,
6983                    "%qE attribute only applies to variadic functions", name);
6984           *no_add_attrs = true;
6985         }
6986     }
6987
6988   if (args)
6989     {
6990       tree position = TREE_VALUE (args);
6991
6992       if (TREE_CODE (position) != INTEGER_CST)
6993         {
6994           warning (OPT_Wattributes,
6995                    "requested position is not an integer constant");
6996           *no_add_attrs = true;
6997         }
6998       else
6999         {
7000           if (tree_int_cst_lt (position, integer_zero_node))
7001             {
7002               warning (OPT_Wattributes,
7003                        "requested position is less than zero");
7004               *no_add_attrs = true;
7005             }
7006         }
7007     }
7008
7009   return NULL_TREE;
7010 }
7011
7012 /* Handle a "type_generic" attribute.  */
7013
7014 static tree
7015 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7016                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7017                                bool * ARG_UNUSED (no_add_attrs))
7018 {
7019   tree params;
7020
7021   /* Ensure we have a function type.  */
7022   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7023
7024   params = TYPE_ARG_TYPES (*node);
7025   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7026     params = TREE_CHAIN (params);
7027
7028   /* Ensure we have a variadic function.  */
7029   gcc_assert (!params);
7030
7031   return NULL_TREE;
7032 }
7033
7034 /* For handling "option" attribute. arguments as in
7035    struct attribute_spec.handler.  */
7036
7037 static tree
7038 handle_option_attribute (tree *node, tree name, tree args, int flags,
7039                          bool *no_add_attrs)
7040 {
7041   /* Ensure we have a function type.  */
7042   if (TREE_CODE (*node) != FUNCTION_DECL)
7043     {
7044       warning (OPT_Wattributes, "%qE attribute ignored", name);
7045       *no_add_attrs = true;
7046     }
7047   else if (targetm.target_option.valid_attribute_p
7048            == default_target_option_valid_attribute_p)
7049     {
7050       warning (OPT_Wattributes,
7051                "%qE attribute is not supported on this machine",
7052                name);
7053       *no_add_attrs = true;
7054     }
7055   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7056                                                       flags))
7057     *no_add_attrs = true;
7058
7059   return NULL_TREE;
7060 }
7061
7062 /* Arguments being collected for optimization.  */
7063 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
7064 DEF_VEC_P(const_char_p);
7065 DEF_VEC_ALLOC_P(const_char_p, gc);
7066 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7067
7068
7069 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7070    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
7071    false for #pragma GCC optimize.  */
7072
7073 bool
7074 parse_optimize_options (tree args, bool attr_p)
7075 {
7076   bool ret = true;
7077   unsigned opt_argc;
7078   unsigned i;
7079   const char **opt_argv;
7080   tree ap;
7081
7082   /* Build up argv vector.  Just in case the string is stored away, use garbage
7083      collected strings.  */
7084   VEC_truncate (const_char_p, optimize_args, 0);
7085   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7086
7087   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7088     {
7089       tree value = TREE_VALUE (ap);
7090
7091       if (TREE_CODE (value) == INTEGER_CST)
7092         {
7093           char buffer[20];
7094           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7095           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7096         }
7097
7098       else if (TREE_CODE (value) == STRING_CST)
7099         {
7100           /* Split string into multiple substrings.  */
7101           size_t len = TREE_STRING_LENGTH (value);
7102           char *p = ASTRDUP (TREE_STRING_POINTER (value));
7103           char *end = p + len;
7104           char *comma;
7105           char *next_p = p;
7106
7107           while (next_p != NULL)
7108             {
7109               size_t len2;
7110               char *q, *r;
7111
7112               p = next_p;
7113               comma = strchr (p, ',');
7114               if (comma)
7115                 {
7116                   len2 = comma - p;
7117                   *comma = '\0';
7118                   next_p = comma+1;
7119                 }
7120               else
7121                 {
7122                   len2 = end - p;
7123                   next_p = NULL;
7124                 }
7125
7126               r = q = (char *) ggc_alloc (len2 + 3);
7127
7128               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7129                  options.  */
7130               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7131                 {
7132                   ret = false;
7133                   if (attr_p)
7134                     warning (OPT_Wattributes,
7135                              "Bad option %s to optimize attribute.", p);
7136                   else
7137                     warning (OPT_Wpragmas,
7138                              "Bad option %s to pragma attribute", p);
7139                   continue;
7140                 }
7141
7142               if (*p != '-')
7143                 {
7144                   *r++ = '-';
7145
7146                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7147                      itself is -Os, and any other switch begins with a -f.  */
7148                   if ((*p >= '0' && *p <= '9')
7149                       || (p[0] == 's' && p[1] == '\0'))
7150                     *r++ = 'O';
7151                   else if (*p != 'O')
7152                     *r++ = 'f';
7153                 }
7154
7155               memcpy (r, p, len2);
7156               r[len2] = '\0';
7157               VEC_safe_push (const_char_p, gc, optimize_args, q);
7158             }
7159
7160         }
7161     }
7162
7163   opt_argc = VEC_length (const_char_p, optimize_args);
7164   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7165
7166   for (i = 1; i < opt_argc; i++)
7167     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7168
7169   /* Now parse the options.  */
7170   decode_options (opt_argc, opt_argv);
7171
7172   VEC_truncate (const_char_p, optimize_args, 0);
7173   return ret;
7174 }
7175
7176 /* For handling "optimize" attribute. arguments as in
7177    struct attribute_spec.handler.  */
7178
7179 static tree
7180 handle_optimize_attribute (tree *node, tree name, tree args,
7181                            int ARG_UNUSED (flags), bool *no_add_attrs)
7182 {
7183   /* Ensure we have a function type.  */
7184   if (TREE_CODE (*node) != FUNCTION_DECL)
7185     {
7186       warning (OPT_Wattributes, "%qE attribute ignored", name);
7187       *no_add_attrs = true;
7188     }
7189   else
7190     {
7191       struct cl_optimization cur_opts;
7192       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7193
7194       /* Save current options.  */
7195       cl_optimization_save (&cur_opts);
7196
7197       /* If we previously had some optimization options, use them as the
7198          default.  */
7199       if (old_opts)
7200         cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7201
7202       /* Parse options, and update the vector.  */
7203       parse_optimize_options (args, true);
7204       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7205         = build_optimization_node ();
7206
7207       /* Restore current options.  */
7208       cl_optimization_restore (&cur_opts);
7209     }
7210
7211   return NULL_TREE;
7212 }
7213 \f
7214 /* Check for valid arguments being passed to a function.
7215    ATTRS is a list of attributes.  There are NARGS arguments in the array
7216    ARGARRAY.  TYPELIST is the list of argument types for the function.
7217  */
7218 void
7219 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7220 {
7221   /* Check for null being passed in a pointer argument that must be
7222      non-null.  We also need to do this if format checking is enabled.  */
7223
7224   if (warn_nonnull)
7225     check_function_nonnull (attrs, nargs, argarray);
7226
7227   /* Check for errors in format strings.  */
7228
7229   if (warn_format || warn_missing_format_attribute)
7230     check_function_format (attrs, nargs, argarray);
7231
7232   if (warn_format)
7233     check_function_sentinel (attrs, nargs, argarray, typelist);
7234 }
7235
7236 /* Generic argument checking recursion routine.  PARAM is the argument to
7237    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
7238    once the argument is resolved.  CTX is context for the callback.  */
7239 void
7240 check_function_arguments_recurse (void (*callback)
7241                                   (void *, tree, unsigned HOST_WIDE_INT),
7242                                   void *ctx, tree param,
7243                                   unsigned HOST_WIDE_INT param_num)
7244 {
7245   if (CONVERT_EXPR_P (param)
7246       && (TYPE_PRECISION (TREE_TYPE (param))
7247           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7248     {
7249       /* Strip coercion.  */
7250       check_function_arguments_recurse (callback, ctx,
7251                                         TREE_OPERAND (param, 0), param_num);
7252       return;
7253     }
7254
7255   if (TREE_CODE (param) == CALL_EXPR)
7256     {
7257       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7258       tree attrs;
7259       bool found_format_arg = false;
7260
7261       /* See if this is a call to a known internationalization function
7262          that modifies a format arg.  Such a function may have multiple
7263          format_arg attributes (for example, ngettext).  */
7264
7265       for (attrs = TYPE_ATTRIBUTES (type);
7266            attrs;
7267            attrs = TREE_CHAIN (attrs))
7268         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7269           {
7270             tree inner_arg;
7271             tree format_num_expr;
7272             int format_num;
7273             int i;
7274             call_expr_arg_iterator iter;
7275
7276             /* Extract the argument number, which was previously checked
7277                to be valid.  */
7278             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7279
7280             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7281                         && !TREE_INT_CST_HIGH (format_num_expr));
7282
7283             format_num = TREE_INT_CST_LOW (format_num_expr);
7284
7285             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7286                  inner_arg != 0;
7287                  inner_arg = next_call_expr_arg (&iter), i++)
7288               if (i == format_num)
7289                 {
7290                   check_function_arguments_recurse (callback, ctx,
7291                                                     inner_arg, param_num);
7292                   found_format_arg = true;
7293                   break;
7294                 }
7295           }
7296
7297       /* If we found a format_arg attribute and did a recursive check,
7298          we are done with checking this argument.  Otherwise, we continue
7299          and this will be considered a non-literal.  */
7300       if (found_format_arg)
7301         return;
7302     }
7303
7304   if (TREE_CODE (param) == COND_EXPR)
7305     {
7306       /* Check both halves of the conditional expression.  */
7307       check_function_arguments_recurse (callback, ctx,
7308                                         TREE_OPERAND (param, 1), param_num);
7309       check_function_arguments_recurse (callback, ctx,
7310                                         TREE_OPERAND (param, 2), param_num);
7311       return;
7312     }
7313
7314   (*callback) (ctx, param, param_num);
7315 }
7316
7317 /* Checks the number of arguments NARGS against the required number
7318    REQUIRED and issues an error if there is a mismatch.  Returns true
7319    if the number of arguments is correct, otherwise false.  */
7320
7321 static bool
7322 validate_nargs (tree fndecl, int nargs, int required)
7323 {
7324   if (nargs < required)
7325     {
7326       error ("not enough arguments to function %qE", fndecl);
7327       return false;
7328     }
7329   else if (nargs > required)
7330     {
7331       error ("too many arguments to function %qE", fndecl);
7332       return false;
7333     }
7334   return true;
7335 }
7336
7337 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7338    Returns false if there was an error, otherwise true.  */
7339
7340 bool
7341 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7342 {
7343   if (!DECL_BUILT_IN (fndecl)
7344       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7345     return true;
7346
7347   switch (DECL_FUNCTION_CODE (fndecl))
7348     {
7349     case BUILT_IN_CONSTANT_P:
7350       return validate_nargs (fndecl, nargs, 1);
7351
7352     case BUILT_IN_ISFINITE:
7353     case BUILT_IN_ISINF:
7354     case BUILT_IN_ISINF_SIGN:
7355     case BUILT_IN_ISNAN:
7356     case BUILT_IN_ISNORMAL:
7357       if (validate_nargs (fndecl, nargs, 1))
7358         {
7359           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7360             {
7361               error ("non-floating-point argument in call to "
7362                      "function %qE", fndecl);
7363               return false;
7364             }
7365           return true;
7366         }
7367       return false;
7368
7369     case BUILT_IN_ISGREATER:
7370     case BUILT_IN_ISGREATEREQUAL:
7371     case BUILT_IN_ISLESS:
7372     case BUILT_IN_ISLESSEQUAL:
7373     case BUILT_IN_ISLESSGREATER:
7374     case BUILT_IN_ISUNORDERED:
7375       if (validate_nargs (fndecl, nargs, 2))
7376         {
7377           enum tree_code code0, code1;
7378           code0 = TREE_CODE (TREE_TYPE (args[0]));
7379           code1 = TREE_CODE (TREE_TYPE (args[1]));
7380           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7381                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7382                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7383             {
7384               error ("non-floating-point arguments in call to "
7385                      "function %qE", fndecl);
7386               return false;
7387             }
7388           return true;
7389         }
7390       return false;
7391
7392     case BUILT_IN_FPCLASSIFY:
7393       if (validate_nargs (fndecl, nargs, 6))
7394         {
7395           unsigned i;
7396
7397           for (i=0; i<5; i++)
7398             if (TREE_CODE (args[i]) != INTEGER_CST)
7399               {
7400                 error ("non-const integer argument %u in call to function %qE",
7401                        i+1, fndecl);
7402                 return false;
7403               }
7404
7405           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7406             {
7407               error ("non-floating-point argument in call to function %qE",
7408                      fndecl);
7409               return false;
7410             }
7411           return true;
7412         }
7413       return false;
7414
7415     default:
7416       return true;
7417     }
7418 }
7419
7420 /* Function to help qsort sort FIELD_DECLs by name order.  */
7421
7422 int
7423 field_decl_cmp (const void *x_p, const void *y_p)
7424 {
7425   const tree *const x = (const tree *const) x_p;
7426   const tree *const y = (const tree *const) y_p;
7427
7428   if (DECL_NAME (*x) == DECL_NAME (*y))
7429     /* A nontype is "greater" than a type.  */
7430     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7431   if (DECL_NAME (*x) == NULL_TREE)
7432     return -1;
7433   if (DECL_NAME (*y) == NULL_TREE)
7434     return 1;
7435   if (DECL_NAME (*x) < DECL_NAME (*y))
7436     return -1;
7437   return 1;
7438 }
7439
7440 static struct {
7441   gt_pointer_operator new_value;
7442   void *cookie;
7443 } resort_data;
7444
7445 /* This routine compares two fields like field_decl_cmp but using the
7446 pointer operator in resort_data.  */
7447
7448 static int
7449 resort_field_decl_cmp (const void *x_p, const void *y_p)
7450 {
7451   const tree *const x = (const tree *const) x_p;
7452   const tree *const y = (const tree *const) y_p;
7453
7454   if (DECL_NAME (*x) == DECL_NAME (*y))
7455     /* A nontype is "greater" than a type.  */
7456     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7457   if (DECL_NAME (*x) == NULL_TREE)
7458     return -1;
7459   if (DECL_NAME (*y) == NULL_TREE)
7460     return 1;
7461   {
7462     tree d1 = DECL_NAME (*x);
7463     tree d2 = DECL_NAME (*y);
7464     resort_data.new_value (&d1, resort_data.cookie);
7465     resort_data.new_value (&d2, resort_data.cookie);
7466     if (d1 < d2)
7467       return -1;
7468   }
7469   return 1;
7470 }
7471
7472 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
7473
7474 void
7475 resort_sorted_fields (void *obj,
7476                       void * ARG_UNUSED (orig_obj),
7477                       gt_pointer_operator new_value,
7478                       void *cookie)
7479 {
7480   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7481   resort_data.new_value = new_value;
7482   resort_data.cookie = cookie;
7483   qsort (&sf->elts[0], sf->len, sizeof (tree),
7484          resort_field_decl_cmp);
7485 }
7486
7487 /* Subroutine of c_parse_error.
7488    Return the result of concatenating LHS and RHS. RHS is really
7489    a string literal, its first character is indicated by RHS_START and
7490    RHS_SIZE is its length (including the terminating NUL character).
7491
7492    The caller is responsible for deleting the returned pointer.  */
7493
7494 static char *
7495 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7496 {
7497   const int lhs_size = strlen (lhs);
7498   char *result = XNEWVEC (char, lhs_size + rhs_size);
7499   strncpy (result, lhs, lhs_size);
7500   strncpy (result + lhs_size, rhs_start, rhs_size);
7501   return result;
7502 }
7503
7504 /* Issue the error given by GMSGID, indicating that it occurred before
7505    TOKEN, which had the associated VALUE.  */
7506
7507 void
7508 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7509 {
7510 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7511
7512   char *message = NULL;
7513
7514   if (token == CPP_EOF)
7515     message = catenate_messages (gmsgid, " at end of input");
7516   else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7517            || token == CPP_CHAR32)
7518     {
7519       unsigned int val = TREE_INT_CST_LOW (value);
7520       const char *prefix;
7521
7522       switch (token)
7523         {
7524         default:
7525           prefix = "";
7526           break;
7527         case CPP_WCHAR:
7528           prefix = "L";
7529           break;
7530         case CPP_CHAR16:
7531           prefix = "u";
7532           break;
7533         case CPP_CHAR32:
7534           prefix = "U";
7535           break;
7536         }
7537
7538       if (val <= UCHAR_MAX && ISGRAPH (val))
7539         message = catenate_messages (gmsgid, " before %s'%c'");
7540       else
7541         message = catenate_messages (gmsgid, " before %s'\\x%x'");
7542
7543       error (message, prefix, val);
7544       free (message);
7545       message = NULL;
7546     }
7547   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7548            || token == CPP_STRING32)
7549     message = catenate_messages (gmsgid, " before string constant");
7550   else if (token == CPP_NUMBER)
7551     message = catenate_messages (gmsgid, " before numeric constant");
7552   else if (token == CPP_NAME)
7553     {
7554       message = catenate_messages (gmsgid, " before %qE");
7555       error (message, value);
7556       free (message);
7557       message = NULL;
7558     }
7559   else if (token == CPP_PRAGMA)
7560     message = catenate_messages (gmsgid, " before %<#pragma%>");
7561   else if (token == CPP_PRAGMA_EOL)
7562     message = catenate_messages (gmsgid, " before end of line");
7563   else if (token < N_TTYPES)
7564     {
7565       message = catenate_messages (gmsgid, " before %qs token");
7566       error (message, cpp_type2name (token));
7567       free (message);
7568       message = NULL;
7569     }
7570   else
7571     error (gmsgid);
7572
7573   if (message)
7574     {
7575       error (message);
7576       free (message);
7577     }
7578 #undef catenate_messages
7579 }
7580
7581 /* Walk a gimplified function and warn for functions whose return value is
7582    ignored and attribute((warn_unused_result)) is set.  This is done before
7583    inlining, so we don't have to worry about that.  */
7584
7585 void
7586 c_warn_unused_result (gimple_seq seq)
7587 {
7588   tree fdecl, ftype;
7589   gimple_stmt_iterator i;
7590
7591   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7592     {
7593       gimple g = gsi_stmt (i);
7594
7595       switch (gimple_code (g))
7596         {
7597         case GIMPLE_BIND:
7598           c_warn_unused_result (gimple_bind_body (g));
7599           break;
7600         case GIMPLE_TRY:
7601           c_warn_unused_result (gimple_try_eval (g));
7602           c_warn_unused_result (gimple_try_cleanup (g));
7603           break;
7604         case GIMPLE_CATCH:
7605           c_warn_unused_result (gimple_catch_handler (g));
7606           break;
7607         case GIMPLE_EH_FILTER:
7608           c_warn_unused_result (gimple_eh_filter_failure (g));
7609           break;
7610
7611         case GIMPLE_CALL:
7612           if (gimple_call_lhs (g))
7613             break;
7614
7615           /* This is a naked call, as opposed to a GIMPLE_CALL with an
7616              LHS.  All calls whose value is ignored should be
7617              represented like this.  Look for the attribute.  */
7618           fdecl = gimple_call_fndecl (g);
7619           ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7620
7621           if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7622             {
7623               location_t loc = gimple_location (g);
7624
7625               if (fdecl)
7626                 warning (0, "%Hignoring return value of %qD, "
7627                          "declared with attribute warn_unused_result",
7628                          &loc, fdecl);
7629               else
7630                 warning (0, "%Hignoring return value of function "
7631                          "declared with attribute warn_unused_result",
7632                          &loc);
7633             }
7634           break;
7635
7636         default:
7637           /* Not a container, not a call, or a call whose value is used.  */
7638           break;
7639         }
7640     }
7641 }
7642
7643 /* Convert a character from the host to the target execution character
7644    set.  cpplib handles this, mostly.  */
7645
7646 HOST_WIDE_INT
7647 c_common_to_target_charset (HOST_WIDE_INT c)
7648 {
7649   /* Character constants in GCC proper are sign-extended under -fsigned-char,
7650      zero-extended under -fno-signed-char.  cpplib insists that characters
7651      and character constants are always unsigned.  Hence we must convert
7652      back and forth.  */
7653   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7654
7655   uc = cpp_host_to_exec_charset (parse_in, uc);
7656
7657   if (flag_signed_char)
7658     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7659                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7660   else
7661     return uc;
7662 }
7663
7664 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
7665    component references, with STOP_REF, or alternatively an INDIRECT_REF of
7666    NULL, at the bottom; much like the traditional rendering of offsetof as a
7667    macro.  Returns the folded and properly cast result.  */
7668
7669 static tree
7670 fold_offsetof_1 (tree expr, tree stop_ref)
7671 {
7672   enum tree_code code = PLUS_EXPR;
7673   tree base, off, t;
7674
7675   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7676     return size_zero_node;
7677
7678   switch (TREE_CODE (expr))
7679     {
7680     case ERROR_MARK:
7681       return expr;
7682
7683     case VAR_DECL:
7684       error ("cannot apply %<offsetof%> to static data member %qD", expr);
7685       return error_mark_node;
7686
7687     case CALL_EXPR:
7688     case TARGET_EXPR:
7689       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7690       return error_mark_node;
7691
7692     case INTEGER_CST:
7693       gcc_assert (integer_zerop (expr));
7694       return size_zero_node;
7695
7696     case NOP_EXPR:
7697     case INDIRECT_REF:
7698       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7699       gcc_assert (base == error_mark_node || base == size_zero_node);
7700       return base;
7701
7702     case COMPONENT_REF:
7703       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7704       if (base == error_mark_node)
7705         return base;
7706
7707       t = TREE_OPERAND (expr, 1);
7708       if (DECL_C_BIT_FIELD (t))
7709         {
7710           error ("attempt to take address of bit-field structure "
7711                  "member %qD", t);
7712           return error_mark_node;
7713         }
7714       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7715                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7716                                   / BITS_PER_UNIT));
7717       break;
7718
7719     case ARRAY_REF:
7720       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7721       if (base == error_mark_node)
7722         return base;
7723
7724       t = TREE_OPERAND (expr, 1);
7725       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7726         {
7727           code = MINUS_EXPR;
7728           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7729         }
7730       t = convert (sizetype, t);
7731       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7732       break;
7733
7734     case COMPOUND_EXPR:
7735       /* Handle static members of volatile structs.  */
7736       t = TREE_OPERAND (expr, 1);
7737       gcc_assert (TREE_CODE (t) == VAR_DECL);
7738       return fold_offsetof_1 (t, stop_ref);
7739
7740     default:
7741       gcc_unreachable ();
7742     }
7743
7744   return size_binop (code, base, off);
7745 }
7746
7747 tree
7748 fold_offsetof (tree expr, tree stop_ref)
7749 {
7750   /* Convert back from the internal sizetype to size_t.  */
7751   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7752 }
7753
7754 /* Print an error message for an invalid lvalue.  USE says
7755    how the lvalue is being used and so selects the error message.  */
7756
7757 void
7758 lvalue_error (enum lvalue_use use)
7759 {
7760   switch (use)
7761     {
7762     case lv_assign:
7763       error ("lvalue required as left operand of assignment");
7764       break;
7765     case lv_increment:
7766       error ("lvalue required as increment operand");
7767       break;
7768     case lv_decrement:
7769       error ("lvalue required as decrement operand");
7770       break;
7771     case lv_addressof:
7772       error ("lvalue required as unary %<&%> operand");
7773       break;
7774     case lv_asm:
7775       error ("lvalue required in asm statement");
7776       break;
7777     default:
7778       gcc_unreachable ();
7779     }
7780 }
7781 \f
7782 /* *PTYPE is an incomplete array.  Complete it with a domain based on
7783    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7784    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7785    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
7786
7787 int
7788 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7789 {
7790   tree maxindex, type, main_type, elt, unqual_elt;
7791   int failure = 0, quals;
7792   hashval_t hashcode = 0;
7793
7794   maxindex = size_zero_node;
7795   if (initial_value)
7796     {
7797       if (TREE_CODE (initial_value) == STRING_CST)
7798         {
7799           int eltsize
7800             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7801           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7802         }
7803       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7804         {
7805           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7806
7807           if (VEC_empty (constructor_elt, v))
7808             {
7809               if (pedantic)
7810                 failure = 3;
7811               maxindex = integer_minus_one_node;
7812             }
7813           else
7814             {
7815               tree curindex;
7816               unsigned HOST_WIDE_INT cnt;
7817               constructor_elt *ce;
7818
7819               if (VEC_index (constructor_elt, v, 0)->index)
7820                 maxindex = fold_convert (sizetype,
7821                                          VEC_index (constructor_elt,
7822                                                     v, 0)->index);
7823               curindex = maxindex;
7824
7825               for (cnt = 1;
7826                    VEC_iterate (constructor_elt, v, cnt, ce);
7827                    cnt++)
7828                 {
7829                   if (ce->index)
7830                     curindex = fold_convert (sizetype, ce->index);
7831                   else
7832                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7833
7834                   if (tree_int_cst_lt (maxindex, curindex))
7835                     maxindex = curindex;
7836                 }
7837             }
7838         }
7839       else
7840         {
7841           /* Make an error message unless that happened already.  */
7842           if (initial_value != error_mark_node)
7843             failure = 1;
7844         }
7845     }
7846   else
7847     {
7848       failure = 2;
7849       if (!do_default)
7850         return failure;
7851     }
7852
7853   type = *ptype;
7854   elt = TREE_TYPE (type);
7855   quals = TYPE_QUALS (strip_array_types (elt));
7856   if (quals == 0)
7857     unqual_elt = elt;
7858   else
7859     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7860
7861   /* Using build_distinct_type_copy and modifying things afterward instead
7862      of using build_array_type to create a new type preserves all of the
7863      TYPE_LANG_FLAG_? bits that the front end may have set.  */
7864   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7865   TREE_TYPE (main_type) = unqual_elt;
7866   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7867   layout_type (main_type);
7868
7869   /* Make sure we have the canonical MAIN_TYPE. */
7870   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7871   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7872                                     hashcode);
7873   main_type = type_hash_canon (hashcode, main_type);
7874
7875   /* Fix the canonical type.  */
7876   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7877       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7878     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7879   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7880            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7881                != TYPE_DOMAIN (main_type)))
7882     TYPE_CANONICAL (main_type)
7883       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7884                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7885   else
7886     TYPE_CANONICAL (main_type) = main_type;
7887
7888   if (quals == 0)
7889     type = main_type;
7890   else
7891     type = c_build_qualified_type (main_type, quals);
7892
7893   if (COMPLETE_TYPE_P (type)
7894       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7895       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7896     {
7897       error ("size of array is too large");
7898       /* If we proceed with the array type as it is, we'll eventually
7899          crash in tree_low_cst().  */
7900       type = error_mark_node;
7901     }
7902
7903   *ptype = type;
7904   return failure;
7905 }
7906
7907 \f
7908 /* Used to help initialize the builtin-types.def table.  When a type of
7909    the correct size doesn't exist, use error_mark_node instead of NULL.
7910    The later results in segfaults even when a decl using the type doesn't
7911    get invoked.  */
7912
7913 tree
7914 builtin_type_for_size (int size, bool unsignedp)
7915 {
7916   tree type = lang_hooks.types.type_for_size (size, unsignedp);
7917   return type ? type : error_mark_node;
7918 }
7919
7920 /* A helper function for resolve_overloaded_builtin in resolving the
7921    overloaded __sync_ builtins.  Returns a positive power of 2 if the
7922    first operand of PARAMS is a pointer to a supported data type.
7923    Returns 0 if an error is encountered.  */
7924
7925 static int
7926 sync_resolve_size (tree function, tree params)
7927 {
7928   tree type;
7929   int size;
7930
7931   if (params == NULL)
7932     {
7933       error ("too few arguments to function %qE", function);
7934       return 0;
7935     }
7936
7937   type = TREE_TYPE (TREE_VALUE (params));
7938   if (TREE_CODE (type) != POINTER_TYPE)
7939     goto incompatible;
7940
7941   type = TREE_TYPE (type);
7942   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7943     goto incompatible;
7944
7945   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7946   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7947     return size;
7948
7949  incompatible:
7950   error ("incompatible type for argument %d of %qE", 1, function);
7951   return 0;
7952 }
7953
7954 /* A helper function for resolve_overloaded_builtin.  Adds casts to
7955    PARAMS to make arguments match up with those of FUNCTION.  Drops
7956    the variadic arguments at the end.  Returns false if some error
7957    was encountered; true on success.  */
7958
7959 static bool
7960 sync_resolve_params (tree orig_function, tree function, tree params)
7961 {
7962   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7963   tree ptype;
7964   int number;
7965
7966   /* We've declared the implementation functions to use "volatile void *"
7967      as the pointer parameter, so we shouldn't get any complaints from the
7968      call to check_function_arguments what ever type the user used.  */
7969   arg_types = TREE_CHAIN (arg_types);
7970   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7971   number = 2;
7972
7973   /* For the rest of the values, we need to cast these to FTYPE, so that we
7974      don't get warnings for passing pointer types, etc.  */
7975   while (arg_types != void_list_node)
7976     {
7977       tree val;
7978
7979       params = TREE_CHAIN (params);
7980       if (params == NULL)
7981         {
7982           error ("too few arguments to function %qE", orig_function);
7983           return false;
7984         }
7985
7986       /* ??? Ideally for the first conversion we'd use convert_for_assignment
7987          so that we get warnings for anything that doesn't match the pointer
7988          type.  This isn't portable across the C and C++ front ends atm.  */
7989       val = TREE_VALUE (params);
7990       val = convert (ptype, val);
7991       val = convert (TREE_VALUE (arg_types), val);
7992       TREE_VALUE (params) = val;
7993
7994       arg_types = TREE_CHAIN (arg_types);
7995       number++;
7996     }
7997
7998   /* The definition of these primitives is variadic, with the remaining
7999      being "an optional list of variables protected by the memory barrier".
8000      No clue what that's supposed to mean, precisely, but we consider all
8001      call-clobbered variables to be protected so we're safe.  */
8002   TREE_CHAIN (params) = NULL;
8003
8004   return true;
8005 }
8006
8007 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
8008    RESULT to make it match the type of the first pointer argument in
8009    PARAMS.  */
8010
8011 static tree
8012 sync_resolve_return (tree params, tree result)
8013 {
8014   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
8015   ptype = TYPE_MAIN_VARIANT (ptype);
8016   return convert (ptype, result);
8017 }
8018
8019 /* Some builtin functions are placeholders for other expressions.  This
8020    function should be called immediately after parsing the call expression
8021    before surrounding code has committed to the type of the expression.
8022
8023    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8024    PARAMS is the argument list for the call.  The return value is non-null
8025    when expansion is complete, and null if normal processing should
8026    continue.  */
8027
8028 tree
8029 resolve_overloaded_builtin (tree function, tree params)
8030 {
8031   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8032   switch (DECL_BUILT_IN_CLASS (function))
8033     {
8034     case BUILT_IN_NORMAL:
8035       break;
8036     case BUILT_IN_MD:
8037       if (targetm.resolve_overloaded_builtin)
8038         return targetm.resolve_overloaded_builtin (function, params);
8039       else
8040         return NULL_TREE;
8041     default:
8042       return NULL_TREE;
8043     }
8044
8045   /* Handle BUILT_IN_NORMAL here.  */
8046   switch (orig_code)
8047     {
8048     case BUILT_IN_FETCH_AND_ADD_N:
8049     case BUILT_IN_FETCH_AND_SUB_N:
8050     case BUILT_IN_FETCH_AND_OR_N:
8051     case BUILT_IN_FETCH_AND_AND_N:
8052     case BUILT_IN_FETCH_AND_XOR_N:
8053     case BUILT_IN_FETCH_AND_NAND_N:
8054     case BUILT_IN_ADD_AND_FETCH_N:
8055     case BUILT_IN_SUB_AND_FETCH_N:
8056     case BUILT_IN_OR_AND_FETCH_N:
8057     case BUILT_IN_AND_AND_FETCH_N:
8058     case BUILT_IN_XOR_AND_FETCH_N:
8059     case BUILT_IN_NAND_AND_FETCH_N:
8060     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8061     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8062     case BUILT_IN_LOCK_TEST_AND_SET_N:
8063     case BUILT_IN_LOCK_RELEASE_N:
8064       {
8065         int n = sync_resolve_size (function, params);
8066         tree new_function, result;
8067
8068         if (n == 0)
8069           return error_mark_node;
8070
8071         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8072         if (!sync_resolve_params (function, new_function, params))
8073           return error_mark_node;
8074
8075         result = build_function_call (new_function, params);
8076         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8077             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8078           result = sync_resolve_return (params, result);
8079
8080         return result;
8081       }
8082
8083     default:
8084       return NULL_TREE;
8085     }
8086 }
8087
8088 /* Ignoring their sign, return true if two scalar types are the same.  */
8089 bool
8090 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8091 {
8092   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8093
8094   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8095               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8096                   || c2 == FIXED_POINT_TYPE));
8097
8098   /* Equality works here because c_common_signed_type uses
8099      TYPE_MAIN_VARIANT.  */
8100   return c_common_signed_type (t1)
8101     == c_common_signed_type (t2);
8102 }
8103
8104 /* Check for missing format attributes on function pointers.  LTYPE is
8105    the new type or left-hand side type.  RTYPE is the old type or
8106    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8107    attribute.  */
8108
8109 bool
8110 check_missing_format_attribute (tree ltype, tree rtype)
8111 {
8112   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8113   tree ra;
8114
8115   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8116     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8117       break;
8118   if (ra)
8119     {
8120       tree la;
8121       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8122         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8123           break;
8124       return !la;
8125     }
8126   else
8127     return false;
8128 }
8129
8130 /* Subscripting with type char is likely to lose on a machine where
8131    chars are signed.  So warn on any machine, but optionally.  Don't
8132    warn for unsigned char since that type is safe.  Don't warn for
8133    signed char because anyone who uses that must have done so
8134    deliberately. Furthermore, we reduce the false positive load by
8135    warning only for non-constant value of type char.  */
8136
8137 void
8138 warn_array_subscript_with_type_char (tree index)
8139 {
8140   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8141       && TREE_CODE (index) != INTEGER_CST)
8142     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8143 }
8144
8145 /* Implement -Wparentheses for the unexpected C precedence rules, to
8146    cover cases like x + y << z which readers are likely to
8147    misinterpret.  We have seen an expression in which CODE is a binary
8148    operator used to combine expressions headed by CODE_LEFT and
8149    CODE_RIGHT.  CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
8150    means that that side of the expression was not formed using a
8151    binary operator, or it was enclosed in parentheses.  */
8152
8153 void
8154 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
8155                         enum tree_code code_right)
8156 {
8157   if (!warn_parentheses)
8158     return;
8159
8160   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
8161     {
8162       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
8163           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8164         warning (OPT_Wparentheses,
8165                  "suggest parentheses around + or - inside shift");
8166     }
8167
8168   if (code == TRUTH_ORIF_EXPR)
8169     {
8170       if (code_left == TRUTH_ANDIF_EXPR
8171           || code_right == TRUTH_ANDIF_EXPR)
8172         warning (OPT_Wparentheses,
8173                  "suggest parentheses around && within ||");
8174     }
8175
8176   if (code == BIT_IOR_EXPR)
8177     {
8178       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8179           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8180           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8181           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8182         warning (OPT_Wparentheses,
8183                  "suggest parentheses around arithmetic in operand of |");
8184       /* Check cases like x|y==z */
8185       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8186           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8187         warning (OPT_Wparentheses,
8188                  "suggest parentheses around comparison in operand of |");
8189     }
8190
8191   if (code == BIT_XOR_EXPR)
8192     {
8193       if (code_left == BIT_AND_EXPR
8194           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8195           || code_right == BIT_AND_EXPR
8196           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8197         warning (OPT_Wparentheses,
8198                  "suggest parentheses around arithmetic in operand of ^");
8199       /* Check cases like x^y==z */
8200       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8201           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8202         warning (OPT_Wparentheses,
8203                  "suggest parentheses around comparison in operand of ^");
8204     }
8205
8206   if (code == BIT_AND_EXPR)
8207     {
8208       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
8209           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8210         warning (OPT_Wparentheses,
8211                  "suggest parentheses around + or - in operand of &");
8212       /* Check cases like x&y==z */
8213       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8214           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8215         warning (OPT_Wparentheses,
8216                  "suggest parentheses around comparison in operand of &");
8217     }
8218
8219   if (code == EQ_EXPR || code == NE_EXPR)
8220     {
8221       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8222           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8223         warning (OPT_Wparentheses,
8224                  "suggest parentheses around comparison in operand of %s",
8225                  code == EQ_EXPR ? "==" : "!=");
8226     }
8227   else if (TREE_CODE_CLASS (code) == tcc_comparison)
8228     {
8229       if ((TREE_CODE_CLASS (code_left) == tcc_comparison
8230            && code_left != NE_EXPR && code_left != EQ_EXPR)
8231           || (TREE_CODE_CLASS (code_right) == tcc_comparison
8232               && code_right != NE_EXPR && code_right != EQ_EXPR))
8233         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
8234                  "have their mathematical meaning");
8235     }
8236 }
8237
8238 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
8239
8240 void
8241 warn_for_unused_label (tree label)
8242 {
8243   if (!TREE_USED (label))
8244     {
8245       if (DECL_INITIAL (label))
8246         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8247       else
8248         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8249     }
8250 }
8251
8252 #ifndef TARGET_HAS_TARGETCM
8253 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8254 #endif
8255
8256 /* Warn for division by zero according to the value of DIVISOR.  */
8257
8258 void
8259 warn_for_div_by_zero (tree divisor)
8260 {
8261   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8262      about division by zero.  Do not issue a warning if DIVISOR has a
8263      floating-point type, since we consider 0.0/0.0 a valid way of
8264      generating a NaN.  */
8265   if (skip_evaluation == 0
8266       && (integer_zerop (divisor) || fixed_zerop (divisor)))
8267     warning (OPT_Wdiv_by_zero, "division by zero");
8268 }
8269
8270 /* Subroutine of build_binary_op. Give warnings for comparisons
8271    between signed and unsigned quantities that may fail. Do the
8272    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8273    so that casts will be considered, but default promotions won't
8274    be.
8275
8276    The arguments of this function map directly to local variables
8277    of build_binary_op.  */
8278
8279 void
8280 warn_for_sign_compare (tree orig_op0, tree orig_op1,
8281                        tree op0, tree op1,
8282                        tree result_type, enum tree_code resultcode)
8283 {
8284   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8285   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8286   int unsignedp0, unsignedp1;
8287
8288   /* In C++, check for comparison of different enum types.  */
8289   if (c_dialect_cxx()
8290       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8291       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8292       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8293       != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8294     {
8295       warning (OPT_Wsign_compare, "comparison between types %qT and %qT",
8296                TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8297     }
8298
8299   /* Do not warn if the comparison is being done in a signed type,
8300      since the signed type will only be chosen if it can represent
8301      all the values of the unsigned type.  */
8302   if (!TYPE_UNSIGNED (result_type))
8303     /* OK */;
8304   /* Do not warn if both operands are unsigned.  */
8305   else if (op0_signed == op1_signed)
8306     /* OK */;
8307   else
8308     {
8309       tree sop, uop;
8310       bool ovf;
8311
8312       if (op0_signed)
8313         sop = orig_op0, uop = orig_op1;
8314       else
8315         sop = orig_op1, uop = orig_op0;
8316
8317       STRIP_TYPE_NOPS (sop);
8318       STRIP_TYPE_NOPS (uop);
8319
8320       /* Do not warn if the signed quantity is an unsuffixed integer
8321          literal (or some static constant expression involving such
8322          literals or a conditional expression involving such literals)
8323          and it is non-negative.  */
8324       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8325         /* OK */;
8326       /* Do not warn if the comparison is an equality operation, the
8327          unsigned quantity is an integral constant, and it would fit
8328          in the result if the result were signed.  */
8329       else if (TREE_CODE (uop) == INTEGER_CST
8330                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8331                && int_fits_type_p (uop, c_common_signed_type (result_type)))
8332         /* OK */;
8333       /* In C, do not warn if the unsigned quantity is an enumeration
8334          constant and its maximum value would fit in the result if the
8335          result were signed.  */
8336       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8337                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8338                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8339                                    c_common_signed_type (result_type)))
8340         /* OK */;
8341       else
8342         warning (OPT_Wsign_compare,
8343                  "comparison between signed and unsigned integer expressions");
8344     }
8345
8346   /* Warn if two unsigned values are being compared in a size larger
8347      than their original size, and one (and only one) is the result of
8348      a `~' operator.  This comparison will always fail.
8349
8350      Also warn if one operand is a constant, and the constant does not
8351      have all bits set that are set in the ~ operand when it is
8352      extended.  */
8353
8354   op0 = get_narrower (op0, &unsignedp0);
8355   op1 = get_narrower (op1, &unsignedp1);
8356
8357   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8358       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8359     {
8360       if (TREE_CODE (op0) == BIT_NOT_EXPR)
8361         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8362       if (TREE_CODE (op1) == BIT_NOT_EXPR)
8363         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8364
8365       if (host_integerp (op0, 0) || host_integerp (op1, 0))
8366         {
8367           tree primop;
8368           HOST_WIDE_INT constant, mask;
8369           int unsignedp;
8370           unsigned int bits;
8371
8372           if (host_integerp (op0, 0))
8373             {
8374               primop = op1;
8375               unsignedp = unsignedp1;
8376               constant = tree_low_cst (op0, 0);
8377             }
8378           else
8379             {
8380               primop = op0;
8381               unsignedp = unsignedp0;
8382               constant = tree_low_cst (op1, 0);
8383             }
8384
8385           bits = TYPE_PRECISION (TREE_TYPE (primop));
8386           if (bits < TYPE_PRECISION (result_type)
8387               && bits < HOST_BITS_PER_LONG && unsignedp)
8388             {
8389               mask = (~ (HOST_WIDE_INT) 0) << bits;
8390               if ((mask & constant) != mask)
8391                 {
8392                   if (constant == 0)
8393                     warning (OPT_Wsign_compare,
8394                              "promoted ~unsigned is always non-zero");
8395                   else
8396                     warning (OPT_Wsign_compare,
8397                              "comparison of promoted ~unsigned with constant");
8398                 }
8399             }
8400         }
8401       else if (unsignedp0 && unsignedp1
8402                && (TYPE_PRECISION (TREE_TYPE (op0))
8403                    < TYPE_PRECISION (result_type))
8404                && (TYPE_PRECISION (TREE_TYPE (op1))
8405                    < TYPE_PRECISION (result_type)))
8406         warning (OPT_Wsign_compare,
8407                  "comparison of promoted ~unsigned with unsigned");
8408     }
8409 }
8410
8411 #include "gt-c-common.h"