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