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