contrib/gcc/c-common.c

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