contrib/gcc-4.7/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, 2012
   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         && !!unsignedp == !!TYPE_UNSIGNED (TREE_VALUE (t)))
3094       return TREE_VALUE (t);
3095
3096   return 0;
3097 }
3098
3099 tree
3100 c_common_unsigned_type (tree type)
3101 {
3102   return c_common_signed_or_unsigned_type (1, type);
3103 }
3104
3105 /* Return a signed type the same as TYPE in other respects.  */
3106
3107 tree
3108 c_common_signed_type (tree type)
3109 {
3110   return c_common_signed_or_unsigned_type (0, type);
3111 }
3112
3113 /* Return a type the same as TYPE except unsigned or
3114    signed according to UNSIGNEDP.  */
3115
3116 tree
3117 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3118 {
3119   tree type1;
3120
3121   /* This block of code emulates the behavior of the old
3122      c_common_unsigned_type. In particular, it returns
3123      long_unsigned_type_node if passed a long, even when a int would
3124      have the same size. This is necessary for warnings to work
3125      correctly in archs where sizeof(int) == sizeof(long) */
3126
3127   type1 = TYPE_MAIN_VARIANT (type);
3128   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3129     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3130   if (type1 == integer_type_node || type1 == unsigned_type_node)
3131     return unsignedp ? unsigned_type_node : integer_type_node;
3132   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3133     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3134   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3135     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3136   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3137     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3138   if (int128_integer_type_node
3139       && (type1 == int128_integer_type_node
3140           || type1 == int128_unsigned_type_node))
3141     return unsignedp ? int128_unsigned_type_node : int128_integer_type_node;
3142   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3143     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3144 #if HOST_BITS_PER_WIDE_INT >= 64
3145   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3146     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3147 #endif
3148   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3149     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3150   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3151     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3152   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3153     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3154   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3155     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3156
3157 #define C_COMMON_FIXED_TYPES(NAME)          \
3158   if (type1 == short_ ## NAME ## _type_node \
3159       || type1 == unsigned_short_ ## NAME ## _type_node) \
3160     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3161                      : short_ ## NAME ## _type_node; \
3162   if (type1 == NAME ## _type_node \
3163       || type1 == unsigned_ ## NAME ## _type_node) \
3164     return unsignedp ? unsigned_ ## NAME ## _type_node \
3165                      : NAME ## _type_node; \
3166   if (type1 == long_ ## NAME ## _type_node \
3167       || type1 == unsigned_long_ ## NAME ## _type_node) \
3168     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3169                      : long_ ## NAME ## _type_node; \
3170   if (type1 == long_long_ ## NAME ## _type_node \
3171       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3172     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3173                      : long_long_ ## NAME ## _type_node;
3174
3175 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3176   if (type1 == NAME ## _type_node \
3177       || type1 == u ## NAME ## _type_node) \
3178     return unsignedp ? u ## NAME ## _type_node \
3179                      : NAME ## _type_node;
3180
3181 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3182   if (type1 == sat_ ## short_ ## NAME ## _type_node \
3183       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3184     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3185                      : sat_ ## short_ ## NAME ## _type_node; \
3186   if (type1 == sat_ ## NAME ## _type_node \
3187       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3188     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3189                      : sat_ ## NAME ## _type_node; \
3190   if (type1 == sat_ ## long_ ## NAME ## _type_node \
3191       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3192     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3193                      : sat_ ## long_ ## NAME ## _type_node; \
3194   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3195       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3196     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3197                      : sat_ ## long_long_ ## NAME ## _type_node;
3198
3199 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
3200   if (type1 == sat_ ## NAME ## _type_node \
3201       || type1 == sat_ ## u ## NAME ## _type_node) \
3202     return unsignedp ? sat_ ## u ## NAME ## _type_node \
3203                      : sat_ ## NAME ## _type_node;
3204
3205   C_COMMON_FIXED_TYPES (fract);
3206   C_COMMON_FIXED_TYPES_SAT (fract);
3207   C_COMMON_FIXED_TYPES (accum);
3208   C_COMMON_FIXED_TYPES_SAT (accum);
3209
3210   C_COMMON_FIXED_MODE_TYPES (qq);
3211   C_COMMON_FIXED_MODE_TYPES (hq);
3212   C_COMMON_FIXED_MODE_TYPES (sq);
3213   C_COMMON_FIXED_MODE_TYPES (dq);
3214   C_COMMON_FIXED_MODE_TYPES (tq);
3215   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3216   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3217   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3218   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3219   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3220   C_COMMON_FIXED_MODE_TYPES (ha);
3221   C_COMMON_FIXED_MODE_TYPES (sa);
3222   C_COMMON_FIXED_MODE_TYPES (da);
3223   C_COMMON_FIXED_MODE_TYPES (ta);
3224   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3225   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3226   C_COMMON_FIXED_MODE_TYPES_SAT (da);
3227   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3228
3229   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3230      the precision; they have precision set to match their range, but
3231      may use a wider mode to match an ABI.  If we change modes, we may
3232      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
3233      the precision as well, so as to yield correct results for
3234      bit-field types.  C++ does not have these separate bit-field
3235      types, and producing a signed or unsigned variant of an
3236      ENUMERAL_TYPE may cause other problems as well.  */
3237
3238   if (!INTEGRAL_TYPE_P (type)
3239       || TYPE_UNSIGNED (type) == unsignedp)
3240     return type;
3241
3242 #define TYPE_OK(node)                                                       \
3243   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
3244    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3245   if (TYPE_OK (signed_char_type_node))
3246     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3247   if (TYPE_OK (integer_type_node))
3248     return unsignedp ? unsigned_type_node : integer_type_node;
3249   if (TYPE_OK (short_integer_type_node))
3250     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3251   if (TYPE_OK (long_integer_type_node))
3252     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3253   if (TYPE_OK (long_long_integer_type_node))
3254     return (unsignedp ? long_long_unsigned_type_node
3255             : long_long_integer_type_node);
3256   if (int128_integer_type_node && TYPE_OK (int128_integer_type_node))
3257     return (unsignedp ? int128_unsigned_type_node
3258             : int128_integer_type_node);
3259   if (TYPE_OK (widest_integer_literal_type_node))
3260     return (unsignedp ? widest_unsigned_literal_type_node
3261             : widest_integer_literal_type_node);
3262
3263 #if HOST_BITS_PER_WIDE_INT >= 64
3264   if (TYPE_OK (intTI_type_node))
3265     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3266 #endif
3267   if (TYPE_OK (intDI_type_node))
3268     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3269   if (TYPE_OK (intSI_type_node))
3270     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3271   if (TYPE_OK (intHI_type_node))
3272     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3273   if (TYPE_OK (intQI_type_node))
3274     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3275 #undef TYPE_OK
3276
3277   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3278 }
3279
3280 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
3281
3282 tree
3283 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3284 {
3285   /* Extended integer types of the same width as a standard type have
3286      lesser rank, so those of the same width as int promote to int or
3287      unsigned int and are valid for printf formats expecting int or
3288      unsigned int.  To avoid such special cases, avoid creating
3289      extended integer types for bit-fields if a standard integer type
3290      is available.  */
3291   if (width == TYPE_PRECISION (integer_type_node))
3292     return unsignedp ? unsigned_type_node : integer_type_node;
3293   if (width == TYPE_PRECISION (signed_char_type_node))
3294     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3295   if (width == TYPE_PRECISION (short_integer_type_node))
3296     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3297   if (width == TYPE_PRECISION (long_integer_type_node))
3298     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3299   if (width == TYPE_PRECISION (long_long_integer_type_node))
3300     return (unsignedp ? long_long_unsigned_type_node
3301             : long_long_integer_type_node);
3302   if (int128_integer_type_node
3303       && width == TYPE_PRECISION (int128_integer_type_node))
3304     return (unsignedp ? int128_unsigned_type_node
3305             : int128_integer_type_node);
3306   return build_nonstandard_integer_type (width, unsignedp);
3307 }
3308
3309 /* The C version of the register_builtin_type langhook.  */
3310
3311 void
3312 c_register_builtin_type (tree type, const char* name)
3313 {
3314   tree decl;
3315
3316   decl = build_decl (UNKNOWN_LOCATION,
3317                      TYPE_DECL, get_identifier (name), type);
3318   DECL_ARTIFICIAL (decl) = 1;
3319   if (!TYPE_NAME (type))
3320     TYPE_NAME (type) = decl;
3321   pushdecl (decl);
3322
3323   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3324 }
3325 \f
3326 /* Print an error message for invalid operands to arith operation
3327    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3328    LOCATION is the location of the message.  */
3329
3330 void
3331 binary_op_error (location_t location, enum tree_code code,
3332                  tree type0, tree type1)
3333 {
3334   const char *opname;
3335
3336   switch (code)
3337     {
3338     case PLUS_EXPR:
3339       opname = "+"; break;
3340     case MINUS_EXPR:
3341       opname = "-"; break;
3342     case MULT_EXPR:
3343       opname = "*"; break;
3344     case MAX_EXPR:
3345       opname = "max"; break;
3346     case MIN_EXPR:
3347       opname = "min"; break;
3348     case EQ_EXPR:
3349       opname = "=="; break;
3350     case NE_EXPR:
3351       opname = "!="; break;
3352     case LE_EXPR:
3353       opname = "<="; break;
3354     case GE_EXPR:
3355       opname = ">="; break;
3356     case LT_EXPR:
3357       opname = "<"; break;
3358     case GT_EXPR:
3359       opname = ">"; break;
3360     case LSHIFT_EXPR:
3361       opname = "<<"; break;
3362     case RSHIFT_EXPR:
3363       opname = ">>"; break;
3364     case TRUNC_MOD_EXPR:
3365     case FLOOR_MOD_EXPR:
3366       opname = "%"; break;
3367     case TRUNC_DIV_EXPR:
3368     case FLOOR_DIV_EXPR:
3369       opname = "/"; break;
3370     case BIT_AND_EXPR:
3371       opname = "&"; break;
3372     case BIT_IOR_EXPR:
3373       opname = "|"; break;
3374     case TRUTH_ANDIF_EXPR:
3375       opname = "&&"; break;
3376     case TRUTH_ORIF_EXPR:
3377       opname = "||"; break;
3378     case BIT_XOR_EXPR:
3379       opname = "^"; break;
3380     default:
3381       gcc_unreachable ();
3382     }
3383   error_at (location,
3384             "invalid operands to binary %s (have %qT and %qT)", opname,
3385             type0, type1);
3386 }
3387 \f
3388 /* Subroutine of build_binary_op, used for comparison operations.
3389    See if the operands have both been converted from subword integer types
3390    and, if so, perhaps change them both back to their original type.
3391    This function is also responsible for converting the two operands
3392    to the proper common type for comparison.
3393
3394    The arguments of this function are all pointers to local variables
3395    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3396    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3397
3398    If this function returns nonzero, it means that the comparison has
3399    a constant value.  What this function returns is an expression for
3400    that value.  */
3401
3402 tree
3403 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3404                  enum tree_code *rescode_ptr)
3405 {
3406   tree type;
3407   tree op0 = *op0_ptr;
3408   tree op1 = *op1_ptr;
3409   int unsignedp0, unsignedp1;
3410   int real1, real2;
3411   tree primop0, primop1;
3412   enum tree_code code = *rescode_ptr;
3413
3414   /* Throw away any conversions to wider types
3415      already present in the operands.  */
3416
3417   primop0 = c_common_get_narrower (op0, &unsignedp0);
3418   primop1 = c_common_get_narrower (op1, &unsignedp1);
3419
3420   /* If primopN is first sign-extended from primopN's precision to opN's
3421      precision, then zero-extended from opN's precision to
3422      *restype_ptr precision, shortenings might be invalid.  */
3423   if (TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (TREE_TYPE (op0))
3424       && TYPE_PRECISION (TREE_TYPE (op0)) < TYPE_PRECISION (*restype_ptr)
3425       && !unsignedp0
3426       && TYPE_UNSIGNED (TREE_TYPE (op0)))
3427     primop0 = op0;
3428   if (TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (TREE_TYPE (op1))
3429       && TYPE_PRECISION (TREE_TYPE (op1)) < TYPE_PRECISION (*restype_ptr)
3430       && !unsignedp1
3431       && TYPE_UNSIGNED (TREE_TYPE (op1)))
3432     primop1 = op1;
3433
3434   /* Handle the case that OP0 does not *contain* a conversion
3435      but it *requires* conversion to FINAL_TYPE.  */
3436
3437   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3438     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3439   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3440     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3441
3442   /* If one of the operands must be floated, we cannot optimize.  */
3443   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3444   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3445
3446   /* If first arg is constant, swap the args (changing operation
3447      so value is preserved), for canonicalization.  Don't do this if
3448      the second arg is 0.  */
3449
3450   if (TREE_CONSTANT (primop0)
3451       && !integer_zerop (primop1) && !real_zerop (primop1)
3452       && !fixed_zerop (primop1))
3453     {
3454       tree tem = primop0;
3455       int temi = unsignedp0;
3456       primop0 = primop1;
3457       primop1 = tem;
3458       tem = op0;
3459       op0 = op1;
3460       op1 = tem;
3461       *op0_ptr = op0;
3462       *op1_ptr = op1;
3463       unsignedp0 = unsignedp1;
3464       unsignedp1 = temi;
3465       temi = real1;
3466       real1 = real2;
3467       real2 = temi;
3468
3469       switch (code)
3470         {
3471         case LT_EXPR:
3472           code = GT_EXPR;
3473           break;
3474         case GT_EXPR:
3475           code = LT_EXPR;
3476           break;
3477         case LE_EXPR:
3478           code = GE_EXPR;
3479           break;
3480         case GE_EXPR:
3481           code = LE_EXPR;
3482           break;
3483         default:
3484           break;
3485         }
3486       *rescode_ptr = code;
3487     }
3488
3489   /* If comparing an integer against a constant more bits wide,
3490      maybe we can deduce a value of 1 or 0 independent of the data.
3491      Or else truncate the constant now
3492      rather than extend the variable at run time.
3493
3494      This is only interesting if the constant is the wider arg.
3495      Also, it is not safe if the constant is unsigned and the
3496      variable arg is signed, since in this case the variable
3497      would be sign-extended and then regarded as unsigned.
3498      Our technique fails in this case because the lowest/highest
3499      possible unsigned results don't follow naturally from the
3500      lowest/highest possible values of the variable operand.
3501      For just EQ_EXPR and NE_EXPR there is another technique that
3502      could be used: see if the constant can be faithfully represented
3503      in the other operand's type, by truncating it and reextending it
3504      and see if that preserves the constant's value.  */
3505
3506   if (!real1 && !real2
3507       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3508       && TREE_CODE (primop1) == INTEGER_CST
3509       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3510     {
3511       int min_gt, max_gt, min_lt, max_lt;
3512       tree maxval, minval;
3513       /* 1 if comparison is nominally unsigned.  */
3514       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3515       tree val;
3516
3517       type = c_common_signed_or_unsigned_type (unsignedp0,
3518                                                TREE_TYPE (primop0));
3519
3520       maxval = TYPE_MAX_VALUE (type);
3521       minval = TYPE_MIN_VALUE (type);
3522
3523       if (unsignedp && !unsignedp0)
3524         *restype_ptr = c_common_signed_type (*restype_ptr);
3525
3526       if (TREE_TYPE (primop1) != *restype_ptr)
3527         {
3528           /* Convert primop1 to target type, but do not introduce
3529              additional overflow.  We know primop1 is an int_cst.  */
3530           primop1 = force_fit_type_double (*restype_ptr,
3531                                            tree_to_double_int (primop1),
3532                                            0, TREE_OVERFLOW (primop1));
3533         }
3534       if (type != *restype_ptr)
3535         {
3536           minval = convert (*restype_ptr, minval);
3537           maxval = convert (*restype_ptr, maxval);
3538         }
3539
3540       if (unsignedp && unsignedp0)
3541         {
3542           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3543           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3544           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3545           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3546         }
3547       else
3548         {
3549           min_gt = INT_CST_LT (primop1, minval);
3550           max_gt = INT_CST_LT (primop1, maxval);
3551           min_lt = INT_CST_LT (minval, primop1);
3552           max_lt = INT_CST_LT (maxval, primop1);
3553         }
3554
3555       val = 0;
3556       /* This used to be a switch, but Genix compiler can't handle that.  */
3557       if (code == NE_EXPR)
3558         {
3559           if (max_lt || min_gt)
3560             val = truthvalue_true_node;
3561         }
3562       else if (code == EQ_EXPR)
3563         {
3564           if (max_lt || min_gt)
3565             val = truthvalue_false_node;
3566         }
3567       else if (code == LT_EXPR)
3568         {
3569           if (max_lt)
3570             val = truthvalue_true_node;
3571           if (!min_lt)
3572             val = truthvalue_false_node;
3573         }
3574       else if (code == GT_EXPR)
3575         {
3576           if (min_gt)
3577             val = truthvalue_true_node;
3578           if (!max_gt)
3579             val = truthvalue_false_node;
3580         }
3581       else if (code == LE_EXPR)
3582         {
3583           if (!max_gt)
3584             val = truthvalue_true_node;
3585           if (min_gt)
3586             val = truthvalue_false_node;
3587         }
3588       else if (code == GE_EXPR)
3589         {
3590           if (!min_lt)
3591             val = truthvalue_true_node;
3592           if (max_lt)
3593             val = truthvalue_false_node;
3594         }
3595
3596       /* If primop0 was sign-extended and unsigned comparison specd,
3597          we did a signed comparison above using the signed type bounds.
3598          But the comparison we output must be unsigned.
3599
3600          Also, for inequalities, VAL is no good; but if the signed
3601          comparison had *any* fixed result, it follows that the
3602          unsigned comparison just tests the sign in reverse
3603          (positive values are LE, negative ones GE).
3604          So we can generate an unsigned comparison
3605          against an extreme value of the signed type.  */
3606
3607       if (unsignedp && !unsignedp0)
3608         {
3609           if (val != 0)
3610             switch (code)
3611               {
3612               case LT_EXPR:
3613               case GE_EXPR:
3614                 primop1 = TYPE_MIN_VALUE (type);
3615                 val = 0;
3616                 break;
3617
3618               case LE_EXPR:
3619               case GT_EXPR:
3620                 primop1 = TYPE_MAX_VALUE (type);
3621                 val = 0;
3622                 break;
3623
3624               default:
3625                 break;
3626               }
3627           type = c_common_unsigned_type (type);
3628         }
3629
3630       if (TREE_CODE (primop0) != INTEGER_CST)
3631         {
3632           if (val == truthvalue_false_node)
3633             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3634           if (val == truthvalue_true_node)
3635             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3636         }
3637
3638       if (val != 0)
3639         {
3640           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3641           if (TREE_SIDE_EFFECTS (primop0))
3642             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3643           return val;
3644         }
3645
3646       /* Value is not predetermined, but do the comparison
3647          in the type of the operand that is not constant.
3648          TYPE is already properly set.  */
3649     }
3650
3651   /* If either arg is decimal float and the other is float, find the
3652      proper common type to use for comparison.  */
3653   else if (real1 && real2
3654            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3655                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3656     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3657
3658   else if (real1 && real2
3659            && (TYPE_PRECISION (TREE_TYPE (primop0))
3660                == TYPE_PRECISION (TREE_TYPE (primop1))))
3661     type = TREE_TYPE (primop0);
3662
3663   /* If args' natural types are both narrower than nominal type
3664      and both extend in the same manner, compare them
3665      in the type of the wider arg.
3666      Otherwise must actually extend both to the nominal
3667      common type lest different ways of extending
3668      alter the result.
3669      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
3670
3671   else if (unsignedp0 == unsignedp1 && real1 == real2
3672            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3673            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3674     {
3675       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3676       type = c_common_signed_or_unsigned_type (unsignedp0
3677                                                || TYPE_UNSIGNED (*restype_ptr),
3678                                                type);
3679       /* Make sure shorter operand is extended the right way
3680          to match the longer operand.  */
3681       primop0
3682         = convert (c_common_signed_or_unsigned_type (unsignedp0,
3683                                                      TREE_TYPE (primop0)),
3684                    primop0);
3685       primop1
3686         = convert (c_common_signed_or_unsigned_type (unsignedp1,
3687                                                      TREE_TYPE (primop1)),
3688                    primop1);
3689     }
3690   else
3691     {
3692       /* Here we must do the comparison on the nominal type
3693          using the args exactly as we received them.  */
3694       type = *restype_ptr;
3695       primop0 = op0;
3696       primop1 = op1;
3697
3698       if (!real1 && !real2 && integer_zerop (primop1)
3699           && TYPE_UNSIGNED (*restype_ptr))
3700         {
3701           tree value = 0;
3702           switch (code)
3703             {
3704             case GE_EXPR:
3705               /* All unsigned values are >= 0, so we warn.  However,
3706                  if OP0 is a constant that is >= 0, the signedness of
3707                  the comparison isn't an issue, so suppress the
3708                  warning.  */
3709               if (warn_type_limits && !in_system_header
3710                   && !(TREE_CODE (primop0) == INTEGER_CST
3711                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3712                                                    primop0))))
3713                 warning (OPT_Wtype_limits,
3714                          "comparison of unsigned expression >= 0 is always true");
3715               value = truthvalue_true_node;
3716               break;
3717
3718             case LT_EXPR:
3719               if (warn_type_limits && !in_system_header
3720                   && !(TREE_CODE (primop0) == INTEGER_CST
3721                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3722                                                    primop0))))
3723                 warning (OPT_Wtype_limits,
3724                          "comparison of unsigned expression < 0 is always false");
3725               value = truthvalue_false_node;
3726               break;
3727
3728             default:
3729               break;
3730             }
3731
3732           if (value != 0)
3733             {
3734               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3735               if (TREE_SIDE_EFFECTS (primop0))
3736                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3737                                primop0, value);
3738               return value;
3739             }
3740         }
3741     }
3742
3743   *op0_ptr = convert (type, primop0);
3744   *op1_ptr = convert (type, primop1);
3745
3746   *restype_ptr = truthvalue_type_node;
3747
3748   return 0;
3749 }
3750 \f
3751 /* Return a tree for the sum or difference (RESULTCODE says which)
3752    of pointer PTROP and integer INTOP.  */
3753
3754 tree
3755 pointer_int_sum (location_t loc, enum tree_code resultcode,
3756                  tree ptrop, tree intop)
3757 {
3758   tree size_exp, ret;
3759
3760   /* The result is a pointer of the same type that is being added.  */
3761   tree result_type = TREE_TYPE (ptrop);
3762
3763   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3764     {
3765       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3766                "pointer of type %<void *%> used in arithmetic");
3767       size_exp = integer_one_node;
3768     }
3769   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3770     {
3771       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3772                "pointer to a function used in arithmetic");
3773       size_exp = integer_one_node;
3774     }
3775   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3776     {
3777       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3778                "pointer to member function used in arithmetic");
3779       size_exp = integer_one_node;
3780     }
3781   else
3782     size_exp = size_in_bytes (TREE_TYPE (result_type));
3783
3784   /* We are manipulating pointer values, so we don't need to warn
3785      about relying on undefined signed overflow.  We disable the
3786      warning here because we use integer types so fold won't know that
3787      they are really pointers.  */
3788   fold_defer_overflow_warnings ();
3789
3790   /* If what we are about to multiply by the size of the elements
3791      contains a constant term, apply distributive law
3792      and multiply that constant term separately.
3793      This helps produce common subexpressions.  */
3794   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3795       && !TREE_CONSTANT (intop)
3796       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3797       && TREE_CONSTANT (size_exp)
3798       /* If the constant comes from pointer subtraction,
3799          skip this optimization--it would cause an error.  */
3800       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3801       /* If the constant is unsigned, and smaller than the pointer size,
3802          then we must skip this optimization.  This is because it could cause
3803          an overflow error if the constant is negative but INTOP is not.  */
3804       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3805           || (TYPE_PRECISION (TREE_TYPE (intop))
3806               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3807     {
3808       enum tree_code subcode = resultcode;
3809       tree int_type = TREE_TYPE (intop);
3810       if (TREE_CODE (intop) == MINUS_EXPR)
3811         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3812       /* Convert both subexpression types to the type of intop,
3813          because weird cases involving pointer arithmetic
3814          can result in a sum or difference with different type args.  */
3815       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3816                                subcode, ptrop,
3817                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3818       intop = convert (int_type, TREE_OPERAND (intop, 0));
3819     }
3820
3821   /* Convert the integer argument to a type the same size as sizetype
3822      so the multiply won't overflow spuriously.  */
3823   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3824       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3825     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3826                                              TYPE_UNSIGNED (sizetype)), intop);
3827
3828   /* Replace the integer argument with a suitable product by the object size.
3829      Do this multiplication as signed, then convert to the appropriate type
3830      for the pointer operation and disregard an overflow that occured only
3831      because of the sign-extension change in the latter conversion.  */
3832   {
3833     tree t = build_binary_op (loc,
3834                               MULT_EXPR, intop,
3835                               convert (TREE_TYPE (intop), size_exp), 1);
3836     intop = convert (sizetype, t);
3837     if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3838       intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3839                                   TREE_INT_CST_HIGH (intop));
3840   }
3841
3842   /* Create the sum or difference.  */
3843   if (resultcode == MINUS_EXPR)
3844     intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
3845
3846   ret = fold_build_pointer_plus_loc (loc, ptrop, intop);
3847
3848   fold_undefer_and_ignore_overflow_warnings ();
3849
3850   return ret;
3851 }
3852 \f
3853 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3854    and if NON_CONST is known not to be permitted in an evaluated part
3855    of a constant expression.  */
3856
3857 tree
3858 c_wrap_maybe_const (tree expr, bool non_const)
3859 {
3860   bool nowarning = TREE_NO_WARNING (expr);
3861   location_t loc = EXPR_LOCATION (expr);
3862
3863   /* This should never be called for C++.  */
3864   if (c_dialect_cxx ())
3865     gcc_unreachable ();
3866
3867   /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING.  */
3868   STRIP_TYPE_NOPS (expr);
3869   expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3870   C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3871   if (nowarning)
3872     TREE_NO_WARNING (expr) = 1;
3873   protected_set_expr_location (expr, loc);
3874
3875   return expr;
3876 }
3877
3878 /* Wrap a SAVE_EXPR around EXPR, if appropriate.  Like save_expr, but
3879    for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3880    around the SAVE_EXPR if needed so that c_fully_fold does not need
3881    to look inside SAVE_EXPRs.  */
3882
3883 tree
3884 c_save_expr (tree expr)
3885 {
3886   bool maybe_const = true;
3887   if (c_dialect_cxx ())
3888     return save_expr (expr);
3889   expr = c_fully_fold (expr, false, &maybe_const);
3890   expr = save_expr (expr);
3891   if (!maybe_const)
3892     expr = c_wrap_maybe_const (expr, true);
3893   return expr;
3894 }
3895
3896 /* Return whether EXPR is a declaration whose address can never be
3897    NULL.  */
3898
3899 bool
3900 decl_with_nonnull_addr_p (const_tree expr)
3901 {
3902   return (DECL_P (expr)
3903           && (TREE_CODE (expr) == PARM_DECL
3904               || TREE_CODE (expr) == LABEL_DECL
3905               || !DECL_WEAK (expr)));
3906 }
3907
3908 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3909    or for an `if' or `while' statement or ?..: exp.  It should already
3910    have been validated to be of suitable type; otherwise, a bad
3911    diagnostic may result.
3912
3913    The EXPR is located at LOCATION.
3914
3915    This preparation consists of taking the ordinary
3916    representation of an expression expr and producing a valid tree
3917    boolean expression describing whether expr is nonzero.  We could
3918    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3919    but we optimize comparisons, &&, ||, and !.
3920
3921    The resulting type should always be `truthvalue_type_node'.  */
3922
3923 tree
3924 c_common_truthvalue_conversion (location_t location, tree expr)
3925 {
3926   switch (TREE_CODE (expr))
3927     {
3928     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3929     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3930     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3931     case ORDERED_EXPR: case UNORDERED_EXPR:
3932       if (TREE_TYPE (expr) == truthvalue_type_node)
3933         return expr;
3934       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3935                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3936       goto ret;
3937
3938     case TRUTH_ANDIF_EXPR:
3939     case TRUTH_ORIF_EXPR:
3940     case TRUTH_AND_EXPR:
3941     case TRUTH_OR_EXPR:
3942     case TRUTH_XOR_EXPR:
3943       if (TREE_TYPE (expr) == truthvalue_type_node)
3944         return expr;
3945       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3946                      c_common_truthvalue_conversion (location,
3947                                                      TREE_OPERAND (expr, 0)),
3948                      c_common_truthvalue_conversion (location,
3949                                                      TREE_OPERAND (expr, 1)));
3950       goto ret;
3951
3952     case TRUTH_NOT_EXPR:
3953       if (TREE_TYPE (expr) == truthvalue_type_node)
3954         return expr;
3955       expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3956                      c_common_truthvalue_conversion (location,
3957                                                      TREE_OPERAND (expr, 0)));
3958       goto ret;
3959
3960     case ERROR_MARK:
3961       return expr;
3962
3963     case INTEGER_CST:
3964       return integer_zerop (expr) ? truthvalue_false_node
3965                                   : truthvalue_true_node;
3966
3967     case REAL_CST:
3968       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3969              ? truthvalue_true_node
3970              : truthvalue_false_node;
3971
3972     case FIXED_CST:
3973       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3974                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3975              ? truthvalue_true_node
3976              : truthvalue_false_node;
3977
3978     case FUNCTION_DECL:
3979       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3980       /* Fall through.  */
3981
3982     case ADDR_EXPR:
3983       {
3984         tree inner = TREE_OPERAND (expr, 0);
3985         if (decl_with_nonnull_addr_p (inner))
3986           {
3987             /* Common Ada/Pascal programmer's mistake.  */
3988             warning_at (location,
3989                         OPT_Waddress,
3990                         "the address of %qD will always evaluate as %<true%>",
3991                         inner);
3992             return truthvalue_true_node;
3993           }
3994         break;
3995       }
3996
3997     case COMPLEX_EXPR:
3998       expr = build_binary_op (EXPR_LOCATION (expr),
3999                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4000                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4001                 c_common_truthvalue_conversion (location,
4002                                                 TREE_OPERAND (expr, 0)),
4003                 c_common_truthvalue_conversion (location,
4004                                                 TREE_OPERAND (expr, 1)),
4005                               0);
4006       goto ret;
4007
4008     case NEGATE_EXPR:
4009     case ABS_EXPR:
4010     case FLOAT_EXPR:
4011     case EXCESS_PRECISION_EXPR:
4012       /* These don't change whether an object is nonzero or zero.  */
4013       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4014
4015     case LROTATE_EXPR:
4016     case RROTATE_EXPR:
4017       /* These don't change whether an object is zero or nonzero, but
4018          we can't ignore them if their second arg has side-effects.  */
4019       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4020         {
4021           expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
4022                          TREE_OPERAND (expr, 1),
4023                          c_common_truthvalue_conversion
4024                          (location, TREE_OPERAND (expr, 0)));
4025           goto ret;
4026         }
4027       else
4028         return c_common_truthvalue_conversion (location,
4029                                                TREE_OPERAND (expr, 0));
4030
4031     case COND_EXPR:
4032       /* Distribute the conversion into the arms of a COND_EXPR.  */
4033       if (c_dialect_cxx ())
4034         {
4035           tree op1 = TREE_OPERAND (expr, 1);
4036           tree op2 = TREE_OPERAND (expr, 2);
4037           /* In C++ one of the arms might have void type if it is throw.  */
4038           if (!VOID_TYPE_P (TREE_TYPE (op1)))
4039             op1 = c_common_truthvalue_conversion (location, op1);
4040           if (!VOID_TYPE_P (TREE_TYPE (op2)))
4041             op2 = c_common_truthvalue_conversion (location, op2);
4042           expr = fold_build3_loc (location, COND_EXPR, truthvalue_type_node,
4043                                   TREE_OPERAND (expr, 0), op1, op2);
4044           goto ret;
4045         }
4046       else
4047         {
4048           /* Folding will happen later for C.  */
4049           expr = build3 (COND_EXPR, truthvalue_type_node,
4050                          TREE_OPERAND (expr, 0),
4051                          c_common_truthvalue_conversion (location,
4052                                                          TREE_OPERAND (expr, 1)),
4053                          c_common_truthvalue_conversion (location,
4054                                                          TREE_OPERAND (expr, 2)));
4055           goto ret;
4056         }
4057
4058     CASE_CONVERT:
4059       {
4060         tree totype = TREE_TYPE (expr);
4061         tree fromtype = TREE_TYPE (TREE_OPERAND (expr, 0));
4062
4063         /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4064            since that affects how `default_conversion' will behave.  */
4065         if (TREE_CODE (totype) == REFERENCE_TYPE
4066             || TREE_CODE (fromtype) == REFERENCE_TYPE)
4067           break;
4068         /* Don't strip a conversion from C++0x scoped enum, since they
4069            don't implicitly convert to other types.  */
4070         if (TREE_CODE (fromtype) == ENUMERAL_TYPE
4071             && ENUM_IS_SCOPED (fromtype))
4072           break;
4073         /* If this isn't narrowing the argument, we can ignore it.  */
4074         if (TYPE_PRECISION (totype) >= TYPE_PRECISION (fromtype))
4075           return c_common_truthvalue_conversion (location,
4076                                                  TREE_OPERAND (expr, 0));
4077       }
4078       break;
4079
4080     case MODIFY_EXPR:
4081       if (!TREE_NO_WARNING (expr)
4082           && warn_parentheses)
4083         {
4084           warning (OPT_Wparentheses,
4085                    "suggest parentheses around assignment used as truth value");
4086           TREE_NO_WARNING (expr) = 1;
4087         }
4088       break;
4089
4090     default:
4091       break;
4092     }
4093
4094   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4095     {
4096       tree t = (in_late_binary_op ? save_expr (expr) : c_save_expr (expr));
4097       expr = (build_binary_op
4098               (EXPR_LOCATION (expr),
4099                (TREE_SIDE_EFFECTS (expr)
4100                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4101         c_common_truthvalue_conversion
4102                (location,
4103                 build_unary_op (location, REALPART_EXPR, t, 0)),
4104         c_common_truthvalue_conversion
4105                (location,
4106                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
4107                0));
4108       goto ret;
4109     }
4110
4111   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
4112     {
4113       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
4114                                           FCONST0 (TYPE_MODE
4115                                                    (TREE_TYPE (expr))));
4116       return build_binary_op (location, NE_EXPR, expr, fixed_zero_node, 1);
4117     }
4118   else
4119     return build_binary_op (location, NE_EXPR, expr, integer_zero_node, 1);
4120
4121  ret:
4122   protected_set_expr_location (expr, location);
4123   return expr;
4124 }
4125 \f
4126 static void def_builtin_1  (enum built_in_function fncode,
4127                             const char *name,
4128                             enum built_in_class fnclass,
4129                             tree fntype, tree libtype,
4130                             bool both_p, bool fallback_p, bool nonansi_p,
4131                             tree fnattrs, bool implicit_p);
4132
4133
4134 /* Apply the TYPE_QUALS to the new DECL.  */
4135
4136 void
4137 c_apply_type_quals_to_decl (int type_quals, tree decl)
4138 {
4139   tree type = TREE_TYPE (decl);
4140
4141   if (type == error_mark_node)
4142     return;
4143
4144   if ((type_quals & TYPE_QUAL_CONST)
4145       || (type && TREE_CODE (type) == REFERENCE_TYPE))
4146     /* We used to check TYPE_NEEDS_CONSTRUCTING here, but now a constexpr
4147        constructor can produce constant init, so rely on cp_finish_decl to
4148        clear TREE_READONLY if the variable has non-constant init.  */
4149     TREE_READONLY (decl) = 1;
4150   if (type_quals & TYPE_QUAL_VOLATILE)
4151     {
4152       TREE_SIDE_EFFECTS (decl) = 1;
4153       TREE_THIS_VOLATILE (decl) = 1;
4154     }
4155   if (type_quals & TYPE_QUAL_RESTRICT)
4156     {
4157       while (type && TREE_CODE (type) == ARRAY_TYPE)
4158         /* Allow 'restrict' on arrays of pointers.
4159            FIXME currently we just ignore it.  */
4160         type = TREE_TYPE (type);
4161       if (!type
4162           || !POINTER_TYPE_P (type)
4163           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
4164         error ("invalid use of %<restrict%>");
4165     }
4166 }
4167
4168 /* Hash function for the problem of multiple type definitions in
4169    different files.  This must hash all types that will compare
4170    equal via comptypes to the same value.  In practice it hashes
4171    on some of the simple stuff and leaves the details to comptypes.  */
4172
4173 static hashval_t
4174 c_type_hash (const void *p)
4175 {
4176   int n_elements;
4177   int shift, size;
4178   const_tree const t = (const_tree) p;
4179   tree t2;
4180   switch (TREE_CODE (t))
4181     {
4182     /* For pointers, hash on pointee type plus some swizzling.  */
4183     case POINTER_TYPE:
4184       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
4185     /* Hash on number of elements and total size.  */
4186     case ENUMERAL_TYPE:
4187       shift = 3;
4188       t2 = TYPE_VALUES (t);
4189       break;
4190     case RECORD_TYPE:
4191       shift = 0;
4192       t2 = TYPE_FIELDS (t);
4193       break;
4194     case QUAL_UNION_TYPE:
4195       shift = 1;
4196       t2 = TYPE_FIELDS (t);
4197       break;
4198     case UNION_TYPE:
4199       shift = 2;
4200       t2 = TYPE_FIELDS (t);
4201       break;
4202     default:
4203       gcc_unreachable ();
4204     }
4205   /* FIXME: We want to use a DECL_CHAIN iteration method here, but
4206      TYPE_VALUES of ENUMERAL_TYPEs is stored as a TREE_LIST.  */
4207   n_elements = list_length (t2);
4208   /* We might have a VLA here.  */
4209   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
4210     size = 0;
4211   else
4212     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
4213   return ((size << 24) | (n_elements << shift));
4214 }
4215
4216 static GTY((param_is (union tree_node))) htab_t type_hash_table;
4217
4218 /* Return the typed-based alias set for T, which may be an expression
4219    or a type.  Return -1 if we don't do anything special.  */
4220
4221 alias_set_type
4222 c_common_get_alias_set (tree t)
4223 {
4224   tree u;
4225   PTR *slot;
4226
4227   /* For VLAs, use the alias set of the element type rather than the
4228      default of alias set 0 for types compared structurally.  */
4229   if (TYPE_P (t) && TYPE_STRUCTURAL_EQUALITY_P (t))
4230     {
4231       if (TREE_CODE (t) == ARRAY_TYPE)
4232         return get_alias_set (TREE_TYPE (t));
4233       return -1;
4234     }
4235
4236   /* Permit type-punning when accessing a union, provided the access
4237      is directly through the union.  For example, this code does not
4238      permit taking the address of a union member and then storing
4239      through it.  Even the type-punning allowed here is a GCC
4240      extension, albeit a common and useful one; the C standard says
4241      that such accesses have implementation-defined behavior.  */
4242   for (u = t;
4243        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4244        u = TREE_OPERAND (u, 0))
4245     if (TREE_CODE (u) == COMPONENT_REF
4246         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4247       return 0;
4248
4249   /* That's all the expressions we handle specially.  */
4250   if (!TYPE_P (t))
4251     return -1;
4252
4253   /* The C standard guarantees that any object may be accessed via an
4254      lvalue that has character type.  */
4255   if (t == char_type_node
4256       || t == signed_char_type_node
4257       || t == unsigned_char_type_node)
4258     return 0;
4259
4260   /* The C standard specifically allows aliasing between signed and
4261      unsigned variants of the same type.  We treat the signed
4262      variant as canonical.  */
4263   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
4264     {
4265       tree t1 = c_common_signed_type (t);
4266
4267       /* t1 == t can happen for boolean nodes which are always unsigned.  */
4268       if (t1 != t)
4269         return get_alias_set (t1);
4270     }
4271
4272   /* Handle the case of multiple type nodes referring to "the same" type,
4273      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
4274      C90 is handled.  (In C99 type compatibility is not transitive, which
4275      complicates things mightily. The alias set splay trees can theoretically
4276      represent this, but insertion is tricky when you consider all the
4277      different orders things might arrive in.) */
4278
4279   if (c_language != clk_c || flag_isoc99)
4280     return -1;
4281
4282   /* Save time if there's only one input file.  */
4283   if (num_in_fnames == 1)
4284     return -1;
4285
4286   /* Pointers need special handling if they point to any type that
4287      needs special handling (below).  */
4288   if (TREE_CODE (t) == POINTER_TYPE)
4289     {
4290       tree t2;
4291       /* Find bottom type under any nested POINTERs.  */
4292       for (t2 = TREE_TYPE (t);
4293            TREE_CODE (t2) == POINTER_TYPE;
4294            t2 = TREE_TYPE (t2))
4295         ;
4296       if (TREE_CODE (t2) != RECORD_TYPE
4297           && TREE_CODE (t2) != ENUMERAL_TYPE
4298           && TREE_CODE (t2) != QUAL_UNION_TYPE
4299           && TREE_CODE (t2) != UNION_TYPE)
4300         return -1;
4301       if (TYPE_SIZE (t2) == 0)
4302         return -1;
4303     }
4304   /* These are the only cases that need special handling.  */
4305   if (TREE_CODE (t) != RECORD_TYPE
4306       && TREE_CODE (t) != ENUMERAL_TYPE
4307       && TREE_CODE (t) != QUAL_UNION_TYPE
4308       && TREE_CODE (t) != UNION_TYPE
4309       && TREE_CODE (t) != POINTER_TYPE)
4310     return -1;
4311   /* Undefined? */
4312   if (TYPE_SIZE (t) == 0)
4313     return -1;
4314
4315   /* Look up t in hash table.  Only one of the compatible types within each
4316      alias set is recorded in the table.  */
4317   if (!type_hash_table)
4318     type_hash_table = htab_create_ggc (1021, c_type_hash,
4319             (htab_eq) lang_hooks.types_compatible_p,
4320             NULL);
4321   slot = htab_find_slot (type_hash_table, t, INSERT);
4322   if (*slot != NULL)
4323     {
4324       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
4325       return TYPE_ALIAS_SET ((tree)*slot);
4326     }
4327   else
4328     /* Our caller will assign and record (in t) a new alias set; all we need
4329        to do is remember t in the hash table.  */
4330     *slot = t;
4331
4332   return -1;
4333 }
4334 \f
4335 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where
4336    the second parameter indicates which OPERATOR is being applied.
4337    The COMPLAIN flag controls whether we should diagnose possibly
4338    ill-formed constructs or not.  LOC is the location of the SIZEOF or
4339    TYPEOF operator.  */
4340
4341 tree
4342 c_sizeof_or_alignof_type (location_t loc,
4343                           tree type, bool is_sizeof, int complain)
4344 {
4345   const char *op_name;
4346   tree value = NULL;
4347   enum tree_code type_code = TREE_CODE (type);
4348
4349   op_name = is_sizeof ? "sizeof" : "__alignof__";
4350
4351   if (type_code == FUNCTION_TYPE)
4352     {
4353       if (is_sizeof)
4354         {
4355           if (complain && (pedantic || warn_pointer_arith))
4356             pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4357                      "invalid application of %<sizeof%> to a function type");
4358           else if (!complain)
4359             return error_mark_node;
4360           value = size_one_node;
4361         }
4362       else
4363         {
4364           if (complain)
4365             {
4366               if (c_dialect_cxx ())
4367                 pedwarn (loc, OPT_pedantic, "ISO C++ does not permit "
4368                          "%<alignof%> applied to a function type");
4369               else
4370                 pedwarn (loc, OPT_pedantic, "ISO C does not permit "
4371                          "%<_Alignof%> applied to a function type");
4372             }
4373           value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
4374         }
4375     }
4376   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
4377     {
4378       if (type_code == VOID_TYPE
4379           && complain && (pedantic || warn_pointer_arith))
4380         pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
4381                  "invalid application of %qs to a void type", op_name);
4382       else if (!complain)
4383         return error_mark_node;
4384       value = size_one_node;
4385     }
4386   else if (!COMPLETE_TYPE_P (type)
4387            && (!c_dialect_cxx () || is_sizeof || type_code != ARRAY_TYPE))
4388     {
4389       if (complain)
4390         error_at (loc, "invalid application of %qs to incomplete type %qT",
4391                   op_name, type);
4392       return error_mark_node;
4393     }
4394   else if (c_dialect_cxx () && type_code == ARRAY_TYPE
4395            && !COMPLETE_TYPE_P (TREE_TYPE (type)))
4396     {
4397       if (complain)
4398         error_at (loc, "invalid application of %qs to array type %qT of "
4399                   "incomplete element type", op_name, type);
4400       return error_mark_node;
4401     }
4402   else
4403     {
4404       if (is_sizeof)
4405         /* Convert in case a char is more than one unit.  */
4406         value = size_binop_loc (loc, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
4407                                 size_int (TYPE_PRECISION (char_type_node)
4408                                           / BITS_PER_UNIT));
4409       else
4410         value = size_int (TYPE_ALIGN_UNIT (type));
4411     }
4412
4413   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
4414      TYPE_IS_SIZETYPE means that certain things (like overflow) will
4415      never happen.  However, this node should really have type
4416      `size_t', which is just a typedef for an ordinary integer type.  */
4417   value = fold_convert_loc (loc, size_type_node, value);
4418   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
4419
4420   return value;
4421 }
4422
4423 /* Implement the __alignof keyword: Return the minimum required
4424    alignment of EXPR, measured in bytes.  For VAR_DECLs,
4425    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
4426    from an "aligned" __attribute__ specification).  LOC is the
4427    location of the ALIGNOF operator.  */
4428
4429 tree
4430 c_alignof_expr (location_t loc, tree expr)
4431 {
4432   tree t;
4433
4434   if (VAR_OR_FUNCTION_DECL_P (expr))
4435     t = size_int (DECL_ALIGN_UNIT (expr));
4436
4437   else if (TREE_CODE (expr) == COMPONENT_REF
4438            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
4439     {
4440       error_at (loc, "%<__alignof%> applied to a bit-field");
4441       t = size_one_node;
4442     }
4443   else if (TREE_CODE (expr) == COMPONENT_REF
4444            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
4445     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
4446
4447   else if (TREE_CODE (expr) == INDIRECT_REF)
4448     {
4449       tree t = TREE_OPERAND (expr, 0);
4450       tree best = t;
4451       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4452
4453       while (CONVERT_EXPR_P (t)
4454              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
4455         {
4456           int thisalign;
4457
4458           t = TREE_OPERAND (t, 0);
4459           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
4460           if (thisalign > bestalign)
4461             best = t, bestalign = thisalign;
4462         }
4463       return c_alignof (loc, TREE_TYPE (TREE_TYPE (best)));
4464     }
4465   else
4466     return c_alignof (loc, TREE_TYPE (expr));
4467
4468   return fold_convert_loc (loc, size_type_node, t);
4469 }
4470 \f
4471 /* Handle C and C++ default attributes.  */
4472
4473 enum built_in_attribute
4474 {
4475 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4476 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4477 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4478 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4479 #include "builtin-attrs.def"
4480 #undef DEF_ATTR_NULL_TREE
4481 #undef DEF_ATTR_INT
4482 #undef DEF_ATTR_IDENT
4483 #undef DEF_ATTR_TREE_LIST
4484   ATTR_LAST
4485 };
4486
4487 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
4488
4489 static void c_init_attributes (void);
4490
4491 enum c_builtin_type
4492 {
4493 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
4494 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
4495 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
4496 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
4497 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4498 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4499 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
4500 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
4501 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
4502 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
4503 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
4504 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
4505 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
4506 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
4507 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
4508   NAME,
4509 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
4510 #include "builtin-types.def"
4511 #undef DEF_PRIMITIVE_TYPE
4512 #undef DEF_FUNCTION_TYPE_0
4513 #undef DEF_FUNCTION_TYPE_1
4514 #undef DEF_FUNCTION_TYPE_2
4515 #undef DEF_FUNCTION_TYPE_3
4516 #undef DEF_FUNCTION_TYPE_4
4517 #undef DEF_FUNCTION_TYPE_5
4518 #undef DEF_FUNCTION_TYPE_6
4519 #undef DEF_FUNCTION_TYPE_7
4520 #undef DEF_FUNCTION_TYPE_VAR_0
4521 #undef DEF_FUNCTION_TYPE_VAR_1
4522 #undef DEF_FUNCTION_TYPE_VAR_2
4523 #undef DEF_FUNCTION_TYPE_VAR_3
4524 #undef DEF_FUNCTION_TYPE_VAR_4
4525 #undef DEF_FUNCTION_TYPE_VAR_5
4526 #undef DEF_POINTER_TYPE
4527   BT_LAST
4528 };
4529
4530 typedef enum c_builtin_type builtin_type;
4531
4532 /* A temporary array for c_common_nodes_and_builtins.  Used in
4533    communication with def_fn_type.  */
4534 static tree builtin_types[(int) BT_LAST + 1];
4535
4536 /* A helper function for c_common_nodes_and_builtins.  Build function type
4537    for DEF with return type RET and N arguments.  If VAR is true, then the
4538    function should be variadic after those N arguments.
4539
4540    Takes special care not to ICE if any of the types involved are
4541    error_mark_node, which indicates that said type is not in fact available
4542    (see builtin_type_for_size).  In which case the function type as a whole
4543    should be error_mark_node.  */
4544
4545 static void
4546 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
4547 {
4548   tree t;
4549   tree *args = XALLOCAVEC (tree, n);
4550   va_list list;
4551   int i;
4552
4553   va_start (list, n);
4554   for (i = 0; i < n; ++i)
4555     {
4556       builtin_type a = (builtin_type) va_arg (list, int);
4557       t = builtin_types[a];
4558       if (t == error_mark_node)
4559         goto egress;
4560       args[i] = t;
4561     }
4562
4563   t = builtin_types[ret];
4564   if (t == error_mark_node)
4565     goto egress;
4566   if (var)
4567     t = build_varargs_function_type_array (t, n, args);
4568   else
4569     t = build_function_type_array (t, n, args);
4570
4571  egress:
4572   builtin_types[def] = t;
4573   va_end (list);
4574 }
4575
4576 /* Build builtin functions common to both C and C++ language
4577    frontends.  */
4578
4579 static void
4580 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4581 {
4582 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4583   builtin_types[ENUM] = VALUE;
4584 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4585   def_fn_type (ENUM, RETURN, 0, 0);
4586 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4587   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4588 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4589   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4590 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4591   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4592 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4593   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4594 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4595   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4596 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4597                             ARG6)                                       \
4598   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4599 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4600                             ARG6, ARG7)                                 \
4601   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4602 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4603   def_fn_type (ENUM, RETURN, 1, 0);
4604 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4605   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4606 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4607   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4608 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4609   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4610 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4611   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4612 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4613   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4614 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4615   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4616
4617 #include "builtin-types.def"
4618
4619 #undef DEF_PRIMITIVE_TYPE
4620 #undef DEF_FUNCTION_TYPE_1
4621 #undef DEF_FUNCTION_TYPE_2
4622 #undef DEF_FUNCTION_TYPE_3
4623 #undef DEF_FUNCTION_TYPE_4
4624 #undef DEF_FUNCTION_TYPE_5
4625 #undef DEF_FUNCTION_TYPE_6
4626 #undef DEF_FUNCTION_TYPE_VAR_0
4627 #undef DEF_FUNCTION_TYPE_VAR_1
4628 #undef DEF_FUNCTION_TYPE_VAR_2
4629 #undef DEF_FUNCTION_TYPE_VAR_3
4630 #undef DEF_FUNCTION_TYPE_VAR_4
4631 #undef DEF_FUNCTION_TYPE_VAR_5
4632 #undef DEF_POINTER_TYPE
4633   builtin_types[(int) BT_LAST] = NULL_TREE;
4634
4635   c_init_attributes ();
4636
4637 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4638                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4639   if (NAME && COND)                                                     \
4640     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4641                    builtin_types[(int) TYPE],                           \
4642                    builtin_types[(int) LIBTYPE],                        \
4643                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4644                    built_in_attributes[(int) ATTRS], IMPLICIT);
4645 #include "builtins.def"
4646 #undef DEF_BUILTIN
4647
4648   targetm.init_builtins ();
4649
4650   build_common_builtin_nodes ();
4651
4652   if (flag_mudflap)
4653     mudflap_init ();
4654 }
4655
4656 /* Like get_identifier, but avoid warnings about null arguments when
4657    the argument may be NULL for targets where GCC lacks stdint.h type
4658    information.  */
4659
4660 static inline tree
4661 c_get_ident (const char *id)
4662 {
4663   return get_identifier (id);
4664 }
4665
4666 /* Build tree nodes and builtin functions common to both C and C++ language
4667    frontends.  */
4668
4669 void
4670 c_common_nodes_and_builtins (void)
4671 {
4672   int char16_type_size;
4673   int char32_type_size;
4674   int wchar_type_size;
4675   tree array_domain_type;
4676   tree va_list_ref_type_node;
4677   tree va_list_arg_type_node;
4678
4679   build_common_tree_nodes (flag_signed_char, flag_short_double);
4680
4681   /* Define `int' and `char' first so that dbx will output them first.  */
4682   record_builtin_type (RID_INT, NULL, integer_type_node);
4683   record_builtin_type (RID_CHAR, "char", char_type_node);
4684
4685   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4686      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4687      but not C.  Are the conditionals here needed?  */
4688   if (c_dialect_cxx ())
4689     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4690   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4691   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4692   record_builtin_type (RID_MAX, "long unsigned int",
4693                        long_unsigned_type_node);
4694   if (int128_integer_type_node != NULL_TREE)
4695     {
4696       record_builtin_type (RID_INT128, "__int128",
4697                            int128_integer_type_node);
4698       record_builtin_type (RID_MAX, "__int128 unsigned",
4699                            int128_unsigned_type_node);
4700     }
4701   if (c_dialect_cxx ())
4702     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4703   record_builtin_type (RID_MAX, "long long int",
4704                        long_long_integer_type_node);
4705   record_builtin_type (RID_MAX, "long long unsigned int",
4706                        long_long_unsigned_type_node);
4707   if (c_dialect_cxx ())
4708     record_builtin_type (RID_MAX, "long long unsigned",
4709                          long_long_unsigned_type_node);
4710   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4711   record_builtin_type (RID_MAX, "short unsigned int",
4712                        short_unsigned_type_node);
4713   if (c_dialect_cxx ())
4714     record_builtin_type (RID_MAX, "unsigned short",
4715                          short_unsigned_type_node);
4716
4717   /* Define both `signed char' and `unsigned char'.  */
4718   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4719   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4720
4721   /* These are types that c_common_type_for_size and
4722      c_common_type_for_mode use.  */
4723   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4724                                          TYPE_DECL, NULL_TREE,
4725                                          intQI_type_node));
4726   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4727                                          TYPE_DECL, NULL_TREE,
4728                                          intHI_type_node));
4729   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4730                                          TYPE_DECL, NULL_TREE,
4731                                          intSI_type_node));
4732   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4733                                          TYPE_DECL, NULL_TREE,
4734                                          intDI_type_node));
4735 #if HOST_BITS_PER_WIDE_INT >= 64
4736   if (targetm.scalar_mode_supported_p (TImode))
4737     lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4738                                            TYPE_DECL,
4739                                            get_identifier ("__int128_t"),
4740                                            intTI_type_node));
4741 #endif
4742   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4743                                          TYPE_DECL, NULL_TREE,
4744                                          unsigned_intQI_type_node));
4745   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4746                                          TYPE_DECL, NULL_TREE,
4747                                          unsigned_intHI_type_node));
4748   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4749                                          TYPE_DECL, NULL_TREE,
4750                                          unsigned_intSI_type_node));
4751   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4752                                          TYPE_DECL, NULL_TREE,
4753                                          unsigned_intDI_type_node));
4754 #if HOST_BITS_PER_WIDE_INT >= 64
4755   if (targetm.scalar_mode_supported_p (TImode))
4756     lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4757                                            TYPE_DECL,
4758                                            get_identifier ("__uint128_t"),
4759                                            unsigned_intTI_type_node));
4760 #endif
4761
4762   /* Create the widest literal types.  */
4763   widest_integer_literal_type_node
4764     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4765   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4766                                          TYPE_DECL, NULL_TREE,
4767                                          widest_integer_literal_type_node));
4768
4769   widest_unsigned_literal_type_node
4770     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4771   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4772                                          TYPE_DECL, NULL_TREE,
4773                                          widest_unsigned_literal_type_node));
4774
4775   signed_size_type_node = c_common_signed_type (size_type_node);
4776
4777   pid_type_node =
4778     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4779
4780   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4781   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4782   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4783
4784   /* Only supported decimal floating point extension if the target
4785      actually supports underlying modes. */
4786   if (targetm.scalar_mode_supported_p (SDmode)
4787       && targetm.scalar_mode_supported_p (DDmode)
4788       && targetm.scalar_mode_supported_p (TDmode))
4789     {
4790       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4791       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4792       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4793     }
4794
4795   if (targetm.fixed_point_supported_p ())
4796     {
4797       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4798       record_builtin_type (RID_FRACT, NULL, fract_type_node);
4799       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4800       record_builtin_type (RID_MAX, "long long _Fract",
4801                            long_long_fract_type_node);
4802       record_builtin_type (RID_MAX, "unsigned short _Fract",
4803                            unsigned_short_fract_type_node);
4804       record_builtin_type (RID_MAX, "unsigned _Fract",
4805                            unsigned_fract_type_node);
4806       record_builtin_type (RID_MAX, "unsigned long _Fract",
4807                            unsigned_long_fract_type_node);
4808       record_builtin_type (RID_MAX, "unsigned long long _Fract",
4809                            unsigned_long_long_fract_type_node);
4810       record_builtin_type (RID_MAX, "_Sat short _Fract",
4811                            sat_short_fract_type_node);
4812       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4813       record_builtin_type (RID_MAX, "_Sat long _Fract",
4814                            sat_long_fract_type_node);
4815       record_builtin_type (RID_MAX, "_Sat long long _Fract",
4816                            sat_long_long_fract_type_node);
4817       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4818                            sat_unsigned_short_fract_type_node);
4819       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4820                            sat_unsigned_fract_type_node);
4821       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4822                            sat_unsigned_long_fract_type_node);
4823       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4824                            sat_unsigned_long_long_fract_type_node);
4825       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4826       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4827       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4828       record_builtin_type (RID_MAX, "long long _Accum",
4829                            long_long_accum_type_node);
4830       record_builtin_type (RID_MAX, "unsigned short _Accum",
4831                            unsigned_short_accum_type_node);
4832       record_builtin_type (RID_MAX, "unsigned _Accum",
4833                            unsigned_accum_type_node);
4834       record_builtin_type (RID_MAX, "unsigned long _Accum",
4835                            unsigned_long_accum_type_node);
4836       record_builtin_type (RID_MAX, "unsigned long long _Accum",
4837                            unsigned_long_long_accum_type_node);
4838       record_builtin_type (RID_MAX, "_Sat short _Accum",
4839                            sat_short_accum_type_node);
4840       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4841       record_builtin_type (RID_MAX, "_Sat long _Accum",
4842                            sat_long_accum_type_node);
4843       record_builtin_type (RID_MAX, "_Sat long long _Accum",
4844                           sat_long_long_accum_type_node);
4845       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4846                            sat_unsigned_short_accum_type_node);
4847       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4848                            sat_unsigned_accum_type_node);
4849       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4850                            sat_unsigned_long_accum_type_node);
4851       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4852                            sat_unsigned_long_long_accum_type_node);
4853
4854     }
4855
4856   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4857                                          TYPE_DECL,
4858                                          get_identifier ("complex int"),
4859                                          complex_integer_type_node));
4860   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4861                                          TYPE_DECL,
4862                                          get_identifier ("complex float"),
4863                                          complex_float_type_node));
4864   lang_hooks.decls.pushdecl (build_decl (UNKNOWN_LOCATION,
4865                                          TYPE_DECL,
4866                                          get_identifier ("complex double"),
4867                                          complex_double_type_node));
4868   lang_hooks.decls.pushdecl
4869     (build_decl (UNKNOWN_LOCATION,
4870                  TYPE_DECL, get_identifier ("complex long double"),
4871                  complex_long_double_type_node));
4872
4873   if (c_dialect_cxx ())
4874     /* For C++, make fileptr_type_node a distinct void * type until
4875        FILE type is defined.  */
4876     fileptr_type_node = build_variant_type_copy (ptr_type_node);
4877
4878   record_builtin_type (RID_VOID, NULL, void_type_node);
4879
4880   /* Set the TYPE_NAME for any variants that were built before
4881      record_builtin_type gave names to the built-in types. */
4882   {
4883     tree void_name = TYPE_NAME (void_type_node);
4884     TYPE_NAME (void_type_node) = NULL_TREE;
4885     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4886       = void_name;
4887     TYPE_NAME (void_type_node) = void_name;
4888   }
4889
4890   /* This node must not be shared.  */
4891   void_zero_node = make_node (INTEGER_CST);
4892   TREE_TYPE (void_zero_node) = void_type_node;
4893
4894   void_list_node = build_void_list_node ();
4895
4896   /* Make a type to be the domain of a few array types
4897      whose domains don't really matter.
4898      200 is small enough that it always fits in size_t
4899      and large enough that it can hold most function names for the
4900      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
4901   array_domain_type = build_index_type (size_int (200));
4902
4903   /* Make a type for arrays of characters.
4904      With luck nothing will ever really depend on the length of this
4905      array type.  */
4906   char_array_type_node
4907     = build_array_type (char_type_node, array_domain_type);
4908
4909   /* Likewise for arrays of ints.  */
4910   int_array_type_node
4911     = build_array_type (integer_type_node, array_domain_type);
4912
4913   string_type_node = build_pointer_type (char_type_node);
4914   const_string_type_node
4915     = build_pointer_type (build_qualified_type
4916                           (char_type_node, TYPE_QUAL_CONST));
4917
4918   /* This is special for C++ so functions can be overloaded.  */
4919   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4920   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4921   wchar_type_size = TYPE_PRECISION (wchar_type_node);
4922   underlying_wchar_type_node = wchar_type_node;
4923   if (c_dialect_cxx ())
4924     {
4925       if (TYPE_UNSIGNED (wchar_type_node))
4926         wchar_type_node = make_unsigned_type (wchar_type_size);
4927       else
4928         wchar_type_node = make_signed_type (wchar_type_size);
4929       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4930     }
4931
4932   /* This is for wide string constants.  */
4933   wchar_array_type_node
4934     = build_array_type (wchar_type_node, array_domain_type);
4935
4936   /* Define 'char16_t'.  */
4937   char16_type_node = get_identifier (CHAR16_TYPE);
4938   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4939   char16_type_size = TYPE_PRECISION (char16_type_node);
4940   if (c_dialect_cxx ())
4941     {
4942       char16_type_node = make_unsigned_type (char16_type_size);
4943
4944       if (cxx_dialect == cxx0x)
4945         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4946     }
4947
4948   /* This is for UTF-16 string constants.  */
4949   char16_array_type_node
4950     = build_array_type (char16_type_node, array_domain_type);
4951
4952   /* Define 'char32_t'.  */
4953   char32_type_node = get_identifier (CHAR32_TYPE);
4954   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4955   char32_type_size = TYPE_PRECISION (char32_type_node);
4956   if (c_dialect_cxx ())
4957     {
4958       char32_type_node = make_unsigned_type (char32_type_size);
4959
4960       if (cxx_dialect == cxx0x)
4961         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4962     }
4963
4964   /* This is for UTF-32 string constants.  */
4965   char32_array_type_node
4966     = build_array_type (char32_type_node, array_domain_type);
4967
4968   wint_type_node =
4969     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4970
4971   intmax_type_node =
4972     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4973   uintmax_type_node =
4974     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4975
4976   if (SIG_ATOMIC_TYPE)
4977     sig_atomic_type_node =
4978       TREE_TYPE (identifier_global_value (c_get_ident (SIG_ATOMIC_TYPE)));
4979   if (INT8_TYPE)
4980     int8_type_node =
4981       TREE_TYPE (identifier_global_value (c_get_ident (INT8_TYPE)));
4982   if (INT16_TYPE)
4983     int16_type_node =
4984       TREE_TYPE (identifier_global_value (c_get_ident (INT16_TYPE)));
4985   if (INT32_TYPE)
4986     int32_type_node =
4987       TREE_TYPE (identifier_global_value (c_get_ident (INT32_TYPE)));
4988   if (INT64_TYPE)
4989     int64_type_node =
4990       TREE_TYPE (identifier_global_value (c_get_ident (INT64_TYPE)));
4991   if (UINT8_TYPE)
4992     uint8_type_node =
4993       TREE_TYPE (identifier_global_value (c_get_ident (UINT8_TYPE)));
4994   if (UINT16_TYPE)
4995     uint16_type_node =
4996       TREE_TYPE (identifier_global_value (c_get_ident (UINT16_TYPE)));
4997   if (UINT32_TYPE)
4998     c_uint32_type_node =
4999       TREE_TYPE (identifier_global_value (c_get_ident (UINT32_TYPE)));
5000   if (UINT64_TYPE)
5001     c_uint64_type_node =
5002       TREE_TYPE (identifier_global_value (c_get_ident (UINT64_TYPE)));
5003   if (INT_LEAST8_TYPE)
5004     int_least8_type_node =
5005       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST8_TYPE)));
5006   if (INT_LEAST16_TYPE)
5007     int_least16_type_node =
5008       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST16_TYPE)));
5009   if (INT_LEAST32_TYPE)
5010     int_least32_type_node =
5011       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST32_TYPE)));
5012   if (INT_LEAST64_TYPE)
5013     int_least64_type_node =
5014       TREE_TYPE (identifier_global_value (c_get_ident (INT_LEAST64_TYPE)));
5015   if (UINT_LEAST8_TYPE)
5016     uint_least8_type_node =
5017       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST8_TYPE)));
5018   if (UINT_LEAST16_TYPE)
5019     uint_least16_type_node =
5020       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST16_TYPE)));
5021   if (UINT_LEAST32_TYPE)
5022     uint_least32_type_node =
5023       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST32_TYPE)));
5024   if (UINT_LEAST64_TYPE)
5025     uint_least64_type_node =
5026       TREE_TYPE (identifier_global_value (c_get_ident (UINT_LEAST64_TYPE)));
5027   if (INT_FAST8_TYPE)
5028     int_fast8_type_node =
5029       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST8_TYPE)));
5030   if (INT_FAST16_TYPE)
5031     int_fast16_type_node =
5032       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST16_TYPE)));
5033   if (INT_FAST32_TYPE)
5034     int_fast32_type_node =
5035       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST32_TYPE)));
5036   if (INT_FAST64_TYPE)
5037     int_fast64_type_node =
5038       TREE_TYPE (identifier_global_value (c_get_ident (INT_FAST64_TYPE)));
5039   if (UINT_FAST8_TYPE)
5040     uint_fast8_type_node =
5041       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST8_TYPE)));
5042   if (UINT_FAST16_TYPE)
5043     uint_fast16_type_node =
5044       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST16_TYPE)));
5045   if (UINT_FAST32_TYPE)
5046     uint_fast32_type_node =
5047       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST32_TYPE)));
5048   if (UINT_FAST64_TYPE)
5049     uint_fast64_type_node =
5050       TREE_TYPE (identifier_global_value (c_get_ident (UINT_FAST64_TYPE)));
5051   if (INTPTR_TYPE)
5052     intptr_type_node =
5053       TREE_TYPE (identifier_global_value (c_get_ident (INTPTR_TYPE)));
5054   if (UINTPTR_TYPE)
5055     uintptr_type_node =
5056       TREE_TYPE (identifier_global_value (c_get_ident (UINTPTR_TYPE)));
5057
5058   default_function_type
5059     = build_varargs_function_type_list (integer_type_node, NULL_TREE);
5060   ptrdiff_type_node
5061     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
5062   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
5063
5064   lang_hooks.decls.pushdecl
5065     (build_decl (UNKNOWN_LOCATION,
5066                  TYPE_DECL, get_identifier ("__builtin_va_list"),
5067                  va_list_type_node));
5068   if (targetm.enum_va_list_p)
5069     {
5070       int l;
5071       const char *pname;
5072       tree ptype;
5073
5074       for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
5075         {
5076           lang_hooks.decls.pushdecl
5077             (build_decl (UNKNOWN_LOCATION,
5078                          TYPE_DECL, get_identifier (pname),
5079                          ptype));
5080
5081         }
5082     }
5083
5084   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
5085     {
5086       va_list_arg_type_node = va_list_ref_type_node =
5087         build_pointer_type (TREE_TYPE (va_list_type_node));
5088     }
5089   else
5090     {
5091       va_list_arg_type_node = va_list_type_node;
5092       va_list_ref_type_node = build_reference_type (va_list_type_node);
5093     }
5094
5095   if (!flag_preprocess_only)
5096     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
5097
5098   main_identifier_node = get_identifier ("main");
5099
5100   /* Create the built-in __null node.  It is important that this is
5101      not shared.  */
5102   null_node = make_node (INTEGER_CST);
5103   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
5104
5105   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
5106   memset (builtin_types, 0, sizeof (builtin_types));
5107 }
5108
5109 /* The number of named compound-literals generated thus far.  */
5110 static GTY(()) int compound_literal_number;
5111
5112 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
5113
5114 void
5115 set_compound_literal_name (tree decl)
5116 {
5117   char *name;
5118   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
5119                            compound_literal_number);
5120   compound_literal_number++;
5121   DECL_NAME (decl) = get_identifier (name);
5122 }
5123
5124 tree
5125 build_va_arg (location_t loc, tree expr, tree type)
5126 {
5127   expr = build1 (VA_ARG_EXPR, type, expr);
5128   SET_EXPR_LOCATION (expr, loc);
5129   return expr;
5130 }
5131
5132
5133 /* Linked list of disabled built-in functions.  */
5134
5135 typedef struct disabled_builtin
5136 {
5137   const char *name;
5138   struct disabled_builtin *next;
5139 } disabled_builtin;
5140 static disabled_builtin *disabled_builtins = NULL;
5141
5142 static bool builtin_function_disabled_p (const char *);
5143
5144 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
5145    begins with "__builtin_", give an error.  */
5146
5147 void
5148 disable_builtin_function (const char *name)
5149 {
5150   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
5151     error ("cannot disable built-in function %qs", name);
5152   else
5153     {
5154       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
5155       new_disabled_builtin->name = name;
5156       new_disabled_builtin->next = disabled_builtins;
5157       disabled_builtins = new_disabled_builtin;
5158     }
5159 }
5160
5161
5162 /* Return true if the built-in function NAME has been disabled, false
5163    otherwise.  */
5164
5165 static bool
5166 builtin_function_disabled_p (const char *name)
5167 {
5168   disabled_builtin *p;
5169   for (p = disabled_builtins; p != NULL; p = p->next)
5170     {
5171       if (strcmp (name, p->name) == 0)
5172         return true;
5173     }
5174   return false;
5175 }
5176
5177
5178 /* Worker for DEF_BUILTIN.
5179    Possibly define a builtin function with one or two names.
5180    Does not declare a non-__builtin_ function if flag_no_builtin, or if
5181    nonansi_p and flag_no_nonansi_builtin.  */
5182
5183 static void
5184 def_builtin_1 (enum built_in_function fncode,
5185                const char *name,
5186                enum built_in_class fnclass,
5187                tree fntype, tree libtype,
5188                bool both_p, bool fallback_p, bool nonansi_p,
5189                tree fnattrs, bool implicit_p)
5190 {
5191   tree decl;
5192   const char *libname;
5193
5194   if (fntype == error_mark_node)
5195     return;
5196
5197   gcc_assert ((!both_p && !fallback_p)
5198               || !strncmp (name, "__builtin_",
5199                            strlen ("__builtin_")));
5200
5201   libname = name + strlen ("__builtin_");
5202   decl = add_builtin_function (name, fntype, fncode, fnclass,
5203                                (fallback_p ? libname : NULL),
5204                                fnattrs);
5205
5206   set_builtin_decl (fncode, decl, implicit_p);
5207
5208   if (both_p
5209       && !flag_no_builtin && !builtin_function_disabled_p (libname)
5210       && !(nonansi_p && flag_no_nonansi_builtin))
5211     add_builtin_function (libname, libtype, fncode, fnclass,
5212                           NULL, fnattrs);
5213 }
5214 \f
5215 /* Nonzero if the type T promotes to int.  This is (nearly) the
5216    integral promotions defined in ISO C99 6.3.1.1/2.  */
5217
5218 bool
5219 c_promoting_integer_type_p (const_tree t)
5220 {
5221   switch (TREE_CODE (t))
5222     {
5223     case INTEGER_TYPE:
5224       return (TYPE_MAIN_VARIANT (t) == char_type_node
5225               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
5226               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
5227               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
5228               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
5229               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
5230
5231     case ENUMERAL_TYPE:
5232       /* ??? Technically all enumerations not larger than an int
5233          promote to an int.  But this is used along code paths
5234          that only want to notice a size change.  */
5235       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
5236
5237     case BOOLEAN_TYPE:
5238       return 1;
5239
5240     default:
5241       return 0;
5242     }
5243 }
5244
5245 /* Return 1 if PARMS specifies a fixed number of parameters
5246    and none of their types is affected by default promotions.  */
5247
5248 int
5249 self_promoting_args_p (const_tree parms)
5250 {
5251   const_tree t;
5252   for (t = parms; t; t = TREE_CHAIN (t))
5253     {
5254       tree type = TREE_VALUE (t);
5255
5256       if (type == error_mark_node)
5257         continue;
5258
5259       if (TREE_CHAIN (t) == 0 && type != void_type_node)
5260         return 0;
5261
5262       if (type == 0)
5263         return 0;
5264
5265       if (TYPE_MAIN_VARIANT (type) == float_type_node)
5266         return 0;
5267
5268       if (c_promoting_integer_type_p (type))
5269         return 0;
5270     }
5271   return 1;
5272 }
5273
5274 /* Recursively remove any '*' or '&' operator from TYPE.  */
5275 tree
5276 strip_pointer_operator (tree t)
5277 {
5278   while (POINTER_TYPE_P (t))
5279     t = TREE_TYPE (t);
5280   return t;
5281 }
5282
5283 /* Recursively remove pointer or array type from TYPE. */
5284 tree
5285 strip_pointer_or_array_types (tree t)
5286 {
5287   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
5288     t = TREE_TYPE (t);
5289   return t;
5290 }
5291
5292 /* Used to compare case labels.  K1 and K2 are actually tree nodes
5293    representing case labels, or NULL_TREE for a `default' label.
5294    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5295    K2, and 0 if K1 and K2 are equal.  */
5296
5297 int
5298 case_compare (splay_tree_key k1, splay_tree_key k2)
5299 {
5300   /* Consider a NULL key (such as arises with a `default' label) to be
5301      smaller than anything else.  */
5302   if (!k1)
5303     return k2 ? -1 : 0;
5304   else if (!k2)
5305     return k1 ? 1 : 0;
5306
5307   return tree_int_cst_compare ((tree) k1, (tree) k2);
5308 }
5309
5310 /* Process a case label, located at LOC, for the range LOW_VALUE
5311    ... HIGH_VALUE.  If LOW_VALUE and HIGH_VALUE are both NULL_TREE
5312    then this case label is actually a `default' label.  If only
5313    HIGH_VALUE is NULL_TREE, then case label was declared using the
5314    usual C/C++ syntax, rather than the GNU case range extension.
5315    CASES is a tree containing all the case ranges processed so far;
5316    COND is the condition for the switch-statement itself.  Returns the
5317    CASE_LABEL_EXPR created, or ERROR_MARK_NODE if no CASE_LABEL_EXPR
5318    is created.  */
5319
5320 tree
5321 c_add_case_label (location_t loc, splay_tree cases, tree cond, tree orig_type,
5322                   tree low_value, tree high_value)
5323 {
5324   tree type;
5325   tree label;
5326   tree case_label;
5327   splay_tree_node node;
5328
5329   /* Create the LABEL_DECL itself.  */
5330   label = create_artificial_label (loc);
5331
5332   /* If there was an error processing the switch condition, bail now
5333      before we get more confused.  */
5334   if (!cond || cond == error_mark_node)
5335     goto error_out;
5336
5337   if ((low_value && TREE_TYPE (low_value)
5338        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5339       || (high_value && TREE_TYPE (high_value)
5340           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5341     {
5342       error_at (loc, "pointers are not permitted as case values");
5343       goto error_out;
5344     }
5345
5346   /* Case ranges are a GNU extension.  */
5347   if (high_value)
5348     pedwarn (loc, OPT_pedantic,
5349              "range expressions in switch statements are non-standard");
5350
5351   type = TREE_TYPE (cond);
5352   if (low_value)
5353     {
5354       low_value = check_case_value (low_value);
5355       low_value = convert_and_check (type, low_value);
5356       if (low_value == error_mark_node)
5357         goto error_out;
5358     }
5359   if (high_value)
5360     {
5361       high_value = check_case_value (high_value);
5362       high_value = convert_and_check (type, high_value);
5363       if (high_value == error_mark_node)
5364         goto error_out;
5365     }
5366
5367   if (low_value && high_value)
5368     {
5369       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5370          really a case range, even though it was written that way.
5371          Remove the HIGH_VALUE to simplify later processing.  */
5372       if (tree_int_cst_equal (low_value, high_value))
5373         high_value = NULL_TREE;
5374       else if (!tree_int_cst_lt (low_value, high_value))
5375         warning_at (loc, 0, "empty range specified");
5376     }
5377
5378   /* See if the case is in range of the type of the original testing
5379      expression.  If both low_value and high_value are out of range,
5380      don't insert the case label and return NULL_TREE.  */
5381   if (low_value
5382       && !check_case_bounds (type, orig_type,
5383                              &low_value, high_value ? &high_value : NULL))
5384     return NULL_TREE;
5385
5386   /* Look up the LOW_VALUE in the table of case labels we already
5387      have.  */
5388   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5389   /* If there was not an exact match, check for overlapping ranges.
5390      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5391      that's a `default' label and the only overlap is an exact match.  */
5392   if (!node && (low_value || high_value))
5393     {
5394       splay_tree_node low_bound;
5395       splay_tree_node high_bound;
5396
5397       /* Even though there wasn't an exact match, there might be an
5398          overlap between this case range and another case range.
5399          Since we've (inductively) not allowed any overlapping case
5400          ranges, we simply need to find the greatest low case label
5401          that is smaller that LOW_VALUE, and the smallest low case
5402          label that is greater than LOW_VALUE.  If there is an overlap
5403          it will occur in one of these two ranges.  */
5404       low_bound = splay_tree_predecessor (cases,
5405                                           (splay_tree_key) low_value);
5406       high_bound = splay_tree_successor (cases,
5407                                          (splay_tree_key) low_value);
5408
5409       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5410          the LOW_VALUE, so there is no need to check unless the
5411          LOW_BOUND is in fact itself a case range.  */
5412       if (low_bound
5413           && CASE_HIGH ((tree) low_bound->value)
5414           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5415                                     low_value) >= 0)
5416         node = low_bound;
5417       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5418          range is bigger than the low end of the current range, so we
5419          are only interested if the current range is a real range, and
5420          not an ordinary case label.  */
5421       else if (high_bound
5422                && high_value
5423                && (tree_int_cst_compare ((tree) high_bound->key,
5424                                          high_value)
5425                    <= 0))
5426         node = high_bound;
5427     }
5428   /* If there was an overlap, issue an error.  */
5429   if (node)
5430     {
5431       tree duplicate = CASE_LABEL ((tree) node->value);
5432
5433       if (high_value)
5434         {
5435           error_at (loc, "duplicate (or overlapping) case value");
5436           error_at (DECL_SOURCE_LOCATION (duplicate),
5437                     "this is the first entry overlapping that value");
5438         }
5439       else if (low_value)
5440         {
5441           error_at (loc, "duplicate case value") ;
5442           error_at (DECL_SOURCE_LOCATION (duplicate), "previously used here");
5443         }
5444       else
5445         {
5446           error_at (loc, "multiple default labels in one switch");
5447           error_at (DECL_SOURCE_LOCATION (duplicate),
5448                     "this is the first default label");
5449         }
5450       goto error_out;
5451     }
5452
5453   /* Add a CASE_LABEL to the statement-tree.  */
5454   case_label = add_stmt (build_case_label (low_value, high_value, label));
5455   /* Register this case label in the splay tree.  */
5456   splay_tree_insert (cases,
5457                      (splay_tree_key) low_value,
5458                      (splay_tree_value) case_label);
5459
5460   return case_label;
5461
5462  error_out:
5463   /* Add a label so that the back-end doesn't think that the beginning of
5464      the switch is unreachable.  Note that we do not add a case label, as
5465      that just leads to duplicates and thence to failure later on.  */
5466   if (!cases->root)
5467     {
5468       tree t = create_artificial_label (loc);
5469       add_stmt (build_stmt (loc, LABEL_EXPR, t));
5470     }
5471   return error_mark_node;
5472 }
5473
5474 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
5475    Used to verify that case values match up with enumerator values.  */
5476
5477 static void
5478 match_case_to_enum_1 (tree key, tree type, tree label)
5479 {
5480   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
5481
5482   /* ??? Not working too hard to print the double-word value.
5483      Should perhaps be done with %lwd in the diagnostic routines?  */
5484   if (TREE_INT_CST_HIGH (key) == 0)
5485     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
5486               TREE_INT_CST_LOW (key));
5487   else if (!TYPE_UNSIGNED (type)
5488            && TREE_INT_CST_HIGH (key) == -1
5489            && TREE_INT_CST_LOW (key) != 0)
5490     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
5491               -TREE_INT_CST_LOW (key));
5492   else
5493     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
5494               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
5495               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
5496
5497   if (TYPE_NAME (type) == 0)
5498     warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5499                 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5500                 "case value %qs not in enumerated type",
5501                 buf);
5502   else
5503     warning_at (DECL_SOURCE_LOCATION (CASE_LABEL (label)),
5504                 warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
5505                 "case value %qs not in enumerated type %qT",
5506                 buf, type);
5507 }
5508
5509 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
5510    Used to verify that case values match up with enumerator values.  */
5511
5512 static int
5513 match_case_to_enum (splay_tree_node node, void *data)
5514 {
5515   tree label = (tree) node->value;
5516   tree type = (tree) data;
5517
5518   /* Skip default case.  */
5519   if (!CASE_LOW (label))
5520     return 0;
5521
5522   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
5523      when we did our enum->case scan.  Reset our scratch bit after.  */
5524   if (!CASE_LOW_SEEN (label))
5525     match_case_to_enum_1 (CASE_LOW (label), type, label);
5526   else
5527     CASE_LOW_SEEN (label) = 0;
5528
5529   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
5530      not set, that means that CASE_HIGH did not appear when we did our
5531      enum->case scan.  Reset our scratch bit after.  */
5532   if (CASE_HIGH (label))
5533     {
5534       if (!CASE_HIGH_SEEN (label))
5535         match_case_to_enum_1 (CASE_HIGH (label), type, label);
5536       else
5537         CASE_HIGH_SEEN (label) = 0;
5538     }
5539
5540   return 0;
5541 }
5542
5543 /* Handle -Wswitch*.  Called from the front end after parsing the
5544    switch construct.  */
5545 /* ??? Should probably be somewhere generic, since other languages
5546    besides C and C++ would want this.  At the moment, however, C/C++
5547    are the only tree-ssa languages that support enumerations at all,
5548    so the point is moot.  */
5549
5550 void
5551 c_do_switch_warnings (splay_tree cases, location_t switch_location,
5552                       tree type, tree cond)
5553 {
5554   splay_tree_node default_node;
5555   splay_tree_node node;
5556   tree chain;
5557
5558   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
5559     return;
5560
5561   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
5562   if (!default_node)
5563     warning_at (switch_location, OPT_Wswitch_default,
5564                 "switch missing default case");
5565
5566   /* From here on, we only care about about enumerated types.  */
5567   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
5568     return;
5569
5570   /* From here on, we only care about -Wswitch and -Wswitch-enum.  */
5571   if (!warn_switch_enum && !warn_switch)
5572     return;
5573
5574   /* Check the cases.  Warn about case values which are not members of
5575      the enumerated type.  For -Wswitch-enum, or for -Wswitch when
5576      there is no default case, check that exactly all enumeration
5577      literals are covered by the cases.  */
5578
5579   /* Clearing COND if it is not an integer constant simplifies
5580      the tests inside the loop below.  */
5581   if (TREE_CODE (cond) != INTEGER_CST)
5582     cond = NULL_TREE;
5583
5584   /* The time complexity here is O(N*lg(N)) worst case, but for the
5585       common case of monotonically increasing enumerators, it is
5586       O(N), since the nature of the splay tree will keep the next
5587       element adjacent to the root at all times.  */
5588
5589   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
5590     {
5591       tree value = TREE_VALUE (chain);
5592       if (TREE_CODE (value) == CONST_DECL)
5593         value = DECL_INITIAL (value);
5594       node = splay_tree_lookup (cases, (splay_tree_key) value);
5595       if (node)
5596         {
5597           /* Mark the CASE_LOW part of the case entry as seen.  */
5598           tree label = (tree) node->value;
5599           CASE_LOW_SEEN (label) = 1;
5600           continue;
5601         }
5602
5603       /* Even though there wasn't an exact match, there might be a
5604          case range which includes the enumerator's value.  */
5605       node = splay_tree_predecessor (cases, (splay_tree_key) value);
5606       if (node && CASE_HIGH ((tree) node->value))
5607         {
5608           tree label = (tree) node->value;
5609           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
5610           if (cmp >= 0)
5611             {
5612               /* If we match the upper bound exactly, mark the CASE_HIGH
5613                  part of the case entry as seen.  */
5614               if (cmp == 0)
5615                 CASE_HIGH_SEEN (label) = 1;
5616               continue;
5617             }
5618         }
5619
5620       /* We've now determined that this enumerated literal isn't
5621          handled by the case labels of the switch statement.  */
5622
5623       /* If the switch expression is a constant, we only really care
5624          about whether that constant is handled by the switch.  */
5625       if (cond && tree_int_cst_compare (cond, value))
5626         continue;
5627
5628       /* If there is a default_node, the only relevant option is
5629          Wswitch-enum.  Otherwise, if both are enabled then we prefer
5630          to warn using -Wswitch because -Wswitch is enabled by -Wall
5631          while -Wswitch-enum is explicit.  */
5632       warning_at (switch_location,
5633                   (default_node || !warn_switch
5634                    ? OPT_Wswitch_enum
5635                    : OPT_Wswitch),
5636                   "enumeration value %qE not handled in switch",
5637                   TREE_PURPOSE (chain));
5638     }
5639
5640   /* Warn if there are case expressions that don't correspond to
5641      enumerators.  This can occur since C and C++ don't enforce
5642      type-checking of assignments to enumeration variables.
5643
5644      The time complexity here is now always O(N) worst case, since
5645      we should have marked both the lower bound and upper bound of
5646      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
5647      above.  This scan also resets those fields.  */
5648
5649   splay_tree_foreach (cases, match_case_to_enum, type);
5650 }
5651
5652 /* Finish an expression taking the address of LABEL (an
5653    IDENTIFIER_NODE).  Returns an expression for the address.
5654
5655    LOC is the location for the expression returned.  */
5656
5657 tree
5658 finish_label_address_expr (tree label, location_t loc)
5659 {
5660   tree result;
5661
5662   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
5663
5664   if (label == error_mark_node)
5665     return error_mark_node;
5666
5667   label = lookup_label (label);
5668   if (label == NULL_TREE)
5669     result = null_pointer_node;
5670   else
5671     {
5672       TREE_USED (label) = 1;
5673       result = build1 (ADDR_EXPR, ptr_type_node, label);
5674       /* The current function is not necessarily uninlinable.
5675          Computed gotos are incompatible with inlining, but the value
5676          here could be used only in a diagnostic, for example.  */
5677       protected_set_expr_location (result, loc);
5678     }
5679
5680   return result;
5681 }
5682 \f
5683
5684 /* Given a boolean expression ARG, return a tree representing an increment
5685    or decrement (as indicated by CODE) of ARG.  The front end must check for
5686    invalid cases (e.g., decrement in C++).  */
5687 tree
5688 boolean_increment (enum tree_code code, tree arg)
5689 {
5690   tree val;
5691   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5692
5693   arg = stabilize_reference (arg);
5694   switch (code)
5695     {
5696     case PREINCREMENT_EXPR:
5697       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5698       break;
5699     case POSTINCREMENT_EXPR:
5700       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5701       arg = save_expr (arg);
5702       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5703       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5704       break;
5705     case PREDECREMENT_EXPR:
5706       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5707                     invert_truthvalue_loc (input_location, arg));
5708       break;
5709     case POSTDECREMENT_EXPR:
5710       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5711                     invert_truthvalue_loc (input_location, arg));
5712       arg = save_expr (arg);
5713       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5714       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5715       break;
5716     default:
5717       gcc_unreachable ();
5718     }
5719   TREE_SIDE_EFFECTS (val) = 1;
5720   return val;
5721 }
5722 \f
5723 /* Built-in macros for stddef.h and stdint.h, that require macros
5724    defined in this file.  */
5725 void
5726 c_stddef_cpp_builtins(void)
5727 {
5728   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5729   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5730   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5731   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5732   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5733   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5734   builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5735   builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5736   if (SIG_ATOMIC_TYPE)
5737     builtin_define_with_value ("__SIG_ATOMIC_TYPE__", SIG_ATOMIC_TYPE, 0);
5738   if (INT8_TYPE)
5739     builtin_define_with_value ("__INT8_TYPE__", INT8_TYPE, 0);
5740   if (INT16_TYPE)
5741     builtin_define_with_value ("__INT16_TYPE__", INT16_TYPE, 0);
5742   if (INT32_TYPE)
5743     builtin_define_with_value ("__INT32_TYPE__", INT32_TYPE, 0);
5744   if (INT64_TYPE)
5745     builtin_define_with_value ("__INT64_TYPE__", INT64_TYPE, 0);
5746   if (UINT8_TYPE)
5747     builtin_define_with_value ("__UINT8_TYPE__", UINT8_TYPE, 0);
5748   if (UINT16_TYPE)
5749     builtin_define_with_value ("__UINT16_TYPE__", UINT16_TYPE, 0);
5750   if (UINT32_TYPE)
5751     builtin_define_with_value ("__UINT32_TYPE__", UINT32_TYPE, 0);
5752   if (UINT64_TYPE)
5753     builtin_define_with_value ("__UINT64_TYPE__", UINT64_TYPE, 0);
5754   if (INT_LEAST8_TYPE)
5755     builtin_define_with_value ("__INT_LEAST8_TYPE__", INT_LEAST8_TYPE, 0);
5756   if (INT_LEAST16_TYPE)
5757     builtin_define_with_value ("__INT_LEAST16_TYPE__", INT_LEAST16_TYPE, 0);
5758   if (INT_LEAST32_TYPE)
5759     builtin_define_with_value ("__INT_LEAST32_TYPE__", INT_LEAST32_TYPE, 0);
5760   if (INT_LEAST64_TYPE)
5761     builtin_define_with_value ("__INT_LEAST64_TYPE__", INT_LEAST64_TYPE, 0);
5762   if (UINT_LEAST8_TYPE)
5763     builtin_define_with_value ("__UINT_LEAST8_TYPE__", UINT_LEAST8_TYPE, 0);
5764   if (UINT_LEAST16_TYPE)
5765     builtin_define_with_value ("__UINT_LEAST16_TYPE__", UINT_LEAST16_TYPE, 0);
5766   if (UINT_LEAST32_TYPE)
5767     builtin_define_with_value ("__UINT_LEAST32_TYPE__", UINT_LEAST32_TYPE, 0);
5768   if (UINT_LEAST64_TYPE)
5769     builtin_define_with_value ("__UINT_LEAST64_TYPE__", UINT_LEAST64_TYPE, 0);
5770   if (INT_FAST8_TYPE)
5771     builtin_define_with_value ("__INT_FAST8_TYPE__", INT_FAST8_TYPE, 0);
5772   if (INT_FAST16_TYPE)
5773     builtin_define_with_value ("__INT_FAST16_TYPE__", INT_FAST16_TYPE, 0);
5774   if (INT_FAST32_TYPE)
5775     builtin_define_with_value ("__INT_FAST32_TYPE__", INT_FAST32_TYPE, 0);
5776   if (INT_FAST64_TYPE)
5777     builtin_define_with_value ("__INT_FAST64_TYPE__", INT_FAST64_TYPE, 0);
5778   if (UINT_FAST8_TYPE)
5779     builtin_define_with_value ("__UINT_FAST8_TYPE__", UINT_FAST8_TYPE, 0);
5780   if (UINT_FAST16_TYPE)
5781     builtin_define_with_value ("__UINT_FAST16_TYPE__", UINT_FAST16_TYPE, 0);
5782   if (UINT_FAST32_TYPE)
5783     builtin_define_with_value ("__UINT_FAST32_TYPE__", UINT_FAST32_TYPE, 0);
5784   if (UINT_FAST64_TYPE)
5785     builtin_define_with_value ("__UINT_FAST64_TYPE__", UINT_FAST64_TYPE, 0);
5786   if (INTPTR_TYPE)
5787     builtin_define_with_value ("__INTPTR_TYPE__", INTPTR_TYPE, 0);
5788   if (UINTPTR_TYPE)
5789     builtin_define_with_value ("__UINTPTR_TYPE__", UINTPTR_TYPE, 0);
5790 }
5791
5792 static void
5793 c_init_attributes (void)
5794 {
5795   /* Fill in the built_in_attributes array.  */
5796 #define DEF_ATTR_NULL_TREE(ENUM)                                \
5797   built_in_attributes[(int) ENUM] = NULL_TREE;
5798 #define DEF_ATTR_INT(ENUM, VALUE)                               \
5799   built_in_attributes[(int) ENUM] = build_int_cst (integer_type_node, VALUE);
5800 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
5801   built_in_attributes[(int) ENUM] = get_identifier (STRING);
5802 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5803   built_in_attributes[(int) ENUM]                       \
5804     = tree_cons (built_in_attributes[(int) PURPOSE],    \
5805                  built_in_attributes[(int) VALUE],      \
5806                  built_in_attributes[(int) CHAIN]);
5807 #include "builtin-attrs.def"
5808 #undef DEF_ATTR_NULL_TREE
5809 #undef DEF_ATTR_INT
5810 #undef DEF_ATTR_IDENT
5811 #undef DEF_ATTR_TREE_LIST
5812 }
5813
5814 /* Returns TRUE iff the attribute indicated by ATTR_ID takes a plain
5815    identifier as an argument, so the front end shouldn't look it up.  */
5816
5817 bool
5818 attribute_takes_identifier_p (const_tree attr_id)
5819 {
5820   const struct attribute_spec *spec = lookup_attribute_spec (attr_id);
5821   if (spec == NULL)
5822     /* Unknown attribute that we'll end up ignoring, return true so we
5823        don't complain about an identifier argument.  */
5824     return true;
5825   else if (!strcmp ("mode", spec->name)
5826            || !strcmp ("format", spec->name)
5827            || !strcmp ("cleanup", spec->name))
5828     return true;
5829   else
5830     return targetm.attribute_takes_identifier_p (attr_id);
5831 }
5832
5833 /* Attribute handlers common to C front ends.  */
5834
5835 /* Handle a "packed" attribute; arguments as in
5836    struct attribute_spec.handler.  */
5837
5838 static tree
5839 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5840                          int flags, bool *no_add_attrs)
5841 {
5842   if (TYPE_P (*node))
5843     {
5844       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5845         *node = build_variant_type_copy (*node);
5846       TYPE_PACKED (*node) = 1;
5847     }
5848   else if (TREE_CODE (*node) == FIELD_DECL)
5849     {
5850       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT
5851           /* Still pack bitfields.  */
5852           && ! DECL_INITIAL (*node))
5853         warning (OPT_Wattributes,
5854                  "%qE attribute ignored for field of type %qT",
5855                  name, TREE_TYPE (*node));
5856       else
5857         DECL_PACKED (*node) = 1;
5858     }
5859   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5860      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5861      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5862      that changes what the typedef is typing.  */
5863   else
5864     {
5865       warning (OPT_Wattributes, "%qE attribute ignored", name);
5866       *no_add_attrs = true;
5867     }
5868
5869   return NULL_TREE;
5870 }
5871
5872 /* Handle a "nocommon" attribute; arguments as in
5873    struct attribute_spec.handler.  */
5874
5875 static tree
5876 handle_nocommon_attribute (tree *node, tree name,
5877                            tree ARG_UNUSED (args),
5878                            int ARG_UNUSED (flags), bool *no_add_attrs)
5879 {
5880   if (TREE_CODE (*node) == VAR_DECL)
5881     DECL_COMMON (*node) = 0;
5882   else
5883     {
5884       warning (OPT_Wattributes, "%qE attribute ignored", name);
5885       *no_add_attrs = true;
5886     }
5887
5888   return NULL_TREE;
5889 }
5890
5891 /* Handle a "common" attribute; arguments as in
5892    struct attribute_spec.handler.  */
5893
5894 static tree
5895 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5896                          int ARG_UNUSED (flags), bool *no_add_attrs)
5897 {
5898   if (TREE_CODE (*node) == VAR_DECL)
5899     DECL_COMMON (*node) = 1;
5900   else
5901     {
5902       warning (OPT_Wattributes, "%qE attribute ignored", name);
5903       *no_add_attrs = true;
5904     }
5905
5906   return NULL_TREE;
5907 }
5908
5909 /* Handle a "noreturn" attribute; arguments as in
5910    struct attribute_spec.handler.  */
5911
5912 static tree
5913 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5914                            int ARG_UNUSED (flags), bool *no_add_attrs)
5915 {
5916   tree type = TREE_TYPE (*node);
5917
5918   /* See FIXME comment in c_common_attribute_table.  */
5919   if (TREE_CODE (*node) == FUNCTION_DECL
5920       || objc_method_decl (TREE_CODE (*node)))
5921     TREE_THIS_VOLATILE (*node) = 1;
5922   else if (TREE_CODE (type) == POINTER_TYPE
5923            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5924     TREE_TYPE (*node)
5925       = build_pointer_type
5926         (build_type_variant (TREE_TYPE (type),
5927                              TYPE_READONLY (TREE_TYPE (type)), 1));
5928   else
5929     {
5930       warning (OPT_Wattributes, "%qE attribute ignored", name);
5931       *no_add_attrs = true;
5932     }
5933
5934   return NULL_TREE;
5935 }
5936
5937 /* Handle a "hot" and attribute; arguments as in
5938    struct attribute_spec.handler.  */
5939
5940 static tree
5941 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5942                       int ARG_UNUSED (flags), bool *no_add_attrs)
5943 {
5944   if (TREE_CODE (*node) == FUNCTION_DECL)
5945     {
5946       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5947         {
5948           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5949                    name, "cold");
5950           *no_add_attrs = true;
5951         }
5952       /* Most of the rest of the hot processing is done later with
5953          lookup_attribute.  */
5954     }
5955   else
5956     {
5957       warning (OPT_Wattributes, "%qE attribute ignored", name);
5958       *no_add_attrs = true;
5959     }
5960
5961   return NULL_TREE;
5962 }
5963 /* Handle a "cold" and attribute; arguments as in
5964    struct attribute_spec.handler.  */
5965
5966 static tree
5967 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5968                        int ARG_UNUSED (flags), bool *no_add_attrs)
5969 {
5970   if (TREE_CODE (*node) == FUNCTION_DECL)
5971     {
5972       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5973         {
5974           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5975                    name, "hot");
5976           *no_add_attrs = true;
5977         }
5978       /* Most of the rest of the cold processing is done later with
5979          lookup_attribute.  */
5980     }
5981   else
5982     {
5983       warning (OPT_Wattributes, "%qE attribute ignored", name);
5984       *no_add_attrs = true;
5985     }
5986
5987   return NULL_TREE;
5988 }
5989
5990 /* Handle a "noinline" attribute; arguments as in
5991    struct attribute_spec.handler.  */
5992
5993 static tree
5994 handle_noinline_attribute (tree *node, tree name,
5995                            tree ARG_UNUSED (args),
5996                            int ARG_UNUSED (flags), bool *no_add_attrs)
5997 {
5998   if (TREE_CODE (*node) == FUNCTION_DECL)
5999     DECL_UNINLINABLE (*node) = 1;
6000   else
6001     {
6002       warning (OPT_Wattributes, "%qE attribute ignored", name);
6003       *no_add_attrs = true;
6004     }
6005
6006   return NULL_TREE;
6007 }
6008
6009 /* Handle a "noclone" attribute; arguments as in
6010    struct attribute_spec.handler.  */
6011
6012 static tree
6013 handle_noclone_attribute (tree *node, tree name,
6014                           tree ARG_UNUSED (args),
6015                           int ARG_UNUSED (flags), bool *no_add_attrs)
6016 {
6017   if (TREE_CODE (*node) != FUNCTION_DECL)
6018     {
6019       warning (OPT_Wattributes, "%qE attribute ignored", name);
6020       *no_add_attrs = true;
6021     }
6022
6023   return NULL_TREE;
6024 }
6025
6026 /* Handle a "always_inline" attribute; arguments as in
6027    struct attribute_spec.handler.  */
6028
6029 static tree
6030 handle_always_inline_attribute (tree *node, tree name,
6031                                 tree ARG_UNUSED (args),
6032                                 int ARG_UNUSED (flags),
6033                                 bool *no_add_attrs)
6034 {
6035   if (TREE_CODE (*node) == FUNCTION_DECL)
6036     {
6037       /* Set the attribute and mark it for disregarding inline
6038          limits.  */
6039       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
6040     }
6041   else
6042     {
6043       warning (OPT_Wattributes, "%qE attribute ignored", name);
6044       *no_add_attrs = true;
6045     }
6046
6047   return NULL_TREE;
6048 }
6049
6050 /* Handle a "gnu_inline" attribute; arguments as in
6051    struct attribute_spec.handler.  */
6052
6053 static tree
6054 handle_gnu_inline_attribute (tree *node, tree name,
6055                              tree ARG_UNUSED (args),
6056                              int ARG_UNUSED (flags),
6057                              bool *no_add_attrs)
6058 {
6059   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6060     {
6061       /* Do nothing else, just set the attribute.  We'll get at
6062          it later with lookup_attribute.  */
6063     }
6064   else
6065     {
6066       warning (OPT_Wattributes, "%qE attribute ignored", name);
6067       *no_add_attrs = true;
6068     }
6069
6070   return NULL_TREE;
6071 }
6072
6073 /* Handle a "leaf" attribute; arguments as in
6074    struct attribute_spec.handler.  */
6075
6076 static tree
6077 handle_leaf_attribute (tree *node, tree name,
6078                        tree ARG_UNUSED (args),
6079                        int ARG_UNUSED (flags), bool *no_add_attrs)
6080 {
6081   if (TREE_CODE (*node) != FUNCTION_DECL)
6082     {
6083       warning (OPT_Wattributes, "%qE attribute ignored", name);
6084       *no_add_attrs = true;
6085     }
6086   if (!TREE_PUBLIC (*node))
6087     {
6088       warning (OPT_Wattributes, "%qE attribute has no effect on unit local functions", name);
6089       *no_add_attrs = true;
6090     }
6091
6092   return NULL_TREE;
6093 }
6094
6095 /* Handle an "artificial" attribute; arguments as in
6096    struct attribute_spec.handler.  */
6097
6098 static tree
6099 handle_artificial_attribute (tree *node, tree name,
6100                              tree ARG_UNUSED (args),
6101                              int ARG_UNUSED (flags),
6102                              bool *no_add_attrs)
6103 {
6104   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
6105     {
6106       /* Do nothing else, just set the attribute.  We'll get at
6107          it later with lookup_attribute.  */
6108     }
6109   else
6110     {
6111       warning (OPT_Wattributes, "%qE attribute ignored", name);
6112       *no_add_attrs = true;
6113     }
6114
6115   return NULL_TREE;
6116 }
6117
6118 /* Handle a "flatten" attribute; arguments as in
6119    struct attribute_spec.handler.  */
6120
6121 static tree
6122 handle_flatten_attribute (tree *node, tree name,
6123                           tree args ATTRIBUTE_UNUSED,
6124                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
6125 {
6126   if (TREE_CODE (*node) == FUNCTION_DECL)
6127     /* Do nothing else, just set the attribute.  We'll get at
6128        it later with lookup_attribute.  */
6129     ;
6130   else
6131     {
6132       warning (OPT_Wattributes, "%qE attribute ignored", name);
6133       *no_add_attrs = true;
6134     }
6135
6136   return NULL_TREE;
6137 }
6138
6139 /* Handle a "warning" or "error" attribute; arguments as in
6140    struct attribute_spec.handler.  */
6141
6142 static tree
6143 handle_error_attribute (tree *node, tree name, tree args,
6144                         int ARG_UNUSED (flags), bool *no_add_attrs)
6145 {
6146   if (TREE_CODE (*node) == FUNCTION_DECL
6147       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6148     /* Do nothing else, just set the attribute.  We'll get at
6149        it later with lookup_attribute.  */
6150     ;
6151   else
6152     {
6153       warning (OPT_Wattributes, "%qE attribute ignored", name);
6154       *no_add_attrs = true;
6155     }
6156
6157   return NULL_TREE;
6158 }
6159
6160 /* Handle a "used" attribute; arguments as in
6161    struct attribute_spec.handler.  */
6162
6163 static tree
6164 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
6165                        int ARG_UNUSED (flags), bool *no_add_attrs)
6166 {
6167   tree node = *pnode;
6168
6169   if (TREE_CODE (node) == FUNCTION_DECL
6170       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node))
6171       || (TREE_CODE (node) == TYPE_DECL))
6172     {
6173       TREE_USED (node) = 1;
6174       DECL_PRESERVE_P (node) = 1;
6175       if (TREE_CODE (node) == VAR_DECL)
6176         DECL_READ_P (node) = 1;
6177     }
6178   else
6179     {
6180       warning (OPT_Wattributes, "%qE attribute ignored", name);
6181       *no_add_attrs = true;
6182     }
6183
6184   return NULL_TREE;
6185 }
6186
6187 /* Handle a "unused" attribute; arguments as in
6188    struct attribute_spec.handler.  */
6189
6190 static tree
6191 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6192                          int flags, bool *no_add_attrs)
6193 {
6194   if (DECL_P (*node))
6195     {
6196       tree decl = *node;
6197
6198       if (TREE_CODE (decl) == PARM_DECL
6199           || TREE_CODE (decl) == VAR_DECL
6200           || TREE_CODE (decl) == FUNCTION_DECL
6201           || TREE_CODE (decl) == LABEL_DECL
6202           || TREE_CODE (decl) == TYPE_DECL)
6203         {
6204           TREE_USED (decl) = 1;
6205           if (TREE_CODE (decl) == VAR_DECL
6206               || TREE_CODE (decl) == PARM_DECL)
6207             DECL_READ_P (decl) = 1;
6208         }
6209       else
6210         {
6211           warning (OPT_Wattributes, "%qE attribute ignored", name);
6212           *no_add_attrs = true;
6213         }
6214     }
6215   else
6216     {
6217       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6218         *node = build_variant_type_copy (*node);
6219       TREE_USED (*node) = 1;
6220     }
6221
6222   return NULL_TREE;
6223 }
6224
6225 /* Handle a "externally_visible" attribute; arguments as in
6226    struct attribute_spec.handler.  */
6227
6228 static tree
6229 handle_externally_visible_attribute (tree *pnode, tree name,
6230                                      tree ARG_UNUSED (args),
6231                                      int ARG_UNUSED (flags),
6232                                      bool *no_add_attrs)
6233 {
6234   tree node = *pnode;
6235
6236   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
6237     {
6238       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
6239            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
6240         {
6241           warning (OPT_Wattributes,
6242                    "%qE attribute have effect only on public objects", name);
6243           *no_add_attrs = true;
6244         }
6245     }
6246   else
6247     {
6248       warning (OPT_Wattributes, "%qE attribute ignored", name);
6249       *no_add_attrs = true;
6250     }
6251
6252   return NULL_TREE;
6253 }
6254
6255 /* Handle a "const" attribute; arguments as in
6256    struct attribute_spec.handler.  */
6257
6258 static tree
6259 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6260                         int ARG_UNUSED (flags), bool *no_add_attrs)
6261 {
6262   tree type = TREE_TYPE (*node);
6263
6264   /* See FIXME comment on noreturn in c_common_attribute_table.  */
6265   if (TREE_CODE (*node) == FUNCTION_DECL)
6266     TREE_READONLY (*node) = 1;
6267   else if (TREE_CODE (type) == POINTER_TYPE
6268            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
6269     TREE_TYPE (*node)
6270       = build_pointer_type
6271         (build_type_variant (TREE_TYPE (type), 1,
6272                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
6273   else
6274     {
6275       warning (OPT_Wattributes, "%qE attribute ignored", name);
6276       *no_add_attrs = true;
6277     }
6278
6279   return NULL_TREE;
6280 }
6281
6282 /* Handle a "transparent_union" attribute; arguments as in
6283    struct attribute_spec.handler.  */
6284
6285 static tree
6286 handle_transparent_union_attribute (tree *node, tree name,
6287                                     tree ARG_UNUSED (args), int flags,
6288                                     bool *no_add_attrs)
6289 {
6290   tree type;
6291
6292   *no_add_attrs = true;
6293
6294   if (TREE_CODE (*node) == TYPE_DECL)
6295     node = &TREE_TYPE (*node);
6296   type = *node;
6297
6298   if (TREE_CODE (type) == UNION_TYPE)
6299     {
6300       /* Make sure that the first field will work for a transparent union.
6301          If the type isn't complete yet, leave the check to the code in
6302          finish_struct.  */
6303       if (TYPE_SIZE (type))
6304         {
6305           tree first = first_field (type);
6306           if (first == NULL_TREE
6307               || DECL_ARTIFICIAL (first)
6308               || TYPE_MODE (type) != DECL_MODE (first))
6309             goto ignored;
6310         }
6311
6312       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6313         {
6314           /* If the type isn't complete yet, setting the flag
6315              on a variant wouldn't ever be checked.  */
6316           if (!TYPE_SIZE (type))
6317             goto ignored;
6318
6319           /* build_duplicate_type doesn't work for C++.  */
6320           if (c_dialect_cxx ())
6321             goto ignored;
6322
6323           /* A type variant isn't good enough, since we don't a cast
6324              to such a type removed as a no-op.  */
6325           *node = type = build_duplicate_type (type);
6326         }
6327
6328       TYPE_TRANSPARENT_AGGR (type) = 1;
6329       return NULL_TREE;
6330     }
6331
6332  ignored:
6333   warning (OPT_Wattributes, "%qE attribute ignored", name);
6334   return NULL_TREE;
6335 }
6336
6337 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
6338    get the requested priority for a constructor or destructor,
6339    possibly issuing diagnostics for invalid or reserved
6340    priorities.  */
6341
6342 static priority_type
6343 get_priority (tree args, bool is_destructor)
6344 {
6345   HOST_WIDE_INT pri;
6346   tree arg;
6347
6348   if (!args)
6349     return DEFAULT_INIT_PRIORITY;
6350
6351   if (!SUPPORTS_INIT_PRIORITY)
6352     {
6353       if (is_destructor)
6354         error ("destructor priorities are not supported");
6355       else
6356         error ("constructor priorities are not supported");
6357       return DEFAULT_INIT_PRIORITY;
6358     }
6359
6360   arg = TREE_VALUE (args);
6361   if (!host_integerp (arg, /*pos=*/0)
6362       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
6363     goto invalid;
6364
6365   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
6366   if (pri < 0 || pri > MAX_INIT_PRIORITY)
6367     goto invalid;
6368
6369   if (pri <= MAX_RESERVED_INIT_PRIORITY)
6370     {
6371       if (is_destructor)
6372         warning (0,
6373                  "destructor priorities from 0 to %d are reserved "
6374                  "for the implementation",
6375                  MAX_RESERVED_INIT_PRIORITY);
6376       else
6377         warning (0,
6378                  "constructor priorities from 0 to %d are reserved "
6379                  "for the implementation",
6380                  MAX_RESERVED_INIT_PRIORITY);
6381     }
6382   return pri;
6383
6384  invalid:
6385   if (is_destructor)
6386     error ("destructor priorities must be integers from 0 to %d inclusive",
6387            MAX_INIT_PRIORITY);
6388   else
6389     error ("constructor priorities must be integers from 0 to %d inclusive",
6390            MAX_INIT_PRIORITY);
6391   return DEFAULT_INIT_PRIORITY;
6392 }
6393
6394 /* Handle a "constructor" attribute; arguments as in
6395    struct attribute_spec.handler.  */
6396
6397 static tree
6398 handle_constructor_attribute (tree *node, tree name, tree args,
6399                               int ARG_UNUSED (flags),
6400                               bool *no_add_attrs)
6401 {
6402   tree decl = *node;
6403   tree type = TREE_TYPE (decl);
6404
6405   if (TREE_CODE (decl) == FUNCTION_DECL
6406       && TREE_CODE (type) == FUNCTION_TYPE
6407       && decl_function_context (decl) == 0)
6408     {
6409       priority_type priority;
6410       DECL_STATIC_CONSTRUCTOR (decl) = 1;
6411       priority = get_priority (args, /*is_destructor=*/false);
6412       SET_DECL_INIT_PRIORITY (decl, priority);
6413       TREE_USED (decl) = 1;
6414     }
6415   else
6416     {
6417       warning (OPT_Wattributes, "%qE attribute ignored", name);
6418       *no_add_attrs = true;
6419     }
6420
6421   return NULL_TREE;
6422 }
6423
6424 /* Handle a "destructor" attribute; arguments as in
6425    struct attribute_spec.handler.  */
6426
6427 static tree
6428 handle_destructor_attribute (tree *node, tree name, tree args,
6429                              int ARG_UNUSED (flags),
6430                              bool *no_add_attrs)
6431 {
6432   tree decl = *node;
6433   tree type = TREE_TYPE (decl);
6434
6435   if (TREE_CODE (decl) == FUNCTION_DECL
6436       && TREE_CODE (type) == FUNCTION_TYPE
6437       && decl_function_context (decl) == 0)
6438     {
6439       priority_type priority;
6440       DECL_STATIC_DESTRUCTOR (decl) = 1;
6441       priority = get_priority (args, /*is_destructor=*/true);
6442       SET_DECL_FINI_PRIORITY (decl, priority);
6443       TREE_USED (decl) = 1;
6444     }
6445   else
6446     {
6447       warning (OPT_Wattributes, "%qE attribute ignored", name);
6448       *no_add_attrs = true;
6449     }
6450
6451   return NULL_TREE;
6452 }
6453
6454 /* Nonzero if the mode is a valid vector mode for this architecture.
6455    This returns nonzero even if there is no hardware support for the
6456    vector mode, but we can emulate with narrower modes.  */
6457
6458 static int
6459 vector_mode_valid_p (enum machine_mode mode)
6460 {
6461   enum mode_class mclass = GET_MODE_CLASS (mode);
6462   enum machine_mode innermode;
6463
6464   /* Doh!  What's going on?  */
6465   if (mclass != MODE_VECTOR_INT
6466       && mclass != MODE_VECTOR_FLOAT
6467       && mclass != MODE_VECTOR_FRACT
6468       && mclass != MODE_VECTOR_UFRACT
6469       && mclass != MODE_VECTOR_ACCUM
6470       && mclass != MODE_VECTOR_UACCUM)
6471     return 0;
6472
6473   /* Hardware support.  Woo hoo!  */
6474   if (targetm.vector_mode_supported_p (mode))
6475     return 1;
6476
6477   innermode = GET_MODE_INNER (mode);
6478
6479   /* We should probably return 1 if requesting V4DI and we have no DI,
6480      but we have V2DI, but this is probably very unlikely.  */
6481
6482   /* If we have support for the inner mode, we can safely emulate it.
6483      We may not have V2DI, but me can emulate with a pair of DIs.  */
6484   return targetm.scalar_mode_supported_p (innermode);
6485 }
6486
6487
6488 /* Handle a "mode" attribute; arguments as in
6489    struct attribute_spec.handler.  */
6490
6491 static tree
6492 handle_mode_attribute (tree *node, tree name, tree args,
6493                        int ARG_UNUSED (flags), bool *no_add_attrs)
6494 {
6495   tree type = *node;
6496   tree ident = TREE_VALUE (args);
6497
6498   *no_add_attrs = true;
6499
6500   if (TREE_CODE (ident) != IDENTIFIER_NODE)
6501     warning (OPT_Wattributes, "%qE attribute ignored", name);
6502   else
6503     {
6504       int j;
6505       const char *p = IDENTIFIER_POINTER (ident);
6506       int len = strlen (p);
6507       enum machine_mode mode = VOIDmode;
6508       tree typefm;
6509       bool valid_mode;
6510
6511       if (len > 4 && p[0] == '_' && p[1] == '_'
6512           && p[len - 1] == '_' && p[len - 2] == '_')
6513         {
6514           char *newp = (char *) alloca (len - 1);
6515
6516           strcpy (newp, &p[2]);
6517           newp[len - 4] = '\0';
6518           p = newp;
6519         }
6520
6521       /* Change this type to have a type with the specified mode.
6522          First check for the special modes.  */
6523       if (!strcmp (p, "byte"))
6524         mode = byte_mode;
6525       else if (!strcmp (p, "word"))
6526         mode = word_mode;
6527       else if (!strcmp (p, "pointer"))
6528         mode = ptr_mode;
6529       else if (!strcmp (p, "libgcc_cmp_return"))
6530         mode = targetm.libgcc_cmp_return_mode ();
6531       else if (!strcmp (p, "libgcc_shift_count"))
6532         mode = targetm.libgcc_shift_count_mode ();
6533       else if (!strcmp (p, "unwind_word"))
6534         mode = targetm.unwind_word_mode ();
6535       else
6536         for (j = 0; j < NUM_MACHINE_MODES; j++)
6537           if (!strcmp (p, GET_MODE_NAME (j)))
6538             {
6539               mode = (enum machine_mode) j;
6540               break;
6541             }
6542
6543       if (mode == VOIDmode)
6544         {
6545           error ("unknown machine mode %qE", ident);
6546           return NULL_TREE;
6547         }
6548
6549       valid_mode = false;
6550       switch (GET_MODE_CLASS (mode))
6551         {
6552         case MODE_INT:
6553         case MODE_PARTIAL_INT:
6554         case MODE_FLOAT:
6555         case MODE_DECIMAL_FLOAT:
6556         case MODE_FRACT:
6557         case MODE_UFRACT:
6558         case MODE_ACCUM:
6559         case MODE_UACCUM:
6560           valid_mode = targetm.scalar_mode_supported_p (mode);
6561           break;
6562
6563         case MODE_COMPLEX_INT:
6564         case MODE_COMPLEX_FLOAT:
6565           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
6566           break;
6567
6568         case MODE_VECTOR_INT:
6569         case MODE_VECTOR_FLOAT:
6570         case MODE_VECTOR_FRACT:
6571         case MODE_VECTOR_UFRACT:
6572         case MODE_VECTOR_ACCUM:
6573         case MODE_VECTOR_UACCUM:
6574           warning (OPT_Wattributes, "specifying vector types with "
6575                    "__attribute__ ((mode)) is deprecated");
6576           warning (OPT_Wattributes,
6577                    "use __attribute__ ((vector_size)) instead");
6578           valid_mode = vector_mode_valid_p (mode);
6579           break;
6580
6581         default:
6582           break;
6583         }
6584       if (!valid_mode)
6585         {
6586           error ("unable to emulate %qs", p);
6587           return NULL_TREE;
6588         }
6589
6590       if (POINTER_TYPE_P (type))
6591         {
6592           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (type));
6593           tree (*fn)(tree, enum machine_mode, bool);
6594
6595           if (!targetm.addr_space.valid_pointer_mode (mode, as))
6596             {
6597               error ("invalid pointer mode %qs", p);
6598               return NULL_TREE;
6599             }
6600
6601           if (TREE_CODE (type) == POINTER_TYPE)
6602             fn = build_pointer_type_for_mode;
6603           else
6604             fn = build_reference_type_for_mode;
6605           typefm = fn (TREE_TYPE (type), mode, false);
6606         }
6607       else
6608         {
6609           /* For fixed-point modes, we need to test if the signness of type
6610              and the machine mode are consistent.  */
6611           if (ALL_FIXED_POINT_MODE_P (mode)
6612               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
6613             {
6614               error ("signedness of type and machine mode %qs don%'t match", p);
6615               return NULL_TREE;
6616             }
6617           /* For fixed-point modes, we need to pass saturating info.  */
6618           typefm = lang_hooks.types.type_for_mode (mode,
6619                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
6620                                                       : TYPE_UNSIGNED (type));
6621         }
6622
6623       if (typefm == NULL_TREE)
6624         {
6625           error ("no data type for mode %qs", p);
6626           return NULL_TREE;
6627         }
6628       else if (TREE_CODE (type) == ENUMERAL_TYPE)
6629         {
6630           /* For enumeral types, copy the precision from the integer
6631              type returned above.  If not an INTEGER_TYPE, we can't use
6632              this mode for this type.  */
6633           if (TREE_CODE (typefm) != INTEGER_TYPE)
6634             {
6635               error ("cannot use mode %qs for enumeral types", p);
6636               return NULL_TREE;
6637             }
6638
6639           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
6640             {
6641               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
6642               typefm = type;
6643             }
6644           else
6645             {
6646               /* We cannot build a type variant, as there's code that assumes
6647                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
6648                  debug generators.  Instead, create a subrange type.  This
6649                  results in all of the enumeral values being emitted only once
6650                  in the original, and the subtype gets them by reference.  */
6651               if (TYPE_UNSIGNED (type))
6652                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
6653               else
6654                 typefm = make_signed_type (TYPE_PRECISION (typefm));
6655               TREE_TYPE (typefm) = type;
6656             }
6657         }
6658       else if (VECTOR_MODE_P (mode)
6659                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
6660                : TREE_CODE (type) != TREE_CODE (typefm))
6661         {
6662           error ("mode %qs applied to inappropriate type", p);
6663           return NULL_TREE;
6664         }
6665
6666       *node = typefm;
6667     }
6668
6669   return NULL_TREE;
6670 }
6671
6672 /* Handle a "section" attribute; arguments as in
6673    struct attribute_spec.handler.  */
6674
6675 static tree
6676 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6677                           int ARG_UNUSED (flags), bool *no_add_attrs)
6678 {
6679   tree decl = *node;
6680
6681   if (targetm_common.have_named_sections)
6682     {
6683       user_defined_section_attribute = true;
6684
6685       if ((TREE_CODE (decl) == FUNCTION_DECL
6686            || TREE_CODE (decl) == VAR_DECL)
6687           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
6688         {
6689           if (TREE_CODE (decl) == VAR_DECL
6690               && current_function_decl != NULL_TREE
6691               && !TREE_STATIC (decl))
6692             {
6693               error_at (DECL_SOURCE_LOCATION (decl),
6694                         "section attribute cannot be specified for "
6695                         "local variables");
6696               *no_add_attrs = true;
6697             }
6698
6699           /* The decl may have already been given a section attribute
6700              from a previous declaration.  Ensure they match.  */
6701           else if (DECL_SECTION_NAME (decl) != NULL_TREE
6702                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
6703                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
6704             {
6705               error ("section of %q+D conflicts with previous declaration",
6706                      *node);
6707               *no_add_attrs = true;
6708             }
6709           else if (TREE_CODE (decl) == VAR_DECL
6710                    && !targetm.have_tls && targetm.emutls.tmpl_section
6711                    && DECL_THREAD_LOCAL_P (decl))
6712             {
6713               error ("section of %q+D cannot be overridden", *node);
6714               *no_add_attrs = true;
6715             }
6716           else
6717             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
6718         }
6719       else
6720         {
6721           error ("section attribute not allowed for %q+D", *node);
6722           *no_add_attrs = true;
6723         }
6724     }
6725   else
6726     {
6727       error_at (DECL_SOURCE_LOCATION (*node),
6728                 "section attributes are not supported for this target");
6729       *no_add_attrs = true;
6730     }
6731
6732   return NULL_TREE;
6733 }
6734
6735 /* Check whether ALIGN is a valid user-specified alignment.  If so,
6736    return its base-2 log; if not, output an error and return -1.  If
6737    ALLOW_ZERO then 0 is valid and should result in a return of -1 with
6738    no error.  */
6739 int
6740 check_user_alignment (const_tree align, bool allow_zero)
6741 {
6742   int i;
6743
6744   if (!INTEGRAL_TYPE_P (TREE_TYPE (align))
6745       || TREE_CODE (align) != INTEGER_CST)
6746     {
6747       error ("requested alignment is not an integer constant");
6748       return -1;
6749     }
6750   else if (allow_zero && integer_zerop (align))
6751     return -1;
6752   else if ((i = tree_log2 (align)) == -1)
6753     {
6754       error ("requested alignment is not a power of 2");
6755       return -1;
6756     }
6757   else if (i >= HOST_BITS_PER_INT - BITS_PER_UNIT_LOG)
6758     {
6759       error ("requested alignment is too large");
6760       return -1;
6761     }
6762   return i;
6763 }
6764
6765 /* Handle a "aligned" attribute; arguments as in
6766    struct attribute_spec.handler.  */
6767
6768 static tree
6769 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6770                           int flags, bool *no_add_attrs)
6771 {
6772   tree decl = NULL_TREE;
6773   tree *type = NULL;
6774   int is_type = 0;
6775   tree align_expr = (args ? TREE_VALUE (args)
6776                      : size_int (ATTRIBUTE_ALIGNED_VALUE / BITS_PER_UNIT));
6777   int i;
6778
6779   if (DECL_P (*node))
6780     {
6781       decl = *node;
6782       type = &TREE_TYPE (decl);
6783       is_type = TREE_CODE (*node) == TYPE_DECL;
6784     }
6785   else if (TYPE_P (*node))
6786     type = node, is_type = 1;
6787
6788   if ((i = check_user_alignment (align_expr, false)) == -1)
6789     *no_add_attrs = true;
6790   else if (is_type)
6791     {
6792       if ((flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6793         /* OK, modify the type in place.  */;
6794       /* If we have a TYPE_DECL, then copy the type, so that we
6795          don't accidentally modify a builtin type.  See pushdecl.  */
6796       else if (decl && TREE_TYPE (decl) != error_mark_node
6797                && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
6798         {
6799           tree tt = TREE_TYPE (decl);
6800           *type = build_variant_type_copy (*type);
6801           DECL_ORIGINAL_TYPE (decl) = tt;
6802           TYPE_NAME (*type) = decl;
6803           TREE_USED (*type) = TREE_USED (decl);
6804           TREE_TYPE (decl) = *type;
6805         }
6806       else
6807         *type = build_variant_type_copy (*type);
6808
6809       TYPE_ALIGN (*type) = (1U << i) * BITS_PER_UNIT;
6810       TYPE_USER_ALIGN (*type) = 1;
6811     }
6812   else if (! VAR_OR_FUNCTION_DECL_P (decl)
6813            && TREE_CODE (decl) != FIELD_DECL)
6814     {
6815       error ("alignment may not be specified for %q+D", decl);
6816       *no_add_attrs = true;
6817     }
6818   else if (TREE_CODE (decl) == FUNCTION_DECL
6819            && DECL_ALIGN (decl) > (1U << i) * BITS_PER_UNIT)
6820     {
6821       if (DECL_USER_ALIGN (decl))
6822         error ("alignment for %q+D was previously specified as %d "
6823                "and may not be decreased", decl,
6824                DECL_ALIGN (decl) / BITS_PER_UNIT);
6825       else
6826         error ("alignment for %q+D must be at least %d", decl,
6827                DECL_ALIGN (decl) / BITS_PER_UNIT);
6828       *no_add_attrs = true;
6829     }
6830   else
6831     {
6832       DECL_ALIGN (decl) = (1U << i) * BITS_PER_UNIT;
6833       DECL_USER_ALIGN (decl) = 1;
6834     }
6835
6836   return NULL_TREE;
6837 }
6838
6839 /* Handle a "weak" attribute; arguments as in
6840    struct attribute_spec.handler.  */
6841
6842 static tree
6843 handle_weak_attribute (tree *node, tree name,
6844                        tree ARG_UNUSED (args),
6845                        int ARG_UNUSED (flags),
6846                        bool * ARG_UNUSED (no_add_attrs))
6847 {
6848   if (TREE_CODE (*node) == FUNCTION_DECL
6849       && DECL_DECLARED_INLINE_P (*node))
6850     {
6851       warning (OPT_Wattributes, "inline function %q+D declared weak", *node);
6852       *no_add_attrs = true;
6853     }
6854   else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6855     {
6856       error ("indirect function %q+D cannot be declared weak", *node);
6857       *no_add_attrs = true;
6858       return NULL_TREE;
6859     }
6860   else if (TREE_CODE (*node) == FUNCTION_DECL
6861            || TREE_CODE (*node) == VAR_DECL)
6862     declare_weak (*node);
6863   else
6864     warning (OPT_Wattributes, "%qE attribute ignored", name);
6865
6866   return NULL_TREE;
6867 }
6868
6869 /* Handle an "alias" or "ifunc" attribute; arguments as in
6870    struct attribute_spec.handler, except that IS_ALIAS tells us
6871    whether this is an alias as opposed to ifunc attribute.  */
6872
6873 static tree
6874 handle_alias_ifunc_attribute (bool is_alias, tree *node, tree name, tree args,
6875                               bool *no_add_attrs)
6876 {
6877   tree decl = *node;
6878
6879   if (TREE_CODE (decl) != FUNCTION_DECL
6880       && (!is_alias || TREE_CODE (decl) != VAR_DECL))
6881     {
6882       warning (OPT_Wattributes, "%qE attribute ignored", name);
6883       *no_add_attrs = true;
6884     }
6885   else if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6886       || (TREE_CODE (decl) != FUNCTION_DECL
6887           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6888       /* A static variable declaration is always a tentative definition,
6889          but the alias is a non-tentative definition which overrides.  */
6890       || (TREE_CODE (decl) != FUNCTION_DECL
6891           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6892     {
6893       error ("%q+D defined both normally and as %qE attribute", decl, name);
6894       *no_add_attrs = true;
6895       return NULL_TREE;
6896     }
6897   else if (!is_alias
6898            && (lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
6899                || lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))))
6900     {
6901       error ("weak %q+D cannot be defined %qE", decl, name);
6902       *no_add_attrs = true;
6903       return NULL_TREE;
6904     }
6905
6906   /* Note that the very first time we process a nested declaration,
6907      decl_function_context will not be set.  Indeed, *would* never
6908      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6909      we do below.  After such frobbery, pushdecl would set the context.
6910      In any case, this is never what we want.  */
6911   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6912     {
6913       tree id;
6914
6915       id = TREE_VALUE (args);
6916       if (TREE_CODE (id) != STRING_CST)
6917         {
6918           error ("attribute %qE argument not a string", name);
6919           *no_add_attrs = true;
6920           return NULL_TREE;
6921         }
6922       id = get_identifier (TREE_STRING_POINTER (id));
6923       /* This counts as a use of the object pointed to.  */
6924       TREE_USED (id) = 1;
6925
6926       if (TREE_CODE (decl) == FUNCTION_DECL)
6927         DECL_INITIAL (decl) = error_mark_node;
6928       else
6929         {
6930           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6931             DECL_EXTERNAL (decl) = 1;
6932           else
6933             DECL_EXTERNAL (decl) = 0;
6934           TREE_STATIC (decl) = 1;
6935         }
6936
6937       if (!is_alias)
6938         /* ifuncs are also aliases, so set that attribute too. */
6939         DECL_ATTRIBUTES (decl)
6940           = tree_cons (get_identifier ("alias"), args, DECL_ATTRIBUTES (decl));
6941     }
6942   else
6943     {
6944       warning (OPT_Wattributes, "%qE attribute ignored", name);
6945       *no_add_attrs = true;
6946     }
6947
6948   return NULL_TREE;
6949 }
6950
6951 /* Handle an "alias" or "ifunc" attribute; arguments as in
6952    struct attribute_spec.handler.  */
6953
6954 static tree
6955 handle_ifunc_attribute (tree *node, tree name, tree args,
6956                         int ARG_UNUSED (flags), bool *no_add_attrs)
6957 {
6958   return handle_alias_ifunc_attribute (false, node, name, args, no_add_attrs);
6959 }
6960
6961 /* Handle an "alias" or "ifunc" attribute; arguments as in
6962    struct attribute_spec.handler.  */
6963
6964 static tree
6965 handle_alias_attribute (tree *node, tree name, tree args,
6966                         int ARG_UNUSED (flags), bool *no_add_attrs)
6967 {
6968   return handle_alias_ifunc_attribute (true, node, name, args, no_add_attrs);
6969 }
6970
6971 /* Handle a "weakref" attribute; arguments as in struct
6972    attribute_spec.handler.  */
6973
6974 static tree
6975 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6976                           int flags, bool *no_add_attrs)
6977 {
6978   tree attr = NULL_TREE;
6979
6980   /* We must ignore the attribute when it is associated with
6981      local-scoped decls, since attribute alias is ignored and many
6982      such symbols do not even have a DECL_WEAK field.  */
6983   if (decl_function_context (*node)
6984       || current_function_decl
6985       || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6986     {
6987       warning (OPT_Wattributes, "%qE attribute ignored", name);
6988       *no_add_attrs = true;
6989       return NULL_TREE;
6990     }
6991
6992   if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (*node)))
6993     {
6994       error ("indirect function %q+D cannot be declared weakref", *node);
6995       *no_add_attrs = true;
6996       return NULL_TREE;
6997     }
6998
6999   /* The idea here is that `weakref("name")' mutates into `weakref,
7000      alias("name")', and weakref without arguments, in turn,
7001      implicitly adds weak. */
7002
7003   if (args)
7004     {
7005       attr = tree_cons (get_identifier ("alias"), args, attr);
7006       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
7007
7008       *no_add_attrs = true;
7009
7010       decl_attributes (node, attr, flags);
7011     }
7012   else
7013     {
7014       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
7015         error_at (DECL_SOURCE_LOCATION (*node),
7016                   "weakref attribute must appear before alias attribute");
7017
7018       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
7019          and that isn't supported; and because it wants to add it to
7020          the list of weak decls, which isn't helpful.  */
7021       DECL_WEAK (*node) = 1;
7022     }
7023
7024   return NULL_TREE;
7025 }
7026
7027 /* Handle an "visibility" attribute; arguments as in
7028    struct attribute_spec.handler.  */
7029
7030 static tree
7031 handle_visibility_attribute (tree *node, tree name, tree args,
7032                              int ARG_UNUSED (flags),
7033                              bool *ARG_UNUSED (no_add_attrs))
7034 {
7035   tree decl = *node;
7036   tree id = TREE_VALUE (args);
7037   enum symbol_visibility vis;
7038
7039   if (TYPE_P (*node))
7040     {
7041       if (TREE_CODE (*node) == ENUMERAL_TYPE)
7042         /* OK */;
7043       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
7044         {
7045           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
7046                    name);
7047           return NULL_TREE;
7048         }
7049       else if (TYPE_FIELDS (*node))
7050         {
7051           error ("%qE attribute ignored because %qT is already defined",
7052                  name, *node);
7053           return NULL_TREE;
7054         }
7055     }
7056   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
7057     {
7058       warning (OPT_Wattributes, "%qE attribute ignored", name);
7059       return NULL_TREE;
7060     }
7061
7062   if (TREE_CODE (id) != STRING_CST)
7063     {
7064       error ("visibility argument not a string");
7065       return NULL_TREE;
7066     }
7067
7068   /*  If this is a type, set the visibility on the type decl.  */
7069   if (TYPE_P (decl))
7070     {
7071       decl = TYPE_NAME (decl);
7072       if (!decl)
7073         return NULL_TREE;
7074       if (TREE_CODE (decl) == IDENTIFIER_NODE)
7075         {
7076            warning (OPT_Wattributes, "%qE attribute ignored on types",
7077                     name);
7078            return NULL_TREE;
7079         }
7080     }
7081
7082   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
7083     vis = VISIBILITY_DEFAULT;
7084   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
7085     vis = VISIBILITY_INTERNAL;
7086   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
7087     vis = VISIBILITY_HIDDEN;
7088   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
7089     vis = VISIBILITY_PROTECTED;
7090   else
7091     {
7092       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
7093       vis = VISIBILITY_DEFAULT;
7094     }
7095
7096   if (DECL_VISIBILITY_SPECIFIED (decl)
7097       && vis != DECL_VISIBILITY (decl))
7098     {
7099       tree attributes = (TYPE_P (*node)
7100                          ? TYPE_ATTRIBUTES (*node)
7101                          : DECL_ATTRIBUTES (decl));
7102       if (lookup_attribute ("visibility", attributes))
7103         error ("%qD redeclared with different visibility", decl);
7104       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7105                && lookup_attribute ("dllimport", attributes))
7106         error ("%qD was declared %qs which implies default visibility",
7107                decl, "dllimport");
7108       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7109                && lookup_attribute ("dllexport", attributes))
7110         error ("%qD was declared %qs which implies default visibility",
7111                decl, "dllexport");
7112     }
7113
7114   DECL_VISIBILITY (decl) = vis;
7115   DECL_VISIBILITY_SPECIFIED (decl) = 1;
7116
7117   /* Go ahead and attach the attribute to the node as well.  This is needed
7118      so we can determine whether we have VISIBILITY_DEFAULT because the
7119      visibility was not specified, or because it was explicitly overridden
7120      from the containing scope.  */
7121
7122   return NULL_TREE;
7123 }
7124
7125 /* Determine the ELF symbol visibility for DECL, which is either a
7126    variable or a function.  It is an error to use this function if a
7127    definition of DECL is not available in this translation unit.
7128    Returns true if the final visibility has been determined by this
7129    function; false if the caller is free to make additional
7130    modifications.  */
7131
7132 bool
7133 c_determine_visibility (tree decl)
7134 {
7135   gcc_assert (TREE_CODE (decl) == VAR_DECL
7136               || TREE_CODE (decl) == FUNCTION_DECL);
7137
7138   /* If the user explicitly specified the visibility with an
7139      attribute, honor that.  DECL_VISIBILITY will have been set during
7140      the processing of the attribute.  We check for an explicit
7141      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
7142      to distinguish the use of an attribute from the use of a "#pragma
7143      GCC visibility push(...)"; in the latter case we still want other
7144      considerations to be able to overrule the #pragma.  */
7145   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
7146       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
7147           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
7148               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
7149     return true;
7150
7151   /* Set default visibility to whatever the user supplied with
7152      visibility_specified depending on #pragma GCC visibility.  */
7153   if (!DECL_VISIBILITY_SPECIFIED (decl))
7154     {
7155       if (visibility_options.inpragma
7156           || DECL_VISIBILITY (decl) != default_visibility)
7157         {
7158           DECL_VISIBILITY (decl) = default_visibility;
7159           DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
7160           /* If visibility changed and DECL already has DECL_RTL, ensure
7161              symbol flags are updated.  */
7162           if (((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
7163                || TREE_CODE (decl) == FUNCTION_DECL)
7164               && DECL_RTL_SET_P (decl))
7165             make_decl_rtl (decl);
7166         }
7167     }
7168   return false;
7169 }
7170
7171 /* Handle an "tls_model" attribute; arguments as in
7172    struct attribute_spec.handler.  */
7173
7174 static tree
7175 handle_tls_model_attribute (tree *node, tree name, tree args,
7176                             int ARG_UNUSED (flags), bool *no_add_attrs)
7177 {
7178   tree id;
7179   tree decl = *node;
7180   enum tls_model kind;
7181
7182   *no_add_attrs = true;
7183
7184   if (TREE_CODE (decl) != VAR_DECL || !DECL_THREAD_LOCAL_P (decl))
7185     {
7186       warning (OPT_Wattributes, "%qE attribute ignored", name);
7187       return NULL_TREE;
7188     }
7189
7190   kind = DECL_TLS_MODEL (decl);
7191   id = TREE_VALUE (args);
7192   if (TREE_CODE (id) != STRING_CST)
7193     {
7194       error ("tls_model argument not a string");
7195       return NULL_TREE;
7196     }
7197
7198   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
7199     kind = TLS_MODEL_LOCAL_EXEC;
7200   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
7201     kind = TLS_MODEL_INITIAL_EXEC;
7202   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
7203     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
7204   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
7205     kind = TLS_MODEL_GLOBAL_DYNAMIC;
7206   else
7207     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
7208
7209   DECL_TLS_MODEL (decl) = kind;
7210   return NULL_TREE;
7211 }
7212
7213 /* Handle a "no_instrument_function" attribute; arguments as in
7214    struct attribute_spec.handler.  */
7215
7216 static tree
7217 handle_no_instrument_function_attribute (tree *node, tree name,
7218                                          tree ARG_UNUSED (args),
7219                                          int ARG_UNUSED (flags),
7220                                          bool *no_add_attrs)
7221 {
7222   tree decl = *node;
7223
7224   if (TREE_CODE (decl) != FUNCTION_DECL)
7225     {
7226       error_at (DECL_SOURCE_LOCATION (decl),
7227                 "%qE attribute applies only to functions", name);
7228       *no_add_attrs = true;
7229     }
7230   else if (DECL_INITIAL (decl))
7231     {
7232       error_at (DECL_SOURCE_LOCATION (decl),
7233                 "can%'t set %qE attribute after definition", name);
7234       *no_add_attrs = true;
7235     }
7236   else
7237     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
7238
7239   return NULL_TREE;
7240 }
7241
7242 /* Handle a "malloc" attribute; arguments as in
7243    struct attribute_spec.handler.  */
7244
7245 static tree
7246 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7247                          int ARG_UNUSED (flags), bool *no_add_attrs)
7248 {
7249   if (TREE_CODE (*node) == FUNCTION_DECL
7250       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
7251     DECL_IS_MALLOC (*node) = 1;
7252   else
7253     {
7254       warning (OPT_Wattributes, "%qE attribute ignored", name);
7255       *no_add_attrs = true;
7256     }
7257
7258   return NULL_TREE;
7259 }
7260
7261 /* Handle a "alloc_size" attribute; arguments as in
7262    struct attribute_spec.handler.  */
7263
7264 static tree
7265 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
7266                              int ARG_UNUSED (flags), bool *no_add_attrs)
7267 {
7268   unsigned arg_count = type_num_arguments (*node);
7269   for (; args; args = TREE_CHAIN (args))
7270     {
7271       tree position = TREE_VALUE (args);
7272
7273       if (TREE_CODE (position) != INTEGER_CST
7274           || TREE_INT_CST_HIGH (position)
7275           || TREE_INT_CST_LOW (position) < 1
7276           || TREE_INT_CST_LOW (position) > arg_count )
7277         {
7278           warning (OPT_Wattributes,
7279                    "alloc_size parameter outside range");
7280           *no_add_attrs = true;
7281           return NULL_TREE;
7282         }
7283     }
7284   return NULL_TREE;
7285 }
7286
7287 /* Handle a "fn spec" attribute; arguments as in
7288    struct attribute_spec.handler.  */
7289
7290 static tree
7291 handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name),
7292                          tree args, int ARG_UNUSED (flags),
7293                          bool *no_add_attrs ATTRIBUTE_UNUSED)
7294 {
7295   gcc_assert (args
7296               && TREE_CODE (TREE_VALUE (args)) == STRING_CST
7297               && !TREE_CHAIN (args));
7298   return NULL_TREE;
7299 }
7300
7301 /* Handle a "returns_twice" attribute; arguments as in
7302    struct attribute_spec.handler.  */
7303
7304 static tree
7305 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7306                          int ARG_UNUSED (flags), bool *no_add_attrs)
7307 {
7308   if (TREE_CODE (*node) == FUNCTION_DECL)
7309     DECL_IS_RETURNS_TWICE (*node) = 1;
7310   else
7311     {
7312       warning (OPT_Wattributes, "%qE attribute ignored", name);
7313       *no_add_attrs = true;
7314     }
7315
7316   return NULL_TREE;
7317 }
7318
7319 /* Handle a "no_limit_stack" attribute; arguments as in
7320    struct attribute_spec.handler.  */
7321
7322 static tree
7323 handle_no_limit_stack_attribute (tree *node, tree name,
7324                                  tree ARG_UNUSED (args),
7325                                  int ARG_UNUSED (flags),
7326                                  bool *no_add_attrs)
7327 {
7328   tree decl = *node;
7329
7330   if (TREE_CODE (decl) != FUNCTION_DECL)
7331     {
7332       error_at (DECL_SOURCE_LOCATION (decl),
7333              "%qE attribute applies only to functions", name);
7334       *no_add_attrs = true;
7335     }
7336   else if (DECL_INITIAL (decl))
7337     {
7338       error_at (DECL_SOURCE_LOCATION (decl),
7339                 "can%'t set %qE attribute after definition", name);
7340       *no_add_attrs = true;
7341     }
7342   else
7343     DECL_NO_LIMIT_STACK (decl) = 1;
7344
7345   return NULL_TREE;
7346 }
7347
7348 /* Handle a "pure" attribute; arguments as in
7349    struct attribute_spec.handler.  */
7350
7351 static tree
7352 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7353                        int ARG_UNUSED (flags), bool *no_add_attrs)
7354 {
7355   if (TREE_CODE (*node) == FUNCTION_DECL)
7356     DECL_PURE_P (*node) = 1;
7357   /* ??? TODO: Support types.  */
7358   else
7359     {
7360       warning (OPT_Wattributes, "%qE attribute ignored", name);
7361       *no_add_attrs = true;
7362     }
7363
7364   return NULL_TREE;
7365 }
7366
7367 /* Digest an attribute list destined for a transactional memory statement.
7368    ALLOWED is the set of attributes that are allowed for this statement;
7369    return the attribute we parsed.  Multiple attributes are never allowed.  */
7370
7371 int
7372 parse_tm_stmt_attr (tree attrs, int allowed)
7373 {
7374   tree a_seen = NULL;
7375   int m_seen = 0;
7376
7377   for ( ; attrs ; attrs = TREE_CHAIN (attrs))
7378     {
7379       tree a = TREE_PURPOSE (attrs);
7380       int m = 0;
7381
7382       if (is_attribute_p ("outer", a))
7383         m = TM_STMT_ATTR_OUTER;
7384
7385       if ((m & allowed) == 0)
7386         {
7387           warning (OPT_Wattributes, "%qE attribute directive ignored", a);
7388           continue;
7389         }
7390
7391       if (m_seen == 0)
7392         {
7393           a_seen = a;
7394           m_seen = m;
7395         }
7396       else if (m_seen == m)
7397         warning (OPT_Wattributes, "%qE attribute duplicated", a);
7398       else
7399         warning (OPT_Wattributes, "%qE attribute follows %qE", a, a_seen);
7400     }
7401
7402   return m_seen;
7403 }
7404
7405 /* Transform a TM attribute name into a maskable integer and back.
7406    Note that NULL (i.e. no attribute) is mapped to UNKNOWN, corresponding
7407    to how the lack of an attribute is treated.  */
7408
7409 int
7410 tm_attr_to_mask (tree attr)
7411 {
7412   if (attr == NULL)
7413     return 0;
7414   if (is_attribute_p ("transaction_safe", attr))
7415     return TM_ATTR_SAFE;
7416   if (is_attribute_p ("transaction_callable", attr))
7417     return TM_ATTR_CALLABLE;
7418   if (is_attribute_p ("transaction_pure", attr))
7419     return TM_ATTR_PURE;
7420   if (is_attribute_p ("transaction_unsafe", attr))
7421     return TM_ATTR_IRREVOCABLE;
7422   if (is_attribute_p ("transaction_may_cancel_outer", attr))
7423     return TM_ATTR_MAY_CANCEL_OUTER;
7424   return 0;
7425 }
7426
7427 tree
7428 tm_mask_to_attr (int mask)
7429 {
7430   const char *str;
7431   switch (mask)
7432     {
7433     case TM_ATTR_SAFE:
7434       str = "transaction_safe";
7435       break;
7436     case TM_ATTR_CALLABLE:
7437       str = "transaction_callable";
7438       break;
7439     case TM_ATTR_PURE:
7440       str = "transaction_pure";
7441       break;
7442     case TM_ATTR_IRREVOCABLE:
7443       str = "transaction_unsafe";
7444       break;
7445     case TM_ATTR_MAY_CANCEL_OUTER:
7446       str = "transaction_may_cancel_outer";
7447       break;
7448     default:
7449       gcc_unreachable ();
7450     }
7451   return get_identifier (str);
7452 }
7453
7454 /* Return the first TM attribute seen in LIST.  */
7455
7456 tree
7457 find_tm_attribute (tree list)
7458 {
7459   for (; list ; list = TREE_CHAIN (list))
7460     {
7461       tree name = TREE_PURPOSE (list);
7462       if (tm_attr_to_mask (name) != 0)
7463         return name;
7464     }
7465   return NULL_TREE;
7466 }
7467
7468 /* Handle the TM attributes; arguments as in struct attribute_spec.handler.
7469    Here we accept only function types, and verify that none of the other
7470    function TM attributes are also applied.  */
7471 /* ??? We need to accept class types for C++, but not C.  This greatly
7472    complicates this function, since we can no longer rely on the extra
7473    processing given by function_type_required.  */
7474
7475 static tree
7476 handle_tm_attribute (tree *node, tree name, tree args,
7477                      int flags, bool *no_add_attrs)
7478 {
7479   /* Only one path adds the attribute; others don't.  */
7480   *no_add_attrs = true;
7481
7482   switch (TREE_CODE (*node))
7483     {
7484     case RECORD_TYPE:
7485     case UNION_TYPE:
7486       /* Only tm_callable and tm_safe apply to classes.  */
7487       if (tm_attr_to_mask (name) & ~(TM_ATTR_SAFE | TM_ATTR_CALLABLE))
7488         goto ignored;
7489       /* FALLTHRU */
7490
7491     case FUNCTION_TYPE:
7492     case METHOD_TYPE:
7493       {
7494         tree old_name = find_tm_attribute (TYPE_ATTRIBUTES (*node));
7495         if (old_name == name)
7496           ;
7497         else if (old_name != NULL_TREE)
7498           error ("type was previously declared %qE", old_name);
7499         else
7500           *no_add_attrs = false;
7501       }
7502       break;
7503
7504     case POINTER_TYPE:
7505       {
7506         enum tree_code subcode = TREE_CODE (TREE_TYPE (*node));
7507         if (subcode == FUNCTION_TYPE || subcode == METHOD_TYPE)
7508           {
7509             tree fn_tmp = TREE_TYPE (*node);
7510             decl_attributes (&fn_tmp, tree_cons (name, args, NULL), 0);
7511             *node = build_pointer_type (fn_tmp);
7512             break;
7513           }
7514       }
7515       /* FALLTHRU */
7516
7517     default:
7518       /* If a function is next, pass it on to be tried next.  */
7519       if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
7520         return tree_cons (name, args, NULL);
7521
7522     ignored:
7523       warning (OPT_Wattributes, "%qE attribute ignored", name);
7524       break;
7525     }
7526
7527   return NULL_TREE;
7528 }
7529
7530 /* Handle the TM_WRAP attribute; arguments as in
7531    struct attribute_spec.handler.  */
7532
7533 static tree
7534 handle_tm_wrap_attribute (tree *node, tree name, tree args,
7535                           int ARG_UNUSED (flags), bool *no_add_attrs)
7536 {
7537   tree decl = *node;
7538
7539   /* We don't need the attribute even on success, since we
7540      record the entry in an external table.  */
7541   *no_add_attrs = true;
7542
7543   if (TREE_CODE (decl) != FUNCTION_DECL)
7544     warning (OPT_Wattributes, "%qE attribute ignored", name);
7545   else
7546     {
7547       tree wrap_decl = TREE_VALUE (args);
7548       if (TREE_CODE (wrap_decl) != IDENTIFIER_NODE
7549           && TREE_CODE (wrap_decl) != VAR_DECL
7550           && TREE_CODE (wrap_decl) != FUNCTION_DECL)
7551         error ("%qE argument not an identifier", name);
7552       else
7553         {
7554           if (TREE_CODE (wrap_decl) == IDENTIFIER_NODE)
7555             wrap_decl = lookup_name (wrap_decl);
7556           if (wrap_decl && TREE_CODE (wrap_decl) == FUNCTION_DECL)
7557             {
7558               if (lang_hooks.types_compatible_p (TREE_TYPE (decl),
7559                                                  TREE_TYPE (wrap_decl)))
7560                 record_tm_replacement (wrap_decl, decl);
7561               else
7562                 error ("%qD is not compatible with %qD", wrap_decl, decl);
7563             }
7564           else
7565             error ("transaction_wrap argument is not a function");
7566         }
7567     }
7568
7569   return NULL_TREE;
7570 }
7571
7572 /* Ignore the given attribute.  Used when this attribute may be usefully
7573    overridden by the target, but is not used generically.  */
7574
7575 static tree
7576 ignore_attribute (tree * ARG_UNUSED (node), tree ARG_UNUSED (name),
7577                   tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7578                   bool *no_add_attrs)
7579 {
7580   *no_add_attrs = true;
7581   return NULL_TREE;
7582 }
7583
7584 /* Handle a "no vops" attribute; arguments as in
7585    struct attribute_spec.handler.  */
7586
7587 static tree
7588 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
7589                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
7590                          bool *ARG_UNUSED (no_add_attrs))
7591 {
7592   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
7593   DECL_IS_NOVOPS (*node) = 1;
7594   return NULL_TREE;
7595 }
7596
7597 /* Handle a "deprecated" attribute; arguments as in
7598    struct attribute_spec.handler.  */
7599
7600 static tree
7601 handle_deprecated_attribute (tree *node, tree name,
7602                              tree args, int flags,
7603                              bool *no_add_attrs)
7604 {
7605   tree type = NULL_TREE;
7606   int warn = 0;
7607   tree what = NULL_TREE;
7608
7609   if (!args)
7610     *no_add_attrs = true;
7611   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
7612     {
7613       error ("deprecated message is not a string");
7614       *no_add_attrs = true;
7615     }
7616
7617   if (DECL_P (*node))
7618     {
7619       tree decl = *node;
7620       type = TREE_TYPE (decl);
7621
7622       if (TREE_CODE (decl) == TYPE_DECL
7623           || TREE_CODE (decl) == PARM_DECL
7624           || TREE_CODE (decl) == VAR_DECL
7625           || TREE_CODE (decl) == FUNCTION_DECL
7626           || TREE_CODE (decl) == FIELD_DECL
7627           || objc_method_decl (TREE_CODE (decl)))
7628         TREE_DEPRECATED (decl) = 1;
7629       else
7630         warn = 1;
7631     }
7632   else if (TYPE_P (*node))
7633     {
7634       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
7635         *node = build_variant_type_copy (*node);
7636       TREE_DEPRECATED (*node) = 1;
7637       type = *node;
7638     }
7639   else
7640     warn = 1;
7641
7642   if (warn)
7643     {
7644       *no_add_attrs = true;
7645       if (type && TYPE_NAME (type))
7646         {
7647           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7648             what = TYPE_NAME (*node);
7649           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7650                    && DECL_NAME (TYPE_NAME (type)))
7651             what = DECL_NAME (TYPE_NAME (type));
7652         }
7653       if (what)
7654         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
7655       else
7656         warning (OPT_Wattributes, "%qE attribute ignored", name);
7657     }
7658
7659   return NULL_TREE;
7660 }
7661
7662 /* Handle a "vector_size" attribute; arguments as in
7663    struct attribute_spec.handler.  */
7664
7665 static tree
7666 handle_vector_size_attribute (tree *node, tree name, tree args,
7667                               int ARG_UNUSED (flags),
7668                               bool *no_add_attrs)
7669 {
7670   unsigned HOST_WIDE_INT vecsize, nunits;
7671   enum machine_mode orig_mode;
7672   tree type = *node, new_type, size;
7673
7674   *no_add_attrs = true;
7675
7676   size = TREE_VALUE (args);
7677
7678   if (!host_integerp (size, 1))
7679     {
7680       warning (OPT_Wattributes, "%qE attribute ignored", name);
7681       return NULL_TREE;
7682     }
7683
7684   /* Get the vector size (in bytes).  */
7685   vecsize = tree_low_cst (size, 1);
7686
7687   /* We need to provide for vector pointers, vector arrays, and
7688      functions returning vectors.  For example:
7689
7690        __attribute__((vector_size(16))) short *foo;
7691
7692      In this case, the mode is SI, but the type being modified is
7693      HI, so we need to look further.  */
7694
7695   while (POINTER_TYPE_P (type)
7696          || TREE_CODE (type) == FUNCTION_TYPE
7697          || TREE_CODE (type) == METHOD_TYPE
7698          || TREE_CODE (type) == ARRAY_TYPE
7699          || TREE_CODE (type) == OFFSET_TYPE)
7700     type = TREE_TYPE (type);
7701
7702   /* Get the mode of the type being modified.  */
7703   orig_mode = TYPE_MODE (type);
7704
7705   if ((!INTEGRAL_TYPE_P (type)
7706        && !SCALAR_FLOAT_TYPE_P (type)
7707        && !FIXED_POINT_TYPE_P (type))
7708       || (!SCALAR_FLOAT_MODE_P (orig_mode)
7709           && GET_MODE_CLASS (orig_mode) != MODE_INT
7710           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
7711       || !host_integerp (TYPE_SIZE_UNIT (type), 1)
7712       || TREE_CODE (type) == BOOLEAN_TYPE)
7713     {
7714       error ("invalid vector type for attribute %qE", name);
7715       return NULL_TREE;
7716     }
7717
7718   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
7719     {
7720       error ("vector size not an integral multiple of component size");
7721       return NULL;
7722     }
7723
7724   if (vecsize == 0)
7725     {
7726       error ("zero vector size");
7727       return NULL;
7728     }
7729
7730   /* Calculate how many units fit in the vector.  */
7731   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7732   if (nunits & (nunits - 1))
7733     {
7734       error ("number of components of the vector not a power of two");
7735       return NULL_TREE;
7736     }
7737
7738   new_type = build_vector_type (type, nunits);
7739
7740   /* Build back pointers if needed.  */
7741   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
7742
7743   return NULL_TREE;
7744 }
7745
7746 /* Handle the "nonnull" attribute.  */
7747 static tree
7748 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
7749                           tree args, int ARG_UNUSED (flags),
7750                           bool *no_add_attrs)
7751 {
7752   tree type = *node;
7753   unsigned HOST_WIDE_INT attr_arg_num;
7754
7755   /* If no arguments are specified, all pointer arguments should be
7756      non-null.  Verify a full prototype is given so that the arguments
7757      will have the correct types when we actually check them later.  */
7758   if (!args)
7759     {
7760       if (!prototype_p (type))
7761         {
7762           error ("nonnull attribute without arguments on a non-prototype");
7763           *no_add_attrs = true;
7764         }
7765       return NULL_TREE;
7766     }
7767
7768   /* Argument list specified.  Verify that each argument number references
7769      a pointer argument.  */
7770   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
7771     {
7772       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
7773
7774       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
7775         {
7776           error ("nonnull argument has invalid operand number (argument %lu)",
7777                  (unsigned long) attr_arg_num);
7778           *no_add_attrs = true;
7779           return NULL_TREE;
7780         }
7781
7782       if (prototype_p (type))
7783         {
7784           function_args_iterator iter;
7785           tree argument;
7786
7787           function_args_iter_init (&iter, type);
7788           for (ck_num = 1; ; ck_num++, function_args_iter_next (&iter))
7789             {
7790               argument = function_args_iter_cond (&iter);
7791               if (argument == NULL_TREE || ck_num == arg_num)
7792                 break;
7793             }
7794
7795           if (!argument
7796               || TREE_CODE (argument) == VOID_TYPE)
7797             {
7798               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
7799                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
7800               *no_add_attrs = true;
7801               return NULL_TREE;
7802             }
7803
7804           if (TREE_CODE (argument) != POINTER_TYPE)
7805             {
7806               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
7807                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
7808               *no_add_attrs = true;
7809               return NULL_TREE;
7810             }
7811         }
7812     }
7813
7814   return NULL_TREE;
7815 }
7816
7817 /* Check the argument list of a function call for null in argument slots
7818    that are marked as requiring a non-null pointer argument.  The NARGS
7819    arguments are passed in the array ARGARRAY.
7820 */
7821
7822 static void
7823 check_function_nonnull (tree attrs, int nargs, tree *argarray)
7824 {
7825   tree a, args;
7826   int i;
7827
7828   for (a = attrs; a; a = TREE_CHAIN (a))
7829     {
7830       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
7831         {
7832           args = TREE_VALUE (a);
7833
7834           /* Walk the argument list.  If we encounter an argument number we
7835              should check for non-null, do it.  If the attribute has no args,
7836              then every pointer argument is checked (in which case the check
7837              for pointer type is done in check_nonnull_arg).  */
7838           for (i = 0; i < nargs; i++)
7839             {
7840               if (!args || nonnull_check_p (args, i + 1))
7841                 check_function_arguments_recurse (check_nonnull_arg, NULL,
7842                                                   argarray[i],
7843                                                   i + 1);
7844             }
7845         }
7846     }
7847 }
7848
7849 /* Check that the Nth argument of a function call (counting backwards
7850    from the end) is a (pointer)0.  The NARGS arguments are passed in the
7851    array ARGARRAY.  */
7852
7853 static void
7854 check_function_sentinel (const_tree fntype, int nargs, tree *argarray)
7855 {
7856   tree attr = lookup_attribute ("sentinel", TYPE_ATTRIBUTES (fntype));
7857
7858   if (attr)
7859     {
7860       int len = 0;
7861       int pos = 0;
7862       tree sentinel;
7863       function_args_iterator iter;
7864       tree t;
7865
7866       /* Skip over the named arguments.  */
7867       FOREACH_FUNCTION_ARGS (fntype, t, iter)
7868         {
7869           if (len == nargs)
7870             break;
7871           len++;
7872         }
7873
7874       if (TREE_VALUE (attr))
7875         {
7876           tree p = TREE_VALUE (TREE_VALUE (attr));
7877           pos = TREE_INT_CST_LOW (p);
7878         }
7879
7880       /* The sentinel must be one of the varargs, i.e.
7881          in position >= the number of fixed arguments.  */
7882       if ((nargs - 1 - pos) < len)
7883         {
7884           warning (OPT_Wformat,
7885                    "not enough variable arguments to fit a sentinel");
7886           return;
7887         }
7888
7889       /* Validate the sentinel.  */
7890       sentinel = argarray[nargs - 1 - pos];
7891       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
7892            || !integer_zerop (sentinel))
7893           /* Although __null (in C++) is only an integer we allow it
7894              nevertheless, as we are guaranteed that it's exactly
7895              as wide as a pointer, and we don't want to force
7896              users to cast the NULL they have written there.
7897              We warn with -Wstrict-null-sentinel, though.  */
7898           && (warn_strict_null_sentinel || null_node != sentinel))
7899         warning (OPT_Wformat, "missing sentinel in function call");
7900     }
7901 }
7902
7903 /* Helper for check_function_nonnull; given a list of operands which
7904    must be non-null in ARGS, determine if operand PARAM_NUM should be
7905    checked.  */
7906
7907 static bool
7908 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
7909 {
7910   unsigned HOST_WIDE_INT arg_num = 0;
7911
7912   for (; args; args = TREE_CHAIN (args))
7913     {
7914       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
7915
7916       gcc_assert (found);
7917
7918       if (arg_num == param_num)
7919         return true;
7920     }
7921   return false;
7922 }
7923
7924 /* Check that the function argument PARAM (which is operand number
7925    PARAM_NUM) is non-null.  This is called by check_function_nonnull
7926    via check_function_arguments_recurse.  */
7927
7928 static void
7929 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
7930                    unsigned HOST_WIDE_INT param_num)
7931 {
7932   /* Just skip checking the argument if it's not a pointer.  This can
7933      happen if the "nonnull" attribute was given without an operand
7934      list (which means to check every pointer argument).  */
7935
7936   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
7937     return;
7938
7939   if (integer_zerop (param))
7940     warning (OPT_Wnonnull, "null argument where non-null required "
7941              "(argument %lu)", (unsigned long) param_num);
7942 }
7943
7944 /* Helper for nonnull attribute handling; fetch the operand number
7945    from the attribute argument list.  */
7946
7947 static bool
7948 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
7949 {
7950   /* Verify the arg number is a constant.  */
7951   if (TREE_CODE (arg_num_expr) != INTEGER_CST
7952       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
7953     return false;
7954
7955   *valp = TREE_INT_CST_LOW (arg_num_expr);
7956   return true;
7957 }
7958
7959 /* Handle a "nothrow" attribute; arguments as in
7960    struct attribute_spec.handler.  */
7961
7962 static tree
7963 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
7964                           int ARG_UNUSED (flags), bool *no_add_attrs)
7965 {
7966   if (TREE_CODE (*node) == FUNCTION_DECL)
7967     TREE_NOTHROW (*node) = 1;
7968   /* ??? TODO: Support types.  */
7969   else
7970     {
7971       warning (OPT_Wattributes, "%qE attribute ignored", name);
7972       *no_add_attrs = true;
7973     }
7974
7975   return NULL_TREE;
7976 }
7977
7978 /* Handle a "cleanup" attribute; arguments as in
7979    struct attribute_spec.handler.  */
7980
7981 static tree
7982 handle_cleanup_attribute (tree *node, tree name, tree args,
7983                           int ARG_UNUSED (flags), bool *no_add_attrs)
7984 {
7985   tree decl = *node;
7986   tree cleanup_id, cleanup_decl;
7987
7988   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
7989      for global destructors in C++.  This requires infrastructure that
7990      we don't have generically at the moment.  It's also not a feature
7991      we'd be missing too much, since we do have attribute constructor.  */
7992   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
7993     {
7994       warning (OPT_Wattributes, "%qE attribute ignored", name);
7995       *no_add_attrs = true;
7996       return NULL_TREE;
7997     }
7998
7999   /* Verify that the argument is a function in scope.  */
8000   /* ??? We could support pointers to functions here as well, if
8001      that was considered desirable.  */
8002   cleanup_id = TREE_VALUE (args);
8003   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
8004     {
8005       error ("cleanup argument not an identifier");
8006       *no_add_attrs = true;
8007       return NULL_TREE;
8008     }
8009   cleanup_decl = lookup_name (cleanup_id);
8010   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
8011     {
8012       error ("cleanup argument not a function");
8013       *no_add_attrs = true;
8014       return NULL_TREE;
8015     }
8016
8017   /* That the function has proper type is checked with the
8018      eventual call to build_function_call.  */
8019
8020   return NULL_TREE;
8021 }
8022
8023 /* Handle a "warn_unused_result" attribute.  No special handling.  */
8024
8025 static tree
8026 handle_warn_unused_result_attribute (tree *node, tree name,
8027                                tree ARG_UNUSED (args),
8028                                int ARG_UNUSED (flags), bool *no_add_attrs)
8029 {
8030   /* Ignore the attribute for functions not returning any value.  */
8031   if (VOID_TYPE_P (TREE_TYPE (*node)))
8032     {
8033       warning (OPT_Wattributes, "%qE attribute ignored", name);
8034       *no_add_attrs = true;
8035     }
8036
8037   return NULL_TREE;
8038 }
8039
8040 /* Handle a "sentinel" attribute.  */
8041
8042 static tree
8043 handle_sentinel_attribute (tree *node, tree name, tree args,
8044                            int ARG_UNUSED (flags), bool *no_add_attrs)
8045 {
8046   if (!prototype_p (*node))
8047     {
8048       warning (OPT_Wattributes,
8049                "%qE attribute requires prototypes with named arguments", name);
8050       *no_add_attrs = true;
8051     }
8052   else
8053     {
8054       if (!stdarg_p (*node))
8055         {
8056           warning (OPT_Wattributes,
8057                    "%qE attribute only applies to variadic functions", name);
8058           *no_add_attrs = true;
8059         }
8060     }
8061
8062   if (args)
8063     {
8064       tree position = TREE_VALUE (args);
8065
8066       if (TREE_CODE (position) != INTEGER_CST)
8067         {
8068           warning (OPT_Wattributes,
8069                    "requested position is not an integer constant");
8070           *no_add_attrs = true;
8071         }
8072       else
8073         {
8074           if (tree_int_cst_lt (position, integer_zero_node))
8075             {
8076               warning (OPT_Wattributes,
8077                        "requested position is less than zero");
8078               *no_add_attrs = true;
8079             }
8080         }
8081     }
8082
8083   return NULL_TREE;
8084 }
8085
8086 /* Handle a "type_generic" attribute.  */
8087
8088 static tree
8089 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
8090                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
8091                                bool * ARG_UNUSED (no_add_attrs))
8092 {
8093   /* Ensure we have a function type.  */
8094   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
8095
8096   /* Ensure we have a variadic function.  */
8097   gcc_assert (!prototype_p (*node) || stdarg_p (*node));
8098
8099   return NULL_TREE;
8100 }
8101
8102 /* Handle a "target" attribute.  */
8103
8104 static tree
8105 handle_target_attribute (tree *node, tree name, tree args, int flags,
8106                          bool *no_add_attrs)
8107 {
8108   /* Ensure we have a function type.  */
8109   if (TREE_CODE (*node) != FUNCTION_DECL)
8110     {
8111       warning (OPT_Wattributes, "%qE attribute ignored", name);
8112       *no_add_attrs = true;
8113     }
8114   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
8115                                                       flags))
8116     *no_add_attrs = true;
8117
8118   return NULL_TREE;
8119 }
8120
8121 /* Arguments being collected for optimization.  */
8122 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
8123 DEF_VEC_P(const_char_p);
8124 DEF_VEC_ALLOC_P(const_char_p, gc);
8125 static GTY(()) VEC(const_char_p, gc) *optimize_args;
8126
8127
8128 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
8129    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
8130    false for #pragma GCC optimize.  */
8131
8132 bool
8133 parse_optimize_options (tree args, bool attr_p)
8134 {
8135   bool ret = true;
8136   unsigned opt_argc;
8137   unsigned i;
8138   int saved_flag_strict_aliasing;
8139   const char **opt_argv;
8140   struct cl_decoded_option *decoded_options;
8141   unsigned int decoded_options_count;
8142   tree ap;
8143
8144   /* Build up argv vector.  Just in case the string is stored away, use garbage
8145      collected strings.  */
8146   VEC_truncate (const_char_p, optimize_args, 0);
8147   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
8148
8149   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
8150     {
8151       tree value = TREE_VALUE (ap);
8152
8153       if (TREE_CODE (value) == INTEGER_CST)
8154         {
8155           char buffer[20];
8156           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
8157           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
8158         }
8159
8160       else if (TREE_CODE (value) == STRING_CST)
8161         {
8162           /* Split string into multiple substrings.  */
8163           size_t len = TREE_STRING_LENGTH (value);
8164           char *p = ASTRDUP (TREE_STRING_POINTER (value));
8165           char *end = p + len;
8166           char *comma;
8167           char *next_p = p;
8168
8169           while (next_p != NULL)
8170             {
8171               size_t len2;
8172               char *q, *r;
8173
8174               p = next_p;
8175               comma = strchr (p, ',');
8176               if (comma)
8177                 {
8178                   len2 = comma - p;
8179                   *comma = '\0';
8180                   next_p = comma+1;
8181                 }
8182               else
8183                 {
8184                   len2 = end - p;
8185                   next_p = NULL;
8186                 }
8187
8188               r = q = (char *) ggc_alloc_atomic (len2 + 3);
8189
8190               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
8191                  options.  */
8192               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
8193                 {
8194                   ret = false;
8195                   if (attr_p)
8196                     warning (OPT_Wattributes,
8197                              "bad option %s to optimize attribute", p);
8198                   else
8199                     warning (OPT_Wpragmas,
8200                              "bad option %s to pragma attribute", p);
8201                   continue;
8202                 }
8203
8204               if (*p != '-')
8205                 {
8206                   *r++ = '-';
8207
8208                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
8209                      itself is -Os, and any other switch begins with a -f.  */
8210                   if ((*p >= '0' && *p <= '9')
8211                       || (p[0] == 's' && p[1] == '\0'))
8212                     *r++ = 'O';
8213                   else if (*p != 'O')
8214                     *r++ = 'f';
8215                 }
8216
8217               memcpy (r, p, len2);
8218               r[len2] = '\0';
8219               VEC_safe_push (const_char_p, gc, optimize_args, q);
8220             }
8221
8222         }
8223     }
8224
8225   opt_argc = VEC_length (const_char_p, optimize_args);
8226   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
8227
8228   for (i = 1; i < opt_argc; i++)
8229     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
8230
8231   saved_flag_strict_aliasing = flag_strict_aliasing;
8232
8233   /* Now parse the options.  */
8234   decode_cmdline_options_to_array_default_mask (opt_argc, opt_argv,
8235                                                 &decoded_options,
8236                                                 &decoded_options_count);
8237   decode_options (&global_options, &global_options_set,
8238                   decoded_options, decoded_options_count,
8239                   input_location, global_dc);
8240
8241   targetm.override_options_after_change();
8242
8243   /* Don't allow changing -fstrict-aliasing.  */
8244   flag_strict_aliasing = saved_flag_strict_aliasing;
8245
8246   VEC_truncate (const_char_p, optimize_args, 0);
8247   return ret;
8248 }
8249
8250 /* For handling "optimize" attribute. arguments as in
8251    struct attribute_spec.handler.  */
8252
8253 static tree
8254 handle_optimize_attribute (tree *node, tree name, tree args,
8255                            int ARG_UNUSED (flags), bool *no_add_attrs)
8256 {
8257   /* Ensure we have a function type.  */
8258   if (TREE_CODE (*node) != FUNCTION_DECL)
8259     {
8260       warning (OPT_Wattributes, "%qE attribute ignored", name);
8261       *no_add_attrs = true;
8262     }
8263   else
8264     {
8265       struct cl_optimization cur_opts;
8266       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
8267
8268       /* Save current options.  */
8269       cl_optimization_save (&cur_opts, &global_options);
8270
8271       /* If we previously had some optimization options, use them as the
8272          default.  */
8273       if (old_opts)
8274         cl_optimization_restore (&global_options,
8275                                  TREE_OPTIMIZATION (old_opts));
8276
8277       /* Parse options, and update the vector.  */
8278       parse_optimize_options (args, true);
8279       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
8280         = build_optimization_node ();
8281
8282       /* Restore current options.  */
8283       cl_optimization_restore (&global_options, &cur_opts);
8284     }
8285
8286   return NULL_TREE;
8287 }
8288
8289 /* Handle a "no_split_stack" attribute.  */
8290
8291 static tree
8292 handle_no_split_stack_attribute (tree *node, tree name,
8293                                  tree ARG_UNUSED (args),
8294                                  int ARG_UNUSED (flags),
8295                                  bool *no_add_attrs)
8296 {
8297   tree decl = *node;
8298
8299   if (TREE_CODE (decl) != FUNCTION_DECL)
8300     {
8301       error_at (DECL_SOURCE_LOCATION (decl),
8302                 "%qE attribute applies only to functions", name);
8303       *no_add_attrs = true;
8304     }
8305   else if (DECL_INITIAL (decl))
8306     {
8307       error_at (DECL_SOURCE_LOCATION (decl),
8308                 "can%'t set %qE attribute after definition", name);
8309       *no_add_attrs = true;
8310     }
8311
8312   return NULL_TREE;
8313 }
8314 \f
8315 /* Check for valid arguments being passed to a function with FNTYPE.
8316    There are NARGS arguments in the array ARGARRAY.  */
8317 void
8318 check_function_arguments (const_tree fntype, int nargs, tree *argarray)
8319 {
8320   /* Check for null being passed in a pointer argument that must be
8321      non-null.  We also need to do this if format checking is enabled.  */
8322
8323   if (warn_nonnull)
8324     check_function_nonnull (TYPE_ATTRIBUTES (fntype), nargs, argarray);
8325
8326   /* Check for errors in format strings.  */
8327
8328   if (warn_format || warn_missing_format_attribute)
8329     check_function_format (TYPE_ATTRIBUTES (fntype), nargs, argarray);
8330
8331   if (warn_format)
8332     check_function_sentinel (fntype, nargs, argarray);
8333 }
8334
8335 /* Generic argument checking recursion routine.  PARAM is the argument to
8336    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
8337    once the argument is resolved.  CTX is context for the callback.  */
8338 void
8339 check_function_arguments_recurse (void (*callback)
8340                                   (void *, tree, unsigned HOST_WIDE_INT),
8341                                   void *ctx, tree param,
8342                                   unsigned HOST_WIDE_INT param_num)
8343 {
8344   if (CONVERT_EXPR_P (param)
8345       && (TYPE_PRECISION (TREE_TYPE (param))
8346           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
8347     {
8348       /* Strip coercion.  */
8349       check_function_arguments_recurse (callback, ctx,
8350                                         TREE_OPERAND (param, 0), param_num);
8351       return;
8352     }
8353
8354   if (TREE_CODE (param) == CALL_EXPR)
8355     {
8356       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
8357       tree attrs;
8358       bool found_format_arg = false;
8359
8360       /* See if this is a call to a known internationalization function
8361          that modifies a format arg.  Such a function may have multiple
8362          format_arg attributes (for example, ngettext).  */
8363
8364       for (attrs = TYPE_ATTRIBUTES (type);
8365            attrs;
8366            attrs = TREE_CHAIN (attrs))
8367         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
8368           {
8369             tree inner_arg;
8370             tree format_num_expr;
8371             int format_num;
8372             int i;
8373             call_expr_arg_iterator iter;
8374
8375             /* Extract the argument number, which was previously checked
8376                to be valid.  */
8377             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
8378
8379             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
8380                         && !TREE_INT_CST_HIGH (format_num_expr));
8381
8382             format_num = TREE_INT_CST_LOW (format_num_expr);
8383
8384             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
8385                  inner_arg != 0;
8386                  inner_arg = next_call_expr_arg (&iter), i++)
8387               if (i == format_num)
8388                 {
8389                   check_function_arguments_recurse (callback, ctx,
8390                                                     inner_arg, param_num);
8391                   found_format_arg = true;
8392                   break;
8393                 }
8394           }
8395
8396       /* If we found a format_arg attribute and did a recursive check,
8397          we are done with checking this argument.  Otherwise, we continue
8398          and this will be considered a non-literal.  */
8399       if (found_format_arg)
8400         return;
8401     }
8402
8403   if (TREE_CODE (param) == COND_EXPR)
8404     {
8405       /* Check both halves of the conditional expression.  */
8406       check_function_arguments_recurse (callback, ctx,
8407                                         TREE_OPERAND (param, 1), param_num);
8408       check_function_arguments_recurse (callback, ctx,
8409                                         TREE_OPERAND (param, 2), param_num);
8410       return;
8411     }
8412
8413   (*callback) (ctx, param, param_num);
8414 }
8415
8416 /* Checks for a builtin function FNDECL that the number of arguments
8417    NARGS against the required number REQUIRED and issues an error if
8418    there is a mismatch.  Returns true if the number of arguments is
8419    correct, otherwise false.  */
8420
8421 static bool
8422 builtin_function_validate_nargs (tree fndecl, int nargs, int required)
8423 {
8424   if (nargs < required)
8425     {
8426       error_at (input_location,
8427                 "not enough arguments to function %qE", fndecl);
8428       return false;
8429     }
8430   else if (nargs > required)
8431     {
8432       error_at (input_location,
8433                 "too many arguments to function %qE", fndecl);
8434       return false;
8435     }
8436   return true;
8437 }
8438
8439 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
8440    Returns false if there was an error, otherwise true.  */
8441
8442 bool
8443 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
8444 {
8445   if (!DECL_BUILT_IN (fndecl)
8446       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
8447     return true;
8448
8449   switch (DECL_FUNCTION_CODE (fndecl))
8450     {
8451     case BUILT_IN_CONSTANT_P:
8452       return builtin_function_validate_nargs (fndecl, nargs, 1);
8453
8454     case BUILT_IN_ISFINITE:
8455     case BUILT_IN_ISINF:
8456     case BUILT_IN_ISINF_SIGN:
8457     case BUILT_IN_ISNAN:
8458     case BUILT_IN_ISNORMAL:
8459       if (builtin_function_validate_nargs (fndecl, nargs, 1))
8460         {
8461           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
8462             {
8463               error ("non-floating-point argument in call to "
8464                      "function %qE", fndecl);
8465               return false;
8466             }
8467           return true;
8468         }
8469       return false;
8470
8471     case BUILT_IN_ISGREATER:
8472     case BUILT_IN_ISGREATEREQUAL:
8473     case BUILT_IN_ISLESS:
8474     case BUILT_IN_ISLESSEQUAL:
8475     case BUILT_IN_ISLESSGREATER:
8476     case BUILT_IN_ISUNORDERED:
8477       if (builtin_function_validate_nargs (fndecl, nargs, 2))
8478         {
8479           enum tree_code code0, code1;
8480           code0 = TREE_CODE (TREE_TYPE (args[0]));
8481           code1 = TREE_CODE (TREE_TYPE (args[1]));
8482           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
8483                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
8484                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
8485             {
8486               error ("non-floating-point arguments in call to "
8487                      "function %qE", fndecl);
8488               return false;
8489             }
8490           return true;
8491         }
8492       return false;
8493
8494     case BUILT_IN_FPCLASSIFY:
8495       if (builtin_function_validate_nargs (fndecl, nargs, 6))
8496         {
8497           unsigned i;
8498
8499           for (i=0; i<5; i++)
8500             if (TREE_CODE (args[i]) != INTEGER_CST)
8501               {
8502                 error ("non-const integer argument %u in call to function %qE",
8503                        i+1, fndecl);
8504                 return false;
8505               }
8506
8507           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
8508             {
8509               error ("non-floating-point argument in call to function %qE",
8510                      fndecl);
8511               return false;
8512             }
8513           return true;
8514         }
8515       return false;
8516
8517     case BUILT_IN_ASSUME_ALIGNED:
8518       if (builtin_function_validate_nargs (fndecl, nargs, 2 + (nargs > 2)))
8519         {
8520           if (nargs >= 3 && TREE_CODE (TREE_TYPE (args[2])) != INTEGER_TYPE)
8521             {
8522               error ("non-integer argument 3 in call to function %qE", fndecl);
8523               return false;
8524             }
8525           return true;
8526         }
8527       return false;
8528
8529     default:
8530       return true;
8531     }
8532 }
8533
8534 /* Function to help qsort sort FIELD_DECLs by name order.  */
8535
8536 int
8537 field_decl_cmp (const void *x_p, const void *y_p)
8538 {
8539   const tree *const x = (const tree *const) x_p;
8540   const tree *const y = (const tree *const) y_p;
8541
8542   if (DECL_NAME (*x) == DECL_NAME (*y))
8543     /* A nontype is "greater" than a type.  */
8544     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8545   if (DECL_NAME (*x) == NULL_TREE)
8546     return -1;
8547   if (DECL_NAME (*y) == NULL_TREE)
8548     return 1;
8549   if (DECL_NAME (*x) < DECL_NAME (*y))
8550     return -1;
8551   return 1;
8552 }
8553
8554 static struct {
8555   gt_pointer_operator new_value;
8556   void *cookie;
8557 } resort_data;
8558
8559 /* This routine compares two fields like field_decl_cmp but using the
8560 pointer operator in resort_data.  */
8561
8562 static int
8563 resort_field_decl_cmp (const void *x_p, const void *y_p)
8564 {
8565   const tree *const x = (const tree *const) x_p;
8566   const tree *const y = (const tree *const) y_p;
8567
8568   if (DECL_NAME (*x) == DECL_NAME (*y))
8569     /* A nontype is "greater" than a type.  */
8570     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
8571   if (DECL_NAME (*x) == NULL_TREE)
8572     return -1;
8573   if (DECL_NAME (*y) == NULL_TREE)
8574     return 1;
8575   {
8576     tree d1 = DECL_NAME (*x);
8577     tree d2 = DECL_NAME (*y);
8578     resort_data.new_value (&d1, resort_data.cookie);
8579     resort_data.new_value (&d2, resort_data.cookie);
8580     if (d1 < d2)
8581       return -1;
8582   }
8583   return 1;
8584 }
8585
8586 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
8587
8588 void
8589 resort_sorted_fields (void *obj,
8590                       void * ARG_UNUSED (orig_obj),
8591                       gt_pointer_operator new_value,
8592                       void *cookie)
8593 {
8594   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
8595   resort_data.new_value = new_value;
8596   resort_data.cookie = cookie;
8597   qsort (&sf->elts[0], sf->len, sizeof (tree),
8598          resort_field_decl_cmp);
8599 }
8600
8601 /* Subroutine of c_parse_error.
8602    Return the result of concatenating LHS and RHS. RHS is really
8603    a string literal, its first character is indicated by RHS_START and
8604    RHS_SIZE is its length (including the terminating NUL character).
8605
8606    The caller is responsible for deleting the returned pointer.  */
8607
8608 static char *
8609 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
8610 {
8611   const int lhs_size = strlen (lhs);
8612   char *result = XNEWVEC (char, lhs_size + rhs_size);
8613   strncpy (result, lhs, lhs_size);
8614   strncpy (result + lhs_size, rhs_start, rhs_size);
8615   return result;
8616 }
8617
8618 /* Issue the error given by GMSGID, indicating that it occurred before
8619    TOKEN, which had the associated VALUE.  */
8620
8621 void
8622 c_parse_error (const char *gmsgid, enum cpp_ttype token_type,
8623                tree value, unsigned char token_flags)
8624 {
8625 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
8626
8627   char *message = NULL;
8628
8629   if (token_type == CPP_EOF)
8630     message = catenate_messages (gmsgid, " at end of input");
8631   else if (token_type == CPP_CHAR
8632            || token_type == CPP_WCHAR
8633            || token_type == CPP_CHAR16
8634            || token_type == CPP_CHAR32)
8635     {
8636       unsigned int val = TREE_INT_CST_LOW (value);
8637       const char *prefix;
8638
8639       switch (token_type)
8640         {
8641         default:
8642           prefix = "";
8643           break;
8644         case CPP_WCHAR:
8645           prefix = "L";
8646           break;
8647         case CPP_CHAR16:
8648           prefix = "u";
8649           break;
8650         case CPP_CHAR32:
8651           prefix = "U";
8652           break;
8653         }
8654
8655       if (val <= UCHAR_MAX && ISGRAPH (val))
8656         message = catenate_messages (gmsgid, " before %s'%c'");
8657       else
8658         message = catenate_messages (gmsgid, " before %s'\\x%x'");
8659
8660       error (message, prefix, val);
8661       free (message);
8662       message = NULL;
8663     }
8664   else if (token_type == CPP_STRING
8665            || token_type == CPP_WSTRING
8666            || token_type == CPP_STRING16
8667            || token_type == CPP_STRING32
8668            || token_type == CPP_UTF8STRING)
8669     message = catenate_messages (gmsgid, " before string constant");
8670   else if (token_type == CPP_NUMBER)
8671     message = catenate_messages (gmsgid, " before numeric constant");
8672   else if (token_type == CPP_NAME)
8673     {
8674       message = catenate_messages (gmsgid, " before %qE");
8675       error (message, value);
8676       free (message);
8677       message = NULL;
8678     }
8679   else if (token_type == CPP_PRAGMA)
8680     message = catenate_messages (gmsgid, " before %<#pragma%>");
8681   else if (token_type == CPP_PRAGMA_EOL)
8682     message = catenate_messages (gmsgid, " before end of line");
8683   else if (token_type == CPP_DECLTYPE)
8684     message = catenate_messages (gmsgid, " before %<decltype%>");
8685   else if (token_type < N_TTYPES)
8686     {
8687       message = catenate_messages (gmsgid, " before %qs token");
8688       error (message, cpp_type2name (token_type, token_flags));
8689       free (message);
8690       message = NULL;
8691     }
8692   else
8693     error (gmsgid);
8694
8695   if (message)
8696     {
8697       error (message);
8698       free (message);
8699     }
8700 #undef catenate_messages
8701 }
8702
8703 /* Mapping for cpp message reasons to the options that enable them.  */
8704
8705 struct reason_option_codes_t
8706 {
8707   const int reason;             /* cpplib message reason.  */
8708   const int option_code;        /* gcc option that controls this message.  */
8709 };
8710
8711 static const struct reason_option_codes_t option_codes[] = {
8712   {CPP_W_DEPRECATED,                    OPT_Wdeprecated},
8713   {CPP_W_COMMENTS,                      OPT_Wcomment},
8714   {CPP_W_TRIGRAPHS,                     OPT_Wtrigraphs},
8715   {CPP_W_MULTICHAR,                     OPT_Wmultichar},
8716   {CPP_W_TRADITIONAL,                   OPT_Wtraditional},
8717   {CPP_W_LONG_LONG,                     OPT_Wlong_long},
8718   {CPP_W_ENDIF_LABELS,                  OPT_Wendif_labels},
8719   {CPP_W_VARIADIC_MACROS,               OPT_Wvariadic_macros},
8720   {CPP_W_BUILTIN_MACRO_REDEFINED,       OPT_Wbuiltin_macro_redefined},
8721   {CPP_W_UNDEF,                         OPT_Wundef},
8722   {CPP_W_UNUSED_MACROS,                 OPT_Wunused_macros},
8723   {CPP_W_CXX_OPERATOR_NAMES,            OPT_Wc___compat},
8724   {CPP_W_NORMALIZE,                     OPT_Wnormalized_},
8725   {CPP_W_INVALID_PCH,                   OPT_Winvalid_pch},
8726   {CPP_W_WARNING_DIRECTIVE,             OPT_Wcpp},
8727   {CPP_W_NONE,                          0}
8728 };
8729
8730 /* Return the gcc option code associated with the reason for a cpp
8731    message, or 0 if none.  */
8732
8733 static int
8734 c_option_controlling_cpp_error (int reason)
8735 {
8736   const struct reason_option_codes_t *entry;
8737
8738   for (entry = option_codes; entry->reason != CPP_W_NONE; entry++)
8739     {
8740       if (entry->reason == reason)
8741         return entry->option_code;
8742     }
8743   return 0;
8744 }
8745
8746 /* Callback from cpp_error for PFILE to print diagnostics from the
8747    preprocessor.  The diagnostic is of type LEVEL, with REASON set
8748    to the reason code if LEVEL is represents a warning, at location
8749    LOCATION unless this is after lexing and the compiler's location
8750    should be used instead, with column number possibly overridden by
8751    COLUMN_OVERRIDE if not zero; MSG is the translated message and AP
8752    the arguments.  Returns true if a diagnostic was emitted, false
8753    otherwise.  */
8754
8755 bool
8756 c_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
8757              location_t location, unsigned int column_override,
8758              const char *msg, va_list *ap)
8759 {
8760   diagnostic_info diagnostic;
8761   diagnostic_t dlevel;
8762   bool save_warn_system_headers = global_dc->dc_warn_system_headers;
8763   bool ret;
8764
8765   switch (level)
8766     {
8767     case CPP_DL_WARNING_SYSHDR:
8768       if (flag_no_output)
8769         return false;
8770       global_dc->dc_warn_system_headers = 1;
8771       /* Fall through.  */
8772     case CPP_DL_WARNING:
8773       if (flag_no_output)
8774         return false;
8775       dlevel = DK_WARNING;
8776       break;
8777     case CPP_DL_PEDWARN:
8778       if (flag_no_output && !flag_pedantic_errors)
8779         return false;
8780       dlevel = DK_PEDWARN;
8781       break;
8782     case CPP_DL_ERROR:
8783       dlevel = DK_ERROR;
8784       break;
8785     case CPP_DL_ICE:
8786       dlevel = DK_ICE;
8787       break;
8788     case CPP_DL_NOTE:
8789       dlevel = DK_NOTE;
8790       break;
8791     case CPP_DL_FATAL:
8792       dlevel = DK_FATAL;
8793       break;
8794     default:
8795       gcc_unreachable ();
8796     }
8797   if (done_lexing)
8798     location = input_location;
8799   diagnostic_set_info_translated (&diagnostic, msg, ap,
8800                                   location, dlevel);
8801   if (column_override)
8802     diagnostic_override_column (&diagnostic, column_override);
8803   diagnostic_override_option_index (&diagnostic,
8804                                     c_option_controlling_cpp_error (reason));
8805   ret = report_diagnostic (&diagnostic);
8806   if (level == CPP_DL_WARNING_SYSHDR)
8807     global_dc->dc_warn_system_headers = save_warn_system_headers;
8808   return ret;
8809 }
8810
8811 /* Convert a character from the host to the target execution character
8812    set.  cpplib handles this, mostly.  */
8813
8814 HOST_WIDE_INT
8815 c_common_to_target_charset (HOST_WIDE_INT c)
8816 {
8817   /* Character constants in GCC proper are sign-extended under -fsigned-char,
8818      zero-extended under -fno-signed-char.  cpplib insists that characters
8819      and character constants are always unsigned.  Hence we must convert
8820      back and forth.  */
8821   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
8822
8823   uc = cpp_host_to_exec_charset (parse_in, uc);
8824
8825   if (flag_signed_char)
8826     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
8827                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
8828   else
8829     return uc;
8830 }
8831
8832 /* Fold an offsetof-like expression.  EXPR is a nested sequence of component
8833    references with an INDIRECT_REF of a constant at the bottom; much like the
8834    traditional rendering of offsetof as a macro.  Return the folded result.  */
8835
8836 tree
8837 fold_offsetof_1 (tree expr)
8838 {
8839   tree base, off, t;
8840
8841   switch (TREE_CODE (expr))
8842     {
8843     case ERROR_MARK:
8844       return expr;
8845
8846     case VAR_DECL:
8847       error ("cannot apply %<offsetof%> to static data member %qD", expr);
8848       return error_mark_node;
8849
8850     case CALL_EXPR:
8851     case TARGET_EXPR:
8852       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
8853       return error_mark_node;
8854
8855     case NOP_EXPR:
8856     case INDIRECT_REF:
8857       if (!TREE_CONSTANT (TREE_OPERAND (expr, 0)))
8858         {
8859           error ("cannot apply %<offsetof%> to a non constant address");
8860           return error_mark_node;
8861         }
8862       return TREE_OPERAND (expr, 0);
8863
8864     case COMPONENT_REF:
8865       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
8866       if (base == error_mark_node)
8867         return base;
8868
8869       t = TREE_OPERAND (expr, 1);
8870       if (DECL_C_BIT_FIELD (t))
8871         {
8872           error ("attempt to take address of bit-field structure "
8873                  "member %qD", t);
8874           return error_mark_node;
8875         }
8876       off = size_binop_loc (input_location, PLUS_EXPR, DECL_FIELD_OFFSET (t),
8877                             size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t),
8878                                                     1)
8879                                       / BITS_PER_UNIT));
8880       break;
8881
8882     case ARRAY_REF:
8883       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
8884       if (base == error_mark_node)
8885         return base;
8886
8887       t = TREE_OPERAND (expr, 1);
8888
8889       /* Check if the offset goes beyond the upper bound of the array.  */
8890       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) >= 0)
8891         {
8892           tree upbound = array_ref_up_bound (expr);
8893           if (upbound != NULL_TREE
8894               && TREE_CODE (upbound) == INTEGER_CST
8895               && !tree_int_cst_equal (upbound,
8896                                       TYPE_MAX_VALUE (TREE_TYPE (upbound))))
8897             {
8898               upbound = size_binop (PLUS_EXPR, upbound,
8899                                     build_int_cst (TREE_TYPE (upbound), 1));
8900               if (tree_int_cst_lt (upbound, t))
8901                 {
8902                   tree v;
8903
8904                   for (v = TREE_OPERAND (expr, 0);
8905                        TREE_CODE (v) == COMPONENT_REF;
8906                        v = TREE_OPERAND (v, 0))
8907                     if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
8908                         == RECORD_TYPE)
8909                       {
8910                         tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
8911                         for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
8912                           if (TREE_CODE (fld_chain) == FIELD_DECL)
8913                             break;
8914
8915                         if (fld_chain)
8916                           break;
8917                       }
8918                   /* Don't warn if the array might be considered a poor
8919                      man's flexible array member with a very permissive
8920                      definition thereof.  */
8921                   if (TREE_CODE (v) == ARRAY_REF
8922                       || TREE_CODE (v) == COMPONENT_REF)
8923                     warning (OPT_Warray_bounds,
8924                              "index %E denotes an offset "
8925                              "greater than size of %qT",
8926                              t, TREE_TYPE (TREE_OPERAND (expr, 0)));
8927                 }
8928             }
8929         }
8930
8931       t = convert (sizetype, t);
8932       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
8933       break;
8934
8935     case COMPOUND_EXPR:
8936       /* Handle static members of volatile structs.  */
8937       t = TREE_OPERAND (expr, 1);
8938       gcc_assert (TREE_CODE (t) == VAR_DECL);
8939       return fold_offsetof_1 (t);
8940
8941     default:
8942       gcc_unreachable ();
8943     }
8944
8945   return fold_build_pointer_plus (base, off);
8946 }
8947
8948 /* Likewise, but convert it to the return type of offsetof.  */
8949
8950 tree
8951 fold_offsetof (tree expr)
8952 {
8953   return convert (size_type_node, fold_offsetof_1 (expr));
8954 }
8955
8956 /* Warn for A ?: C expressions (with B omitted) where A is a boolean
8957    expression, because B will always be true. */
8958
8959 void
8960 warn_for_omitted_condop (location_t location, tree cond)
8961 {
8962   if (truth_value_p (TREE_CODE (cond)))
8963       warning_at (location, OPT_Wparentheses,
8964                 "the omitted middle operand in ?: will always be %<true%>, "
8965                 "suggest explicit middle operand");
8966 }
8967
8968 /* Give an error for storing into ARG, which is 'const'.  USE indicates
8969    how ARG was being used.  */
8970
8971 void
8972 readonly_error (tree arg, enum lvalue_use use)
8973 {
8974   gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
8975               || use == lv_asm);
8976   /* Using this macro rather than (for example) arrays of messages
8977      ensures that all the format strings are checked at compile
8978      time.  */
8979 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A)               \
8980                                    : (use == lv_increment ? (I)         \
8981                                    : (use == lv_decrement ? (D) : (AS))))
8982   if (TREE_CODE (arg) == COMPONENT_REF)
8983     {
8984       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
8985         error (READONLY_MSG (G_("assignment of member "
8986                                 "%qD in read-only object"),
8987                              G_("increment of member "
8988                                 "%qD in read-only object"),
8989                              G_("decrement of member "
8990                                 "%qD in read-only object"),
8991                              G_("member %qD in read-only object "
8992                                 "used as %<asm%> output")),
8993                TREE_OPERAND (arg, 1));
8994       else
8995         error (READONLY_MSG (G_("assignment of read-only member %qD"),
8996                              G_("increment of read-only member %qD"),
8997                              G_("decrement of read-only member %qD"),
8998                              G_("read-only member %qD used as %<asm%> output")),
8999                TREE_OPERAND (arg, 1));
9000     }
9001   else if (TREE_CODE (arg) == VAR_DECL)
9002     error (READONLY_MSG (G_("assignment of read-only variable %qD"),
9003                          G_("increment of read-only variable %qD"),
9004                          G_("decrement of read-only variable %qD"),
9005                          G_("read-only variable %qD used as %<asm%> output")),
9006            arg);
9007   else if (TREE_CODE (arg) == PARM_DECL)
9008     error (READONLY_MSG (G_("assignment of read-only parameter %qD"),
9009                          G_("increment of read-only parameter %qD"),
9010                          G_("decrement of read-only parameter %qD"),
9011                          G_("read-only parameter %qD use as %<asm%> output")),
9012            arg);
9013   else if (TREE_CODE (arg) == RESULT_DECL)
9014     {
9015       gcc_assert (c_dialect_cxx ());
9016       error (READONLY_MSG (G_("assignment of "
9017                               "read-only named return value %qD"),
9018                            G_("increment of "
9019                               "read-only named return value %qD"),
9020                            G_("decrement of "
9021                               "read-only named return value %qD"),
9022                            G_("read-only named return value %qD "
9023                               "used as %<asm%>output")),
9024              arg);
9025     }
9026   else if (TREE_CODE (arg) == FUNCTION_DECL)
9027     error (READONLY_MSG (G_("assignment of function %qD"),
9028                          G_("increment of function %qD"),
9029                          G_("decrement of function %qD"),
9030                          G_("function %qD used as %<asm%> output")),
9031            arg);
9032   else
9033     error (READONLY_MSG (G_("assignment of read-only location %qE"),
9034                          G_("increment of read-only location %qE"),
9035                          G_("decrement of read-only location %qE"),
9036                          G_("read-only location %qE used as %<asm%> output")),
9037            arg);
9038 }
9039
9040 /* Print an error message for an invalid lvalue.  USE says
9041    how the lvalue is being used and so selects the error message.  LOC
9042    is the location for the error.  */
9043
9044 void
9045 lvalue_error (location_t loc, enum lvalue_use use)
9046 {
9047   switch (use)
9048     {
9049     case lv_assign:
9050       error_at (loc, "lvalue required as left operand of assignment");
9051       break;
9052     case lv_increment:
9053       error_at (loc, "lvalue required as increment operand");
9054       break;
9055     case lv_decrement:
9056       error_at (loc, "lvalue required as decrement operand");
9057       break;
9058     case lv_addressof:
9059       error_at (loc, "lvalue required as unary %<&%> operand");
9060       break;
9061     case lv_asm:
9062       error_at (loc, "lvalue required in asm statement");
9063       break;
9064     default:
9065       gcc_unreachable ();
9066     }
9067 }
9068
9069 /* Print an error message for an invalid indirection of type TYPE.
9070    ERRSTRING is the name of the operator for the indirection.  */
9071
9072 void
9073 invalid_indirection_error (location_t loc, tree type, ref_operator errstring)
9074 {
9075   switch (errstring)
9076     {
9077     case RO_NULL:
9078       gcc_assert (c_dialect_cxx ());
9079       error_at (loc, "invalid type argument (have %qT)", type);
9080       break;
9081     case RO_ARRAY_INDEXING:
9082       error_at (loc,
9083                 "invalid type argument of array indexing (have %qT)",
9084                 type);
9085       break;
9086     case RO_UNARY_STAR:
9087       error_at (loc,
9088                 "invalid type argument of unary %<*%> (have %qT)",
9089                 type);
9090       break;
9091     case RO_ARROW:
9092       error_at (loc,
9093                 "invalid type argument of %<->%> (have %qT)",
9094                 type);
9095       break;
9096     case RO_IMPLICIT_CONVERSION:
9097       error_at (loc,
9098                 "invalid type argument of implicit conversion (have %qT)",
9099                 type);
9100       break;
9101     default:
9102       gcc_unreachable ();
9103     }
9104 }
9105 \f
9106 /* *PTYPE is an incomplete array.  Complete it with a domain based on
9107    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
9108    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
9109    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
9110
9111 int
9112 complete_array_type (tree *ptype, tree initial_value, bool do_default)
9113 {
9114   tree maxindex, type, main_type, elt, unqual_elt;
9115   int failure = 0, quals;
9116   hashval_t hashcode = 0;
9117
9118   maxindex = size_zero_node;
9119   if (initial_value)
9120     {
9121       if (TREE_CODE (initial_value) == STRING_CST)
9122         {
9123           int eltsize
9124             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
9125           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
9126         }
9127       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
9128         {
9129           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
9130
9131           if (VEC_empty (constructor_elt, v))
9132             {
9133               if (pedantic)
9134                 failure = 3;
9135               maxindex = ssize_int (-1);
9136             }
9137           else
9138             {
9139               tree curindex;
9140               unsigned HOST_WIDE_INT cnt;
9141               constructor_elt *ce;
9142               bool fold_p = false;
9143
9144               if (VEC_index (constructor_elt, v, 0)->index)
9145                 maxindex = fold_convert_loc (input_location, sizetype,
9146                                              VEC_index (constructor_elt,
9147                                                         v, 0)->index);
9148               curindex = maxindex;
9149
9150               for (cnt = 1;
9151                    VEC_iterate (constructor_elt, v, cnt, ce);
9152                    cnt++)
9153                 {
9154                   bool curfold_p = false;
9155                   if (ce->index)
9156                     curindex = ce->index, curfold_p = true;
9157                   else
9158                     {
9159                       if (fold_p)
9160                         curindex = fold_convert (sizetype, curindex);
9161                       curindex = size_binop (PLUS_EXPR, curindex,
9162                                              size_one_node);
9163                     }
9164                   if (tree_int_cst_lt (maxindex, curindex))
9165                     maxindex = curindex, fold_p = curfold_p;
9166                 }
9167                if (fold_p)
9168                  maxindex = fold_convert (sizetype, maxindex);
9169             }
9170         }
9171       else
9172         {
9173           /* Make an error message unless that happened already.  */
9174           if (initial_value != error_mark_node)
9175             failure = 1;
9176         }
9177     }
9178   else
9179     {
9180       failure = 2;
9181       if (!do_default)
9182         return failure;
9183     }
9184
9185   type = *ptype;
9186   elt = TREE_TYPE (type);
9187   quals = TYPE_QUALS (strip_array_types (elt));
9188   if (quals == 0)
9189     unqual_elt = elt;
9190   else
9191     unqual_elt = c_build_qualified_type (elt, KEEP_QUAL_ADDR_SPACE (quals));
9192
9193   /* Using build_distinct_type_copy and modifying things afterward instead
9194      of using build_array_type to create a new type preserves all of the
9195      TYPE_LANG_FLAG_? bits that the front end may have set.  */
9196   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
9197   TREE_TYPE (main_type) = unqual_elt;
9198   TYPE_DOMAIN (main_type)
9199     = build_range_type (TREE_TYPE (maxindex),
9200                         build_int_cst (TREE_TYPE (maxindex), 0), maxindex);
9201   layout_type (main_type);
9202
9203   /* Make sure we have the canonical MAIN_TYPE. */
9204   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
9205   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
9206                                     hashcode);
9207   main_type = type_hash_canon (hashcode, main_type);
9208
9209   /* Fix the canonical type.  */
9210   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
9211       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
9212     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
9213   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
9214            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
9215                != TYPE_DOMAIN (main_type)))
9216     TYPE_CANONICAL (main_type)
9217       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
9218                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
9219   else
9220     TYPE_CANONICAL (main_type) = main_type;
9221
9222   if (quals == 0)
9223     type = main_type;
9224   else
9225     type = c_build_qualified_type (main_type, quals);
9226
9227   if (COMPLETE_TYPE_P (type)
9228       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
9229       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
9230     {
9231       error ("size of array is too large");
9232       /* If we proceed with the array type as it is, we'll eventually
9233          crash in tree_low_cst().  */
9234       type = error_mark_node;
9235     }
9236
9237   *ptype = type;
9238   return failure;
9239 }
9240
9241 /* Like c_mark_addressable but don't check register qualifier.  */
9242 void
9243 c_common_mark_addressable_vec (tree t)
9244 {
9245   while (handled_component_p (t))
9246     t = TREE_OPERAND (t, 0);
9247   if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9248     return;
9249   TREE_ADDRESSABLE (t) = 1;
9250 }
9251
9252
9253 \f
9254 /* Used to help initialize the builtin-types.def table.  When a type of
9255    the correct size doesn't exist, use error_mark_node instead of NULL.
9256    The later results in segfaults even when a decl using the type doesn't
9257    get invoked.  */
9258
9259 tree
9260 builtin_type_for_size (int size, bool unsignedp)
9261 {
9262   tree type = lang_hooks.types.type_for_size (size, unsignedp);
9263   return type ? type : error_mark_node;
9264 }
9265
9266 /* A helper function for resolve_overloaded_builtin in resolving the
9267    overloaded __sync_ builtins.  Returns a positive power of 2 if the
9268    first operand of PARAMS is a pointer to a supported data type.
9269    Returns 0 if an error is encountered.  */
9270
9271 static int
9272 sync_resolve_size (tree function, VEC(tree,gc) *params)
9273 {
9274   tree type;
9275   int size;
9276
9277   if (VEC_empty (tree, params))
9278     {
9279       error ("too few arguments to function %qE", function);
9280       return 0;
9281     }
9282
9283   type = TREE_TYPE (VEC_index (tree, params, 0));
9284   if (TREE_CODE (type) != POINTER_TYPE)
9285     goto incompatible;
9286
9287   type = TREE_TYPE (type);
9288   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9289     goto incompatible;
9290
9291   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
9292   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
9293     return size;
9294
9295  incompatible:
9296   error ("incompatible type for argument %d of %qE", 1, function);
9297   return 0;
9298 }
9299
9300 /* A helper function for resolve_overloaded_builtin.  Adds casts to
9301    PARAMS to make arguments match up with those of FUNCTION.  Drops
9302    the variadic arguments at the end.  Returns false if some error
9303    was encountered; true on success.  */
9304
9305 static bool
9306 sync_resolve_params (location_t loc, tree orig_function, tree function,
9307                      VEC(tree, gc) *params, bool orig_format)
9308 {
9309   function_args_iterator iter;
9310   tree ptype;
9311   unsigned int parmnum;
9312
9313   function_args_iter_init (&iter, TREE_TYPE (function));
9314   /* We've declared the implementation functions to use "volatile void *"
9315      as the pointer parameter, so we shouldn't get any complaints from the
9316      call to check_function_arguments what ever type the user used.  */
9317   function_args_iter_next (&iter);
9318   ptype = TREE_TYPE (TREE_TYPE (VEC_index (tree, params, 0)));
9319
9320   /* For the rest of the values, we need to cast these to FTYPE, so that we
9321      don't get warnings for passing pointer types, etc.  */
9322   parmnum = 0;
9323   while (1)
9324     {
9325       tree val, arg_type;
9326
9327       arg_type = function_args_iter_cond (&iter);
9328       /* XXX void_type_node belies the abstraction.  */
9329       if (arg_type == void_type_node)
9330         break;
9331
9332       ++parmnum;
9333       if (VEC_length (tree, params) <= parmnum)
9334         {
9335           error_at (loc, "too few arguments to function %qE", orig_function);
9336           return false;
9337         }
9338
9339       /* Only convert parameters if arg_type is unsigned integer type with
9340          new format sync routines, i.e. don't attempt to convert pointer
9341          arguments (e.g. EXPECTED argument of __atomic_compare_exchange_n),
9342          bool arguments (e.g. WEAK argument) or signed int arguments (memmodel
9343          kinds).  */
9344       if (TREE_CODE (arg_type) == INTEGER_TYPE && TYPE_UNSIGNED (arg_type))
9345         {
9346           /* Ideally for the first conversion we'd use convert_for_assignment
9347              so that we get warnings for anything that doesn't match the pointer
9348              type.  This isn't portable across the C and C++ front ends atm.  */
9349           val = VEC_index (tree, params, parmnum);
9350           val = convert (ptype, val);
9351           val = convert (arg_type, val);
9352           VEC_replace (tree, params, parmnum, val);
9353         }
9354
9355       function_args_iter_next (&iter);
9356     }
9357
9358   /* __atomic routines are not variadic.  */
9359   if (!orig_format && VEC_length (tree, params) != parmnum + 1)
9360     {
9361       error_at (loc, "too many arguments to function %qE", orig_function);
9362       return false;
9363     }
9364
9365   /* The definition of these primitives is variadic, with the remaining
9366      being "an optional list of variables protected by the memory barrier".
9367      No clue what that's supposed to mean, precisely, but we consider all
9368      call-clobbered variables to be protected so we're safe.  */
9369   VEC_truncate (tree, params, parmnum + 1);
9370
9371   return true;
9372 }
9373
9374 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
9375    RESULT to make it match the type of the first pointer argument in
9376    PARAMS.  */
9377
9378 static tree
9379 sync_resolve_return (tree first_param, tree result, bool orig_format)
9380 {
9381   tree ptype = TREE_TYPE (TREE_TYPE (first_param));
9382   tree rtype = TREE_TYPE (result);
9383   ptype = TYPE_MAIN_VARIANT (ptype);
9384
9385   /* New format doesn't require casting unless the types are the same size.  */
9386   if (orig_format || tree_int_cst_equal (TYPE_SIZE (ptype), TYPE_SIZE (rtype)))
9387     return convert (ptype, result);
9388   else
9389     return result;
9390 }
9391
9392 /* This function verifies the PARAMS to generic atomic FUNCTION.
9393    It returns the size if all the parameters are the same size, otherwise
9394    0 is returned if the parameters are invalid.  */
9395
9396 static int
9397 get_atomic_generic_size (location_t loc, tree function, VEC(tree,gc) *params)
9398 {
9399   unsigned int n_param;
9400   unsigned int n_model;
9401   unsigned int x;
9402   int size_0;
9403   tree type_0;
9404
9405   /* Determine the parameter makeup.  */
9406   switch (DECL_FUNCTION_CODE (function))
9407     {
9408     case BUILT_IN_ATOMIC_EXCHANGE:
9409       n_param = 4;
9410       n_model = 1;
9411       break;
9412     case BUILT_IN_ATOMIC_LOAD:
9413     case BUILT_IN_ATOMIC_STORE:
9414       n_param = 3;
9415       n_model = 1;
9416       break;
9417     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE:
9418       n_param = 6;
9419       n_model = 2;
9420       break;
9421     default:
9422       gcc_unreachable ();
9423     }
9424
9425   if (VEC_length (tree, params) != n_param)
9426     {
9427       error_at (loc, "incorrect number of arguments to function %qE", function);
9428       return 0;
9429     }
9430
9431   /* Get type of first parameter, and determine its size.  */
9432   type_0 = TREE_TYPE (VEC_index (tree, params, 0));
9433   if (TREE_CODE (type_0) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (type_0)))
9434     {
9435       error_at (loc, "argument 1 of %qE must be a non-void pointer type",
9436                 function);
9437       return 0;
9438     }
9439
9440   /* Types must be compile time constant sizes. */
9441   if (TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type_0)))) != INTEGER_CST)
9442     {
9443       error_at (loc,
9444                 "argument 1 of %qE must be a pointer to a constant size type",
9445                 function);
9446       return 0;
9447     }
9448
9449   size_0 = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (type_0)), 1);
9450
9451   /* Zero size objects are not allowed.  */
9452   if (size_0 == 0)
9453     {
9454       error_at (loc,
9455                 "argument 1 of %qE must be a pointer to a nonzero size object",
9456                 function);
9457       return 0;
9458     }
9459
9460   /* Check each other parameter is a pointer and the same size.  */
9461   for (x = 0; x < n_param - n_model; x++)
9462     {
9463       int size;
9464       tree type = TREE_TYPE (VEC_index (tree, params, x));
9465       /* __atomic_compare_exchange has a bool in the 4th postion, skip it.  */
9466       if (n_param == 6 && x == 3)
9467         continue;
9468       if (!POINTER_TYPE_P (type))
9469         {
9470           error_at (loc, "argument %d of %qE must be a pointer type", x + 1,
9471                     function);
9472           return 0;
9473         }
9474       size = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (type)), 1);
9475       if (size != size_0)
9476         {
9477           error_at (loc, "size mismatch in argument %d of %qE", x + 1,
9478                     function);
9479           return 0;
9480         }
9481     }
9482
9483   /* Check memory model parameters for validity.  */
9484   for (x = n_param - n_model ; x < n_param; x++)
9485     {
9486       tree p = VEC_index (tree, params, x);
9487       if (TREE_CODE (p) == INTEGER_CST)
9488         {
9489           int i = tree_low_cst (p, 1);
9490           if (i < 0 || i >= MEMMODEL_LAST)
9491             {
9492               warning_at (loc, OPT_Winvalid_memory_model,
9493                           "invalid memory model argument %d of %qE", x + 1,
9494                           function);
9495             }
9496         }
9497       else
9498         if (!INTEGRAL_TYPE_P (TREE_TYPE (p)))
9499           {
9500             error_at (loc, "non-integer memory model argument %d of %qE", x + 1,
9501                    function);
9502             return 0;
9503           }
9504       }
9505
9506   return size_0;
9507 }
9508
9509
9510 /* This will take an __atomic_ generic FUNCTION call, and add a size parameter N
9511    at the beginning of the parameter list PARAMS representing the size of the
9512    objects.  This is to match the library ABI requirement.  LOC is the location
9513    of the function call.
9514    The new function is returned if it needed rebuilding, otherwise NULL_TREE is
9515    returned to allow the external call to be constructed.  */
9516
9517 static tree
9518 add_atomic_size_parameter (unsigned n, location_t loc, tree function,
9519                            VEC(tree,gc) *params)
9520 {
9521   tree size_node;
9522
9523   /* Insert a SIZE_T parameter as the first param.  If there isn't
9524      enough space, allocate a new vector and recursively re-build with that.  */
9525   if (!VEC_space (tree, params, 1))
9526     {
9527       unsigned int z, len;
9528       VEC(tree,gc) *vec;
9529       tree f;
9530
9531       len = VEC_length (tree, params);
9532       vec = VEC_alloc (tree, gc, len + 1);
9533       for (z = 0; z < len; z++)
9534         VEC_quick_push (tree, vec, VEC_index (tree, params, z));
9535       f = build_function_call_vec (loc, function, vec, NULL);
9536       VEC_free (tree, gc, vec);
9537       return f;
9538     }
9539
9540   /* Add the size parameter and leave as a function call for processing.  */
9541   size_node = build_int_cst (size_type_node, n);
9542   VEC_quick_insert (tree, params, 0, size_node);
9543   return NULL_TREE;
9544 }
9545
9546
9547 /* This will process an __atomic_exchange function call, determine whether it
9548    needs to be mapped to the _N variation, or turned into a library call.
9549    LOC is the location of the builtin call.
9550    FUNCTION is the DECL that has been invoked;
9551    PARAMS is the argument list for the call.  The return value is non-null
9552    TRUE is returned if it is translated into the proper format for a call to the
9553    external library, and NEW_RETURN is set the tree for that function.
9554    FALSE is returned if processing for the _N variation is required, and
9555    NEW_RETURN is set to the the return value the result is copied into.  */
9556 static bool
9557 resolve_overloaded_atomic_exchange (location_t loc, tree function,
9558                                     VEC(tree,gc) *params, tree *new_return)
9559 {
9560   tree p0, p1, p2, p3;
9561   tree I_type, I_type_ptr;
9562   int n = get_atomic_generic_size (loc, function, params);
9563
9564   /* Size of 0 is an error condition.  */
9565   if (n == 0)
9566     {
9567       *new_return = error_mark_node;
9568       return true;
9569     }
9570
9571   /* If not a lock-free size, change to the library generic format.  */
9572   if (n != 1 && n != 2 && n != 4 && n != 8 && n != 16)
9573     {
9574       *new_return = add_atomic_size_parameter (n, loc, function, params);
9575       return true;
9576     }
9577
9578   /* Otherwise there is a lockfree match, transform the call from:
9579        void fn(T* mem, T* desired, T* return, model)
9580      into
9581        *return = (T) (fn (In* mem, (In) *desired, model))  */
9582
9583   p0 = VEC_index (tree, params, 0);
9584   p1 = VEC_index (tree, params, 1);
9585   p2 = VEC_index (tree, params, 2);
9586   p3 = VEC_index (tree, params, 3);
9587
9588   /* Create pointer to appropriate size.  */
9589   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
9590   I_type_ptr = build_pointer_type (I_type);
9591
9592   /* Convert object pointer to required type.  */
9593   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
9594   VEC_replace (tree, params, 0, p0);
9595   /* Convert new value to required type, and dereference it.  */
9596   p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
9597   p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
9598   VEC_replace (tree, params, 1, p1);
9599
9600   /* Move memory model to the 3rd position, and end param list.  */
9601   VEC_replace (tree, params, 2, p3);
9602   VEC_truncate (tree, params, 3);
9603
9604   /* Convert return pointer and dereference it for later assignment.  */
9605   *new_return = build_indirect_ref (loc, p2, RO_UNARY_STAR);
9606
9607   return false;
9608 }
9609
9610
9611 /* This will process an __atomic_compare_exchange function call, determine
9612    whether it needs to be mapped to the _N variation, or turned into a lib call.
9613    LOC is the location of the builtin call.
9614    FUNCTION is the DECL that has been invoked;
9615    PARAMS is the argument list for the call.  The return value is non-null
9616    TRUE is returned if it is translated into the proper format for a call to the
9617    external library, and NEW_RETURN is set the tree for that function.
9618    FALSE is returned if processing for the _N variation is required.  */
9619
9620 static bool
9621 resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
9622                                             VEC(tree,gc) *params,
9623                                             tree *new_return)
9624 {
9625   tree p0, p1, p2;
9626   tree I_type, I_type_ptr;
9627   int n = get_atomic_generic_size (loc, function, params);
9628
9629   /* Size of 0 is an error condition.  */
9630   if (n == 0)
9631     {
9632       *new_return = error_mark_node;
9633       return true;
9634     }
9635
9636   /* If not a lock-free size, change to the library generic format.  */
9637   if (n != 1 && n != 2 && n != 4 && n != 8 && n != 16)
9638     {
9639       /* The library generic format does not have the weak parameter, so
9640          remove it from the param list.  Since a parameter has been removed,
9641          we can be sure that there is room for the SIZE_T parameter, meaning
9642          there will not be a recursive rebuilding of the parameter list, so
9643          there is no danger this will be done twice.  */
9644       if (n > 0)
9645         {
9646           VEC_replace (tree, params, 3, VEC_index (tree, params, 4));
9647           VEC_replace (tree, params, 4, VEC_index (tree, params, 5));
9648           VEC_truncate (tree, params, 5);
9649         }
9650       *new_return = add_atomic_size_parameter (n, loc, function, params);
9651       return true;
9652     }
9653
9654   /* Otherwise, there is a match, so the call needs to be transformed from:
9655        bool fn(T* mem, T* desired, T* return, weak, success, failure)
9656      into
9657        bool fn ((In *)mem, (In *)expected, (In) *desired, weak, succ, fail)  */
9658
9659   p0 = VEC_index (tree, params, 0);
9660   p1 = VEC_index (tree, params, 1);
9661   p2 = VEC_index (tree, params, 2);
9662
9663   /* Create pointer to appropriate size.  */
9664   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
9665   I_type_ptr = build_pointer_type (I_type);
9666
9667   /* Convert object pointer to required type.  */
9668   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
9669   VEC_replace (tree, params, 0, p0);
9670
9671   /* Convert expected pointer to required type.  */
9672   p1 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p1);
9673   VEC_replace (tree, params, 1, p1);
9674
9675   /* Convert desired value to required type, and dereference it.  */
9676   p2 = build_indirect_ref (loc, p2, RO_UNARY_STAR);
9677   p2 = build1 (VIEW_CONVERT_EXPR, I_type, p2);
9678   VEC_replace (tree, params, 2, p2);
9679
9680   /* The rest of the parameters are fine. NULL means no special return value
9681      processing.*/
9682   *new_return = NULL;
9683   return false;
9684 }
9685
9686
9687 /* This will process an __atomic_load function call, determine whether it
9688    needs to be mapped to the _N variation, or turned into a library call.
9689    LOC is the location of the builtin call.
9690    FUNCTION is the DECL that has been invoked;
9691    PARAMS is the argument list for the call.  The return value is non-null
9692    TRUE is returned if it is translated into the proper format for a call to the
9693    external library, and NEW_RETURN is set the tree for that function.
9694    FALSE is returned if processing for the _N variation is required, and
9695    NEW_RETURN is set to the the return value the result is copied into.  */
9696
9697 static bool
9698 resolve_overloaded_atomic_load (location_t loc, tree function,
9699                                 VEC(tree,gc) *params, tree *new_return)
9700 {
9701   tree p0, p1, p2;
9702   tree I_type, I_type_ptr;
9703   int n = get_atomic_generic_size (loc, function, params);
9704
9705   /* Size of 0 is an error condition.  */
9706   if (n == 0)
9707     {
9708       *new_return = error_mark_node;
9709       return true;
9710     }
9711
9712   /* If not a lock-free size, change to the library generic format.  */
9713   if (n != 1 && n != 2 && n != 4 && n != 8 && n != 16)
9714     {
9715       *new_return = add_atomic_size_parameter (n, loc, function, params);
9716       return true;
9717     }
9718
9719   /* Otherwise, there is a match, so the call needs to be transformed from:
9720        void fn(T* mem, T* return, model)
9721      into
9722        *return = (T) (fn ((In *) mem, model))  */
9723
9724   p0 = VEC_index (tree, params, 0);
9725   p1 = VEC_index (tree, params, 1);
9726   p2 = VEC_index (tree, params, 2);
9727
9728   /* Create pointer to appropriate size.  */
9729   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
9730   I_type_ptr = build_pointer_type (I_type);
9731
9732   /* Convert object pointer to required type.  */
9733   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
9734   VEC_replace (tree, params, 0, p0);
9735
9736   /* Move memory model to the 2nd position, and end param list.  */
9737   VEC_replace (tree, params, 1, p2);
9738   VEC_truncate (tree, params, 2);
9739
9740   /* Convert return pointer and dereference it for later assignment.  */
9741   *new_return = build_indirect_ref (loc, p1, RO_UNARY_STAR);
9742
9743   return false;
9744 }
9745
9746
9747 /* This will process an __atomic_store function call, determine whether it
9748    needs to be mapped to the _N variation, or turned into a library call.
9749    LOC is the location of the builtin call.
9750    FUNCTION is the DECL that has been invoked;
9751    PARAMS is the argument list for the call.  The return value is non-null
9752    TRUE is returned if it is translated into the proper format for a call to the
9753    external library, and NEW_RETURN is set the tree for that function.
9754    FALSE is returned if processing for the _N variation is required, and
9755    NEW_RETURN is set to the the return value the result is copied into.  */
9756
9757 static bool
9758 resolve_overloaded_atomic_store (location_t loc, tree function,
9759                                  VEC(tree,gc) *params, tree *new_return)
9760 {
9761   tree p0, p1;
9762   tree I_type, I_type_ptr;
9763   int n = get_atomic_generic_size (loc, function, params);
9764
9765   /* Size of 0 is an error condition.  */
9766   if (n == 0)
9767     {
9768       *new_return = error_mark_node;
9769       return true;
9770     }
9771
9772   /* If not a lock-free size, change to the library generic format.  */
9773   if (n != 1 && n != 2 && n != 4 && n != 8 && n != 16)
9774     {
9775       *new_return = add_atomic_size_parameter (n, loc, function, params);
9776       return true;
9777     }
9778
9779   /* Otherwise, there is a match, so the call needs to be transformed from:
9780        void fn(T* mem, T* value, model)
9781      into
9782        fn ((In *) mem, (In) *value, model)  */
9783
9784   p0 = VEC_index (tree, params, 0);
9785   p1 = VEC_index (tree, params, 1);
9786
9787   /* Create pointer to appropriate size.  */
9788   I_type = builtin_type_for_size (BITS_PER_UNIT * n, 1);
9789   I_type_ptr = build_pointer_type (I_type);
9790
9791   /* Convert object pointer to required type.  */
9792   p0 = build1 (VIEW_CONVERT_EXPR, I_type_ptr, p0);
9793   VEC_replace (tree, params, 0, p0);
9794
9795   /* Convert new value to required type, and dereference it.  */
9796   p1 = build_indirect_ref (loc, p1, RO_UNARY_STAR);
9797   p1 = build1 (VIEW_CONVERT_EXPR, I_type, p1);
9798   VEC_replace (tree, params, 1, p1);
9799
9800   /* The memory model is in the right spot already. Return is void.  */
9801   *new_return = NULL_TREE;
9802
9803   return false;
9804 }
9805
9806
9807 /* Some builtin functions are placeholders for other expressions.  This
9808    function should be called immediately after parsing the call expression
9809    before surrounding code has committed to the type of the expression.
9810
9811    LOC is the location of the builtin call.
9812
9813    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
9814    PARAMS is the argument list for the call.  The return value is non-null
9815    when expansion is complete, and null if normal processing should
9816    continue.  */
9817
9818 tree
9819 resolve_overloaded_builtin (location_t loc, tree function, VEC(tree,gc) *params)
9820 {
9821   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
9822   bool orig_format = true;
9823   tree new_return = NULL_TREE;
9824
9825   switch (DECL_BUILT_IN_CLASS (function))
9826     {
9827     case BUILT_IN_NORMAL:
9828       break;
9829     case BUILT_IN_MD:
9830       if (targetm.resolve_overloaded_builtin)
9831         return targetm.resolve_overloaded_builtin (loc, function, params);
9832       else
9833         return NULL_TREE;
9834     default:
9835       return NULL_TREE;
9836     }
9837
9838   /* Handle BUILT_IN_NORMAL here.  */
9839   switch (orig_code)
9840     {
9841     case BUILT_IN_ATOMIC_EXCHANGE:
9842     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE:
9843     case BUILT_IN_ATOMIC_LOAD:
9844     case BUILT_IN_ATOMIC_STORE:
9845       {
9846         /* Handle these 4 together so that they can fall through to the next
9847            case if the call is transformed to an _N variant.  */
9848         switch (orig_code)
9849         {
9850           case BUILT_IN_ATOMIC_EXCHANGE:
9851             {
9852               if (resolve_overloaded_atomic_exchange (loc, function, params,
9853                                                       &new_return))
9854                 return new_return;
9855               /* Change to the _N variant.  */
9856               orig_code = BUILT_IN_ATOMIC_EXCHANGE_N;
9857               break;
9858             }
9859
9860           case BUILT_IN_ATOMIC_COMPARE_EXCHANGE:
9861             {
9862               if (resolve_overloaded_atomic_compare_exchange (loc, function,
9863                                                               params,
9864                                                               &new_return))
9865                 return new_return;
9866               /* Change to the _N variant.  */
9867               orig_code = BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N;
9868               break;
9869             }
9870           case BUILT_IN_ATOMIC_LOAD:
9871             {
9872               if (resolve_overloaded_atomic_load (loc, function, params,
9873                                                   &new_return))
9874                 return new_return;
9875               /* Change to the _N variant.  */
9876               orig_code = BUILT_IN_ATOMIC_LOAD_N;
9877               break;
9878             }
9879           case BUILT_IN_ATOMIC_STORE:
9880             {
9881               if (resolve_overloaded_atomic_store (loc, function, params,
9882                                                    &new_return))
9883                 return new_return;
9884               /* Change to the _N variant.  */
9885               orig_code = BUILT_IN_ATOMIC_STORE_N;
9886               break;
9887             }
9888           default:
9889             gcc_unreachable ();
9890         }
9891         /* Fallthrough to the normal processing.  */
9892       }
9893     case BUILT_IN_ATOMIC_EXCHANGE_N:
9894     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N:
9895     case BUILT_IN_ATOMIC_LOAD_N:
9896     case BUILT_IN_ATOMIC_STORE_N:
9897     case BUILT_IN_ATOMIC_ADD_FETCH_N:
9898     case BUILT_IN_ATOMIC_SUB_FETCH_N:
9899     case BUILT_IN_ATOMIC_AND_FETCH_N:
9900     case BUILT_IN_ATOMIC_NAND_FETCH_N:
9901     case BUILT_IN_ATOMIC_XOR_FETCH_N:
9902     case BUILT_IN_ATOMIC_OR_FETCH_N:
9903     case BUILT_IN_ATOMIC_FETCH_ADD_N:
9904     case BUILT_IN_ATOMIC_FETCH_SUB_N:
9905     case BUILT_IN_ATOMIC_FETCH_AND_N:
9906     case BUILT_IN_ATOMIC_FETCH_NAND_N:
9907     case BUILT_IN_ATOMIC_FETCH_XOR_N:
9908     case BUILT_IN_ATOMIC_FETCH_OR_N:
9909       {
9910         orig_format = false;
9911         /* Fallthru for parameter processing.  */
9912       }
9913     case BUILT_IN_SYNC_FETCH_AND_ADD_N:
9914     case BUILT_IN_SYNC_FETCH_AND_SUB_N:
9915     case BUILT_IN_SYNC_FETCH_AND_OR_N:
9916     case BUILT_IN_SYNC_FETCH_AND_AND_N:
9917     case BUILT_IN_SYNC_FETCH_AND_XOR_N:
9918     case BUILT_IN_SYNC_FETCH_AND_NAND_N:
9919     case BUILT_IN_SYNC_ADD_AND_FETCH_N:
9920     case BUILT_IN_SYNC_SUB_AND_FETCH_N:
9921     case BUILT_IN_SYNC_OR_AND_FETCH_N:
9922     case BUILT_IN_SYNC_AND_AND_FETCH_N:
9923     case BUILT_IN_SYNC_XOR_AND_FETCH_N:
9924     case BUILT_IN_SYNC_NAND_AND_FETCH_N:
9925     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N:
9926     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N:
9927     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_N:
9928     case BUILT_IN_SYNC_LOCK_RELEASE_N:
9929       {
9930         int n = sync_resolve_size (function, params);
9931         tree new_function, first_param, result;
9932         enum built_in_function fncode;
9933
9934         if (n == 0)
9935           return error_mark_node;
9936
9937         fncode = (enum built_in_function)((int)orig_code + exact_log2 (n) + 1);
9938         new_function = builtin_decl_explicit (fncode);
9939         if (!sync_resolve_params (loc, function, new_function, params,
9940                                   orig_format))
9941           return error_mark_node;
9942
9943         first_param = VEC_index (tree, params, 0);
9944         result = build_function_call_vec (loc, new_function, params, NULL);
9945         if (result == error_mark_node)
9946           return result;
9947         if (orig_code != BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
9948             && orig_code != BUILT_IN_SYNC_LOCK_RELEASE_N
9949             && orig_code != BUILT_IN_ATOMIC_STORE_N)
9950           result = sync_resolve_return (first_param, result, orig_format);
9951
9952         /* If new_return is set, assign function to that expr and cast the
9953            result to void since the generic interface returned void.  */
9954         if (new_return)
9955           {
9956             /* Cast function result from I{1,2,4,8,16} to the required type.  */
9957             result = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (new_return), result);
9958             result = build2 (MODIFY_EXPR, TREE_TYPE (new_return), new_return,
9959                              result);
9960             TREE_SIDE_EFFECTS (result) = 1;
9961             protected_set_expr_location (result, loc);
9962             result = convert (void_type_node, result);
9963           }
9964         return result;
9965       }
9966
9967     default:
9968       return NULL_TREE;
9969     }
9970 }
9971
9972 /* Ignoring their sign, return true if two scalar types are the same.  */
9973 bool
9974 same_scalar_type_ignoring_signedness (tree t1, tree t2)
9975 {
9976   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
9977
9978   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
9979               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
9980                   || c2 == FIXED_POINT_TYPE));
9981
9982   /* Equality works here because c_common_signed_type uses
9983      TYPE_MAIN_VARIANT.  */
9984   return c_common_signed_type (t1)
9985     == c_common_signed_type (t2);
9986 }
9987
9988 /* Check for missing format attributes on function pointers.  LTYPE is
9989    the new type or left-hand side type.  RTYPE is the old type or
9990    right-hand side type.  Returns TRUE if LTYPE is missing the desired
9991    attribute.  */
9992
9993 bool
9994 check_missing_format_attribute (tree ltype, tree rtype)
9995 {
9996   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
9997   tree ra;
9998
9999   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
10000     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
10001       break;
10002   if (ra)
10003     {
10004       tree la;
10005       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
10006         if (is_attribute_p ("format", TREE_PURPOSE (la)))
10007           break;
10008       return !la;
10009     }
10010   else
10011     return false;
10012 }
10013
10014 /* Subscripting with type char is likely to lose on a machine where
10015    chars are signed.  So warn on any machine, but optionally.  Don't
10016    warn for unsigned char since that type is safe.  Don't warn for
10017    signed char because anyone who uses that must have done so
10018    deliberately. Furthermore, we reduce the false positive load by
10019    warning only for non-constant value of type char.  */
10020
10021 void
10022 warn_array_subscript_with_type_char (tree index)
10023 {
10024   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
10025       && TREE_CODE (index) != INTEGER_CST)
10026     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
10027 }
10028
10029 /* Implement -Wparentheses for the unexpected C precedence rules, to
10030    cover cases like x + y << z which readers are likely to
10031    misinterpret.  We have seen an expression in which CODE is a binary
10032    operator used to combine expressions ARG_LEFT and ARG_RIGHT, which
10033    before folding had CODE_LEFT and CODE_RIGHT.  CODE_LEFT and
10034    CODE_RIGHT may be ERROR_MARK, which means that that side of the
10035    expression was not formed using a binary or unary operator, or it
10036    was enclosed in parentheses.  */
10037
10038 void
10039 warn_about_parentheses (enum tree_code code,
10040                         enum tree_code code_left, tree arg_left,
10041                         enum tree_code code_right, tree arg_right)
10042 {
10043   if (!warn_parentheses)
10044     return;
10045
10046   /* This macro tests that the expression ARG with original tree code
10047      CODE appears to be a boolean expression. or the result of folding a
10048      boolean expression.  */
10049 #define APPEARS_TO_BE_BOOLEAN_EXPR_P(CODE, ARG)                             \
10050         (truth_value_p (TREE_CODE (ARG))                                    \
10051          || TREE_CODE (TREE_TYPE (ARG)) == BOOLEAN_TYPE                     \
10052          /* Folding may create 0 or 1 integers from other expressions.  */  \
10053          || ((CODE) != INTEGER_CST                                          \
10054              && (integer_onep (ARG) || integer_zerop (ARG))))
10055
10056   switch (code)
10057     {
10058     case LSHIFT_EXPR:
10059       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
10060         warning (OPT_Wparentheses,
10061                  "suggest parentheses around %<+%> inside %<<<%>");
10062       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
10063         warning (OPT_Wparentheses,
10064                  "suggest parentheses around %<-%> inside %<<<%>");
10065       return;
10066
10067     case RSHIFT_EXPR:
10068       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
10069         warning (OPT_Wparentheses,
10070                  "suggest parentheses around %<+%> inside %<>>%>");
10071       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
10072         warning (OPT_Wparentheses,
10073                  "suggest parentheses around %<-%> inside %<>>%>");
10074       return;
10075
10076     case TRUTH_ORIF_EXPR:
10077       if (code_left == TRUTH_ANDIF_EXPR || code_right == TRUTH_ANDIF_EXPR)
10078         warning (OPT_Wparentheses,
10079                  "suggest parentheses around %<&&%> within %<||%>");
10080       return;
10081
10082     case BIT_IOR_EXPR:
10083       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
10084           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
10085           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
10086           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
10087         warning (OPT_Wparentheses,
10088                  "suggest parentheses around arithmetic in operand of %<|%>");
10089       /* Check cases like x|y==z */
10090       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
10091                || TREE_CODE_CLASS (code_right) == tcc_comparison)
10092         warning (OPT_Wparentheses,
10093                  "suggest parentheses around comparison in operand of %<|%>");
10094       /* Check cases like !x | y */
10095       else if (code_left == TRUTH_NOT_EXPR
10096                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
10097         warning (OPT_Wparentheses, "suggest parentheses around operand of "
10098                  "%<!%> or change %<|%> to %<||%> or %<!%> to %<~%>");
10099       return;
10100
10101     case BIT_XOR_EXPR:
10102       if (code_left == BIT_AND_EXPR
10103           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
10104           || code_right == BIT_AND_EXPR
10105           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
10106         warning (OPT_Wparentheses,
10107                  "suggest parentheses around arithmetic in operand of %<^%>");
10108       /* Check cases like x^y==z */
10109       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
10110                || TREE_CODE_CLASS (code_right) == tcc_comparison)
10111         warning (OPT_Wparentheses,
10112                  "suggest parentheses around comparison in operand of %<^%>");
10113       return;
10114
10115     case BIT_AND_EXPR:
10116       if (code_left == PLUS_EXPR || code_right == PLUS_EXPR)
10117         warning (OPT_Wparentheses,
10118                  "suggest parentheses around %<+%> in operand of %<&%>");
10119       else if (code_left == MINUS_EXPR || code_right == MINUS_EXPR)
10120         warning (OPT_Wparentheses,
10121                  "suggest parentheses around %<-%> in operand of %<&%>");
10122       /* Check cases like x&y==z */
10123       else if (TREE_CODE_CLASS (code_left) == tcc_comparison
10124                || TREE_CODE_CLASS (code_right) == tcc_comparison)
10125         warning (OPT_Wparentheses,
10126                  "suggest parentheses around comparison in operand of %<&%>");
10127       /* Check cases like !x & y */
10128       else if (code_left == TRUTH_NOT_EXPR
10129                && !APPEARS_TO_BE_BOOLEAN_EXPR_P (code_right, arg_right))
10130         warning (OPT_Wparentheses, "suggest parentheses around operand of "
10131                  "%<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>");
10132       return;
10133
10134     case EQ_EXPR:
10135       if (TREE_CODE_CLASS (code_left) == tcc_comparison
10136           || TREE_CODE_CLASS (code_right) == tcc_comparison)
10137         warning (OPT_Wparentheses,
10138                  "suggest parentheses around comparison in operand of %<==%>");
10139       return;
10140     case NE_EXPR:
10141       if (TREE_CODE_CLASS (code_left) == tcc_comparison
10142           || TREE_CODE_CLASS (code_right) == tcc_comparison)
10143         warning (OPT_Wparentheses,
10144                  "suggest parentheses around comparison in operand of %<!=%>");
10145       return;
10146
10147     default:
10148       if (TREE_CODE_CLASS (code) == tcc_comparison
10149            && ((TREE_CODE_CLASS (code_left) == tcc_comparison
10150                 && code_left != NE_EXPR && code_left != EQ_EXPR
10151                 && INTEGRAL_TYPE_P (TREE_TYPE (arg_left)))
10152                || (TREE_CODE_CLASS (code_right) == tcc_comparison
10153                    && code_right != NE_EXPR && code_right != EQ_EXPR
10154                    && INTEGRAL_TYPE_P (TREE_TYPE (arg_right)))))
10155         warning (OPT_Wparentheses, "comparisons like %<X<=Y<=Z%> do not "
10156                  "have their mathematical meaning");
10157       return;
10158     }
10159 #undef NOT_A_BOOLEAN_EXPR_P
10160 }
10161
10162 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
10163
10164 void
10165 warn_for_unused_label (tree label)
10166 {
10167   if (!TREE_USED (label))
10168     {
10169       if (DECL_INITIAL (label))
10170         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
10171       else
10172         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
10173     }
10174 }
10175
10176 /* Warn for division by zero according to the value of DIVISOR.  LOC
10177    is the location of the division operator.  */
10178
10179 void
10180 warn_for_div_by_zero (location_t loc, tree divisor)
10181 {
10182   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
10183      about division by zero.  Do not issue a warning if DIVISOR has a
10184      floating-point type, since we consider 0.0/0.0 a valid way of
10185      generating a NaN.  */
10186   if (c_inhibit_evaluation_warnings == 0
10187       && (integer_zerop (divisor) || fixed_zerop (divisor)))
10188     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
10189 }
10190
10191 /* Subroutine of build_binary_op. Give warnings for comparisons
10192    between signed and unsigned quantities that may fail. Do the
10193    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
10194    so that casts will be considered, but default promotions won't
10195    be.
10196
10197    LOCATION is the location of the comparison operator.
10198
10199    The arguments of this function map directly to local variables
10200    of build_binary_op.  */
10201
10202 void
10203 warn_for_sign_compare (location_t location,
10204                        tree orig_op0, tree orig_op1,
10205                        tree op0, tree op1,
10206                        tree result_type, enum tree_code resultcode)
10207 {
10208   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
10209   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
10210   int unsignedp0, unsignedp1;
10211
10212   /* In C++, check for comparison of different enum types.  */
10213   if (c_dialect_cxx()
10214       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
10215       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
10216       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
10217          != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
10218     {
10219       warning_at (location,
10220                   OPT_Wsign_compare, "comparison between types %qT and %qT",
10221                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
10222     }
10223
10224   /* Do not warn if the comparison is being done in a signed type,
10225      since the signed type will only be chosen if it can represent
10226      all the values of the unsigned type.  */
10227   if (!TYPE_UNSIGNED (result_type))
10228     /* OK */;
10229   /* Do not warn if both operands are unsigned.  */
10230   else if (op0_signed == op1_signed)
10231     /* OK */;
10232   else
10233     {
10234       tree sop, uop, base_type;
10235       bool ovf;
10236
10237       if (op0_signed)
10238         sop = orig_op0, uop = orig_op1;
10239       else
10240         sop = orig_op1, uop = orig_op0;
10241
10242       STRIP_TYPE_NOPS (sop);
10243       STRIP_TYPE_NOPS (uop);
10244       base_type = (TREE_CODE (result_type) == COMPLEX_TYPE
10245                    ? TREE_TYPE (result_type) : result_type);
10246
10247       /* Do not warn if the signed quantity is an unsuffixed integer
10248          literal (or some static constant expression involving such
10249          literals or a conditional expression involving such literals)
10250          and it is non-negative.  */
10251       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
10252         /* OK */;
10253       /* Do not warn if the comparison is an equality operation, the
10254          unsigned quantity is an integral constant, and it would fit
10255          in the result if the result were signed.  */
10256       else if (TREE_CODE (uop) == INTEGER_CST
10257                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
10258                && int_fits_type_p (uop, c_common_signed_type (base_type)))
10259         /* OK */;
10260       /* In C, do not warn if the unsigned quantity is an enumeration
10261          constant and its maximum value would fit in the result if the
10262          result were signed.  */
10263       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
10264                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
10265                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
10266                                    c_common_signed_type (base_type)))
10267         /* OK */;
10268       else
10269         warning_at (location,
10270                     OPT_Wsign_compare,
10271                     "comparison between signed and unsigned integer expressions");
10272     }
10273
10274   /* Warn if two unsigned values are being compared in a size larger
10275      than their original size, and one (and only one) is the result of
10276      a `~' operator.  This comparison will always fail.
10277
10278      Also warn if one operand is a constant, and the constant does not
10279      have all bits set that are set in the ~ operand when it is
10280      extended.  */
10281
10282   op0 = c_common_get_narrower (op0, &unsignedp0);
10283   op1 = c_common_get_narrower (op1, &unsignedp1);
10284
10285   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
10286       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
10287     {
10288       if (TREE_CODE (op0) == BIT_NOT_EXPR)
10289         op0 = c_common_get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
10290       if (TREE_CODE (op1) == BIT_NOT_EXPR)
10291         op1 = c_common_get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
10292
10293       if (host_integerp (op0, 0) || host_integerp (op1, 0))
10294         {
10295           tree primop;
10296           HOST_WIDE_INT constant, mask;
10297           int unsignedp;
10298           unsigned int bits;
10299
10300           if (host_integerp (op0, 0))
10301             {
10302               primop = op1;
10303               unsignedp = unsignedp1;
10304               constant = tree_low_cst (op0, 0);
10305             }
10306           else
10307             {
10308               primop = op0;
10309               unsignedp = unsignedp0;
10310               constant = tree_low_cst (op1, 0);
10311             }
10312
10313           bits = TYPE_PRECISION (TREE_TYPE (primop));
10314           if (bits < TYPE_PRECISION (result_type)
10315               && bits < HOST_BITS_PER_LONG && unsignedp)
10316             {
10317               mask = (~ (HOST_WIDE_INT) 0) << bits;
10318               if ((mask & constant) != mask)
10319                 {
10320                   if (constant == 0)
10321                     warning (OPT_Wsign_compare,
10322                              "promoted ~unsigned is always non-zero");
10323                   else
10324                     warning_at (location, OPT_Wsign_compare,
10325                                 "comparison of promoted ~unsigned with constant");
10326                 }
10327             }
10328         }
10329       else if (unsignedp0 && unsignedp1
10330                && (TYPE_PRECISION (TREE_TYPE (op0))
10331                    < TYPE_PRECISION (result_type))
10332                && (TYPE_PRECISION (TREE_TYPE (op1))
10333                    < TYPE_PRECISION (result_type)))
10334         warning_at (location, OPT_Wsign_compare,
10335                  "comparison of promoted ~unsigned with unsigned");
10336     }
10337 }
10338
10339 /* RESULT_TYPE is the result of converting TYPE1 and TYPE2 to a common
10340    type via c_common_type.  If -Wdouble-promotion is in use, and the
10341    conditions for warning have been met, issue a warning.  GMSGID is
10342    the warning message.  It must have two %T specifiers for the type
10343    that was converted (generally "float") and the type to which it was
10344    converted (generally "double), respectively.  LOC is the location
10345    to which the awrning should refer.  */
10346
10347 void
10348 do_warn_double_promotion (tree result_type, tree type1, tree type2,
10349                          const char *gmsgid, location_t loc)
10350 {
10351   tree source_type;
10352
10353   if (!warn_double_promotion)
10354     return;
10355   /* If the conversion will not occur at run-time, there is no need to
10356      warn about it.  */
10357   if (c_inhibit_evaluation_warnings)
10358     return;
10359   if (TYPE_MAIN_VARIANT (result_type) != double_type_node
10360       && TYPE_MAIN_VARIANT (result_type) != complex_double_type_node)
10361     return;
10362   if (TYPE_MAIN_VARIANT (type1) == float_type_node
10363       || TYPE_MAIN_VARIANT (type1) == complex_float_type_node)
10364     source_type = type1;
10365   else if (TYPE_MAIN_VARIANT (type2) == float_type_node
10366            || TYPE_MAIN_VARIANT (type2) == complex_float_type_node)
10367     source_type = type2;
10368   else
10369     return;
10370   warning_at (loc, OPT_Wdouble_promotion, gmsgid, source_type, result_type);
10371 }
10372
10373 /* Setup a TYPE_DECL node as a typedef representation.
10374
10375    X is a TYPE_DECL for a typedef statement.  Create a brand new
10376    ..._TYPE node (which will be just a variant of the existing
10377    ..._TYPE node with identical properties) and then install X
10378    as the TYPE_NAME of this brand new (duplicate) ..._TYPE node.
10379
10380    The whole point here is to end up with a situation where each
10381    and every ..._TYPE node the compiler creates will be uniquely
10382    associated with AT MOST one node representing a typedef name.
10383    This way, even though the compiler substitutes corresponding
10384    ..._TYPE nodes for TYPE_DECL (i.e. "typedef name") nodes very
10385    early on, later parts of the compiler can always do the reverse
10386    translation and get back the corresponding typedef name.  For
10387    example, given:
10388
10389         typedef struct S MY_TYPE;
10390         MY_TYPE object;
10391
10392    Later parts of the compiler might only know that `object' was of
10393    type `struct S' if it were not for code just below.  With this
10394    code however, later parts of the compiler see something like:
10395
10396         struct S' == struct S
10397         typedef struct S' MY_TYPE;
10398         struct S' object;
10399
10400     And they can then deduce (from the node for type struct S') that
10401     the original object declaration was:
10402
10403                 MY_TYPE object;
10404
10405     Being able to do this is important for proper support of protoize,
10406     and also for generating precise symbolic debugging information
10407     which takes full account of the programmer's (typedef) vocabulary.
10408
10409     Obviously, we don't want to generate a duplicate ..._TYPE node if
10410     the TYPE_DECL node that we are now processing really represents a
10411     standard built-in type.  */
10412
10413 void
10414 set_underlying_type (tree x)
10415 {
10416   if (x == error_mark_node)
10417     return;
10418   if (DECL_IS_BUILTIN (x))
10419     {
10420       if (TYPE_NAME (TREE_TYPE (x)) == 0)
10421         TYPE_NAME (TREE_TYPE (x)) = x;
10422     }
10423   else if (TREE_TYPE (x) != error_mark_node
10424            && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
10425     {
10426       tree tt = TREE_TYPE (x);
10427       DECL_ORIGINAL_TYPE (x) = tt;
10428       tt = build_variant_type_copy (tt);
10429       TYPE_STUB_DECL (tt) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
10430       TYPE_NAME (tt) = x;
10431       TREE_USED (tt) = TREE_USED (x);
10432       TREE_TYPE (x) = tt;
10433     }
10434 }
10435
10436 /* Record the types used by the current global variable declaration
10437    being parsed, so that we can decide later to emit their debug info.
10438    Those types are in types_used_by_cur_var_decl, and we are going to
10439    store them in the types_used_by_vars_hash hash table.
10440    DECL is the declaration of the global variable that has been parsed.  */
10441
10442 void
10443 record_types_used_by_current_var_decl (tree decl)
10444 {
10445   gcc_assert (decl && DECL_P (decl) && TREE_STATIC (decl));
10446
10447   while (!VEC_empty (tree, types_used_by_cur_var_decl))
10448     {
10449       tree type = VEC_pop (tree, types_used_by_cur_var_decl);
10450       types_used_by_var_decl_insert (type, decl);
10451     }
10452 }
10453
10454 /* If DECL is a typedef that is declared in the current function,
10455    record it for the purpose of -Wunused-local-typedefs.  */
10456
10457 void
10458 record_locally_defined_typedef (tree decl)
10459 {
10460   struct c_language_function *l;
10461
10462   if (!warn_unused_local_typedefs
10463       || cfun == NULL
10464       /* if this is not a locally defined typedef then we are not
10465          interested.  */
10466       || !is_typedef_decl (decl)
10467       || !decl_function_context (decl))
10468     return;
10469
10470   l = (struct c_language_function *) cfun->language;
10471   VEC_safe_push (tree, gc, l->local_typedefs, decl);
10472 }
10473
10474 /* If T is a TYPE_DECL declared locally, mark it as used.  */
10475
10476 void
10477 maybe_record_typedef_use (tree t)
10478 {
10479   if (!is_typedef_decl (t))
10480     return;
10481
10482   TREE_USED (t) = true;
10483 }
10484
10485 /* Warn if there are some unused locally defined typedefs in the
10486    current function. */
10487
10488 void
10489 maybe_warn_unused_local_typedefs (void)
10490 {
10491   int i;
10492   tree decl;
10493   /* The number of times we have emitted -Wunused-local-typedefs
10494      warnings.  If this is different from errorcount, that means some
10495      unrelated errors have been issued.  In which case, we'll avoid
10496      emitting "unused-local-typedefs" warnings.  */
10497   static int unused_local_typedefs_warn_count;
10498   struct c_language_function *l;
10499
10500   if (cfun == NULL)
10501     return;
10502
10503   if ((l = (struct c_language_function *) cfun->language) == NULL)
10504     return;
10505
10506   if (warn_unused_local_typedefs
10507       && errorcount == unused_local_typedefs_warn_count)
10508     {
10509       FOR_EACH_VEC_ELT (tree, l->local_typedefs, i, decl)
10510         if (!TREE_USED (decl))
10511           warning_at (DECL_SOURCE_LOCATION (decl),
10512                       OPT_Wunused_local_typedefs,
10513                       "typedef %qD locally defined but not used", decl);
10514       unused_local_typedefs_warn_count = errorcount;
10515     }
10516
10517   if (l->local_typedefs)
10518     {
10519       VEC_free (tree, gc, l->local_typedefs);
10520       l->local_typedefs = NULL;
10521     }
10522 }
10523
10524 /* The C and C++ parsers both use vectors to hold function arguments.
10525    For efficiency, we keep a cache of unused vectors.  This is the
10526    cache.  */
10527
10528 typedef VEC(tree,gc)* tree_gc_vec;
10529 DEF_VEC_P(tree_gc_vec);
10530 DEF_VEC_ALLOC_P(tree_gc_vec,gc);
10531 static GTY((deletable)) VEC(tree_gc_vec,gc) *tree_vector_cache;
10532
10533 /* Return a new vector from the cache.  If the cache is empty,
10534    allocate a new vector.  These vectors are GC'ed, so it is OK if the
10535    pointer is not released..  */
10536
10537 VEC(tree,gc) *
10538 make_tree_vector (void)
10539 {
10540   if (!VEC_empty (tree_gc_vec, tree_vector_cache))
10541     return VEC_pop (tree_gc_vec, tree_vector_cache);
10542   else
10543     {
10544       /* Passing 0 to VEC_alloc returns NULL, and our callers require
10545          that we always return a non-NULL value.  The vector code uses
10546          4 when growing a NULL vector, so we do too.  */
10547       return VEC_alloc (tree, gc, 4);
10548     }
10549 }
10550
10551 /* Release a vector of trees back to the cache.  */
10552
10553 void
10554 release_tree_vector (VEC(tree,gc) *vec)
10555 {
10556   if (vec != NULL)
10557     {
10558       VEC_truncate (tree, vec, 0);
10559       VEC_safe_push (tree_gc_vec, gc, tree_vector_cache, vec);
10560     }
10561 }
10562
10563 /* Get a new tree vector holding a single tree.  */
10564
10565 VEC(tree,gc) *
10566 make_tree_vector_single (tree t)
10567 {
10568   VEC(tree,gc) *ret = make_tree_vector ();
10569   VEC_quick_push (tree, ret, t);
10570   return ret;
10571 }
10572
10573 /* Get a new tree vector of the TREE_VALUEs of a TREE_LIST chain.  */
10574
10575 VEC(tree,gc) *
10576 make_tree_vector_from_list (tree list)
10577 {
10578   VEC(tree,gc) *ret = make_tree_vector ();
10579   for (; list; list = TREE_CHAIN (list))
10580     VEC_safe_push (tree, gc, ret, TREE_VALUE (list));
10581   return ret;
10582 }
10583
10584 /* Get a new tree vector which is a copy of an existing one.  */
10585
10586 VEC(tree,gc) *
10587 make_tree_vector_copy (const VEC(tree,gc) *orig)
10588 {
10589   VEC(tree,gc) *ret;
10590   unsigned int ix;
10591   tree t;
10592
10593   ret = make_tree_vector ();
10594   VEC_reserve (tree, gc, ret, VEC_length (tree, orig));
10595   FOR_EACH_VEC_ELT (tree, orig, ix, t)
10596     VEC_quick_push (tree, ret, t);
10597   return ret;
10598 }
10599
10600 /* Return true if KEYWORD starts a type specifier.  */
10601
10602 bool
10603 keyword_begins_type_specifier (enum rid keyword)
10604 {
10605   switch (keyword)
10606     {
10607     case RID_INT:
10608     case RID_CHAR:
10609     case RID_FLOAT:
10610     case RID_DOUBLE:
10611     case RID_VOID:
10612     case RID_INT128:
10613     case RID_UNSIGNED:
10614     case RID_LONG:
10615     case RID_SHORT:
10616     case RID_SIGNED:
10617     case RID_DFLOAT32:
10618     case RID_DFLOAT64:
10619     case RID_DFLOAT128:
10620     case RID_FRACT:
10621     case RID_ACCUM:
10622     case RID_BOOL:
10623     case RID_WCHAR:
10624     case RID_CHAR16:
10625     case RID_CHAR32:
10626     case RID_SAT:
10627     case RID_COMPLEX:
10628     case RID_TYPEOF:
10629     case RID_STRUCT:
10630     case RID_CLASS:
10631     case RID_UNION:
10632     case RID_ENUM:
10633       return true;
10634     default:
10635       return false;
10636     }
10637 }
10638
10639 /* Return true if KEYWORD names a type qualifier.  */
10640
10641 bool
10642 keyword_is_type_qualifier (enum rid keyword)
10643 {
10644   switch (keyword)
10645     {
10646     case RID_CONST:
10647     case RID_VOLATILE:
10648     case RID_RESTRICT:
10649       return true;
10650     default:
10651       return false;
10652     }
10653 }
10654
10655 /* Return true if KEYWORD names a storage class specifier.
10656
10657    RID_TYPEDEF is not included in this list despite `typedef' being
10658    listed in C99 6.7.1.1.  6.7.1.3 indicates that `typedef' is listed as
10659    such for syntactic convenience only.  */
10660
10661 bool
10662 keyword_is_storage_class_specifier (enum rid keyword)
10663 {
10664   switch (keyword)
10665     {
10666     case RID_STATIC:
10667     case RID_EXTERN:
10668     case RID_REGISTER:
10669     case RID_AUTO:
10670     case RID_MUTABLE:
10671     case RID_THREAD:
10672       return true;
10673     default:
10674       return false;
10675     }
10676 }
10677
10678 /* Return true if KEYWORD names a function-specifier [dcl.fct.spec].  */
10679
10680 static bool
10681 keyword_is_function_specifier (enum rid keyword)
10682 {
10683   switch (keyword)
10684     {
10685     case RID_INLINE:
10686     case RID_NORETURN:
10687     case RID_VIRTUAL:
10688     case RID_EXPLICIT:
10689       return true;
10690     default:
10691       return false;
10692     }
10693 }
10694
10695 /* Return true if KEYWORD names a decl-specifier [dcl.spec] or a
10696    declaration-specifier (C99 6.7).  */
10697
10698 bool
10699 keyword_is_decl_specifier (enum rid keyword)
10700 {
10701   if (keyword_is_storage_class_specifier (keyword)
10702       || keyword_is_type_qualifier (keyword)
10703       || keyword_is_function_specifier (keyword))
10704     return true;
10705
10706   switch (keyword)
10707     {
10708     case RID_TYPEDEF:
10709     case RID_FRIEND:
10710     case RID_CONSTEXPR:
10711       return true;
10712     default:
10713       return false;
10714     }
10715 }
10716
10717 /* Initialize language-specific-bits of tree_contains_struct.  */
10718
10719 void
10720 c_common_init_ts (void)
10721 {
10722   MARK_TS_TYPED (C_MAYBE_CONST_EXPR);
10723   MARK_TS_TYPED (EXCESS_PRECISION_EXPR);
10724 }
10725
10726 /* Build a user-defined numeric literal out of an integer constant type VALUE
10727    with identifier SUFFIX.  */
10728
10729 tree
10730 build_userdef_literal (tree suffix_id, tree value, tree num_string)
10731 {
10732   tree literal = make_node (USERDEF_LITERAL);
10733   USERDEF_LITERAL_SUFFIX_ID (literal) = suffix_id;
10734   USERDEF_LITERAL_VALUE (literal) = value;
10735   USERDEF_LITERAL_NUM_STRING (literal) = num_string;
10736   return literal;
10737 }
10738
10739 #include "gt-c-family-c-common.h"