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