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