gcc/c-common.c

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