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 (location, 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
3518                (location,
3519                 build_unary_op (location, REALPART_EXPR, t, 0)),
3520         c_common_truthvalue_conversion
3521                (location,
3522                 build_unary_op (location, IMAGPART_EXPR, t, 0)),
3523                0));
3524     }
3525
3526   if (TREE_CODE (TREE_TYPE (expr)) == FIXED_POINT_TYPE)
3527     {
3528       tree fixed_zero_node = build_fixed (TREE_TYPE (expr),
3529                                           FCONST0 (TYPE_MODE
3530                                                    (TREE_TYPE (expr))));
3531       return build_binary_op (EXPR_LOCATION (expr),
3532                               NE_EXPR, expr, fixed_zero_node, 1);
3533     }
3534
3535   return build_binary_op (EXPR_LOCATION (expr),
3536                           NE_EXPR, expr, integer_zero_node, 1);
3537 }
3538 \f
3539 static void def_builtin_1  (enum built_in_function fncode,
3540                             const char *name,
3541                             enum built_in_class fnclass,
3542                             tree fntype, tree libtype,
3543                             bool both_p, bool fallback_p, bool nonansi_p,
3544                             tree fnattrs, bool implicit_p);
3545
3546
3547 /* Apply the TYPE_QUALS to the new DECL.  */
3548
3549 void
3550 c_apply_type_quals_to_decl (int type_quals, tree decl)
3551 {
3552   tree type = TREE_TYPE (decl);
3553
3554   if (type == error_mark_node)
3555     return;
3556
3557   if (((type_quals & TYPE_QUAL_CONST)
3558        || (type && TREE_CODE (type) == REFERENCE_TYPE))
3559       /* An object declared 'const' is only readonly after it is
3560          initialized.  We don't have any way of expressing this currently,
3561          so we need to be conservative and unset TREE_READONLY for types
3562          with constructors.  Otherwise aliasing code will ignore stores in
3563          an inline constructor.  */
3564       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
3565     TREE_READONLY (decl) = 1;
3566   if (type_quals & TYPE_QUAL_VOLATILE)
3567     {
3568       TREE_SIDE_EFFECTS (decl) = 1;
3569       TREE_THIS_VOLATILE (decl) = 1;
3570     }
3571   if (type_quals & TYPE_QUAL_RESTRICT)
3572     {
3573       while (type && TREE_CODE (type) == ARRAY_TYPE)
3574         /* Allow 'restrict' on arrays of pointers.
3575            FIXME currently we just ignore it.  */
3576         type = TREE_TYPE (type);
3577       if (!type
3578           || !POINTER_TYPE_P (type)
3579           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
3580         error ("invalid use of %<restrict%>");
3581       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
3582         /* Indicate we need to make a unique alias set for this pointer.
3583            We can't do it here because it might be pointing to an
3584            incomplete type.  */
3585         DECL_POINTER_ALIAS_SET (decl) = -2;
3586     }
3587 }
3588
3589 /* Hash function for the problem of multiple type definitions in
3590    different files.  This must hash all types that will compare
3591    equal via comptypes to the same value.  In practice it hashes
3592    on some of the simple stuff and leaves the details to comptypes.  */
3593
3594 static hashval_t
3595 c_type_hash (const void *p)
3596 {
3597   int i = 0;
3598   int shift, size;
3599   const_tree const t = (const_tree) p;
3600   tree t2;
3601   switch (TREE_CODE (t))
3602     {
3603     /* For pointers, hash on pointee type plus some swizzling.  */
3604     case POINTER_TYPE:
3605       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
3606     /* Hash on number of elements and total size.  */
3607     case ENUMERAL_TYPE:
3608       shift = 3;
3609       t2 = TYPE_VALUES (t);
3610       break;
3611     case RECORD_TYPE:
3612       shift = 0;
3613       t2 = TYPE_FIELDS (t);
3614       break;
3615     case QUAL_UNION_TYPE:
3616       shift = 1;
3617       t2 = TYPE_FIELDS (t);
3618       break;
3619     case UNION_TYPE:
3620       shift = 2;
3621       t2 = TYPE_FIELDS (t);
3622       break;
3623     default:
3624       gcc_unreachable ();
3625     }
3626   for (; t2; t2 = TREE_CHAIN (t2))
3627     i++;
3628   /* We might have a VLA here.  */
3629   if (TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
3630     size = 0;
3631   else
3632     size = TREE_INT_CST_LOW (TYPE_SIZE (t));
3633   return ((size << 24) | (i << shift));
3634 }
3635
3636 static GTY((param_is (union tree_node))) htab_t type_hash_table;
3637
3638 /* Return the typed-based alias set for T, which may be an expression
3639    or a type.  Return -1 if we don't do anything special.  */
3640
3641 alias_set_type
3642 c_common_get_alias_set (tree t)
3643 {
3644   tree u;
3645   PTR *slot;
3646
3647   /* Permit type-punning when accessing a union, provided the access
3648      is directly through the union.  For example, this code does not
3649      permit taking the address of a union member and then storing
3650      through it.  Even the type-punning allowed here is a GCC
3651      extension, albeit a common and useful one; the C standard says
3652      that such accesses have implementation-defined behavior.  */
3653   for (u = t;
3654        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3655        u = TREE_OPERAND (u, 0))
3656     if (TREE_CODE (u) == COMPONENT_REF
3657         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3658       return 0;
3659
3660   /* That's all the expressions we handle specially.  */
3661   if (!TYPE_P (t))
3662     return -1;
3663
3664   /* The C standard guarantees that any object may be accessed via an
3665      lvalue that has character type.  */
3666   if (t == char_type_node
3667       || t == signed_char_type_node
3668       || t == unsigned_char_type_node)
3669     return 0;
3670
3671   /* The C standard specifically allows aliasing between signed and
3672      unsigned variants of the same type.  We treat the signed
3673      variant as canonical.  */
3674   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
3675     {
3676       tree t1 = c_common_signed_type (t);
3677
3678       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3679       if (t1 != t)
3680         return get_alias_set (t1);
3681     }
3682   else if (POINTER_TYPE_P (t))
3683     {
3684       tree t1;
3685
3686       /* Unfortunately, there is no canonical form of a pointer type.
3687          In particular, if we have `typedef int I', then `int *', and
3688          `I *' are different types.  So, we have to pick a canonical
3689          representative.  We do this below.
3690
3691          Technically, this approach is actually more conservative that
3692          it needs to be.  In particular, `const int *' and `int *'
3693          should be in different alias sets, according to the C and C++
3694          standard, since their types are not the same, and so,
3695          technically, an `int **' and `const int **' cannot point at
3696          the same thing.
3697
3698          But, the standard is wrong.  In particular, this code is
3699          legal C++:
3700
3701             int *ip;
3702             int **ipp = &ip;
3703             const int* const* cipp = ipp;
3704
3705          And, it doesn't make sense for that to be legal unless you
3706          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3707          the pointed-to types.  This issue has been reported to the
3708          C++ committee.  */
3709       t1 = build_type_no_quals (t);
3710       if (t1 != t)
3711         return get_alias_set (t1);
3712     }
3713
3714   /* Handle the case of multiple type nodes referring to "the same" type,
3715      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
3716      C90 is handled.  (In C99 type compatibility is not transitive, which
3717      complicates things mightily. The alias set splay trees can theoretically
3718      represent this, but insertion is tricky when you consider all the
3719      different orders things might arrive in.) */
3720
3721   if (c_language != clk_c || flag_isoc99)
3722     return -1;
3723
3724   /* Save time if there's only one input file.  */
3725   if (num_in_fnames == 1)
3726     return -1;
3727
3728   /* Pointers need special handling if they point to any type that
3729      needs special handling (below).  */
3730   if (TREE_CODE (t) == POINTER_TYPE)
3731     {
3732       tree t2;
3733       /* Find bottom type under any nested POINTERs.  */
3734       for (t2 = TREE_TYPE (t);
3735            TREE_CODE (t2) == POINTER_TYPE;
3736            t2 = TREE_TYPE (t2))
3737         ;
3738       if (TREE_CODE (t2) != RECORD_TYPE
3739           && TREE_CODE (t2) != ENUMERAL_TYPE
3740           && TREE_CODE (t2) != QUAL_UNION_TYPE
3741           && TREE_CODE (t2) != UNION_TYPE)
3742         return -1;
3743       if (TYPE_SIZE (t2) == 0)
3744         return -1;
3745     }
3746   /* These are the only cases that need special handling.  */
3747   if (TREE_CODE (t) != RECORD_TYPE
3748       && TREE_CODE (t) != ENUMERAL_TYPE
3749       && TREE_CODE (t) != QUAL_UNION_TYPE
3750       && TREE_CODE (t) != UNION_TYPE
3751       && TREE_CODE (t) != POINTER_TYPE)
3752     return -1;
3753   /* Undefined? */
3754   if (TYPE_SIZE (t) == 0)
3755     return -1;
3756
3757   /* Look up t in hash table.  Only one of the compatible types within each
3758      alias set is recorded in the table.  */
3759   if (!type_hash_table)
3760     type_hash_table = htab_create_ggc (1021, c_type_hash,
3761             (htab_eq) lang_hooks.types_compatible_p,
3762             NULL);
3763   slot = htab_find_slot (type_hash_table, t, INSERT);
3764   if (*slot != NULL)
3765     {
3766       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
3767       return TYPE_ALIAS_SET ((tree)*slot);
3768     }
3769   else
3770     /* Our caller will assign and record (in t) a new alias set; all we need
3771        to do is remember t in the hash table.  */
3772     *slot = t;
3773
3774   return -1;
3775 }
3776 \f
3777 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
3778    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
3779    flag controls whether we should diagnose possibly ill-formed
3780    constructs or not.  */
3781
3782 tree
3783 c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
3784 {
3785   const char *op_name;
3786   tree value = NULL;
3787   enum tree_code type_code = TREE_CODE (type);
3788
3789   op_name = is_sizeof ? "sizeof" : "__alignof__";
3790
3791   if (type_code == FUNCTION_TYPE)
3792     {
3793       if (is_sizeof)
3794         {
3795           if (complain && (pedantic || warn_pointer_arith))
3796             pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3797                      "invalid application of %<sizeof%> to a function type");
3798           else if (!complain)
3799             return error_mark_node;
3800           value = size_one_node;
3801         }
3802       else
3803         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3804     }
3805   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
3806     {
3807       if (type_code == VOID_TYPE
3808           && complain && (pedantic || warn_pointer_arith))
3809         pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3810                  "invalid application of %qs to a void type", op_name);
3811       else if (!complain)
3812         return error_mark_node;
3813       value = size_one_node;
3814     }
3815   else if (!COMPLETE_TYPE_P (type))
3816     {
3817       if (complain)
3818         error ("invalid application of %qs to incomplete type %qT ",
3819                op_name, type);
3820       value = size_zero_node;
3821     }
3822   else
3823     {
3824       if (is_sizeof)
3825         /* Convert in case a char is more than one unit.  */
3826         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
3827                             size_int (TYPE_PRECISION (char_type_node)
3828                                       / BITS_PER_UNIT));
3829       else
3830         value = size_int (TYPE_ALIGN_UNIT (type));
3831     }
3832
3833   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
3834      TYPE_IS_SIZETYPE means that certain things (like overflow) will
3835      never happen.  However, this node should really have type
3836      `size_t', which is just a typedef for an ordinary integer type.  */
3837   value = fold_convert (size_type_node, value);
3838   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
3839
3840   return value;
3841 }
3842
3843 /* Implement the __alignof keyword: Return the minimum required
3844    alignment of EXPR, measured in bytes.  For VAR_DECLs,
3845    FUNCTION_DECLs and FIELD_DECLs return DECL_ALIGN (which can be set
3846    from an "aligned" __attribute__ specification).  */
3847
3848 tree
3849 c_alignof_expr (tree expr)
3850 {
3851   tree t;
3852
3853   if (VAR_OR_FUNCTION_DECL_P (expr))
3854     t = size_int (DECL_ALIGN_UNIT (expr));
3855
3856   else if (TREE_CODE (expr) == COMPONENT_REF
3857            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3858     {
3859       error ("%<__alignof%> applied to a bit-field");
3860       t = size_one_node;
3861     }
3862   else if (TREE_CODE (expr) == COMPONENT_REF
3863            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3864     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3865
3866   else if (TREE_CODE (expr) == INDIRECT_REF)
3867     {
3868       tree t = TREE_OPERAND (expr, 0);
3869       tree best = t;
3870       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3871
3872       while (CONVERT_EXPR_P (t)
3873              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3874         {
3875           int thisalign;
3876
3877           t = TREE_OPERAND (t, 0);
3878           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3879           if (thisalign > bestalign)
3880             best = t, bestalign = thisalign;
3881         }
3882       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3883     }
3884   else
3885     return c_alignof (TREE_TYPE (expr));
3886
3887   return fold_convert (size_type_node, t);
3888 }
3889 \f
3890 /* Handle C and C++ default attributes.  */
3891
3892 enum built_in_attribute
3893 {
3894 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3895 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3896 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3897 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3898 #include "builtin-attrs.def"
3899 #undef DEF_ATTR_NULL_TREE
3900 #undef DEF_ATTR_INT
3901 #undef DEF_ATTR_IDENT
3902 #undef DEF_ATTR_TREE_LIST
3903   ATTR_LAST
3904 };
3905
3906 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3907
3908 static void c_init_attributes (void);
3909
3910 enum c_builtin_type
3911 {
3912 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3913 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3914 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3915 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3916 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3917 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3918 #define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3919 #define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3920 #define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3921 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3922 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3923 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3924 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3925 #define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3926 #define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3927   NAME,
3928 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3929 #include "builtin-types.def"
3930 #undef DEF_PRIMITIVE_TYPE
3931 #undef DEF_FUNCTION_TYPE_0
3932 #undef DEF_FUNCTION_TYPE_1
3933 #undef DEF_FUNCTION_TYPE_2
3934 #undef DEF_FUNCTION_TYPE_3
3935 #undef DEF_FUNCTION_TYPE_4
3936 #undef DEF_FUNCTION_TYPE_5
3937 #undef DEF_FUNCTION_TYPE_6
3938 #undef DEF_FUNCTION_TYPE_7
3939 #undef DEF_FUNCTION_TYPE_VAR_0
3940 #undef DEF_FUNCTION_TYPE_VAR_1
3941 #undef DEF_FUNCTION_TYPE_VAR_2
3942 #undef DEF_FUNCTION_TYPE_VAR_3
3943 #undef DEF_FUNCTION_TYPE_VAR_4
3944 #undef DEF_FUNCTION_TYPE_VAR_5
3945 #undef DEF_POINTER_TYPE
3946   BT_LAST
3947 };
3948
3949 typedef enum c_builtin_type builtin_type;
3950
3951 /* A temporary array for c_common_nodes_and_builtins.  Used in
3952    communication with def_fn_type.  */
3953 static tree builtin_types[(int) BT_LAST + 1];
3954
3955 /* A helper function for c_common_nodes_and_builtins.  Build function type
3956    for DEF with return type RET and N arguments.  If VAR is true, then the
3957    function should be variadic after those N arguments.
3958
3959    Takes special care not to ICE if any of the types involved are
3960    error_mark_node, which indicates that said type is not in fact available
3961    (see builtin_type_for_size).  In which case the function type as a whole
3962    should be error_mark_node.  */
3963
3964 static void
3965 def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3966 {
3967   tree args = NULL, t;
3968   va_list list;
3969   int i;
3970
3971   va_start (list, n);
3972   for (i = 0; i < n; ++i)
3973     {
3974       builtin_type a = (builtin_type) va_arg (list, int);
3975       t = builtin_types[a];
3976       if (t == error_mark_node)
3977         goto egress;
3978       args = tree_cons (NULL_TREE, t, args);
3979     }
3980   va_end (list);
3981
3982   args = nreverse (args);
3983   if (!var)
3984     args = chainon (args, void_list_node);
3985
3986   t = builtin_types[ret];
3987   if (t == error_mark_node)
3988     goto egress;
3989   t = build_function_type (t, args);
3990
3991  egress:
3992   builtin_types[def] = t;
3993 }
3994
3995 /* Build builtin functions common to both C and C++ language
3996    frontends.  */
3997
3998 static void
3999 c_define_builtins (tree va_list_ref_type_node, tree va_list_arg_type_node)
4000 {
4001 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
4002   builtin_types[ENUM] = VALUE;
4003 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
4004   def_fn_type (ENUM, RETURN, 0, 0);
4005 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
4006   def_fn_type (ENUM, RETURN, 0, 1, ARG1);
4007 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
4008   def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
4009 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4010   def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
4011 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4012   def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
4013 #define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4014   def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4015 #define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4016                             ARG6)                                       \
4017   def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
4018 #define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
4019                             ARG6, ARG7)                                 \
4020   def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
4021 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
4022   def_fn_type (ENUM, RETURN, 1, 0);
4023 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
4024   def_fn_type (ENUM, RETURN, 1, 1, ARG1);
4025 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
4026   def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
4027 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
4028   def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
4029 #define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
4030   def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
4031 #define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
4032   def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
4033 #define DEF_POINTER_TYPE(ENUM, TYPE) \
4034   builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
4035
4036 #include "builtin-types.def"
4037
4038 #undef DEF_PRIMITIVE_TYPE
4039 #undef DEF_FUNCTION_TYPE_1
4040 #undef DEF_FUNCTION_TYPE_2
4041 #undef DEF_FUNCTION_TYPE_3
4042 #undef DEF_FUNCTION_TYPE_4
4043 #undef DEF_FUNCTION_TYPE_5
4044 #undef DEF_FUNCTION_TYPE_6
4045 #undef DEF_FUNCTION_TYPE_VAR_0
4046 #undef DEF_FUNCTION_TYPE_VAR_1
4047 #undef DEF_FUNCTION_TYPE_VAR_2
4048 #undef DEF_FUNCTION_TYPE_VAR_3
4049 #undef DEF_FUNCTION_TYPE_VAR_4
4050 #undef DEF_FUNCTION_TYPE_VAR_5
4051 #undef DEF_POINTER_TYPE
4052   builtin_types[(int) BT_LAST] = NULL_TREE;
4053
4054   c_init_attributes ();
4055
4056 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
4057                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
4058   if (NAME && COND)                                                     \
4059     def_builtin_1 (ENUM, NAME, CLASS,                                   \
4060                    builtin_types[(int) TYPE],                           \
4061                    builtin_types[(int) LIBTYPE],                        \
4062                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
4063                    built_in_attributes[(int) ATTRS], IMPLICIT);
4064 #include "builtins.def"
4065 #undef DEF_BUILTIN
4066
4067   targetm.init_builtins ();
4068
4069   build_common_builtin_nodes ();
4070
4071   if (flag_mudflap)
4072     mudflap_init ();
4073 }
4074
4075 /* Build tree nodes and builtin functions common to both C and C++ language
4076    frontends.  */
4077
4078 void
4079 c_common_nodes_and_builtins (void)
4080 {
4081   int char16_type_size;
4082   int char32_type_size;
4083   int wchar_type_size;
4084   tree array_domain_type;
4085   tree va_list_ref_type_node;
4086   tree va_list_arg_type_node;
4087
4088   /* Define `int' and `char' first so that dbx will output them first.  */
4089   record_builtin_type (RID_INT, NULL, integer_type_node);
4090   record_builtin_type (RID_CHAR, "char", char_type_node);
4091
4092   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
4093      "unsigned long", "long long unsigned" and "unsigned short" were in C++
4094      but not C.  Are the conditionals here needed?  */
4095   if (c_dialect_cxx ())
4096     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
4097   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
4098   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
4099   record_builtin_type (RID_MAX, "long unsigned int",
4100                        long_unsigned_type_node);
4101   if (c_dialect_cxx ())
4102     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
4103   record_builtin_type (RID_MAX, "long long int",
4104                        long_long_integer_type_node);
4105   record_builtin_type (RID_MAX, "long long unsigned int",
4106                        long_long_unsigned_type_node);
4107   if (c_dialect_cxx ())
4108     record_builtin_type (RID_MAX, "long long unsigned",
4109                          long_long_unsigned_type_node);
4110   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
4111   record_builtin_type (RID_MAX, "short unsigned int",
4112                        short_unsigned_type_node);
4113   if (c_dialect_cxx ())
4114     record_builtin_type (RID_MAX, "unsigned short",
4115                          short_unsigned_type_node);
4116
4117   /* Define both `signed char' and `unsigned char'.  */
4118   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
4119   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
4120
4121   /* These are types that c_common_type_for_size and
4122      c_common_type_for_mode use.  */
4123   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4124                                          intQI_type_node));
4125   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4126                                          intHI_type_node));
4127   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4128                                          intSI_type_node));
4129   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4130                                          intDI_type_node));
4131 #if HOST_BITS_PER_WIDE_INT >= 64
4132   if (targetm.scalar_mode_supported_p (TImode))
4133     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4134                                            get_identifier ("__int128_t"),
4135                                            intTI_type_node));
4136 #endif
4137   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4138                                          unsigned_intQI_type_node));
4139   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4140                                          unsigned_intHI_type_node));
4141   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4142                                          unsigned_intSI_type_node));
4143   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4144                                          unsigned_intDI_type_node));
4145 #if HOST_BITS_PER_WIDE_INT >= 64
4146   if (targetm.scalar_mode_supported_p (TImode))
4147     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4148                                            get_identifier ("__uint128_t"),
4149                                            unsigned_intTI_type_node));
4150 #endif
4151
4152   /* Create the widest literal types.  */
4153   widest_integer_literal_type_node
4154     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
4155   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4156                                          widest_integer_literal_type_node));
4157
4158   widest_unsigned_literal_type_node
4159     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
4160   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
4161                                          widest_unsigned_literal_type_node));
4162
4163   /* `unsigned long' is the standard type for sizeof.
4164      Note that stddef.h uses `unsigned long',
4165      and this must agree, even if long and int are the same size.  */
4166   size_type_node =
4167     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
4168   signed_size_type_node = c_common_signed_type (size_type_node);
4169   set_sizetype (size_type_node);
4170
4171   pid_type_node =
4172     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
4173
4174   build_common_tree_nodes_2 (flag_short_double);
4175
4176   record_builtin_type (RID_FLOAT, NULL, float_type_node);
4177   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
4178   record_builtin_type (RID_MAX, "long double", long_double_type_node);
4179
4180   /* Only supported decimal floating point extension if the target
4181      actually supports underlying modes. */
4182   if (targetm.scalar_mode_supported_p (SDmode)
4183       && targetm.scalar_mode_supported_p (DDmode)
4184       && targetm.scalar_mode_supported_p (TDmode))
4185     {
4186       record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
4187       record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
4188       record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
4189     }
4190
4191   if (targetm.fixed_point_supported_p ())
4192     {
4193       record_builtin_type (RID_MAX, "short _Fract", short_fract_type_node);
4194       record_builtin_type (RID_FRACT, NULL, fract_type_node);
4195       record_builtin_type (RID_MAX, "long _Fract", long_fract_type_node);
4196       record_builtin_type (RID_MAX, "long long _Fract",
4197                            long_long_fract_type_node);
4198       record_builtin_type (RID_MAX, "unsigned short _Fract",
4199                            unsigned_short_fract_type_node);
4200       record_builtin_type (RID_MAX, "unsigned _Fract",
4201                            unsigned_fract_type_node);
4202       record_builtin_type (RID_MAX, "unsigned long _Fract",
4203                            unsigned_long_fract_type_node);
4204       record_builtin_type (RID_MAX, "unsigned long long _Fract",
4205                            unsigned_long_long_fract_type_node);
4206       record_builtin_type (RID_MAX, "_Sat short _Fract",
4207                            sat_short_fract_type_node);
4208       record_builtin_type (RID_MAX, "_Sat _Fract", sat_fract_type_node);
4209       record_builtin_type (RID_MAX, "_Sat long _Fract",
4210                            sat_long_fract_type_node);
4211       record_builtin_type (RID_MAX, "_Sat long long _Fract",
4212                            sat_long_long_fract_type_node);
4213       record_builtin_type (RID_MAX, "_Sat unsigned short _Fract",
4214                            sat_unsigned_short_fract_type_node);
4215       record_builtin_type (RID_MAX, "_Sat unsigned _Fract",
4216                            sat_unsigned_fract_type_node);
4217       record_builtin_type (RID_MAX, "_Sat unsigned long _Fract",
4218                            sat_unsigned_long_fract_type_node);
4219       record_builtin_type (RID_MAX, "_Sat unsigned long long _Fract",
4220                            sat_unsigned_long_long_fract_type_node);
4221       record_builtin_type (RID_MAX, "short _Accum", short_accum_type_node);
4222       record_builtin_type (RID_ACCUM, NULL, accum_type_node);
4223       record_builtin_type (RID_MAX, "long _Accum", long_accum_type_node);
4224       record_builtin_type (RID_MAX, "long long _Accum",
4225                            long_long_accum_type_node);
4226       record_builtin_type (RID_MAX, "unsigned short _Accum",
4227                            unsigned_short_accum_type_node);
4228       record_builtin_type (RID_MAX, "unsigned _Accum",
4229                            unsigned_accum_type_node);
4230       record_builtin_type (RID_MAX, "unsigned long _Accum",
4231                            unsigned_long_accum_type_node);
4232       record_builtin_type (RID_MAX, "unsigned long long _Accum",
4233                            unsigned_long_long_accum_type_node);
4234       record_builtin_type (RID_MAX, "_Sat short _Accum",
4235                            sat_short_accum_type_node);
4236       record_builtin_type (RID_MAX, "_Sat _Accum", sat_accum_type_node);
4237       record_builtin_type (RID_MAX, "_Sat long _Accum",
4238                            sat_long_accum_type_node);
4239       record_builtin_type (RID_MAX, "_Sat long long _Accum",
4240                           sat_long_long_accum_type_node);
4241       record_builtin_type (RID_MAX, "_Sat unsigned short _Accum",
4242                            sat_unsigned_short_accum_type_node);
4243       record_builtin_type (RID_MAX, "_Sat unsigned _Accum",
4244                            sat_unsigned_accum_type_node);
4245       record_builtin_type (RID_MAX, "_Sat unsigned long _Accum",
4246                            sat_unsigned_long_accum_type_node);
4247       record_builtin_type (RID_MAX, "_Sat unsigned long long _Accum",
4248                            sat_unsigned_long_long_accum_type_node);
4249
4250     }
4251
4252   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4253                                          get_identifier ("complex int"),
4254                                          complex_integer_type_node));
4255   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4256                                          get_identifier ("complex float"),
4257                                          complex_float_type_node));
4258   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
4259                                          get_identifier ("complex double"),
4260                                          complex_double_type_node));
4261   lang_hooks.decls.pushdecl
4262     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
4263                  complex_long_double_type_node));
4264
4265   if (c_dialect_cxx ())
4266     /* For C++, make fileptr_type_node a distinct void * type until
4267        FILE type is defined.  */
4268     fileptr_type_node = build_variant_type_copy (ptr_type_node);
4269
4270   record_builtin_type (RID_VOID, NULL, void_type_node);
4271
4272   /* Set the TYPE_NAME for any variants that were built before
4273      record_builtin_type gave names to the built-in types. */
4274   {
4275     tree void_name = TYPE_NAME (void_type_node);
4276     TYPE_NAME (void_type_node) = NULL_TREE;
4277     TYPE_NAME (build_qualified_type (void_type_node, TYPE_QUAL_CONST))
4278       = void_name;
4279     TYPE_NAME (void_type_node) = void_name;
4280   }
4281
4282   /* This node must not be shared.  */
4283   void_zero_node = make_node (INTEGER_CST);
4284   TREE_TYPE (void_zero_node) = void_type_node;
4285
4286   void_list_node = build_void_list_node ();
4287
4288   /* Make a type to be the domain of a few array types
4289      whose domains don't really matter.
4290      200 is small enough that it always fits in size_t
4291      and large enough that it can hold most function names for the
4292      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
4293   array_domain_type = build_index_type (size_int (200));
4294
4295   /* Make a type for arrays of characters.
4296      With luck nothing will ever really depend on the length of this
4297      array type.  */
4298   char_array_type_node
4299     = build_array_type (char_type_node, array_domain_type);
4300
4301   /* Likewise for arrays of ints.  */
4302   int_array_type_node
4303     = build_array_type (integer_type_node, array_domain_type);
4304
4305   string_type_node = build_pointer_type (char_type_node);
4306   const_string_type_node
4307     = build_pointer_type (build_qualified_type
4308                           (char_type_node, TYPE_QUAL_CONST));
4309
4310   /* This is special for C++ so functions can be overloaded.  */
4311   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
4312   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
4313   wchar_type_size = TYPE_PRECISION (wchar_type_node);
4314   if (c_dialect_cxx ())
4315     {
4316       if (TYPE_UNSIGNED (wchar_type_node))
4317         wchar_type_node = make_unsigned_type (wchar_type_size);
4318       else
4319         wchar_type_node = make_signed_type (wchar_type_size);
4320       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
4321     }
4322   else
4323     {
4324       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
4325       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
4326     }
4327
4328   /* This is for wide string constants.  */
4329   wchar_array_type_node
4330     = build_array_type (wchar_type_node, array_domain_type);
4331
4332   /* Define 'char16_t'.  */
4333   char16_type_node = get_identifier (CHAR16_TYPE);
4334   char16_type_node = TREE_TYPE (identifier_global_value (char16_type_node));
4335   char16_type_size = TYPE_PRECISION (char16_type_node);
4336   if (c_dialect_cxx ())
4337     {
4338       char16_type_node = make_unsigned_type (char16_type_size);
4339
4340       if (cxx_dialect == cxx0x)
4341         record_builtin_type (RID_CHAR16, "char16_t", char16_type_node);
4342     }
4343
4344   /* This is for UTF-16 string constants.  */
4345   char16_array_type_node
4346     = build_array_type (char16_type_node, array_domain_type);
4347
4348   /* Define 'char32_t'.  */
4349   char32_type_node = get_identifier (CHAR32_TYPE);
4350   char32_type_node = TREE_TYPE (identifier_global_value (char32_type_node));
4351   char32_type_size = TYPE_PRECISION (char32_type_node);
4352   if (c_dialect_cxx ())
4353     {
4354       char32_type_node = make_unsigned_type (char32_type_size);
4355
4356       if (cxx_dialect == cxx0x)
4357         record_builtin_type (RID_CHAR32, "char32_t", char32_type_node);
4358     }
4359
4360   /* This is for UTF-32 string constants.  */
4361   char32_array_type_node
4362     = build_array_type (char32_type_node, array_domain_type);
4363
4364   wint_type_node =
4365     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
4366
4367   intmax_type_node =
4368     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
4369   uintmax_type_node =
4370     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
4371
4372   default_function_type = build_function_type (integer_type_node, NULL_TREE);
4373   ptrdiff_type_node
4374     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
4375   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
4376
4377   lang_hooks.decls.pushdecl
4378     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4379                  va_list_type_node));
4380 #ifdef TARGET_ENUM_VA_LIST
4381   {
4382     int l;
4383     const char *pname;
4384     tree ptype;
4385     for (l = 0; TARGET_ENUM_VA_LIST (l, &pname, &ptype); ++l)
4386       {
4387         lang_hooks.decls.pushdecl
4388           (build_decl (TYPE_DECL, get_identifier (pname),
4389                        ptype));
4390
4391       }
4392   }
4393 #endif
4394
4395   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4396     {
4397       va_list_arg_type_node = va_list_ref_type_node =
4398         build_pointer_type (TREE_TYPE (va_list_type_node));
4399     }
4400   else
4401     {
4402       va_list_arg_type_node = va_list_type_node;
4403       va_list_ref_type_node = build_reference_type (va_list_type_node);
4404     }
4405
4406   if (!flag_preprocess_only)
4407     c_define_builtins (va_list_ref_type_node, va_list_arg_type_node);
4408
4409   main_identifier_node = get_identifier ("main");
4410
4411   /* Create the built-in __null node.  It is important that this is
4412      not shared.  */
4413   null_node = make_node (INTEGER_CST);
4414   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
4415
4416   /* Since builtin_types isn't gc'ed, don't export these nodes.  */
4417   memset (builtin_types, 0, sizeof (builtin_types));
4418 }
4419
4420 /* Look up the function in built_in_decls that corresponds to DECL
4421    and set ASMSPEC as its user assembler name.  DECL must be a
4422    function decl that declares a builtin.  */
4423
4424 void
4425 set_builtin_user_assembler_name (tree decl, const char *asmspec)
4426 {
4427   tree builtin;
4428   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
4429               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
4430               && asmspec != 0);
4431
4432   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
4433   set_user_assembler_name (builtin, asmspec);
4434   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
4435     init_block_move_fn (asmspec);
4436   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
4437     init_block_clear_fn (asmspec);
4438 }
4439
4440 /* The number of named compound-literals generated thus far.  */
4441 static GTY(()) int compound_literal_number;
4442
4443 /* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
4444
4445 void
4446 set_compound_literal_name (tree decl)
4447 {
4448   char *name;
4449   ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
4450                            compound_literal_number);
4451   compound_literal_number++;
4452   DECL_NAME (decl) = get_identifier (name);
4453 }
4454
4455 tree
4456 build_va_arg (tree expr, tree type)
4457 {
4458   return build1 (VA_ARG_EXPR, type, expr);
4459 }
4460
4461
4462 /* Linked list of disabled built-in functions.  */
4463
4464 typedef struct disabled_builtin
4465 {
4466   const char *name;
4467   struct disabled_builtin *next;
4468 } disabled_builtin;
4469 static disabled_builtin *disabled_builtins = NULL;
4470
4471 static bool builtin_function_disabled_p (const char *);
4472
4473 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
4474    begins with "__builtin_", give an error.  */
4475
4476 void
4477 disable_builtin_function (const char *name)
4478 {
4479   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
4480     error ("cannot disable built-in function %qs", name);
4481   else
4482     {
4483       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
4484       new_disabled_builtin->name = name;
4485       new_disabled_builtin->next = disabled_builtins;
4486       disabled_builtins = new_disabled_builtin;
4487     }
4488 }
4489
4490
4491 /* Return true if the built-in function NAME has been disabled, false
4492    otherwise.  */
4493
4494 static bool
4495 builtin_function_disabled_p (const char *name)
4496 {
4497   disabled_builtin *p;
4498   for (p = disabled_builtins; p != NULL; p = p->next)
4499     {
4500       if (strcmp (name, p->name) == 0)
4501         return true;
4502     }
4503   return false;
4504 }
4505
4506
4507 /* Worker for DEF_BUILTIN.
4508    Possibly define a builtin function with one or two names.
4509    Does not declare a non-__builtin_ function if flag_no_builtin, or if
4510    nonansi_p and flag_no_nonansi_builtin.  */
4511
4512 static void
4513 def_builtin_1 (enum built_in_function fncode,
4514                const char *name,
4515                enum built_in_class fnclass,
4516                tree fntype, tree libtype,
4517                bool both_p, bool fallback_p, bool nonansi_p,
4518                tree fnattrs, bool implicit_p)
4519 {
4520   tree decl;
4521   const char *libname;
4522
4523   if (fntype == error_mark_node)
4524     return;
4525
4526   gcc_assert ((!both_p && !fallback_p)
4527               || !strncmp (name, "__builtin_",
4528                            strlen ("__builtin_")));
4529
4530   libname = name + strlen ("__builtin_");
4531   decl = add_builtin_function (name, fntype, fncode, fnclass,
4532                                (fallback_p ? libname : NULL),
4533                                fnattrs);
4534   if (both_p
4535       && !flag_no_builtin && !builtin_function_disabled_p (libname)
4536       && !(nonansi_p && flag_no_nonansi_builtin))
4537     add_builtin_function (libname, libtype, fncode, fnclass,
4538                           NULL, fnattrs);
4539
4540   built_in_decls[(int) fncode] = decl;
4541   if (implicit_p)
4542     implicit_built_in_decls[(int) fncode] = decl;
4543 }
4544 \f
4545 /* Nonzero if the type T promotes to int.  This is (nearly) the
4546    integral promotions defined in ISO C99 6.3.1.1/2.  */
4547
4548 bool
4549 c_promoting_integer_type_p (const_tree t)
4550 {
4551   switch (TREE_CODE (t))
4552     {
4553     case INTEGER_TYPE:
4554       return (TYPE_MAIN_VARIANT (t) == char_type_node
4555               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
4556               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
4557               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
4558               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
4559               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
4560
4561     case ENUMERAL_TYPE:
4562       /* ??? Technically all enumerations not larger than an int
4563          promote to an int.  But this is used along code paths
4564          that only want to notice a size change.  */
4565       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
4566
4567     case BOOLEAN_TYPE:
4568       return 1;
4569
4570     default:
4571       return 0;
4572     }
4573 }
4574
4575 /* Return 1 if PARMS specifies a fixed number of parameters
4576    and none of their types is affected by default promotions.  */
4577
4578 int
4579 self_promoting_args_p (const_tree parms)
4580 {
4581   const_tree t;
4582   for (t = parms; t; t = TREE_CHAIN (t))
4583     {
4584       tree type = TREE_VALUE (t);
4585
4586       if (type == error_mark_node)
4587         continue;
4588
4589       if (TREE_CHAIN (t) == 0 && type != void_type_node)
4590         return 0;
4591
4592       if (type == 0)
4593         return 0;
4594
4595       if (TYPE_MAIN_VARIANT (type) == float_type_node)
4596         return 0;
4597
4598       if (c_promoting_integer_type_p (type))
4599         return 0;
4600     }
4601   return 1;
4602 }
4603
4604 /* Recursively remove any '*' or '&' operator from TYPE.  */
4605 tree
4606 strip_pointer_operator (tree t)
4607 {
4608   while (POINTER_TYPE_P (t))
4609     t = TREE_TYPE (t);
4610   return t;
4611 }
4612
4613 /* Recursively remove pointer or array type from TYPE. */
4614 tree
4615 strip_pointer_or_array_types (tree t)
4616 {
4617   while (TREE_CODE (t) == ARRAY_TYPE || POINTER_TYPE_P (t))
4618     t = TREE_TYPE (t);
4619   return t;
4620 }
4621
4622 /* Used to compare case labels.  K1 and K2 are actually tree nodes
4623    representing case labels, or NULL_TREE for a `default' label.
4624    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4625    K2, and 0 if K1 and K2 are equal.  */
4626
4627 int
4628 case_compare (splay_tree_key k1, splay_tree_key k2)
4629 {
4630   /* Consider a NULL key (such as arises with a `default' label) to be
4631      smaller than anything else.  */
4632   if (!k1)
4633     return k2 ? -1 : 0;
4634   else if (!k2)
4635     return k1 ? 1 : 0;
4636
4637   return tree_int_cst_compare ((tree) k1, (tree) k2);
4638 }
4639
4640 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
4641    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4642    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
4643    case label was declared using the usual C/C++ syntax, rather than
4644    the GNU case range extension.  CASES is a tree containing all the
4645    case ranges processed so far; COND is the condition for the
4646    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
4647    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
4648
4649 tree
4650 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
4651                   tree low_value, tree high_value)
4652 {
4653   tree type;
4654   tree label;
4655   tree case_label;
4656   splay_tree_node node;
4657
4658   /* Create the LABEL_DECL itself.  */
4659   label = create_artificial_label ();
4660
4661   /* If there was an error processing the switch condition, bail now
4662      before we get more confused.  */
4663   if (!cond || cond == error_mark_node)
4664     goto error_out;
4665
4666   if ((low_value && TREE_TYPE (low_value)
4667        && POINTER_TYPE_P (TREE_TYPE (low_value)))
4668       || (high_value && TREE_TYPE (high_value)
4669           && POINTER_TYPE_P (TREE_TYPE (high_value))))
4670     {
4671       error ("pointers are not permitted as case values");
4672       goto error_out;
4673     }
4674
4675   /* Case ranges are a GNU extension.  */
4676   if (high_value)
4677     pedwarn (input_location, OPT_pedantic,
4678              "range expressions in switch statements are non-standard");
4679
4680   type = TREE_TYPE (cond);
4681   if (low_value)
4682     {
4683       low_value = check_case_value (low_value);
4684       low_value = convert_and_check (type, low_value);
4685       if (low_value == error_mark_node)
4686         goto error_out;
4687     }
4688   if (high_value)
4689     {
4690       high_value = check_case_value (high_value);
4691       high_value = convert_and_check (type, high_value);
4692       if (high_value == error_mark_node)
4693         goto error_out;
4694     }
4695
4696   if (low_value && high_value)
4697     {
4698       /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4699          really a case range, even though it was written that way.
4700          Remove the HIGH_VALUE to simplify later processing.  */
4701       if (tree_int_cst_equal (low_value, high_value))
4702         high_value = NULL_TREE;
4703       else if (!tree_int_cst_lt (low_value, high_value))
4704         warning (0, "empty range specified");
4705     }
4706
4707   /* See if the case is in range of the type of the original testing
4708      expression.  If both low_value and high_value are out of range,
4709      don't insert the case label and return NULL_TREE.  */
4710   if (low_value
4711       && !check_case_bounds (type, orig_type,
4712                              &low_value, high_value ? &high_value : NULL))
4713     return NULL_TREE;
4714
4715   /* Look up the LOW_VALUE in the table of case labels we already
4716      have.  */
4717   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
4718   /* If there was not an exact match, check for overlapping ranges.
4719      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4720      that's a `default' label and the only overlap is an exact match.  */
4721   if (!node && (low_value || high_value))
4722     {
4723       splay_tree_node low_bound;
4724       splay_tree_node high_bound;
4725
4726       /* Even though there wasn't an exact match, there might be an
4727          overlap between this case range and another case range.
4728          Since we've (inductively) not allowed any overlapping case
4729          ranges, we simply need to find the greatest low case label
4730          that is smaller that LOW_VALUE, and the smallest low case
4731          label that is greater than LOW_VALUE.  If there is an overlap
4732          it will occur in one of these two ranges.  */
4733       low_bound = splay_tree_predecessor (cases,
4734                                           (splay_tree_key) low_value);
4735       high_bound = splay_tree_successor (cases,
4736                                          (splay_tree_key) low_value);
4737
4738       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
4739          the LOW_VALUE, so there is no need to check unless the
4740          LOW_BOUND is in fact itself a case range.  */
4741       if (low_bound
4742           && CASE_HIGH ((tree) low_bound->value)
4743           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
4744                                     low_value) >= 0)
4745         node = low_bound;
4746       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
4747          range is bigger than the low end of the current range, so we
4748          are only interested if the current range is a real range, and
4749          not an ordinary case label.  */
4750       else if (high_bound
4751                && high_value
4752                && (tree_int_cst_compare ((tree) high_bound->key,
4753                                          high_value)
4754                    <= 0))
4755         node = high_bound;
4756     }
4757   /* If there was an overlap, issue an error.  */
4758   if (node)
4759     {
4760       tree duplicate = CASE_LABEL ((tree) node->value);
4761
4762       if (high_value)
4763         {
4764           error ("duplicate (or overlapping) case value");
4765           error ("%Jthis is the first entry overlapping that value", duplicate);
4766         }
4767       else if (low_value)
4768         {
4769           error ("duplicate case value") ;
4770           error ("%Jpreviously used here", duplicate);
4771         }
4772       else
4773         {
4774           error ("multiple default labels in one switch");
4775           error ("%Jthis is the first default label", duplicate);
4776         }
4777       goto error_out;
4778     }
4779
4780   /* Add a CASE_LABEL to the statement-tree.  */
4781   case_label = add_stmt (build_case_label (low_value, high_value, label));
4782   /* Register this case label in the splay tree.  */
4783   splay_tree_insert (cases,
4784                      (splay_tree_key) low_value,
4785                      (splay_tree_value) case_label);
4786
4787   return case_label;
4788
4789  error_out:
4790   /* Add a label so that the back-end doesn't think that the beginning of
4791      the switch is unreachable.  Note that we do not add a case label, as
4792      that just leads to duplicates and thence to failure later on.  */
4793   if (!cases->root)
4794     {
4795       tree t = create_artificial_label ();
4796       add_stmt (build_stmt (LABEL_EXPR, t));
4797     }
4798   return error_mark_node;
4799 }
4800
4801 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
4802    Used to verify that case values match up with enumerator values.  */
4803
4804 static void
4805 match_case_to_enum_1 (tree key, tree type, tree label)
4806 {
4807   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
4808
4809   /* ??? Not working too hard to print the double-word value.
4810      Should perhaps be done with %lwd in the diagnostic routines?  */
4811   if (TREE_INT_CST_HIGH (key) == 0)
4812     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
4813               TREE_INT_CST_LOW (key));
4814   else if (!TYPE_UNSIGNED (type)
4815            && TREE_INT_CST_HIGH (key) == -1
4816            && TREE_INT_CST_LOW (key) != 0)
4817     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
4818               -TREE_INT_CST_LOW (key));
4819   else
4820     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4821               (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (key),
4822               (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (key));
4823
4824   if (TYPE_NAME (type) == 0)
4825     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4826              "%Jcase value %qs not in enumerated type",
4827              CASE_LABEL (label), buf);
4828   else
4829     warning (warn_switch ? OPT_Wswitch : OPT_Wswitch_enum,
4830              "%Jcase value %qs not in enumerated type %qT",
4831              CASE_LABEL (label), buf, type);
4832 }
4833
4834 /* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
4835    Used to verify that case values match up with enumerator values.  */
4836
4837 static int
4838 match_case_to_enum (splay_tree_node node, void *data)
4839 {
4840   tree label = (tree) node->value;
4841   tree type = (tree) data;
4842
4843   /* Skip default case.  */
4844   if (!CASE_LOW (label))
4845     return 0;
4846
4847   /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
4848      when we did our enum->case scan.  Reset our scratch bit after.  */
4849   if (!CASE_LOW_SEEN (label))
4850     match_case_to_enum_1 (CASE_LOW (label), type, label);
4851   else
4852     CASE_LOW_SEEN (label) = 0;
4853
4854   /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
4855      not set, that means that CASE_HIGH did not appear when we did our
4856      enum->case scan.  Reset our scratch bit after.  */
4857   if (CASE_HIGH (label))
4858     {
4859       if (!CASE_HIGH_SEEN (label))
4860         match_case_to_enum_1 (CASE_HIGH (label), type, label);
4861       else
4862         CASE_HIGH_SEEN (label) = 0;
4863     }
4864
4865   return 0;
4866 }
4867
4868 /* Handle -Wswitch*.  Called from the front end after parsing the
4869    switch construct.  */
4870 /* ??? Should probably be somewhere generic, since other languages
4871    besides C and C++ would want this.  At the moment, however, C/C++
4872    are the only tree-ssa languages that support enumerations at all,
4873    so the point is moot.  */
4874
4875 void
4876 c_do_switch_warnings (splay_tree cases, location_t switch_location,
4877                       tree type, tree cond)
4878 {
4879   splay_tree_node default_node;
4880   splay_tree_node node;
4881   tree chain;
4882   int saved_warn_switch;
4883
4884   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
4885     return;
4886
4887   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
4888   if (!default_node)
4889     warning (OPT_Wswitch_default, "%Hswitch missing default case",
4890              &switch_location);
4891
4892   /* From here on, we only care about about enumerated types.  */
4893   if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
4894     return;
4895
4896   /* If the switch expression was an enumerated type, check that
4897      exactly all enumeration literals are covered by the cases.
4898      The check is made when -Wswitch was specified and there is no
4899      default case, or when -Wswitch-enum was specified.  */
4900
4901   if (!warn_switch_enum
4902       && !(warn_switch && !default_node))
4903     return;
4904
4905   /* Clearing COND if it is not an integer constant simplifies
4906      the tests inside the loop below.  */
4907   if (TREE_CODE (cond) != INTEGER_CST)
4908     cond = NULL_TREE;
4909
4910   /* The time complexity here is O(N*lg(N)) worst case, but for the
4911       common case of monotonically increasing enumerators, it is
4912       O(N), since the nature of the splay tree will keep the next
4913       element adjacent to the root at all times.  */
4914
4915   for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
4916     {
4917       tree value = TREE_VALUE (chain);
4918       if (TREE_CODE (value) == CONST_DECL)
4919         value = DECL_INITIAL (value);
4920       node = splay_tree_lookup (cases, (splay_tree_key) value);
4921       if (node)
4922         {
4923           /* Mark the CASE_LOW part of the case entry as seen.  */
4924           tree label = (tree) node->value;
4925           CASE_LOW_SEEN (label) = 1;
4926           continue;
4927         }
4928
4929       /* Even though there wasn't an exact match, there might be a
4930          case range which includes the enumerator's value.  */
4931       node = splay_tree_predecessor (cases, (splay_tree_key) value);
4932       if (node && CASE_HIGH ((tree) node->value))
4933         {
4934           tree label = (tree) node->value;
4935           int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
4936           if (cmp >= 0)
4937             {
4938               /* If we match the upper bound exactly, mark the CASE_HIGH
4939                  part of the case entry as seen.  */
4940               if (cmp == 0)
4941                 CASE_HIGH_SEEN (label) = 1;
4942               continue;
4943             }
4944         }
4945
4946       /* We've now determined that this enumerated literal isn't
4947          handled by the case labels of the switch statement.  */
4948
4949       /* If the switch expression is a constant, we only really care
4950          about whether that constant is handled by the switch.  */
4951       if (cond && tree_int_cst_compare (cond, value))
4952         continue;
4953
4954       /* If there is a default_node, the only relevant option is
4955          Wswitch-enum. Otherwise, if both are enabled then we prefer
4956          to warn using -Wswitch because -Wswitch is enabled by -Wall
4957          while -Wswitch-enum is explicit.  */
4958       warning ((default_node || !warn_switch)
4959                ? OPT_Wswitch_enum : OPT_Wswitch,
4960                "%Henumeration value %qE not handled in switch",
4961                &switch_location, TREE_PURPOSE (chain));
4962     }
4963
4964   /* Warn if there are case expressions that don't correspond to
4965      enumerators.  This can occur since C and C++ don't enforce
4966      type-checking of assignments to enumeration variables.
4967
4968      The time complexity here is now always O(N) worst case, since
4969      we should have marked both the lower bound and upper bound of
4970      every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
4971      above.  This scan also resets those fields.  */
4972
4973   /* If there is a default_node, the only relevant option is
4974      Wswitch-enum. Otherwise, if both are enabled then we prefer
4975      to warn using -Wswitch because -Wswitch is enabled by -Wall
4976      while -Wswitch-enum is explicit.  */
4977   saved_warn_switch = warn_switch;
4978   if (default_node)
4979     warn_switch = 0;
4980   splay_tree_foreach (cases, match_case_to_enum, type);
4981   warn_switch = saved_warn_switch;
4982
4983 }
4984
4985 /* Finish an expression taking the address of LABEL (an
4986    IDENTIFIER_NODE).  Returns an expression for the address.
4987
4988    LOC is the location for the expression returned.  */
4989
4990 tree
4991 finish_label_address_expr (tree label, location_t loc)
4992 {
4993   tree result;
4994
4995   pedwarn (input_location, OPT_pedantic, "taking the address of a label is non-standard");
4996
4997   if (label == error_mark_node)
4998     return error_mark_node;
4999
5000   label = lookup_label (label);
5001   if (label == NULL_TREE)
5002     result = null_pointer_node;
5003   else
5004     {
5005       TREE_USED (label) = 1;
5006       result = build1 (ADDR_EXPR, ptr_type_node, label);
5007       /* The current function in not necessarily uninlinable.
5008          Computed gotos are incompatible with inlining, but the value
5009          here could be used only in a diagnostic, for example.  */
5010       protected_set_expr_location (result, loc);
5011     }
5012
5013   return result;
5014 }
5015
5016 /* Hook used by expand_expr to expand language-specific tree codes.  */
5017 /* The only things that should go here are bits needed to expand
5018    constant initializers.  Everything else should be handled by the
5019    gimplification routines.  */
5020
5021 rtx
5022 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
5023                int modifiera /* Actually enum expand_modifier.  */,
5024                rtx *alt_rtl)
5025 {
5026   enum expand_modifier modifier = (enum expand_modifier) modifiera;
5027   switch (TREE_CODE (exp))
5028     {
5029     case COMPOUND_LITERAL_EXPR:
5030       {
5031         /* Initialize the anonymous variable declared in the compound
5032            literal, then return the variable.  */
5033         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
5034         emit_local_var (decl);
5035         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
5036       }
5037
5038     default:
5039       gcc_unreachable ();
5040     }
5041 }
5042
5043 /* Hook used by staticp to handle language-specific tree codes.  */
5044
5045 tree
5046 c_staticp (tree exp)
5047 {
5048   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
5049           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
5050           ? exp : NULL);
5051 }
5052 \f
5053
5054 /* Given a boolean expression ARG, return a tree representing an increment
5055    or decrement (as indicated by CODE) of ARG.  The front end must check for
5056    invalid cases (e.g., decrement in C++).  */
5057 tree
5058 boolean_increment (enum tree_code code, tree arg)
5059 {
5060   tree val;
5061   tree true_res = build_int_cst (TREE_TYPE (arg), 1);
5062
5063   arg = stabilize_reference (arg);
5064   switch (code)
5065     {
5066     case PREINCREMENT_EXPR:
5067       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5068       break;
5069     case POSTINCREMENT_EXPR:
5070       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
5071       arg = save_expr (arg);
5072       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5073       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5074       break;
5075     case PREDECREMENT_EXPR:
5076       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5077                     invert_truthvalue (arg));
5078       break;
5079     case POSTDECREMENT_EXPR:
5080       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
5081                     invert_truthvalue (arg));
5082       arg = save_expr (arg);
5083       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
5084       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
5085       break;
5086     default:
5087       gcc_unreachable ();
5088     }
5089   TREE_SIDE_EFFECTS (val) = 1;
5090   return val;
5091 }
5092 \f
5093 /* Built-in macros for stddef.h, that require macros defined in this
5094    file.  */
5095 void
5096 c_stddef_cpp_builtins(void)
5097 {
5098   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
5099   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
5100   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
5101   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
5102   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
5103   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
5104   builtin_define_with_value ("__CHAR16_TYPE__", CHAR16_TYPE, 0);
5105   builtin_define_with_value ("__CHAR32_TYPE__", CHAR32_TYPE, 0);
5106 }
5107
5108 static void
5109 c_init_attributes (void)
5110 {
5111   /* Fill in the built_in_attributes array.  */
5112 #define DEF_ATTR_NULL_TREE(ENUM)                                \
5113   built_in_attributes[(int) ENUM] = NULL_TREE;
5114 #define DEF_ATTR_INT(ENUM, VALUE)                               \
5115   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
5116 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
5117   built_in_attributes[(int) ENUM] = get_identifier (STRING);
5118 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
5119   built_in_attributes[(int) ENUM]                       \
5120     = tree_cons (built_in_attributes[(int) PURPOSE],    \
5121                  built_in_attributes[(int) VALUE],      \
5122                  built_in_attributes[(int) CHAIN]);
5123 #include "builtin-attrs.def"
5124 #undef DEF_ATTR_NULL_TREE
5125 #undef DEF_ATTR_INT
5126 #undef DEF_ATTR_IDENT
5127 #undef DEF_ATTR_TREE_LIST
5128 }
5129
5130 /* Attribute handlers common to C front ends.  */
5131
5132 /* Handle a "packed" attribute; arguments as in
5133    struct attribute_spec.handler.  */
5134
5135 static tree
5136 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5137                          int flags, bool *no_add_attrs)
5138 {
5139   if (TYPE_P (*node))
5140     {
5141       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5142         *node = build_variant_type_copy (*node);
5143       TYPE_PACKED (*node) = 1;
5144     }
5145   else if (TREE_CODE (*node) == FIELD_DECL)
5146     {
5147       if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
5148         warning (OPT_Wattributes,
5149                  "%qE attribute ignored for field of type %qT",
5150                  name, TREE_TYPE (*node));
5151       else
5152         DECL_PACKED (*node) = 1;
5153     }
5154   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
5155      used for DECL_REGISTER.  It wouldn't mean anything anyway.
5156      We can't set DECL_PACKED on the type of a TYPE_DECL, because
5157      that changes what the typedef is typing.  */
5158   else
5159     {
5160       warning (OPT_Wattributes, "%qE attribute ignored", name);
5161       *no_add_attrs = true;
5162     }
5163
5164   return NULL_TREE;
5165 }
5166
5167 /* Handle a "nocommon" attribute; arguments as in
5168    struct attribute_spec.handler.  */
5169
5170 static tree
5171 handle_nocommon_attribute (tree *node, tree name,
5172                            tree ARG_UNUSED (args),
5173                            int ARG_UNUSED (flags), bool *no_add_attrs)
5174 {
5175   if (TREE_CODE (*node) == VAR_DECL)
5176     DECL_COMMON (*node) = 0;
5177   else
5178     {
5179       warning (OPT_Wattributes, "%qE attribute ignored", name);
5180       *no_add_attrs = true;
5181     }
5182
5183   return NULL_TREE;
5184 }
5185
5186 /* Handle a "common" attribute; arguments as in
5187    struct attribute_spec.handler.  */
5188
5189 static tree
5190 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5191                          int ARG_UNUSED (flags), bool *no_add_attrs)
5192 {
5193   if (TREE_CODE (*node) == VAR_DECL)
5194     DECL_COMMON (*node) = 1;
5195   else
5196     {
5197       warning (OPT_Wattributes, "%qE attribute ignored", name);
5198       *no_add_attrs = true;
5199     }
5200
5201   return NULL_TREE;
5202 }
5203
5204 /* Handle a "noreturn" attribute; arguments as in
5205    struct attribute_spec.handler.  */
5206
5207 static tree
5208 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5209                            int ARG_UNUSED (flags), bool *no_add_attrs)
5210 {
5211   tree type = TREE_TYPE (*node);
5212
5213   /* See FIXME comment in c_common_attribute_table.  */
5214   if (TREE_CODE (*node) == FUNCTION_DECL)
5215     TREE_THIS_VOLATILE (*node) = 1;
5216   else if (TREE_CODE (type) == POINTER_TYPE
5217            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5218     TREE_TYPE (*node)
5219       = build_pointer_type
5220         (build_type_variant (TREE_TYPE (type),
5221                              TYPE_READONLY (TREE_TYPE (type)), 1));
5222   else
5223     {
5224       warning (OPT_Wattributes, "%qE attribute ignored", name);
5225       *no_add_attrs = true;
5226     }
5227
5228   return NULL_TREE;
5229 }
5230
5231 /* Handle a "hot" and attribute; arguments as in
5232    struct attribute_spec.handler.  */
5233
5234 static tree
5235 handle_hot_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5236                       int ARG_UNUSED (flags), bool *no_add_attrs)
5237 {
5238   if (TREE_CODE (*node) == FUNCTION_DECL)
5239     {
5240       if (lookup_attribute ("cold", DECL_ATTRIBUTES (*node)) != NULL)
5241         {
5242           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5243                    name, "cold");
5244           *no_add_attrs = true;
5245         }
5246       /* Most of the rest of the hot processing is done later with
5247          lookup_attribute.  */
5248     }
5249   else
5250     {
5251       warning (OPT_Wattributes, "%qE attribute ignored", name);
5252       *no_add_attrs = true;
5253     }
5254
5255   return NULL_TREE;
5256 }
5257 /* Handle a "cold" and attribute; arguments as in
5258    struct attribute_spec.handler.  */
5259
5260 static tree
5261 handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5262                        int ARG_UNUSED (flags), bool *no_add_attrs)
5263 {
5264   if (TREE_CODE (*node) == FUNCTION_DECL)
5265     {
5266       if (lookup_attribute ("hot", DECL_ATTRIBUTES (*node)) != NULL)
5267         {
5268           warning (OPT_Wattributes, "%qE attribute conflicts with attribute %s",
5269                    name, "hot");
5270           *no_add_attrs = true;
5271         }
5272       /* Most of the rest of the cold processing is done later with
5273          lookup_attribute.  */
5274     }
5275   else
5276     {
5277       warning (OPT_Wattributes, "%qE attribute ignored", name);
5278       *no_add_attrs = true;
5279     }
5280
5281   return NULL_TREE;
5282 }
5283
5284 /* Handle a "noinline" attribute; arguments as in
5285    struct attribute_spec.handler.  */
5286
5287 static tree
5288 handle_noinline_attribute (tree *node, tree name,
5289                            tree ARG_UNUSED (args),
5290                            int ARG_UNUSED (flags), bool *no_add_attrs)
5291 {
5292   if (TREE_CODE (*node) == FUNCTION_DECL)
5293     DECL_UNINLINABLE (*node) = 1;
5294   else
5295     {
5296       warning (OPT_Wattributes, "%qE attribute ignored", name);
5297       *no_add_attrs = true;
5298     }
5299
5300   return NULL_TREE;
5301 }
5302
5303 /* Handle a "always_inline" attribute; arguments as in
5304    struct attribute_spec.handler.  */
5305
5306 static tree
5307 handle_always_inline_attribute (tree *node, tree name,
5308                                 tree ARG_UNUSED (args),
5309                                 int ARG_UNUSED (flags),
5310                                 bool *no_add_attrs)
5311 {
5312   if (TREE_CODE (*node) == FUNCTION_DECL)
5313     {
5314       /* Set the attribute and mark it for disregarding inline
5315          limits.  */
5316       DECL_DISREGARD_INLINE_LIMITS (*node) = 1;
5317     }
5318   else
5319     {
5320       warning (OPT_Wattributes, "%qE attribute ignored", name);
5321       *no_add_attrs = true;
5322     }
5323
5324   return NULL_TREE;
5325 }
5326
5327 /* Handle a "gnu_inline" attribute; arguments as in
5328    struct attribute_spec.handler.  */
5329
5330 static tree
5331 handle_gnu_inline_attribute (tree *node, tree name,
5332                              tree ARG_UNUSED (args),
5333                              int ARG_UNUSED (flags),
5334                              bool *no_add_attrs)
5335 {
5336   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5337     {
5338       /* Do nothing else, just set the attribute.  We'll get at
5339          it later with lookup_attribute.  */
5340     }
5341   else
5342     {
5343       warning (OPT_Wattributes, "%qE attribute ignored", name);
5344       *no_add_attrs = true;
5345     }
5346
5347   return NULL_TREE;
5348 }
5349
5350 /* Handle an "artificial" attribute; arguments as in
5351    struct attribute_spec.handler.  */
5352
5353 static tree
5354 handle_artificial_attribute (tree *node, tree name,
5355                              tree ARG_UNUSED (args),
5356                              int ARG_UNUSED (flags),
5357                              bool *no_add_attrs)
5358 {
5359   if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
5360     {
5361       /* Do nothing else, just set the attribute.  We'll get at
5362          it later with lookup_attribute.  */
5363     }
5364   else
5365     {
5366       warning (OPT_Wattributes, "%qE attribute ignored", name);
5367       *no_add_attrs = true;
5368     }
5369
5370   return NULL_TREE;
5371 }
5372
5373 /* Handle a "flatten" attribute; arguments as in
5374    struct attribute_spec.handler.  */
5375
5376 static tree
5377 handle_flatten_attribute (tree *node, tree name,
5378                           tree args ATTRIBUTE_UNUSED,
5379                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5380 {
5381   if (TREE_CODE (*node) == FUNCTION_DECL)
5382     /* Do nothing else, just set the attribute.  We'll get at
5383        it later with lookup_attribute.  */
5384     ;
5385   else
5386     {
5387       warning (OPT_Wattributes, "%qE attribute ignored", name);
5388       *no_add_attrs = true;
5389     }
5390
5391   return NULL_TREE;
5392 }
5393
5394 /* Handle a "warning" or "error" attribute; arguments as in
5395    struct attribute_spec.handler.  */
5396
5397 static tree
5398 handle_error_attribute (tree *node, tree name, tree args,
5399                         int ARG_UNUSED (flags), bool *no_add_attrs)
5400 {
5401   if (TREE_CODE (*node) == FUNCTION_DECL
5402       || TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5403     /* Do nothing else, just set the attribute.  We'll get at
5404        it later with lookup_attribute.  */
5405     ;
5406   else
5407     {
5408       warning (OPT_Wattributes, "%qE attribute ignored", name);
5409       *no_add_attrs = true;
5410     }
5411
5412   return NULL_TREE;
5413 }
5414
5415 /* Handle a "used" attribute; arguments as in
5416    struct attribute_spec.handler.  */
5417
5418 static tree
5419 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
5420                        int ARG_UNUSED (flags), bool *no_add_attrs)
5421 {
5422   tree node = *pnode;
5423
5424   if (TREE_CODE (node) == FUNCTION_DECL
5425       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
5426     {
5427       TREE_USED (node) = 1;
5428       DECL_PRESERVE_P (node) = 1;
5429     }
5430   else
5431     {
5432       warning (OPT_Wattributes, "%qE attribute ignored", name);
5433       *no_add_attrs = true;
5434     }
5435
5436   return NULL_TREE;
5437 }
5438
5439 /* Handle a "unused" attribute; arguments as in
5440    struct attribute_spec.handler.  */
5441
5442 static tree
5443 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5444                          int flags, bool *no_add_attrs)
5445 {
5446   if (DECL_P (*node))
5447     {
5448       tree decl = *node;
5449
5450       if (TREE_CODE (decl) == PARM_DECL
5451           || TREE_CODE (decl) == VAR_DECL
5452           || TREE_CODE (decl) == FUNCTION_DECL
5453           || TREE_CODE (decl) == LABEL_DECL
5454           || TREE_CODE (decl) == TYPE_DECL)
5455         TREE_USED (decl) = 1;
5456       else
5457         {
5458           warning (OPT_Wattributes, "%qE attribute ignored", name);
5459           *no_add_attrs = true;
5460         }
5461     }
5462   else
5463     {
5464       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5465         *node = build_variant_type_copy (*node);
5466       TREE_USED (*node) = 1;
5467     }
5468
5469   return NULL_TREE;
5470 }
5471
5472 /* Handle a "externally_visible" attribute; arguments as in
5473    struct attribute_spec.handler.  */
5474
5475 static tree
5476 handle_externally_visible_attribute (tree *pnode, tree name,
5477                                      tree ARG_UNUSED (args),
5478                                      int ARG_UNUSED (flags),
5479                                      bool *no_add_attrs)
5480 {
5481   tree node = *pnode;
5482
5483   if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
5484     {
5485       if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
5486            && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
5487         {
5488           warning (OPT_Wattributes,
5489                    "%qE attribute have effect only on public objects", name);
5490           *no_add_attrs = true;
5491         }
5492     }
5493   else
5494     {
5495       warning (OPT_Wattributes, "%qE attribute ignored", name);
5496       *no_add_attrs = true;
5497     }
5498
5499   return NULL_TREE;
5500 }
5501
5502 /* Handle a "const" attribute; arguments as in
5503    struct attribute_spec.handler.  */
5504
5505 static tree
5506 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5507                         int ARG_UNUSED (flags), bool *no_add_attrs)
5508 {
5509   tree type = TREE_TYPE (*node);
5510
5511   /* See FIXME comment on noreturn in c_common_attribute_table.  */
5512   if (TREE_CODE (*node) == FUNCTION_DECL)
5513     TREE_READONLY (*node) = 1;
5514   else if (TREE_CODE (type) == POINTER_TYPE
5515            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
5516     TREE_TYPE (*node)
5517       = build_pointer_type
5518         (build_type_variant (TREE_TYPE (type), 1,
5519                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
5520   else
5521     {
5522       warning (OPT_Wattributes, "%qE attribute ignored", name);
5523       *no_add_attrs = true;
5524     }
5525
5526   return NULL_TREE;
5527 }
5528
5529 /* Handle a "transparent_union" attribute; arguments as in
5530    struct attribute_spec.handler.  */
5531
5532 static tree
5533 handle_transparent_union_attribute (tree *node, tree name,
5534                                     tree ARG_UNUSED (args), int flags,
5535                                     bool *no_add_attrs)
5536 {
5537   tree type;
5538
5539   *no_add_attrs = true;
5540
5541   if (TREE_CODE (*node) == TYPE_DECL)
5542     node = &TREE_TYPE (*node);
5543   type = *node;
5544
5545   if (TREE_CODE (type) == UNION_TYPE)
5546     {
5547       /* When IN_PLACE is set, leave the check for FIELDS and MODE to
5548          the code in finish_struct.  */
5549       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5550         {
5551           if (TYPE_FIELDS (type) == NULL_TREE
5552               || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
5553             goto ignored;
5554
5555           /* A type variant isn't good enough, since we don't a cast
5556              to such a type removed as a no-op.  */
5557           *node = type = build_duplicate_type (type);
5558         }
5559
5560       TYPE_TRANSPARENT_UNION (type) = 1;
5561       return NULL_TREE;
5562     }
5563
5564  ignored:
5565   warning (OPT_Wattributes, "%qE attribute ignored", name);
5566   return NULL_TREE;
5567 }
5568
5569 /* Subroutine of handle_{con,de}structor_attribute.  Evaluate ARGS to
5570    get the requested priority for a constructor or destructor,
5571    possibly issuing diagnostics for invalid or reserved
5572    priorities.  */
5573
5574 static priority_type
5575 get_priority (tree args, bool is_destructor)
5576 {
5577   HOST_WIDE_INT pri;
5578   tree arg;
5579
5580   if (!args)
5581     return DEFAULT_INIT_PRIORITY;
5582
5583   if (!SUPPORTS_INIT_PRIORITY)
5584     {
5585       if (is_destructor)
5586         error ("destructor priorities are not supported");
5587       else
5588         error ("constructor priorities are not supported");
5589       return DEFAULT_INIT_PRIORITY;
5590     }
5591
5592   arg = TREE_VALUE (args);
5593   if (!host_integerp (arg, /*pos=*/0)
5594       || !INTEGRAL_TYPE_P (TREE_TYPE (arg)))
5595     goto invalid;
5596
5597   pri = tree_low_cst (TREE_VALUE (args), /*pos=*/0);
5598   if (pri < 0 || pri > MAX_INIT_PRIORITY)
5599     goto invalid;
5600
5601   if (pri <= MAX_RESERVED_INIT_PRIORITY)
5602     {
5603       if (is_destructor)
5604         warning (0,
5605                  "destructor priorities from 0 to %d are reserved "
5606                  "for the implementation",
5607                  MAX_RESERVED_INIT_PRIORITY);
5608       else
5609         warning (0,
5610                  "constructor priorities from 0 to %d are reserved "
5611                  "for the implementation",
5612                  MAX_RESERVED_INIT_PRIORITY);
5613     }
5614   return pri;
5615
5616  invalid:
5617   if (is_destructor)
5618     error ("destructor priorities must be integers from 0 to %d inclusive",
5619            MAX_INIT_PRIORITY);
5620   else
5621     error ("constructor priorities must be integers from 0 to %d inclusive",
5622            MAX_INIT_PRIORITY);
5623   return DEFAULT_INIT_PRIORITY;
5624 }
5625
5626 /* Handle a "constructor" attribute; arguments as in
5627    struct attribute_spec.handler.  */
5628
5629 static tree
5630 handle_constructor_attribute (tree *node, tree name, tree args,
5631                               int ARG_UNUSED (flags),
5632                               bool *no_add_attrs)
5633 {
5634   tree decl = *node;
5635   tree type = TREE_TYPE (decl);
5636
5637   if (TREE_CODE (decl) == FUNCTION_DECL
5638       && TREE_CODE (type) == FUNCTION_TYPE
5639       && decl_function_context (decl) == 0)
5640     {
5641       priority_type priority;
5642       DECL_STATIC_CONSTRUCTOR (decl) = 1;
5643       priority = get_priority (args, /*is_destructor=*/false);
5644       SET_DECL_INIT_PRIORITY (decl, priority);
5645       TREE_USED (decl) = 1;
5646     }
5647   else
5648     {
5649       warning (OPT_Wattributes, "%qE attribute ignored", name);
5650       *no_add_attrs = true;
5651     }
5652
5653   return NULL_TREE;
5654 }
5655
5656 /* Handle a "destructor" attribute; arguments as in
5657    struct attribute_spec.handler.  */
5658
5659 static tree
5660 handle_destructor_attribute (tree *node, tree name, tree args,
5661                              int ARG_UNUSED (flags),
5662                              bool *no_add_attrs)
5663 {
5664   tree decl = *node;
5665   tree type = TREE_TYPE (decl);
5666
5667   if (TREE_CODE (decl) == FUNCTION_DECL
5668       && TREE_CODE (type) == FUNCTION_TYPE
5669       && decl_function_context (decl) == 0)
5670     {
5671       priority_type priority;
5672       DECL_STATIC_DESTRUCTOR (decl) = 1;
5673       priority = get_priority (args, /*is_destructor=*/true);
5674       SET_DECL_FINI_PRIORITY (decl, priority);
5675       TREE_USED (decl) = 1;
5676     }
5677   else
5678     {
5679       warning (OPT_Wattributes, "%qE attribute ignored", name);
5680       *no_add_attrs = true;
5681     }
5682
5683   return NULL_TREE;
5684 }
5685
5686 /* Handle a "mode" attribute; arguments as in
5687    struct attribute_spec.handler.  */
5688
5689 static tree
5690 handle_mode_attribute (tree *node, tree name, tree args,
5691                        int ARG_UNUSED (flags), bool *no_add_attrs)
5692 {
5693   tree type = *node;
5694
5695   *no_add_attrs = true;
5696
5697   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
5698     warning (OPT_Wattributes, "%qE attribute ignored", name);
5699   else
5700     {
5701       int j;
5702       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
5703       int len = strlen (p);
5704       enum machine_mode mode = VOIDmode;
5705       tree typefm;
5706       bool valid_mode;
5707
5708       if (len > 4 && p[0] == '_' && p[1] == '_'
5709           && p[len - 1] == '_' && p[len - 2] == '_')
5710         {
5711           char *newp = (char *) alloca (len - 1);
5712
5713           strcpy (newp, &p[2]);
5714           newp[len - 4] = '\0';
5715           p = newp;
5716         }
5717
5718       /* Change this type to have a type with the specified mode.
5719          First check for the special modes.  */
5720       if (!strcmp (p, "byte"))
5721         mode = byte_mode;
5722       else if (!strcmp (p, "word"))
5723         mode = word_mode;
5724       else if (!strcmp (p, "pointer"))
5725         mode = ptr_mode;
5726       else if (!strcmp (p, "libgcc_cmp_return"))
5727         mode = targetm.libgcc_cmp_return_mode ();
5728       else if (!strcmp (p, "libgcc_shift_count"))
5729         mode = targetm.libgcc_shift_count_mode ();
5730       else if (!strcmp (p, "unwind_word"))
5731         mode = targetm.unwind_word_mode ();
5732       else
5733         for (j = 0; j < NUM_MACHINE_MODES; j++)
5734           if (!strcmp (p, GET_MODE_NAME (j)))
5735             {
5736               mode = (enum machine_mode) j;
5737               break;
5738             }
5739
5740       if (mode == VOIDmode)
5741         {
5742           error ("unknown machine mode %qs", p);
5743           return NULL_TREE;
5744         }
5745
5746       valid_mode = false;
5747       switch (GET_MODE_CLASS (mode))
5748         {
5749         case MODE_INT:
5750         case MODE_PARTIAL_INT:
5751         case MODE_FLOAT:
5752         case MODE_DECIMAL_FLOAT:
5753         case MODE_FRACT:
5754         case MODE_UFRACT:
5755         case MODE_ACCUM:
5756         case MODE_UACCUM:
5757           valid_mode = targetm.scalar_mode_supported_p (mode);
5758           break;
5759
5760         case MODE_COMPLEX_INT:
5761         case MODE_COMPLEX_FLOAT:
5762           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
5763           break;
5764
5765         case MODE_VECTOR_INT:
5766         case MODE_VECTOR_FLOAT:
5767         case MODE_VECTOR_FRACT:
5768         case MODE_VECTOR_UFRACT:
5769         case MODE_VECTOR_ACCUM:
5770         case MODE_VECTOR_UACCUM:
5771           warning (OPT_Wattributes, "specifying vector types with "
5772                    "__attribute__ ((mode)) is deprecated");
5773           warning (OPT_Wattributes,
5774                    "use __attribute__ ((vector_size)) instead");
5775           valid_mode = vector_mode_valid_p (mode);
5776           break;
5777
5778         default:
5779           break;
5780         }
5781       if (!valid_mode)
5782         {
5783           error ("unable to emulate %qs", p);
5784           return NULL_TREE;
5785         }
5786
5787       if (POINTER_TYPE_P (type))
5788         {
5789           tree (*fn)(tree, enum machine_mode, bool);
5790
5791           if (!targetm.valid_pointer_mode (mode))
5792             {
5793               error ("invalid pointer mode %qs", p);
5794               return NULL_TREE;
5795             }
5796
5797           if (TREE_CODE (type) == POINTER_TYPE)
5798             fn = build_pointer_type_for_mode;
5799           else
5800             fn = build_reference_type_for_mode;
5801           typefm = fn (TREE_TYPE (type), mode, false);
5802         }
5803       else
5804         {
5805           /* For fixed-point modes, we need to test if the signness of type
5806              and the machine mode are consistent.  */
5807           if (ALL_FIXED_POINT_MODE_P (mode)
5808               && TYPE_UNSIGNED (type) != UNSIGNED_FIXED_POINT_MODE_P (mode))
5809             {
5810               error ("signness of type and machine mode %qs don't match", p);
5811               return NULL_TREE;
5812             }
5813           /* For fixed-point modes, we need to pass saturating info.  */
5814           typefm = lang_hooks.types.type_for_mode (mode,
5815                         ALL_FIXED_POINT_MODE_P (mode) ? TYPE_SATURATING (type)
5816                                                       : TYPE_UNSIGNED (type));
5817         }
5818
5819       if (typefm == NULL_TREE)
5820         {
5821           error ("no data type for mode %qs", p);
5822           return NULL_TREE;
5823         }
5824       else if (TREE_CODE (type) == ENUMERAL_TYPE)
5825         {
5826           /* For enumeral types, copy the precision from the integer
5827              type returned above.  If not an INTEGER_TYPE, we can't use
5828              this mode for this type.  */
5829           if (TREE_CODE (typefm) != INTEGER_TYPE)
5830             {
5831               error ("cannot use mode %qs for enumeral types", p);
5832               return NULL_TREE;
5833             }
5834
5835           if (flags & ATTR_FLAG_TYPE_IN_PLACE)
5836             {
5837               TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
5838               typefm = type;
5839             }
5840           else
5841             {
5842               /* We cannot build a type variant, as there's code that assumes
5843                  that TYPE_MAIN_VARIANT has the same mode.  This includes the
5844                  debug generators.  Instead, create a subrange type.  This
5845                  results in all of the enumeral values being emitted only once
5846                  in the original, and the subtype gets them by reference.  */
5847               if (TYPE_UNSIGNED (type))
5848                 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
5849               else
5850                 typefm = make_signed_type (TYPE_PRECISION (typefm));
5851               TREE_TYPE (typefm) = type;
5852             }
5853         }
5854       else if (VECTOR_MODE_P (mode)
5855                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
5856                : TREE_CODE (type) != TREE_CODE (typefm))
5857         {
5858           error ("mode %qs applied to inappropriate type", p);
5859           return NULL_TREE;
5860         }
5861
5862       *node = typefm;
5863     }
5864
5865   return NULL_TREE;
5866 }
5867
5868 /* Handle a "section" attribute; arguments as in
5869    struct attribute_spec.handler.  */
5870
5871 static tree
5872 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5873                           int ARG_UNUSED (flags), bool *no_add_attrs)
5874 {
5875   tree decl = *node;
5876
5877   if (targetm.have_named_sections)
5878     {
5879       user_defined_section_attribute = true;
5880
5881       if ((TREE_CODE (decl) == FUNCTION_DECL
5882            || TREE_CODE (decl) == VAR_DECL)
5883           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5884         {
5885           if (TREE_CODE (decl) == VAR_DECL
5886               && current_function_decl != NULL_TREE
5887               && !TREE_STATIC (decl))
5888             {
5889               error ("%Jsection attribute cannot be specified for "
5890                      "local variables", decl);
5891               *no_add_attrs = true;
5892             }
5893
5894           /* The decl may have already been given a section attribute
5895              from a previous declaration.  Ensure they match.  */
5896           else if (DECL_SECTION_NAME (decl) != NULL_TREE
5897                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5898                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5899             {
5900               error ("section of %q+D conflicts with previous declaration",
5901                      *node);
5902               *no_add_attrs = true;
5903             }
5904           else if (TREE_CODE (decl) == VAR_DECL
5905                    && !targetm.have_tls && targetm.emutls.tmpl_section
5906                    && DECL_THREAD_LOCAL_P (decl))
5907             {
5908               error ("section of %q+D cannot be overridden", *node);
5909               *no_add_attrs = true;
5910             }
5911           else
5912             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5913         }
5914       else
5915         {
5916           error ("section attribute not allowed for %q+D", *node);
5917           *no_add_attrs = true;
5918         }
5919     }
5920   else
5921     {
5922       error ("%Jsection attributes are not supported for this target", *node);
5923       *no_add_attrs = true;
5924     }
5925
5926   return NULL_TREE;
5927 }
5928
5929 /* Handle a "aligned" attribute; arguments as in
5930    struct attribute_spec.handler.  */
5931
5932 static tree
5933 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
5934                           int flags, bool *no_add_attrs)
5935 {
5936   tree decl = NULL_TREE;
5937   tree *type = NULL;
5938   int is_type = 0;
5939   tree align_expr = (args ? TREE_VALUE (args)
5940                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5941   int i;
5942
5943   if (DECL_P (*node))
5944     {
5945       decl = *node;
5946       type = &TREE_TYPE (decl);
5947       is_type = TREE_CODE (*node) == TYPE_DECL;
5948     }
5949   else if (TYPE_P (*node))
5950     type = node, is_type = 1;
5951
5952   if (TREE_CODE (align_expr) != INTEGER_CST)
5953     {
5954       error ("requested alignment is not a constant");
5955       *no_add_attrs = true;
5956     }
5957   else if ((i = tree_log2 (align_expr)) == -1)
5958     {
5959       error ("requested alignment is not a power of 2");
5960       *no_add_attrs = true;
5961     }
5962   else if (i > HOST_BITS_PER_INT - 2)
5963     {
5964       error ("requested alignment is too large");
5965       *no_add_attrs = true;
5966     }
5967   else if (is_type)
5968     {
5969       /* If we have a TYPE_DECL, then copy the type, so that we
5970          don't accidentally modify a builtin type.  See pushdecl.  */
5971       if (decl && TREE_TYPE (decl) != error_mark_node
5972           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5973         {
5974           tree tt = TREE_TYPE (decl);
5975           *type = build_variant_type_copy (*type);
5976           DECL_ORIGINAL_TYPE (decl) = tt;
5977           TYPE_NAME (*type) = decl;
5978           TREE_USED (*type) = TREE_USED (decl);
5979           TREE_TYPE (decl) = *type;
5980         }
5981       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5982         *type = build_variant_type_copy (*type);
5983
5984       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5985       TYPE_USER_ALIGN (*type) = 1;
5986     }
5987   else if (! VAR_OR_FUNCTION_DECL_P (decl)
5988            && TREE_CODE (decl) != FIELD_DECL)
5989     {
5990       error ("alignment may not be specified for %q+D", decl);
5991       *no_add_attrs = true;
5992     }
5993   else if (TREE_CODE (decl) == FUNCTION_DECL
5994            && DECL_ALIGN (decl) > (1 << i) * BITS_PER_UNIT)
5995     {
5996       if (DECL_USER_ALIGN (decl))
5997         error ("alignment for %q+D was previously specified as %d "
5998                "and may not be decreased", decl,
5999                DECL_ALIGN (decl) / BITS_PER_UNIT);
6000       else
6001         error ("alignment for %q+D must be at least %d", decl,
6002                DECL_ALIGN (decl) / BITS_PER_UNIT);
6003       *no_add_attrs = true;
6004     }
6005   else
6006     {
6007       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
6008       DECL_USER_ALIGN (decl) = 1;
6009     }
6010
6011   return NULL_TREE;
6012 }
6013
6014 /* Handle a "weak" attribute; arguments as in
6015    struct attribute_spec.handler.  */
6016
6017 static tree
6018 handle_weak_attribute (tree *node, tree name,
6019                        tree ARG_UNUSED (args),
6020                        int ARG_UNUSED (flags),
6021                        bool * ARG_UNUSED (no_add_attrs))
6022 {
6023   if (TREE_CODE (*node) == FUNCTION_DECL
6024       && DECL_DECLARED_INLINE_P (*node))
6025     {
6026       error ("inline function %q+D cannot be declared weak", *node);
6027       *no_add_attrs = true;
6028     }
6029   else if (TREE_CODE (*node) == FUNCTION_DECL
6030            || TREE_CODE (*node) == VAR_DECL)
6031     declare_weak (*node);
6032   else
6033     warning (OPT_Wattributes, "%qE attribute ignored", name);
6034
6035   return NULL_TREE;
6036 }
6037
6038 /* Handle an "alias" attribute; arguments as in
6039    struct attribute_spec.handler.  */
6040
6041 static tree
6042 handle_alias_attribute (tree *node, tree name, tree args,
6043                         int ARG_UNUSED (flags), bool *no_add_attrs)
6044 {
6045   tree decl = *node;
6046
6047   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
6048       || (TREE_CODE (decl) != FUNCTION_DECL
6049           && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
6050       /* A static variable declaration is always a tentative definition,
6051          but the alias is a non-tentative definition which overrides.  */
6052       || (TREE_CODE (decl) != FUNCTION_DECL
6053           && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
6054     {
6055       error ("%q+D defined both normally and as an alias", decl);
6056       *no_add_attrs = true;
6057     }
6058
6059   /* Note that the very first time we process a nested declaration,
6060      decl_function_context will not be set.  Indeed, *would* never
6061      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
6062      we do below.  After such frobbery, pushdecl would set the context.
6063      In any case, this is never what we want.  */
6064   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
6065     {
6066       tree id;
6067
6068       id = TREE_VALUE (args);
6069       if (TREE_CODE (id) != STRING_CST)
6070         {
6071           error ("alias argument not a string");
6072           *no_add_attrs = true;
6073           return NULL_TREE;
6074         }
6075       id = get_identifier (TREE_STRING_POINTER (id));
6076       /* This counts as a use of the object pointed to.  */
6077       TREE_USED (id) = 1;
6078
6079       if (TREE_CODE (decl) == FUNCTION_DECL)
6080         DECL_INITIAL (decl) = error_mark_node;
6081       else
6082         {
6083           if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
6084             DECL_EXTERNAL (decl) = 1;
6085           else
6086             DECL_EXTERNAL (decl) = 0;
6087           TREE_STATIC (decl) = 1;
6088         }
6089     }
6090   else
6091     {
6092       warning (OPT_Wattributes, "%qE attribute ignored", name);
6093       *no_add_attrs = true;
6094     }
6095
6096   return NULL_TREE;
6097 }
6098
6099 /* Handle a "weakref" attribute; arguments as in struct
6100    attribute_spec.handler.  */
6101
6102 static tree
6103 handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6104                           int flags, bool *no_add_attrs)
6105 {
6106   tree attr = NULL_TREE;
6107
6108   /* We must ignore the attribute when it is associated with
6109      local-scoped decls, since attribute alias is ignored and many
6110      such symbols do not even have a DECL_WEAK field.  */
6111   if (decl_function_context (*node)
6112       || current_function_decl
6113       || (TREE_CODE (*node) != VAR_DECL && TREE_CODE (*node) != FUNCTION_DECL))
6114     {
6115       warning (OPT_Wattributes, "%qE attribute ignored", name);
6116       *no_add_attrs = true;
6117       return NULL_TREE;
6118     }
6119
6120   /* The idea here is that `weakref("name")' mutates into `weakref,
6121      alias("name")', and weakref without arguments, in turn,
6122      implicitly adds weak. */
6123
6124   if (args)
6125     {
6126       attr = tree_cons (get_identifier ("alias"), args, attr);
6127       attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
6128
6129       *no_add_attrs = true;
6130
6131       decl_attributes (node, attr, flags);
6132     }
6133   else
6134     {
6135       if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
6136         error ("%Jweakref attribute must appear before alias attribute",
6137                *node);
6138
6139       /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
6140          and that isn't supported; and because it wants to add it to
6141          the list of weak decls, which isn't helpful.  */
6142       DECL_WEAK (*node) = 1;
6143     }
6144
6145   return NULL_TREE;
6146 }
6147
6148 /* Handle an "visibility" attribute; arguments as in
6149    struct attribute_spec.handler.  */
6150
6151 static tree
6152 handle_visibility_attribute (tree *node, tree name, tree args,
6153                              int ARG_UNUSED (flags),
6154                              bool *ARG_UNUSED (no_add_attrs))
6155 {
6156   tree decl = *node;
6157   tree id = TREE_VALUE (args);
6158   enum symbol_visibility vis;
6159
6160   if (TYPE_P (*node))
6161     {
6162       if (TREE_CODE (*node) == ENUMERAL_TYPE)
6163         /* OK */;
6164       else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
6165         {
6166           warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
6167                    name);
6168           return NULL_TREE;
6169         }
6170       else if (TYPE_FIELDS (*node))
6171         {
6172           error ("%qE attribute ignored because %qT is already defined",
6173                  name, *node);
6174           return NULL_TREE;
6175         }
6176     }
6177   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
6178     {
6179       warning (OPT_Wattributes, "%qE attribute ignored", name);
6180       return NULL_TREE;
6181     }
6182
6183   if (TREE_CODE (id) != STRING_CST)
6184     {
6185       error ("visibility argument not a string");
6186       return NULL_TREE;
6187     }
6188
6189   /*  If this is a type, set the visibility on the type decl.  */
6190   if (TYPE_P (decl))
6191     {
6192       decl = TYPE_NAME (decl);
6193       if (!decl)
6194         return NULL_TREE;
6195       if (TREE_CODE (decl) == IDENTIFIER_NODE)
6196         {
6197            warning (OPT_Wattributes, "%qE attribute ignored on types",
6198                     name);
6199            return NULL_TREE;
6200         }
6201     }
6202
6203   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
6204     vis = VISIBILITY_DEFAULT;
6205   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
6206     vis = VISIBILITY_INTERNAL;
6207   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
6208     vis = VISIBILITY_HIDDEN;
6209   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
6210     vis = VISIBILITY_PROTECTED;
6211   else
6212     {
6213       error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
6214       vis = VISIBILITY_DEFAULT;
6215     }
6216
6217   if (DECL_VISIBILITY_SPECIFIED (decl)
6218       && vis != DECL_VISIBILITY (decl))
6219     {
6220       tree attributes = (TYPE_P (*node)
6221                          ? TYPE_ATTRIBUTES (*node)
6222                          : DECL_ATTRIBUTES (decl));
6223       if (lookup_attribute ("visibility", attributes))
6224         error ("%qD redeclared with different visibility", decl);
6225       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6226                && lookup_attribute ("dllimport", attributes))
6227         error ("%qD was declared %qs which implies default visibility",
6228                decl, "dllimport");
6229       else if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6230                && lookup_attribute ("dllexport", attributes))
6231         error ("%qD was declared %qs which implies default visibility",
6232                decl, "dllexport");
6233     }
6234
6235   DECL_VISIBILITY (decl) = vis;
6236   DECL_VISIBILITY_SPECIFIED (decl) = 1;
6237
6238   /* Go ahead and attach the attribute to the node as well.  This is needed
6239      so we can determine whether we have VISIBILITY_DEFAULT because the
6240      visibility was not specified, or because it was explicitly overridden
6241      from the containing scope.  */
6242
6243   return NULL_TREE;
6244 }
6245
6246 /* Determine the ELF symbol visibility for DECL, which is either a
6247    variable or a function.  It is an error to use this function if a
6248    definition of DECL is not available in this translation unit.
6249    Returns true if the final visibility has been determined by this
6250    function; false if the caller is free to make additional
6251    modifications.  */
6252
6253 bool
6254 c_determine_visibility (tree decl)
6255 {
6256   gcc_assert (TREE_CODE (decl) == VAR_DECL
6257               || TREE_CODE (decl) == FUNCTION_DECL);
6258
6259   /* If the user explicitly specified the visibility with an
6260      attribute, honor that.  DECL_VISIBILITY will have been set during
6261      the processing of the attribute.  We check for an explicit
6262      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
6263      to distinguish the use of an attribute from the use of a "#pragma
6264      GCC visibility push(...)"; in the latter case we still want other
6265      considerations to be able to overrule the #pragma.  */
6266   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))
6267       || (TARGET_DLLIMPORT_DECL_ATTRIBUTES
6268           && (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl))
6269               || lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))))
6270     return true;
6271
6272   /* Set default visibility to whatever the user supplied with
6273      visibility_specified depending on #pragma GCC visibility.  */
6274   if (!DECL_VISIBILITY_SPECIFIED (decl))
6275     {
6276       DECL_VISIBILITY (decl) = default_visibility;
6277       DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
6278     }
6279   return false;
6280 }
6281
6282 /* Handle an "tls_model" attribute; arguments as in
6283    struct attribute_spec.handler.  */
6284
6285 static tree
6286 handle_tls_model_attribute (tree *node, tree name, tree args,
6287                             int ARG_UNUSED (flags), bool *no_add_attrs)
6288 {
6289   tree id;
6290   tree decl = *node;
6291   enum tls_model kind;
6292
6293   *no_add_attrs = true;
6294
6295   if (!DECL_THREAD_LOCAL_P (decl))
6296     {
6297       warning (OPT_Wattributes, "%qE attribute ignored", name);
6298       return NULL_TREE;
6299     }
6300
6301   kind = DECL_TLS_MODEL (decl);
6302   id = TREE_VALUE (args);
6303   if (TREE_CODE (id) != STRING_CST)
6304     {
6305       error ("tls_model argument not a string");
6306       return NULL_TREE;
6307     }
6308
6309   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
6310     kind = TLS_MODEL_LOCAL_EXEC;
6311   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
6312     kind = TLS_MODEL_INITIAL_EXEC;
6313   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
6314     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
6315   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
6316     kind = TLS_MODEL_GLOBAL_DYNAMIC;
6317   else
6318     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
6319
6320   DECL_TLS_MODEL (decl) = kind;
6321   return NULL_TREE;
6322 }
6323
6324 /* Handle a "no_instrument_function" attribute; arguments as in
6325    struct attribute_spec.handler.  */
6326
6327 static tree
6328 handle_no_instrument_function_attribute (tree *node, tree name,
6329                                          tree ARG_UNUSED (args),
6330                                          int ARG_UNUSED (flags),
6331                                          bool *no_add_attrs)
6332 {
6333   tree decl = *node;
6334
6335   if (TREE_CODE (decl) != FUNCTION_DECL)
6336     {
6337       error ("%J%qE attribute applies only to functions", decl, name);
6338       *no_add_attrs = true;
6339     }
6340   else if (DECL_INITIAL (decl))
6341     {
6342       error ("%Jcan%'t set %qE attribute after definition", decl, name);
6343       *no_add_attrs = true;
6344     }
6345   else
6346     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
6347
6348   return NULL_TREE;
6349 }
6350
6351 /* Handle a "malloc" attribute; arguments as in
6352    struct attribute_spec.handler.  */
6353
6354 static tree
6355 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6356                          int ARG_UNUSED (flags), bool *no_add_attrs)
6357 {
6358   if (TREE_CODE (*node) == FUNCTION_DECL
6359       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
6360     DECL_IS_MALLOC (*node) = 1;
6361   else
6362     {
6363       warning (OPT_Wattributes, "%qE attribute ignored", name);
6364       *no_add_attrs = true;
6365     }
6366
6367   return NULL_TREE;
6368 }
6369
6370 /* Handle a "alloc_size" attribute; arguments as in
6371    struct attribute_spec.handler.  */
6372
6373 static tree
6374 handle_alloc_size_attribute (tree *node, tree ARG_UNUSED (name), tree args,
6375                              int ARG_UNUSED (flags), bool *no_add_attrs)
6376 {
6377   unsigned arg_count = type_num_arguments (*node);
6378   for (; args; args = TREE_CHAIN (args))
6379     {
6380       tree position = TREE_VALUE (args);
6381
6382       if (TREE_CODE (position) != INTEGER_CST
6383           || TREE_INT_CST_HIGH (position)
6384           || TREE_INT_CST_LOW (position) < 1
6385           || TREE_INT_CST_LOW (position) > arg_count )
6386         {
6387           warning (OPT_Wattributes,
6388                    "alloc_size parameter outside range");
6389           *no_add_attrs = true;
6390           return NULL_TREE;
6391         }
6392     }
6393   return NULL_TREE;
6394 }
6395
6396 /* Handle a "returns_twice" attribute; arguments as in
6397    struct attribute_spec.handler.  */
6398
6399 static tree
6400 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6401                          int ARG_UNUSED (flags), bool *no_add_attrs)
6402 {
6403   if (TREE_CODE (*node) == FUNCTION_DECL)
6404     DECL_IS_RETURNS_TWICE (*node) = 1;
6405   else
6406     {
6407       warning (OPT_Wattributes, "%qE attribute ignored", name);
6408       *no_add_attrs = true;
6409     }
6410
6411   return NULL_TREE;
6412 }
6413
6414 /* Handle a "no_limit_stack" attribute; arguments as in
6415    struct attribute_spec.handler.  */
6416
6417 static tree
6418 handle_no_limit_stack_attribute (tree *node, tree name,
6419                                  tree ARG_UNUSED (args),
6420                                  int ARG_UNUSED (flags),
6421                                  bool *no_add_attrs)
6422 {
6423   tree decl = *node;
6424
6425   if (TREE_CODE (decl) != FUNCTION_DECL)
6426     {
6427       error ("%J%qE attribute applies only to functions", decl, name);
6428       *no_add_attrs = true;
6429     }
6430   else if (DECL_INITIAL (decl))
6431     {
6432       error ("%Jcan%'t set %qE attribute after definition", decl, name);
6433       *no_add_attrs = true;
6434     }
6435   else
6436     DECL_NO_LIMIT_STACK (decl) = 1;
6437
6438   return NULL_TREE;
6439 }
6440
6441 /* Handle a "pure" attribute; arguments as in
6442    struct attribute_spec.handler.  */
6443
6444 static tree
6445 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6446                        int ARG_UNUSED (flags), bool *no_add_attrs)
6447 {
6448   if (TREE_CODE (*node) == FUNCTION_DECL)
6449     DECL_PURE_P (*node) = 1;
6450   /* ??? TODO: Support types.  */
6451   else
6452     {
6453       warning (OPT_Wattributes, "%qE attribute ignored", name);
6454       *no_add_attrs = true;
6455     }
6456
6457   return NULL_TREE;
6458 }
6459
6460 /* Handle a "no vops" attribute; arguments as in
6461    struct attribute_spec.handler.  */
6462
6463 static tree
6464 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
6465                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6466                          bool *ARG_UNUSED (no_add_attrs))
6467 {
6468   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
6469   DECL_IS_NOVOPS (*node) = 1;
6470   return NULL_TREE;
6471 }
6472
6473 /* Handle a "deprecated" attribute; arguments as in
6474    struct attribute_spec.handler.  */
6475
6476 static tree
6477 handle_deprecated_attribute (tree *node, tree name,
6478                              tree ARG_UNUSED (args), int flags,
6479                              bool *no_add_attrs)
6480 {
6481   tree type = NULL_TREE;
6482   int warn = 0;
6483   tree what = NULL_TREE;
6484
6485   if (DECL_P (*node))
6486     {
6487       tree decl = *node;
6488       type = TREE_TYPE (decl);
6489
6490       if (TREE_CODE (decl) == TYPE_DECL
6491           || TREE_CODE (decl) == PARM_DECL
6492           || TREE_CODE (decl) == VAR_DECL
6493           || TREE_CODE (decl) == FUNCTION_DECL
6494           || TREE_CODE (decl) == FIELD_DECL)
6495         TREE_DEPRECATED (decl) = 1;
6496       else
6497         warn = 1;
6498     }
6499   else if (TYPE_P (*node))
6500     {
6501       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
6502         *node = build_variant_type_copy (*node);
6503       TREE_DEPRECATED (*node) = 1;
6504       type = *node;
6505     }
6506   else
6507     warn = 1;
6508
6509   if (warn)
6510     {
6511       *no_add_attrs = true;
6512       if (type && TYPE_NAME (type))
6513         {
6514           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
6515             what = TYPE_NAME (*node);
6516           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6517                    && DECL_NAME (TYPE_NAME (type)))
6518             what = DECL_NAME (TYPE_NAME (type));
6519         }
6520       if (what)
6521         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
6522       else
6523         warning (OPT_Wattributes, "%qE attribute ignored", name);
6524     }
6525
6526   return NULL_TREE;
6527 }
6528
6529 /* Handle a "vector_size" attribute; arguments as in
6530    struct attribute_spec.handler.  */
6531
6532 static tree
6533 handle_vector_size_attribute (tree *node, tree name, tree args,
6534                               int ARG_UNUSED (flags),
6535                               bool *no_add_attrs)
6536 {
6537   unsigned HOST_WIDE_INT vecsize, nunits;
6538   enum machine_mode orig_mode;
6539   tree type = *node, new_type, size;
6540
6541   *no_add_attrs = true;
6542
6543   size = TREE_VALUE (args);
6544
6545   if (!host_integerp (size, 1))
6546     {
6547       warning (OPT_Wattributes, "%qE attribute ignored", name);
6548       return NULL_TREE;
6549     }
6550
6551   /* Get the vector size (in bytes).  */
6552   vecsize = tree_low_cst (size, 1);
6553
6554   /* We need to provide for vector pointers, vector arrays, and
6555      functions returning vectors.  For example:
6556
6557        __attribute__((vector_size(16))) short *foo;
6558
6559      In this case, the mode is SI, but the type being modified is
6560      HI, so we need to look further.  */
6561
6562   while (POINTER_TYPE_P (type)
6563          || TREE_CODE (type) == FUNCTION_TYPE
6564          || TREE_CODE (type) == METHOD_TYPE
6565          || TREE_CODE (type) == ARRAY_TYPE
6566          || TREE_CODE (type) == OFFSET_TYPE)
6567     type = TREE_TYPE (type);
6568
6569   /* Get the mode of the type being modified.  */
6570   orig_mode = TYPE_MODE (type);
6571
6572   if ((!INTEGRAL_TYPE_P (type)
6573        && !SCALAR_FLOAT_TYPE_P (type)
6574        && !FIXED_POINT_TYPE_P (type))
6575       || (!SCALAR_FLOAT_MODE_P (orig_mode)
6576           && GET_MODE_CLASS (orig_mode) != MODE_INT
6577           && !ALL_SCALAR_FIXED_POINT_MODE_P (orig_mode))
6578       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
6579     {
6580       error ("invalid vector type for attribute %qE", name);
6581       return NULL_TREE;
6582     }
6583
6584   if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
6585     {
6586       error ("vector size not an integral multiple of component size");
6587       return NULL;
6588     }
6589
6590   if (vecsize == 0)
6591     {
6592       error ("zero vector size");
6593       return NULL;
6594     }
6595
6596   /* Calculate how many units fit in the vector.  */
6597   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6598   if (nunits & (nunits - 1))
6599     {
6600       error ("number of components of the vector not a power of two");
6601       return NULL_TREE;
6602     }
6603
6604   new_type = build_vector_type (type, nunits);
6605
6606   /* Build back pointers if needed.  */
6607   *node = lang_hooks.types.reconstruct_complex_type (*node, new_type);
6608
6609   return NULL_TREE;
6610 }
6611
6612 /* Handle the "nonnull" attribute.  */
6613 static tree
6614 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
6615                           tree args, int ARG_UNUSED (flags),
6616                           bool *no_add_attrs)
6617 {
6618   tree type = *node;
6619   unsigned HOST_WIDE_INT attr_arg_num;
6620
6621   /* If no arguments are specified, all pointer arguments should be
6622      non-null.  Verify a full prototype is given so that the arguments
6623      will have the correct types when we actually check them later.  */
6624   if (!args)
6625     {
6626       if (!TYPE_ARG_TYPES (type))
6627         {
6628           error ("nonnull attribute without arguments on a non-prototype");
6629           *no_add_attrs = true;
6630         }
6631       return NULL_TREE;
6632     }
6633
6634   /* Argument list specified.  Verify that each argument number references
6635      a pointer argument.  */
6636   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
6637     {
6638       tree argument;
6639       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
6640
6641       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
6642         {
6643           error ("nonnull argument has invalid operand number (argument %lu)",
6644                  (unsigned long) attr_arg_num);
6645           *no_add_attrs = true;
6646           return NULL_TREE;
6647         }
6648
6649       argument = TYPE_ARG_TYPES (type);
6650       if (argument)
6651         {
6652           for (ck_num = 1; ; ck_num++)
6653             {
6654               if (!argument || ck_num == arg_num)
6655                 break;
6656               argument = TREE_CHAIN (argument);
6657             }
6658
6659           if (!argument
6660               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
6661             {
6662               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
6663                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
6664               *no_add_attrs = true;
6665               return NULL_TREE;
6666             }
6667
6668           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
6669             {
6670               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
6671                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
6672               *no_add_attrs = true;
6673               return NULL_TREE;
6674             }
6675         }
6676     }
6677
6678   return NULL_TREE;
6679 }
6680
6681 /* Check the argument list of a function call for null in argument slots
6682    that are marked as requiring a non-null pointer argument.  The NARGS
6683    arguments are passed in the array ARGARRAY.
6684 */
6685
6686 static void
6687 check_function_nonnull (tree attrs, int nargs, tree *argarray)
6688 {
6689   tree a, args;
6690   int i;
6691
6692   for (a = attrs; a; a = TREE_CHAIN (a))
6693     {
6694       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
6695         {
6696           args = TREE_VALUE (a);
6697
6698           /* Walk the argument list.  If we encounter an argument number we
6699              should check for non-null, do it.  If the attribute has no args,
6700              then every pointer argument is checked (in which case the check
6701              for pointer type is done in check_nonnull_arg).  */
6702           for (i = 0; i < nargs; i++)
6703             {
6704               if (!args || nonnull_check_p (args, i + 1))
6705                 check_function_arguments_recurse (check_nonnull_arg, NULL,
6706                                                   argarray[i],
6707                                                   i + 1);
6708             }
6709         }
6710     }
6711 }
6712
6713 /* Check that the Nth argument of a function call (counting backwards
6714    from the end) is a (pointer)0.  The NARGS arguments are passed in the
6715    array ARGARRAY.  */
6716
6717 static void
6718 check_function_sentinel (tree attrs, int nargs, tree *argarray, tree typelist)
6719 {
6720   tree attr = lookup_attribute ("sentinel", attrs);
6721
6722   if (attr)
6723     {
6724       int len = 0;
6725       int pos = 0;
6726       tree sentinel;
6727
6728       /* Skip over the named arguments.  */
6729       while (typelist && len < nargs)
6730         {
6731           typelist = TREE_CHAIN (typelist);
6732           len++;
6733         }
6734
6735       if (TREE_VALUE (attr))
6736         {
6737           tree p = TREE_VALUE (TREE_VALUE (attr));
6738           pos = TREE_INT_CST_LOW (p);
6739         }
6740
6741       /* The sentinel must be one of the varargs, i.e.
6742          in position >= the number of fixed arguments.  */
6743       if ((nargs - 1 - pos) < len)
6744         {
6745           warning (OPT_Wformat,
6746                    "not enough variable arguments to fit a sentinel");
6747           return;
6748         }
6749
6750       /* Validate the sentinel.  */
6751       sentinel = argarray[nargs - 1 - pos];
6752       if ((!POINTER_TYPE_P (TREE_TYPE (sentinel))
6753            || !integer_zerop (sentinel))
6754           /* Although __null (in C++) is only an integer we allow it
6755              nevertheless, as we are guaranteed that it's exactly
6756              as wide as a pointer, and we don't want to force
6757              users to cast the NULL they have written there.
6758              We warn with -Wstrict-null-sentinel, though.  */
6759           && (warn_strict_null_sentinel || null_node != sentinel))
6760         warning (OPT_Wformat, "missing sentinel in function call");
6761     }
6762 }
6763
6764 /* Helper for check_function_nonnull; given a list of operands which
6765    must be non-null in ARGS, determine if operand PARAM_NUM should be
6766    checked.  */
6767
6768 static bool
6769 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
6770 {
6771   unsigned HOST_WIDE_INT arg_num = 0;
6772
6773   for (; args; args = TREE_CHAIN (args))
6774     {
6775       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
6776
6777       gcc_assert (found);
6778
6779       if (arg_num == param_num)
6780         return true;
6781     }
6782   return false;
6783 }
6784
6785 /* Check that the function argument PARAM (which is operand number
6786    PARAM_NUM) is non-null.  This is called by check_function_nonnull
6787    via check_function_arguments_recurse.  */
6788
6789 static void
6790 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
6791                    unsigned HOST_WIDE_INT param_num)
6792 {
6793   /* Just skip checking the argument if it's not a pointer.  This can
6794      happen if the "nonnull" attribute was given without an operand
6795      list (which means to check every pointer argument).  */
6796
6797   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
6798     return;
6799
6800   if (integer_zerop (param))
6801     warning (OPT_Wnonnull, "null argument where non-null required "
6802              "(argument %lu)", (unsigned long) param_num);
6803 }
6804
6805 /* Helper for nonnull attribute handling; fetch the operand number
6806    from the attribute argument list.  */
6807
6808 static bool
6809 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
6810 {
6811   /* Verify the arg number is a constant.  */
6812   if (TREE_CODE (arg_num_expr) != INTEGER_CST
6813       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
6814     return false;
6815
6816   *valp = TREE_INT_CST_LOW (arg_num_expr);
6817   return true;
6818 }
6819
6820 /* Handle a "nothrow" attribute; arguments as in
6821    struct attribute_spec.handler.  */
6822
6823 static tree
6824 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
6825                           int ARG_UNUSED (flags), bool *no_add_attrs)
6826 {
6827   if (TREE_CODE (*node) == FUNCTION_DECL)
6828     TREE_NOTHROW (*node) = 1;
6829   /* ??? TODO: Support types.  */
6830   else
6831     {
6832       warning (OPT_Wattributes, "%qE attribute ignored", name);
6833       *no_add_attrs = true;
6834     }
6835
6836   return NULL_TREE;
6837 }
6838
6839 /* Handle a "cleanup" attribute; arguments as in
6840    struct attribute_spec.handler.  */
6841
6842 static tree
6843 handle_cleanup_attribute (tree *node, tree name, tree args,
6844                           int ARG_UNUSED (flags), bool *no_add_attrs)
6845 {
6846   tree decl = *node;
6847   tree cleanup_id, cleanup_decl;
6848
6849   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
6850      for global destructors in C++.  This requires infrastructure that
6851      we don't have generically at the moment.  It's also not a feature
6852      we'd be missing too much, since we do have attribute constructor.  */
6853   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
6854     {
6855       warning (OPT_Wattributes, "%qE attribute ignored", name);
6856       *no_add_attrs = true;
6857       return NULL_TREE;
6858     }
6859
6860   /* Verify that the argument is a function in scope.  */
6861   /* ??? We could support pointers to functions here as well, if
6862      that was considered desirable.  */
6863   cleanup_id = TREE_VALUE (args);
6864   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
6865     {
6866       error ("cleanup argument not an identifier");
6867       *no_add_attrs = true;
6868       return NULL_TREE;
6869     }
6870   cleanup_decl = lookup_name (cleanup_id);
6871   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
6872     {
6873       error ("cleanup argument not a function");
6874       *no_add_attrs = true;
6875       return NULL_TREE;
6876     }
6877
6878   /* That the function has proper type is checked with the
6879      eventual call to build_function_call.  */
6880
6881   return NULL_TREE;
6882 }
6883
6884 /* Handle a "warn_unused_result" attribute.  No special handling.  */
6885
6886 static tree
6887 handle_warn_unused_result_attribute (tree *node, tree name,
6888                                tree ARG_UNUSED (args),
6889                                int ARG_UNUSED (flags), bool *no_add_attrs)
6890 {
6891   /* Ignore the attribute for functions not returning any value.  */
6892   if (VOID_TYPE_P (TREE_TYPE (*node)))
6893     {
6894       warning (OPT_Wattributes, "%qE attribute ignored", name);
6895       *no_add_attrs = true;
6896     }
6897
6898   return NULL_TREE;
6899 }
6900
6901 /* Handle a "sentinel" attribute.  */
6902
6903 static tree
6904 handle_sentinel_attribute (tree *node, tree name, tree args,
6905                            int ARG_UNUSED (flags), bool *no_add_attrs)
6906 {
6907   tree params = TYPE_ARG_TYPES (*node);
6908
6909   if (!params)
6910     {
6911       warning (OPT_Wattributes,
6912                "%qE attribute requires prototypes with named arguments", name);
6913       *no_add_attrs = true;
6914     }
6915   else
6916     {
6917       while (TREE_CHAIN (params))
6918         params = TREE_CHAIN (params);
6919
6920       if (VOID_TYPE_P (TREE_VALUE (params)))
6921         {
6922           warning (OPT_Wattributes,
6923                    "%qE attribute only applies to variadic functions", name);
6924           *no_add_attrs = true;
6925         }
6926     }
6927
6928   if (args)
6929     {
6930       tree position = TREE_VALUE (args);
6931
6932       if (TREE_CODE (position) != INTEGER_CST)
6933         {
6934           warning (OPT_Wattributes,
6935                    "requested position is not an integer constant");
6936           *no_add_attrs = true;
6937         }
6938       else
6939         {
6940           if (tree_int_cst_lt (position, integer_zero_node))
6941             {
6942               warning (OPT_Wattributes,
6943                        "requested position is less than zero");
6944               *no_add_attrs = true;
6945             }
6946         }
6947     }
6948
6949   return NULL_TREE;
6950 }
6951
6952 /* Handle a "type_generic" attribute.  */
6953
6954 static tree
6955 handle_type_generic_attribute (tree *node, tree ARG_UNUSED (name),
6956                                tree ARG_UNUSED (args), int ARG_UNUSED (flags),
6957                                bool * ARG_UNUSED (no_add_attrs))
6958 {
6959   tree params;
6960
6961   /* Ensure we have a function type.  */
6962   gcc_assert (TREE_CODE (*node) == FUNCTION_TYPE);
6963
6964   params = TYPE_ARG_TYPES (*node);
6965   while (params && ! VOID_TYPE_P (TREE_VALUE (params)))
6966     params = TREE_CHAIN (params);
6967
6968   /* Ensure we have a variadic function.  */
6969   gcc_assert (!params);
6970
6971   return NULL_TREE;
6972 }
6973
6974 /* Handle a "target" attribute.  */
6975
6976 static tree
6977 handle_target_attribute (tree *node, tree name, tree args, int flags,
6978                          bool *no_add_attrs)
6979 {
6980   /* Ensure we have a function type.  */
6981   if (TREE_CODE (*node) != FUNCTION_DECL)
6982     {
6983       warning (OPT_Wattributes, "%qE attribute ignored", name);
6984       *no_add_attrs = true;
6985     }
6986   else if (! targetm.target_option.valid_attribute_p (*node, name, args,
6987                                                       flags))
6988     *no_add_attrs = true;
6989
6990   return NULL_TREE;
6991 }
6992
6993 /* Arguments being collected for optimization.  */
6994 typedef const char *const_char_p;               /* For DEF_VEC_P.  */
6995 DEF_VEC_P(const_char_p);
6996 DEF_VEC_ALLOC_P(const_char_p, gc);
6997 static GTY(()) VEC(const_char_p, gc) *optimize_args;
6998
6999
7000 /* Inner function to convert a TREE_LIST to argv string to parse the optimize
7001    options in ARGS.  ATTR_P is true if this is for attribute(optimize), and
7002    false for #pragma GCC optimize.  */
7003
7004 bool
7005 parse_optimize_options (tree args, bool attr_p)
7006 {
7007   bool ret = true;
7008   unsigned opt_argc;
7009   unsigned i;
7010   const char **opt_argv;
7011   tree ap;
7012
7013   /* Build up argv vector.  Just in case the string is stored away, use garbage
7014      collected strings.  */
7015   VEC_truncate (const_char_p, optimize_args, 0);
7016   VEC_safe_push (const_char_p, gc, optimize_args, NULL);
7017
7018   for (ap = args; ap != NULL_TREE; ap = TREE_CHAIN (ap))
7019     {
7020       tree value = TREE_VALUE (ap);
7021
7022       if (TREE_CODE (value) == INTEGER_CST)
7023         {
7024           char buffer[20];
7025           sprintf (buffer, "-O%ld", (long) TREE_INT_CST_LOW (value));
7026           VEC_safe_push (const_char_p, gc, optimize_args, ggc_strdup (buffer));
7027         }
7028
7029       else if (TREE_CODE (value) == STRING_CST)
7030         {
7031           /* Split string into multiple substrings.  */
7032           size_t len = TREE_STRING_LENGTH (value);
7033           char *p = ASTRDUP (TREE_STRING_POINTER (value));
7034           char *end = p + len;
7035           char *comma;
7036           char *next_p = p;
7037
7038           while (next_p != NULL)
7039             {
7040               size_t len2;
7041               char *q, *r;
7042
7043               p = next_p;
7044               comma = strchr (p, ',');
7045               if (comma)
7046                 {
7047                   len2 = comma - p;
7048                   *comma = '\0';
7049                   next_p = comma+1;
7050                 }
7051               else
7052                 {
7053                   len2 = end - p;
7054                   next_p = NULL;
7055                 }
7056
7057               r = q = (char *) ggc_alloc (len2 + 3);
7058
7059               /* If the user supplied -Oxxx or -fxxx, only allow -Oxxx or -fxxx
7060                  options.  */
7061               if (*p == '-' && p[1] != 'O' && p[1] != 'f')
7062                 {
7063                   ret = false;
7064                   if (attr_p)
7065                     warning (OPT_Wattributes,
7066                              "Bad option %s to optimize attribute.", p);
7067                   else
7068                     warning (OPT_Wpragmas,
7069                              "Bad option %s to pragma attribute", p);
7070                   continue;
7071                 }
7072
7073               if (*p != '-')
7074                 {
7075                   *r++ = '-';
7076
7077                   /* Assume that Ox is -Ox, a numeric value is -Ox, a s by
7078                      itself is -Os, and any other switch begins with a -f.  */
7079                   if ((*p >= '0' && *p <= '9')
7080                       || (p[0] == 's' && p[1] == '\0'))
7081                     *r++ = 'O';
7082                   else if (*p != 'O')
7083                     *r++ = 'f';
7084                 }
7085
7086               memcpy (r, p, len2);
7087               r[len2] = '\0';
7088               VEC_safe_push (const_char_p, gc, optimize_args, q);
7089             }
7090
7091         }
7092     }
7093
7094   opt_argc = VEC_length (const_char_p, optimize_args);
7095   opt_argv = (const char **) alloca (sizeof (char *) * (opt_argc + 1));
7096
7097   for (i = 1; i < opt_argc; i++)
7098     opt_argv[i] = VEC_index (const_char_p, optimize_args, i);
7099
7100   /* Now parse the options.  */
7101   decode_options (opt_argc, opt_argv);
7102
7103   VEC_truncate (const_char_p, optimize_args, 0);
7104   return ret;
7105 }
7106
7107 /* For handling "optimize" attribute. arguments as in
7108    struct attribute_spec.handler.  */
7109
7110 static tree
7111 handle_optimize_attribute (tree *node, tree name, tree args,
7112                            int ARG_UNUSED (flags), bool *no_add_attrs)
7113 {
7114   /* Ensure we have a function type.  */
7115   if (TREE_CODE (*node) != FUNCTION_DECL)
7116     {
7117       warning (OPT_Wattributes, "%qE attribute ignored", name);
7118       *no_add_attrs = true;
7119     }
7120   else
7121     {
7122       struct cl_optimization cur_opts;
7123       tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
7124
7125       /* Save current options.  */
7126       cl_optimization_save (&cur_opts);
7127
7128       /* If we previously had some optimization options, use them as the
7129          default.  */
7130       if (old_opts)
7131         cl_optimization_restore (TREE_OPTIMIZATION (old_opts));
7132
7133       /* Parse options, and update the vector.  */
7134       parse_optimize_options (args, true);
7135       DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
7136         = build_optimization_node ();
7137
7138       /* Restore current options.  */
7139       cl_optimization_restore (&cur_opts);
7140     }
7141
7142   return NULL_TREE;
7143 }
7144 \f
7145 /* Check for valid arguments being passed to a function.
7146    ATTRS is a list of attributes.  There are NARGS arguments in the array
7147    ARGARRAY.  TYPELIST is the list of argument types for the function.
7148  */
7149 void
7150 check_function_arguments (tree attrs, int nargs, tree *argarray, tree typelist)
7151 {
7152   /* Check for null being passed in a pointer argument that must be
7153      non-null.  We also need to do this if format checking is enabled.  */
7154
7155   if (warn_nonnull)
7156     check_function_nonnull (attrs, nargs, argarray);
7157
7158   /* Check for errors in format strings.  */
7159
7160   if (warn_format || warn_missing_format_attribute)
7161     check_function_format (attrs, nargs, argarray);
7162
7163   if (warn_format)
7164     check_function_sentinel (attrs, nargs, argarray, typelist);
7165 }
7166
7167 /* Generic argument checking recursion routine.  PARAM is the argument to
7168    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
7169    once the argument is resolved.  CTX is context for the callback.  */
7170 void
7171 check_function_arguments_recurse (void (*callback)
7172                                   (void *, tree, unsigned HOST_WIDE_INT),
7173                                   void *ctx, tree param,
7174                                   unsigned HOST_WIDE_INT param_num)
7175 {
7176   if (CONVERT_EXPR_P (param)
7177       && (TYPE_PRECISION (TREE_TYPE (param))
7178           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
7179     {
7180       /* Strip coercion.  */
7181       check_function_arguments_recurse (callback, ctx,
7182                                         TREE_OPERAND (param, 0), param_num);
7183       return;
7184     }
7185
7186   if (TREE_CODE (param) == CALL_EXPR)
7187     {
7188       tree type = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (param)));
7189       tree attrs;
7190       bool found_format_arg = false;
7191
7192       /* See if this is a call to a known internationalization function
7193          that modifies a format arg.  Such a function may have multiple
7194          format_arg attributes (for example, ngettext).  */
7195
7196       for (attrs = TYPE_ATTRIBUTES (type);
7197            attrs;
7198            attrs = TREE_CHAIN (attrs))
7199         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
7200           {
7201             tree inner_arg;
7202             tree format_num_expr;
7203             int format_num;
7204             int i;
7205             call_expr_arg_iterator iter;
7206
7207             /* Extract the argument number, which was previously checked
7208                to be valid.  */
7209             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
7210
7211             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
7212                         && !TREE_INT_CST_HIGH (format_num_expr));
7213
7214             format_num = TREE_INT_CST_LOW (format_num_expr);
7215
7216             for (inner_arg = first_call_expr_arg (param, &iter), i = 1;
7217                  inner_arg != 0;
7218                  inner_arg = next_call_expr_arg (&iter), i++)
7219               if (i == format_num)
7220                 {
7221                   check_function_arguments_recurse (callback, ctx,
7222                                                     inner_arg, param_num);
7223                   found_format_arg = true;
7224                   break;
7225                 }
7226           }
7227
7228       /* If we found a format_arg attribute and did a recursive check,
7229          we are done with checking this argument.  Otherwise, we continue
7230          and this will be considered a non-literal.  */
7231       if (found_format_arg)
7232         return;
7233     }
7234
7235   if (TREE_CODE (param) == COND_EXPR)
7236     {
7237       /* Check both halves of the conditional expression.  */
7238       check_function_arguments_recurse (callback, ctx,
7239                                         TREE_OPERAND (param, 1), param_num);
7240       check_function_arguments_recurse (callback, ctx,
7241                                         TREE_OPERAND (param, 2), param_num);
7242       return;
7243     }
7244
7245   (*callback) (ctx, param, param_num);
7246 }
7247
7248 /* Checks the number of arguments NARGS against the required number
7249    REQUIRED and issues an error if there is a mismatch.  Returns true
7250    if the number of arguments is correct, otherwise false.  */
7251
7252 static bool
7253 validate_nargs (tree fndecl, int nargs, int required)
7254 {
7255   if (nargs < required)
7256     {
7257       error ("not enough arguments to function %qE", fndecl);
7258       return false;
7259     }
7260   else if (nargs > required)
7261     {
7262       error ("too many arguments to function %qE", fndecl);
7263       return false;
7264     }
7265   return true;
7266 }
7267
7268 /* Verifies the NARGS arguments ARGS to the builtin function FNDECL.
7269    Returns false if there was an error, otherwise true.  */
7270
7271 bool
7272 check_builtin_function_arguments (tree fndecl, int nargs, tree *args)
7273 {
7274   if (!DECL_BUILT_IN (fndecl)
7275       || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
7276     return true;
7277
7278   switch (DECL_FUNCTION_CODE (fndecl))
7279     {
7280     case BUILT_IN_CONSTANT_P:
7281       return validate_nargs (fndecl, nargs, 1);
7282
7283     case BUILT_IN_ISFINITE:
7284     case BUILT_IN_ISINF:
7285     case BUILT_IN_ISINF_SIGN:
7286     case BUILT_IN_ISNAN:
7287     case BUILT_IN_ISNORMAL:
7288       if (validate_nargs (fndecl, nargs, 1))
7289         {
7290           if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
7291             {
7292               error ("non-floating-point argument in call to "
7293                      "function %qE", fndecl);
7294               return false;
7295             }
7296           return true;
7297         }
7298       return false;
7299
7300     case BUILT_IN_ISGREATER:
7301     case BUILT_IN_ISGREATEREQUAL:
7302     case BUILT_IN_ISLESS:
7303     case BUILT_IN_ISLESSEQUAL:
7304     case BUILT_IN_ISLESSGREATER:
7305     case BUILT_IN_ISUNORDERED:
7306       if (validate_nargs (fndecl, nargs, 2))
7307         {
7308           enum tree_code code0, code1;
7309           code0 = TREE_CODE (TREE_TYPE (args[0]));
7310           code1 = TREE_CODE (TREE_TYPE (args[1]));
7311           if (!((code0 == REAL_TYPE && code1 == REAL_TYPE)
7312                 || (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7313                 || (code0 == INTEGER_TYPE && code1 == REAL_TYPE)))
7314             {
7315               error ("non-floating-point arguments in call to "
7316                      "function %qE", fndecl);
7317               return false;
7318             }
7319           return true;
7320         }
7321       return false;
7322
7323     case BUILT_IN_FPCLASSIFY:
7324       if (validate_nargs (fndecl, nargs, 6))
7325         {
7326           unsigned i;
7327
7328           for (i=0; i<5; i++)
7329             if (TREE_CODE (args[i]) != INTEGER_CST)
7330               {
7331                 error ("non-const integer argument %u in call to function %qE",
7332                        i+1, fndecl);
7333                 return false;
7334               }
7335
7336           if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
7337             {
7338               error ("non-floating-point argument in call to function %qE",
7339                      fndecl);
7340               return false;
7341             }
7342           return true;
7343         }
7344       return false;
7345
7346     default:
7347       return true;
7348     }
7349 }
7350
7351 /* Function to help qsort sort FIELD_DECLs by name order.  */
7352
7353 int
7354 field_decl_cmp (const void *x_p, const void *y_p)
7355 {
7356   const tree *const x = (const tree *const) x_p;
7357   const tree *const y = (const tree *const) y_p;
7358
7359   if (DECL_NAME (*x) == DECL_NAME (*y))
7360     /* A nontype is "greater" than a type.  */
7361     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7362   if (DECL_NAME (*x) == NULL_TREE)
7363     return -1;
7364   if (DECL_NAME (*y) == NULL_TREE)
7365     return 1;
7366   if (DECL_NAME (*x) < DECL_NAME (*y))
7367     return -1;
7368   return 1;
7369 }
7370
7371 static struct {
7372   gt_pointer_operator new_value;
7373   void *cookie;
7374 } resort_data;
7375
7376 /* This routine compares two fields like field_decl_cmp but using the
7377 pointer operator in resort_data.  */
7378
7379 static int
7380 resort_field_decl_cmp (const void *x_p, const void *y_p)
7381 {
7382   const tree *const x = (const tree *const) x_p;
7383   const tree *const y = (const tree *const) y_p;
7384
7385   if (DECL_NAME (*x) == DECL_NAME (*y))
7386     /* A nontype is "greater" than a type.  */
7387     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
7388   if (DECL_NAME (*x) == NULL_TREE)
7389     return -1;
7390   if (DECL_NAME (*y) == NULL_TREE)
7391     return 1;
7392   {
7393     tree d1 = DECL_NAME (*x);
7394     tree d2 = DECL_NAME (*y);
7395     resort_data.new_value (&d1, resort_data.cookie);
7396     resort_data.new_value (&d2, resort_data.cookie);
7397     if (d1 < d2)
7398       return -1;
7399   }
7400   return 1;
7401 }
7402
7403 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
7404
7405 void
7406 resort_sorted_fields (void *obj,
7407                       void * ARG_UNUSED (orig_obj),
7408                       gt_pointer_operator new_value,
7409                       void *cookie)
7410 {
7411   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
7412   resort_data.new_value = new_value;
7413   resort_data.cookie = cookie;
7414   qsort (&sf->elts[0], sf->len, sizeof (tree),
7415          resort_field_decl_cmp);
7416 }
7417
7418 /* Subroutine of c_parse_error.
7419    Return the result of concatenating LHS and RHS. RHS is really
7420    a string literal, its first character is indicated by RHS_START and
7421    RHS_SIZE is its length (including the terminating NUL character).
7422
7423    The caller is responsible for deleting the returned pointer.  */
7424
7425 static char *
7426 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
7427 {
7428   const int lhs_size = strlen (lhs);
7429   char *result = XNEWVEC (char, lhs_size + rhs_size);
7430   strncpy (result, lhs, lhs_size);
7431   strncpy (result + lhs_size, rhs_start, rhs_size);
7432   return result;
7433 }
7434
7435 /* Issue the error given by GMSGID, indicating that it occurred before
7436    TOKEN, which had the associated VALUE.  */
7437
7438 void
7439 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
7440 {
7441 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
7442
7443   char *message = NULL;
7444
7445   if (token == CPP_EOF)
7446     message = catenate_messages (gmsgid, " at end of input");
7447   else if (token == CPP_CHAR || token == CPP_WCHAR || token == CPP_CHAR16
7448            || token == CPP_CHAR32)
7449     {
7450       unsigned int val = TREE_INT_CST_LOW (value);
7451       const char *prefix;
7452
7453       switch (token)
7454         {
7455         default:
7456           prefix = "";
7457           break;
7458         case CPP_WCHAR:
7459           prefix = "L";
7460           break;
7461         case CPP_CHAR16:
7462           prefix = "u";
7463           break;
7464         case CPP_CHAR32:
7465           prefix = "U";
7466           break;
7467         }
7468
7469       if (val <= UCHAR_MAX && ISGRAPH (val))
7470         message = catenate_messages (gmsgid, " before %s'%c'");
7471       else
7472         message = catenate_messages (gmsgid, " before %s'\\x%x'");
7473
7474       error (message, prefix, val);
7475       free (message);
7476       message = NULL;
7477     }
7478   else if (token == CPP_STRING || token == CPP_WSTRING || token == CPP_STRING16
7479            || token == CPP_STRING32)
7480     message = catenate_messages (gmsgid, " before string constant");
7481   else if (token == CPP_NUMBER)
7482     message = catenate_messages (gmsgid, " before numeric constant");
7483   else if (token == CPP_NAME)
7484     {
7485       message = catenate_messages (gmsgid, " before %qE");
7486       error (message, value);
7487       free (message);
7488       message = NULL;
7489     }
7490   else if (token == CPP_PRAGMA)
7491     message = catenate_messages (gmsgid, " before %<#pragma%>");
7492   else if (token == CPP_PRAGMA_EOL)
7493     message = catenate_messages (gmsgid, " before end of line");
7494   else if (token < N_TTYPES)
7495     {
7496       message = catenate_messages (gmsgid, " before %qs token");
7497       error (message, cpp_type2name (token));
7498       free (message);
7499       message = NULL;
7500     }
7501   else
7502     error (gmsgid);
7503
7504   if (message)
7505     {
7506       error (message);
7507       free (message);
7508     }
7509 #undef catenate_messages
7510 }
7511
7512 /* Walk a gimplified function and warn for functions whose return value is
7513    ignored and attribute((warn_unused_result)) is set.  This is done before
7514    inlining, so we don't have to worry about that.  */
7515
7516 void
7517 c_warn_unused_result (gimple_seq seq)
7518 {
7519   tree fdecl, ftype;
7520   gimple_stmt_iterator i;
7521
7522   for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
7523     {
7524       gimple g = gsi_stmt (i);
7525
7526       switch (gimple_code (g))
7527         {
7528         case GIMPLE_BIND:
7529           c_warn_unused_result (gimple_bind_body (g));
7530           break;
7531         case GIMPLE_TRY:
7532           c_warn_unused_result (gimple_try_eval (g));
7533           c_warn_unused_result (gimple_try_cleanup (g));
7534           break;
7535         case GIMPLE_CATCH:
7536           c_warn_unused_result (gimple_catch_handler (g));
7537           break;
7538         case GIMPLE_EH_FILTER:
7539           c_warn_unused_result (gimple_eh_filter_failure (g));
7540           break;
7541
7542         case GIMPLE_CALL:
7543           if (gimple_call_lhs (g))
7544             break;
7545
7546           /* This is a naked call, as opposed to a GIMPLE_CALL with an
7547              LHS.  All calls whose value is ignored should be
7548              represented like this.  Look for the attribute.  */
7549           fdecl = gimple_call_fndecl (g);
7550           ftype = TREE_TYPE (TREE_TYPE (gimple_call_fn (g)));
7551
7552           if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
7553             {
7554               location_t loc = gimple_location (g);
7555
7556               if (fdecl)
7557                 warning (0, "%Hignoring return value of %qD, "
7558                          "declared with attribute warn_unused_result",
7559                          &loc, fdecl);
7560               else
7561                 warning (0, "%Hignoring return value of function "
7562                          "declared with attribute warn_unused_result",
7563                          &loc);
7564             }
7565           break;
7566
7567         default:
7568           /* Not a container, not a call, or a call whose value is used.  */
7569           break;
7570         }
7571     }
7572 }
7573
7574 /* Convert a character from the host to the target execution character
7575    set.  cpplib handles this, mostly.  */
7576
7577 HOST_WIDE_INT
7578 c_common_to_target_charset (HOST_WIDE_INT c)
7579 {
7580   /* Character constants in GCC proper are sign-extended under -fsigned-char,
7581      zero-extended under -fno-signed-char.  cpplib insists that characters
7582      and character constants are always unsigned.  Hence we must convert
7583      back and forth.  */
7584   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
7585
7586   uc = cpp_host_to_exec_charset (parse_in, uc);
7587
7588   if (flag_signed_char)
7589     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
7590                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
7591   else
7592     return uc;
7593 }
7594
7595 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
7596    component references, with STOP_REF, or alternatively an INDIRECT_REF of
7597    NULL, at the bottom; much like the traditional rendering of offsetof as a
7598    macro.  Returns the folded and properly cast result.  */
7599
7600 static tree
7601 fold_offsetof_1 (tree expr, tree stop_ref)
7602 {
7603   enum tree_code code = PLUS_EXPR;
7604   tree base, off, t;
7605
7606   if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
7607     return size_zero_node;
7608
7609   switch (TREE_CODE (expr))
7610     {
7611     case ERROR_MARK:
7612       return expr;
7613
7614     case VAR_DECL:
7615       error ("cannot apply %<offsetof%> to static data member %qD", expr);
7616       return error_mark_node;
7617
7618     case CALL_EXPR:
7619     case TARGET_EXPR:
7620       error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
7621       return error_mark_node;
7622
7623     case INTEGER_CST:
7624       gcc_assert (integer_zerop (expr));
7625       return size_zero_node;
7626
7627     case NOP_EXPR:
7628     case INDIRECT_REF:
7629       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7630       gcc_assert (base == error_mark_node || base == size_zero_node);
7631       return base;
7632
7633     case COMPONENT_REF:
7634       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7635       if (base == error_mark_node)
7636         return base;
7637
7638       t = TREE_OPERAND (expr, 1);
7639       if (DECL_C_BIT_FIELD (t))
7640         {
7641           error ("attempt to take address of bit-field structure "
7642                  "member %qD", t);
7643           return error_mark_node;
7644         }
7645       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
7646                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
7647                                   / BITS_PER_UNIT));
7648       break;
7649
7650     case ARRAY_REF:
7651       base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
7652       if (base == error_mark_node)
7653         return base;
7654
7655       t = TREE_OPERAND (expr, 1);
7656       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
7657         {
7658           code = MINUS_EXPR;
7659           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
7660         }
7661       t = convert (sizetype, t);
7662       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
7663       break;
7664
7665     case COMPOUND_EXPR:
7666       /* Handle static members of volatile structs.  */
7667       t = TREE_OPERAND (expr, 1);
7668       gcc_assert (TREE_CODE (t) == VAR_DECL);
7669       return fold_offsetof_1 (t, stop_ref);
7670
7671     default:
7672       gcc_unreachable ();
7673     }
7674
7675   return size_binop (code, base, off);
7676 }
7677
7678 tree
7679 fold_offsetof (tree expr, tree stop_ref)
7680 {
7681   /* Convert back from the internal sizetype to size_t.  */
7682   return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
7683 }
7684
7685 /* Print an error message for an invalid lvalue.  USE says
7686    how the lvalue is being used and so selects the error message.  */
7687
7688 void
7689 lvalue_error (enum lvalue_use use)
7690 {
7691   switch (use)
7692     {
7693     case lv_assign:
7694       error ("lvalue required as left operand of assignment");
7695       break;
7696     case lv_increment:
7697       error ("lvalue required as increment operand");
7698       break;
7699     case lv_decrement:
7700       error ("lvalue required as decrement operand");
7701       break;
7702     case lv_addressof:
7703       error ("lvalue required as unary %<&%> operand");
7704       break;
7705     case lv_asm:
7706       error ("lvalue required in asm statement");
7707       break;
7708     default:
7709       gcc_unreachable ();
7710     }
7711 }
7712 \f
7713 /* *PTYPE is an incomplete array.  Complete it with a domain based on
7714    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
7715    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7716    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
7717
7718 int
7719 complete_array_type (tree *ptype, tree initial_value, bool do_default)
7720 {
7721   tree maxindex, type, main_type, elt, unqual_elt;
7722   int failure = 0, quals;
7723   hashval_t hashcode = 0;
7724
7725   maxindex = size_zero_node;
7726   if (initial_value)
7727     {
7728       if (TREE_CODE (initial_value) == STRING_CST)
7729         {
7730           int eltsize
7731             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
7732           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
7733         }
7734       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
7735         {
7736           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
7737
7738           if (VEC_empty (constructor_elt, v))
7739             {
7740               if (pedantic)
7741                 failure = 3;
7742               maxindex = integer_minus_one_node;
7743             }
7744           else
7745             {
7746               tree curindex;
7747               unsigned HOST_WIDE_INT cnt;
7748               constructor_elt *ce;
7749
7750               if (VEC_index (constructor_elt, v, 0)->index)
7751                 maxindex = fold_convert (sizetype,
7752                                          VEC_index (constructor_elt,
7753                                                     v, 0)->index);
7754               curindex = maxindex;
7755
7756               for (cnt = 1;
7757                    VEC_iterate (constructor_elt, v, cnt, ce);
7758                    cnt++)
7759                 {
7760                   if (ce->index)
7761                     curindex = fold_convert (sizetype, ce->index);
7762                   else
7763                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
7764
7765                   if (tree_int_cst_lt (maxindex, curindex))
7766                     maxindex = curindex;
7767                 }
7768             }
7769         }
7770       else
7771         {
7772           /* Make an error message unless that happened already.  */
7773           if (initial_value != error_mark_node)
7774             failure = 1;
7775         }
7776     }
7777   else
7778     {
7779       failure = 2;
7780       if (!do_default)
7781         return failure;
7782     }
7783
7784   type = *ptype;
7785   elt = TREE_TYPE (type);
7786   quals = TYPE_QUALS (strip_array_types (elt));
7787   if (quals == 0)
7788     unqual_elt = elt;
7789   else
7790     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
7791
7792   /* Using build_distinct_type_copy and modifying things afterward instead
7793      of using build_array_type to create a new type preserves all of the
7794      TYPE_LANG_FLAG_? bits that the front end may have set.  */
7795   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7796   TREE_TYPE (main_type) = unqual_elt;
7797   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
7798   layout_type (main_type);
7799
7800   /* Make sure we have the canonical MAIN_TYPE. */
7801   hashcode = iterative_hash_object (TYPE_HASH (unqual_elt), hashcode);
7802   hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (main_type)),
7803                                     hashcode);
7804   main_type = type_hash_canon (hashcode, main_type);
7805
7806   /* Fix the canonical type.  */
7807   if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (main_type))
7808       || TYPE_STRUCTURAL_EQUALITY_P (TYPE_DOMAIN (main_type)))
7809     SET_TYPE_STRUCTURAL_EQUALITY (main_type);
7810   else if (TYPE_CANONICAL (TREE_TYPE (main_type)) != TREE_TYPE (main_type)
7811            || (TYPE_CANONICAL (TYPE_DOMAIN (main_type))
7812                != TYPE_DOMAIN (main_type)))
7813     TYPE_CANONICAL (main_type)
7814       = build_array_type (TYPE_CANONICAL (TREE_TYPE (main_type)),
7815                           TYPE_CANONICAL (TYPE_DOMAIN (main_type)));
7816   else
7817     TYPE_CANONICAL (main_type) = main_type;
7818
7819   if (quals == 0)
7820     type = main_type;
7821   else
7822     type = c_build_qualified_type (main_type, quals);
7823
7824   if (COMPLETE_TYPE_P (type)
7825       && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7826       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7827     {
7828       error ("size of array is too large");
7829       /* If we proceed with the array type as it is, we'll eventually
7830          crash in tree_low_cst().  */
7831       type = error_mark_node;
7832     }
7833
7834   *ptype = type;
7835   return failure;
7836 }
7837
7838 \f
7839 /* Used to help initialize the builtin-types.def table.  When a type of
7840    the correct size doesn't exist, use error_mark_node instead of NULL.
7841    The later results in segfaults even when a decl using the type doesn't
7842    get invoked.  */
7843
7844 tree
7845 builtin_type_for_size (int size, bool unsignedp)
7846 {
7847   tree type = lang_hooks.types.type_for_size (size, unsignedp);
7848   return type ? type : error_mark_node;
7849 }
7850
7851 /* A helper function for resolve_overloaded_builtin in resolving the
7852    overloaded __sync_ builtins.  Returns a positive power of 2 if the
7853    first operand of PARAMS is a pointer to a supported data type.
7854    Returns 0 if an error is encountered.  */
7855
7856 static int
7857 sync_resolve_size (tree function, tree params)
7858 {
7859   tree type;
7860   int size;
7861
7862   if (params == NULL)
7863     {
7864       error ("too few arguments to function %qE", function);
7865       return 0;
7866     }
7867
7868   type = TREE_TYPE (TREE_VALUE (params));
7869   if (TREE_CODE (type) != POINTER_TYPE)
7870     goto incompatible;
7871
7872   type = TREE_TYPE (type);
7873   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
7874     goto incompatible;
7875
7876   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
7877   if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
7878     return size;
7879
7880  incompatible:
7881   error ("incompatible type for argument %d of %qE", 1, function);
7882   return 0;
7883 }
7884
7885 /* A helper function for resolve_overloaded_builtin.  Adds casts to
7886    PARAMS to make arguments match up with those of FUNCTION.  Drops
7887    the variadic arguments at the end.  Returns false if some error
7888    was encountered; true on success.  */
7889
7890 static bool
7891 sync_resolve_params (tree orig_function, tree function, tree params)
7892 {
7893   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
7894   tree ptype;
7895   int number;
7896
7897   /* We've declared the implementation functions to use "volatile void *"
7898      as the pointer parameter, so we shouldn't get any complaints from the
7899      call to check_function_arguments what ever type the user used.  */
7900   arg_types = TREE_CHAIN (arg_types);
7901   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7902   number = 2;
7903
7904   /* For the rest of the values, we need to cast these to FTYPE, so that we
7905      don't get warnings for passing pointer types, etc.  */
7906   while (arg_types != void_list_node)
7907     {
7908       tree val;
7909
7910       params = TREE_CHAIN (params);
7911       if (params == NULL)
7912         {
7913           error ("too few arguments to function %qE", orig_function);
7914           return false;
7915         }
7916
7917       /* ??? Ideally for the first conversion we'd use convert_for_assignment
7918          so that we get warnings for anything that doesn't match the pointer
7919          type.  This isn't portable across the C and C++ front ends atm.  */
7920       val = TREE_VALUE (params);
7921       val = convert (ptype, val);
7922       val = convert (TREE_VALUE (arg_types), val);
7923       TREE_VALUE (params) = val;
7924
7925       arg_types = TREE_CHAIN (arg_types);
7926       number++;
7927     }
7928
7929   /* The definition of these primitives is variadic, with the remaining
7930      being "an optional list of variables protected by the memory barrier".
7931      No clue what that's supposed to mean, precisely, but we consider all
7932      call-clobbered variables to be protected so we're safe.  */
7933   TREE_CHAIN (params) = NULL;
7934
7935   return true;
7936 }
7937
7938 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
7939    RESULT to make it match the type of the first pointer argument in
7940    PARAMS.  */
7941
7942 static tree
7943 sync_resolve_return (tree params, tree result)
7944 {
7945   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
7946   ptype = TYPE_MAIN_VARIANT (ptype);
7947   return convert (ptype, result);
7948 }
7949
7950 /* Some builtin functions are placeholders for other expressions.  This
7951    function should be called immediately after parsing the call expression
7952    before surrounding code has committed to the type of the expression.
7953
7954    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
7955    PARAMS is the argument list for the call.  The return value is non-null
7956    when expansion is complete, and null if normal processing should
7957    continue.  */
7958
7959 tree
7960 resolve_overloaded_builtin (tree function, tree params)
7961 {
7962   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
7963   switch (DECL_BUILT_IN_CLASS (function))
7964     {
7965     case BUILT_IN_NORMAL:
7966       break;
7967     case BUILT_IN_MD:
7968       if (targetm.resolve_overloaded_builtin)
7969         return targetm.resolve_overloaded_builtin (function, params);
7970       else
7971         return NULL_TREE;
7972     default:
7973       return NULL_TREE;
7974     }
7975
7976   /* Handle BUILT_IN_NORMAL here.  */
7977   switch (orig_code)
7978     {
7979     case BUILT_IN_FETCH_AND_ADD_N:
7980     case BUILT_IN_FETCH_AND_SUB_N:
7981     case BUILT_IN_FETCH_AND_OR_N:
7982     case BUILT_IN_FETCH_AND_AND_N:
7983     case BUILT_IN_FETCH_AND_XOR_N:
7984     case BUILT_IN_FETCH_AND_NAND_N:
7985     case BUILT_IN_ADD_AND_FETCH_N:
7986     case BUILT_IN_SUB_AND_FETCH_N:
7987     case BUILT_IN_OR_AND_FETCH_N:
7988     case BUILT_IN_AND_AND_FETCH_N:
7989     case BUILT_IN_XOR_AND_FETCH_N:
7990     case BUILT_IN_NAND_AND_FETCH_N:
7991     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
7992     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
7993     case BUILT_IN_LOCK_TEST_AND_SET_N:
7994     case BUILT_IN_LOCK_RELEASE_N:
7995       {
7996         int n = sync_resolve_size (function, params);
7997         tree new_function, result;
7998
7999         if (n == 0)
8000           return error_mark_node;
8001
8002         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
8003         if (!sync_resolve_params (function, new_function, params))
8004           return error_mark_node;
8005
8006         result = build_function_call (new_function, params);
8007         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
8008             && orig_code != BUILT_IN_LOCK_RELEASE_N)
8009           result = sync_resolve_return (params, result);
8010
8011         return result;
8012       }
8013
8014     default:
8015       return NULL_TREE;
8016     }
8017 }
8018
8019 /* Ignoring their sign, return true if two scalar types are the same.  */
8020 bool
8021 same_scalar_type_ignoring_signedness (tree t1, tree t2)
8022 {
8023   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
8024
8025   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE || c1 == FIXED_POINT_TYPE)
8026               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE
8027                   || c2 == FIXED_POINT_TYPE));
8028
8029   /* Equality works here because c_common_signed_type uses
8030      TYPE_MAIN_VARIANT.  */
8031   return c_common_signed_type (t1)
8032     == c_common_signed_type (t2);
8033 }
8034
8035 /* Check for missing format attributes on function pointers.  LTYPE is
8036    the new type or left-hand side type.  RTYPE is the old type or
8037    right-hand side type.  Returns TRUE if LTYPE is missing the desired
8038    attribute.  */
8039
8040 bool
8041 check_missing_format_attribute (tree ltype, tree rtype)
8042 {
8043   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
8044   tree ra;
8045
8046   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
8047     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
8048       break;
8049   if (ra)
8050     {
8051       tree la;
8052       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
8053         if (is_attribute_p ("format", TREE_PURPOSE (la)))
8054           break;
8055       return !la;
8056     }
8057   else
8058     return false;
8059 }
8060
8061 /* Subscripting with type char is likely to lose on a machine where
8062    chars are signed.  So warn on any machine, but optionally.  Don't
8063    warn for unsigned char since that type is safe.  Don't warn for
8064    signed char because anyone who uses that must have done so
8065    deliberately. Furthermore, we reduce the false positive load by
8066    warning only for non-constant value of type char.  */
8067
8068 void
8069 warn_array_subscript_with_type_char (tree index)
8070 {
8071   if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
8072       && TREE_CODE (index) != INTEGER_CST)
8073     warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
8074 }
8075
8076 /* Implement -Wparentheses for the unexpected C precedence rules, to
8077    cover cases like x + y << z which readers are likely to
8078    misinterpret.  We have seen an expression in which CODE is a binary
8079    operator used to combine expressions headed by CODE_LEFT and
8080    CODE_RIGHT.  CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which
8081    means that that side of the expression was not formed using a
8082    binary operator, or it was enclosed in parentheses.  */
8083
8084 void
8085 warn_about_parentheses (enum tree_code code, enum tree_code code_left,
8086                         enum tree_code code_right)
8087 {
8088   if (!warn_parentheses)
8089     return;
8090
8091   if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
8092     {
8093       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
8094           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8095         warning (OPT_Wparentheses,
8096                  "suggest parentheses around + or - inside shift");
8097     }
8098
8099   if (code == TRUTH_ORIF_EXPR)
8100     {
8101       if (code_left == TRUTH_ANDIF_EXPR
8102           || code_right == TRUTH_ANDIF_EXPR)
8103         warning (OPT_Wparentheses,
8104                  "suggest parentheses around && within ||");
8105     }
8106
8107   if (code == BIT_IOR_EXPR)
8108     {
8109       if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR
8110           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8111           || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR
8112           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8113         warning (OPT_Wparentheses,
8114                  "suggest parentheses around arithmetic in operand of |");
8115       /* Check cases like x|y==z */
8116       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8117           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8118         warning (OPT_Wparentheses,
8119                  "suggest parentheses around comparison in operand of |");
8120     }
8121
8122   if (code == BIT_XOR_EXPR)
8123     {
8124       if (code_left == BIT_AND_EXPR
8125           || code_left == PLUS_EXPR || code_left == MINUS_EXPR
8126           || code_right == BIT_AND_EXPR
8127           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8128         warning (OPT_Wparentheses,
8129                  "suggest parentheses around arithmetic in operand of ^");
8130       /* Check cases like x^y==z */
8131       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8132           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8133         warning (OPT_Wparentheses,
8134                  "suggest parentheses around comparison in operand of ^");
8135     }
8136
8137   if (code == BIT_AND_EXPR)
8138     {
8139       if (code_left == PLUS_EXPR || code_left == MINUS_EXPR
8140           || code_right == PLUS_EXPR || code_right == MINUS_EXPR)
8141         warning (OPT_Wparentheses,
8142                  "suggest parentheses around + or - in operand of &");
8143       /* Check cases like x&y==z */
8144       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8145           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8146         warning (OPT_Wparentheses,
8147                  "suggest parentheses around comparison in operand of &");
8148     }
8149
8150   if (code == EQ_EXPR || code == NE_EXPR)
8151     {
8152       if (TREE_CODE_CLASS (code_left) == tcc_comparison
8153           || TREE_CODE_CLASS (code_right) == tcc_comparison)
8154         warning (OPT_Wparentheses,
8155                  "suggest parentheses around comparison in operand of %s",
8156                  code == EQ_EXPR ? "==" : "!=");
8157     }
8158   else if (TREE_CODE_CLASS (code) == tcc_comparison)
8159     {
8160       if ((TREE_CODE_CLASS (code_left) == tcc_comparison
8161            && code_left != NE_EXPR && code_left != EQ_EXPR)
8162           || (TREE_CODE_CLASS (code_right) == tcc_comparison
8163               && code_right != NE_EXPR && code_right != EQ_EXPR))
8164         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
8165                  "have their mathematical meaning");
8166     }
8167 }
8168
8169 /* If LABEL (a LABEL_DECL) has not been used, issue a warning.  */
8170
8171 void
8172 warn_for_unused_label (tree label)
8173 {
8174   if (!TREE_USED (label))
8175     {
8176       if (DECL_INITIAL (label))
8177         warning (OPT_Wunused_label, "label %q+D defined but not used", label);
8178       else
8179         warning (OPT_Wunused_label, "label %q+D declared but not defined", label);
8180     }
8181 }
8182
8183 #ifndef TARGET_HAS_TARGETCM
8184 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
8185 #endif
8186
8187 /* Warn for division by zero according to the value of DIVISOR.  LOC
8188    is the location of the division operator.  */
8189
8190 void
8191 warn_for_div_by_zero (location_t loc, tree divisor)
8192 {
8193   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
8194      about division by zero.  Do not issue a warning if DIVISOR has a
8195      floating-point type, since we consider 0.0/0.0 a valid way of
8196      generating a NaN.  */
8197   if (skip_evaluation == 0
8198       && (integer_zerop (divisor) || fixed_zerop (divisor)))
8199     warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
8200 }
8201
8202 /* Subroutine of build_binary_op. Give warnings for comparisons
8203    between signed and unsigned quantities that may fail. Do the
8204    checking based on the original operand trees ORIG_OP0 and ORIG_OP1,
8205    so that casts will be considered, but default promotions won't
8206    be.
8207
8208    LOCATION is the location of the comparison operator.
8209
8210    The arguments of this function map directly to local variables
8211    of build_binary_op.  */
8212
8213 void
8214 warn_for_sign_compare (location_t location,
8215                        tree orig_op0, tree orig_op1,
8216                        tree op0, tree op1,
8217                        tree result_type, enum tree_code resultcode)
8218 {
8219   int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8220   int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8221   int unsignedp0, unsignedp1;
8222
8223   /* In C++, check for comparison of different enum types.  */
8224   if (c_dialect_cxx()
8225       && TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE
8226       && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE
8227       && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0))
8228       != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)))
8229     {
8230       warning_at (location,
8231                   OPT_Wsign_compare, "comparison between types %qT and %qT",
8232                   TREE_TYPE (orig_op0), TREE_TYPE (orig_op1));
8233     }
8234
8235   /* Do not warn if the comparison is being done in a signed type,
8236      since the signed type will only be chosen if it can represent
8237      all the values of the unsigned type.  */
8238   if (!TYPE_UNSIGNED (result_type))
8239     /* OK */;
8240   /* Do not warn if both operands are unsigned.  */
8241   else if (op0_signed == op1_signed)
8242     /* OK */;
8243   else
8244     {
8245       tree sop, uop;
8246       bool ovf;
8247
8248       if (op0_signed)
8249         sop = orig_op0, uop = orig_op1;
8250       else
8251         sop = orig_op1, uop = orig_op0;
8252
8253       STRIP_TYPE_NOPS (sop);
8254       STRIP_TYPE_NOPS (uop);
8255
8256       /* Do not warn if the signed quantity is an unsuffixed integer
8257          literal (or some static constant expression involving such
8258          literals or a conditional expression involving such literals)
8259          and it is non-negative.  */
8260       if (tree_expr_nonnegative_warnv_p (sop, &ovf))
8261         /* OK */;
8262       /* Do not warn if the comparison is an equality operation, the
8263          unsigned quantity is an integral constant, and it would fit
8264          in the result if the result were signed.  */
8265       else if (TREE_CODE (uop) == INTEGER_CST
8266                && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8267                && int_fits_type_p (uop, c_common_signed_type (result_type)))
8268         /* OK */;
8269       /* In C, do not warn if the unsigned quantity is an enumeration
8270          constant and its maximum value would fit in the result if the
8271          result were signed.  */
8272       else if (!c_dialect_cxx() && TREE_CODE (uop) == INTEGER_CST
8273                && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8274                && int_fits_type_p (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8275                                    c_common_signed_type (result_type)))
8276         /* OK */;
8277       else
8278         warning_at (location,
8279                     OPT_Wsign_compare,
8280                     "comparison between signed and unsigned integer expressions");
8281     }
8282
8283   /* Warn if two unsigned values are being compared in a size larger
8284      than their original size, and one (and only one) is the result of
8285      a `~' operator.  This comparison will always fail.
8286
8287      Also warn if one operand is a constant, and the constant does not
8288      have all bits set that are set in the ~ operand when it is
8289      extended.  */
8290
8291   op0 = get_narrower (op0, &unsignedp0);
8292   op1 = get_narrower (op1, &unsignedp1);
8293
8294   if ((TREE_CODE (op0) == BIT_NOT_EXPR)
8295       ^ (TREE_CODE (op1) == BIT_NOT_EXPR))
8296     {
8297       if (TREE_CODE (op0) == BIT_NOT_EXPR)
8298         op0 = get_narrower (TREE_OPERAND (op0, 0), &unsignedp0);
8299       if (TREE_CODE (op1) == BIT_NOT_EXPR)
8300         op1 = get_narrower (TREE_OPERAND (op1, 0), &unsignedp1);
8301
8302       if (host_integerp (op0, 0) || host_integerp (op1, 0))
8303         {
8304           tree primop;
8305           HOST_WIDE_INT constant, mask;
8306           int unsignedp;
8307           unsigned int bits;
8308
8309           if (host_integerp (op0, 0))
8310             {
8311               primop = op1;
8312               unsignedp = unsignedp1;
8313               constant = tree_low_cst (op0, 0);
8314             }
8315           else
8316             {
8317               primop = op0;
8318               unsignedp = unsignedp0;
8319               constant = tree_low_cst (op1, 0);
8320             }
8321
8322           bits = TYPE_PRECISION (TREE_TYPE (primop));
8323           if (bits < TYPE_PRECISION (result_type)
8324               && bits < HOST_BITS_PER_LONG && unsignedp)
8325             {
8326               mask = (~ (HOST_WIDE_INT) 0) << bits;
8327               if ((mask & constant) != mask)
8328                 {
8329                   if (constant == 0)
8330                     warning (OPT_Wsign_compare,
8331                              "promoted ~unsigned is always non-zero");
8332                   else
8333                     warning_at (location, OPT_Wsign_compare,
8334                                 "comparison of promoted ~unsigned with constant");
8335                 }
8336             }
8337         }
8338       else if (unsignedp0 && unsignedp1
8339                && (TYPE_PRECISION (TREE_TYPE (op0))
8340                    < TYPE_PRECISION (result_type))
8341                && (TYPE_PRECISION (TREE_TYPE (op1))
8342                    < TYPE_PRECISION (result_type)))
8343         warning_at (location, OPT_Wsign_compare,
8344                  "comparison of promoted ~unsigned with unsigned");
8345     }
8346 }
8347
8348 #include "gt-c-common.h"