contrib/gcc-4.4/gcc/c-common.c

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