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