gcc/c-common.c

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