gcc/c-family/c-common.c

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