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