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