gcc/c-common.c

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