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