gcc/c-family/c-common.c

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