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