gcc/c-common.c

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