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