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