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