gcc/c-common.c

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