gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "intl.h"
  27 #include "tree.h"
  28 #include "flags.h"
  29 #include "output.h"
  30 #include "c-pragma.h"
  31 #include "rtl.h"
  32 #include "ggc.h"
  33 #include "varray.h"
  34 #include "expr.h"
  35 #include "c-common.h"
  36 #include "tm_p.h"
  37 #include "obstack.h"
  38 #include "cpplib.h"
  39 #include "target.h"
  40 #include "langhooks.h"
  41 #include "tree-inline.h"
  42 #include "c-tree.h"
  43 #include "toplev.h"
  44 #include "diagnostic.h"
  45 #include "tree-iterator.h"
  46 #include "hashtab.h"
  47 #include "tree-mudflap.h"
  48 #include "opts.h"
  49 #include "real.h"
  50 #include "cgraph.h"
  51 #include "target-def.h"
  52 #include "gimple.h"
  53 #include "fixed-value.h"
  54 #include "libfuncs.h"
  55
  56 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  57
  58 /* We let tm.h override the types used here, to handle trivial differences
  59    such as the choice of unsigned int or long unsigned int for size_t.
  60    When machines start needing nontrivial differences in the size type,
  61    it would be best to do something here to figure out automatically
  62    from other information what type to use.  */
  63
  64 #ifndef SIZE_TYPE
  65 #define SIZE_TYPE "long unsigned int"
  66 #endif
  67
  68 #ifndef PID_TYPE
  69 #define PID_TYPE "int"
  70 #endif
  71
  72 #ifndef CHAR16_TYPE
  73 #define CHAR16_TYPE "short unsigned int"
  74 #endif
  75
  76 #ifndef CHAR32_TYPE
  77 #define CHAR32_TYPE "unsigned int"
  78 #endif
  79
  80 #ifndef WCHAR_TYPE
  81 #define WCHAR_TYPE "int"
  82 #endif
  83
  84 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  85 #define MODIFIED_WCHAR_TYPE \
  86         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  87
  88 #ifndef PTRDIFF_TYPE
  89 #define PTRDIFF_TYPE "long int"
  90 #endif
  91
  92 #ifndef WINT_TYPE
  93 #define WINT_TYPE "unsigned int"
  94 #endif
  95
  96 #ifndef INTMAX_TYPE
  97 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  98                      ? "int"                                    \
  99                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
 100                         ? "long int"                            \
 101                         : "long long int"))
 102 #endif
 103
 104 #ifndef UINTMAX_TYPE
 105 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
 106                      ? "unsigned int"                           \
 107                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
 108                         ? "long unsigned int"                   \
 109                         : "long long unsigned int"))
 110 #endif
 111
 112 /* The following symbols are subsumed in the c_global_trees array, and
 113    listed here individually for documentation purposes.
 114
 115    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
 116
 117         tree short_integer_type_node;
 118         tree long_integer_type_node;
 119         tree long_long_integer_type_node;
 120
 121         tree short_unsigned_type_node;
 122         tree long_unsigned_type_node;
 123         tree long_long_unsigned_type_node;
 124
 125         tree truthvalue_type_node;
 126         tree truthvalue_false_node;
 127         tree truthvalue_true_node;
 128
 129         tree ptrdiff_type_node;
 130
 131         tree unsigned_char_type_node;
 132         tree signed_char_type_node;
 133         tree wchar_type_node;
 134         tree signed_wchar_type_node;
 135         tree unsigned_wchar_type_node;
 136
 137         tree char16_type_node;
 138         tree char32_type_node;
 139
 140         tree float_type_node;
 141         tree double_type_node;
 142         tree long_double_type_node;
 143
 144         tree complex_integer_type_node;
 145         tree complex_float_type_node;
 146         tree complex_double_type_node;
 147         tree complex_long_double_type_node;
 148
 149         tree dfloat32_type_node;
 150         tree dfloat64_type_node;
 151         tree_dfloat128_type_node;
 152
 153         tree intQI_type_node;
 154         tree intHI_type_node;
 155         tree intSI_type_node;
 156         tree intDI_type_node;
 157         tree intTI_type_node;
 158
 159         tree unsigned_intQI_type_node;
 160         tree unsigned_intHI_type_node;
 161         tree unsigned_intSI_type_node;
 162         tree unsigned_intDI_type_node;
 163         tree unsigned_intTI_type_node;
 164
 165         tree widest_integer_literal_type_node;
 166         tree widest_unsigned_literal_type_node;
 167
 168    Nodes for types `void *' and `const void *'.
 169
 170         tree ptr_type_node, const_ptr_type_node;
 171
 172    Nodes for types `char *' and `const char *'.
 173
 174         tree string_type_node, const_string_type_node;
 175
 176    Type `char[SOMENUMBER]'.
 177    Used when an array of char is needed and the size is irrelevant.
 178
 179         tree char_array_type_node;
 180
 181    Type `int[SOMENUMBER]' or something like it.
 182    Used when an array of int needed and the size is irrelevant.
 183
 184         tree int_array_type_node;
 185
 186    Type `wchar_t[SOMENUMBER]' or something like it.
 187    Used when a wide string literal is created.
 188
 189         tree wchar_array_type_node;
 190
 191    Type `char16_t[SOMENUMBER]' or something like it.
 192    Used when a UTF-16 string literal is created.
 193
 194         tree char16_array_type_node;
 195
 196    Type `char32_t[SOMENUMBER]' or something like it.
 197    Used when a UTF-32 string literal is created.
 198
 199         tree char32_array_type_node;
 200
 201    Type `int ()' -- used for implicit declaration of functions.
 202
 203         tree default_function_type;
 204
 205    A VOID_TYPE node, packaged in a TREE_LIST.
 206
 207         tree void_list_node;
 208
 209   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 210   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 211   VAR_DECLS, but C++ does.)
 212
 213         tree function_name_decl_node;
 214         tree pretty_function_name_decl_node;
 215         tree c99_function_name_decl_node;
 216
 217   Stack of nested function name VAR_DECLs.
 218
 219         tree saved_function_name_decls;
 220
 221 */
 222
 223 tree c_global_trees[CTI_MAX];
 224 \f
 225 /* Switches common to the C front ends.  */
 226
 227 /* Nonzero if preprocessing only.  */
 228
 229 int flag_preprocess_only;
 230
 231 /* Nonzero means don't output line number information.  */
 232
 233 char flag_no_line_commands;
 234
 235 /* Nonzero causes -E output not to be done, but directives such as
 236    #define that have side effects are still obeyed.  */
 237
 238 char flag_no_output;
 239
 240 /* Nonzero means dump macros in some fashion.  */
 241
 242 char flag_dump_macros;
 243
 244 /* Nonzero means pass #include lines through to the output.  */
 245
 246 char flag_dump_includes;
 247
 248 /* Nonzero means process PCH files while preprocessing.  */
 249
 250 bool flag_pch_preprocess;
 251
 252 /* The file name to which we should write a precompiled header, or
 253    NULL if no header will be written in this compile.  */
 254
 255 const char *pch_file;
 256
 257 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 258    user's namespace.  */
 259 int flag_iso;
 260
 261 /* Nonzero if -undef was given.  It suppresses target built-in macros
 262    and assertions.  */
 263 int flag_undef;
 264
 265 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 266
 267 int flag_no_builtin;
 268
 269 /* Nonzero means don't recognize the non-ANSI builtin functions.
 270    -ansi sets this.  */
 271
 272 int flag_no_nonansi_builtin;
 273
 274 /* Nonzero means give `double' the same size as `float'.  */
 275
 276 int flag_short_double;
 277
 278 /* Nonzero means give `wchar_t' the same size as `short'.  */
 279
 280 int flag_short_wchar;
 281
 282 /* Nonzero means allow implicit conversions between vectors with
 283    differing numbers of subparts and/or differing element types.  */
 284 int flag_lax_vector_conversions;
 285
 286 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
 287 int flag_ms_extensions;
 288
 289 /* Nonzero means don't recognize the keyword `asm'.  */
 290
 291 int flag_no_asm;
 292
 293 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
 294
 295 int flag_signed_bitfields = 1;
 296
 297 /* Warn about #pragma directives that are not recognized.  */
 298
 299 int warn_unknown_pragmas; /* Tri state variable.  */
 300
 301 /* Warn about format/argument anomalies in calls to formatted I/O functions
 302    (*printf, *scanf, strftime, strfmon, etc.).  */
 303
 304 int warn_format;
 305
 306 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
 307    with GCC this doesn't matter as __null is guaranteed to have the right
 308    size.  */
 309
 310 int warn_strict_null_sentinel;
 311
 312 /* Zero means that faster, ...NonNil variants of objc_msgSend...
 313    calls will be used in ObjC; passing nil receivers to such calls
 314    will most likely result in crashes.  */
 315 int flag_nil_receivers = 1;
 316
 317 /* Nonzero means that code generation will be altered to support
 318    "zero-link" execution.  This currently affects ObjC only, but may
 319    affect other languages in the future.  */
 320 int flag_zero_link = 0;
 321
 322 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
 323    unit.  It will inform the ObjC runtime that class definition(s) herein
 324    contained are to replace one(s) previously loaded.  */
 325 int flag_replace_objc_classes = 0;
 326
 327 /* C/ObjC language option variables.  */
 328
 329
 330 /* Nonzero means allow type mismatches in conditional expressions;
 331    just make their values `void'.  */
 332
 333 int flag_cond_mismatch;
 334
 335 /* Nonzero means enable C89 Amendment 1 features.  */
 336
 337 int flag_isoc94;
 338
 339 /* Nonzero means use the ISO C99 dialect of C.  */
 340
 341 int flag_isoc99;
 342
 343 /* Nonzero means that we have builtin functions, and main is an int.  */
 344
 345 int flag_hosted = 1;
 346
 347
 348 /* ObjC language option variables.  */
 349
 350
 351 /* Open and close the file for outputting class declarations, if
 352    requested (ObjC).  */
 353
 354 int flag_gen_declaration;
 355
 356 /* Tells the compiler that this is a special run.  Do not perform any
 357    compiling, instead we are to test some platform dependent features
 358    and output a C header file with appropriate definitions.  */
 359
 360 int print_struct_values;
 361
 362 /* Tells the compiler what is the constant string class for ObjC.  */
 363
 364 const char *constant_string_class_name;
 365
 366
 367 /* C++ language option variables.  */
 368
 369
 370 /* Nonzero means don't recognize any extension keywords.  */
 371
 372 int flag_no_gnu_keywords;
 373
 374 /* Nonzero means do emit exported implementations of functions even if
 375    they can be inlined.  */
 376
 377 int flag_implement_inlines = 1;
 378
 379 /* Nonzero means that implicit instantiations will be emitted if needed.  */
 380
 381 int flag_implicit_templates = 1;
 382
 383 /* Nonzero means that implicit instantiations of inline templates will be
 384    emitted if needed, even if instantiations of non-inline templates
 385    aren't.  */
 386
 387 int flag_implicit_inline_templates = 1;
 388
 389 /* Nonzero means generate separate instantiation control files and
 390    juggle them at link time.  */
 391
 392 int flag_use_repository;
 393
 394 /* Nonzero if we want to issue diagnostics that the standard says are not
 395    required.  */
 396
 397 int flag_optional_diags = 1;
 398
 399 /* Nonzero means we should attempt to elide constructors when possible.  */
 400
 401 int flag_elide_constructors = 1;
 402
 403 /* Nonzero means that member functions defined in class scope are
 404    inline by default.  */
 405
 406 int flag_default_inline = 1;
 407
 408 /* Controls whether compiler generates 'type descriptor' that give
 409    run-time type information.  */
 410
 411 int flag_rtti = 1;
 412
 413 /* Nonzero if we want to conserve space in the .o files.  We do this
 414    by putting uninitialized data and runtime initialized data into
 415    .common instead of .data at the expense of not flagging multiple
 416    definitions.  */
 417
 418 int flag_conserve_space;
 419
 420 /* Nonzero if we want to obey access control semantics.  */
 421
 422 int flag_access_control = 1;
 423
 424 /* Nonzero if we want to check the return value of new and avoid calling
 425    constructors if it is a null pointer.  */
 426
 427 int flag_check_new;
 428
 429 /* The C++ dialect being used. C++98 is the default.  */
 430
 431 enum cxx_dialect cxx_dialect = cxx98;
 432
 433 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
 434    initialization variables.
 435    0: Old rules, set by -fno-for-scope.
 436    2: New ISO rules, set by -ffor-scope.
 437    1: Try to implement new ISO rules, but with backup compatibility
 438    (and warnings).  This is the default, for now.  */
 439
 440 int flag_new_for_scope = 1;
 441
 442 /* Nonzero if we want to emit defined symbols with common-like linkage as
 443    weak symbols where possible, in order to conform to C++ semantics.
 444    Otherwise, emit them as local symbols.  */
 445
 446 int flag_weak = 1;
 447
 448 /* 0 means we want the preprocessor to not emit line directives for
 449    the current working directory.  1 means we want it to do it.  -1
 450    means we should decide depending on whether debugging information
 451    is being emitted or not.  */
 452
 453 int flag_working_directory = -1;
 454
 455 /* Nonzero to use __cxa_atexit, rather than atexit, to register
 456    destructors for local statics and global objects.  '2' means it has been
 457    set nonzero as a default, not by a command-line flag.  */
 458
 459 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
 460
 461 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
 462    code.  '2' means it has not been set explicitly on the command line.  */
 463
 464 int flag_use_cxa_get_exception_ptr = 2;
 465
 466 /* Nonzero means to implement standard semantics for exception
 467    specifications, calling unexpected if an exception is thrown that
 468    doesn't match the specification.  Zero means to treat them as
 469    assertions and optimize accordingly, but not check them.  */
 470
 471 int flag_enforce_eh_specs = 1;
 472
 473 /* Nonzero means to generate thread-safe code for initializing local
 474    statics.  */
 475
 476 int flag_threadsafe_statics = 1;
 477
 478 /* Nonzero means warn about implicit declarations.  */
 479
 480 int warn_implicit = 1;
 481
 482 /* Maximum template instantiation depth.  This limit is rather
 483    arbitrary, but it exists to limit the time it takes to notice
 484    infinite template instantiations.  */
 485
 486 int max_tinst_depth = 500;
 487
 488
 489
 490 /* The elements of `ridpointers' are identifier nodes for the reserved
 491    type names and storage classes.  It is indexed by a RID_... value.  */
 492 tree *ridpointers;
 493
 494 tree (*make_fname_decl) (tree, int);
 495
 496 /* Nonzero means the expression being parsed will never be evaluated.
 497    This is a count, since unevaluated expressions can nest.  */
 498 int skip_evaluation;
 499
 500 /* Whether lexing has been completed, so subsequent preprocessor
 501    errors should use the compiler's input_location.  */
 502 bool done_lexing = false;
 503
 504 /* Information about how a function name is generated.  */
 505 struct fname_var_t
 506 {
 507   tree *const decl;     /* pointer to the VAR_DECL.  */
 508   const unsigned rid;   /* RID number for the identifier.  */
 509   const int pretty;     /* How pretty is it? */
 510 };
 511
 512 /* The three ways of getting then name of the current function.  */
 513
 514 const struct fname_var_t fname_vars[] =
 515 {
 516   /* C99 compliant __func__, must be first.  */
 517   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 518   /* GCC __FUNCTION__ compliant.  */
 519   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 520   /* GCC __PRETTY_FUNCTION__ compliant.  */
 521   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 522   {NULL, 0, 0},
 523 };
 524
 525 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
 526 static tree check_case_value (tree);
 527 static bool check_case_bounds (tree, tree, tree *, tree *);
 528
 529 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
 530 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
 531 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
 532 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
 533 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
 534 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
 535 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
 536 static tree handle_always_inline_attribute (tree *, tree, tree, int,
 537                                             bool *);
 538 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
 539 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
 540 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
 541 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
 542 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
 543 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
 544 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
 545                                                  bool *);
 546 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
 547 static tree handle_transparent_union_attribute (tree *, tree, tree,
 548                                                 int, bool *);
 549 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
 550 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
 551 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
 552 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
 553 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
 554 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
 555 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
 556 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
 557 static tree handle_visibility_attribute (tree *, tree, tree, int,
 558                                          bool *);
 559 static tree handle_tls_model_attribute (tree *, tree, tree, int,
 560                                         bool *);
 561 static tree handle_no_instrument_function_attribute (tree *, tree,
 562                                                      tree, int, bool *);
 563 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
 564 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
 565 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
 566                                              bool *);
 567 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
 568 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
 569 static tree handle_deprecated_attribute (tree *, tree, tree, int,
 570                                          bool *);
 571 static tree handle_vector_size_attribute (tree *, tree, tree, int,
 572                                           bool *);
 573 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
 574 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
 575 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
 576 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
 577                                                  bool *);
 578 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
 579 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
 580 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
 581 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
 582 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
 583
 584 static void check_function_nonnull (tree, int, tree *);
 585 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
 586 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
 587 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
 588 static int resort_field_decl_cmp (const void *, const void *);
 589
 590 /* Reserved words.  The third field is a mask: keywords are disabled
 591    if they match the mask.
 592
 593    Masks for languages:
 594    C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
 595    C --std=c99: D_CXXONLY | D_OBJC
 596    ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
 597    C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
 598    C++ --std=c0x: D_CONLY | D_OBJC
 599    ObjC++ is like C++ except that D_OBJC is not set
 600
 601    If -fno-asm is used, D_ASM is added to the mask.  If
 602    -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in
 603    C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
 604    In C with -Wc++-compat, we warn if D_CXXWARN is set.  */
 605
 606 const struct c_common_resword c_common_reswords[] =
 607 {
 608   { "_Bool",            RID_BOOL,      D_CONLY },
 609   { "_Complex",         RID_COMPLEX,    0 },
 610   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
 611   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
 612   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
 613   { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
 614   { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
 615   { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
 616   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
 617   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
 618   { "__alignof",        RID_ALIGNOF,    0 },
 619   { "__alignof__",      RID_ALIGNOF,    0 },
 620   { "__asm",            RID_ASM,        0 },
 621   { "__asm__",          RID_ASM,        0 },
 622   { "__attribute",      RID_ATTRIBUTE,  0 },
 623   { "__attribute__",    RID_ATTRIBUTE,  0 },
 624   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
 625   { "__builtin_offsetof", RID_OFFSETOF, 0 },
 626   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
 627   { "__builtin_va_arg", RID_VA_ARG,     0 },
 628   { "__complex",        RID_COMPLEX,    0 },
 629   { "__complex__",      RID_COMPLEX,    0 },
 630   { "__const",          RID_CONST,      0 },
 631   { "__const__",        RID_CONST,      0 },
 632   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
 633   { "__extension__",    RID_EXTENSION,  0 },
 634   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
 635   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
 636   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
 637   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
 638   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
 639   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
 640   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
 641   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
 642   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
 643   { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },
 644   { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },
 645   { "__is_class",       RID_IS_CLASS,   D_CXXONLY },
 646   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
 647   { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },
 648   { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },
 649   { "__is_pod",         RID_IS_POD,     D_CXXONLY },
 650   { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
 651   { "__is_union",       RID_IS_UNION,   D_CXXONLY },
 652   { "__imag",           RID_IMAGPART,   0 },
 653   { "__imag__",         RID_IMAGPART,   0 },
 654   { "__inline",         RID_INLINE,     0 },
 655   { "__inline__",       RID_INLINE,     0 },
 656   { "__label__",        RID_LABEL,      0 },
 657   { "__null",           RID_NULL,       0 },
 658   { "__real",           RID_REALPART,   0 },
 659   { "__real__",         RID_REALPART,   0 },
 660   { "__restrict",       RID_RESTRICT,   0 },
 661   { "__restrict__",     RID_RESTRICT,   0 },
 662   { "__signed",         RID_SIGNED,     0 },
 663   { "__signed__",       RID_SIGNED,     0 },
 664   { "__thread",         RID_THREAD,     0 },
 665   { "__typeof",         RID_TYPEOF,     0 },
 666   { "__typeof__",       RID_TYPEOF,     0 },
 667   { "__volatile",       RID_VOLATILE,   0 },
 668   { "__volatile__",     RID_VOLATILE,   0 },
 669   { "asm",              RID_ASM,        D_ASM },
 670   { "auto",             RID_AUTO,       0 },
 671   { "bool",             RID_BOOL,       D_CXXONLY | D_CXXWARN },
 672   { "break",            RID_BREAK,      0 },
 673   { "case",             RID_CASE,       0 },
 674   { "catch",            RID_CATCH,      D_CXX_OBJC | D_CXXWARN },
 675   { "char",             RID_CHAR,       0 },
 676   { "char16_t",         RID_CHAR16,     D_CXXONLY | D_CXX0X | D_CXXWARN },
 677   { "char32_t",         RID_CHAR32,     D_CXXONLY | D_CXX0X | D_CXXWARN },
 678   { "class",            RID_CLASS,      D_CXX_OBJC | D_CXXWARN },
 679   { "const",            RID_CONST,      0 },
 680   { "const_cast",       RID_CONSTCAST,  D_CXXONLY | D_CXXWARN },
 681   { "continue",         RID_CONTINUE,   0 },
 682   { "decltype",         RID_DECLTYPE,   D_CXXONLY | D_CXX0X | D_CXXWARN },
 683   { "default",          RID_DEFAULT,    0 },
 684   { "delete",           RID_DELETE,     D_CXXONLY | D_CXXWARN },
 685   { "do",               RID_DO,         0 },
 686   { "double",           RID_DOUBLE,     0 },
 687   { "dynamic_cast",     RID_DYNCAST,    D_CXXONLY | D_CXXWARN },
 688   { "else",             RID_ELSE,       0 },
 689   { "enum",             RID_ENUM,       0 },
 690   { "explicit",         RID_EXPLICIT,   D_CXXONLY | D_CXXWARN },
 691   { "export",           RID_EXPORT,     D_CXXONLY | D_CXXWARN },
 692   { "extern",           RID_EXTERN,     0 },
 693   { "false",            RID_FALSE,      D_CXXONLY | D_CXXWARN },
 694   { "float",            RID_FLOAT,      0 },
 695   { "for",              RID_FOR,        0 },
 696   { "friend",           RID_FRIEND,     D_CXXONLY | D_CXXWARN },
 697   { "goto",             RID_GOTO,       0 },
 698   { "if",               RID_IF,         0 },
 699   { "inline",           RID_INLINE,     D_EXT89 },
 700   { "int",              RID_INT,        0 },
 701   { "long",             RID_LONG,       0 },
 702   { "mutable",          RID_MUTABLE,    D_CXXONLY | D_CXXWARN },
 703   { "namespace",        RID_NAMESPACE,  D_CXXONLY | D_CXXWARN },
 704   { "new",              RID_NEW,        D_CXXONLY | D_CXXWARN },
 705   { "operator",         RID_OPERATOR,   D_CXXONLY | D_CXXWARN },
 706   { "private",          RID_PRIVATE,    D_CXX_OBJC | D_CXXWARN },
 707   { "protected",        RID_PROTECTED,  D_CXX_OBJC | D_CXXWARN },
 708   { "public",           RID_PUBLIC,     D_CXX_OBJC | D_CXXWARN },
 709   { "register",         RID_REGISTER,   0 },
 710   { "reinterpret_cast", RID_REINTCAST,  D_CXXONLY | D_CXXWARN },
 711   { "restrict",         RID_RESTRICT,   D_CONLY | D_C99 },
 712   { "return",           RID_RETURN,     0 },
 713   { "short",            RID_SHORT,      0 },
 714   { "signed",           RID_SIGNED,     0 },
 715   { "sizeof",           RID_SIZEOF,     0 },
 716   { "static",           RID_STATIC,     0 },
 717   { "static_assert",    RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
 718   { "static_cast",      RID_STATCAST,   D_CXXONLY | D_CXXWARN },
 719   { "struct",           RID_STRUCT,     0 },
 720   { "switch",           RID_SWITCH,     0 },
 721   { "template",         RID_TEMPLATE,   D_CXXONLY | D_CXXWARN },
 722   { "this",             RID_THIS,       D_CXXONLY | D_CXXWARN },
 723   { "throw",            RID_THROW,      D_CXX_OBJC | D_CXXWARN },
 724   { "true",             RID_TRUE,       D_CXXONLY | D_CXXWARN },
 725   { "try",              RID_TRY,        D_CXX_OBJC | D_CXXWARN },
 726   { "typedef",          RID_TYPEDEF,    0 },
 727   { "typename",         RID_TYPENAME,   D_CXXONLY | D_CXXWARN },
 728   { "typeid",           RID_TYPEID,     D_CXXONLY | D_CXXWARN },
 729   { "typeof",           RID_TYPEOF,     D_ASM | D_EXT },
 730   { "union",            RID_UNION,      0 },
 731   { "unsigned",         RID_UNSIGNED,   0 },
 732   { "using",            RID_USING,      D_CXXONLY | D_CXXWARN },
 733   { "virtual",          RID_VIRTUAL,    D_CXXONLY | D_CXXWARN },
 734   { "void",             RID_VOID,       0 },
 735   { "volatile",         RID_VOLATILE,   0 },
 736   { "wchar_t",          RID_WCHAR,      D_CXXONLY },
 737   { "while",            RID_WHILE,      0 },
 738   /* These Objective-C keywords are recognized only immediately after
 739      an '@'.  */
 740   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
 741   { "defs",             RID_AT_DEFS,            D_OBJC },
 742   { "encode",           RID_AT_ENCODE,          D_OBJC },
 743   { "end",              RID_AT_END,             D_OBJC },
 744   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
 745   { "interface",        RID_AT_INTERFACE,       D_OBJC },
 746   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
 747   { "selector",         RID_AT_SELECTOR,        D_OBJC },
 748   { "finally",          RID_AT_FINALLY,         D_OBJC },
 749   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
 750   /* These are recognized only in protocol-qualifier context
 751      (see above) */
 752   { "bycopy",           RID_BYCOPY,             D_OBJC },
 753   { "byref",            RID_BYREF,              D_OBJC },
 754   { "in",               RID_IN,                 D_OBJC },
 755   { "inout",            RID_INOUT,              D_OBJC },
 756   { "oneway",           RID_ONEWAY,             D_OBJC },
 757   { "out",              RID_OUT,                D_OBJC },
 758 };
 759
 760 const unsigned int num_c_common_reswords =
 761   sizeof c_common_reswords / sizeof (struct c_common_resword);
 762
 763 /* Table of machine-independent attributes common to all C-like languages.  */
 764 const struct attribute_spec c_common_attribute_table[] =
 765 {
 766   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 767   { "packed",                 0, 0, false, false, false,
 768                               handle_packed_attribute },
 769   { "nocommon",               0, 0, true,  false, false,
 770                               handle_nocommon_attribute },
 771   { "common",                 0, 0, true,  false, false,
 772                               handle_common_attribute },
 773   /* FIXME: logically, noreturn attributes should be listed as
 774      "false, true, true" and apply to function types.  But implementing this
 775      would require all the places in the compiler that use TREE_THIS_VOLATILE
 776      on a decl to identify non-returning functions to be located and fixed
 777      to check the function type instead.  */
 778   { "noreturn",               0, 0, true,  false, false,
 779                               handle_noreturn_attribute },
 780   { "volatile",               0, 0, true,  false, false,
 781                               handle_noreturn_attribute },
 782   { "noinline",               0, 0, true,  false, false,
 783                               handle_noinline_attribute },
 784   { "always_inline",          0, 0, true,  false, false,
 785                               handle_always_inline_attribute },
 786   { "gnu_inline",             0, 0, true,  false, false,
 787                               handle_gnu_inline_attribute },
 788   { "artificial",             0, 0, true,  false, false,
 789                               handle_artificial_attribute },
 790   { "flatten",                0, 0, true,  false, false,
 791                               handle_flatten_attribute },
 792   { "used",                   0, 0, true,  false, false,
 793                               handle_used_attribute },
 794   { "unused",                 0, 0, false, false, false,
 795                               handle_unused_attribute },
 796   { "externally_visible",     0, 0, true,  false, false,
 797                               handle_externally_visible_attribute },
 798   /* The same comments as for noreturn attributes apply to const ones.  */
 799   { "const",                  0, 0, true,  false, false,
 800                               handle_const_attribute },
 801   { "transparent_union",      0, 0, false, false, false,
 802                               handle_transparent_union_attribute },
 803   { "constructor",            0, 1, true,  false, false,
 804                               handle_constructor_attribute },
 805   { "destructor",             0, 1, true,  false, false,
 806                               handle_destructor_attribute },
 807   { "mode",                   1, 1, false,  true, false,
 808                               handle_mode_attribute },
 809   { "section",                1, 1, true,  false, false,
 810                               handle_section_attribute },
 811   { "aligned",                0, 1, false, false, false,
 812                               handle_aligned_attribute },
 813   { "weak",                   0, 0, true,  false, false,
 814                               handle_weak_attribute },
 815   { "alias",                  1, 1, true,  false, false,
 816                               handle_alias_attribute },
 817   { "weakref",                0, 1, true,  false, false,
 818                               handle_weakref_attribute },
 819   { "no_instrument_function", 0, 0, true,  false, false,
 820                               handle_no_instrument_function_attribute },
 821   { "malloc",                 0, 0, true,  false, false,
 822                               handle_malloc_attribute },
 823   { "returns_twice",          0, 0, true,  false, false,
 824                               handle_returns_twice_attribute },
 825   { "no_stack_limit",         0, 0, true,  false, false,
 826                               handle_no_limit_stack_attribute },
 827   { "pure",                   0, 0, true,  false, false,
 828                               handle_pure_attribute },
 829   /* For internal use (marking of builtins) only.  The name contains space
 830      to prevent its usage in source code.  */
 831   { "no vops",                0, 0, true,  false, false,
 832                               handle_novops_attribute },
 833   { "deprecated",             0, 0, false, false, false,
 834                               handle_deprecated_attribute },
 835   { "vector_size",            1, 1, false, true, false,
 836                               handle_vector_size_attribute },
 837   { "visibility",             1, 1, false, false, false,
 838                               handle_visibility_attribute },
 839   { "tls_model",              1, 1, true,  false, false,
 840                               handle_tls_model_attribute },
 841   { "nonnull",                0, -1, false, true, true,
 842                               handle_nonnull_attribute },
 843   { "nothrow",                0, 0, true,  false, false,
 844                               handle_nothrow_attribute },
 845   { "may_alias",              0, 0, false, true, false, NULL },
 846   { "cleanup",                1, 1, true, false, false,
 847                               handle_cleanup_attribute },
 848   { "warn_unused_result",     0, 0, false, true, true,
 849                               handle_warn_unused_result_attribute },
 850   { "sentinel",               0, 1, false, true, true,
 851                               handle_sentinel_attribute },
 852   /* For internal use (marking of builtins) only.  The name contains space
 853      to prevent its usage in source code.  */
 854   { "type generic",           0, 0, false, true, true,
 855                               handle_type_generic_attribute },
 856   { "alloc_size",             1, 2, false, true, true,
 857                               handle_alloc_size_attribute },
 858   { "cold",                   0, 0, true,  false, false,
 859                               handle_cold_attribute },
 860   { "hot",                    0, 0, true,  false, false,
 861                               handle_hot_attribute },
 862   { "warning",                1, 1, true,  false, false,
 863                               handle_error_attribute },
 864   { "error",                  1, 1, true,  false, false,
 865                               handle_error_attribute },
 866   { "target",                 1, -1, true, false, false,
 867                               handle_target_attribute },
 868   { "optimize",               1, -1, true, false, false,
 869                               handle_optimize_attribute },
 870   { NULL,                     0, 0, false, false, false, NULL }
 871 };
 872
 873 /* Give the specifications for the format attributes, used by C and all
 874    descendants.  */
 875
 876 const struct attribute_spec c_common_format_attribute_table[] =
 877 {
 878   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 879   { "format",                 3, 3, false, true,  true,
 880                               handle_format_attribute },
 881   { "format_arg",             1, 1, false, true,  true,
 882                               handle_format_arg_attribute },
 883   { NULL,                     0, 0, false, false, false, NULL }
 884 };
 885
 886 /* Push current bindings for the function name VAR_DECLS.  */
 887
 888 void
 889 start_fname_decls (void)
 890 {
 891   unsigned ix;
 892   tree saved = NULL_TREE;
 893
 894   for (ix = 0; fname_vars[ix].decl; ix++)
 895     {
 896       tree decl = *fname_vars[ix].decl;
 897
 898       if (decl)
 899         {
 900           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
 901           *fname_vars[ix].decl = NULL_TREE;
 902         }
 903     }
 904   if (saved || saved_function_name_decls)
 905     /* Normally they'll have been NULL, so only push if we've got a
 906        stack, or they are non-NULL.  */
 907     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 908                                            saved_function_name_decls);
 909 }
 910
 911 /* Finish up the current bindings, adding them into the current function's
 912    statement tree.  This must be done _before_ finish_stmt_tree is called.
 913    If there is no current function, we must be at file scope and no statements
 914    are involved. Pop the previous bindings.  */
 915
 916 void
 917 finish_fname_decls (void)
 918 {
 919   unsigned ix;
 920   tree stmts = NULL_TREE;
 921   tree stack = saved_function_name_decls;
 922
 923   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 924     append_to_statement_list (TREE_VALUE (stack), &stmts);
 925
 926   if (stmts)
 927     {
 928       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
 929
 930       if (TREE_CODE (*bodyp) == BIND_EXPR)
 931         bodyp = &BIND_EXPR_BODY (*bodyp);
 932
 933       append_to_statement_list_force (*bodyp, &stmts);
 934       *bodyp = stmts;
 935     }
 936
 937   for (ix = 0; fname_vars[ix].decl; ix++)
 938     *fname_vars[ix].decl = NULL_TREE;
 939
 940   if (stack)
 941     {
 942       /* We had saved values, restore them.  */
 943       tree saved;
 944
 945       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 946         {
 947           tree decl = TREE_PURPOSE (saved);
 948           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 949
 950           *fname_vars[ix].decl = decl;
 951         }
 952       stack = TREE_CHAIN (stack);
 953     }
 954   saved_function_name_decls = stack;
 955 }
 956
 957 /* Return the text name of the current function, suitably prettified
 958    by PRETTY_P.  Return string must be freed by caller.  */
 959
 960 const char *
 961 fname_as_string (int pretty_p)
 962 {
 963   const char *name = "top level";
 964   char *namep;
 965   int vrb = 2, len;
 966   cpp_string cstr = { 0, 0 }, strname;
 967
 968   if (!pretty_p)
 969     {
 970       name = "";
 971       vrb = 0;
 972     }
 973
 974   if (current_function_decl)
 975     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
 976
 977   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
 978
 979   namep = XNEWVEC (char, len);
 980   snprintf (namep, len, "\"%s\"", name);
 981   strname.text = (unsigned char *) namep;
 982   strname.len = len - 1;
 983
 984   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
 985     {
 986       XDELETEVEC (namep);
 987       return (const char *) cstr.text;
 988     }
 989
 990   return namep;
 991 }
 992
 993 /* Return the VAR_DECL for a const char array naming the current
 994    function. If the VAR_DECL has not yet been created, create it
 995    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 996    ID is its name (unfortunately C and C++ hold the RID values of
 997    keywords in different places, so we can't derive RID from ID in
 998    this language independent code. LOC is the location of the
 999    function.  */
1000
1001 tree
1002 fname_decl (location_t loc, unsigned int rid, tree id)
1003 {
1004   unsigned ix;
1005   tree decl = NULL_TREE;
1006
1007   for (ix = 0; fname_vars[ix].decl; ix++)
1008     if (fname_vars[ix].rid == rid)
1009       break;
1010
1011   decl = *fname_vars[ix].decl;
1012   if (!decl)
1013     {
1014       /* If a tree is built here, it would normally have the lineno of
1015          the current statement.  Later this tree will be moved to the
1016          beginning of the function and this line number will be wrong.
1017          To avoid this problem set the lineno to 0 here; that prevents
1018          it from appearing in the RTL.  */
1019       tree stmts;
1020       location_t saved_location = input_location;
1021       input_location = UNKNOWN_LOCATION;
1022
1023       stmts = push_stmt_list ();
1024       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1025       stmts = pop_stmt_list (stmts);
1026       if (!IS_EMPTY_STMT (stmts))
1027         saved_function_name_decls
1028           = tree_cons (decl, stmts, saved_function_name_decls);
1029       *fname_vars[ix].decl = decl;
1030       input_location = saved_location;
1031     }
1032   if (!ix && !current_function_decl)
1033     pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1034
1035   return decl;
1036 }
1037
1038 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
1039
1040 tree
1041 fix_string_type (tree value)
1042 {
1043   int length = TREE_STRING_LENGTH (value);
1044   int nchars;
1045   tree e_type, i_type, a_type;
1046
1047   /* Compute the number of elements, for the array type.  */
1048   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1049     {
1050       nchars = length;
1051       e_type = char_type_node;
1052     }
1053   else if (TREE_TYPE (value) == char16_array_type_node)
1054     {
1055       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1056       e_type = char16_type_node;
1057     }
1058   else if (TREE_TYPE (value) == char32_array_type_node)
1059     {
1060       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1061       e_type = char32_type_node;
1062     }
1063   else
1064     {
1065       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1066       e_type = wchar_type_node;
1067     }
1068
1069   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
1070      limit in C++98 Annex B is very large (65536) and is not normative,
1071      so we do not diagnose it (warn_overlength_strings is forced off
1072      in c_common_post_options).  */
1073   if (warn_overlength_strings)
1074     {
1075       const int nchars_max = flag_isoc99 ? 4095 : 509;
1076       const int relevant_std = flag_isoc99 ? 99 : 90;
1077       if (nchars - 1 > nchars_max)
1078         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
1079            separate the %d from the 'C'.  'ISO' should not be
1080            translated, but it may be moved after 'C%d' in languages
1081            where modifiers follow nouns.  */
1082         pedwarn (input_location, OPT_Woverlength_strings,
1083                  "string length %qd is greater than the length %qd "
1084                  "ISO C%d compilers are required to support",
1085                  nchars - 1, nchars_max, relevant_std);
1086     }
1087
1088   /* Create the array type for the string constant.  The ISO C++
1089      standard says that a string literal has type `const char[N]' or
1090      `const wchar_t[N]'.  We use the same logic when invoked as a C
1091      front-end with -Wwrite-strings.
1092      ??? We should change the type of an expression depending on the
1093      state of a warning flag.  We should just be warning -- see how
1094      this is handled in the C++ front-end for the deprecated implicit
1095      conversion from string literals to `char*' or `wchar_t*'.
1096
1097      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1098      array type being the unqualified version of that type.
1099      Therefore, if we are constructing an array of const char, we must
1100      construct the matching unqualified array type first.  The C front
1101      end does not require this, but it does no harm, so we do it
1102      unconditionally.  */
1103   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1104   a_type = build_array_type (e_type, i_type);
1105   if (c_dialect_cxx() || warn_write_strings)
1106     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1107
1108   TREE_TYPE (value) = a_type;
1109   TREE_CONSTANT (value) = 1;
1110   TREE_READONLY (value) = 1;
1111   TREE_STATIC (value) = 1;
1112   return value;
1113 }
1114 \f
1115 /* Fully fold EXPR, an expression that was not folded (beyond integer
1116    constant expressions and null pointer constants) when being built
1117    up.  If IN_INIT, this is in a static initializer and certain
1118    changes are made to the folding done.  Clear *MAYBE_CONST if
1119    MAYBE_CONST is not NULL and EXPR is definitely not a constant
1120    expression because it contains an evaluated operator (in C99) or an
1121    operator outside of sizeof returning an integer constant (in C90)
1122    not permitted in constant expressions, or because it contains an
1123    evaluated arithmetic overflow.  (*MAYBE_CONST should typically be
1124    set to true by callers before calling this function.)  Return the
1125    folded expression.  Function arguments have already been folded
1126    before calling this function, as have the contents of SAVE_EXPR,
1127    TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1128    C_MAYBE_CONST_EXPR.  */
1129
1130 tree
1131 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1132 {
1133   tree ret;
1134   tree eptype = NULL_TREE;
1135   bool dummy = true;
1136   bool maybe_const_itself = true;
1137
1138   /* This function is not relevant to C++ because C++ folds while
1139      parsing, and may need changes to be correct for C++ when C++
1140      stops folding while parsing.  */
1141   if (c_dialect_cxx ())
1142     gcc_unreachable ();
1143
1144   if (!maybe_const)
1145     maybe_const = &dummy;
1146   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1147     {
1148       eptype = TREE_TYPE (expr);
1149       expr = TREE_OPERAND (expr, 0);
1150     }
1151   ret = c_fully_fold_internal (expr, in_init, maybe_const,
1152                                &maybe_const_itself);
1153   if (eptype)
1154     ret = fold_convert (eptype, ret);
1155   *maybe_const &= maybe_const_itself;
1156   return ret;
1157 }
1158
1159 /* Internal helper for c_fully_fold.  EXPR and IN_INIT are as for
1160    c_fully_fold.  *MAYBE_CONST_OPERANDS is cleared because of operands
1161    not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1162    arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1163    both evaluated and unevaluated subexpressions while
1164    *MAYBE_CONST_ITSELF is carried from only evaluated
1165    subexpressions).  */
1166
1167 static tree
1168 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1169                        bool *maybe_const_itself)
1170 {
1171   tree ret = expr;
1172   enum tree_code code = TREE_CODE (expr);
1173   enum tree_code_class kind = TREE_CODE_CLASS (code);
1174   location_t loc = EXPR_LOCATION (expr);
1175   tree op0, op1, op2, op3;
1176   tree orig_op0, orig_op1, orig_op2;
1177   bool op0_const = true, op1_const = true, op2_const = true;
1178   bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1179   bool nowarning = TREE_NO_WARNING (expr);
1180
1181   /* This function is not relevant to C++ because C++ folds while
1182      parsing, and may need changes to be correct for C++ when C++
1183      stops folding while parsing.  */
1184   if (c_dialect_cxx ())
1185     gcc_unreachable ();
1186
1187   /* Constants, declarations, statements, errors, SAVE_EXPRs and
1188      anything else not counted as an expression cannot usefully be
1189      folded further at this point.  */
1190   if (!IS_EXPR_CODE_CLASS (kind)
1191       || kind == tcc_statement
1192       || code == SAVE_EXPR)
1193     return expr;
1194
1195   /* Operands of variable-length expressions (function calls) have
1196      already been folded, as have __builtin_* function calls, and such
1197      expressions cannot occur in constant expressions.  */
1198   if (kind == tcc_vl_exp)
1199     {
1200       *maybe_const_operands = false;
1201       ret = fold (expr);
1202       goto out;
1203     }
1204
1205   if (code == C_MAYBE_CONST_EXPR)
1206     {
1207       tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1208       tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1209       if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1210         *maybe_const_operands = false;
1211       if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1212         *maybe_const_itself = false;
1213       if (pre && !in_init)
1214         ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1215       else
1216         ret = inner;
1217       goto out;
1218     }
1219
1220   /* Assignment, increment, decrement, function call and comma
1221      operators, and statement expressions, cannot occur in constant
1222      expressions if evaluated / outside of sizeof.  (Function calls
1223      were handled above, though VA_ARG_EXPR is treated like a function
1224      call here, and statement expressions are handled through
1225      C_MAYBE_CONST_EXPR to avoid folding inside them.)  */
1226   switch (code)
1227     {
1228     case MODIFY_EXPR:
1229     case PREDECREMENT_EXPR:
1230     case PREINCREMENT_EXPR:
1231     case POSTDECREMENT_EXPR:
1232     case POSTINCREMENT_EXPR:
1233     case COMPOUND_EXPR:
1234       *maybe_const_operands = false;
1235       break;
1236
1237     case VA_ARG_EXPR:
1238     case TARGET_EXPR:
1239     case BIND_EXPR:
1240     case OBJ_TYPE_REF:
1241       *maybe_const_operands = false;
1242       ret = fold (expr);
1243       goto out;
1244
1245     default:
1246       break;
1247     }
1248
1249   /* Fold individual tree codes as appropriate.  */
1250   switch (code)
1251     {
1252     case COMPOUND_LITERAL_EXPR:
1253       /* Any non-constancy will have been marked in a containing
1254          C_MAYBE_CONST_EXPR; there is no more folding to do here.  */
1255       goto out;
1256
1257     case COMPONENT_REF:
1258       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1259       op1 = TREE_OPERAND (expr, 1);
1260       op2 = TREE_OPERAND (expr, 2);
1261       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1262                                    maybe_const_itself);
1263       if (op0 != orig_op0)
1264         ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1265       if (ret != expr)
1266         {
1267           TREE_READONLY (ret) = TREE_READONLY (expr);
1268           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1269         }
1270       goto out;
1271
1272     case ARRAY_REF:
1273       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1274       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1275       op2 = TREE_OPERAND (expr, 2);
1276       op3 = TREE_OPERAND (expr, 3);
1277       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1278                                    maybe_const_itself);
1279       op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1280                                    maybe_const_itself);
1281       op1 = decl_constant_value_for_optimization (op1);
1282       if (op0 != orig_op0 || op1 != orig_op1)
1283         ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1284       if (ret != expr)
1285         {
1286           TREE_READONLY (ret) = TREE_READONLY (expr);
1287           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1288           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1289         }
1290       ret = fold (ret);
1291       goto out;
1292
1293     case COMPOUND_EXPR:
1294     case MODIFY_EXPR:
1295     case PREDECREMENT_EXPR:
1296     case PREINCREMENT_EXPR:
1297     case POSTDECREMENT_EXPR:
1298     case POSTINCREMENT_EXPR:
1299     case PLUS_EXPR:
1300     case MINUS_EXPR:
1301     case MULT_EXPR:
1302     case POINTER_PLUS_EXPR:
1303     case TRUNC_DIV_EXPR:
1304     case CEIL_DIV_EXPR:
1305     case FLOOR_DIV_EXPR:
1306     case TRUNC_MOD_EXPR:
1307     case RDIV_EXPR:
1308     case EXACT_DIV_EXPR:
1309     case LSHIFT_EXPR:
1310     case RSHIFT_EXPR:
1311     case BIT_IOR_EXPR:
1312     case BIT_XOR_EXPR:
1313     case BIT_AND_EXPR:
1314     case LT_EXPR:
1315     case LE_EXPR:
1316     case GT_EXPR:
1317     case GE_EXPR:
1318     case EQ_EXPR:
1319     case NE_EXPR:
1320     case COMPLEX_EXPR:
1321     case TRUTH_AND_EXPR:
1322     case TRUTH_OR_EXPR:
1323     case TRUTH_XOR_EXPR:
1324     case UNORDERED_EXPR:
1325     case ORDERED_EXPR:
1326     case UNLT_EXPR:
1327     case UNLE_EXPR:
1328     case UNGT_EXPR:
1329     case UNGE_EXPR:
1330     case UNEQ_EXPR:
1331       /* Binary operations evaluating both arguments (increment and
1332          decrement are binary internally in GCC).  */
1333       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1334       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1335       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1336                                    maybe_const_itself);
1337       if (code != MODIFY_EXPR
1338           && code != PREDECREMENT_EXPR
1339           && code != PREINCREMENT_EXPR
1340           && code != POSTDECREMENT_EXPR
1341           && code != POSTINCREMENT_EXPR)
1342         op0 = decl_constant_value_for_optimization (op0);
1343       /* The RHS of a MODIFY_EXPR was fully folded when building that
1344          expression for the sake of conversion warnings.  */
1345       if (code != MODIFY_EXPR)
1346         op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1347                                      maybe_const_itself);
1348       op1 = decl_constant_value_for_optimization (op1);
1349       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1350         ret = in_init
1351           ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1352           : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1353       else
1354         ret = fold (expr);
1355       goto out;
1356
1357     case INDIRECT_REF:
1358     case FIX_TRUNC_EXPR:
1359     case FLOAT_EXPR:
1360     CASE_CONVERT:
1361     case NON_LVALUE_EXPR:
1362     case NEGATE_EXPR:
1363     case BIT_NOT_EXPR:
1364     case TRUTH_NOT_EXPR:
1365     case ADDR_EXPR:
1366     case CONJ_EXPR:
1367     case REALPART_EXPR:
1368     case IMAGPART_EXPR:
1369       /* Unary operations.  */
1370       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1371       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1372                                    maybe_const_itself);
1373       if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1374         op0 = decl_constant_value_for_optimization (op0);
1375       if (op0 != orig_op0 || in_init)
1376         ret = in_init
1377           ? fold_build1_initializer (code, TREE_TYPE (expr), op0)
1378           : fold_build1 (code, TREE_TYPE (expr), op0);
1379       else
1380         ret = fold (expr);
1381       if (code == INDIRECT_REF
1382           && ret != expr
1383           && TREE_CODE (ret) == INDIRECT_REF)
1384         {
1385           TREE_READONLY (ret) = TREE_READONLY (expr);
1386           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1387           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1388         }
1389       goto out;
1390
1391     case TRUTH_ANDIF_EXPR:
1392     case TRUTH_ORIF_EXPR:
1393       /* Binary operations not necessarily evaluating both
1394          arguments.  */
1395       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1396       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1397       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1398       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1399       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1400         ret = in_init
1401           ? fold_build2_initializer (code, TREE_TYPE (expr), op0, op1)
1402           : fold_build2 (code, TREE_TYPE (expr), op0, op1);
1403       else
1404         ret = fold (expr);
1405       *maybe_const_operands &= op0_const;
1406       *maybe_const_itself &= op0_const_self;
1407       if (!(flag_isoc99
1408             && op0_const
1409             && op0_const_self
1410             && (code == TRUTH_ANDIF_EXPR
1411                 ? op0 == truthvalue_false_node
1412                 : op0 == truthvalue_true_node)))
1413         *maybe_const_operands &= op1_const;
1414       if (!(op0_const
1415             && op0_const_self
1416             && (code == TRUTH_ANDIF_EXPR
1417                 ? op0 == truthvalue_false_node
1418                 : op0 == truthvalue_true_node)))
1419         *maybe_const_itself &= op1_const_self;
1420       goto out;
1421
1422     case COND_EXPR:
1423       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1424       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1425       orig_op2 = op2 = TREE_OPERAND (expr, 2);
1426       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1427       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1428       op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1429       if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1430         ret = fold_build3 (code, TREE_TYPE (expr), op0, op1, op2);
1431       else
1432         ret = fold (expr);
1433       *maybe_const_operands &= op0_const;
1434       *maybe_const_itself &= op0_const_self;
1435       if (!(flag_isoc99
1436             && op0_const
1437             && op0_const_self
1438             && op0 == truthvalue_false_node))
1439         *maybe_const_operands &= op1_const;
1440       if (!(op0_const
1441             && op0_const_self
1442             && op0 == truthvalue_false_node))
1443         *maybe_const_itself &= op1_const_self;
1444       if (!(flag_isoc99
1445             && op0_const
1446             && op0_const_self
1447             && op0 == truthvalue_true_node))
1448         *maybe_const_operands &= op2_const;
1449       if (!(op0_const
1450             && op0_const_self
1451             && op0 == truthvalue_true_node))
1452         *maybe_const_itself &= op2_const_self;
1453       goto out;
1454
1455     case EXCESS_PRECISION_EXPR:
1456       /* Each case where an operand with excess precision may be
1457          encountered must remove the EXCESS_PRECISION_EXPR around
1458          inner operands and possibly put one around the whole
1459          expression or possibly convert to the semantic type (which
1460          c_fully_fold does); we cannot tell at this stage which is
1461          appropriate in any particular case.  */
1462       gcc_unreachable ();
1463
1464     default:
1465       /* Various codes may appear through folding built-in functions
1466          and their arguments.  */
1467       goto out;
1468     }
1469
1470  out:
1471   /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1472      have been done by this point, so remove them again.  */
1473   nowarning |= TREE_NO_WARNING (ret);
1474   STRIP_TYPE_NOPS (ret);
1475   if (nowarning && !TREE_NO_WARNING (ret))
1476     {
1477       if (!CAN_HAVE_LOCATION_P (ret))
1478         ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1479       TREE_NO_WARNING (ret) = 1;
1480     }
1481   if (ret != expr)
1482     protected_set_expr_location (ret, loc);
1483   return ret;
1484 }
1485
1486 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1487    return EXP.  Otherwise, return either EXP or its known constant
1488    value (if it has one), but return EXP if EXP has mode BLKmode.  ???
1489    Is the BLKmode test appropriate?  */
1490
1491 tree
1492 decl_constant_value_for_optimization (tree exp)
1493 {
1494   tree ret;
1495
1496   /* This function is only used by C, for c_fully_fold and other
1497      optimization, and may not be correct for C++.  */
1498   if (c_dialect_cxx ())
1499     gcc_unreachable ();
1500
1501   if (!optimize
1502       || TREE_CODE (exp) != VAR_DECL
1503       || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1504       || DECL_MODE (exp) == BLKmode)
1505     return exp;
1506
1507   ret = decl_constant_value (exp);
1508   /* Avoid unwanted tree sharing between the initializer and current
1509      function's body where the tree can be modified e.g. by the
1510      gimplifier.  */
1511   if (ret != exp && TREE_STATIC (exp))
1512     ret = unshare_expr (ret);
1513   return ret;
1514 }
1515
1516 /* Print a warning if a constant expression had overflow in folding.
1517    Invoke this function on every expression that the language
1518    requires to be a constant expression.
1519    Note the ANSI C standard says it is erroneous for a
1520    constant expression to overflow.  */
1521
1522 void
1523 constant_expression_warning (tree value)
1524 {
1525   if (warn_overflow && pedantic
1526       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1527           || TREE_CODE (value) == FIXED_CST
1528           || TREE_CODE (value) == VECTOR_CST
1529           || TREE_CODE (value) == COMPLEX_CST)
1530       && TREE_OVERFLOW (value))
1531     pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1532 }
1533
1534 /* The same as above but print an unconditional error.  */
1535 void
1536 constant_expression_error (tree value)
1537 {
1538   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1539        || TREE_CODE (value) == FIXED_CST
1540        || TREE_CODE (value) == VECTOR_CST
1541        || TREE_CODE (value) == COMPLEX_CST)
1542       && TREE_OVERFLOW (value))
1543     error ("overflow in constant expression");
1544 }
1545
1546 /* Print a warning if an expression had overflow in folding and its
1547    operands hadn't.
1548
1549    Invoke this function on every expression that
1550    (1) appears in the source code, and
1551    (2) is a constant expression that overflowed, and
1552    (3) is not already checked by convert_and_check;
1553    however, do not invoke this function on operands of explicit casts
1554    or when the expression is the result of an operator and any operand
1555    already overflowed.  */
1556
1557 void
1558 overflow_warning (tree value)
1559 {
1560   if (skip_evaluation) return;
1561
1562   switch (TREE_CODE (value))
1563     {
1564     case INTEGER_CST:
1565       warning (OPT_Woverflow, "integer overflow in expression");
1566       break;
1567
1568     case REAL_CST:
1569       warning (OPT_Woverflow, "floating point overflow in expression");
1570       break;
1571
1572     case FIXED_CST:
1573       warning (OPT_Woverflow, "fixed-point overflow in expression");
1574       break;
1575
1576     case VECTOR_CST:
1577       warning (OPT_Woverflow, "vector overflow in expression");
1578       break;
1579
1580     case COMPLEX_CST:
1581       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1582         warning (OPT_Woverflow, "complex integer overflow in expression");
1583       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1584         warning (OPT_Woverflow, "complex floating point overflow in expression");
1585       break;
1586
1587     default:
1588       break;
1589     }
1590 }
1591
1592
1593 /* Warn about use of a logical || / && operator being used in a
1594    context where it is likely that the bitwise equivalent was intended
1595    by the programmer. CODE is the TREE_CODE of the operator, ARG1
1596    and ARG2 the arguments.  */
1597
1598 void
1599 warn_logical_operator (enum tree_code code, tree arg1, tree
1600     arg2)
1601 {
1602   switch (code)
1603     {
1604       case TRUTH_ANDIF_EXPR:
1605       case TRUTH_ORIF_EXPR:
1606       case TRUTH_OR_EXPR:
1607       case TRUTH_AND_EXPR:
1608         if (!TREE_NO_WARNING (arg1)
1609             && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
1610             && !CONSTANT_CLASS_P (arg1)
1611             && TREE_CODE (arg2) == INTEGER_CST
1612             && !integer_zerop (arg2))
1613           {
1614             warning (OPT_Wlogical_op,
1615                      "logical %<%s%> with non-zero constant "
1616                      "will always evaluate as true",
1617                      ((code == TRUTH_ANDIF_EXPR)
1618                       || (code == TRUTH_AND_EXPR)) ? "&&" : "||");
1619             TREE_NO_WARNING (arg1) = true;
1620           }
1621         break;
1622       default:
1623         break;
1624     }
1625 }
1626
1627
1628 /* Print a warning about casts that might indicate violation
1629    of strict aliasing rules if -Wstrict-aliasing is used and
1630    strict aliasing mode is in effect. OTYPE is the original
1631    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1632
1633 bool
1634 strict_aliasing_warning (tree otype, tree type, tree expr)
1635 {
1636   if (!(flag_strict_aliasing
1637         && POINTER_TYPE_P (type)
1638         && POINTER_TYPE_P (otype)
1639         && !VOID_TYPE_P (TREE_TYPE (type)))
1640       /* If the type we are casting to is a ref-all pointer
1641          dereferencing it is always valid.  */
1642       || TYPE_REF_CAN_ALIAS_ALL (type))
1643     return false;
1644
1645   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1646       && (DECL_P (TREE_OPERAND (expr, 0))
1647           || handled_component_p (TREE_OPERAND (expr, 0))))
1648     {
1649       /* Casting the address of an object to non void pointer. Warn
1650          if the cast breaks type based aliasing.  */
1651       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1652         {
1653           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1654                    "might break strict-aliasing rules");
1655           return true;
1656         }
1657       else
1658         {
1659           /* warn_strict_aliasing >= 3.   This includes the default (3).
1660              Only warn if the cast is dereferenced immediately.  */
1661           alias_set_type set1 =
1662             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1663           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1664
1665           if (set1 != set2 && set2 != 0
1666               && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1667             {
1668               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1669                        "pointer will break strict-aliasing rules");
1670               return true;
1671             }
1672           else if (warn_strict_aliasing == 2
1673                    && !alias_sets_must_conflict_p (set1, set2))
1674             {
1675               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1676                        "pointer might break strict-aliasing rules");
1677               return true;
1678             }
1679         }
1680     }
1681   else
1682     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1683       {
1684         /* At this level, warn for any conversions, even if an address is
1685            not taken in the same statement.  This will likely produce many
1686            false positives, but could be useful to pinpoint problems that
1687            are not revealed at higher levels.  */
1688         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1689         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1690         if (!COMPLETE_TYPE_P (type)
1691             || !alias_sets_must_conflict_p (set1, set2))
1692           {
1693             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1694                      "pointer might break strict-aliasing rules");
1695             return true;
1696           }
1697       }
1698
1699   return false;
1700 }
1701
1702 /* Warn for unlikely, improbable, or stupid DECL declarations
1703    of `main'.  */
1704
1705 void
1706 check_main_parameter_types (tree decl)
1707 {
1708   tree args;
1709   int argct = 0;
1710
1711   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1712       args = TREE_CHAIN (args))
1713    {
1714      tree type = args ? TREE_VALUE (args) : 0;
1715
1716      if (type == void_type_node || type == error_mark_node )
1717        break;
1718
1719      ++argct;
1720      switch (argct)
1721        {
1722        case 1:
1723          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1724            pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1725                     decl);
1726          break;
1727
1728        case 2:
1729          if (TREE_CODE (type) != POINTER_TYPE
1730              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1731              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1732                  != char_type_node))
1733            pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1734                     decl);
1735          break;
1736
1737        case 3:
1738          if (TREE_CODE (type) != POINTER_TYPE
1739              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1740              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1741                  != char_type_node))
1742            pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1743                     "%<char **%>", decl);
1744          break;
1745        }
1746    }
1747
1748   /* It is intentional that this message does not mention the third
1749     argument because it's only mentioned in an appendix of the
1750     standard.  */
1751   if (argct > 0 && (argct < 2 || argct > 3))
1752     pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1753 }
1754
1755 /* True if pointers to distinct types T1 and T2 can be converted to
1756    each other without an explicit cast.  Only returns true for opaque
1757    vector types.  */
1758 bool
1759 vector_targets_convertible_p (const_tree t1, const_tree t2)
1760 {
1761   if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1762       && (targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1763       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1764     return true;
1765
1766   return false;
1767 }
1768
1769 /* True if vector types T1 and T2 can be converted to each other
1770    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1771    can only be converted with -flax-vector-conversions yet that is not
1772    in effect, emit a note telling the user about that option if such
1773    a note has not previously been emitted.  */
1774 bool
1775 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1776 {
1777   static bool emitted_lax_note = false;
1778   bool convertible_lax;
1779
1780   if ((targetm.vector_opaque_p (t1) || targetm.vector_opaque_p (t2))
1781       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1782     return true;
1783
1784   convertible_lax =
1785     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1786      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1787          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1788      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1789          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1790
1791   if (!convertible_lax || flag_lax_vector_conversions)
1792     return convertible_lax;
1793
1794   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1795       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1796     return true;
1797
1798   if (emit_lax_note && !emitted_lax_note)
1799     {
1800       emitted_lax_note = true;
1801       inform (input_location, "use -flax-vector-conversions to permit "
1802               "conversions between vectors with differing "
1803               "element types or numbers of subparts");
1804     }
1805
1806   return false;
1807 }
1808
1809 /* This is a helper function of build_binary_op.
1810
1811    For certain operations if both args were extended from the same
1812    smaller type, do the arithmetic in that type and then extend.
1813
1814    BITWISE indicates a bitwise operation.
1815    For them, this optimization is safe only if
1816    both args are zero-extended or both are sign-extended.
1817    Otherwise, we might change the result.
1818    Eg, (short)-1 | (unsigned short)-1 is (int)-1
1819    but calculated in (unsigned short) it would be (unsigned short)-1.
1820 */
1821 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1822 {
1823   int unsigned0, unsigned1;
1824   tree arg0, arg1;
1825   int uns;
1826   tree type;
1827
1828   /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
1829      excessive narrowing when we call get_narrower below.  For
1830      example, suppose that OP0 is of unsigned int extended
1831      from signed char and that RESULT_TYPE is long long int.
1832      If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1833      like
1834
1835      (long long int) (unsigned int) signed_char
1836
1837      which get_narrower would narrow down to
1838
1839      (unsigned int) signed char
1840
1841      If we do not cast OP0 first, get_narrower would return
1842      signed_char, which is inconsistent with the case of the
1843      explicit cast.  */
1844   op0 = convert (result_type, op0);
1845   op1 = convert (result_type, op1);
1846
1847   arg0 = get_narrower (op0, &unsigned0);
1848   arg1 = get_narrower (op1, &unsigned1);
1849
1850   /* UNS is 1 if the operation to be done is an unsigned one.  */
1851   uns = TYPE_UNSIGNED (result_type);
1852
1853   /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1854      but it *requires* conversion to FINAL_TYPE.  */
1855
1856   if ((TYPE_PRECISION (TREE_TYPE (op0))
1857        == TYPE_PRECISION (TREE_TYPE (arg0)))
1858       && TREE_TYPE (op0) != result_type)
1859     unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1860   if ((TYPE_PRECISION (TREE_TYPE (op1))
1861        == TYPE_PRECISION (TREE_TYPE (arg1)))
1862       && TREE_TYPE (op1) != result_type)
1863     unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1864
1865   /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
1866
1867   /* For bitwise operations, signedness of nominal type
1868      does not matter.  Consider only how operands were extended.  */
1869   if (bitwise)
1870     uns = unsigned0;
1871
1872   /* Note that in all three cases below we refrain from optimizing
1873      an unsigned operation on sign-extended args.
1874      That would not be valid.  */
1875
1876   /* Both args variable: if both extended in same way
1877      from same width, do it in that width.
1878      Do it unsigned if args were zero-extended.  */
1879   if ((TYPE_PRECISION (TREE_TYPE (arg0))
1880        < TYPE_PRECISION (result_type))
1881       && (TYPE_PRECISION (TREE_TYPE (arg1))
1882           == TYPE_PRECISION (TREE_TYPE (arg0)))
1883       && unsigned0 == unsigned1
1884       && (unsigned0 || !uns))
1885     return c_common_signed_or_unsigned_type
1886       (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1887
1888   else if (TREE_CODE (arg0) == INTEGER_CST
1889            && (unsigned1 || !uns)
1890            && (TYPE_PRECISION (TREE_TYPE (arg1))
1891                < TYPE_PRECISION (result_type))
1892            && (type
1893                = c_common_signed_or_unsigned_type (unsigned1,
1894                                                    TREE_TYPE (arg1)))
1895            && !POINTER_TYPE_P (type)
1896            && int_fits_type_p (arg0, type))
1897     return type;
1898
1899   else if (TREE_CODE (arg1) == INTEGER_CST
1900            && (unsigned0 || !uns)
1901            && (TYPE_PRECISION (TREE_TYPE (arg0))
1902                < TYPE_PRECISION (result_type))
1903            && (type
1904                = c_common_signed_or_unsigned_type (unsigned0,
1905                                                    TREE_TYPE (arg0)))
1906            && !POINTER_TYPE_P (type)
1907            && int_fits_type_p (arg1, type))
1908     return type;
1909
1910   return result_type;
1911 }
1912
1913 /* Warns if the conversion of EXPR to TYPE may alter a value.
1914    This is a helper function for warnings_for_convert_and_check.  */
1915
1916 static void
1917 conversion_warning (tree type, tree expr)
1918 {
1919   bool give_warning = false;
1920
1921   int i;
1922   const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
1923   tree expr_type = TREE_TYPE (expr);
1924
1925   if (!warn_conversion && !warn_sign_conversion)
1926     return;
1927
1928   /* If any operand is artificial, then this expression was generated
1929      by the compiler and we do not warn.  */
1930   for (i = 0; i < expr_num_operands; i++)
1931     {
1932       tree op = TREE_OPERAND (expr, i);
1933       if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
1934         return;
1935     }
1936
1937   switch (TREE_CODE (expr))
1938     {
1939     case EQ_EXPR:
1940     case NE_EXPR:
1941     case LE_EXPR:
1942     case GE_EXPR:
1943     case LT_EXPR:
1944     case GT_EXPR:
1945     case TRUTH_ANDIF_EXPR:
1946     case TRUTH_ORIF_EXPR:
1947     case TRUTH_AND_EXPR:
1948     case TRUTH_OR_EXPR:
1949     case TRUTH_XOR_EXPR:
1950     case TRUTH_NOT_EXPR:
1951       /* Conversion from boolean to a signed:1 bit-field (which only
1952          can hold the values 0 and -1) doesn't lose information - but
1953          it does change the value.  */
1954       if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
1955         warning (OPT_Wconversion,
1956                  "conversion to %qT from boolean expression", type);
1957       return;
1958
1959     case REAL_CST:
1960     case INTEGER_CST:
1961
1962       /* Warn for real constant that is not an exact integer converted
1963          to integer type.  */
1964       if (TREE_CODE (expr_type) == REAL_TYPE
1965           && TREE_CODE (type) == INTEGER_TYPE)
1966         {
1967           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
1968             give_warning = true;
1969         }
1970       /* Warn for an integer constant that does not fit into integer type.  */
1971       else if (TREE_CODE (expr_type) == INTEGER_TYPE
1972                && TREE_CODE (type) == INTEGER_TYPE
1973                && !int_fits_type_p (expr, type))
1974         {
1975           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
1976               && tree_int_cst_sgn (expr) < 0)
1977             warning (OPT_Wsign_conversion,
1978                      "negative integer implicitly converted to unsigned type");
1979           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
1980             warning (OPT_Wsign_conversion,  "conversion of unsigned constant "
1981                      "value to negative integer");
1982           else
1983             give_warning = true;
1984         }
1985       else if (TREE_CODE (type) == REAL_TYPE)
1986         {
1987           /* Warn for an integer constant that does not fit into real type.  */
1988           if (TREE_CODE (expr_type) == INTEGER_TYPE)
1989             {
1990               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
1991               if (!exact_real_truncate (TYPE_MODE (type), &a))
1992                 give_warning = true;
1993             }
1994           /* Warn for a real constant that does not fit into a smaller
1995              real type.  */
1996           else if (TREE_CODE (expr_type) == REAL_TYPE
1997                    && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
1998             {
1999               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2000               if (!exact_real_truncate (TYPE_MODE (type), &a))
2001                 give_warning = true;
2002             }
2003         }
2004
2005       if (give_warning)
2006         warning (OPT_Wconversion,
2007                  "conversion to %qT alters %qT constant value",
2008                  type, expr_type);
2009
2010       return;
2011
2012     case COND_EXPR:
2013       {
2014         /* In case of COND_EXPR, if both operands are constants or
2015            COND_EXPR, then we do not care about the type of COND_EXPR,
2016            only about the conversion of each operand.  */
2017         tree op1 = TREE_OPERAND (expr, 1);
2018         tree op2 = TREE_OPERAND (expr, 2);
2019
2020         if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2021              || TREE_CODE (op1) == COND_EXPR)
2022             && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2023                 || TREE_CODE (op2) == COND_EXPR))
2024           {
2025             conversion_warning (type, op1);
2026             conversion_warning (type, op2);
2027             return;
2028           }
2029         /* Fall through.  */
2030       }
2031
2032     default: /* 'expr' is not a constant.  */
2033
2034       /* Warn for real types converted to integer types.  */
2035       if (TREE_CODE (expr_type) == REAL_TYPE
2036           && TREE_CODE (type) == INTEGER_TYPE)
2037         give_warning = true;
2038
2039       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2040                && TREE_CODE (type) == INTEGER_TYPE)
2041         {
2042           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
2043           expr = get_unwidened (expr, 0);
2044           expr_type = TREE_TYPE (expr);
2045
2046           /* Don't warn for short y; short x = ((int)y & 0xff);  */
2047           if (TREE_CODE (expr) == BIT_AND_EXPR
2048                 || TREE_CODE (expr) == BIT_IOR_EXPR
2049               || TREE_CODE (expr) == BIT_XOR_EXPR)
2050             {
2051               /* If both args were extended from a shortest type,
2052                  use that type if that is safe.  */
2053               expr_type = shorten_binary_op (expr_type,
2054                                              TREE_OPERAND (expr, 0),
2055                                              TREE_OPERAND (expr, 1),
2056                                              /* bitwise */1);
2057
2058               if (TREE_CODE (expr) == BIT_AND_EXPR)
2059                 {
2060                   tree op0 = TREE_OPERAND (expr, 0);
2061                   tree op1 = TREE_OPERAND (expr, 1);
2062                   bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2063                   bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2064
2065                   /* If one of the operands is a non-negative constant
2066                      that fits in the target type, then the type of the
2067                      other operand does not matter. */
2068                   if ((TREE_CODE (op0) == INTEGER_CST
2069                        && int_fits_type_p (op0, c_common_signed_type (type))
2070                        && int_fits_type_p (op0, c_common_unsigned_type (type)))
2071                       || (TREE_CODE (op1) == INTEGER_CST
2072                           && int_fits_type_p (op1, c_common_signed_type (type))
2073                           && int_fits_type_p (op1,
2074                                               c_common_unsigned_type (type))))
2075                     return;
2076                   /* If constant is unsigned and fits in the target
2077                      type, then the result will also fit.  */
2078                   else if ((TREE_CODE (op0) == INTEGER_CST
2079                             && unsigned0
2080                             && int_fits_type_p (op0, type))
2081                            || (TREE_CODE (op1) == INTEGER_CST
2082                                && unsigned1
2083                                && int_fits_type_p (op1, type)))
2084                     return;
2085                 }
2086             }
2087           /* Warn for integer types converted to smaller integer types.  */
2088           if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2089             give_warning = true;
2090
2091           /* When they are the same width but different signedness,
2092              then the value may change.  */
2093           else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2094                     && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2095                    /* Even when converted to a bigger type, if the type is
2096                       unsigned but expr is signed, then negative values
2097                       will be changed.  */
2098                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2099             warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2100                      "may change the sign of the result",
2101                      type, expr_type);
2102         }
2103
2104       /* Warn for integer types converted to real types if and only if
2105          all the range of values of the integer type cannot be
2106          represented by the real type.  */
2107       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2108                && TREE_CODE (type) == REAL_TYPE)
2109         {
2110           tree type_low_bound = TYPE_MIN_VALUE (expr_type);
2111           tree type_high_bound = TYPE_MAX_VALUE (expr_type);
2112           REAL_VALUE_TYPE real_low_bound
2113             = real_value_from_int_cst (0, type_low_bound);
2114           REAL_VALUE_TYPE real_high_bound
2115             = real_value_from_int_cst (0, type_high_bound);
2116
2117           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2118               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2119             give_warning = true;
2120         }
2121
2122       /* Warn for real types converted to smaller real types.  */
2123       else if (TREE_CODE (expr_type) == REAL_TYPE
2124                && TREE_CODE (type) == REAL_TYPE
2125                && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2126         give_warning = true;
2127
2128
2129       if (give_warning)
2130         warning (OPT_Wconversion,
2131                  "conversion to %qT from %qT may alter its value",
2132                  type, expr_type);
2133     }
2134 }
2135
2136 /* Produce warnings after a conversion. RESULT is the result of
2137    converting EXPR to TYPE.  This is a helper function for
2138    convert_and_check and cp_convert_and_check.  */
2139
2140 void
2141 warnings_for_convert_and_check (tree type, tree expr, tree result)
2142 {
2143   if (TREE_CODE (expr) == INTEGER_CST
2144       && (TREE_CODE (type) == INTEGER_TYPE
2145           || TREE_CODE (type) == ENUMERAL_TYPE)
2146       && !int_fits_type_p (expr, type))
2147     {
2148       /* Do not diagnose overflow in a constant expression merely
2149          because a conversion overflowed.  */
2150       if (TREE_OVERFLOW (result))
2151         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2152
2153       if (TYPE_UNSIGNED (type))
2154         {
2155           /* This detects cases like converting -129 or 256 to
2156              unsigned char.  */
2157           if (!int_fits_type_p (expr, c_common_signed_type (type)))
2158             warning (OPT_Woverflow,
2159                      "large integer implicitly truncated to unsigned type");
2160           else
2161             conversion_warning (type, expr);
2162         }
2163       else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2164         warning (OPT_Woverflow,
2165                  "overflow in implicit constant conversion");
2166       /* No warning for converting 0x80000000 to int.  */
2167       else if (pedantic
2168                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2169                    || TYPE_PRECISION (TREE_TYPE (expr))
2170                    != TYPE_PRECISION (type)))
2171         warning (OPT_Woverflow,
2172                  "overflow in implicit constant conversion");
2173
2174       else
2175         conversion_warning (type, expr);
2176     }
2177   else if ((TREE_CODE (result) == INTEGER_CST
2178             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2179     warning (OPT_Woverflow,
2180              "overflow in implicit constant conversion");
2181   else
2182     conversion_warning (type, expr);
2183 }
2184
2185
2186 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2187    Invoke this function on every expression that is converted implicitly,
2188    i.e. because of language rules and not because of an explicit cast.  */
2189
2190 tree
2191 convert_and_check (tree type, tree expr)
2192 {
2193   tree result;
2194   tree expr_for_warning;
2195
2196   /* Convert from a value with possible excess precision rather than
2197      via the semantic type, but do not warn about values not fitting
2198      exactly in the semantic type.  */
2199   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2200     {
2201       tree orig_type = TREE_TYPE (expr);
2202       expr = TREE_OPERAND (expr, 0);
2203       expr_for_warning = convert (orig_type, expr);
2204       if (orig_type == type)
2205         return expr_for_warning;
2206     }
2207   else
2208     expr_for_warning = expr;
2209
2210   if (TREE_TYPE (expr) == type)
2211     return expr;
2212
2213   result = convert (type, expr);
2214
2215   if (!skip_evaluation && !TREE_OVERFLOW_P (expr) && result != error_mark_node)
2216     warnings_for_convert_and_check (type, expr_for_warning, result);
2217
2218   return result;
2219 }
2220 \f
2221 /* A node in a list that describes references to variables (EXPR), which are
2222    either read accesses if WRITER is zero, or write accesses, in which case
2223    WRITER is the parent of EXPR.  */
2224 struct tlist
2225 {
2226   struct tlist *next;
2227   tree expr, writer;
2228 };
2229
2230 /* Used to implement a cache the results of a call to verify_tree.  We only
2231    use this for SAVE_EXPRs.  */
2232 struct tlist_cache
2233 {
2234   struct tlist_cache *next;
2235   struct tlist *cache_before_sp;
2236   struct tlist *cache_after_sp;
2237   tree expr;
2238 };
2239
2240 /* Obstack to use when allocating tlist structures, and corresponding
2241    firstobj.  */
2242 static struct obstack tlist_obstack;
2243 static char *tlist_firstobj = 0;
2244
2245 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2246    warnings.  */
2247 static struct tlist *warned_ids;
2248 /* SAVE_EXPRs need special treatment.  We process them only once and then
2249    cache the results.  */
2250 static struct tlist_cache *save_expr_cache;
2251
2252 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2253 static void merge_tlist (struct tlist **, struct tlist *, int);
2254 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2255 static int warning_candidate_p (tree);
2256 static void warn_for_collisions (struct tlist *);
2257 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2258 static struct tlist *new_tlist (struct tlist *, tree, tree);
2259
2260 /* Create a new struct tlist and fill in its fields.  */
2261 static struct tlist *
2262 new_tlist (struct tlist *next, tree t, tree writer)
2263 {
2264   struct tlist *l;
2265   l = XOBNEW (&tlist_obstack, struct tlist);
2266   l->next = next;
2267   l->expr = t;
2268   l->writer = writer;
2269   return l;
2270 }
2271
2272 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
2273    is nonnull, we ignore any node we find which has a writer equal to it.  */
2274
2275 static void
2276 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2277 {
2278   while (add)
2279     {
2280       struct tlist *next = add->next;
2281       if (!copy)
2282         add->next = *to;
2283       if (!exclude_writer || add->writer != exclude_writer)
2284         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2285       add = next;
2286     }
2287 }
2288
2289 /* Merge the nodes of ADD into TO.  This merging process is done so that for
2290    each variable that already exists in TO, no new node is added; however if
2291    there is a write access recorded in ADD, and an occurrence on TO is only
2292    a read access, then the occurrence in TO will be modified to record the
2293    write.  */
2294
2295 static void
2296 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2297 {
2298   struct tlist **end = to;
2299
2300   while (*end)
2301     end = &(*end)->next;
2302
2303   while (add)
2304     {
2305       int found = 0;
2306       struct tlist *tmp2;
2307       struct tlist *next = add->next;
2308
2309       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2310         if (tmp2->expr == add->expr)
2311           {
2312             found = 1;
2313             if (!tmp2->writer)
2314               tmp2->writer = add->writer;
2315           }
2316       if (!found)
2317         {
2318           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2319           end = &(*end)->next;
2320           *end = 0;
2321         }
2322       add = next;
2323     }
2324 }
2325
2326 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
2327    references in list LIST conflict with it, excluding reads if ONLY writers
2328    is nonzero.  */
2329
2330 static void
2331 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2332                        int only_writes)
2333 {
2334   struct tlist *tmp;
2335
2336   /* Avoid duplicate warnings.  */
2337   for (tmp = warned_ids; tmp; tmp = tmp->next)
2338     if (tmp->expr == written)
2339       return;
2340
2341   while (list)
2342     {
2343       if (list->expr == written
2344           && list->writer != writer
2345           && (!only_writes || list->writer)
2346           && DECL_NAME (list->expr))
2347         {
2348           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2349           warning_at (EXPR_HAS_LOCATION (writer)
2350                       ? EXPR_LOCATION (writer) : input_location,
2351                       OPT_Wsequence_point, "operation on %qE may be undefined",
2352                       list->expr);
2353         }
2354       list = list->next;
2355     }
2356 }
2357
2358 /* Given a list LIST of references to variables, find whether any of these
2359    can cause conflicts due to missing sequence points.  */
2360
2361 static void
2362 warn_for_collisions (struct tlist *list)
2363 {
2364   struct tlist *tmp;
2365
2366   for (tmp = list; tmp; tmp = tmp->next)
2367     {
2368       if (tmp->writer)
2369         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2370     }
2371 }
2372
2373 /* Return nonzero if X is a tree that can be verified by the sequence point
2374    warnings.  */
2375 static int
2376 warning_candidate_p (tree x)
2377 {
2378   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
2379 }
2380
2381 /* Walk the tree X, and record accesses to variables.  If X is written by the
2382    parent tree, WRITER is the parent.
2383    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
2384    expression or its only operand forces a sequence point, then everything up
2385    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
2386    in PNO_SP.
2387    Once we return, we will have emitted warnings if any subexpression before
2388    such a sequence point could be undefined.  On a higher level, however, the
2389    sequence point may not be relevant, and we'll merge the two lists.
2390
2391    Example: (b++, a) + b;
2392    The call that processes the COMPOUND_EXPR will store the increment of B
2393    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
2394    processes the PLUS_EXPR will need to merge the two lists so that
2395    eventually, all accesses end up on the same list (and we'll warn about the
2396    unordered subexpressions b++ and b.
2397
2398    A note on merging.  If we modify the former example so that our expression
2399    becomes
2400      (b++, b) + a
2401    care must be taken not simply to add all three expressions into the final
2402    PNO_SP list.  The function merge_tlist takes care of that by merging the
2403    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2404    way, so that no more than one access to B is recorded.  */
2405
2406 static void
2407 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2408              tree writer)
2409 {
2410   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2411   enum tree_code code;
2412   enum tree_code_class cl;
2413
2414   /* X may be NULL if it is the operand of an empty statement expression
2415      ({ }).  */
2416   if (x == NULL)
2417     return;
2418
2419  restart:
2420   code = TREE_CODE (x);
2421   cl = TREE_CODE_CLASS (code);
2422
2423   if (warning_candidate_p (x))
2424     {
2425       *pno_sp = new_tlist (*pno_sp, x, writer);
2426       return;
2427     }
2428
2429   switch (code)
2430     {
2431     case CONSTRUCTOR:
2432       return;
2433
2434     case COMPOUND_EXPR:
2435     case TRUTH_ANDIF_EXPR:
2436     case TRUTH_ORIF_EXPR:
2437       tmp_before = tmp_nosp = tmp_list3 = 0;
2438       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2439       warn_for_collisions (tmp_nosp);
2440       merge_tlist (pbefore_sp, tmp_before, 0);
2441       merge_tlist (pbefore_sp, tmp_nosp, 0);
2442       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2443       merge_tlist (pbefore_sp, tmp_list3, 0);
2444       return;
2445
2446     case COND_EXPR:
2447       tmp_before = tmp_list2 = 0;
2448       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2449       warn_for_collisions (tmp_list2);
2450       merge_tlist (pbefore_sp, tmp_before, 0);
2451       merge_tlist (pbefore_sp, tmp_list2, 1);
2452
2453       tmp_list3 = tmp_nosp = 0;
2454       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2455       warn_for_collisions (tmp_nosp);
2456       merge_tlist (pbefore_sp, tmp_list3, 0);
2457
2458       tmp_list3 = tmp_list2 = 0;
2459       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2460       warn_for_collisions (tmp_list2);
2461       merge_tlist (pbefore_sp, tmp_list3, 0);
2462       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2463          two first, to avoid warning for (a ? b++ : b++).  */
2464       merge_tlist (&tmp_nosp, tmp_list2, 0);
2465       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2466       return;
2467
2468     case PREDECREMENT_EXPR:
2469     case PREINCREMENT_EXPR:
2470     case POSTDECREMENT_EXPR:
2471     case POSTINCREMENT_EXPR:
2472       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2473       return;
2474
2475     case MODIFY_EXPR:
2476       tmp_before = tmp_nosp = tmp_list3 = 0;
2477       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2478       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2479       /* Expressions inside the LHS are not ordered wrt. the sequence points
2480          in the RHS.  Example:
2481            *a = (a++, 2)
2482          Despite the fact that the modification of "a" is in the before_sp
2483          list (tmp_before), it conflicts with the use of "a" in the LHS.
2484          We can handle this by adding the contents of tmp_list3
2485          to those of tmp_before, and redoing the collision warnings for that
2486          list.  */
2487       add_tlist (&tmp_before, tmp_list3, x, 1);
2488       warn_for_collisions (tmp_before);
2489       /* Exclude the LHS itself here; we first have to merge it into the
2490          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
2491          didn't exclude the LHS, we'd get it twice, once as a read and once
2492          as a write.  */
2493       add_tlist (pno_sp, tmp_list3, x, 0);
2494       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2495
2496       merge_tlist (pbefore_sp, tmp_before, 0);
2497       if (warning_candidate_p (TREE_OPERAND (x, 0)))
2498         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2499       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2500       return;
2501
2502     case CALL_EXPR:
2503       /* We need to warn about conflicts among arguments and conflicts between
2504          args and the function address.  Side effects of the function address,
2505          however, are not ordered by the sequence point of the call.  */
2506       {
2507         call_expr_arg_iterator iter;
2508         tree arg;
2509         tmp_before = tmp_nosp = 0;
2510         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2511         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2512           {
2513             tmp_list2 = tmp_list3 = 0;
2514             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2515             merge_tlist (&tmp_list3, tmp_list2, 0);
2516             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2517           }
2518         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2519         warn_for_collisions (tmp_before);
2520         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2521         return;
2522       }
2523
2524     case TREE_LIST:
2525       /* Scan all the list, e.g. indices of multi dimensional array.  */
2526       while (x)
2527         {
2528           tmp_before = tmp_nosp = 0;
2529           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2530           merge_tlist (&tmp_nosp, tmp_before, 0);
2531           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2532           x = TREE_CHAIN (x);
2533         }
2534       return;
2535
2536     case SAVE_EXPR:
2537       {
2538         struct tlist_cache *t;
2539         for (t = save_expr_cache; t; t = t->next)
2540           if (t->expr == x)
2541             break;
2542
2543         if (!t)
2544           {
2545             t = XOBNEW (&tlist_obstack, struct tlist_cache);
2546             t->next = save_expr_cache;
2547             t->expr = x;
2548             save_expr_cache = t;
2549
2550             tmp_before = tmp_nosp = 0;
2551             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2552             warn_for_collisions (tmp_nosp);
2553
2554             tmp_list3 = 0;
2555             while (tmp_nosp)
2556               {
2557                 struct tlist *t = tmp_nosp;
2558                 tmp_nosp = t->next;
2559                 merge_tlist (&tmp_list3, t, 0);
2560               }
2561             t->cache_before_sp = tmp_before;
2562             t->cache_after_sp = tmp_list3;
2563           }
2564         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2565         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2566         return;
2567       }
2568
2569     case ADDR_EXPR:
2570       x = TREE_OPERAND (x, 0);
2571       if (DECL_P (x))
2572         return;
2573       writer = 0;
2574       goto restart;
2575
2576     default:
2577       /* For other expressions, simply recurse on their operands.
2578          Manual tail recursion for unary expressions.
2579          Other non-expressions need not be processed.  */
2580       if (cl == tcc_unary)
2581         {
2582           x = TREE_OPERAND (x, 0);
2583           writer = 0;
2584           goto restart;
2585         }
2586       else if (IS_EXPR_CODE_CLASS (cl))
2587         {
2588           int lp;
2589           int max = TREE_OPERAND_LENGTH (x);
2590           for (lp = 0; lp < max; lp++)
2591             {
2592               tmp_before = tmp_nosp = 0;
2593               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2594               merge_tlist (&tmp_nosp, tmp_before, 0);
2595               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2596             }
2597         }
2598       return;
2599     }
2600 }
2601
2602 /* Try to warn for undefined behavior in EXPR due to missing sequence
2603    points.  */
2604
2605 void
2606 verify_sequence_points (tree expr)
2607 {
2608   struct tlist *before_sp = 0, *after_sp = 0;
2609
2610   warned_ids = 0;
2611   save_expr_cache = 0;
2612   if (tlist_firstobj == 0)
2613     {
2614       gcc_obstack_init (&tlist_obstack);
2615       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2616     }
2617
2618   verify_tree (expr, &before_sp, &after_sp, 0);
2619   warn_for_collisions (after_sp);
2620   obstack_free (&tlist_obstack, tlist_firstobj);
2621 }
2622 \f
2623 /* Validate the expression after `case' and apply default promotions.  */
2624
2625 static tree
2626 check_case_value (tree value)
2627 {
2628   if (value == NULL_TREE)
2629     return value;
2630
2631   /* ??? Can we ever get nops here for a valid case value?  We
2632      shouldn't for C.  */
2633   STRIP_TYPE_NOPS (value);
2634   /* In C++, the following is allowed:
2635
2636        const int i = 3;
2637        switch (...) { case i: ... }
2638
2639      So, we try to reduce the VALUE to a constant that way.  */
2640   if (c_dialect_cxx ())
2641     {
2642       value = decl_constant_value (value);
2643       STRIP_TYPE_NOPS (value);
2644       value = fold (value);
2645     }
2646
2647   if (TREE_CODE (value) == INTEGER_CST)
2648     /* Promote char or short to int.  */
2649     value = perform_integral_promotions (value);
2650   else if (value != error_mark_node)
2651     {
2652       error ("case label does not reduce to an integer constant");
2653       value = error_mark_node;
2654     }
2655
2656   constant_expression_warning (value);
2657
2658   return value;
2659 }
2660 \f
2661 /* See if the case values LOW and HIGH are in the range of the original
2662    type (i.e. before the default conversion to int) of the switch testing
2663    expression.
2664    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2665    the type before promoting it.  CASE_LOW_P is a pointer to the lower
2666    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2667    if the case is not a case range.
2668    The caller has to make sure that we are not called with NULL for
2669    CASE_LOW_P (i.e. the default case).
2670    Returns true if the case label is in range of ORIG_TYPE (saturated or
2671    untouched) or false if the label is out of range.  */
2672
2673 static bool
2674 check_case_bounds (tree type, tree orig_type,
2675                    tree *case_low_p, tree *case_high_p)
2676 {
2677   tree min_value, max_value;
2678   tree case_low = *case_low_p;
2679   tree case_high = case_high_p ? *case_high_p : case_low;
2680
2681   /* If there was a problem with the original type, do nothing.  */
2682   if (orig_type == error_mark_node)
2683     return true;
2684
2685   min_value = TYPE_MIN_VALUE (orig_type);
2686   max_value = TYPE_MAX_VALUE (orig_type);
2687
2688   /* Case label is less than minimum for type.  */
2689   if (tree_int_cst_compare (case_low, min_value) < 0
2690       && tree_int_cst_compare (case_high, min_value) < 0)
2691     {
2692       warning (0, "case label value is less than minimum value for type");
2693       return false;
2694     }
2695
2696   /* Case value is greater than maximum for type.  */
2697   if (tree_int_cst_compare (case_low, max_value) > 0
2698       && tree_int_cst_compare (case_high, max_value) > 0)
2699     {
2700       warning (0, "case label value exceeds maximum value for type");
2701       return false;
2702     }
2703
2704   /* Saturate lower case label value to minimum.  */
2705   if (tree_int_cst_compare (case_high, min_value) >= 0
2706       && tree_int_cst_compare (case_low, min_value) < 0)
2707     {
2708       warning (0, "lower value in case label range"
2709                " less than minimum value for type");
2710       case_low = min_value;
2711     }
2712
2713   /* Saturate upper case label value to maximum.  */
2714   if (tree_int_cst_compare (case_low, max_value) <= 0
2715       && tree_int_cst_compare (case_high, max_value) > 0)
2716     {
2717       warning (0, "upper value in case label range"
2718                " exceeds maximum value for type");
2719       case_high = max_value;
2720     }
2721
2722   if (*case_low_p != case_low)
2723     *case_low_p = convert (type, case_low);
2724   if (case_high_p && *case_high_p != case_high)
2725     *case_high_p = convert (type, case_high);
2726
2727   return true;
2728 }
2729 \f
2730 /* Return an integer type with BITS bits of precision,
2731    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2732
2733 tree
2734 c_common_type_for_size (unsigned int bits, int unsignedp)
2735 {
2736   if (bits == TYPE_PRECISION (integer_type_node))
2737     return unsignedp ? unsigned_type_node : integer_type_node;
2738
2739   if (bits == TYPE_PRECISION (signed_char_type_node))
2740     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2741
2742   if (bits == TYPE_PRECISION (short_integer_type_node))
2743     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2744
2745   if (bits == TYPE_PRECISION (long_integer_type_node))
2746     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2747
2748   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2749     return (unsignedp ? long_long_unsigned_type_node
2750             : long_long_integer_type_node);
2751
2752   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2753     return (unsignedp ? widest_unsigned_literal_type_node
2754             : widest_integer_literal_type_node);
2755
2756   if (bits <= TYPE_PRECISION (intQI_type_node))
2757     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2758
2759   if (bits <= TYPE_PRECISION (intHI_type_node))
2760     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2761
2762   if (bits <= TYPE_PRECISION (intSI_type_node))
2763     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2764
2765   if (bits <= TYPE_PRECISION (intDI_type_node))
2766     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2767
2768   return 0;
2769 }
2770
2771 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2772    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2773    and saturating if SATP is nonzero, otherwise not saturating.  */
2774
2775 tree
2776 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2777                                     int unsignedp, int satp)
2778 {
2779   enum machine_mode mode;
2780   if (ibit == 0)
2781     mode = unsignedp ? UQQmode : QQmode;
2782   else
2783     mode = unsignedp ? UHAmode : HAmode;
2784
2785   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2786     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2787       break;
2788
2789   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2790     {
2791       sorry ("GCC cannot support operators with integer types and "
2792              "fixed-point types that have too many integral and "
2793              "fractional bits together");
2794       return 0;
2795     }
2796
2797   return c_common_type_for_mode (mode, satp);
2798 }
2799
2800 /* Used for communication between c_common_type_for_mode and
2801    c_register_builtin_type.  */
2802 static GTY(()) tree registered_builtin_types;
2803
2804 /* Return a data type that has machine mode MODE.
2805    If the mode is an integer,
2806    then UNSIGNEDP selects between signed and unsigned types.
2807    If the mode is a fixed-point mode,
2808    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2809
2810 tree
2811 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2812 {
2813   tree t;
2814
2815   if (mode == TYPE_MODE (integer_type_node))
2816     return unsignedp ? unsigned_type_node : integer_type_node;
2817
2818   if (mode == TYPE_MODE (signed_char_type_node))
2819     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2820
2821   if (mode == TYPE_MODE (short_integer_type_node))
2822     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2823
2824   if (mode == TYPE_MODE (long_integer_type_node))
2825     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2826
2827   if (mode == TYPE_MODE (long_long_integer_type_node))
2828     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2829
2830   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2831     return unsignedp ? widest_unsigned_literal_type_node
2832                      : widest_integer_literal_type_node;
2833
2834   if (mode == QImode)
2835     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2836
2837   if (mode == HImode)
2838     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2839
2840   if (mode == SImode)
2841     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2842
2843   if (mode == DImode)
2844     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2845
2846 #if HOST_BITS_PER_WIDE_INT >= 64
2847   if (mode == TYPE_MODE (intTI_type_node))
2848     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2849 #endif
2850
2851   if (mode == TYPE_MODE (float_type_node))
2852     return float_type_node;
2853
2854   if (mode == TYPE_MODE (double_type_node))
2855     return double_type_node;
2856
2857   if (mode == TYPE_MODE (long_double_type_node))
2858     return long_double_type_node;
2859
2860   if (mode == TYPE_MODE (void_type_node))
2861     return void_type_node;
2862
2863   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2864     return (unsignedp
2865             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2866             : make_signed_type (GET_MODE_PRECISION (mode)));
2867
2868   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2869     return (unsignedp
2870             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2871             : make_signed_type (GET_MODE_PRECISION (mode)));
2872
2873   if (COMPLEX_MODE_P (mode))
2874     {
2875       enum machine_mode inner_mode;
2876       tree inner_type;
2877
2878       if (mode == TYPE_MODE (complex_float_type_node))
2879         return complex_float_type_node;
2880       if (mode == TYPE_MODE (complex_double_type_node))
2881         return complex_double_type_node;
2882       if (mode == TYPE_MODE (complex_long_double_type_node))
2883         return complex_long_double_type_node;
2884
2885       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2886         return complex_integer_type_node;
2887
2888       inner_mode = GET_MODE_INNER (mode);
2889       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2890       if (inner_type != NULL_TREE)
2891         return build_complex_type (inner_type);
2892     }
2893   else if (VECTOR_MODE_P (mode))
2894     {
2895       enum machine_mode inner_mode = GET_MODE_INNER (mode);
2896       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2897       if (inner_type != NULL_TREE)
2898         return build_vector_type_for_mode (inner_type, mode);
2899     }
2900
2901   if (mode == TYPE_MODE (dfloat32_type_node))
2902     return dfloat32_type_node;
2903   if (mode == TYPE_MODE (dfloat64_type_node))
2904     return dfloat64_type_node;
2905   if (mode == TYPE_MODE (dfloat128_type_node))
2906     return dfloat128_type_node;
2907
2908   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
2909     {
2910       if (mode == TYPE_MODE (short_fract_type_node))
2911         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
2912       if (mode == TYPE_MODE (fract_type_node))
2913         return unsignedp ? sat_fract_type_node : fract_type_node;
2914       if (mode == TYPE_MODE (long_fract_type_node))
2915         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
2916       if (mode == TYPE_MODE (long_long_fract_type_node))
2917         return unsignedp ? sat_long_long_fract_type_node
2918                          : long_long_fract_type_node;
2919
2920       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
2921         return unsignedp ? sat_unsigned_short_fract_type_node
2922                          : unsigned_short_fract_type_node;
2923       if (mode == TYPE_MODE (unsigned_fract_type_node))
2924         return unsignedp ? sat_unsigned_fract_type_node
2925                          : unsigned_fract_type_node;
2926       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
2927         return unsignedp ? sat_unsigned_long_fract_type_node
2928                          : unsigned_long_fract_type_node;
2929       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
2930         return unsignedp ? sat_unsigned_long_long_fract_type_node
2931                          : unsigned_long_long_fract_type_node;
2932
2933       if (mode == TYPE_MODE (short_accum_type_node))
2934         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
2935       if (mode == TYPE_MODE (accum_type_node))
2936         return unsignedp ? sat_accum_type_node : accum_type_node;
2937       if (mode == TYPE_MODE (long_accum_type_node))
2938         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
2939       if (mode == TYPE_MODE (long_long_accum_type_node))
2940         return unsignedp ? sat_long_long_accum_type_node
2941                          : long_long_accum_type_node;
2942
2943       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
2944         return unsignedp ? sat_unsigned_short_accum_type_node
2945                          : unsigned_short_accum_type_node;
2946       if (mode == TYPE_MODE (unsigned_accum_type_node))
2947         return unsignedp ? sat_unsigned_accum_type_node
2948                          : unsigned_accum_type_node;
2949       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
2950         return unsignedp ? sat_unsigned_long_accum_type_node
2951                          : unsigned_long_accum_type_node;
2952       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
2953         return unsignedp ? sat_unsigned_long_long_accum_type_node
2954                          : unsigned_long_long_accum_type_node;
2955
2956       if (mode == QQmode)
2957         return unsignedp ? sat_qq_type_node : qq_type_node;
2958       if (mode == HQmode)
2959         return unsignedp ? sat_hq_type_node : hq_type_node;
2960       if (mode == SQmode)
2961         return unsignedp ? sat_sq_type_node : sq_type_node;
2962       if (mode == DQmode)
2963         return unsignedp ? sat_dq_type_node : dq_type_node;
2964       if (mode == TQmode)
2965         return unsignedp ? sat_tq_type_node : tq_type_node;
2966
2967       if (mode == UQQmode)
2968         return unsignedp ? sat_uqq_type_node : uqq_type_node;
2969       if (mode == UHQmode)
2970         return unsignedp ? sat_uhq_type_node : uhq_type_node;
2971       if (mode == USQmode)
2972         return unsignedp ? sat_usq_type_node : usq_type_node;
2973       if (mode == UDQmode)
2974         return unsignedp ? sat_udq_type_node : udq_type_node;
2975       if (mode == UTQmode)
2976         return unsignedp ? sat_utq_type_node : utq_type_node;
2977
2978       if (mode == HAmode)
2979         return unsignedp ? sat_ha_type_node : ha_type_node;
2980       if (mode == SAmode)
2981         return unsignedp ? sat_sa_type_node : sa_type_node;
2982       if (mode == DAmode)
2983         return unsignedp ? sat_da_type_node : da_type_node;
2984       if (mode == TAmode)
2985         return unsignedp ? sat_ta_type_node : ta_type_node;
2986
2987       if (mode == UHAmode)
2988         return unsignedp ? sat_uha_type_node : uha_type_node;
2989       if (mode == USAmode)
2990         return unsignedp ? sat_usa_type_node : usa_type_node;
2991       if (mode == UDAmode)
2992         return unsignedp ? sat_uda_type_node : uda_type_node;
2993       if (mode == UTAmode)
2994         return unsignedp ? sat_uta_type_node : uta_type_node;
2995     }
2996
2997   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
2998     if (TYPE_MODE (TREE_VALUE (t)) == mode)
2999       return TREE_VALUE (t);
3000
3001   return 0;
3002 }
3003
3004 tree
3005 c_common_unsigned_type (tree type)
3006 {
3007   return c_common_signed_or_unsigned_type (1, type);
3008 }
3009
3010 /* Return a signed type the same as TYPE in other respects.  */
3011
3012 tree
3013 c_common_signed_type (tree type)
3014 {
3015   return c_common_signed_or_unsigned_type (0, type);
3016 }
3017
3018 /* Return a type the same as TYPE except unsigned or
3019    signed according to UNSIGNEDP.  */
3020
3021 tree
3022 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3023 {
3024   tree type1;
3025
3026   /* This block of code emulates the behavior of the old
3027      c_common_unsigned_type. In particular, it returns
3028      long_unsigned_type_node if passed a long, even when a int would
3029      have the same size. This is necessary for warnings to work
3030      correctly in archs where sizeof(int) == sizeof(long) */
3031
3032   type1 = TYPE_MAIN_VARIANT (type);
3033   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3034     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3035   if (type1 == integer_type_node || type1 == unsigned_type_node)
3036     return unsignedp ? unsigned_type_node : integer_type_node;
3037   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3038     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3039   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3040     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3041   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3042     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3043   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3044     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3045 #if HOST_BITS_PER_WIDE_INT >= 64
3046   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3047     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3048 #endif
3049   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3050     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3051   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3052     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3053   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3054     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3055   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3056     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3057
3058 #define C_COMMON_FIXED_TYPES(NAME)          \
3059   if (type1 == short_ ## NAME ## _type_node \
3060       || type1 == unsigned_short_ ## NAME ## _type_node) \
3061     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3062                      : short_ ## NAME ## _type_node; \
3063   if (type1 == NAME ## _type_node \
3064       || type1 == unsigned_ ## NAME ## _type_node) \
3065     return unsignedp ? unsigned_ ## NAME ## _type_node \
3066                      : NAME ## _type_node; \
3067   if (type1 == long_ ## NAME ## _type_node \
3068       || type1 == unsigned_long_ ## NAME ## _type_node) \
3069     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3070                      : long_ ## NAME ## _type_node; \
3071   if (type1 == long_long_ ## NAME ## _type_node \
3072       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3073     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3074                      : long_long_ ## NAME ## _type_node;
3075
3076 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3077   if (type1 == NAME ## _type_node \
3078       || type1 == u ## NAME ## _type_node) \
3079     return unsignedp ? u ## NAME ## _type_node \
3080                      : NAME ## _type_node;
3081
3082 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3083   if (type1 == sat_ ## short_ ## NAME ## _type_node \
3084       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3085     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3086                      : sat_ ## short_ ## NAME ## _type_node; \
3087   if (type1 == sat_ ## NAME ## _type_node \
3088       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3089     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3090                      : sat_ ## NAME ## _type_node; \
3091   if (type1 == sat_ ## long_ ## NAME ## _type_node \
3092       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3093     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3094                      : sat_ ## long_ ## NAME ## _type_node; \
3095   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3096       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3097     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3098                      : sat_ ## long_long_ ## NAME ## _type_node;
3099
3100 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
3101   if (type1 == sat_ ## NAME ## _type_node \
3102       || type1 == sat_ ## u ## NAME ## _type_node) \
3103     return unsignedp ? sat_ ## u ## NAME ## _type_node \
3104                      : sat_ ## NAME ## _type_node;
3105
3106   C_COMMON_FIXED_TYPES (fract);
3107   C_COMMON_FIXED_TYPES_SAT (fract);
3108   C_COMMON_FIXED_TYPES (accum);
3109   C_COMMON_FIXED_TYPES_SAT (accum);
3110
3111   C_COMMON_FIXED_MODE_TYPES (qq);
3112   C_COMMON_FIXED_MODE_TYPES (hq);
3113   C_COMMON_FIXED_MODE_TYPES (sq);
3114   C_COMMON_FIXED_MODE_TYPES (dq);
3115   C_COMMON_FIXED_MODE_TYPES (tq);
3116   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3117   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3118   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3119   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3120   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3121   C_COMMON_FIXED_MODE_TYPES (ha);
3122   C_COMMON_FIXED_MODE_TYPES (sa);
3123   C_COMMON_FIXED_MODE_TYPES (da);
3124   C_COMMON_FIXED_MODE_TYPES (ta);
3125   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3126   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3127   C_COMMON_FIXED_MODE_TYPES_SAT (da);
3128   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3129
3130   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3131      the precision; they have precision set to match their range, but
3132      may use a wider mode to match an ABI.  If we change modes, we may
3133      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
3134      the precision as well, so as to yield correct results for
3135      bit-field types.  C++ does not have these separate bit-field
3136      types, and producing a signed or unsigned variant of an
3137      ENUMERAL_TYPE may cause other problems as well.  */
3138
3139   if (!INTEGRAL_TYPE_P (type)
3140       || TYPE_UNSIGNED (type) == unsignedp)
3141     return type;
3142
3143 #define TYPE_OK(node)                                                       \
3144   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
3145    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3146   if (TYPE_OK (signed_char_type_node))
3147     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3148   if (TYPE_OK (integer_type_node))
3149     return unsignedp ? unsigned_type_node : integer_type_node;
3150   if (TYPE_OK (short_integer_type_node))
3151     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3152   if (TYPE_OK (long_integer_type_node))
3153     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3154   if (TYPE_OK (long_long_integer_type_node))
3155     return (unsignedp ? long_long_unsigned_type_node
3156             : long_long_integer_type_node);
3157   if (TYPE_OK (widest_integer_literal_type_node))
3158     return (unsignedp ? widest_unsigned_literal_type_node
3159             : widest_integer_literal_type_node);
3160
3161 #if HOST_BITS_PER_WIDE_INT >= 64
3162   if (TYPE_OK (intTI_type_node))
3163     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3164 #endif
3165   if (TYPE_OK (intDI_type_node))
3166     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3167   if (TYPE_OK (intSI_type_node))
3168     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3169   if (TYPE_OK (intHI_type_node))
3170     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3171   if (TYPE_OK (intQI_type_node))
3172     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3173 #undef TYPE_OK
3174
3175   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3176 }
3177
3178 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
3179
3180 tree
3181 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3182 {
3183   /* Extended integer types of the same width as a standard type have
3184      lesser rank, so those of the same width as int promote to int or
3185      unsigned int and are valid for printf formats expecting int or
3186      unsigned int.  To avoid such special cases, avoid creating
3187      extended integer types for bit-fields if a standard integer type
3188      is available.  */
3189   if (width == TYPE_PRECISION (integer_type_node))
3190     return unsignedp ? unsigned_type_node : integer_type_node;
3191   if (width == TYPE_PRECISION (signed_char_type_node))
3192     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3193   if (width == TYPE_PRECISION (short_integer_type_node))
3194     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3195   if (width == TYPE_PRECISION (long_integer_type_node))
3196     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3197   if (width == TYPE_PRECISION (long_long_integer_type_node))
3198     return (unsignedp ? long_long_unsigned_type_node
3199             : long_long_integer_type_node);
3200   return build_nonstandard_integer_type (width, unsignedp);
3201 }
3202
3203 /* The C version of the register_builtin_type langhook.  */
3204
3205 void
3206 c_register_builtin_type (tree type, const char* name)
3207 {
3208   tree decl;
3209
3210   decl = build_decl (TYPE_DECL, get_identifier (name), type);
3211   DECL_ARTIFICIAL (decl) = 1;
3212   if (!TYPE_NAME (type))
3213     TYPE_NAME (type) = decl;
3214   pushdecl (decl);
3215
3216   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3217 }
3218 \f
3219 /* Print an error message for invalid operands to arith operation
3220    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3221    LOCATION is the location of the message.  */
3222
3223 void
3224 binary_op_error (location_t location, enum tree_code code,
3225                  tree type0, tree type1)
3226 {
3227   const char *opname;
3228
3229   switch (code)
3230     {
3231     case PLUS_EXPR:
3232       opname = "+"; break;
3233     case MINUS_EXPR:
3234       opname = "-"; break;
3235     case MULT_EXPR:
3236       opname = "*"; break;
3237     case MAX_EXPR:
3238       opname = "max"; break;
3239     case MIN_EXPR:
3240       opname = "min"; break;
3241     case EQ_EXPR:
3242       opname = "=="; break;
3243     case NE_EXPR:
3244       opname = "!="; break;
3245     case LE_EXPR:
3246       opname = "<="; break;
3247     case GE_EXPR:
3248       opname = ">="; break;
3249     case LT_EXPR:
3250       opname = "<"; break;
3251     case GT_EXPR:
3252       opname = ">"; break;
3253     case LSHIFT_EXPR:
3254       opname = "<<"; break;
3255     case RSHIFT_EXPR:
3256       opname = ">>"; break;
3257     case TRUNC_MOD_EXPR:
3258     case FLOOR_MOD_EXPR:
3259       opname = "%"; break;
3260     case TRUNC_DIV_EXPR:
3261     case FLOOR_DIV_EXPR:
3262       opname = "/"; break;
3263     case BIT_AND_EXPR:
3264       opname = "&"; break;
3265     case BIT_IOR_EXPR:
3266       opname = "|"; break;
3267     case TRUTH_ANDIF_EXPR:
3268       opname = "&&"; break;
3269     case TRUTH_ORIF_EXPR:
3270       opname = "||"; break;
3271     case BIT_XOR_EXPR:
3272       opname = "^"; break;
3273     default:
3274       gcc_unreachable ();
3275     }
3276   error_at (location,
3277             "invalid operands to binary %s (have %qT and %qT)", opname,
3278             type0, type1);
3279 }
3280 \f
3281 /* Subroutine of build_binary_op, used for comparison operations.
3282    See if the operands have both been converted from subword integer types
3283    and, if so, perhaps change them both back to their original type.
3284    This function is also responsible for converting the two operands
3285    to the proper common type for comparison.
3286
3287    The arguments of this function are all pointers to local variables
3288    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3289    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3290
3291    If this function returns nonzero, it means that the comparison has
3292    a constant value.  What this function returns is an expression for
3293    that value.  */
3294
3295 tree
3296 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3297                  enum tree_code *rescode_ptr)
3298 {
3299   tree type;
3300   tree op0 = *op0_ptr;
3301   tree op1 = *op1_ptr;
3302   int unsignedp0, unsignedp1;
3303   int real1, real2;
3304   tree primop0, primop1;
3305   enum tree_code code = *rescode_ptr;
3306
3307   /* Throw away any conversions to wider types
3308      already present in the operands.  */
3309
3310   primop0 = get_narrower (op0, &unsignedp0);
3311   primop1 = get_narrower (op1, &unsignedp1);
3312
3313   /* Handle the case that OP0 does not *contain* a conversion
3314      but it *requires* conversion to FINAL_TYPE.  */
3315
3316   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3317     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3318   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3319     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3320
3321   /* If one of the operands must be floated, we cannot optimize.  */
3322   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3323   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3324
3325   /* If first arg is constant, swap the args (changing operation
3326      so value is preserved), for canonicalization.  Don't do this if
3327      the second arg is 0.  */
3328
3329   if (TREE_CONSTANT (primop0)
3330       && !integer_zerop (primop1) && !real_zerop (primop1)
3331       && !fixed_zerop (primop1))
3332     {
3333       tree tem = primop0;
3334       int temi = unsignedp0;
3335       primop0 = primop1;
3336       primop1 = tem;
3337       tem = op0;
3338       op0 = op1;
3339       op1 = tem;
3340       *op0_ptr = op0;
3341       *op1_ptr = op1;
3342       unsignedp0 = unsignedp1;
3343       unsignedp1 = temi;
3344       temi = real1;
3345       real1 = real2;
3346       real2 = temi;
3347
3348       switch (code)
3349         {
3350         case LT_EXPR:
3351           code = GT_EXPR;
3352           break;
3353         case GT_EXPR:
3354           code = LT_EXPR;
3355           break;
3356         case LE_EXPR:
3357           code = GE_EXPR;
3358           break;
3359         case GE_EXPR:
3360           code = LE_EXPR;
3361           break;
3362         default:
3363           break;
3364         }
3365       *rescode_ptr = code;
3366     }
3367
3368   /* If comparing an integer against a constant more bits wide,
3369      maybe we can deduce a value of 1 or 0 independent of the data.
3370      Or else truncate the constant now
3371      rather than extend the variable at run time.
3372
3373      This is only interesting if the constant is the wider arg.
3374      Also, it is not safe if the constant is unsigned and the
3375      variable arg is signed, since in this case the variable
3376      would be sign-extended and then regarded as unsigned.
3377      Our technique fails in this case because the lowest/highest
3378      possible unsigned results don't follow naturally from the
3379      lowest/highest possible values of the variable operand.
3380      For just EQ_EXPR and NE_EXPR there is another technique that
3381      could be used: see if the constant can be faithfully represented
3382      in the other operand's type, by truncating it and reextending it
3383      and see if that preserves the constant's value.  */
3384
3385   if (!real1 && !real2
3386       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3387       && TREE_CODE (primop1) == INTEGER_CST
3388       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3389     {
3390       int min_gt, max_gt, min_lt, max_lt;
3391       tree maxval, minval;
3392       /* 1 if comparison is nominally unsigned.  */
3393       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3394       tree val;
3395
3396       type = c_common_signed_or_unsigned_type (unsignedp0,
3397                                                TREE_TYPE (primop0));
3398
3399       maxval = TYPE_MAX_VALUE (type);
3400       minval = TYPE_MIN_VALUE (type);
3401
3402       if (unsignedp && !unsignedp0)
3403         *restype_ptr = c_common_signed_type (*restype_ptr);
3404
3405       if (TREE_TYPE (primop1) != *restype_ptr)
3406         {
3407           /* Convert primop1 to target type, but do not introduce
3408              additional overflow.  We know primop1 is an int_cst.  */
3409           primop1 = force_fit_type_double (*restype_ptr,
3410                                            TREE_INT_CST_LOW (primop1),
3411                                            TREE_INT_CST_HIGH (primop1), 0,
3412                                            TREE_OVERFLOW (primop1));
3413         }
3414       if (type != *restype_ptr)
3415         {
3416           minval = convert (*restype_ptr, minval);
3417           maxval = convert (*restype_ptr, maxval);
3418         }
3419
3420       if (unsignedp && unsignedp0)
3421         {
3422           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3423           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3424           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3425           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3426         }
3427       else
3428         {
3429           min_gt = INT_CST_LT (primop1, minval);
3430           max_gt = INT_CST_LT (primop1, maxval);
3431           min_lt = INT_CST_LT (minval, primop1);
3432           max_lt = INT_CST_LT (maxval, primop1);
3433         }
3434
3435       val = 0;
3436       /* This used to be a switch, but Genix compiler can't handle that.  */
3437       if (code == NE_EXPR)
3438         {
3439           if (max_lt || min_gt)
3440             val = truthvalue_true_node;
3441         }
3442       else if (code == EQ_EXPR)
3443         {
3444           if (max_lt || min_gt)
3445             val = truthvalue_false_node;
3446         }
3447       else if (code == LT_EXPR)
3448         {
3449           if (max_lt)
3450             val = truthvalue_true_node;
3451           if (!min_lt)
3452             val = truthvalue_false_node;
3453         }
3454       else if (code == GT_EXPR)
3455         {
3456           if (min_gt)
3457             val = truthvalue_true_node;
3458           if (!max_gt)
3459             val = truthvalue_false_node;
3460         }
3461       else if (code == LE_EXPR)
3462         {
3463           if (!max_gt)
3464             val = truthvalue_true_node;
3465           if (min_gt)
3466             val = truthvalue_false_node;
3467         }
3468       else if (code == GE_EXPR)
3469         {
3470           if (!min_lt)
3471             val = truthvalue_true_node;
3472           if (max_lt)
3473             val = truthvalue_false_node;
3474         }
3475
3476       /* If primop0 was sign-extended and unsigned comparison specd,
3477          we did a signed comparison above using the signed type bounds.
3478          But the comparison we output must be unsigned.
3479
3480          Also, for inequalities, VAL is no good; but if the signed
3481          comparison had *any* fixed result, it follows that the
3482          unsigned comparison just tests the sign in reverse
3483          (positive values are LE, negative ones GE).
3484          So we can generate an unsigned comparison
3485          against an extreme value of the signed type.  */
3486
3487       if (unsignedp && !unsignedp0)
3488         {
3489           if (val != 0)
3490             switch (code)
3491               {
3492               case LT_EXPR:
3493               case GE_EXPR:
3494                 primop1 = TYPE_MIN_VALUE (type);
3495                 val = 0;
3496                 break;
3497
3498               case LE_EXPR:
3499               case GT_EXPR:
3500                 primop1 = TYPE_MAX_VALUE (type);
3501                 val = 0;
3502                 break;
3503
3504               default:
3505                 break;
3506               }
3507           type = c_common_unsigned_type (type);
3508         }
3509
3510       if (TREE_CODE (primop0) != INTEGER_CST)
3511         {
3512           if (val == truthvalue_false_node)
3513             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3514           if (val == truthvalue_true_node)
3515             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3516         }
3517
3518       if (val != 0)
3519         {
3520           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3521           if (TREE_SIDE_EFFECTS (primop0))
3522             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3523           return val;
3524         }
3525
3526       /* Value is not predetermined, but do the comparison
3527          in the type of the operand that is not constant.
3528          TYPE is already properly set.  */
3529     }
3530
3531   /* If either arg is decimal float and the other is float, find the
3532      proper common type to use for comparison.  */
3533   else if (real1 && real2
3534            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3535                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3536     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3537
3538   else if (real1 && real2
3539            && (TYPE_PRECISION (TREE_TYPE (primop0))
3540                == TYPE_PRECISION (TREE_TYPE (primop1))))
3541     type = TREE_TYPE (primop0);
3542
3543   /* If args' natural types are both narrower than nominal type
3544      and both extend in the same manner, compare them
3545      in the type of the wider arg.
3546      Otherwise must actually extend both to the nominal
3547      common type lest different ways of extending
3548      alter the result.
3549      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
3550
3551   else if (unsignedp0 == unsignedp1 && real1 == real2
3552            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3553            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3554     {
3555       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3556       type = c_common_signed_or_unsigned_type (unsignedp0
3557                                                || TYPE_UNSIGNED (*restype_ptr),
3558                                                type);
3559       /* Make sure shorter operand is extended the right way
3560          to match the longer operand.  */
3561       primop0
3562         = convert (c_common_signed_or_unsigned_type (unsignedp0,
3563                                                      TREE_TYPE (primop0)),
3564                    primop0);
3565       primop1
3566         = convert (c_common_signed_or_unsigned_type (unsignedp1,
3567                                                      TREE_TYPE (primop1)),
3568                    primop1);
3569     }
3570   else
3571     {
3572       /* Here we must do the comparison on the nominal type
3573          using the args exactly as we received them.  */
3574       type = *restype_ptr;
3575       primop0 = op0;
3576       primop1 = op1;
3577
3578       if (!real1 && !real2 && integer_zerop (primop1)
3579           && TYPE_UNSIGNED (*restype_ptr))
3580         {
3581           tree value = 0;
3582           switch (code)
3583             {
3584             case GE_EXPR:
3585               /* All unsigned values are >= 0, so we warn.  However,
3586                  if OP0 is a constant that is >= 0, the signedness of
3587                  the comparison isn't an issue, so suppress the
3588                  warning.  */
3589               if (warn_type_limits && !in_system_header
3590                   && !(TREE_CODE (primop0) == INTEGER_CST
3591                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3592                                                    primop0))))
3593                 warning (OPT_Wtype_limits,
3594                          "comparison of unsigned expression >= 0 is always true");
3595               value = truthvalue_true_node;
3596               break;
3597
3598             case LT_EXPR:
3599               if (warn_type_limits && !in_system_header
3600                   && !(TREE_CODE (primop0) == INTEGER_CST
3601                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3602                                                    primop0))))
3603                 warning (OPT_Wtype_limits,
3604                          "comparison of unsigned expression < 0 is always false");
3605               value = truthvalue_false_node;
3606               break;
3607
3608             default:
3609               break;
3610             }
3611
3612           if (value != 0)
3613             {
3614               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3615               if (TREE_SIDE_EFFECTS (primop0))
3616                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3617                                primop0, value);
3618               return value;
3619             }
3620         }
3621     }
3622
3623   *op0_ptr = convert (type, primop0);
3624   *op1_ptr = convert (type, primop1);
3625
3626   *restype_ptr = truthvalue_type_node;
3627
3628   return 0;
3629 }
3630 \f
3631 /* Return a tree for the sum or difference (RESULTCODE says which)
3632    of pointer PTROP and integer INTOP.  */
3633
3634 tree
3635 pointer_int_sum (location_t location, enum tree_code resultcode,
3636                  tree ptrop, tree intop)
3637 {
3638   tree size_exp, ret;
3639
3640   /* The result is a pointer of the same type that is being added.  */
3641   tree result_type = TREE_TYPE (ptrop);
3642
3643   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3644     {
3645       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3646                "pointer of type %<void *%> used in arithmetic");
3647       size_exp = integer_one_node;
3648     }
3649   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3650     {
3651       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3652                "pointer to a function used in arithmetic");
3653       size_exp = integer_one_node;
3654     }
3655   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3656     {
3657       pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3658                "pointer to member function used in arithmetic");
3659       size_exp = integer_one_node;
3660     }
3661   else
3662     size_exp = size_in_bytes (TREE_TYPE (result_type));
3663
3664   /* We are manipulating pointer values, so we don't need to warn
3665      about relying on undefined signed overflow.  We disable the
3666      warning here because we use integer types so fold won't know that
3667      they are really pointers.  */
3668   fold_defer_overflow_warnings ();
3669
3670   /* If what we are about to multiply by the size of the elements
3671      contains a constant term, apply distributive law
3672      and multiply that constant term separately.
3673      This helps produce common subexpressions.  */
3674   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3675       && !TREE_CONSTANT (intop)
3676       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3677       && TREE_CONSTANT (size_exp)
3678       /* If the constant comes from pointer subtraction,
3679          skip this optimization--it would cause an error.  */
3680       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3681       /* If the constant is unsigned, and smaller than the pointer size,
3682          then we must skip this optimization.  This is because it could cause
3683          an overflow error if the constant is negative but INTOP is not.  */
3684       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3685           || (TYPE_PRECISION (TREE_TYPE (intop))
3686               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3687     {
3688       enum tree_code subcode = resultcode;
3689       tree int_type = TREE_TYPE (intop);
3690       if (TREE_CODE (intop) == MINUS_EXPR)
3691         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3692       /* Convert both subexpression types to the type of intop,
3693          because weird cases involving pointer arithmetic
3694          can result in a sum or difference with different type args.  */
3695       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3696                                subcode, ptrop,
3697                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3698       intop = convert (int_type, TREE_OPERAND (intop, 0));
3699     }
3700
3701   /* Convert the integer argument to a type the same size as sizetype
3702      so the multiply won't overflow spuriously.  */
3703   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3704       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3705     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3706                                              TYPE_UNSIGNED (sizetype)), intop);
3707
3708   /* Replace the integer argument with a suitable product by the object size.
3709      Do this multiplication as signed, then convert to the appropriate
3710      type for the pointer operation.  */
3711   intop = convert (sizetype,
3712                    build_binary_op (EXPR_LOCATION (intop),
3713                                     MULT_EXPR, intop,
3714                                     convert (TREE_TYPE (intop), size_exp), 1));
3715
3716   /* Create the sum or difference.  */
3717   if (resultcode == MINUS_EXPR)
3718     intop = fold_build1 (NEGATE_EXPR, sizetype, intop);
3719
3720   if (TREE_CODE (intop) == INTEGER_CST)
3721     {
3722       tree offset_node;
3723       tree string_cst = string_constant (ptrop, &offset_node);
3724
3725       if (string_cst != 0
3726           && !(offset_node && TREE_CODE (offset_node) != INTEGER_CST))
3727         {
3728           HOST_WIDE_INT max = TREE_STRING_LENGTH (string_cst);
3729           HOST_WIDE_INT offset;
3730           if (offset_node == 0)
3731             offset = 0;
3732           else if (! host_integerp (offset_node, 0))
3733             offset = -1;
3734           else
3735             offset = tree_low_cst (offset_node, 0);
3736
3737           offset = offset + tree_low_cst (intop, 0);
3738           if (offset < 0 || offset > max)
3739             warning_at (location, 0,
3740                         "offset %<%wd%> outside bounds of constant string",
3741                         tree_low_cst (intop, 0));
3742         }
3743     }
3744
3745   ret = fold_build2 (POINTER_PLUS_EXPR, result_type, ptrop, intop);
3746
3747   fold_undefer_and_ignore_overflow_warnings ();
3748
3749   return ret;
3750 }
3751 \f
3752 /* Wrap a SAVE_EXPR around EXPR, if appropriate.  Like save_expr, but
3753    for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3754    around the SAVE_EXPR if needed so that c_fully_fold does not need
3755    to look inside SAVE_EXPRs.  */
3756
3757 tree
3758 c_save_expr (tree expr)
3759 {
3760   bool maybe_const = true;
3761   if (c_dialect_cxx ())
3762     return save_expr (expr);
3763   expr = c_fully_fold (expr, false, &maybe_const);
3764   expr = save_expr (expr);
3765   if (!maybe_const)
3766     {
3767       expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3768       C_MAYBE_CONST_EXPR_NON_CONST (expr) = 1;
3769     }
3770   return expr;
3771 }
3772
3773 /* Return whether EXPR is a declaration whose address can never be
3774    NULL.  */
3775
3776 bool
3777 decl_with_nonnull_addr_p (const_tree expr)
3778 {
3779   return (DECL_P (expr)
3780           && (TREE_CODE (expr) == PARM_DECL
3781               || TREE_CODE (expr) == LABEL_DECL
3782               || !DECL_WEAK (expr)));
3783 }
3784
3785 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3786    or for an `if' or `while' statement or ?..: exp.  It should already
3787    have been validated to be of suitable type; otherwise, a bad
3788    diagnostic may result.
3789
3790    The EXPR is located at LOCATION.
3791
3792    This preparation consists of taking the ordinary
3793    representation of an expression expr and producing a valid tree
3794    boolean expression describing whether expr is nonzero.  We could
3795    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3796    but we optimize comparisons, &&, ||, and !.
3797
3798    The resulting type should always be `truthvalue_type_node'.  */
3799
3800 tree
3801 c_common_truthvalue_conversion (location_t location, tree expr)
3802 {
3803   switch (TREE_CODE (expr))
3804     {
3805     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3806     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3807     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3808     case ORDERED_EXPR: case UNORDERED_EXPR:
3809       if (TREE_TYPE (expr) == truthvalue_type_node)
3810         return expr;
3811       return build2 (TREE_CODE (expr), truthvalue_type_node,
3812                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3813
3814     case TRUTH_ANDIF_EXPR:
3815     case TRUTH_ORIF_EXPR:
3816     case TRUTH_AND_EXPR:
3817     case TRUTH_OR_EXPR:
3818     case TRUTH_XOR_EXPR:
3819       if (TREE_TYPE (expr) == truthvalue_type_node)
3820         return expr;
3821       return build2 (TREE_CODE (expr), truthvalue_type_node,
3822                  c_common_truthvalue_conversion (location,
3823                                                  TREE_OPERAND (expr, 0)),
3824                  c_common_truthvalue_conversion (location,
3825                                                  TREE_OPERAND (expr, 1)));
3826
3827     case TRUTH_NOT_EXPR:
3828       if (TREE_TYPE (expr) == truthvalue_type_node)
3829         return expr;
3830       return build1 (TREE_CODE (expr), truthvalue_type_node,
3831                  c_common_truthvalue_conversion (location,
3832                                                  TREE_OPERAND (expr, 0)));
3833
3834     case ERROR_MARK:
3835       return expr;
3836
3837     case INTEGER_CST:
3838       return integer_zerop (expr) ? truthvalue_false_node
3839                                   : truthvalue_true_node;
3840
3841     case REAL_CST:
3842       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3843              ? truthvalue_true_node
3844              : truthvalue_false_node;
3845
3846     case FIXED_CST:
3847       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3848                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3849              ? truthvalue_true_node
3850              : truthvalue_false_node;
3851
3852     case FUNCTION_DECL:
3853       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3854       /* Fall through.  */
3855
3856     case ADDR_EXPR:
3857       {
3858         tree inner = TREE_OPERAND (expr, 0);
3859         if (decl_with_nonnull_addr_p (inner))
3860           {
3861             /* Common Ada/Pascal programmer's mistake.  */
3862             warning_at (location,
3863                         OPT_Waddress,
3864                         "the address of %qD will always evaluate as %<true%>",
3865                         inner);
3866             return truthvalue_true_node;
3867           }
3868
3869         /* If we still have a decl, it is possible for its address to
3870            be NULL, so we cannot optimize.  */
3871         if (DECL_P (inner))
3872           {
3873             gcc_assert (DECL_WEAK (inner));
3874             break;
3875           }
3876
3877         if (TREE_SIDE_EFFECTS (inner))
3878           return build2 (COMPOUND_EXPR, truthvalue_type_node,
3879                          inner, truthvalue_true_node);
3880         else
3881           return truthvalue_true_node;
3882       }
3883
3884     case COMPLEX_EXPR:
3885       return build_binary_op (EXPR_LOCATION (expr),
3886                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3887                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3888                 c_common_truthvalue_conversion (location,
3889                                                 TREE_OPERAND (expr, 0)),
3890                 c_common_truthvalue_conversion (location,
3891                                                 TREE_OPERAND (expr, 1)),
3892                               0);
3893
3894     case NEGATE_EXPR:
3895     case ABS_EXPR:
3896     case FLOAT_EXPR:
3897     case EXCESS_PRECISION_EXPR:
3898       /* These don't change whether an object is nonzero or zero.  */
3899       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
3900
3901     case LROTATE_EXPR:
3902     case RROTATE_EXPR:
3903       /* These don't change whether an object is zero or nonzero, but
3904          we can't ignore them if their second arg has side-effects.  */
3905       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3906         return build2 (COMPOUND_EXPR, truthvalue_type_node,
3907                        TREE_OPERAND (expr, 1),
3908                        c_common_truthvalue_conversion
3909                         (location, TREE_OPERAND (expr, 0)));
3910       else
3911         return c_common_truthvalue_conversion (location,
3912                                                TREE_OPERAND (expr, 0));
3913
3914     case COND_EXPR:
3915       /* Distribute the conversion into the arms of a COND_EXPR.  */
3916       if (c_dialect_cxx ())
3917         return fold_build3 (COND_EXPR, truthvalue_type_node,
3918                             TREE_OPERAND (expr, 0),
3919                             c_common_truthvalue_conversion (location,
3920                                                             TREE_OPERAND (expr,
3921                                                                           1)),
3922                             c_common_truthvalue_conversion (location,
3923                                                             TREE_OPERAND (expr,
3924                                                                           2)));
3925       else
3926         /* Folding will happen later for C.  */
3927         return build3 (COND_EXPR, truthvalue_type_node,
3928                        TREE_OPERAND (expr, 0),
3929                        c_common_truthvalue_conversion (location,
3930                                                        TREE_OPERAND (expr, 1)),
3931                        c_common_truthvalue_conversion (location,
3932                                                        TREE_OPERAND (expr, 2)));
3933
3934     CASE_CONVERT:
3935       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3936          since that affects how `default_conversion' will behave.  */
3937       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3938           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3939         break;
3940       /* If this is widening the argument, we can ignore it.  */
3941       if (TYPE_PRECISION (TREE_TYPE (expr))
3942           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3943         return c_common_truthvalue_conversion (location,
3944                                                TREE_OPERAND (expr, 0));
3945       break;
3946
3947     case MODIFY_EXPR:
3948       if (!TREE_NO_WARNING (expr)
3949           && warn_parentheses)
3950         {
3951           warning (OPT_Wparentheses,
3952                    "suggest parentheses around assignment used as truth value");
3953           TREE_NO_WARNING (expr) = 1;
3954         }
3955       break;
3956
3957     default:
3958       break;
3959     }
3960
3961   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3962     {
3963       tree t = c_save_expr (expr);
3964       return (build_binary_op
3965               (EXPR_LOCATION (expr),
3966                (TREE_SIDE_EFFECTS (expr)
3967                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3968         c_common_truthvalue_conversion
3969                (location,
3970                 build_unary_op (location, REALPART_EXPR, t, 0)),
3971         c_common_truthvalue_conversion
3972                (location,
3973                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3974                0));
3975     }
3976
3977   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3978     {
3979       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3980                                           FCONST0 (TYPE_MODE
3981                                                    (TREE_TYPE (expr))));
3982       return build_binary_op (EXPR_LOCATION (expr),
3983                               NE_EXPR, expr, fixed_zero_node, 1);
3984     }
3985
3986   return build_binary_op (EXPR_LOCATION (expr),
3987                           NE_EXPR, expr, integer_zero_node, 1);
3988 }
3989 \f
3990 static void def_builtin_1  (enum built_in_function fncode,
3991                             const char *name,
3992                             enum built_in_class fnclass,
3993                             tree fntype, tree libtype,
3994                             bool both_p, bool fallback_p, bool nonansi_p,
3995                             tree fnattrs, bool implicit_p);
3996
3997
3998 /* Apply the TYPE_QUALS to the new DECL.  */
3999
4000 void
4001 c_apply_type_quals_to_decl (int type_quals, tree decl)
4002 {
4003   tree type = TREE_TYPE (decl);
4004
4005   if (type == error_mark_node)
4006     return;
4007
4008   if (((type_quals & TYPE_QUAL_CONST)
4009        || (type && TREE_CODE (type) == REFERENCE_TYPE))
4010       /* An object declared 'const' is only readonly after it is
4011          initialized.  We don't have any way of expressing this currently,
4012          so we need to be conservative and unset TREE_READONLY for types
4013          with constructors.  Otherwise aliasing code will ignore stores in
4014          an inline constructor.  */
4015       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
4016     TREE_READONLY (decl) = 1;
4017   if (type_quals & TYPE_QUAL_VOLATILE)
4018     {
4019       TREE_SIDE_EFFECTS (decl) = 1;
4020       TREE_THIS_VOLATILE (decl) = 1;
4021     }
4022   if (type_quals & TYPE_QUAL_RESTRICT)
4023     {
4024       while (type && TREE_CODE (type) == ARRAY_TYPE)
4025         /* Allow 'restrict' on arrays of pointers.
4026            FIXME currently we just ignore it.  */
4027         type = TREE_TYPE (type);
4028       if (!type
4029           || !POINTER_TYPE_P (type)
4030           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4031         error ("invalid use of %<restrict%>");
4032       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
4033         /* Indicate we need to make a unique alias set for this pointer.
4034            We can't do it here because it might be pointing to an
4035            incomplete type.  */
4036         DECL_POINTER_ALIAS_SET (decl) = -2;
4037     }
4038 }
4039
4040 /* Hash function for the problem of multiple type definitions in
4041    different files.  This must hash all types that will compare
4042    equal via comptypes to the same value.  In practice it hashes
4043    on some of the simple stuff and leaves the details to comptypes.  */
4044
4045 static hashval_t
4046 c_type_hash (const void *p)
4047 {
4048   int i = 0;
4049   int shift, size;
4050   const_tree const t = (const_tree) p;
4051   tree t2;
4052   switch (TREE_CODE (t))
4053     {
4054     /* For pointers, hash on pointee type plus some swizzling.  */
4055     case POINTER_TYPE:
4056       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4057     /* Hash on number of elements and total size.  */
4058     case ENUMERAL_TYPE:
4059       shift = 3;
4060       t2 = TYPE_VALUES (t);
4061       break;
4062     case RECORD_TYPE:
4063       shift = 0;
4064       t2 = TYPE_FIELDS (t);
4065       break;
4066     case QUAL_UNION_TYPE:
4067       shift = 1;
4068       t2 = TYPE_FIELDS (t);
4069       break;
4070     case UNION_TYPE:
4071       shift = 2;
4072       t2 = TYPE_FIELDS (t);
4073       break;
4074     default:
4075       gcc_unreachable ();
4076     }
4077   for (; t2; t2 = TREE_CHAIN (t2))
4078     i++;
4079   /* We might have a VLA here.  */
4080   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4081     size = 0;
4082   else
4083     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4084   return ((size << 24) | (i << shift));
4085 }
4086
4087 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4088
4089 /* Return the typed-based alias set for T, which may be an expression
4090    or a type.  Return -1 if we don't do anything special.  */
4091
4092 alias_set_type
4093 c_common_get_alias_set (tree t)
4094 {
4095   tree u;
4096   PTR *slot;
4097
4098   /* Permit type-punning when accessing a union, provided the access
4099      is directly through the union.  For example, this code does not
4100      permit taking the address of a union member and then storing
4101      through it.  Even the type-punning allowed here is a GCC
4102      extension, albeit a common and useful one; the C standard says
4103      that such accesses have implementation-defined behavior.  */
4104   for (u = t;
4105        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4106        u = TREE_OPERAND (u, 0))
4107     if (TREE_CODE (u) == COMPONENT_REF
4108         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4109       return 0;
4110
4111   /* That's all the expressions we handle specially.  */
4112   if (!TYPE_P (t))
4113     return -1;
4114
4115   /* The C standard guarantees that any object may be accessed via an
4116      lvalue that has character type.  */
4117   if (t == char_type_node
4118       || t == signed_char_type_node
4119       || t == unsigned_char_type_node)
4120     return 0;
4121
4122   /* The C standard specifically allows aliasing between signed and
4123      unsigned variants of the same type.  We treat the signed
4124      variant as canonical.  */
4125   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4126     {
4127       tree t1 = c_common_signed_type (t);
4128
4129       /* t1 == t can happen for boolean nodes which are always unsigned.  */
4130       if (t1 != t)
4131         return get_alias_set (t1);
4132     }
4133   else if (POINTER_TYPE_P (t))
4134     {
4135       tree t1;
4136
4137       /* Unfortunately, there is no canonical form of a pointer type.
4138          In particular, if we have `typedef int I', then `int *', and
4139          `I *' are different types.  So, we have to pick a canonical
4140          representative.  We do this below.
4141
4142          Technically, this approach is actually more conservative that
4143          it needs to be.  In particular, `const int *' and `int *'
4144          should be in different alias sets, according to the C and C++
4145          standard, since their types are not the same, and so,
4146          technically, an `int **' and `const int **' cannot point at
4147          the same thing.
4148
4149          But, the standard is wrong.  In particular, this code is
4150          legal C++:
4151
4152             int *ip;
4153             int **ipp = &ip;
4154             const int* const* cipp = ipp;
4155
4156          And, it doesn't make sense for that to be legal unless you
4157          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
4158          the pointed-to types.  This issue has been reported to the
4159          C++ committee.  */
4160       t1 = build_type_no_quals (t);
4161       if (t1 != t)
4162         return get_alias_set (t1);
4163     }
4164
4165   /* Handle the case of multiple type nodes referring to "the same" type,
4166      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
4167      C90 is handled.  (In C99 type compatibility is not transitive, which
4168      complicates things mightily. The alias set splay trees can theoretically
4169      represent this, but insertion is tricky when you consider all the
4170      different orders things might arrive in.) */
4171
4172   if (c_language != clk_c || flag_isoc99)
4173     return -1;
4174
4175   /* Save time if there's only one input file.  */
4176   if (num_in_fnames == 1)
4177     return -1;
4178
4179   /* Pointers need special handling if they point to any type that
4180      needs special handling (below).  */
4181   if (TREE_CODE (t) == POINTER_TYPE)
4182     {
4183       tree t2;
4184       /* Find bottom type under any nested POINTERs.  */
4185       for (t2 = TREE_TYPE (t);
4186            TREE_CODE (t2) == POINTER_TYPE;
4187            t2 = TREE_TYPE (t2))
4188         ;
4189       if (TREE_CODE (t2) != RECORD_TYPE
4190           && TREE_CODE (t2) != ENUMERAL_TYPE
4191           && TREE_CODE (t2) != QUAL_UNION_TYPE
4192           && TREE_CODE (t2) != UNION_TYPE)
4193         return -1;
4194       if (TYPE_SIZE (t2) == 0)
4195         return -1;
4196     }
4197   /* These are the only cases that need special handling.  */
4198   if (TREE_CODE (t) != RECORD_TYPE
4199       && TREE_CODE (t) != ENUMERAL_TYPE
4200       && TREE_CODE (t) != QUAL_UNION_TYPE
4201       && TREE_CODE (t) != UNION_TYPE
4202       && TREE_CODE (t) != POINTER_TYPE)
4203     return -1;
4204   /* Undefined? */
4205   if (TYPE_SIZE (t) == 0)
4206     return -1;
4207
4208   /* Look up t in hash table.  Only one of the compatible types within each
4209      alias set is recorded in the table.  */
4210   if (!type_hash_table)
4211     type_hash_table = htab_create_ggc (1021, c_type_hash,
4212             (htab_eq) lang_hooks.types_compatible_p,
4213             NULL);
4214   slot = htab_find_slot (type_hash_table, t, INSERT);
4215   if (*slot != NULL)
4216     {
4217       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4218       return TYPE_ALIAS_SET ((tree)*slot);
4219     }
4220   else
4221     /* Our caller will assign and record (in t) a new alias set; all we need
4222        to do is remember t in the hash table.  */
4223     *slot = t;
4224
4225   return -1;
4226 }
4227 \f
4228 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
4229    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
4230    flag controls whether we should diagnose possibly ill-formed
4231    constructs or not.  */
4232
4233 tree
4234 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
4235 {
4236   const char *op_name;
4237   tree value = NULL;
4238   enum tree_code type_code = TREE_CODE (type);
4239
4240   op_name = is_sizeof ? "sizeof" : "__alignof__";
4241
4242   if (type_code == FUNCTION_TYPE)
4243     {
4244       if (is_sizeof)
4245         {
4246           if (complain && (pedantic || warn_pointer_arith))
4247             pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4248                      "invalid application of %<sizeof%> to a function type");
4249           else if (!complain)
4250             return error_mark_node;
4251           value = size_one_node;
4252         }
4253       else
4254         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4255     }
4256   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4257     {
4258       if (type_code == VOID_TYPE
4259           && complain && (pedantic || warn_pointer_arith))
4260         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4261                  "invalid application of %qs to a void type", op_name);
4262       else if (!complain)
4263         return error_mark_node;
4264       value = size_one_node;
4265     }
4266   else if (!COMPLETE_TYPE_P (type))
4267     {
4268       if (complain)
4269         error ("invalid application of %qs to incomplete type %qT ",
4270                op_name, type);
4271       value = size_zero_node;
4272     }
4273   else
4274     {
4275       if (is_sizeof)
4276         /* Convert in case a char is more than one unit.  */
4277         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4278                             size_int (TYPE_PRECISION (char_type_node)
4279                                       / BITS_PER_UNIT));
4280       else
4281         value = size_int (TYPE_ALIGN_UNIT (type));
4282     }
4283
4284   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4285      TYPE_IS_SIZETYPE means that certain things (like overflow) will
4286      never happen.  However, this node should really have type
4287      `size_t', which is just a typedef for an ordinary integer type.  */
4288   value = fold_convert (size_type_node, value);
4289   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4290
4291   return value;
4292 }
4293
4294 /* Implement the __alignof keyword: Return the minimum required
4295    alignment of EXPR, measured in bytes.  For VAR_DECLs,
4296    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4297    from an "aligned" __attribute__ specification).  */
4298
4299 tree
4300 c_alignof_expr (tree expr)
4301 {
4302   tree t;
4303
4304   if (VAR_OR_FUNCTION_DECL_P (expr))
4305     t = size_int (DECL_ALIGN_UNIT (expr));
4306
4307   else if (TREE_CODE (expr) == COMPONENT_REF
4308            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4309     {
4310       error ("%<__alignof%> applied to a bit-field");
4311       t = size_one_node;
4312     }
4313   else if (TREE_CODE (expr) == COMPONENT_REF
4314            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4315     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4316
4317   else if (TREE_CODE (expr) == INDIRECT_REF)
4318     {
4319       tree t = TREE_OPERAND (expr, 0);
4320       tree best = t;
4321       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4322
4323       while (CONVERT_EXPR_P (t)
4324              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4325         {
4326           int thisalign;
4327
4328           t = TREE_OPERAND (t, 0);
4329           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4330           if (thisalign > bestalign)
4331             best = t, bestalign = thisalign;
4332         }
4333       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
4334     }
4335   else
4336     return c_alignof (TREE_TYPE (expr));
4337
4338   return fold_convert (size_type_node, t);
4339 }
4340 \f
4341 /* Handle C and C++ default attributes.  */
4342
4343 enum built_in_attribute
4344 {
4345 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4346 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4347 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4348 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4349 #include "builtin-attrs.def"
4350 #undef DEF_ATTR_NULL_TREE
4351 #undef DEF_ATTR_INT
4352 #undef DEF_ATTR_IDENT
4353 #undef DEF_ATTR_TREE_LIST
4354   ATTR_LAST
4355 };
4356
4357 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4358
4359 static void c_init_attributes (void);
4360
4361 enum c_builtin_type
4362 {
4363 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4364 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4365 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4366 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4367 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4368 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4369 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4370 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4371 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4372 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4373 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4374 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4375 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4376 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4377 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4378   NAME,
4379 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4380 #include "builtin-types.def"
4381 #undef DEF_PRIMITIVE_TYPE
4382 #undef DEF_FUNCTION_TYPE_0
4383 #undef DEF_FUNCTION_TYPE_1
4384 #undef DEF_FUNCTION_TYPE_2
4385 #undef DEF_FUNCTION_TYPE_3
4386 #undef DEF_FUNCTION_TYPE_4
4387 #undef DEF_FUNCTION_TYPE_5
4388 #undef DEF_FUNCTION_TYPE_6
4389 #undef DEF_FUNCTION_TYPE_7
4390 #undef DEF_FUNCTION_TYPE_VAR_0
4391 #undef DEF_FUNCTION_TYPE_VAR_1
4392 #undef DEF_FUNCTION_TYPE_VAR_2
4393 #undef DEF_FUNCTION_TYPE_VAR_3
4394 #undef DEF_FUNCTION_TYPE_VAR_4
4395 #undef DEF_FUNCTION_TYPE_VAR_5
4396 #undef DEF_POINTER_TYPE
4397   BT_LAST
4398 };
4399
4400 typedef enum c_builtin_type builtin_type;
4401
4402 /* A temporary array for c_common_nodes_and_builtins.  Used in
4403    communication with def_fn_type.  */
4404 static tree builtin_types[(int) BT_LAST + 1];
4405
4406 /* A helper function for c_common_nodes_and_builtins.  Build function type
4407    for DEF with return type RET and N arguments.  If VAR is true, then the
4408    function should be variadic after those N arguments.
4409
4410    Takes special care not to ICE if any of the types involved are
4411    error_mark_node, which indicates that said type is not in fact available
4412    (see builtin_type_for_size).  In which case the function type as a whole
4413    should be error_mark_node.  */
4414
4415 static void
4416 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4417 {
4418   tree args = NULL, t;
4419   va_list list;
4420   int i;
4421
4422   va_start (list, n);
4423   for (i = 0; i < n; ++i)
4424     {
4425       builtin_type a = (builtin_type) va_arg (list, int);
4426       t = builtin_types[a];
4427       if (t == error_mark_node)
4428         goto egress;
4429       args = tree_cons (NULL_TREE, t, args);
4430     }
4431   va_end (list);
4432
4433   args = nreverse (args);
4434   if (!var)
4435     args = chainon (args, void_list_node);
4436
4437   t = builtin_types[ret];
4438   if (t == error_mark_node)
4439     goto egress;
4440   t = build_function_type (t, args);
4441
4442  egress:
4443   builtin_types[def] = t;
4444 }
4445
4446 /* Build builtin functions common to both C and C++ language
4447    frontends.  */
4448
4449 static void
4450 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4451 {
4452 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4453   builtin_types[ENUM] = VALUE;
4454 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4455   def_fn_type (ENUM, RETURN, 0, 0);
4456 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4457   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4458 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4459   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4460 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4461   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4462 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4463   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4464 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4465   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4466 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4467                             ARG6)                                       \
4468   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4469 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4470                             ARG6, ARG7)                                 \
4471   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4472 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4473   def_fn_type (ENUM, RETURN, 1, 0);
4474 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4475   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4476 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4477   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4478 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4479   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4480 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4481   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4482 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4483   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4484 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4485   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4486
4487 #include "builtin-types.def"
4488
4489 #undef DEF_PRIMITIVE_TYPE
4490 #undef DEF_FUNCTION_TYPE_1
4491 #undef DEF_FUNCTION_TYPE_2
4492 #undef DEF_FUNCTION_TYPE_3
4493 #undef DEF_FUNCTION_TYPE_4
4494 #undef DEF_FUNCTION_TYPE_5
4495 #undef DEF_FUNCTION_TYPE_6
4496 #undef DEF_FUNCTION_TYPE_VAR_0
4497 #undef DEF_FUNCTION_TYPE_VAR_1
4498 #undef DEF_FUNCTION_TYPE_VAR_2
4499 #undef DEF_FUNCTION_TYPE_VAR_3
4500 #undef DEF_FUNCTION_TYPE_VAR_4
4501 #undef DEF_FUNCTION_TYPE_VAR_5
4502 #undef DEF_POINTER_TYPE
4503   builtin_types[(int) BT_LAST] = NULL_TREE;
4504
4505   c_init_attributes ();
4506
4507 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4508                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4509   if (NAME && COND)                                                     \
4510     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4511                    builtin_types[(int) TYPE],                           \
4512                    builtin_types[(int) LIBTYPE],                        \
4513                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4514                    built_in_attributes[(int) ATTRS], IMPLICIT);
4515 #include "builtins.def"
4516 #undef DEF_BUILTIN
4517
4518   targetm.init_builtins ();
4519
4520   build_common_builtin_nodes ();
4521
4522   if (flag_mudflap)
4523     mudflap_init ();
4524 }
4525
4526 /* Build tree nodes and builtin functions common to both C and C++ language
4527    frontends.  */
4528
4529 void
4530 c_common_nodes_and_builtins (void)
4531 {
4532   int char16_type_size;
4533   int char32_type_size;
4534   int wchar_type_size;
4535   tree array_domain_type;
4536   tree va_list_ref_type_node;
4537   tree va_list_arg_type_node;
4538
4539   /* Define `int' and `char' first so that dbx will output them first.  */
4540   record_builtin_type (RID_INT, NULL, integer_type_node);
4541   record_builtin_type (RID_CHAR, "char", char_type_node);
4542
4543   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4544      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4545      but not C.  Are the conditionals here needed?  */
4546   if (c_dialect_cxx ())
4547     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4548   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4549   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4550   record_builtin_type (RID_MAX, "long unsigned int",
4551                        long_unsigned_type_node);
4552   if (c_dialect_cxx ())
4553     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4554   record_builtin_type (RID_MAX, "long long int",
4555                        long_long_integer_type_node);
4556   record_builtin_type (RID_MAX, "long long unsigned int",
4557                        long_long_unsigned_type_node);
4558   if (c_dialect_cxx ())
4559     record_builtin_type (RID_MAX, "long long unsigned",
4560                          long_long_unsigned_type_node);
4561   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4562   record_builtin_type (RID_MAX, "short unsigned int",
4563                        short_unsigned_type_node);
4564   if (c_dialect_cxx ())
4565     record_builtin_type (RID_MAX, "unsigned short",
4566                          short_unsigned_type_node);
4567
4568   /* Define both `signed char' and `unsigned char'.  */
4569   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4570   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4571
4572   /* These are types that c_common_type_for_size and
4573      c_common_type_for_mode use.  */
4574   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4575                                          intQI_type_node));
4576   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4577                                          intHI_type_node));
4578   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4579                                          intSI_type_node));
4580   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4581                                          intDI_type_node));
4582 #if HOST_BITS_PER_WIDE_INT >= 64
4583   if (targetm.scalar_mode_supported_p (TImode))
4584     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4585                                            get_identifier ("__int128_t"),
4586                                            intTI_type_node));
4587 #endif
4588   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4589                                          unsigned_intQI_type_node));
4590   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4591                                          unsigned_intHI_type_node));
4592   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4593                                          unsigned_intSI_type_node));
4594   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4595                                          unsigned_intDI_type_node));
4596 #if HOST_BITS_PER_WIDE_INT >= 64
4597   if (targetm.scalar_mode_supported_p (TImode))
4598     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4599                                            get_identifier ("__uint128_t"),
4600                                            unsigned_intTI_type_node));
4601 #endif
4602
4603   /* Create the widest literal types.  */
4604   widest_integer_literal_type_node
4605     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4606   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4607                                          widest_integer_literal_type_node));
4608
4609   widest_unsigned_literal_type_node
4610     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4611   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4612                                          widest_unsigned_literal_type_node));
4613
4614   /* `unsigned long' is the standard type for sizeof.
4615      Note that stddef.h uses `unsigned long',
4616      and this must agree, even if long and int are the same size.  */
4617   size_type_node =
4618     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4619   signed_size_type_node = c_common_signed_type (size_type_node);
4620   set_sizetype (size_type_node);
4621
4622   pid_type_node =
4623     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4624
4625   build_common_tree_nodes_2 (flag_short_double);
4626
4627   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4628   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4629   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4630
4631   /* Only supported decimal floating point extension if the target
4632      actually supports underlying modes. */
4633   if (targetm.scalar_mode_supported_p (SDmode)
4634       && targetm.scalar_mode_supported_p (DDmode)
4635       && targetm.scalar_mode_supported_p (TDmode))
4636     {
4637       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4638       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4639       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4640     }
4641
4642   if (targetm.fixed_point_supported_p ())
4643     {
4644       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4645       record_builtin_type (RID_FRACT, NULL, fract_type_node);
4646       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4647       record_builtin_type (RID_MAX, "long long _Fract",
4648                            long_long_fract_type_node);
4649       record_builtin_type (RID_MAX, "unsigned short _Fract",
4650                            unsigned_short_fract_type_node);
4651       record_builtin_type (RID_MAX, "unsigned _Fract",
4652                            unsigned_fract_type_node);
4653       record_builtin_type (RID_MAX, "unsigned long _Fract",
4654                            unsigned_long_fract_type_node);
4655       record_builtin_type (RID_MAX, "unsigned long long _Fract",
4656                            unsigned_long_long_fract_type_node);
4657       record_builtin_type (RID_MAX, "_Sat short _Fract",
4658                            sat_short_fract_type_node);
4659       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4660       record_builtin_type (RID_MAX, "_Sat long _Fract",
4661                            sat_long_fract_type_node);
4662       record_builtin_type (RID_MAX, "_Sat long long _Fract",
4663                            sat_long_long_fract_type_node);
4664       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4665                            sat_unsigned_short_fract_type_node);
4666       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4667                            sat_unsigned_fract_type_node);
4668       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4669                            sat_unsigned_long_fract_type_node);
4670       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4671                            sat_unsigned_long_long_fract_type_node);
4672       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4673       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4674       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4675       record_builtin_type (RID_MAX, "long long _Accum",
4676                            long_long_accum_type_node);
4677       record_builtin_type (RID_MAX, "unsigned short _Accum",
4678                            unsigned_short_accum_type_node);
4679       record_builtin_type (RID_MAX, "unsigned _Accum",
4680                            unsigned_accum_type_node);
4681       record_builtin_type (RID_MAX, "unsigned long _Accum",
4682                            unsigned_long_accum_type_node);
4683       record_builtin_type (RID_MAX, "unsigned long long _Accum",
4684                            unsigned_long_long_accum_type_node);
4685       record_builtin_type (RID_MAX, "_Sat short _Accum",
4686                            sat_short_accum_type_node);
4687       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4688       record_builtin_type (RID_MAX, "_Sat long _Accum",
4689                            sat_long_accum_type_node);
4690       record_builtin_type (RID_MAX, "_Sat long long _Accum",
4691                           sat_long_long_accum_type_node);
4692       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4693                            sat_unsigned_short_accum_type_node);
4694       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4695                            sat_unsigned_accum_type_node);
4696       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4697                            sat_unsigned_long_accum_type_node);
4698       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4699                            sat_unsigned_long_long_accum_type_node);
4700
4701     }
4702
4703   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4704                                          get_identifier ("complex int"),
4705                                          complex_integer_type_node));
4706   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4707                                          get_identifier ("complex float"),
4708                                          complex_float_type_node));
4709   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4710                                          get_identifier ("complex double"),
4711                                          complex_double_type_node));
4712   lang_hooks.decls.pushdecl
4713     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4714                  complex_long_double_type_node));
4715
4716   if (c_dialect_cxx ())
4717     /* For C++, make fileptr_type_node a distinct void * type until
4718        FILE type is defined.  */
4719     fileptr_type_node = build_variant_type_copy (ptr_type_node);
4720
4721   record_builtin_type (RID_VOID, NULL, void_type_node);
4722
4723   /* Set the TYPE_NAME for any variants that were built before
4724      record_builtin_type gave names to the built-in types. */
4725   {
4726     tree void_name = TYPE_NAME (void_type_node);
4727     TYPE_NAME (void_type_node) = NULL_TREE;
4728     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4729       = void_name;
4730     TYPE_NAME (void_type_node) = void_name;
4731   }
4732
4733   /* This node must not be shared.  */
4734   void_zero_node = make_node (INTEGER_CST);
4735   TREE_TYPE (void_zero_node) = void_type_node;
4736
4737   void_list_node = build_void_list_node ();
4738
4739   /* Make a type to be the domain of a few array types
4740      whose domains don't really matter.
4741      200 is small enough that it always fits in size_t
4742      and large enough that it can hold most function names for the
4743      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
4744   array_domain_type = build_index_type (size_int (200));
4745
4746   /* Make a type for arrays of characters.
4747      With luck nothing will ever really depend on the length of this
4748      array type.  */
4749   char_array_type_node
4750     = build_array_type (char_type_node, array_domain_type);
4751
4752   /* Likewise for arrays of ints.  */
4753   int_array_type_node
4754     = build_array_type (integer_type_node, array_domain_type);
4755
4756   string_type_node = build_pointer_type (char_type_node);
4757   const_string_type_node
4758     = build_pointer_type (build_qualified_type
4759                           (char_type_node, TYPE_QUAL_CONST));
4760
4761   /* This is special for C++ so functions can be overloaded.  */
4762   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4763   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4764   wchar_type_size = TYPE_PRECISION (wchar_type_node);
4765   if (c_dialect_cxx ())
4766     {
4767       if (TYPE_UNSIGNED (wchar_type_node))
4768         wchar_type_node = make_unsigned_type (wchar_type_size);
4769       else
4770         wchar_type_node = make_signed_type (wchar_type_size);
4771       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4772     }
4773   else
4774     {
4775       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4776       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4777     }
4778
4779   /* This is for wide string constants.  */
4780   wchar_array_type_node
4781     = build_array_type (wchar_type_node, array_domain_type);
4782
4783   /* Define 'char16_t'.  */
4784   char16_type_node = get_identifier (CHAR16_TYPE);
4785   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4786   char16_type_size = TYPE_PRECISION (char16_type_node);
4787   if (c_dialect_cxx ())
4788     {
4789       char16_type_node = make_unsigned_type (char16_type_size);
4790
4791       if (cxx_dialect == cxx0x)
4792         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4793     }
4794
4795   /* This is for UTF-16 string constants.  */
4796   char16_array_type_node
4797     = build_array_type (char16_type_node, array_domain_type);
4798
4799   /* Define 'char32_t'.  */
4800   char32_type_node = get_identifier (CHAR32_TYPE);
4801   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4802   char32_type_size = TYPE_PRECISION (char32_type_node);
4803   if (c_dialect_cxx ())
4804     {
4805       char32_type_node = make_unsigned_type (char32_type_size);
4806
4807       if (cxx_dialect == cxx0x)
4808         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4809     }
4810
4811   /* This is for UTF-32 string constants.  */
4812   char32_array_type_node
4813     = build_array_type (char32_type_node, array_domain_type);
4814
4815   wint_type_node =
4816     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4817
4818   intmax_type_node =
4819     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4820   uintmax_type_node =
4821     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4822
4823   default_function_type = build_function_type (integer_type_node, NULL_TREE);
4824   ptrdiff_type_node
4825     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4826   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4827
4828   lang_hooks.decls.pushdecl
4829     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4830                  va_list_type_node));
4831 #ifdef TARGET_ENUM_VA_LIST
4832   {
4833     int l;
4834     const char *pname;
4835     tree ptype;
4836     for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4837       {
4838         lang_hooks.decls.pushdecl
4839           (build_decl (TYPE_DECL, get_identifier (pname),
4840                        ptype));
4841
4842       }
4843   }
4844 #endif
4845
4846   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4847     {
4848       va_list_arg_type_node = va_list_ref_type_node =
4849         build_pointer_type (TREE_TYPE (va_list_type_node));
4850     }
4851   else
4852     {
4853       va_list_arg_type_node = va_list_type_node;
4854       va_list_ref_type_node = build_reference_type (va_list_type_node);
4855     }
4856
4857   if (!flag_preprocess_only)
4858     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4859
4860   main_identifier_node = get_identifier ("main");
4861
4862   /* Create the built-in __null node.  It is important that this is
4863      not shared.  */
4864   null_node = make_node (INTEGER_CST);
4865   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4866
4867   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
4868   memset (builtin_types, 0, sizeof (builtin_types));
4869 }
4870
4871 /* Look up the function in built_in_decls that corresponds to DECL
4872    and set ASMSPEC as its user assembler name.  DECL must be a
4873    function decl that declares a builtin.  */
4874
4875 void
4876 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4877 {
4878   tree builtin;
4879   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4880               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4881               && asmspec != 0);
4882
4883   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4884   set_user_assembler_name (builtin, asmspec);
4885   switch (DECL_FUNCTION_CODE (decl))
4886     {
4887     case BUILT_IN_MEMCPY:
4888       init_block_move_fn (asmspec);
4889       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
4890       break;
4891     case BUILT_IN_MEMSET:
4892       init_block_clear_fn (asmspec);
4893       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
4894       break;
4895     case BUILT_IN_MEMMOVE:
4896       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
4897       break;
4898     case BUILT_IN_MEMCMP:
4899       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
4900       break;
4901     case BUILT_IN_ABORT:
4902       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
4903       break;
4904     default:
4905       break;
4906     }
4907 }
4908
4909 /* The number of named compound-literals generated thus far.  */
4910 static GTY(()) int compound_literal_number;
4911
4912 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
4913
4914 void
4915 set_compound_literal_name (tree decl)
4916 {
4917   char *name;
4918   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4919                            compound_literal_number);
4920   compound_literal_number++;
4921   DECL_NAME (decl) = get_identifier (name);
4922 }
4923
4924 tree
4925 build_va_arg (tree expr, tree type)
4926 {
4927   return build1 (VA_ARG_EXPR, type, expr);
4928 }
4929
4930
4931 /* Linked list of disabled built-in functions.  */
4932
4933 typedef struct disabled_builtin
4934 {
4935   const char *name;
4936   struct disabled_builtin *next;
4937 } disabled_builtin;
4938 static disabled_builtin *disabled_builtins = NULL;
4939
4940 static bool builtin_function_disabled_p (const char *);
4941
4942 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
4943    begins with "__builtin_", give an error.  */
4944
4945 void
4946 disable_builtin_function (const char *name)
4947 {
4948   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4949     error ("cannot disable built-in function %qs", name);
4950   else
4951     {
4952       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4953       new_disabled_builtin->name = name;
4954       new_disabled_builtin->next = disabled_builtins;
4955       disabled_builtins = new_disabled_builtin;
4956     }
4957 }
4958
4959
4960 /* Return true if the built-in function NAME has been disabled, false
4961    otherwise.  */
4962
4963 static bool
4964 builtin_function_disabled_p (const char *name)
4965 {
4966   disabled_builtin *p;
4967   for (p = disabled_builtins; p != NULL; p = p->next)
4968     {
4969       if (strcmp (name, p->name) == 0)
4970         return true;
4971     }
4972   return false;
4973 }
4974
4975
4976 /* Worker for DEF_BUILTIN.
4977    Possibly define a builtin function with one or two names.
4978    Does not declare a non-__builtin_ function if flag_no_builtin, or if
4979    nonansi_p and flag_no_nonansi_builtin.  */
4980
4981 static void
4982 def_builtin_1 (enum built_in_function fncode,
4983                const char *name,
4984                enum built_in_class fnclass,
4985                tree fntype, tree libtype,
4986                bool both_p, bool fallback_p, bool nonansi_p,
4987                tree fnattrs, bool implicit_p)
4988 {
4989   tree decl;
4990   const char *libname;
4991
4992   if (fntype == error_mark_node)
4993     return;
4994
4995   gcc_assert ((!both_p && !fallback_p)
4996               || !strncmp (name, "__builtin_",
4997                            strlen ("__builtin_")));
4998
4999   libname = name + strlen ("__builtin_");
5000   decl = add_builtin_function (name, fntype, fncode, fnclass,
5001                                (fallback_p ? libname : NULL),
5002                                fnattrs);
5003   if (both_p
5004       && !flag_no_builtin && !builtin_function_disabled_p (libname)
5005       && !(nonansi_p && flag_no_nonansi_builtin))
5006     add_builtin_function (libname, libtype, fncode, fnclass,
5007                           NULL, fnattrs);
5008
5009   built_in_decls[(int) fncode] = decl;
5010   if (implicit_p)
5011     implicit_built_in_decls[(int) fncode] = decl;
5012 }
5013 \f
5014 /* Nonzero if the type T promotes to int.  This is (nearly) the
5015    integral promotions defined in ISO C99 6.3.1.1/2.  */
5016
5017 bool
5018 c_promoting_integer_type_p (const_tree t)
5019 {
5020   switch (TREE_CODE (t))
5021     {
5022     case INTEGER_TYPE:
5023       return (TYPE_MAIN_VARIANT (t) == char_type_node
5024               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5025               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5026               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5027               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5028               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5029
5030     case ENUMERAL_TYPE:
5031       /* ??? Technically all enumerations not larger than an int
5032          promote to an int.  But this is used along code paths
5033          that only want to notice a size change.  */
5034       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5035
5036     case BOOLEAN_TYPE:
5037       return 1;
5038
5039     default:
5040       return 0;
5041     }
5042 }
5043
5044 /* Return 1 if PARMS specifies a fixed number of parameters
5045    and none of their types is affected by default promotions.  */
5046
5047 int
5048 self_promoting_args_p (const_tree parms)
5049 {
5050   const_tree t;
5051   for (t = parms; t; t = TREE_CHAIN (t))
5052     {
5053       tree type = TREE_VALUE (t);
5054
5055       if (type == error_mark_node)
5056         continue;
5057
5058       if (TREE_CHAIN (t) == 0 && type != void_type_node)
5059         return 0;
5060
5061       if (type == 0)
5062         return 0;
5063
5064       if (TYPE_MAIN_VARIANT (type) == float_type_node)
5065         return 0;
5066
5067       if (c_promoting_integer_type_p (type))
5068         return 0;
5069     }
5070   return 1;
5071 }
5072
5073 /* Recursively remove any '*' or '&' operator from TYPE.  */
5074 tree
5075 strip_pointer_operator (tree t)
5076 {
5077   while (POINTER_TYPE_P (t))
5078     t = TREE_TYPE (t);
5079   return t;
5080 }
5081
5082 /* Recursively remove pointer or array type from TYPE. */
5083 tree
5084 strip_pointer_or_array_types (tree t)
5085 {
5086   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5087     t = TREE_TYPE (t);
5088   return t;
5089 }
5090
5091 /* Used to compare case labels.  K1 and K2 are actually tree nodes
5092    representing case labels, or NULL_TREE for a `default' label.
5093    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5094    K2, and 0 if K1 and K2 are equal.  */
5095
5096 int
5097 case_compare (splay_tree_key k1, splay_tree_key k2)
5098 {
5099   /* Consider a NULL key (such as arises with a `default' label) to be
5100      smaller than anything else.  */
5101   if (!k1)
5102     return k2 ? -1 : 0;
5103   else if (!k2)
5104     return k1 ? 1 : 0;
5105
5106   return tree_int_cst_compare ((tree) k1, (tree) k2);
5107 }
5108
5109 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
5110    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5111    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
5112    case label was declared using the usual C/C++ syntax, rather than
5113    the GNU case range extension.  CASES is a tree containing all the
5114    case ranges processed so far; COND is the condition for the
5115    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
5116    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
5117
5118 tree
5119 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
5120                   tree low_value, tree high_value)
5121 {
5122   tree type;
5123   tree label;
5124   tree case_label;
5125   splay_tree_node node;
5126
5127   /* Create the LABEL_DECL itself.  */
5128   label = create_artificial_label ();
5129
5130   /* If there was an error processing the switch condition, bail now
5131      before we get more confused.  */
5132   if (!cond || cond == error_mark_node)
5133     goto error_out;
5134
5135   if ((low_value && TREE_TYPE (low_value)
5136        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5137       || (high_value && TREE_TYPE (high_value)
5138           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5139     {
5140       error ("pointers are not permitted as case values");
5141       goto error_out;
5142     }
5143
5144   /* Case ranges are a GNU extension.  */
5145   if (high_value)
5146     pedwarn (input_location, OPT_pedantic,
5147              "range expressions in switch statements are non-standard");
5148
5149   type = TREE_TYPE (cond);
5150   if (low_value)
5151     {
5152       low_value = check_case_value (low_value);
5153       low_value = convert_and_check (type, low_value);
5154       if (low_value == error_mark_node)
5155         goto error_out;
5156     }
5157   if (high_value)
5158     {
5159       high_value = check_case_value (high_value);
5160       high_value = convert_and_check (type, high_value);
5161       if (high_value == error_mark_node)
5162         goto error_out;
5163     }
5164
5165   if (low_value && high_value)
5166     {
5167       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5168          really a case range, even though it was written that way.
5169          Remove the HIGH_VALUE to simplify later processing.  */
5170       if (tree_int_cst_equal (low_value, high_value))
5171         high_value = NULL_TREE;
5172       else if (!tree_int_cst_lt (low_value, high_value))
5173         warning (0, "empty range specified");
5174     }
5175
5176   /* See if the case is in range of the type of the original testing
5177      expression.  If both low_value and high_value are out of range,
5178      don't insert the case label and return NULL_TREE.  */
5179   if (low_value
5180       && !check_case_bounds (type, orig_type,
5181                              &low_value, high_value ? &high_value : NULL))
5182     return NULL_TREE;
5183
5184   /* Look up the LOW_VALUE in the table of case labels we already
5185      have.  */
5186   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5187   /* If there was not an exact match, check for overlapping ranges.
5188      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5189      that's a `default' label and the only overlap is an exact match.  */
5190   if (!node && (low_value || high_value))
5191     {
5192       splay_tree_node low_bound;
5193       splay_tree_node high_bound;
5194
5195       /* Even though there wasn't an exact match, there might be an
5196          overlap between this case range and another case range.
5197          Since we've (inductively) not allowed any overlapping case
5198          ranges, we simply need to find the greatest low case label
5199          that is smaller that LOW_VALUE, and the smallest low case
5200          label that is greater than LOW_VALUE.  If there is an overlap
5201          it will occur in one of these two ranges.  */
5202       low_bound = splay_tree_predecessor (cases,
5203                                           (splay_tree_key) low_value);
5204       high_bound = splay_tree_successor (cases,
5205                                          (splay_tree_key) low_value);
5206
5207       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5208          the LOW_VALUE, so there is no need to check unless the
5209          LOW_BOUND is in fact itself a case range.  */
5210       if (low_bound
5211           && CASE_HIGH ((tree) low_bound->value)
5212           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5213                                     low_value) >= 0)
5214         node = low_bound;
5215       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5216          range is bigger than the low end of the current range, so we
5217          are only interested if the current range is a real range, and
5218          not an ordinary case label.  */
5219       else if (high_bound
5220                && high_value
5221                && (tree_int_cst_compare ((tree) high_bound->key,
5222                                          high_value)
5223                    <= 0))
5224         node = high_bound;
5225     }
5226   /* If there was an overlap, issue an error.  */
5227   if (node)
5228     {
5229       tree duplicate = CASE_LABEL ((tree) node->value);
5230
5231       if (high_value)
5232         {
5233           error ("duplicate (or overlapping) case value");
5234           error ("%Jthis is the first entry overlapping that value", duplicate);
5235         }
5236       else if (low_value)
5237         {
5238           error ("duplicate case value") ;
5239           error ("%Jpreviously used here", duplicate);
5240         }
5241       else
5242         {
5243           error ("multiple default labels in one switch");
5244           error ("%Jthis is the first default label", duplicate);
5245         }
5246       goto error_out;
5247     }
5248
5249   /* Add a CASE_LABEL to the statement-tree.  */
5250   case_label = add_stmt (build_case_label (low_value, high_value, label));
5251   /* Register this case label in the splay tree.  */
5252   splay_tree_insert (cases,
5253                      (splay_tree_key) low_value,
5254                      (splay_tree_value) case_label);
5255
5256   return case_label;
5257
5258  error_out:
5259   /* Add a label so that the back-end doesn't think that the beginning of
5260      the switch is unreachable.  Note that we do not add a case label, as
5261      that just leads to duplicates and thence to failure later on.  */
5262   if (!cases->root)
5263     {
5264       tree t = create_artificial_label ();
5265       add_stmt (build_stmt (LABEL_EXPR, t));
5266     }
5267   return error_mark_node;
5268 }
5269
5270 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5271    Used to verify that case values match up with enumerator values.  */
5272
5273 static void
5274 match_case_to_enum_1 (tree key, tree type, tree label)
5275 {
5276   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5277
5278   /* ??? Not working too hard to print the double-word value.
5279      Should perhaps be done with %lwd in the diagnostic routines?  */
5280   if (TREE_INT_CST_HIGH (key) == 0)
5281     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5282               TREE_INT_CST_LOW (key));
5283   else if (!TYPE_UNSIGNED (type)
5284            && TREE_INT_CST_HIGH (key) == -1
5285            && TREE_INT_CST_LOW (key) != 0)
5286     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5287               -TREE_INT_CST_LOW (key));
5288   else
5289     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5290               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5291               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5292
5293   if (TYPE_NAME (type) == 0)
5294     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5295              "%Jcase value %qs not in enumerated type",
5296              CASE_LABEL (label), buf);
5297   else
5298     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5299              "%Jcase value %qs not in enumerated type %qT",
5300              CASE_LABEL (label), buf, type);
5301 }
5302
5303 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5304    Used to verify that case values match up with enumerator values.  */
5305
5306 static int
5307 match_case_to_enum (splay_tree_node node, void *data)
5308 {
5309   tree label = (tree) node->value;
5310   tree type = (tree) data;
5311
5312   /* Skip default case.  */
5313   if (!CASE_LOW (label))
5314     return 0;
5315
5316   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5317      when we did our enum->case scan.  Reset our scratch bit after.  */
5318   if (!CASE_LOW_SEEN (label))
5319     match_case_to_enum_1 (CASE_LOW (label), type, label);
5320   else
5321     CASE_LOW_SEEN (label) = 0;
5322
5323   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
5324      not set, that means that CASE_HIGH did not appear when we did our
5325      enum->case scan.  Reset our scratch bit after.  */
5326   if (CASE_HIGH (label))
5327     {
5328       if (!CASE_HIGH_SEEN (label))
5329         match_case_to_enum_1 (CASE_HIGH (label), type, label);
5330       else
5331         CASE_HIGH_SEEN (label) = 0;
5332     }
5333
5334   return 0;
5335 }
5336
5337 /* Handle -Wswitch*.  Called from the front end after parsing the
5338    switch construct.  */
5339 /* ??? Should probably be somewhere generic, since other languages
5340    besides C and C++ would want this.  At the moment, however, C/C++
5341    are the only tree-ssa languages that support enumerations at all,
5342    so the point is moot.  */
5343
5344 void
5345 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5346                       tree type, tree cond)
5347 {
5348   splay_tree_node default_node;
5349   splay_tree_node node;
5350   tree chain;
5351   int saved_warn_switch;
5352
5353   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5354     return;
5355
5356   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5357   if (!default_node)
5358     warning (OPT_Wswitch_default, "%Hswitch missing default case",
5359              &switch_location);
5360
5361   /* From here on, we only care about about enumerated types.  */
5362   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5363     return;
5364
5365   /* If the switch expression was an enumerated type, check that
5366      exactly all enumeration literals are covered by the cases.
5367      The check is made when -Wswitch was specified and there is no
5368      default case, or when -Wswitch-enum was specified.  */
5369
5370   if (!warn_switch_enum
5371       && !(warn_switch && !default_node))
5372     return;
5373
5374   /* Clearing COND if it is not an integer constant simplifies
5375      the tests inside the loop below.  */
5376   if (TREE_CODE (cond) != INTEGER_CST)
5377     cond = NULL_TREE;
5378
5379   /* The time complexity here is O(N*lg(N)) worst case, but for the
5380       common case of monotonically increasing enumerators, it is
5381       O(N), since the nature of the splay tree will keep the next
5382       element adjacent to the root at all times.  */
5383
5384   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5385     {
5386       tree value = TREE_VALUE (chain);
5387       if (TREE_CODE (value) == CONST_DECL)
5388         value = DECL_INITIAL (value);
5389       node = splay_tree_lookup (cases, (splay_tree_key) value);
5390       if (node)
5391         {
5392           /* Mark the CASE_LOW part of the case entry as seen.  */
5393           tree label = (tree) node->value;
5394           CASE_LOW_SEEN (label) = 1;
5395           continue;
5396         }
5397
5398       /* Even though there wasn't an exact match, there might be a
5399          case range which includes the enumerator's value.  */
5400       node = splay_tree_predecessor (cases, (splay_tree_key) value);
5401       if (node && CASE_HIGH ((tree) node->value))
5402         {
5403           tree label = (tree) node->value;
5404           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5405           if (cmp >= 0)
5406             {
5407               /* If we match the upper bound exactly, mark the CASE_HIGH
5408                  part of the case entry as seen.  */
5409               if (cmp == 0)
5410                 CASE_HIGH_SEEN (label) = 1;
5411               continue;
5412             }
5413         }
5414
5415       /* We've now determined that this enumerated literal isn't
5416          handled by the case labels of the switch statement.  */
5417
5418       /* If the switch expression is a constant, we only really care
5419          about whether that constant is handled by the switch.  */
5420       if (cond && tree_int_cst_compare (cond, value))
5421         continue;
5422
5423       /* If there is a default_node, the only relevant option is
5424          Wswitch-enum. Otherwise, if both are enabled then we prefer
5425          to warn using -Wswitch because -Wswitch is enabled by -Wall
5426          while -Wswitch-enum is explicit.  */
5427       warning ((default_node || !warn_switch)
5428                ? OPT_Wswitch_enum : OPT_Wswitch,
5429                "%Henumeration value %qE not handled in switch",
5430                &switch_location, TREE_PURPOSE (chain));
5431     }
5432
5433   /* Warn if there are case expressions that don't correspond to
5434      enumerators.  This can occur since C and C++ don't enforce
5435      type-checking of assignments to enumeration variables.
5436
5437      The time complexity here is now always O(N) worst case, since
5438      we should have marked both the lower bound and upper bound of
5439      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5440      above.  This scan also resets those fields.  */
5441
5442   /* If there is a default_node, the only relevant option is
5443      Wswitch-enum. Otherwise, if both are enabled then we prefer
5444      to warn using -Wswitch because -Wswitch is enabled by -Wall
5445      while -Wswitch-enum is explicit.  */
5446   saved_warn_switch = warn_switch;
5447   if (default_node)
5448     warn_switch = 0;
5449   splay_tree_foreach (cases, match_case_to_enum, type);
5450   warn_switch = saved_warn_switch;
5451
5452 }
5453
5454 /* Finish an expression taking the address of LABEL (an
5455    IDENTIFIER_NODE).  Returns an expression for the address.
5456
5457    LOC is the location for the expression returned.  */
5458
5459 tree
5460 finish_label_address_expr (tree label, location_t loc)
5461 {
5462   tree result;
5463
5464   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5465
5466   if (label == error_mark_node)
5467     return error_mark_node;
5468
5469   label = lookup_label (label);
5470   if (label == NULL_TREE)
5471     result = null_pointer_node;
5472   else
5473     {
5474       TREE_USED (label) = 1;
5475       result = build1 (ADDR_EXPR, ptr_type_node, label);
5476       /* The current function in not necessarily uninlinable.
5477          Computed gotos are incompatible with inlining, but the value
5478          here could be used only in a diagnostic, for example.  */
5479       protected_set_expr_location (result, loc);
5480     }
5481
5482   return result;
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 /* Callback from cpp_error for PFILE to print diagnostics from the
7969    preprocessor.  The diagnostic is of type LEVEL, at location
7970    LOCATION unless this is after lexing and the compiler's location
7971    should be used instead, with column number possibly overridden by
7972    COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
7973    the arguments.  Returns true if a diagnostic was emitted, false
7974    otherwise.  */
7975
7976 bool
7977 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level,
7978              location_t location, unsigned int column_override,
7979              const char *msg, va_list *ap)
7980 {
7981   diagnostic_info diagnostic;
7982   diagnostic_t dlevel;
7983   int save_warn_system_headers = warn_system_headers;
7984   bool ret;
7985
7986   switch (level)
7987     {
7988     case CPP_DL_WARNING_SYSHDR:
7989       if (flag_no_output)
7990         return false;
7991       warn_system_headers = 1;
7992       /* Fall through.  */
7993     case CPP_DL_WARNING:
7994       if (flag_no_output)
7995         return false;
7996       dlevel = DK_WARNING;
7997       break;
7998     case CPP_DL_PEDWARN:
7999       if (flag_no_output && !flag_pedantic_errors)
8000         return false;
8001       dlevel = DK_PEDWARN;
8002       break;
8003     case CPP_DL_ERROR:
8004       dlevel = DK_ERROR;
8005       break;
8006     case CPP_DL_ICE:
8007       dlevel = DK_ICE;
8008       break;
8009     case CPP_DL_NOTE:
8010       dlevel = DK_NOTE;
8011       break;
8012     default:
8013       gcc_unreachable ();
8014     }
8015   if (done_lexing)
8016     location = input_location;
8017   diagnostic_set_info_translated (&diagnostic, msg, ap,
8018                                   location, dlevel);
8019   if (column_override)
8020     diagnostic_override_column (&diagnostic, column_override);
8021   ret = report_diagnostic (&diagnostic);
8022   if (level == CPP_DL_WARNING_SYSHDR)
8023     warn_system_headers = save_warn_system_headers;
8024   return ret;
8025 }
8026
8027 /* Walk a gimplified function and warn for functions whose return value is
8028    ignored and attribute((warn_unused_result)) is set.  This is done before
8029    inlining, so we don't have to worry about that.  */
8030
8031 void
8032 c_warn_unused_result (gimple_seq seq)
8033 {
8034   tree fdecl, ftype;
8035   gimple_stmt_iterator i;
8036
8037   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8038     {
8039       gimple g = gsi_stmt (i);
8040
8041       switch (gimple_code (g))
8042         {
8043         case GIMPLE_BIND:
8044           c_warn_unused_result (gimple_bind_body (g));
8045           break;
8046         case GIMPLE_TRY:
8047           c_warn_unused_result (gimple_try_eval (g));
8048           c_warn_unused_result (gimple_try_cleanup (g));
8049           break;
8050         case GIMPLE_CATCH:
8051           c_warn_unused_result (gimple_catch_handler (g));
8052           break;
8053         case GIMPLE_EH_FILTER:
8054           c_warn_unused_result (gimple_eh_filter_failure (g));
8055           break;
8056
8057         case GIMPLE_CALL:
8058           if (gimple_call_lhs (g))
8059             break;
8060
8061           /* This is a naked call, as opposed to a GIMPLE_CALL with an
8062              LHS.  All calls whose value is ignored should be
8063              represented like this.  Look for the attribute.  */
8064           fdecl = gimple_call_fndecl (g);
8065           ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
8066
8067           if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8068             {
8069               location_t loc = gimple_location (g);
8070
8071               if (fdecl)
8072                 warning (0, "%Hignoring return value of %qD, "
8073                          "declared with attribute warn_unused_result",
8074                          &loc, fdecl);
8075               else
8076                 warning (0, "%Hignoring return value of function "
8077                          "declared with attribute warn_unused_result",
8078                          &loc);
8079             }
8080           break;
8081
8082         default:
8083           /* Not a container, not a call, or a call whose value is used.  */
8084           break;
8085         }
8086     }
8087 }
8088
8089 /* Convert a character from the host to the target execution character
8090    set.  cpplib handles this, mostly.  */
8091
8092 HOST_WIDE_INT
8093 c_common_to_target_charset (HOST_WIDE_INT c)
8094 {
8095   /* Character constants in GCC proper are sign-extended under -fsigned-char,
8096      zero-extended under -fno-signed-char.  cpplib insists that characters
8097      and character constants are always unsigned.  Hence we must convert
8098      back and forth.  */
8099   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8100
8101   uc = cpp_host_to_exec_charset (parse_in, uc);
8102
8103   if (flag_signed_char)
8104     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8105                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8106   else
8107     return uc;
8108 }
8109
8110 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
8111    component references, with STOP_REF, or alternatively an INDIRECT_REF of
8112    NULL, at the bottom; much like the traditional rendering of offsetof as a
8113    macro.  Returns the folded and properly cast result.  */
8114
8115 static tree
8116 fold_offsetof_1 (tree expr, tree stop_ref)
8117 {
8118   enum tree_code code = PLUS_EXPR;
8119   tree base, off, t;
8120
8121   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8122     return size_zero_node;
8123
8124   switch (TREE_CODE (expr))
8125     {
8126     case ERROR_MARK:
8127       return expr;
8128
8129     case VAR_DECL:
8130       error ("cannot apply %<offsetof%> to static data member %qD", expr);
8131       return error_mark_node;
8132
8133     case CALL_EXPR:
8134     case TARGET_EXPR:
8135       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8136       return error_mark_node;
8137
8138     case INTEGER_CST:
8139       gcc_assert (integer_zerop (expr));
8140       return size_zero_node;
8141
8142     case NOP_EXPR:
8143     case INDIRECT_REF:
8144       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8145       gcc_assert (base == error_mark_node || base == size_zero_node);
8146       return base;
8147
8148     case COMPONENT_REF:
8149       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8150       if (base == error_mark_node)
8151         return base;
8152
8153       t = TREE_OPERAND (expr, 1);
8154       if (DECL_C_BIT_FIELD (t))
8155         {
8156           error ("attempt to take address of bit-field structure "
8157                  "member %qD", t);
8158           return error_mark_node;
8159         }
8160       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
8161                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
8162                                   / BITS_PER_UNIT));
8163       break;
8164
8165     case ARRAY_REF:
8166       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8167       if (base == error_mark_node)
8168         return base;
8169
8170       t = TREE_OPERAND (expr, 1);
8171       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8172         {
8173           code = MINUS_EXPR;
8174           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
8175         }
8176       t = convert (sizetype, t);
8177       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8178       break;
8179
8180     case COMPOUND_EXPR:
8181       /* Handle static members of volatile structs.  */
8182       t = TREE_OPERAND (expr, 1);
8183       gcc_assert (TREE_CODE (t) == VAR_DECL);
8184       return fold_offsetof_1 (t, stop_ref);
8185
8186     default:
8187       gcc_unreachable ();
8188     }
8189
8190   return size_binop (code, base, off);
8191 }
8192
8193 tree
8194 fold_offsetof (tree expr, tree stop_ref)
8195 {
8196   /* Convert back from the internal sizetype to size_t.  */
8197   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8198 }
8199
8200 /* Print an error message for an invalid lvalue.  USE says
8201    how the lvalue is being used and so selects the error message.  */
8202
8203 void
8204 lvalue_error (enum lvalue_use use)
8205 {
8206   switch (use)
8207     {
8208     case lv_assign:
8209       error ("lvalue required as left operand of assignment");
8210       break;
8211     case lv_increment:
8212       error ("lvalue required as increment operand");
8213       break;
8214     case lv_decrement:
8215       error ("lvalue required as decrement operand");
8216       break;
8217     case lv_addressof:
8218       error ("lvalue required as unary %<&%> operand");
8219       break;
8220     case lv_asm:
8221       error ("lvalue required in asm statement");
8222       break;
8223     default:
8224       gcc_unreachable ();
8225     }
8226 }
8227 \f
8228 /* *PTYPE is an incomplete array.  Complete it with a domain based on
8229    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8230    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8231    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
8232
8233 int
8234 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8235 {
8236   tree maxindex, type, main_type, elt, unqual_elt;
8237   int failure = 0, quals;
8238   hashval_t hashcode = 0;
8239
8240   maxindex = size_zero_node;
8241   if (initial_value)
8242     {
8243       if (TREE_CODE (initial_value) == STRING_CST)
8244         {
8245           int eltsize
8246             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8247           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8248         }
8249       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8250         {
8251           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8252
8253           if (VEC_empty (constructor_elt, v))
8254             {
8255               if (pedantic)
8256                 failure = 3;
8257               maxindex = integer_minus_one_node;
8258             }
8259           else
8260             {
8261               tree curindex;
8262               unsigned HOST_WIDE_INT cnt;
8263               constructor_elt *ce;
8264               bool fold_p = false;
8265
8266               if (VEC_index (constructor_elt, v, 0)->index)
8267                 maxindex = fold_convert (sizetype,
8268                                          VEC_index (constructor_elt,
8269                                                     v, 0)->index);
8270               curindex = maxindex;
8271
8272               for (cnt = 1;
8273                    VEC_iterate (constructor_elt, v, cnt, ce);
8274                    cnt++)
8275                 {
8276                   bool curfold_p = false;
8277                   if (ce->index)
8278                     curindex = ce->index, curfold_p = true;
8279                   else
8280                     {
8281                       if (fold_p)
8282                         curindex = fold_convert (sizetype, curindex);
8283                       curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
8284                     }
8285                   if (tree_int_cst_lt (maxindex, curindex))
8286                     maxindex = curindex, fold_p = curfold_p;
8287                 }
8288                if (fold_p)
8289                  maxindex = fold_convert (sizetype, maxindex);
8290             }
8291         }
8292       else
8293         {
8294           /* Make an error message unless that happened already.  */
8295           if (initial_value != error_mark_node)
8296             failure = 1;
8297         }
8298     }
8299   else
8300     {
8301       failure = 2;
8302       if (!do_default)
8303         return failure;
8304     }
8305
8306   type = *ptype;
8307   elt = TREE_TYPE (type);
8308   quals = TYPE_QUALS (strip_array_types (elt));
8309   if (quals == 0)
8310     unqual_elt = elt;
8311   else
8312     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
8313
8314   /* Using build_distinct_type_copy and modifying things afterward instead
8315      of using build_array_type to create a new type preserves all of the
8316      TYPE_LANG_FLAG_? bits that the front end may have set.  */
8317   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8318   TREE_TYPE (main_type) = unqual_elt;
8319   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8320   layout_type (main_type);
8321
8322   /* Make sure we have the canonical MAIN_TYPE. */
8323   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8324   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8325                                     hashcode);
8326   main_type = type_hash_canon (hashcode, main_type);
8327
8328   /* Fix the canonical type.  */
8329   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8330       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8331     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8332   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8333            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8334                != TYPE_DOMAIN (main_type)))
8335     TYPE_CANONICAL (main_type)
8336       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8337                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8338   else
8339     TYPE_CANONICAL (main_type) = main_type;
8340
8341   if (quals == 0)
8342     type = main_type;
8343   else
8344     type = c_build_qualified_type (main_type, quals);
8345
8346   if (COMPLETE_TYPE_P (type)
8347       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8348       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8349     {
8350       error ("size of array is too large");
8351       /* If we proceed with the array type as it is, we'll eventually
8352          crash in tree_low_cst().  */
8353       type = error_mark_node;
8354     }
8355
8356   *ptype = type;
8357   return failure;
8358 }
8359
8360 \f
8361 /* Used to help initialize the builtin-types.def table.  When a type of
8362    the correct size doesn't exist, use error_mark_node instead of NULL.
8363    The later results in segfaults even when a decl using the type doesn't
8364    get invoked.  */
8365
8366 tree
8367 builtin_type_for_size (int size, bool unsignedp)
8368 {
8369   tree type = lang_hooks.types.type_for_size (size, unsignedp);
8370   return type ? type : error_mark_node;
8371 }
8372
8373 /* A helper function for resolve_overloaded_builtin in resolving the
8374    overloaded __sync_ builtins.  Returns a positive power of 2 if the
8375    first operand of PARAMS is a pointer to a supported data type.
8376    Returns 0 if an error is encountered.  */
8377
8378 static int
8379 sync_resolve_size (tree function, tree params)
8380 {
8381   tree type;
8382   int size;
8383
8384   if (params == NULL)
8385     {
8386       error ("too few arguments to function %qE", function);
8387       return 0;
8388     }
8389
8390   type = TREE_TYPE (TREE_VALUE (params));
8391   if (TREE_CODE (type) != POINTER_TYPE)
8392     goto incompatible;
8393
8394   type = TREE_TYPE (type);
8395   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8396     goto incompatible;
8397
8398   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8399   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8400     return size;
8401
8402  incompatible:
8403   error ("incompatible type for argument %d of %qE", 1, function);
8404   return 0;
8405 }
8406
8407 /* A helper function for resolve_overloaded_builtin.  Adds casts to
8408    PARAMS to make arguments match up with those of FUNCTION.  Drops
8409    the variadic arguments at the end.  Returns false if some error
8410    was encountered; true on success.  */
8411
8412 static bool
8413 sync_resolve_params (tree orig_function, tree function, tree params)
8414 {
8415   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8416   tree ptype;
8417   int number;
8418
8419   /* We've declared the implementation functions to use "volatile void *"
8420      as the pointer parameter, so we shouldn't get any complaints from the
8421      call to check_function_arguments what ever type the user used.  */
8422   arg_types = TREE_CHAIN (arg_types);
8423   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
8424   number = 2;
8425
8426   /* For the rest of the values, we need to cast these to FTYPE, so that we
8427      don't get warnings for passing pointer types, etc.  */
8428   while (arg_types != void_list_node)
8429     {
8430       tree val;
8431
8432       params = TREE_CHAIN (params);
8433       if (params == NULL)
8434         {
8435           error ("too few arguments to function %qE", orig_function);
8436           return false;
8437         }
8438
8439       /* ??? Ideally for the first conversion we'd use convert_for_assignment
8440          so that we get warnings for anything that doesn't match the pointer
8441          type.  This isn't portable across the C and C++ front ends atm.  */
8442       val = TREE_VALUE (params);
8443       val = convert (ptype, val);
8444       val = convert (TREE_VALUE (arg_types), val);
8445       TREE_VALUE (params) = val;
8446
8447       arg_types = TREE_CHAIN (arg_types);
8448       number++;
8449     }
8450
8451   /* The definition of these primitives is variadic, with the remaining
8452      being "an optional list of variables protected by the memory barrier".
8453      No clue what that's supposed to mean, precisely, but we consider all
8454      call-clobbered variables to be protected so we're safe.  */
8455   TREE_CHAIN (params) = NULL;
8456
8457   return true;
8458 }
8459
8460 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
8461    RESULT to make it match the type of the first pointer argument in
8462    PARAMS.  */
8463
8464 static tree
8465 sync_resolve_return (tree params, tree result)
8466 {
8467   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
8468   ptype = TYPE_MAIN_VARIANT (ptype);
8469   return convert (ptype, result);
8470 }
8471
8472 /* Some builtin functions are placeholders for other expressions.  This
8473    function should be called immediately after parsing the call expression
8474    before surrounding code has committed to the type of the expression.
8475
8476    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8477    PARAMS is the argument list for the call.  The return value is non-null
8478    when expansion is complete, and null if normal processing should
8479    continue.  */
8480
8481 tree
8482 resolve_overloaded_builtin (tree function, tree params)
8483 {
8484   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8485   switch (DECL_BUILT_IN_CLASS (function))
8486     {
8487     case BUILT_IN_NORMAL:
8488       break;
8489     case BUILT_IN_MD:
8490       if (targetm.resolve_overloaded_builtin)
8491         return targetm.resolve_overloaded_builtin (function, params);
8492       else
8493         return NULL_TREE;
8494     default:
8495       return NULL_TREE;
8496     }
8497
8498   /* Handle BUILT_IN_NORMAL here.  */
8499   switch (orig_code)
8500     {
8501     case BUILT_IN_FETCH_AND_ADD_N:
8502     case BUILT_IN_FETCH_AND_SUB_N:
8503     case BUILT_IN_FETCH_AND_OR_N:
8504     case BUILT_IN_FETCH_AND_AND_N:
8505     case BUILT_IN_FETCH_AND_XOR_N:
8506     case BUILT_IN_FETCH_AND_NAND_N:
8507     case BUILT_IN_ADD_AND_FETCH_N:
8508     case BUILT_IN_SUB_AND_FETCH_N:
8509     case BUILT_IN_OR_AND_FETCH_N:
8510     case BUILT_IN_AND_AND_FETCH_N:
8511     case BUILT_IN_XOR_AND_FETCH_N:
8512     case BUILT_IN_NAND_AND_FETCH_N:
8513     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8514     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8515     case BUILT_IN_LOCK_TEST_AND_SET_N:
8516     case BUILT_IN_LOCK_RELEASE_N:
8517       {
8518         int n = sync_resolve_size (function, params);
8519         tree new_function, result;
8520
8521         if (n == 0)
8522           return error_mark_node;
8523
8524         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8525         if (!sync_resolve_params (function, new_function, params))
8526           return error_mark_node;
8527
8528         result = build_function_call (new_function, params);
8529         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8530             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8531           result = sync_resolve_return (params, result);
8532
8533         return result;
8534       }
8535
8536     default:
8537       return NULL_TREE;
8538     }
8539 }
8540
8541 /* Ignoring their sign, return true if two scalar types are the same.  */
8542 bool
8543 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8544 {
8545   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8546
8547   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8548               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8549                   || c2 == FIXED_POINT_TYPE));
8550
8551   /* Equality works here because c_common_signed_type uses
8552      TYPE_MAIN_VARIANT.  */
8553   return c_common_signed_type (t1)
8554     == c_common_signed_type (t2);
8555 }
8556
8557 /* Check for missing format attributes on function pointers.  LTYPE is
8558    the new type or left-hand side type.  RTYPE is the old type or
8559    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8560    attribute.  */
8561
8562 bool
8563 check_missing_format_attribute (tree ltype, tree rtype)
8564 {
8565   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8566   tree ra;
8567
8568   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8569     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8570       break;
8571   if (ra)
8572     {
8573       tree la;
8574       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8575         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8576           break;
8577       return !la;
8578     }
8579   else
8580     return false;
8581 }
8582
8583 /* Subscripting with type char is likely to lose on a machine where
8584    chars are signed.  So warn on any machine, but optionally.  Don't
8585    warn for unsigned char since that type is safe.  Don't warn for
8586    signed char because anyone who uses that must have done so
8587    deliberately. Furthermore, we reduce the false positive load by
8588    warning only for non-constant value of type char.  */
8589
8590 void
8591 warn_array_subscript_with_type_char (tree index)
8592 {
8593   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8594       && TREE_CODE (index) != INTEGER_CST)
8595     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8596 }
8597
8598 /* Implement -Wparentheses for the unexpected C precedence rules, to
8599    cover cases like x + y << z which readers are likely to
8600    misinterpret.  We have seen an expression in which CODE is a binary
8601    operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8602    before folding had CODE_LEFT and CODE_RIGHT.  CODE_LEFT and
8603    CODE_RIGHT may be ERROR_MARK, which means that that side of the
8604    expression was not formed using a binary or unary operator, or it
8605    was enclosed in parentheses.  */
8606
8607 void
8608 warn_about_parentheses (enum tree_code code,
8609                         enum tree_code code_left, tree arg_left,
8610                         enum tree_code code_right, tree arg_right)
8611 {
8612   if (!warn_parentheses)
8613     return;
8614
8615   /* This macro tests that the expression ARG with original tree code
8616      CODE appears to be a boolean expression. or the result of folding a
8617      boolean expression.  */
8618 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG)                             \
8619         (truth_value_p (TREE_CODE (ARG))                                    \
8620          || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE                     \
8621          /* Folding may create 0 or 1 integers from other expressions.  */  \
8622          || ((CODE) != INTEGER_CST                                          \
8623              && (integer_onep (ARG) || integer_zerop (ARG))))
8624
8625   switch (code)
8626     {
8627     case LSHIFT_EXPR:
8628       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8629         warning (OPT_Wparentheses,
8630                  "suggest parentheses around %<+%> inside %<<<%>");
8631       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8632         warning (OPT_Wparentheses,
8633                  "suggest parentheses around %<-%> inside %<<<%>");
8634       return;
8635
8636     case RSHIFT_EXPR:
8637       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8638         warning (OPT_Wparentheses,
8639                  "suggest parentheses around %<+%> inside %<>>%>");
8640       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8641         warning (OPT_Wparentheses,
8642                  "suggest parentheses around %<-%> inside %<>>%>");
8643       return;
8644
8645     case TRUTH_ORIF_EXPR:
8646       if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
8647         warning (OPT_Wparentheses,
8648                  "suggest parentheses around %<&&%> within %<||%>");
8649       return;
8650
8651     case BIT_IOR_EXPR:
8652       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8653           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8654           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8655           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8656         warning (OPT_Wparentheses,
8657                  "suggest parentheses around arithmetic in operand of %<|%>");
8658       /* Check cases like x|y==z */
8659       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8660                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8661         warning (OPT_Wparentheses,
8662                  "suggest parentheses around comparison in operand of %<|%>");
8663       /* Check cases like !x | y */
8664       else if (code_left == TRUTH_NOT_EXPR
8665                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8666         warning (OPT_Wparentheses, "suggest parentheses around operand of "
8667                  "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
8668       return;
8669
8670     case BIT_XOR_EXPR:
8671       if (code_left == BIT_AND_EXPR
8672           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8673           || code_right == BIT_AND_EXPR
8674           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8675         warning (OPT_Wparentheses,
8676                  "suggest parentheses around arithmetic in operand of %<^%>");
8677       /* Check cases like x^y==z */
8678       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8679                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8680         warning (OPT_Wparentheses,
8681                  "suggest parentheses around comparison in operand of %<^%>");
8682       return;
8683
8684     case BIT_AND_EXPR:
8685       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8686         warning (OPT_Wparentheses,
8687                  "suggest parentheses around %<+%> in operand of %<&%>");
8688       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8689         warning (OPT_Wparentheses,
8690                  "suggest parentheses around %<-%> in operand of %<&%>");
8691       /* Check cases like x&y==z */
8692       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
8693                || TREE_CODE_CLASS (code_right) == tcc_comparison)
8694         warning (OPT_Wparentheses,
8695                  "suggest parentheses around comparison in operand of %<&%>");
8696       /* Check cases like !x & y */
8697       else if (code_left == TRUTH_NOT_EXPR
8698                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
8699         warning (OPT_Wparentheses, "suggest parentheses around operand of "
8700                  "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
8701       return;
8702
8703     case EQ_EXPR:
8704       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8705           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8706         warning (OPT_Wparentheses,
8707                  "suggest parentheses around comparison in operand of %<==%>");
8708       return;
8709     case NE_EXPR:
8710       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8711           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8712         warning (OPT_Wparentheses,
8713                  "suggest parentheses around comparison in operand of %<!=%>");
8714       return;
8715
8716     default:
8717       if (TREE_CODE_CLASS (code) == tcc_comparison
8718            && ((TREE_CODE_CLASS (code_left) == tcc_comparison
8719                 && code_left != NE_EXPR && code_left != EQ_EXPR
8720                 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
8721                || (TREE_CODE_CLASS (code_right) == tcc_comparison
8722                    && code_right != NE_EXPR && code_right != EQ_EXPR
8723                    && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
8724         warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
8725                  "have their mathematical meaning");
8726       return;
8727     }
8728 #undef NOT_A_BOOLEAN_EXPR_P
8729 }
8730
8731 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
8732
8733 void
8734 warn_for_unused_label (tree label)
8735 {
8736   if (!TREE_USED (label))
8737     {
8738       if (DECL_INITIAL (label))
8739         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8740       else
8741         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8742     }
8743 }
8744
8745 #ifndef TARGET_HAS_TARGETCM
8746 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8747 #endif
8748
8749 /* Warn for division by zero according to the value of DIVISOR.  LOC
8750    is the location of the division operator.  */
8751
8752 void
8753 warn_for_div_by_zero (location_t loc, tree divisor)
8754 {
8755   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8756      about division by zero.  Do not issue a warning if DIVISOR has a
8757      floating-point type, since we consider 0.0/0.0 a valid way of
8758      generating a NaN.  */
8759   if (skip_evaluation == 0
8760       && (integer_zerop (divisor) || fixed_zerop (divisor)))
8761     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8762 }
8763
8764 /* Subroutine of build_binary_op. Give warnings for comparisons
8765    between signed and unsigned quantities that may fail. Do the
8766    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8767    so that casts will be considered, but default promotions won't
8768    be.
8769
8770    LOCATION is the location of the comparison operator.
8771
8772    The arguments of this function map directly to local variables
8773    of build_binary_op.  */
8774
8775 void
8776 warn_for_sign_compare (location_t location,
8777                        tree orig_op0, tree orig_op1,
8778                        tree op0, tree op1,
8779                        tree result_type, enum tree_code resultcode)
8780 {
8781   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8782   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8783   int unsignedp0, unsignedp1;
8784
8785   /* In C++, check for comparison of different enum types.  */
8786   if (c_dialect_cxx()
8787       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8788       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8789       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8790          != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8791     {
8792       warning_at (location,
8793                   OPT_Wsign_compare, "comparison between types %qT and %qT",
8794                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8795     }
8796
8797   /* Do not warn if the comparison is being done in a signed type,
8798      since the signed type will only be chosen if it can represent
8799      all the values of the unsigned type.  */
8800   if (!TYPE_UNSIGNED (result_type))
8801     /* OK */;
8802   /* Do not warn if both operands are unsigned.  */
8803   else if (op0_signed == op1_signed)
8804     /* OK */;
8805   else
8806     {
8807       tree sop, uop, base_type;
8808       bool ovf;
8809
8810       if (op0_signed)
8811         sop = orig_op0, uop = orig_op1;
8812       else
8813         sop = orig_op1, uop = orig_op0;
8814
8815       STRIP_TYPE_NOPS (sop);
8816       STRIP_TYPE_NOPS (uop);
8817       base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
8818                    ? TREE_TYPE (result_type) : result_type);
8819
8820       /* Do not warn if the signed quantity is an unsuffixed integer
8821          literal (or some static constant expression involving such
8822          literals or a conditional expression involving such literals)
8823          and it is non-negative.  */
8824       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8825         /* OK */;
8826       /* Do not warn if the comparison is an equality operation, the
8827          unsigned quantity is an integral constant, and it would fit
8828          in the result if the result were signed.  */
8829       else if (TREE_CODE (uop) == INTEGER_CST
8830                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8831                && int_fits_type_p (uop, c_common_signed_type (base_type)))
8832         /* OK */;
8833       /* In C, do not warn if the unsigned quantity is an enumeration
8834          constant and its maximum value would fit in the result if the
8835          result were signed.  */
8836       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8837                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8838                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8839                                    c_common_signed_type (base_type)))
8840         /* OK */;
8841       else
8842         warning_at (location,
8843                     OPT_Wsign_compare,
8844                     "comparison between signed and unsigned integer expressions");
8845     }
8846
8847   /* Warn if two unsigned values are being compared in a size larger
8848      than their original size, and one (and only one) is the result of
8849      a `~' operator.  This comparison will always fail.
8850
8851      Also warn if one operand is a constant, and the constant does not
8852      have all bits set that are set in the ~ operand when it is
8853      extended.  */
8854
8855   op0 = get_narrower (op0, &unsignedp0);
8856   op1 = get_narrower (op1, &unsignedp1);
8857
8858   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8859       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8860     {
8861       if (TREE_CODE (op0) == BIT_NOT_EXPR)
8862         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8863       if (TREE_CODE (op1) == BIT_NOT_EXPR)
8864         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8865
8866       if (host_integerp (op0, 0) || host_integerp (op1, 0))
8867         {
8868           tree primop;
8869           HOST_WIDE_INT constant, mask;
8870           int unsignedp;
8871           unsigned int bits;
8872
8873           if (host_integerp (op0, 0))
8874             {
8875               primop = op1;
8876               unsignedp = unsignedp1;
8877               constant = tree_low_cst (op0, 0);
8878             }
8879           else
8880             {
8881               primop = op0;
8882               unsignedp = unsignedp0;
8883               constant = tree_low_cst (op1, 0);
8884             }
8885
8886           bits = TYPE_PRECISION (TREE_TYPE (primop));
8887           if (bits < TYPE_PRECISION (result_type)
8888               && bits < HOST_BITS_PER_LONG && unsignedp)
8889             {
8890               mask = (~ (HOST_WIDE_INT) 0) << bits;
8891               if ((mask & constant) != mask)
8892                 {
8893                   if (constant == 0)
8894                     warning (OPT_Wsign_compare,
8895                              "promoted ~unsigned is always non-zero");
8896                   else
8897                     warning_at (location, OPT_Wsign_compare,
8898                                 "comparison of promoted ~unsigned with constant");
8899                 }
8900             }
8901         }
8902       else if (unsignedp0 && unsignedp1
8903                && (TYPE_PRECISION (TREE_TYPE (op0))
8904                    < TYPE_PRECISION (result_type))
8905                && (TYPE_PRECISION (TREE_TYPE (op1))
8906                    < TYPE_PRECISION (result_type)))
8907         warning_at (location, OPT_Wsign_compare,
8908                  "comparison of promoted ~unsigned with unsigned");
8909     }
8910 }
8911
8912 #include "gt-c-common.h"