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