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