gcc/c-family/c-common.c

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