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