gcc/c-common.c

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