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