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