gcc/c-common.c

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