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

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