gcc/c-common.c

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