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