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