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