gcc/c-common.c

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