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

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