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 (tree attr_id)
5822 {
5823   return (is_attribute_p ("mode", attr_id)
5824           || is_attribute_p ("format", attr_id)
5825           || is_attribute_p ("cleanup", attr_id));
5826 }
5827
5828 /* Attribute handlers common to C front ends.  */
5829
5830 /* Handle a "packed" attribute; arguments as in
5831    struct attribute_spec.handler.  */
5832
5833 static tree
5834 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5835                          int flags, bool *no_add_attrs)
5836 {
5837   if (TYPE_P (*node))
5838     {
5839       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5840         *node = build_variant_type_copy (*node);
5841       TYPE_PACKED (*node) = 1;
5842     }
5843   else if (TREE_CODE (*node) == FIELD_DECL)
5844     {
5845       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5846           /* Still pack bitfields.  */
5847           && ! DECL_INITIAL (*node))
5848         warning (OPT_Wattributes,
5849                  "%qE attribute ignored for field of type %qT",
5850                  name, TREE_TYPE (*node));
5851       else
5852         DECL_PACKED (*node) = 1;
5853     }
5854   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5855      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5856      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5857      that changes what the typedef is typing.  */
5858   else
5859     {
5860       warning (OPT_Wattributes, "%qE attribute ignored", name);
5861       *no_add_attrs = true;
5862     }
5863
5864   return NULL_TREE;
5865 }
5866
5867 /* Handle a "nocommon" attribute; arguments as in
5868    struct attribute_spec.handler.  */
5869
5870 static tree
5871 handle_nocommon_attribute (tree *node, tree name,
5872                            tree ARG_UNUSED (args),
5873                            int ARG_UNUSED (flags), bool *no_add_attrs)
5874 {
5875   if (TREE_CODE (*node) == VAR_DECL)
5876     DECL_COMMON (*node) = 0;
5877   else
5878     {
5879       warning (OPT_Wattributes, "%qE attribute ignored", name);
5880       *no_add_attrs = true;
5881     }
5882
5883   return NULL_TREE;
5884 }
5885
5886 /* Handle a "common" attribute; arguments as in
5887    struct attribute_spec.handler.  */
5888
5889 static tree
5890 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5891                          int ARG_UNUSED (flags), bool *no_add_attrs)
5892 {
5893   if (TREE_CODE (*node) == VAR_DECL)
5894     DECL_COMMON (*node) = 1;
5895   else
5896     {
5897       warning (OPT_Wattributes, "%qE attribute ignored", name);
5898       *no_add_attrs = true;
5899     }
5900
5901   return NULL_TREE;
5902 }
5903
5904 /* Handle a "noreturn" attribute; arguments as in
5905    struct attribute_spec.handler.  */
5906
5907 static tree
5908 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5909                            int ARG_UNUSED (flags), bool *no_add_attrs)
5910 {
5911   tree type = TREE_TYPE (*node);
5912
5913   /* See FIXME comment in c_common_attribute_table.  */
5914   if (TREE_CODE (*node) == FUNCTION_DECL)
5915     TREE_THIS_VOLATILE (*node) = 1;
5916   else if (TREE_CODE (type) == POINTER_TYPE
5917            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5918     TREE_TYPE (*node)
5919       = build_pointer_type
5920         (build_type_variant (TREE_TYPE (type),
5921                              TYPE_READONLY (TREE_TYPE (type)), 1));
5922   else
5923     {
5924       warning (OPT_Wattributes, "%qE attribute ignored", name);
5925       *no_add_attrs = true;
5926     }
5927
5928   return NULL_TREE;
5929 }
5930
5931 /* Handle a "hot" and attribute; arguments as in
5932    struct attribute_spec.handler.  */
5933
5934 static tree
5935 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5936                       int ARG_UNUSED (flags), bool *no_add_attrs)
5937 {
5938   if (TREE_CODE (*node) == FUNCTION_DECL)
5939     {
5940       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5941         {
5942           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5943                    name, "cold");
5944           *no_add_attrs = true;
5945         }
5946       /* Most of the rest of the hot processing is done later with
5947          lookup_attribute.  */
5948     }
5949   else
5950     {
5951       warning (OPT_Wattributes, "%qE attribute ignored", name);
5952       *no_add_attrs = true;
5953     }
5954
5955   return NULL_TREE;
5956 }
5957 /* Handle a "cold" and attribute; arguments as in
5958    struct attribute_spec.handler.  */
5959
5960 static tree
5961 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5962                        int ARG_UNUSED (flags), bool *no_add_attrs)
5963 {
5964   if (TREE_CODE (*node) == FUNCTION_DECL)
5965     {
5966       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5967         {
5968           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5969                    name, "hot");
5970           *no_add_attrs = true;
5971         }
5972       /* Most of the rest of the cold processing is done later with
5973          lookup_attribute.  */
5974     }
5975   else
5976     {
5977       warning (OPT_Wattributes, "%qE attribute ignored", name);
5978       *no_add_attrs = true;
5979     }
5980
5981   return NULL_TREE;
5982 }
5983
5984 /* Handle a "noinline" attribute; arguments as in
5985    struct attribute_spec.handler.  */
5986
5987 static tree
5988 handle_noinline_attribute (tree *node, tree name,
5989                            tree ARG_UNUSED (args),
5990                            int ARG_UNUSED (flags), bool *no_add_attrs)
5991 {
5992   if (TREE_CODE (*node) == FUNCTION_DECL)
5993     DECL_UNINLINABLE (*node) = 1;
5994   else
5995     {
5996       warning (OPT_Wattributes, "%qE attribute ignored", name);
5997       *no_add_attrs = true;
5998     }
5999
6000   return NULL_TREE;
6001 }
6002
6003 /* Handle a "noclone" attribute; arguments as in
6004    struct attribute_spec.handler.  */
6005
6006 static tree
6007 handle_noclone_attribute (tree *node, tree name,
6008                           tree ARG_UNUSED (args),
6009                           int ARG_UNUSED (flags), bool *no_add_attrs)
6010 {
6011   if (TREE_CODE (*node) != FUNCTION_DECL)
6012     {
6013       warning (OPT_Wattributes, "%qE attribute ignored", name);
6014       *no_add_attrs = true;
6015     }
6016
6017   return NULL_TREE;
6018 }
6019
6020 /* Handle a "always_inline" attribute; arguments as in
6021    struct attribute_spec.handler.  */
6022
6023 static tree
6024 handle_always_inline_attribute (tree *node, tree name,
6025                                 tree ARG_UNUSED (args),
6026                                 int ARG_UNUSED (flags),
6027                                 bool *no_add_attrs)
6028 {
6029   if (TREE_CODE (*node) == FUNCTION_DECL)
6030     {
6031       /* Set the attribute and mark it for disregarding inline
6032          limits.  */
6033       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6034     }
6035   else
6036     {
6037       warning (OPT_Wattributes, "%qE attribute ignored", name);
6038       *no_add_attrs = true;
6039     }
6040
6041   return NULL_TREE;
6042 }
6043
6044 /* Handle a "gnu_inline" attribute; arguments as in
6045    struct attribute_spec.handler.  */
6046
6047 static tree
6048 handle_gnu_inline_attribute (tree *node, tree name,
6049                              tree ARG_UNUSED (args),
6050                              int ARG_UNUSED (flags),
6051                              bool *no_add_attrs)
6052 {
6053   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6054     {
6055       /* Do nothing else, just set the attribute.  We'll get at
6056          it later with lookup_attribute.  */
6057     }
6058   else
6059     {
6060       warning (OPT_Wattributes, "%qE attribute ignored", name);
6061       *no_add_attrs = true;
6062     }
6063
6064   return NULL_TREE;
6065 }
6066
6067 /* Handle an "artificial" attribute; arguments as in
6068    struct attribute_spec.handler.  */
6069
6070 static tree
6071 handle_artificial_attribute (tree *node, tree name,
6072                              tree ARG_UNUSED (args),
6073                              int ARG_UNUSED (flags),
6074                              bool *no_add_attrs)
6075 {
6076   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6077     {
6078       /* Do nothing else, just set the attribute.  We'll get at
6079          it later with lookup_attribute.  */
6080     }
6081   else
6082     {
6083       warning (OPT_Wattributes, "%qE attribute ignored", name);
6084       *no_add_attrs = true;
6085     }
6086
6087   return NULL_TREE;
6088 }
6089
6090 /* Handle a "flatten" attribute; arguments as in
6091    struct attribute_spec.handler.  */
6092
6093 static tree
6094 handle_flatten_attribute (tree *node, tree name,
6095                           tree args ATTRIBUTE_UNUSED,
6096                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6097 {
6098   if (TREE_CODE (*node) == FUNCTION_DECL)
6099     /* Do nothing else, just set the attribute.  We'll get at
6100        it later with lookup_attribute.  */
6101     ;
6102   else
6103     {
6104       warning (OPT_Wattributes, "%qE attribute ignored", name);
6105       *no_add_attrs = true;
6106     }
6107
6108   return NULL_TREE;
6109 }
6110
6111 /* Handle a "warning" or "error" attribute; arguments as in
6112    struct attribute_spec.handler.  */
6113
6114 static tree
6115 handle_error_attribute (tree *node, tree name, tree args,
6116                         int ARG_UNUSED (flags), bool *no_add_attrs)
6117 {
6118   if (TREE_CODE (*node) == FUNCTION_DECL
6119       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6120     /* Do nothing else, just set the attribute.  We'll get at
6121        it later with lookup_attribute.  */
6122     ;
6123   else
6124     {
6125       warning (OPT_Wattributes, "%qE attribute ignored", name);
6126       *no_add_attrs = true;
6127     }
6128
6129   return NULL_TREE;
6130 }
6131
6132 /* Handle a "used" attribute; arguments as in
6133    struct attribute_spec.handler.  */
6134
6135 static tree
6136 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6137                        int ARG_UNUSED (flags), bool *no_add_attrs)
6138 {
6139   tree node = *pnode;
6140
6141   if (TREE_CODE (node) == FUNCTION_DECL
6142       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
6143     {
6144       TREE_USED (node) = 1;
6145       DECL_PRESERVE_P (node) = 1;
6146       if (TREE_CODE (node) == VAR_DECL)
6147         DECL_READ_P (node) = 1;
6148     }
6149   else
6150     {
6151       warning (OPT_Wattributes, "%qE attribute ignored", name);
6152       *no_add_attrs = true;
6153     }
6154
6155   return NULL_TREE;
6156 }
6157
6158 /* Handle a "unused" attribute; arguments as in
6159    struct attribute_spec.handler.  */
6160
6161 static tree
6162 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6163                          int flags, bool *no_add_attrs)
6164 {
6165   if (DECL_P (*node))
6166     {
6167       tree decl = *node;
6168
6169       if (TREE_CODE (decl) == PARM_DECL
6170           || TREE_CODE (decl) == VAR_DECL
6171           || TREE_CODE (decl) == FUNCTION_DECL
6172           || TREE_CODE (decl) == LABEL_DECL
6173           || TREE_CODE (decl) == TYPE_DECL)
6174         {
6175           TREE_USED (decl) = 1;
6176           if (TREE_CODE (decl) == VAR_DECL
6177               || TREE_CODE (decl) == PARM_DECL)
6178             DECL_READ_P (decl) = 1;
6179         }
6180       else
6181         {
6182           warning (OPT_Wattributes, "%qE attribute ignored", name);
6183           *no_add_attrs = true;
6184         }
6185     }
6186   else
6187     {
6188       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6189         *node = build_variant_type_copy (*node);
6190       TREE_USED (*node) = 1;
6191     }
6192
6193   return NULL_TREE;
6194 }
6195
6196 /* Handle a "externally_visible" attribute; arguments as in
6197    struct attribute_spec.handler.  */
6198
6199 static tree
6200 handle_externally_visible_attribute (tree *pnode, tree name,
6201                                      tree ARG_UNUSED (args),
6202                                      int ARG_UNUSED (flags),
6203                                      bool *no_add_attrs)
6204 {
6205   tree node = *pnode;
6206
6207   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6208     {
6209       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6210            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6211         {
6212           warning (OPT_Wattributes,
6213                    "%qE attribute have effect only on public objects", name);
6214           *no_add_attrs = true;
6215         }
6216     }
6217   else
6218     {
6219       warning (OPT_Wattributes, "%qE attribute ignored", name);
6220       *no_add_attrs = true;
6221     }
6222
6223   return NULL_TREE;
6224 }
6225
6226 /* Handle a "const" attribute; arguments as in
6227    struct attribute_spec.handler.  */
6228
6229 static tree
6230 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6231                         int ARG_UNUSED (flags), bool *no_add_attrs)
6232 {
6233   tree type = TREE_TYPE (*node);
6234
6235   /* See FIXME comment on noreturn in c_common_attribute_table.  */
6236   if (TREE_CODE (*node) == FUNCTION_DECL)
6237     TREE_READONLY (*node) = 1;
6238   else if (TREE_CODE (type) == POINTER_TYPE
6239            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6240     TREE_TYPE (*node)
6241       = build_pointer_type
6242         (build_type_variant (TREE_TYPE (type), 1,
6243                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
6244   else
6245     {
6246       warning (OPT_Wattributes, "%qE attribute ignored", name);
6247       *no_add_attrs = true;
6248     }
6249
6250   return NULL_TREE;
6251 }
6252
6253 /* Handle a "transparent_union" attribute; arguments as in
6254    struct attribute_spec.handler.  */
6255
6256 static tree
6257 handle_transparent_union_attribute (tree *node, tree name,
6258                                     tree ARG_UNUSED (args), int flags,
6259                                     bool *no_add_attrs)
6260 {
6261   tree type;
6262
6263   *no_add_attrs = true;
6264
6265   if (TREE_CODE (*node) == TYPE_DECL)
6266     node = &TREE_TYPE (*node);
6267   type = *node;
6268
6269   if (TREE_CODE (type) == UNION_TYPE)
6270     {
6271       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
6272          the code in finish_struct.  */
6273       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6274         {
6275           if (TYPE_FIELDS (type) == NULL_TREE
6276               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
6277             goto ignored;
6278
6279           /* A type variant isn't good enough, since we don't a cast
6280              to such a type removed as a no-op.  */
6281           *node = type = build_duplicate_type (type);
6282         }
6283
6284       TYPE_TRANSPARENT_AGGR (type) = 1;
6285       return NULL_TREE;
6286     }
6287
6288  ignored:
6289   warning (OPT_Wattributes, "%qE attribute ignored", name);
6290   return NULL_TREE;
6291 }
6292
6293 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
6294    get the requested priority for a constructor or destructor,
6295    possibly issuing diagnostics for invalid or reserved
6296    priorities.  */
6297
6298 static priority_type
6299 get_priority (tree args, bool is_destructor)
6300 {
6301   HOST_WIDE_INT pri;
6302   tree arg;
6303
6304   if (!args)
6305     return DEFAULT_INIT_PRIORITY;
6306
6307   if (!SUPPORTS_INIT_PRIORITY)
6308     {
6309       if (is_destructor)
6310         error ("destructor priorities are not supported");
6311       else
6312         error ("constructor priorities are not supported");
6313       return DEFAULT_INIT_PRIORITY;
6314     }
6315
6316   arg = TREE_VALUE (args);
6317   if (!host_integerp (arg, /*pos=*/0)
6318       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6319     goto invalid;
6320
6321   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6322   if (pri < 0 || pri > MAX_INIT_PRIORITY)
6323     goto invalid;
6324
6325   if (pri <= MAX_RESERVED_INIT_PRIORITY)
6326     {
6327       if (is_destructor)
6328         warning (0,
6329                  "destructor priorities from 0 to %d are reserved "
6330                  "for the implementation",
6331                  MAX_RESERVED_INIT_PRIORITY);
6332       else
6333         warning (0,
6334                  "constructor priorities from 0 to %d are reserved "
6335                  "for the implementation",
6336                  MAX_RESERVED_INIT_PRIORITY);
6337     }
6338   return pri;
6339
6340  invalid:
6341   if (is_destructor)
6342     error ("destructor priorities must be integers from 0 to %d inclusive",
6343            MAX_INIT_PRIORITY);
6344   else
6345     error ("constructor priorities must be integers from 0 to %d inclusive",
6346            MAX_INIT_PRIORITY);
6347   return DEFAULT_INIT_PRIORITY;
6348 }
6349
6350 /* Handle a "constructor" attribute; arguments as in
6351    struct attribute_spec.handler.  */
6352
6353 static tree
6354 handle_constructor_attribute (tree *node, tree name, tree args,
6355                               int ARG_UNUSED (flags),
6356                               bool *no_add_attrs)
6357 {
6358   tree decl = *node;
6359   tree type = TREE_TYPE (decl);
6360
6361   if (TREE_CODE (decl) == FUNCTION_DECL
6362       && TREE_CODE (type) == FUNCTION_TYPE
6363       && decl_function_context (decl) == 0)
6364     {
6365       priority_type priority;
6366       DECL_STATIC_CONSTRUCTOR (decl) = 1;
6367       priority = get_priority (args, /*is_destructor=*/false);
6368       SET_DECL_INIT_PRIORITY (decl, priority);
6369       TREE_USED (decl) = 1;
6370     }
6371   else
6372     {
6373       warning (OPT_Wattributes, "%qE attribute ignored", name);
6374       *no_add_attrs = true;
6375     }
6376
6377   return NULL_TREE;
6378 }
6379
6380 /* Handle a "destructor" attribute; arguments as in
6381    struct attribute_spec.handler.  */
6382
6383 static tree
6384 handle_destructor_attribute (tree *node, tree name, tree args,
6385                              int ARG_UNUSED (flags),
6386                              bool *no_add_attrs)
6387 {
6388   tree decl = *node;
6389   tree type = TREE_TYPE (decl);
6390
6391   if (TREE_CODE (decl) == FUNCTION_DECL
6392       && TREE_CODE (type) == FUNCTION_TYPE
6393       && decl_function_context (decl) == 0)
6394     {
6395       priority_type priority;
6396       DECL_STATIC_DESTRUCTOR (decl) = 1;
6397       priority = get_priority (args, /*is_destructor=*/true);
6398       SET_DECL_FINI_PRIORITY (decl, priority);
6399       TREE_USED (decl) = 1;
6400     }
6401   else
6402     {
6403       warning (OPT_Wattributes, "%qE attribute ignored", name);
6404       *no_add_attrs = true;
6405     }
6406
6407   return NULL_TREE;
6408 }
6409
6410 /* Handle a "mode" attribute; arguments as in
6411    struct attribute_spec.handler.  */
6412
6413 static tree
6414 handle_mode_attribute (tree *node, tree name, tree args,
6415                        int ARG_UNUSED (flags), bool *no_add_attrs)
6416 {
6417   tree type = *node;
6418   tree ident = TREE_VALUE (args);
6419
6420   *no_add_attrs = true;
6421
6422   if (TREE_CODE (ident) != IDENTIFIER_NODE)
6423     warning (OPT_Wattributes, "%qE attribute ignored", name);
6424   else
6425     {
6426       int j;
6427       const char *p = IDENTIFIER_POINTER (ident);
6428       int len = strlen (p);
6429       enum machine_mode mode = VOIDmode;
6430       tree typefm;
6431       bool valid_mode;
6432
6433       if (len > 4 && p[0] == '_' && p[1] == '_'
6434           && p[len - 1] == '_' && p[len - 2] == '_')
6435         {
6436           char *newp = (char *) alloca (len - 1);
6437
6438           strcpy (newp, &p[2]);
6439           newp[len - 4] = '\0';
6440           p = newp;
6441         }
6442
6443       /* Change this type to have a type with the specified mode.
6444          First check for the special modes.  */
6445       if (!strcmp (p, "byte"))
6446         mode = byte_mode;
6447       else if (!strcmp (p, "word"))
6448         mode = word_mode;
6449       else if (!strcmp (p, "pointer"))
6450         mode = ptr_mode;
6451       else if (!strcmp (p, "libgcc_cmp_return"))
6452         mode = targetm.libgcc_cmp_return_mode ();
6453       else if (!strcmp (p, "libgcc_shift_count"))
6454         mode = targetm.libgcc_shift_count_mode ();
6455       else if (!strcmp (p, "unwind_word"))
6456         mode = targetm.unwind_word_mode ();
6457       else
6458         for (j = 0; j < NUM_MACHINE_MODES; j++)
6459           if (!strcmp (p, GET_MODE_NAME (j)))
6460             {
6461               mode = (enum machine_mode) j;
6462               break;
6463             }
6464
6465       if (mode == VOIDmode)
6466         {
6467           error ("unknown machine mode %qE", ident);
6468           return NULL_TREE;
6469         }
6470
6471       valid_mode = false;
6472       switch (GET_MODE_CLASS (mode))
6473         {
6474         case MODE_INT:
6475         case MODE_PARTIAL_INT:
6476         case MODE_FLOAT:
6477         case MODE_DECIMAL_FLOAT:
6478         case MODE_FRACT:
6479         case MODE_UFRACT:
6480         case MODE_ACCUM:
6481         case MODE_UACCUM:
6482           valid_mode = targetm.scalar_mode_supported_p (mode);
6483           break;
6484
6485         case MODE_COMPLEX_INT:
6486         case MODE_COMPLEX_FLOAT:
6487           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6488           break;
6489
6490         case MODE_VECTOR_INT:
6491         case MODE_VECTOR_FLOAT:
6492         case MODE_VECTOR_FRACT:
6493         case MODE_VECTOR_UFRACT:
6494         case MODE_VECTOR_ACCUM:
6495         case MODE_VECTOR_UACCUM:
6496           warning (OPT_Wattributes, "specifying vector types with "
6497                    "__attribute__ ((mode)) is deprecated");
6498           warning (OPT_Wattributes,
6499                    "use __attribute__ ((vector_size)) instead");
6500           valid_mode = vector_mode_valid_p (mode);
6501           break;
6502
6503         default:
6504           break;
6505         }
6506       if (!valid_mode)
6507         {
6508           error ("unable to emulate %qs", p);
6509           return NULL_TREE;
6510         }
6511
6512       if (POINTER_TYPE_P (type))
6513         {
6514           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6515           tree (*fn)(tree, enum machine_mode, bool);
6516
6517           if (!targetm.addr_space.valid_pointer_mode (mode, as))
6518             {
6519               error ("invalid pointer mode %qs", p);
6520               return NULL_TREE;
6521             }
6522
6523           if (TREE_CODE (type) == POINTER_TYPE)
6524             fn = build_pointer_type_for_mode;
6525           else
6526             fn = build_reference_type_for_mode;
6527           typefm = fn (TREE_TYPE (type), mode, false);
6528         }
6529       else
6530         {
6531           /* For fixed-point modes, we need to test if the signness of type
6532              and the machine mode are consistent.  */
6533           if (ALL_FIXED_POINT_MODE_P (mode)
6534               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6535             {
6536               error ("signness of type and machine mode %qs don't match", p);
6537               return NULL_TREE;
6538             }
6539           /* For fixed-point modes, we need to pass saturating info.  */
6540           typefm = lang_hooks.types.type_for_mode (mode,
6541                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6542                                                       : TYPE_UNSIGNED (type));
6543         }
6544
6545       if (typefm == NULL_TREE)
6546         {
6547           error ("no data type for mode %qs", p);
6548           return NULL_TREE;
6549         }
6550       else if (TREE_CODE (type) == ENUMERAL_TYPE)
6551         {
6552           /* For enumeral types, copy the precision from the integer
6553              type returned above.  If not an INTEGER_TYPE, we can't use
6554              this mode for this type.  */
6555           if (TREE_CODE (typefm) != INTEGER_TYPE)
6556             {
6557               error ("cannot use mode %qs for enumeral types", p);
6558               return NULL_TREE;
6559             }
6560
6561           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6562             {
6563               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6564               typefm = type;
6565             }
6566           else
6567             {
6568               /* We cannot build a type variant, as there's code that assumes
6569                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
6570                  debug generators.  Instead, create a subrange type.  This
6571                  results in all of the enumeral values being emitted only once
6572                  in the original, and the subtype gets them by reference.  */
6573               if (TYPE_UNSIGNED (type))
6574                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6575               else
6576                 typefm = make_signed_type (TYPE_PRECISION (typefm));
6577               TREE_TYPE (typefm) = type;
6578             }
6579         }
6580       else if (VECTOR_MODE_P (mode)
6581                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6582                : TREE_CODE (type) != TREE_CODE (typefm))
6583         {
6584           error ("mode %qs applied to inappropriate type", p);
6585           return NULL_TREE;
6586         }
6587
6588       *node = typefm;
6589     }
6590
6591   return NULL_TREE;
6592 }
6593
6594 /* Handle a "section" attribute; arguments as in
6595    struct attribute_spec.handler.  */
6596
6597 static tree
6598 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6599                           int ARG_UNUSED (flags), bool *no_add_attrs)
6600 {
6601   tree decl = *node;
6602
6603   if (targetm.have_named_sections)
6604     {
6605       user_defined_section_attribute = true;
6606
6607       if ((TREE_CODE (decl) == FUNCTION_DECL
6608            || TREE_CODE (decl) == VAR_DECL)
6609           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6610         {
6611           if (TREE_CODE (decl) == VAR_DECL
6612               && current_function_decl != NULL_TREE
6613               && !TREE_STATIC (decl))
6614             {
6615               error_at (DECL_SOURCE_LOCATION (decl),
6616                         "section attribute cannot be specified for "
6617                         "local variables");
6618               *no_add_attrs = true;
6619             }
6620
6621           /* The decl may have already been given a section attribute
6622              from a previous declaration.  Ensure they match.  */
6623           else if (DECL_SECTION_NAME (decl) != NULL_TREE
6624                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6625                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6626             {
6627               error ("section of %q+D conflicts with previous declaration",
6628                      *node);
6629               *no_add_attrs = true;
6630             }
6631           else if (TREE_CODE (decl) == VAR_DECL
6632                    && !targetm.have_tls && targetm.emutls.tmpl_section
6633                    && DECL_THREAD_LOCAL_P (decl))
6634             {
6635               error ("section of %q+D cannot be overridden", *node);
6636               *no_add_attrs = true;
6637             }
6638           else
6639             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6640         }
6641       else
6642         {
6643           error ("section attribute not allowed for %q+D", *node);
6644           *no_add_attrs = true;
6645         }
6646     }
6647   else
6648     {
6649       error_at (DECL_SOURCE_LOCATION (*node),
6650                 "section attributes are not supported for this target");
6651       *no_add_attrs = true;
6652     }
6653
6654   return NULL_TREE;
6655 }
6656
6657 /* Handle a "aligned" attribute; arguments as in
6658    struct attribute_spec.handler.  */
6659
6660 static tree
6661 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6662                           int flags, bool *no_add_attrs)
6663 {
6664   tree decl = NULL_TREE;
6665   tree *type = NULL;
6666   int is_type = 0;
6667   tree align_expr = (args ? TREE_VALUE (args)
6668                      : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6669   int i;
6670
6671   if (DECL_P (*node))
6672     {
6673       decl = *node;
6674       type = &TREE_TYPE (decl);
6675       is_type = TREE_CODE (*node) == TYPE_DECL;
6676     }
6677   else if (TYPE_P (*node))
6678     type = node, is_type = 1;
6679
6680   if (TREE_CODE (align_expr) != INTEGER_CST)
6681     {
6682       error ("requested alignment is not a constant");
6683       *no_add_attrs = true;
6684     }
6685   else if ((i = tree_log2 (align_expr)) == -1)
6686     {
6687       error ("requested alignment is not a power of 2");
6688       *no_add_attrs = true;
6689     }
6690   else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6691     {
6692       error ("requested alignment is too large");
6693       *no_add_attrs = true;
6694     }
6695   else if (is_type)
6696     {
6697       if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6698         /* OK, modify the type in place.  */;
6699       /* If we have a TYPE_DECL, then copy the type, so that we
6700          don't accidentally modify a builtin type.  See pushdecl.  */
6701       else if (decl && TREE_TYPE (decl) != error_mark_node
6702                && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6703         {
6704           tree tt = TREE_TYPE (decl);
6705           *type = build_variant_type_copy (*type);
6706           DECL_ORIGINAL_TYPE (decl) = tt;
6707           TYPE_NAME (*type) = decl;
6708           TREE_USED (*type) = TREE_USED (decl);
6709           TREE_TYPE (decl) = *type;
6710         }
6711       else
6712         *type = build_variant_type_copy (*type);
6713
6714       TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6715       TYPE_USER_ALIGN (*type) = 1;
6716     }
6717   else if (! VAR_OR_FUNCTION_DECL_P (decl)
6718            && TREE_CODE (decl) != FIELD_DECL)
6719     {
6720       error ("alignment may not be specified for %q+D", decl);
6721       *no_add_attrs = true;
6722     }
6723   else if (TREE_CODE (decl) == FUNCTION_DECL
6724            && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6725     {
6726       if (DECL_USER_ALIGN (decl))
6727         error ("alignment for %q+D was previously specified as %d "
6728                "and may not be decreased", decl,
6729                DECL_ALIGN (decl) / BITS_PER_UNIT);
6730       else
6731         error ("alignment for %q+D must be at least %d", decl,
6732                DECL_ALIGN (decl) / BITS_PER_UNIT);
6733       *no_add_attrs = true;
6734     }
6735   else
6736     {
6737       DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6738       DECL_USER_ALIGN (decl) = 1;
6739     }
6740
6741   return NULL_TREE;
6742 }
6743
6744 /* Handle a "weak" attribute; arguments as in
6745    struct attribute_spec.handler.  */
6746
6747 static tree
6748 handle_weak_attribute (tree *node, tree name,
6749                        tree ARG_UNUSED (args),
6750                        int ARG_UNUSED (flags),
6751                        bool * ARG_UNUSED (no_add_attrs))
6752 {
6753   if (TREE_CODE (*node) == FUNCTION_DECL
6754       && DECL_DECLARED_INLINE_P (*node))
6755     {
6756       error ("inline function %q+D cannot be declared weak", *node);
6757       *no_add_attrs = true;
6758     }
6759   else if (TREE_CODE (*node) == FUNCTION_DECL
6760            || TREE_CODE (*node) == VAR_DECL)
6761     declare_weak (*node);
6762   else
6763     warning (OPT_Wattributes, "%qE attribute ignored", name);
6764
6765   return NULL_TREE;
6766 }
6767
6768 /* Handle an "alias" attribute; arguments as in
6769    struct attribute_spec.handler.  */
6770
6771 static tree
6772 handle_alias_attribute (tree *node, tree name, tree args,
6773                         int ARG_UNUSED (flags), bool *no_add_attrs)
6774 {
6775   tree decl = *node;
6776
6777   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
6778     {
6779       warning (OPT_Wattributes, "%qE attribute ignored", name);
6780       *no_add_attrs = true;
6781     }
6782   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6783       || (TREE_CODE (decl) != FUNCTION_DECL
6784           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6785       /* A static variable declaration is always a tentative definition,
6786          but the alias is a non-tentative definition which overrides.  */
6787       || (TREE_CODE (decl) != FUNCTION_DECL
6788           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6789     {
6790       error ("%q+D defined both normally and as an alias", decl);
6791       *no_add_attrs = true;
6792     }
6793
6794   /* Note that the very first time we process a nested declaration,
6795      decl_function_context will not be set.  Indeed, *would* never
6796      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6797      we do below.  After such frobbery, pushdecl would set the context.
6798      In any case, this is never what we want.  */
6799   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6800     {
6801       tree id;
6802
6803       id = TREE_VALUE (args);
6804       if (TREE_CODE (id) != STRING_CST)
6805         {
6806           error ("alias argument not a string");
6807           *no_add_attrs = true;
6808           return NULL_TREE;
6809         }
6810       id = get_identifier (TREE_STRING_POINTER (id));
6811       /* This counts as a use of the object pointed to.  */
6812       TREE_USED (id) = 1;
6813
6814       if (TREE_CODE (decl) == FUNCTION_DECL)
6815         DECL_INITIAL (decl) = error_mark_node;
6816       else
6817         {
6818           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6819             DECL_EXTERNAL (decl) = 1;
6820           else
6821             DECL_EXTERNAL (decl) = 0;
6822           TREE_STATIC (decl) = 1;
6823         }
6824     }
6825   else
6826     {
6827       warning (OPT_Wattributes, "%qE attribute ignored", name);
6828       *no_add_attrs = true;
6829     }
6830
6831   return NULL_TREE;
6832 }
6833
6834 /* Handle a "weakref" attribute; arguments as in struct
6835    attribute_spec.handler.  */
6836
6837 static tree
6838 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6839                           int flags, bool *no_add_attrs)
6840 {
6841   tree attr = NULL_TREE;
6842
6843   /* We must ignore the attribute when it is associated with
6844      local-scoped decls, since attribute alias is ignored and many
6845      such symbols do not even have a DECL_WEAK field.  */
6846   if (decl_function_context (*node)
6847       || current_function_decl
6848       || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6849     {
6850       warning (OPT_Wattributes, "%qE attribute ignored", name);
6851       *no_add_attrs = true;
6852       return NULL_TREE;
6853     }
6854
6855   /* The idea here is that `weakref("name")' mutates into `weakref,
6856      alias("name")', and weakref without arguments, in turn,
6857      implicitly adds weak. */
6858
6859   if (args)
6860     {
6861       attr = tree_cons (get_identifier ("alias"), args, attr);
6862       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6863
6864       *no_add_attrs = true;
6865
6866       decl_attributes (node, attr, flags);
6867     }
6868   else
6869     {
6870       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6871         error_at (DECL_SOURCE_LOCATION (*node),
6872                   "weakref attribute must appear before alias attribute");
6873
6874       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6875          and that isn't supported; and because it wants to add it to
6876          the list of weak decls, which isn't helpful.  */
6877       DECL_WEAK (*node) = 1;
6878     }
6879
6880   return NULL_TREE;
6881 }
6882
6883 /* Handle an "visibility" attribute; arguments as in
6884    struct attribute_spec.handler.  */
6885
6886 static tree
6887 handle_visibility_attribute (tree *node, tree name, tree args,
6888                              int ARG_UNUSED (flags),
6889                              bool *ARG_UNUSED (no_add_attrs))
6890 {
6891   tree decl = *node;
6892   tree id = TREE_VALUE (args);
6893   enum symbol_visibility vis;
6894
6895   if (TYPE_P (*node))
6896     {
6897       if (TREE_CODE (*node) == ENUMERAL_TYPE)
6898         /* OK */;
6899       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6900         {
6901           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6902                    name);
6903           return NULL_TREE;
6904         }
6905       else if (TYPE_FIELDS (*node))
6906         {
6907           error ("%qE attribute ignored because %qT is already defined",
6908                  name, *node);
6909           return NULL_TREE;
6910         }
6911     }
6912   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6913     {
6914       warning (OPT_Wattributes, "%qE attribute ignored", name);
6915       return NULL_TREE;
6916     }
6917
6918   if (TREE_CODE (id) != STRING_CST)
6919     {
6920       error ("visibility argument not a string");
6921       return NULL_TREE;
6922     }
6923
6924   /*  If this is a type, set the visibility on the type decl.  */
6925   if (TYPE_P (decl))
6926     {
6927       decl = TYPE_NAME (decl);
6928       if (!decl)
6929         return NULL_TREE;
6930       if (TREE_CODE (decl) == IDENTIFIER_NODE)
6931         {
6932            warning (OPT_Wattributes, "%qE attribute ignored on types",
6933                     name);
6934            return NULL_TREE;
6935         }
6936     }
6937
6938   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6939     vis = VISIBILITY_DEFAULT;
6940   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6941     vis = VISIBILITY_INTERNAL;
6942   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6943     vis = VISIBILITY_HIDDEN;
6944   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6945     vis = VISIBILITY_PROTECTED;
6946   else
6947     {
6948       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6949       vis = VISIBILITY_DEFAULT;
6950     }
6951
6952   if (DECL_VISIBILITY_SPECIFIED (decl)
6953       && vis != DECL_VISIBILITY (decl))
6954     {
6955       tree attributes = (TYPE_P (*node)
6956                          ? TYPE_ATTRIBUTES (*node)
6957                          : DECL_ATTRIBUTES (decl));
6958       if (lookup_attribute ("visibility", attributes))
6959         error ("%qD redeclared with different visibility", decl);
6960       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6961                && lookup_attribute ("dllimport", attributes))
6962         error ("%qD was declared %qs which implies default visibility",
6963                decl, "dllimport");
6964       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6965                && lookup_attribute ("dllexport", attributes))
6966         error ("%qD was declared %qs which implies default visibility",
6967                decl, "dllexport");
6968     }
6969
6970   DECL_VISIBILITY (decl) = vis;
6971   DECL_VISIBILITY_SPECIFIED (decl) = 1;
6972
6973   /* Go ahead and attach the attribute to the node as well.  This is needed
6974      so we can determine whether we have VISIBILITY_DEFAULT because the
6975      visibility was not specified, or because it was explicitly overridden
6976      from the containing scope.  */
6977
6978   return NULL_TREE;
6979 }
6980
6981 /* Determine the ELF symbol visibility for DECL, which is either a
6982    variable or a function.  It is an error to use this function if a
6983    definition of DECL is not available in this translation unit.
6984    Returns true if the final visibility has been determined by this
6985    function; false if the caller is free to make additional
6986    modifications.  */
6987
6988 bool
6989 c_determine_visibility (tree decl)
6990 {
6991   gcc_assert (TREE_CODE (decl) == VAR_DECL
6992               || TREE_CODE (decl) == FUNCTION_DECL);
6993
6994   /* If the user explicitly specified the visibility with an
6995      attribute, honor that.  DECL_VISIBILITY will have been set during
6996      the processing of the attribute.  We check for an explicit
6997      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6998      to distinguish the use of an attribute from the use of a "#pragma
6999      GCC visibility push(...)"; in the latter case we still want other
7000      considerations to be able to overrule the #pragma.  */
7001   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
7002       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7003           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
7004               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
7005     return true;
7006
7007   /* Set default visibility to whatever the user supplied with
7008      visibility_specified depending on #pragma GCC visibility.  */
7009   if (!DECL_VISIBILITY_SPECIFIED (decl))
7010     {
7011       if (visibility_options.inpragma
7012           || DECL_VISIBILITY (decl) != default_visibility)
7013         {
7014           DECL_VISIBILITY (decl) = default_visibility;
7015           DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
7016           /* If visibility changed and DECL already has DECL_RTL, ensure
7017              symbol flags are updated.  */
7018           if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
7019                || TREE_CODE (decl) == FUNCTION_DECL)
7020               && DECL_RTL_SET_P (decl))
7021             make_decl_rtl (decl);
7022         }
7023     }
7024   return false;
7025 }
7026
7027 /* Handle an "tls_model" attribute; arguments as in
7028    struct attribute_spec.handler.  */
7029
7030 static tree
7031 handle_tls_model_attribute (tree *node, tree name, tree args,
7032                             int ARG_UNUSED (flags), bool *no_add_attrs)
7033 {
7034   tree id;
7035   tree decl = *node;
7036   enum tls_model kind;
7037
7038   *no_add_attrs = true;
7039
7040   if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7041     {
7042       warning (OPT_Wattributes, "%qE attribute ignored", name);
7043       return NULL_TREE;
7044     }
7045
7046   kind = DECL_TLS_MODEL (decl);
7047   id = TREE_VALUE (args);
7048   if (TREE_CODE (id) != STRING_CST)
7049     {
7050       error ("tls_model argument not a string");
7051       return NULL_TREE;
7052     }
7053
7054   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7055     kind = TLS_MODEL_LOCAL_EXEC;
7056   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7057     kind = TLS_MODEL_INITIAL_EXEC;
7058   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7059     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7060   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7061     kind = TLS_MODEL_GLOBAL_DYNAMIC;
7062   else
7063     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7064
7065   DECL_TLS_MODEL (decl) = kind;
7066   return NULL_TREE;
7067 }
7068
7069 /* Handle a "no_instrument_function" attribute; arguments as in
7070    struct attribute_spec.handler.  */
7071
7072 static tree
7073 handle_no_instrument_function_attribute (tree *node, tree name,
7074                                          tree ARG_UNUSED (args),
7075                                          int ARG_UNUSED (flags),
7076                                          bool *no_add_attrs)
7077 {
7078   tree decl = *node;
7079
7080   if (TREE_CODE (decl) != FUNCTION_DECL)
7081     {
7082       error_at (DECL_SOURCE_LOCATION (decl),
7083                 "%qE attribute applies only to functions", name);
7084       *no_add_attrs = true;
7085     }
7086   else if (DECL_INITIAL (decl))
7087     {
7088       error_at (DECL_SOURCE_LOCATION (decl),
7089                 "can%'t set %qE attribute after definition", name);
7090       *no_add_attrs = true;
7091     }
7092   else
7093     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7094
7095   return NULL_TREE;
7096 }
7097
7098 /* Handle a "malloc" attribute; arguments as in
7099    struct attribute_spec.handler.  */
7100
7101 static tree
7102 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7103                          int ARG_UNUSED (flags), bool *no_add_attrs)
7104 {
7105   if (TREE_CODE (*node) == FUNCTION_DECL
7106       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7107     DECL_IS_MALLOC (*node) = 1;
7108   else
7109     {
7110       warning (OPT_Wattributes, "%qE attribute ignored", name);
7111       *no_add_attrs = true;
7112     }
7113
7114   return NULL_TREE;
7115 }
7116
7117 /* Handle a "alloc_size" attribute; arguments as in
7118    struct attribute_spec.handler.  */
7119
7120 static tree
7121 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7122                              int ARG_UNUSED (flags), bool *no_add_attrs)
7123 {
7124   unsigned arg_count = type_num_arguments (*node);
7125   for (; args; args = TREE_CHAIN (args))
7126     {
7127       tree position = TREE_VALUE (args);
7128
7129       if (TREE_CODE (position) != INTEGER_CST
7130           || TREE_INT_CST_HIGH (position)
7131           || TREE_INT_CST_LOW (position) < 1
7132           || TREE_INT_CST_LOW (position) > arg_count )
7133         {
7134           warning (OPT_Wattributes,
7135                    "alloc_size parameter outside range");
7136           *no_add_attrs = true;
7137           return NULL_TREE;
7138         }
7139     }
7140   return NULL_TREE;
7141 }
7142
7143 /* Handle a "fn spec" attribute; arguments as in
7144    struct attribute_spec.handler.  */
7145
7146 static tree
7147 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7148                          tree args, int ARG_UNUSED (flags),
7149                          bool *no_add_attrs ATTRIBUTE_UNUSED)
7150 {
7151   gcc_assert (args
7152               && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7153               && !TREE_CHAIN (args));
7154   return NULL_TREE;
7155 }
7156
7157 /* Handle a "returns_twice" attribute; arguments as in
7158    struct attribute_spec.handler.  */
7159
7160 static tree
7161 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7162                          int ARG_UNUSED (flags), bool *no_add_attrs)
7163 {
7164   if (TREE_CODE (*node) == FUNCTION_DECL)
7165     DECL_IS_RETURNS_TWICE (*node) = 1;
7166   else
7167     {
7168       warning (OPT_Wattributes, "%qE attribute ignored", name);
7169       *no_add_attrs = true;
7170     }
7171
7172   return NULL_TREE;
7173 }
7174
7175 /* Handle a "no_limit_stack" attribute; arguments as in
7176    struct attribute_spec.handler.  */
7177
7178 static tree
7179 handle_no_limit_stack_attribute (tree *node, tree name,
7180                                  tree ARG_UNUSED (args),
7181                                  int ARG_UNUSED (flags),
7182                                  bool *no_add_attrs)
7183 {
7184   tree decl = *node;
7185
7186   if (TREE_CODE (decl) != FUNCTION_DECL)
7187     {
7188       error_at (DECL_SOURCE_LOCATION (decl),
7189              "%qE attribute applies only to functions", name);
7190       *no_add_attrs = true;
7191     }
7192   else if (DECL_INITIAL (decl))
7193     {
7194       error_at (DECL_SOURCE_LOCATION (decl),
7195                 "can%'t set %qE attribute after definition", name);
7196       *no_add_attrs = true;
7197     }
7198   else
7199     DECL_NO_LIMIT_STACK (decl) = 1;
7200
7201   return NULL_TREE;
7202 }
7203
7204 /* Handle a "pure" attribute; arguments as in
7205    struct attribute_spec.handler.  */
7206
7207 static tree
7208 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7209                        int ARG_UNUSED (flags), bool *no_add_attrs)
7210 {
7211   if (TREE_CODE (*node) == FUNCTION_DECL)
7212     DECL_PURE_P (*node) = 1;
7213   /* ??? TODO: Support types.  */
7214   else
7215     {
7216       warning (OPT_Wattributes, "%qE attribute ignored", name);
7217       *no_add_attrs = true;
7218     }
7219
7220   return NULL_TREE;
7221 }
7222
7223 /* Handle a "no vops" attribute; arguments as in
7224    struct attribute_spec.handler.  */
7225
7226 static tree
7227 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7228                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7229                          bool *ARG_UNUSED (no_add_attrs))
7230 {
7231   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7232   DECL_IS_NOVOPS (*node) = 1;
7233   return NULL_TREE;
7234 }
7235
7236 /* Handle a "deprecated" attribute; arguments as in
7237    struct attribute_spec.handler.  */
7238
7239 static tree
7240 handle_deprecated_attribute (tree *node, tree name,
7241                              tree args, int flags,
7242                              bool *no_add_attrs)
7243 {
7244   tree type = NULL_TREE;
7245   int warn = 0;
7246   tree what = NULL_TREE;
7247
7248   if (!args)
7249     *no_add_attrs = true;
7250   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7251     {
7252       error ("deprecated message is not a string");
7253       *no_add_attrs = true;
7254     }
7255
7256   if (DECL_P (*node))
7257     {
7258       tree decl = *node;
7259       type = TREE_TYPE (decl);
7260
7261       if (TREE_CODE (decl) == TYPE_DECL
7262           || TREE_CODE (decl) == PARM_DECL
7263           || TREE_CODE (decl) == VAR_DECL
7264           || TREE_CODE (decl) == FUNCTION_DECL
7265           || TREE_CODE (decl) == FIELD_DECL)
7266         TREE_DEPRECATED (decl) = 1;
7267       else
7268         warn = 1;
7269     }
7270   else if (TYPE_P (*node))
7271     {
7272       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7273         *node = build_variant_type_copy (*node);
7274       TREE_DEPRECATED (*node) = 1;
7275       type = *node;
7276     }
7277   else
7278     warn = 1;
7279
7280   if (warn)
7281     {
7282       *no_add_attrs = true;
7283       if (type && TYPE_NAME (type))
7284         {
7285           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7286             what = TYPE_NAME (*node);
7287           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7288                    && DECL_NAME (TYPE_NAME (type)))
7289             what = DECL_NAME (TYPE_NAME (type));
7290         }
7291       if (what)
7292         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7293       else
7294         warning (OPT_Wattributes, "%qE attribute ignored", name);
7295     }
7296
7297   return NULL_TREE;
7298 }
7299
7300 /* Handle a "vector_size" attribute; arguments as in
7301    struct attribute_spec.handler.  */
7302
7303 static tree
7304 handle_vector_size_attribute (tree *node, tree name, tree args,
7305                               int ARG_UNUSED (flags),
7306                               bool *no_add_attrs)
7307 {
7308   unsigned HOST_WIDE_INT vecsize, nunits;
7309   enum machine_mode orig_mode;
7310   tree type = *node, new_type, size;
7311
7312   *no_add_attrs = true;
7313
7314   size = TREE_VALUE (args);
7315
7316   if (!host_integerp (size, 1))
7317     {
7318       warning (OPT_Wattributes, "%qE attribute ignored", name);
7319       return NULL_TREE;
7320     }
7321
7322   /* Get the vector size (in bytes).  */
7323   vecsize = tree_low_cst (size, 1);
7324
7325   /* We need to provide for vector pointers, vector arrays, and
7326      functions returning vectors.  For example:
7327
7328        __attribute__((vector_size(16))) short *foo;
7329
7330      In this case, the mode is SI, but the type being modified is
7331      HI, so we need to look further.  */
7332
7333   while (POINTER_TYPE_P (type)
7334          || TREE_CODE (type) == FUNCTION_TYPE
7335          || TREE_CODE (type) == METHOD_TYPE
7336          || TREE_CODE (type) == ARRAY_TYPE
7337          || TREE_CODE (type) == OFFSET_TYPE)
7338     type = TREE_TYPE (type);
7339
7340   /* Get the mode of the type being modified.  */
7341   orig_mode = TYPE_MODE (type);
7342
7343   if ((!INTEGRAL_TYPE_P (type)
7344        && !SCALAR_FLOAT_TYPE_P (type)
7345        && !FIXED_POINT_TYPE_P (type))
7346       || (!SCALAR_FLOAT_MODE_P (orig_mode)
7347           && GET_MODE_CLASS (orig_mode) != MODE_INT
7348           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7349       || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7350       || TREE_CODE (type) == BOOLEAN_TYPE)
7351     {
7352       error ("invalid vector type for attribute %qE", name);
7353       return NULL_TREE;
7354     }
7355
7356   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7357     {
7358       error ("vector size not an integral multiple of component size");
7359       return NULL;
7360     }
7361
7362   if (vecsize == 0)
7363     {
7364       error ("zero vector size");
7365       return NULL;
7366     }
7367
7368   /* Calculate how many units fit in the vector.  */
7369   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7370   if (nunits & (nunits - 1))
7371     {
7372       error ("number of components of the vector not a power of two");
7373       return NULL_TREE;
7374     }
7375
7376   new_type = build_vector_type (type, nunits);
7377
7378   /* Build back pointers if needed.  */
7379   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7380
7381   return NULL_TREE;
7382 }
7383
7384 /* Handle the "nonnull" attribute.  */
7385 static tree
7386 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7387                           tree args, int ARG_UNUSED (flags),
7388                           bool *no_add_attrs)
7389 {
7390   tree type = *node;
7391   unsigned HOST_WIDE_INT attr_arg_num;
7392
7393   /* If no arguments are specified, all pointer arguments should be
7394      non-null.  Verify a full prototype is given so that the arguments
7395      will have the correct types when we actually check them later.  */
7396   if (!args)
7397     {
7398       if (!TYPE_ARG_TYPES (type))
7399         {
7400           error ("nonnull attribute without arguments on a non-prototype");
7401           *no_add_attrs = true;
7402         }
7403       return NULL_TREE;
7404     }
7405
7406   /* Argument list specified.  Verify that each argument number references
7407      a pointer argument.  */
7408   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7409     {
7410       tree argument;
7411       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7412
7413       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7414         {
7415           error ("nonnull argument has invalid operand number (argument %lu)",
7416                  (unsigned long) attr_arg_num);
7417           *no_add_attrs = true;
7418           return NULL_TREE;
7419         }
7420
7421       argument = TYPE_ARG_TYPES (type);
7422       if (argument)
7423         {
7424           for (ck_num = 1; ; ck_num++)
7425             {
7426               if (!argument || ck_num == arg_num)
7427                 break;
7428               argument = TREE_CHAIN (argument);
7429             }
7430
7431           if (!argument
7432               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
7433             {
7434               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7435                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
7436               *no_add_attrs = true;
7437               return NULL_TREE;
7438             }
7439
7440           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
7441             {
7442               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7443                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
7444               *no_add_attrs = true;
7445               return NULL_TREE;
7446             }
7447         }
7448     }
7449
7450   return NULL_TREE;
7451 }
7452
7453 /* Check the argument list of a function call for null in argument slots
7454    that are marked as requiring a non-null pointer argument.  The NARGS
7455    arguments are passed in the array ARGARRAY.
7456 */
7457
7458 static void
7459 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7460 {
7461   tree a, args;
7462   int i;
7463
7464   for (a = attrs; a; a = TREE_CHAIN (a))
7465     {
7466       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7467         {
7468           args = TREE_VALUE (a);
7469
7470           /* Walk the argument list.  If we encounter an argument number we
7471              should check for non-null, do it.  If the attribute has no args,
7472              then every pointer argument is checked (in which case the check
7473              for pointer type is done in check_nonnull_arg).  */
7474           for (i = 0; i < nargs; i++)
7475             {
7476               if (!args || nonnull_check_p (args, i + 1))
7477                 check_function_arguments_recurse (check_nonnull_arg, NULL,
7478                                                   argarray[i],
7479                                                   i + 1);
7480             }
7481         }
7482     }
7483 }
7484
7485 /* Check that the Nth argument of a function call (counting backwards
7486    from the end) is a (pointer)0.  The NARGS arguments are passed in the
7487    array ARGARRAY.  */
7488
7489 static void
7490 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
7491 {
7492   tree attr = lookup_attribute ("sentinel", attrs);
7493
7494   if (attr)
7495     {
7496       int len = 0;
7497       int pos = 0;
7498       tree sentinel;
7499
7500       /* Skip over the named arguments.  */
7501       while (typelist && len < nargs)
7502         {
7503           typelist = TREE_CHAIN (typelist);
7504           len++;
7505         }
7506
7507       if (TREE_VALUE (attr))
7508         {
7509           tree p = TREE_VALUE (TREE_VALUE (attr));
7510           pos = TREE_INT_CST_LOW (p);
7511         }
7512
7513       /* The sentinel must be one of the varargs, i.e.
7514          in position >= the number of fixed arguments.  */
7515       if ((nargs - 1 - pos) < len)
7516         {
7517           warning (OPT_Wformat,
7518                    "not enough variable arguments to fit a sentinel");
7519           return;
7520         }
7521
7522       /* Validate the sentinel.  */
7523       sentinel = argarray[nargs - 1 - pos];
7524       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7525            || !integer_zerop (sentinel))
7526           /* Although __null (in C++) is only an integer we allow it
7527              nevertheless, as we are guaranteed that it's exactly
7528              as wide as a pointer, and we don't want to force
7529              users to cast the NULL they have written there.
7530              We warn with -Wstrict-null-sentinel, though.  */
7531           && (warn_strict_null_sentinel || null_node != sentinel))
7532         warning (OPT_Wformat, "missing sentinel in function call");
7533     }
7534 }
7535
7536 /* Helper for check_function_nonnull; given a list of operands which
7537    must be non-null in ARGS, determine if operand PARAM_NUM should be
7538    checked.  */
7539
7540 static bool
7541 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7542 {
7543   unsigned HOST_WIDE_INT arg_num = 0;
7544
7545   for (; args; args = TREE_CHAIN (args))
7546     {
7547       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7548
7549       gcc_assert (found);
7550
7551       if (arg_num == param_num)
7552         return true;
7553     }
7554   return false;
7555 }
7556
7557 /* Check that the function argument PARAM (which is operand number
7558    PARAM_NUM) is non-null.  This is called by check_function_nonnull
7559    via check_function_arguments_recurse.  */
7560
7561 static void
7562 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7563                    unsigned HOST_WIDE_INT param_num)
7564 {
7565   /* Just skip checking the argument if it's not a pointer.  This can
7566      happen if the "nonnull" attribute was given without an operand
7567      list (which means to check every pointer argument).  */
7568
7569   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7570     return;
7571
7572   if (integer_zerop (param))
7573     warning (OPT_Wnonnull, "null argument where non-null required "
7574              "(argument %lu)", (unsigned long) param_num);
7575 }
7576
7577 /* Helper for nonnull attribute handling; fetch the operand number
7578    from the attribute argument list.  */
7579
7580 static bool
7581 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7582 {
7583   /* Verify the arg number is a constant.  */
7584   if (TREE_CODE (arg_num_expr) != INTEGER_CST
7585       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7586     return false;
7587
7588   *valp = TREE_INT_CST_LOW (arg_num_expr);
7589   return true;
7590 }
7591
7592 /* Handle a "nothrow" attribute; arguments as in
7593    struct attribute_spec.handler.  */
7594
7595 static tree
7596 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7597                           int ARG_UNUSED (flags), bool *no_add_attrs)
7598 {
7599   if (TREE_CODE (*node) == FUNCTION_DECL)
7600     TREE_NOTHROW (*node) = 1;
7601   /* ??? TODO: Support types.  */
7602   else
7603     {
7604       warning (OPT_Wattributes, "%qE attribute ignored", name);
7605       *no_add_attrs = true;
7606     }
7607
7608   return NULL_TREE;
7609 }
7610
7611 /* Handle a "cleanup" attribute; arguments as in
7612    struct attribute_spec.handler.  */
7613
7614 static tree
7615 handle_cleanup_attribute (tree *node, tree name, tree args,
7616                           int ARG_UNUSED (flags), bool *no_add_attrs)
7617 {
7618   tree decl = *node;
7619   tree cleanup_id, cleanup_decl;
7620
7621   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7622      for global destructors in C++.  This requires infrastructure that
7623      we don't have generically at the moment.  It's also not a feature
7624      we'd be missing too much, since we do have attribute constructor.  */
7625   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7626     {
7627       warning (OPT_Wattributes, "%qE attribute ignored", name);
7628       *no_add_attrs = true;
7629       return NULL_TREE;
7630     }
7631
7632   /* Verify that the argument is a function in scope.  */
7633   /* ??? We could support pointers to functions here as well, if
7634      that was considered desirable.  */
7635   cleanup_id = TREE_VALUE (args);
7636   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
7637     {
7638       error ("cleanup argument not an identifier");
7639       *no_add_attrs = true;
7640       return NULL_TREE;
7641     }
7642   cleanup_decl = lookup_name (cleanup_id);
7643   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
7644     {
7645       error ("cleanup argument not a function");
7646       *no_add_attrs = true;
7647       return NULL_TREE;
7648     }
7649
7650   /* That the function has proper type is checked with the
7651      eventual call to build_function_call.  */
7652
7653   return NULL_TREE;
7654 }
7655
7656 /* Handle a "warn_unused_result" attribute.  No special handling.  */
7657
7658 static tree
7659 handle_warn_unused_result_attribute (tree *node, tree name,
7660                                tree ARG_UNUSED (args),
7661                                int ARG_UNUSED (flags), bool *no_add_attrs)
7662 {
7663   /* Ignore the attribute for functions not returning any value.  */
7664   if (VOID_TYPE_P (TREE_TYPE (*node)))
7665     {
7666       warning (OPT_Wattributes, "%qE attribute ignored", name);
7667       *no_add_attrs = true;
7668     }
7669
7670   return NULL_TREE;
7671 }
7672
7673 /* Handle a "sentinel" attribute.  */
7674
7675 static tree
7676 handle_sentinel_attribute (tree *node, tree name, tree args,
7677                            int ARG_UNUSED (flags), bool *no_add_attrs)
7678 {
7679   tree params = TYPE_ARG_TYPES (*node);
7680
7681   if (!params)
7682     {
7683       warning (OPT_Wattributes,
7684                "%qE attribute requires prototypes with named arguments", name);
7685       *no_add_attrs = true;
7686     }
7687   else
7688     {
7689       while (TREE_CHAIN (params))
7690         params = TREE_CHAIN (params);
7691
7692       if (VOID_TYPE_P (TREE_VALUE (params)))
7693         {
7694           warning (OPT_Wattributes,
7695                    "%qE attribute only applies to variadic functions", name);
7696           *no_add_attrs = true;
7697         }
7698     }
7699
7700   if (args)
7701     {
7702       tree position = TREE_VALUE (args);
7703
7704       if (TREE_CODE (position) != INTEGER_CST)
7705         {
7706           warning (OPT_Wattributes,
7707                    "requested position is not an integer constant");
7708           *no_add_attrs = true;
7709         }
7710       else
7711         {
7712           if (tree_int_cst_lt (position, integer_zero_node))
7713             {
7714               warning (OPT_Wattributes,
7715                        "requested position is less than zero");
7716               *no_add_attrs = true;
7717             }
7718         }
7719     }
7720
7721   return NULL_TREE;
7722 }
7723
7724 /* Handle a "type_generic" attribute.  */
7725
7726 static tree
7727 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
7728                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7729                                bool * ARG_UNUSED (no_add_attrs))
7730 {
7731   tree params;
7732
7733   /* Ensure we have a function type.  */
7734   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
7735
7736   params = TYPE_ARG_TYPES (*node);
7737   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
7738     params = TREE_CHAIN (params);
7739
7740   /* Ensure we have a variadic function.  */
7741   gcc_assert (!params);
7742
7743   return NULL_TREE;
7744 }
7745
7746 /* Handle a "target" attribute.  */
7747
7748 static tree
7749 handle_target_attribute (tree *node, tree name, tree args, int flags,
7750                          bool *no_add_attrs)
7751 {
7752   /* Ensure we have a function type.  */
7753   if (TREE_CODE (*node) != FUNCTION_DECL)
7754     {
7755       warning (OPT_Wattributes, "%qE attribute ignored", name);
7756       *no_add_attrs = true;
7757     }
7758   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
7759                                                       flags))
7760     *no_add_attrs = true;
7761
7762   return NULL_TREE;
7763 }
7764
7765 /* Arguments being collected for optimization.  */
7766 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
7767 DEF_VEC_P(const_char_p);
7768 DEF_VEC_ALLOC_P(const_char_p, gc);
7769 static GTY(()) VEC(const_char_p, gc) *optimize_args;
7770
7771
7772 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7773    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
7774    false for #pragma GCC optimize.  */
7775
7776 bool
7777 parse_optimize_options (tree args, bool attr_p)
7778 {
7779   bool ret = true;
7780   unsigned opt_argc;
7781   unsigned i;
7782   int saved_flag_strict_aliasing;
7783   const char **opt_argv;
7784   tree ap;
7785
7786   /* Build up argv vector.  Just in case the string is stored away, use garbage
7787      collected strings.  */
7788   VEC_truncate (const_char_p, optimize_args, 0);
7789   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7790
7791   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7792     {
7793       tree value = TREE_VALUE (ap);
7794
7795       if (TREE_CODE (value) == INTEGER_CST)
7796         {
7797           char buffer[20];
7798           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7799           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7800         }
7801
7802       else if (TREE_CODE (value) == STRING_CST)
7803         {
7804           /* Split string into multiple substrings.  */
7805           size_t len = TREE_STRING_LENGTH (value);
7806           char *p = ASTRDUP (TREE_STRING_POINTER (value));
7807           char *end = p + len;
7808           char *comma;
7809           char *next_p = p;
7810
7811           while (next_p != NULL)
7812             {
7813               size_t len2;
7814               char *q, *r;
7815
7816               p = next_p;
7817               comma = strchr (p, ',');
7818               if (comma)
7819                 {
7820                   len2 = comma - p;
7821                   *comma = '\0';
7822                   next_p = comma+1;
7823                 }
7824               else
7825                 {
7826                   len2 = end - p;
7827                   next_p = NULL;
7828                 }
7829
7830               r = q = (char *) ggc_alloc (len2 + 3);
7831
7832               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7833                  options.  */
7834               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7835                 {
7836                   ret = false;
7837                   if (attr_p)
7838                     warning (OPT_Wattributes,
7839                              "Bad option %s to optimize attribute.", p);
7840                   else
7841                     warning (OPT_Wpragmas,
7842                              "Bad option %s to pragma attribute", p);
7843                   continue;
7844                 }
7845
7846               if (*p != '-')
7847                 {
7848                   *r++ = '-';
7849
7850                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7851                      itself is -Os, and any other switch begins with a -f.  */
7852                   if ((*p >= '0' && *p <= '9')
7853                       || (p[0] == 's' && p[1] == '\0'))
7854                     *r++ = 'O';
7855                   else if (*p != 'O')
7856                     *r++ = 'f';
7857                 }
7858
7859               memcpy (r, p, len2);
7860               r[len2] = '\0';
7861               VEC_safe_push (const_char_p, gc, optimize_args, q);
7862             }
7863
7864         }
7865     }
7866
7867   opt_argc = VEC_length (const_char_p, optimize_args);
7868   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7869
7870   for (i = 1; i < opt_argc; i++)
7871     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7872
7873   saved_flag_strict_aliasing = flag_strict_aliasing;
7874
7875   /* Now parse the options.  */
7876   decode_options (opt_argc, opt_argv);
7877
7878   targetm.override_options_after_change();
7879
7880   /* Don't allow changing -fstrict-aliasing.  */
7881   flag_strict_aliasing = saved_flag_strict_aliasing;
7882
7883   VEC_truncate (const_char_p, optimize_args, 0);
7884   return ret;
7885 }
7886
7887 /* For handling "optimize" attribute. arguments as in
7888    struct attribute_spec.handler.  */
7889
7890 static tree
7891 handle_optimize_attribute (tree *node, tree name, tree args,
7892                            int ARG_UNUSED (flags), bool *no_add_attrs)
7893 {
7894   /* Ensure we have a function type.  */
7895   if (TREE_CODE (*node) != FUNCTION_DECL)
7896     {
7897       warning (OPT_Wattributes, "%qE attribute ignored", name);
7898       *no_add_attrs = true;
7899     }
7900   else
7901     {
7902       struct cl_optimization cur_opts;
7903       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7904
7905       /* Save current options.  */
7906       cl_optimization_save (&cur_opts);
7907
7908       /* If we previously had some optimization options, use them as the
7909          default.  */
7910       if (old_opts)
7911         cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7912
7913       /* Parse options, and update the vector.  */
7914       parse_optimize_options (args, true);
7915       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7916         = build_optimization_node ();
7917
7918       /* Restore current options.  */
7919       cl_optimization_restore (&cur_opts);
7920     }
7921
7922   return NULL_TREE;
7923 }
7924 \f
7925 /* Check for valid arguments being passed to a function.
7926    ATTRS is a list of attributes.  There are NARGS arguments in the array
7927    ARGARRAY.  TYPELIST is the list of argument types for the function.
7928  */
7929 void
7930 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7931 {
7932   /* Check for null being passed in a pointer argument that must be
7933      non-null.  We also need to do this if format checking is enabled.  */
7934
7935   if (warn_nonnull)
7936     check_function_nonnull (attrs, nargs, argarray);
7937
7938   /* Check for errors in format strings.  */
7939
7940   if (warn_format || warn_missing_format_attribute)
7941     check_function_format (attrs, nargs, argarray);
7942
7943   if (warn_format)
7944     check_function_sentinel (attrs, nargs, argarray, typelist);
7945 }
7946
7947 /* Generic argument checking recursion routine.  PARAM is the argument to
7948    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
7949    once the argument is resolved.  CTX is context for the callback.  */
7950 void
7951 check_function_arguments_recurse (void (*callback)
7952                                   (void *, tree, unsigned HOST_WIDE_INT),
7953                                   void *ctx, tree param,
7954                                   unsigned HOST_WIDE_INT param_num)
7955 {
7956   if (CONVERT_EXPR_P (param)
7957       && (TYPE_PRECISION (TREE_TYPE (param))
7958           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7959     {
7960       /* Strip coercion.  */
7961       check_function_arguments_recurse (callback, ctx,
7962                                         TREE_OPERAND (param, 0), param_num);
7963       return;
7964     }
7965
7966   if (TREE_CODE (param) == CALL_EXPR)
7967     {
7968       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7969       tree attrs;
7970       bool found_format_arg = false;
7971
7972       /* See if this is a call to a known internationalization function
7973          that modifies a format arg.  Such a function may have multiple
7974          format_arg attributes (for example, ngettext).  */
7975
7976       for (attrs = TYPE_ATTRIBUTES (type);
7977            attrs;
7978            attrs = TREE_CHAIN (attrs))
7979         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7980           {
7981             tree inner_arg;
7982             tree format_num_expr;
7983             int format_num;
7984             int i;
7985             call_expr_arg_iterator iter;
7986
7987             /* Extract the argument number, which was previously checked
7988                to be valid.  */
7989             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7990
7991             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7992                         && !TREE_INT_CST_HIGH (format_num_expr));
7993
7994             format_num = TREE_INT_CST_LOW (format_num_expr);
7995
7996             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7997                  inner_arg != 0;
7998                  inner_arg = next_call_expr_arg (&iter), i++)
7999               if (i == format_num)
8000                 {
8001                   check_function_arguments_recurse (callback, ctx,
8002                                                     inner_arg, param_num);
8003                   found_format_arg = true;
8004                   break;
8005                 }
8006           }
8007
8008       /* If we found a format_arg attribute and did a recursive check,
8009          we are done with checking this argument.  Otherwise, we continue
8010          and this will be considered a non-literal.  */
8011       if (found_format_arg)
8012         return;
8013     }
8014
8015   if (TREE_CODE (param) == COND_EXPR)
8016     {
8017       /* Check both halves of the conditional expression.  */
8018       check_function_arguments_recurse (callback, ctx,
8019                                         TREE_OPERAND (param, 1), param_num);
8020       check_function_arguments_recurse (callback, ctx,
8021                                         TREE_OPERAND (param, 2), param_num);
8022       return;
8023     }
8024
8025   (*callback) (ctx, param, param_num);
8026 }
8027
8028 /* Checks for a builtin function FNDECL that the number of arguments
8029    NARGS against the required number REQUIRED and issues an error if
8030    there is a mismatch.  Returns true if the number of arguments is
8031    correct, otherwise false.  */
8032
8033 static bool
8034 builtin_function_validate_nargs (tree fndecl, int nargs, int required)
8035 {
8036   if (nargs < required)
8037     {
8038       error_at (input_location,
8039                 "not enough arguments to function %qE", fndecl);
8040       return false;
8041     }
8042   else if (nargs > required)
8043     {
8044       error_at (input_location,
8045                 "too many arguments to function %qE", fndecl);
8046       return false;
8047     }
8048   return true;
8049 }
8050
8051 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8052    Returns false if there was an error, otherwise true.  */
8053
8054 bool
8055 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8056 {
8057   if (!DECL_BUILT_IN (fndecl)
8058       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8059     return true;
8060
8061   switch (DECL_FUNCTION_CODE (fndecl))
8062     {
8063     case BUILT_IN_CONSTANT_P:
8064       return builtin_function_validate_nargs (fndecl, nargs, 1);
8065
8066     case BUILT_IN_ISFINITE:
8067     case BUILT_IN_ISINF:
8068     case BUILT_IN_ISINF_SIGN:
8069     case BUILT_IN_ISNAN:
8070     case BUILT_IN_ISNORMAL:
8071       if (builtin_function_validate_nargs (fndecl, nargs, 1))
8072         {
8073           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8074             {
8075               error ("non-floating-point argument in call to "
8076                      "function %qE", fndecl);
8077               return false;
8078             }
8079           return true;
8080         }
8081       return false;
8082
8083     case BUILT_IN_ISGREATER:
8084     case BUILT_IN_ISGREATEREQUAL:
8085     case BUILT_IN_ISLESS:
8086     case BUILT_IN_ISLESSEQUAL:
8087     case BUILT_IN_ISLESSGREATER:
8088     case BUILT_IN_ISUNORDERED:
8089       if (builtin_function_validate_nargs (fndecl, nargs, 2))
8090         {
8091           enum tree_code code0, code1;
8092           code0 = TREE_CODE (TREE_TYPE (args[0]));
8093           code1 = TREE_CODE (TREE_TYPE (args[1]));
8094           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8095                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8096                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8097             {
8098               error ("non-floating-point arguments in call to "
8099                      "function %qE", fndecl);
8100               return false;
8101             }
8102           return true;
8103         }
8104       return false;
8105
8106     case BUILT_IN_FPCLASSIFY:
8107       if (builtin_function_validate_nargs (fndecl, nargs, 6))
8108         {
8109           unsigned i;
8110
8111           for (i=0; i<5; i++)
8112             if (TREE_CODE (args[i]) != INTEGER_CST)
8113               {
8114                 error ("non-const integer argument %u in call to function %qE",
8115                        i+1, fndecl);
8116                 return false;
8117               }
8118
8119           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8120             {
8121               error ("non-floating-point argument in call to function %qE",
8122                      fndecl);
8123               return false;
8124             }
8125           return true;
8126         }
8127       return false;
8128
8129     default:
8130       return true;
8131     }
8132 }
8133
8134 /* Function to help qsort sort FIELD_DECLs by name order.  */
8135
8136 int
8137 field_decl_cmp (const void *x_p, const void *y_p)
8138 {
8139   const tree *const x = (const tree *const) x_p;
8140   const tree *const y = (const tree *const) y_p;
8141
8142   if (DECL_NAME (*x) == DECL_NAME (*y))
8143     /* A nontype is "greater" than a type.  */
8144     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8145   if (DECL_NAME (*x) == NULL_TREE)
8146     return -1;
8147   if (DECL_NAME (*y) == NULL_TREE)
8148     return 1;
8149   if (DECL_NAME (*x) < DECL_NAME (*y))
8150     return -1;
8151   return 1;
8152 }
8153
8154 static struct {
8155   gt_pointer_operator new_value;
8156   void *cookie;
8157 } resort_data;
8158
8159 /* This routine compares two fields like field_decl_cmp but using the
8160 pointer operator in resort_data.  */
8161
8162 static int
8163 resort_field_decl_cmp (const void *x_p, const void *y_p)
8164 {
8165   const tree *const x = (const tree *const) x_p;
8166   const tree *const y = (const tree *const) y_p;
8167
8168   if (DECL_NAME (*x) == DECL_NAME (*y))
8169     /* A nontype is "greater" than a type.  */
8170     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8171   if (DECL_NAME (*x) == NULL_TREE)
8172     return -1;
8173   if (DECL_NAME (*y) == NULL_TREE)
8174     return 1;
8175   {
8176     tree d1 = DECL_NAME (*x);
8177     tree d2 = DECL_NAME (*y);
8178     resort_data.new_value (&d1, resort_data.cookie);
8179     resort_data.new_value (&d2, resort_data.cookie);
8180     if (d1 < d2)
8181       return -1;
8182   }
8183   return 1;
8184 }
8185
8186 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
8187
8188 void
8189 resort_sorted_fields (void *obj,
8190                       void * ARG_UNUSED (orig_obj),
8191                       gt_pointer_operator new_value,
8192                       void *cookie)
8193 {
8194   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8195   resort_data.new_value = new_value;
8196   resort_data.cookie = cookie;
8197   qsort (&sf->elts[0], sf->len, sizeof (tree),
8198          resort_field_decl_cmp);
8199 }
8200
8201 /* Subroutine of c_parse_error.
8202    Return the result of concatenating LHS and RHS. RHS is really
8203    a string literal, its first character is indicated by RHS_START and
8204    RHS_SIZE is its length (including the terminating NUL character).
8205
8206    The caller is responsible for deleting the returned pointer.  */
8207
8208 static char *
8209 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8210 {
8211   const int lhs_size = strlen (lhs);
8212   char *result = XNEWVEC (char, lhs_size + rhs_size);
8213   strncpy (result, lhs, lhs_size);
8214   strncpy (result + lhs_size, rhs_start, rhs_size);
8215   return result;
8216 }
8217
8218 /* Issue the error given by GMSGID, indicating that it occurred before
8219    TOKEN, which had the associated VALUE.  */
8220
8221 void
8222 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8223                tree value, unsigned char token_flags)
8224 {
8225 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8226
8227   char *message = NULL;
8228
8229   if (token_type == CPP_EOF)
8230     message = catenate_messages (gmsgid, " at end of input");
8231   else if (token_type == CPP_CHAR
8232            || token_type == CPP_WCHAR
8233            || token_type == CPP_CHAR16
8234            || token_type == CPP_CHAR32)
8235     {
8236       unsigned int val = TREE_INT_CST_LOW (value);
8237       const char *prefix;
8238
8239       switch (token_type)
8240         {
8241         default:
8242           prefix = "";
8243           break;
8244         case CPP_WCHAR:
8245           prefix = "L";
8246           break;
8247         case CPP_CHAR16:
8248           prefix = "u";
8249           break;
8250         case CPP_CHAR32:
8251           prefix = "U";
8252           break;
8253         }
8254
8255       if (val <= UCHAR_MAX && ISGRAPH (val))
8256         message = catenate_messages (gmsgid, " before %s'%c'");
8257       else
8258         message = catenate_messages (gmsgid, " before %s'\\x%x'");
8259
8260       error (message, prefix, val);
8261       free (message);
8262       message = NULL;
8263     }
8264   else if (token_type == CPP_STRING
8265            || token_type == CPP_WSTRING
8266            || token_type == CPP_STRING16
8267            || token_type == CPP_STRING32
8268            || token_type == CPP_UTF8STRING)
8269     message = catenate_messages (gmsgid, " before string constant");
8270   else if (token_type == CPP_NUMBER)
8271     message = catenate_messages (gmsgid, " before numeric constant");
8272   else if (token_type == CPP_NAME)
8273     {
8274       message = catenate_messages (gmsgid, " before %qE");
8275       error (message, value);
8276       free (message);
8277       message = NULL;
8278     }
8279   else if (token_type == CPP_PRAGMA)
8280     message = catenate_messages (gmsgid, " before %<#pragma%>");
8281   else if (token_type == CPP_PRAGMA_EOL)
8282     message = catenate_messages (gmsgid, " before end of line");
8283   else if (token_type < N_TTYPES)
8284     {
8285       message = catenate_messages (gmsgid, " before %qs token");
8286       error (message, cpp_type2name (token_type, token_flags));
8287       free (message);
8288       message = NULL;
8289     }
8290   else
8291     error (gmsgid);
8292
8293   if (message)
8294     {
8295       error (message);
8296       free (message);
8297     }
8298 #undef catenate_messages
8299 }
8300
8301 /* Mapping for cpp message reasons to the options that enable them.  */
8302
8303 struct reason_option_codes_t
8304 {
8305   const int reason;             /* cpplib message reason.  */
8306   const int option_code;        /* gcc option that controls this message.  */
8307 };
8308
8309 static const struct reason_option_codes_t option_codes[] = {
8310   {CPP_W_DEPRECATED,                    OPT_Wdeprecated},
8311   {CPP_W_COMMENTS,                      OPT_Wcomments},
8312   {CPP_W_TRIGRAPHS,                     OPT_Wtrigraphs},
8313   {CPP_W_MULTICHAR,                     OPT_Wmultichar},
8314   {CPP_W_TRADITIONAL,                   OPT_Wtraditional},
8315   {CPP_W_LONG_LONG,                     OPT_Wlong_long},
8316   {CPP_W_ENDIF_LABELS,                  OPT_Wendif_labels},
8317   {CPP_W_VARIADIC_MACROS,               OPT_Wvariadic_macros},
8318   {CPP_W_BUILTIN_MACRO_REDEFINED,       OPT_Wbuiltin_macro_redefined},
8319   {CPP_W_UNDEF,                         OPT_Wundef},
8320   {CPP_W_UNUSED_MACROS,                 OPT_Wunused_macros},
8321   {CPP_W_CXX_OPERATOR_NAMES,            OPT_Wc___compat},
8322   {CPP_W_NORMALIZE,                     OPT_Wnormalized_},
8323   {CPP_W_INVALID_PCH,                   OPT_Winvalid_pch},
8324   {CPP_W_WARNING_DIRECTIVE,             OPT_Wcpp},
8325   {CPP_W_NONE,                          0}
8326 };
8327
8328 /* Return the gcc option code associated with the reason for a cpp
8329    message, or 0 if none.  */
8330
8331 static int
8332 c_option_controlling_cpp_error (int reason)
8333 {
8334   const struct reason_option_codes_t *entry;
8335
8336   for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8337     {
8338       if (entry->reason == reason)
8339         return entry->option_code;
8340     }
8341   return 0;
8342 }
8343
8344 /* Callback from cpp_error for PFILE to print diagnostics from the
8345    preprocessor.  The diagnostic is of type LEVEL, with REASON set
8346    to the reason code if LEVEL is represents a warning, at location
8347    LOCATION unless this is after lexing and the compiler's location
8348    should be used instead, with column number possibly overridden by
8349    COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8350    the arguments.  Returns true if a diagnostic was emitted, false
8351    otherwise.  */
8352
8353 bool
8354 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
8355              location_t location, unsigned int column_override,
8356              const char *msg, va_list *ap)
8357 {
8358   diagnostic_info diagnostic;
8359   diagnostic_t dlevel;
8360   int save_warn_system_headers = warn_system_headers;
8361   bool ret;
8362
8363   switch (level)
8364     {
8365     case CPP_DL_WARNING_SYSHDR:
8366       if (flag_no_output)
8367         return false;
8368       warn_system_headers = 1;
8369       /* Fall through.  */
8370     case CPP_DL_WARNING:
8371       if (flag_no_output)
8372         return false;
8373       dlevel = DK_WARNING;
8374       break;
8375     case CPP_DL_PEDWARN:
8376       if (flag_no_output && !flag_pedantic_errors)
8377         return false;
8378       dlevel = DK_PEDWARN;
8379       break;
8380     case CPP_DL_ERROR:
8381       dlevel = DK_ERROR;
8382       break;
8383     case CPP_DL_ICE:
8384       dlevel = DK_ICE;
8385       break;
8386     case CPP_DL_NOTE:
8387       dlevel = DK_NOTE;
8388       break;
8389     case CPP_DL_FATAL:
8390       dlevel = DK_FATAL;
8391       break;
8392     default:
8393       gcc_unreachable ();
8394     }
8395   if (done_lexing)
8396     location = input_location;
8397   diagnostic_set_info_translated (&diagnostic, msg, ap,
8398                                   location, dlevel);
8399   if (column_override)
8400     diagnostic_override_column (&diagnostic, column_override);
8401   diagnostic_override_option_index (&diagnostic,
8402                                     c_option_controlling_cpp_error (reason));
8403   ret = report_diagnostic (&diagnostic);
8404   if (level == CPP_DL_WARNING_SYSHDR)
8405     warn_system_headers = save_warn_system_headers;
8406   return ret;
8407 }
8408
8409 /* Convert a character from the host to the target execution character
8410    set.  cpplib handles this, mostly.  */
8411
8412 HOST_WIDE_INT
8413 c_common_to_target_charset (HOST_WIDE_INT c)
8414 {
8415   /* Character constants in GCC proper are sign-extended under -fsigned-char,
8416      zero-extended under -fno-signed-char.  cpplib insists that characters
8417      and character constants are always unsigned.  Hence we must convert
8418      back and forth.  */
8419   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8420
8421   uc = cpp_host_to_exec_charset (parse_in, uc);
8422
8423   if (flag_signed_char)
8424     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8425                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8426   else
8427     return uc;
8428 }
8429
8430 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
8431    component references, with STOP_REF, or alternatively an INDIRECT_REF of
8432    NULL, at the bottom; much like the traditional rendering of offsetof as a
8433    macro.  Returns the folded and properly cast result.  */
8434
8435 static tree
8436 fold_offsetof_1 (tree expr, tree stop_ref)
8437 {
8438   enum tree_code code = PLUS_EXPR;
8439   tree base, off, t;
8440
8441   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
8442     return size_zero_node;
8443
8444   switch (TREE_CODE (expr))
8445     {
8446     case ERROR_MARK:
8447       return expr;
8448
8449     case VAR_DECL:
8450       error ("cannot apply %<offsetof%> to static data member %qD", expr);
8451       return error_mark_node;
8452
8453     case CALL_EXPR:
8454     case TARGET_EXPR:
8455       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8456       return error_mark_node;
8457
8458     case NOP_EXPR:
8459     case INDIRECT_REF:
8460       if (!integer_zerop (TREE_OPERAND (expr, 0)))
8461         {
8462           error ("cannot apply %<offsetof%> to a non constant address");
8463           return error_mark_node;
8464         }
8465       return size_zero_node;
8466
8467     case COMPONENT_REF:
8468       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8469       if (base == error_mark_node)
8470         return base;
8471
8472       t = TREE_OPERAND (expr, 1);
8473       if (DECL_C_BIT_FIELD (t))
8474         {
8475           error ("attempt to take address of bit-field structure "
8476                  "member %qD", t);
8477           return error_mark_node;
8478         }
8479       off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8480                             size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8481                                                     1)
8482                                       / BITS_PER_UNIT));
8483       break;
8484
8485     case ARRAY_REF:
8486       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
8487       if (base == error_mark_node)
8488         return base;
8489
8490       t = TREE_OPERAND (expr, 1);
8491       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
8492         {
8493           code = MINUS_EXPR;
8494           t = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (t), t);
8495         }
8496       t = convert (sizetype, t);
8497       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8498
8499       /* Check if the offset goes beyond the upper bound of the array.  */
8500       if (code == PLUS_EXPR && TREE_CODE (t) == INTEGER_CST)
8501         {
8502           tree upbound = array_ref_up_bound (expr);
8503           if (upbound != NULL_TREE
8504               && TREE_CODE (upbound) == INTEGER_CST
8505               && !tree_int_cst_equal (upbound,
8506                                       TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8507             {
8508               upbound = size_binop (PLUS_EXPR, upbound,
8509                                     build_int_cst (TREE_TYPE (upbound), 1));
8510               if (tree_int_cst_lt (upbound, t))
8511                 {
8512                   tree v;
8513
8514                   for (v = TREE_OPERAND (expr, 0);
8515                        TREE_CODE (v) == COMPONENT_REF;
8516                        v = TREE_OPERAND (v, 0))
8517                     if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8518                         == RECORD_TYPE)
8519                       {
8520                         tree fld_chain = TREE_CHAIN (TREE_OPERAND (v, 1));
8521                         for (; fld_chain; fld_chain = TREE_CHAIN (fld_chain))
8522                           if (TREE_CODE (fld_chain) == FIELD_DECL)
8523                             break;
8524
8525                         if (fld_chain)
8526                           break;
8527                       }
8528                   /* Don't warn if the array might be considered a poor
8529                      man's flexible array member with a very permissive
8530                      definition thereof.  */
8531                   if (TREE_CODE (v) == ARRAY_REF
8532                       || TREE_CODE (v) == COMPONENT_REF)
8533                     warning (OPT_Warray_bounds,
8534                              "index %E denotes an offset "
8535                              "greater than size of %qT",
8536                              t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8537                 }
8538             }
8539         }
8540       break;
8541
8542     case COMPOUND_EXPR:
8543       /* Handle static members of volatile structs.  */
8544       t = TREE_OPERAND (expr, 1);
8545       gcc_assert (TREE_CODE (t) == VAR_DECL);
8546       return fold_offsetof_1 (t, stop_ref);
8547
8548     default:
8549       gcc_unreachable ();
8550     }
8551
8552   return size_binop (code, base, off);
8553 }
8554
8555 tree
8556 fold_offsetof (tree expr, tree stop_ref)
8557 {
8558   /* Convert back from the internal sizetype to size_t.  */
8559   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
8560 }
8561
8562 /* Print an error message for an invalid lvalue.  USE says
8563    how the lvalue is being used and so selects the error message.  */
8564
8565 void
8566 lvalue_error (enum lvalue_use use)
8567 {
8568   switch (use)
8569     {
8570     case lv_assign:
8571       error ("lvalue required as left operand of assignment");
8572       break;
8573     case lv_increment:
8574       error ("lvalue required as increment operand");
8575       break;
8576     case lv_decrement:
8577       error ("lvalue required as decrement operand");
8578       break;
8579     case lv_addressof:
8580       error ("lvalue required as unary %<&%> operand");
8581       break;
8582     case lv_asm:
8583       error ("lvalue required in asm statement");
8584       break;
8585     default:
8586       gcc_unreachable ();
8587     }
8588 }
8589 \f
8590 /* *PTYPE is an incomplete array.  Complete it with a domain based on
8591    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
8592    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8593    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
8594
8595 int
8596 complete_array_type (tree *ptype, tree initial_value, bool do_default)
8597 {
8598   tree maxindex, type, main_type, elt, unqual_elt;
8599   int failure = 0, quals;
8600   hashval_t hashcode = 0;
8601
8602   maxindex = size_zero_node;
8603   if (initial_value)
8604     {
8605       if (TREE_CODE (initial_value) == STRING_CST)
8606         {
8607           int eltsize
8608             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
8609           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
8610         }
8611       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
8612         {
8613           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
8614
8615           if (VEC_empty (constructor_elt, v))
8616             {
8617               if (pedantic)
8618                 failure = 3;
8619               maxindex = integer_minus_one_node;
8620             }
8621           else
8622             {
8623               tree curindex;
8624               unsigned HOST_WIDE_INT cnt;
8625               constructor_elt *ce;
8626               bool fold_p = false;
8627
8628               if (VEC_index (constructor_elt, v, 0)->index)
8629                 maxindex = fold_convert_loc (input_location, sizetype,
8630                                              VEC_index (constructor_elt,
8631                                                         v, 0)->index);
8632               curindex = maxindex;
8633
8634               for (cnt = 1;
8635                    VEC_iterate (constructor_elt, v, cnt, ce);
8636                    cnt++)
8637                 {
8638                   bool curfold_p = false;
8639                   if (ce->index)
8640                     curindex = ce->index, curfold_p = true;
8641                   else
8642                     {
8643                       if (fold_p)
8644                         curindex = fold_convert (sizetype, curindex);
8645                       curindex = size_binop (PLUS_EXPR, curindex,
8646                                              size_one_node);
8647                     }
8648                   if (tree_int_cst_lt (maxindex, curindex))
8649                     maxindex = curindex, fold_p = curfold_p;
8650                 }
8651                if (fold_p)
8652                  maxindex = fold_convert (sizetype, maxindex);
8653             }
8654         }
8655       else
8656         {
8657           /* Make an error message unless that happened already.  */
8658           if (initial_value != error_mark_node)
8659             failure = 1;
8660         }
8661     }
8662   else
8663     {
8664       failure = 2;
8665       if (!do_default)
8666         return failure;
8667     }
8668
8669   type = *ptype;
8670   elt = TREE_TYPE (type);
8671   quals = TYPE_QUALS (strip_array_types (elt));
8672   if (quals == 0)
8673     unqual_elt = elt;
8674   else
8675     unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
8676
8677   /* Using build_distinct_type_copy and modifying things afterward instead
8678      of using build_array_type to create a new type preserves all of the
8679      TYPE_LANG_FLAG_? bits that the front end may have set.  */
8680   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
8681   TREE_TYPE (main_type) = unqual_elt;
8682   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
8683   layout_type (main_type);
8684
8685   /* Make sure we have the canonical MAIN_TYPE. */
8686   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
8687   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
8688                                     hashcode);
8689   main_type = type_hash_canon (hashcode, main_type);
8690
8691   /* Fix the canonical type.  */
8692   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
8693       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
8694     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
8695   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
8696            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
8697                != TYPE_DOMAIN (main_type)))
8698     TYPE_CANONICAL (main_type)
8699       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
8700                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
8701   else
8702     TYPE_CANONICAL (main_type) = main_type;
8703
8704   if (quals == 0)
8705     type = main_type;
8706   else
8707     type = c_build_qualified_type (main_type, quals);
8708
8709   if (COMPLETE_TYPE_P (type)
8710       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8711       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8712     {
8713       error ("size of array is too large");
8714       /* If we proceed with the array type as it is, we'll eventually
8715          crash in tree_low_cst().  */
8716       type = error_mark_node;
8717     }
8718
8719   *ptype = type;
8720   return failure;
8721 }
8722
8723 \f
8724 /* Used to help initialize the builtin-types.def table.  When a type of
8725    the correct size doesn't exist, use error_mark_node instead of NULL.
8726    The later results in segfaults even when a decl using the type doesn't
8727    get invoked.  */
8728
8729 tree
8730 builtin_type_for_size (int size, bool unsignedp)
8731 {
8732   tree type = lang_hooks.types.type_for_size (size, unsignedp);
8733   return type ? type : error_mark_node;
8734 }
8735
8736 /* A helper function for resolve_overloaded_builtin in resolving the
8737    overloaded __sync_ builtins.  Returns a positive power of 2 if the
8738    first operand of PARAMS is a pointer to a supported data type.
8739    Returns 0 if an error is encountered.  */
8740
8741 static int
8742 sync_resolve_size (tree function, VEC(tree,gc) *params)
8743 {
8744   tree type;
8745   int size;
8746
8747   if (VEC_empty (tree, params))
8748     {
8749       error ("too few arguments to function %qE", function);
8750       return 0;
8751     }
8752
8753   type = TREE_TYPE (VEC_index (tree, params, 0));
8754   if (TREE_CODE (type) != POINTER_TYPE)
8755     goto incompatible;
8756
8757   type = TREE_TYPE (type);
8758   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8759     goto incompatible;
8760
8761   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
8762   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
8763     return size;
8764
8765  incompatible:
8766   error ("incompatible type for argument %d of %qE", 1, function);
8767   return 0;
8768 }
8769
8770 /* A helper function for resolve_overloaded_builtin.  Adds casts to
8771    PARAMS to make arguments match up with those of FUNCTION.  Drops
8772    the variadic arguments at the end.  Returns false if some error
8773    was encountered; true on success.  */
8774
8775 static bool
8776 sync_resolve_params (tree orig_function, tree function, VEC(tree, gc) *params)
8777 {
8778   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
8779   tree ptype;
8780   unsigned int parmnum;
8781
8782   /* We've declared the implementation functions to use "volatile void *"
8783      as the pointer parameter, so we shouldn't get any complaints from the
8784      call to check_function_arguments what ever type the user used.  */
8785   arg_types = TREE_CHAIN (arg_types);
8786   ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
8787
8788   /* For the rest of the values, we need to cast these to FTYPE, so that we
8789      don't get warnings for passing pointer types, etc.  */
8790   parmnum = 0;
8791   while (arg_types != void_list_node)
8792     {
8793       tree val;
8794
8795       ++parmnum;
8796       if (VEC_length (tree, params) <= parmnum)
8797         {
8798           error ("too few arguments to function %qE", orig_function);
8799           return false;
8800         }
8801
8802       /* ??? Ideally for the first conversion we'd use convert_for_assignment
8803          so that we get warnings for anything that doesn't match the pointer
8804          type.  This isn't portable across the C and C++ front ends atm.  */
8805       val = VEC_index (tree, params, parmnum);
8806       val = convert (ptype, val);
8807       val = convert (TREE_VALUE (arg_types), val);
8808       VEC_replace (tree, params, parmnum, val);
8809
8810       arg_types = TREE_CHAIN (arg_types);
8811     }
8812
8813   /* The definition of these primitives is variadic, with the remaining
8814      being "an optional list of variables protected by the memory barrier".
8815      No clue what that's supposed to mean, precisely, but we consider all
8816      call-clobbered variables to be protected so we're safe.  */
8817   VEC_truncate (tree, params, parmnum + 1);
8818
8819   return true;
8820 }
8821
8822 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
8823    RESULT to make it match the type of the first pointer argument in
8824    PARAMS.  */
8825
8826 static tree
8827 sync_resolve_return (tree first_param, tree result)
8828 {
8829   tree ptype = TREE_TYPE (TREE_TYPE (first_param));
8830   ptype = TYPE_MAIN_VARIANT (ptype);
8831   return convert (ptype, result);
8832 }
8833
8834 /* Some builtin functions are placeholders for other expressions.  This
8835    function should be called immediately after parsing the call expression
8836    before surrounding code has committed to the type of the expression.
8837
8838    LOC is the location of the builtin call.
8839
8840    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
8841    PARAMS is the argument list for the call.  The return value is non-null
8842    when expansion is complete, and null if normal processing should
8843    continue.  */
8844
8845 tree
8846 resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
8847 {
8848   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
8849   switch (DECL_BUILT_IN_CLASS (function))
8850     {
8851     case BUILT_IN_NORMAL:
8852       break;
8853     case BUILT_IN_MD:
8854       if (targetm.resolve_overloaded_builtin)
8855         return targetm.resolve_overloaded_builtin (loc, function, params);
8856       else
8857         return NULL_TREE;
8858     default:
8859       return NULL_TREE;
8860     }
8861
8862   /* Handle BUILT_IN_NORMAL here.  */
8863   switch (orig_code)
8864     {
8865     case BUILT_IN_FETCH_AND_ADD_N:
8866     case BUILT_IN_FETCH_AND_SUB_N:
8867     case BUILT_IN_FETCH_AND_OR_N:
8868     case BUILT_IN_FETCH_AND_AND_N:
8869     case BUILT_IN_FETCH_AND_XOR_N:
8870     case BUILT_IN_FETCH_AND_NAND_N:
8871     case BUILT_IN_ADD_AND_FETCH_N:
8872     case BUILT_IN_SUB_AND_FETCH_N:
8873     case BUILT_IN_OR_AND_FETCH_N:
8874     case BUILT_IN_AND_AND_FETCH_N:
8875     case BUILT_IN_XOR_AND_FETCH_N:
8876     case BUILT_IN_NAND_AND_FETCH_N:
8877     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
8878     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
8879     case BUILT_IN_LOCK_TEST_AND_SET_N:
8880     case BUILT_IN_LOCK_RELEASE_N:
8881       {
8882         int n = sync_resolve_size (function, params);
8883         tree new_function, first_param, result;
8884
8885         if (n == 0)
8886           return error_mark_node;
8887
8888         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8889         if (!sync_resolve_params (function, new_function, params))
8890           return error_mark_node;
8891
8892         first_param = VEC_index (tree, params, 0);
8893         result = build_function_call_vec (loc, new_function, params, NULL);
8894         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8895             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8896           result = sync_resolve_return (first_param, result);
8897
8898         return result;
8899       }
8900
8901     default:
8902       return NULL_TREE;
8903     }
8904 }
8905
8906 /* Ignoring their sign, return true if two scalar types are the same.  */
8907 bool
8908 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8909 {
8910   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8911
8912   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8913               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8914                   || c2 == FIXED_POINT_TYPE));
8915
8916   /* Equality works here because c_common_signed_type uses
8917      TYPE_MAIN_VARIANT.  */
8918   return c_common_signed_type (t1)
8919     == c_common_signed_type (t2);
8920 }
8921
8922 /* Check for missing format attributes on function pointers.  LTYPE is
8923    the new type or left-hand side type.  RTYPE is the old type or
8924    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8925    attribute.  */
8926
8927 bool
8928 check_missing_format_attribute (tree ltype, tree rtype)
8929 {
8930   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8931   tree ra;
8932
8933   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8934     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8935       break;
8936   if (ra)
8937     {
8938       tree la;
8939       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8940         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8941           break;
8942       return !la;
8943     }
8944   else
8945     return false;
8946 }
8947
8948 /* Subscripting with type char is likely to lose on a machine where
8949    chars are signed.  So warn on any machine, but optionally.  Don't
8950    warn for unsigned char since that type is safe.  Don't warn for
8951    signed char because anyone who uses that must have done so
8952    deliberately. Furthermore, we reduce the false positive load by
8953    warning only for non-constant value of type char.  */
8954
8955 void
8956 warn_array_subscript_with_type_char (tree index)
8957 {
8958   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8959       && TREE_CODE (index) != INTEGER_CST)
8960     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8961 }
8962
8963 /* Implement -Wparentheses for the unexpected C precedence rules, to
8964    cover cases like x + y << z which readers are likely to
8965    misinterpret.  We have seen an expression in which CODE is a binary
8966    operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
8967    before folding had CODE_LEFT and CODE_RIGHT.  CODE_LEFT and
8968    CODE_RIGHT may be ERROR_MARK, which means that that side of the
8969    expression was not formed using a binary or unary operator, or it
8970    was enclosed in parentheses.  */
8971
8972 void
8973 warn_about_parentheses (enum tree_code code,
8974                         enum tree_code code_left, tree arg_left,
8975                         enum tree_code code_right, tree arg_right)
8976 {
8977   if (!warn_parentheses)
8978     return;
8979
8980   /* This macro tests that the expression ARG with original tree code
8981      CODE appears to be a boolean expression. or the result of folding a
8982      boolean expression.  */
8983 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG)                             \
8984         (truth_value_p (TREE_CODE (ARG))                                    \
8985          || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE                     \
8986          /* Folding may create 0 or 1 integers from other expressions.  */  \
8987          || ((CODE) != INTEGER_CST                                          \
8988              && (integer_onep (ARG) || integer_zerop (ARG))))
8989
8990   switch (code)
8991     {
8992     case LSHIFT_EXPR:
8993       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
8994         warning (OPT_Wparentheses,
8995                  "suggest parentheses around %<+%> inside %<<<%>");
8996       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
8997         warning (OPT_Wparentheses,
8998                  "suggest parentheses around %<-%> inside %<<<%>");
8999       return;
9000
9001     case RSHIFT_EXPR:
9002       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9003         warning (OPT_Wparentheses,
9004                  "suggest parentheses around %<+%> inside %<>>%>");
9005       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9006         warning (OPT_Wparentheses,
9007                  "suggest parentheses around %<-%> inside %<>>%>");
9008       return;
9009
9010     case TRUTH_ORIF_EXPR:
9011       if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
9012         warning (OPT_Wparentheses,
9013                  "suggest parentheses around %<&&%> within %<||%>");
9014       return;
9015
9016     case BIT_IOR_EXPR:
9017       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
9018           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9019           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
9020           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9021         warning (OPT_Wparentheses,
9022                  "suggest parentheses around arithmetic in operand of %<|%>");
9023       /* Check cases like x|y==z */
9024       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9025                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9026         warning (OPT_Wparentheses,
9027                  "suggest parentheses around comparison in operand of %<|%>");
9028       /* Check cases like !x | y */
9029       else if (code_left == TRUTH_NOT_EXPR
9030                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9031         warning (OPT_Wparentheses, "suggest parentheses around operand of "
9032                  "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
9033       return;
9034
9035     case BIT_XOR_EXPR:
9036       if (code_left == BIT_AND_EXPR
9037           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
9038           || code_right == BIT_AND_EXPR
9039           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
9040         warning (OPT_Wparentheses,
9041                  "suggest parentheses around arithmetic in operand of %<^%>");
9042       /* Check cases like x^y==z */
9043       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9044                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9045         warning (OPT_Wparentheses,
9046                  "suggest parentheses around comparison in operand of %<^%>");
9047       return;
9048
9049     case BIT_AND_EXPR:
9050       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
9051         warning (OPT_Wparentheses,
9052                  "suggest parentheses around %<+%> in operand of %<&%>");
9053       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
9054         warning (OPT_Wparentheses,
9055                  "suggest parentheses around %<-%> in operand of %<&%>");
9056       /* Check cases like x&y==z */
9057       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
9058                || TREE_CODE_CLASS (code_right) == tcc_comparison)
9059         warning (OPT_Wparentheses,
9060                  "suggest parentheses around comparison in operand of %<&%>");
9061       /* Check cases like !x & y */
9062       else if (code_left == TRUTH_NOT_EXPR
9063                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
9064         warning (OPT_Wparentheses, "suggest parentheses around operand of "
9065                  "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
9066       return;
9067
9068     case EQ_EXPR:
9069       if (TREE_CODE_CLASS (code_left) == tcc_comparison
9070           || TREE_CODE_CLASS (code_right) == tcc_comparison)
9071         warning (OPT_Wparentheses,
9072                  "suggest parentheses around comparison in operand of %<==%>");
9073       return;
9074     case NE_EXPR:
9075       if (TREE_CODE_CLASS (code_left) == tcc_comparison
9076           || TREE_CODE_CLASS (code_right) == tcc_comparison)
9077         warning (OPT_Wparentheses,
9078                  "suggest parentheses around comparison in operand of %<!=%>");
9079       return;
9080
9081     default:
9082       if (TREE_CODE_CLASS (code) == tcc_comparison
9083            && ((TREE_CODE_CLASS (code_left) == tcc_comparison
9084                 && code_left != NE_EXPR && code_left != EQ_EXPR
9085                 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
9086                || (TREE_CODE_CLASS (code_right) == tcc_comparison
9087                    && code_right != NE_EXPR && code_right != EQ_EXPR
9088                    && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
9089         warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
9090                  "have their mathematical meaning");
9091       return;
9092     }
9093 #undef NOT_A_BOOLEAN_EXPR_P
9094 }
9095
9096 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
9097
9098 void
9099 warn_for_unused_label (tree label)
9100 {
9101   if (!TREE_USED (label))
9102     {
9103       if (DECL_INITIAL (label))
9104         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
9105       else
9106         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
9107     }
9108 }
9109
9110 #ifndef TARGET_HAS_TARGETCM
9111 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
9112 #endif
9113
9114 /* Warn for division by zero according to the value of DIVISOR.  LOC
9115    is the location of the division operator.  */
9116
9117 void
9118 warn_for_div_by_zero (location_t loc, tree divisor)
9119 {
9120   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
9121      about division by zero.  Do not issue a warning if DIVISOR has a
9122      floating-point type, since we consider 0.0/0.0 a valid way of
9123      generating a NaN.  */
9124   if (c_inhibit_evaluation_warnings == 0
9125       && (integer_zerop (divisor) || fixed_zerop (divisor)))
9126     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
9127 }
9128
9129 /* Subroutine of build_binary_op. Give warnings for comparisons
9130    between signed and unsigned quantities that may fail. Do the
9131    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
9132    so that casts will be considered, but default promotions won't
9133    be.
9134
9135    LOCATION is the location of the comparison operator.
9136
9137    The arguments of this function map directly to local variables
9138    of build_binary_op.  */
9139
9140 void
9141 warn_for_sign_compare (location_t location,
9142                        tree orig_op0, tree orig_op1,
9143                        tree op0, tree op1,
9144                        tree result_type, enum tree_code resultcode)
9145 {
9146   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
9147   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
9148   int unsignedp0, unsignedp1;
9149
9150   /* In C++, check for comparison of different enum types.  */
9151   if (c_dialect_cxx()
9152       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
9153       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
9154       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
9155          != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
9156     {
9157       warning_at (location,
9158                   OPT_Wsign_compare, "comparison between types %qT and %qT",
9159                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
9160     }
9161
9162   /* Do not warn if the comparison is being done in a signed type,
9163      since the signed type will only be chosen if it can represent
9164      all the values of the unsigned type.  */
9165   if (!TYPE_UNSIGNED (result_type))
9166     /* OK */;
9167   /* Do not warn if both operands are unsigned.  */
9168   else if (op0_signed == op1_signed)
9169     /* OK */;
9170   else
9171     {
9172       tree sop, uop, base_type;
9173       bool ovf;
9174
9175       if (op0_signed)
9176         sop = orig_op0, uop = orig_op1;
9177       else
9178         sop = orig_op1, uop = orig_op0;
9179
9180       STRIP_TYPE_NOPS (sop);
9181       STRIP_TYPE_NOPS (uop);
9182       base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
9183                    ? TREE_TYPE (result_type) : result_type);
9184
9185       /* Do not warn if the signed quantity is an unsuffixed integer
9186          literal (or some static constant expression involving such
9187          literals or a conditional expression involving such literals)
9188          and it is non-negative.  */
9189       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
9190         /* OK */;
9191       /* Do not warn if the comparison is an equality operation, the
9192          unsigned quantity is an integral constant, and it would fit
9193          in the result if the result were signed.  */
9194       else if (TREE_CODE (uop) == INTEGER_CST
9195                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
9196                && int_fits_type_p (uop, c_common_signed_type (base_type)))
9197         /* OK */;
9198       /* In C, do not warn if the unsigned quantity is an enumeration
9199          constant and its maximum value would fit in the result if the
9200          result were signed.  */
9201       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
9202                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
9203                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
9204                                    c_common_signed_type (base_type)))
9205         /* OK */;
9206       else
9207         warning_at (location,
9208                     OPT_Wsign_compare,
9209                     "comparison between signed and unsigned integer expressions");
9210     }
9211
9212   /* Warn if two unsigned values are being compared in a size larger
9213      than their original size, and one (and only one) is the result of
9214      a `~' operator.  This comparison will always fail.
9215
9216      Also warn if one operand is a constant, and the constant does not
9217      have all bits set that are set in the ~ operand when it is
9218      extended.  */
9219
9220   op0 = get_narrower (op0, &unsignedp0);
9221   op1 = get_narrower (op1, &unsignedp1);
9222
9223   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
9224       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
9225     {
9226       if (TREE_CODE (op0) == BIT_NOT_EXPR)
9227         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
9228       if (TREE_CODE (op1) == BIT_NOT_EXPR)
9229         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
9230
9231       if (host_integerp (op0, 0) || host_integerp (op1, 0))
9232         {
9233           tree primop;
9234           HOST_WIDE_INT constant, mask;
9235           int unsignedp;
9236           unsigned int bits;
9237
9238           if (host_integerp (op0, 0))
9239             {
9240               primop = op1;
9241               unsignedp = unsignedp1;
9242               constant = tree_low_cst (op0, 0);
9243             }
9244           else
9245             {
9246               primop = op0;
9247               unsignedp = unsignedp0;
9248               constant = tree_low_cst (op1, 0);
9249             }
9250
9251           bits = TYPE_PRECISION (TREE_TYPE (primop));
9252           if (bits < TYPE_PRECISION (result_type)
9253               && bits < HOST_BITS_PER_LONG && unsignedp)
9254             {
9255               mask = (~ (HOST_WIDE_INT) 0) << bits;
9256               if ((mask & constant) != mask)
9257                 {
9258                   if (constant == 0)
9259                     warning (OPT_Wsign_compare,
9260                              "promoted ~unsigned is always non-zero");
9261                   else
9262                     warning_at (location, OPT_Wsign_compare,
9263                                 "comparison of promoted ~unsigned with constant");
9264                 }
9265             }
9266         }
9267       else if (unsignedp0 && unsignedp1
9268                && (TYPE_PRECISION (TREE_TYPE (op0))
9269                    < TYPE_PRECISION (result_type))
9270                && (TYPE_PRECISION (TREE_TYPE (op1))
9271                    < TYPE_PRECISION (result_type)))
9272         warning_at (location, OPT_Wsign_compare,
9273                  "comparison of promoted ~unsigned with unsigned");
9274     }
9275 }
9276
9277 /* Setup a TYPE_DECL node as a typedef representation.
9278
9279    X is a TYPE_DECL for a typedef statement.  Create a brand new
9280    ..._TYPE node (which will be just a variant of the existing
9281    ..._TYPE node with identical properties) and then install X
9282    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
9283
9284    The whole point here is to end up with a situation where each
9285    and every ..._TYPE node the compiler creates will be uniquely
9286    associated with AT MOST one node representing a typedef name.
9287    This way, even though the compiler substitutes corresponding
9288    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
9289    early on, later parts of the compiler can always do the reverse
9290    translation and get back the corresponding typedef name.  For
9291    example, given:
9292
9293         typedef struct S MY_TYPE;
9294         MY_TYPE object;
9295
9296    Later parts of the compiler might only know that `object' was of
9297    type `struct S' if it were not for code just below.  With this
9298    code however, later parts of the compiler see something like:
9299
9300         struct S' == struct S
9301         typedef struct S' MY_TYPE;
9302         struct S' object;
9303
9304     And they can then deduce (from the node for type struct S') that
9305     the original object declaration was:
9306
9307                 MY_TYPE object;
9308
9309     Being able to do this is important for proper support of protoize,
9310     and also for generating precise symbolic debugging information
9311     which takes full account of the programmer's (typedef) vocabulary.
9312
9313     Obviously, we don't want to generate a duplicate ..._TYPE node if
9314     the TYPE_DECL node that we are now processing really represents a
9315     standard built-in type.  */
9316
9317 void
9318 set_underlying_type (tree x)
9319 {
9320   if (x == error_mark_node)
9321     return;
9322   if (DECL_IS_BUILTIN (x))
9323     {
9324       if (TYPE_NAME (TREE_TYPE (x)) == 0)
9325         TYPE_NAME (TREE_TYPE (x)) = x;
9326     }
9327   else if (TREE_TYPE (x) != error_mark_node
9328            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
9329     {
9330       tree tt = TREE_TYPE (x);
9331       DECL_ORIGINAL_TYPE (x) = tt;
9332       tt = build_variant_type_copy (tt);
9333       TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
9334       TYPE_NAME (tt) = x;
9335       TREE_USED (tt) = TREE_USED (x);
9336       TREE_TYPE (x) = tt;
9337     }
9338 }
9339
9340 /* Returns true if X is a typedef decl.  */
9341
9342 bool
9343 is_typedef_decl (tree x)
9344 {
9345   return (x && TREE_CODE (x) == TYPE_DECL
9346           && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
9347 }
9348
9349 /* Record the types used by the current global variable declaration
9350    being parsed, so that we can decide later to emit their debug info.
9351    Those types are in types_used_by_cur_var_decl, and we are going to
9352    store them in the types_used_by_vars_hash hash table.
9353    DECL is the declaration of the global variable that has been parsed.  */
9354
9355 void
9356 record_types_used_by_current_var_decl (tree decl)
9357 {
9358   gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
9359
9360   if (types_used_by_cur_var_decl)
9361     {
9362       tree node;
9363       for (node = types_used_by_cur_var_decl;
9364            node;
9365            node = TREE_CHAIN (node))
9366       {
9367         tree type = TREE_PURPOSE (node);
9368         types_used_by_var_decl_insert (type, decl);
9369       }
9370       types_used_by_cur_var_decl = NULL;
9371     }
9372 }
9373
9374 /* The C and C++ parsers both use vectors to hold function arguments.
9375    For efficiency, we keep a cache of unused vectors.  This is the
9376    cache.  */
9377
9378 typedef VEC(tree,gc)* tree_gc_vec;
9379 DEF_VEC_P(tree_gc_vec);
9380 DEF_VEC_ALLOC_P(tree_gc_vec,gc);
9381 static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
9382
9383 /* Return a new vector from the cache.  If the cache is empty,
9384    allocate a new vector.  These vectors are GC'ed, so it is OK if the
9385    pointer is not released..  */
9386
9387 VEC(tree,gc) *
9388 make_tree_vector (void)
9389 {
9390   if (!VEC_empty (tree_gc_vec, tree_vector_cache))
9391     return VEC_pop (tree_gc_vec, tree_vector_cache);
9392   else
9393     {
9394       /* Passing 0 to VEC_alloc returns NULL, and our callers require
9395          that we always return a non-NULL value.  The vector code uses
9396          4 when growing a NULL vector, so we do too.  */
9397       return VEC_alloc (tree, gc, 4);
9398     }
9399 }
9400
9401 /* Release a vector of trees back to the cache.  */
9402
9403 void
9404 release_tree_vector (VEC(tree,gc) *vec)
9405 {
9406   if (vec != NULL)
9407     {
9408       VEC_truncate (tree, vec, 0);
9409       VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
9410     }
9411 }
9412
9413 /* Get a new tree vector holding a single tree.  */
9414
9415 VEC(tree,gc) *
9416 make_tree_vector_single (tree t)
9417 {
9418   VEC(tree,gc) *ret = make_tree_vector ();
9419   VEC_quick_push (tree, ret, t);
9420   return ret;
9421 }
9422
9423 /* Get a new tree vector which is a copy of an existing one.  */
9424
9425 VEC(tree,gc) *
9426 make_tree_vector_copy (const VEC(tree,gc) *orig)
9427 {
9428   VEC(tree,gc) *ret;
9429   unsigned int ix;
9430   tree t;
9431
9432   ret = make_tree_vector ();
9433   VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
9434   for (ix = 0; VEC_iterate (tree, orig, ix, t); ++ix)
9435     VEC_quick_push (tree, ret, t);
9436   return ret;
9437 }
9438
9439 #include "gt-c-common.h"