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