gcc/c-common.c

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