gcc/c-common.c

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