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