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