gcc/c-family/c-common.c

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