gcc/c-common.c

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