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