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