gcc/c-common.c

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