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];
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
3315   c_init_attributes ();
3316
3317 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3318                     NONANSI_P, ATTRS, IMPLICIT, COND)                   \
3319   if (NAME && COND)                                                     \
3320     def_builtin_1 (ENUM, NAME, CLASS,                                   \
3321                    builtin_types[(int) TYPE],                           \
3322                    builtin_types[(int) LIBTYPE],                        \
3323                    BOTH_P, FALLBACK_P, NONANSI_P,                       \
3324                    built_in_attributes[(int) ATTRS], IMPLICIT);
3325 #include "builtins.def"
3326 #undef DEF_BUILTIN
3327
3328   build_common_builtin_nodes ();
3329
3330   targetm.init_builtins ();
3331   if (flag_mudflap)
3332     mudflap_init ();
3333
3334   main_identifier_node = get_identifier ("main");
3335
3336   /* Create the built-in __null node.  It is important that this is
3337      not shared.  */
3338   null_node = make_node (INTEGER_CST);
3339   TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3340 }
3341
3342 /* Look up the function in built_in_decls that corresponds to DECL
3343    and set ASMSPEC as its user assembler name.  DECL must be a
3344    function decl that declares a builtin.  */
3345
3346 void
3347 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3348 {
3349   tree builtin;
3350   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3351               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3352               && asmspec != 0);
3353
3354   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3355   set_user_assembler_name (builtin, asmspec);
3356   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3357     init_block_move_fn (asmspec);
3358   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3359     init_block_clear_fn (asmspec);
3360 }
3361
3362 tree
3363 build_va_arg (tree expr, tree type)
3364 {
3365   return build1 (VA_ARG_EXPR, type, expr);
3366 }
3367
3368
3369 /* Linked list of disabled built-in functions.  */
3370
3371 typedef struct disabled_builtin
3372 {
3373   const char *name;
3374   struct disabled_builtin *next;
3375 } disabled_builtin;
3376 static disabled_builtin *disabled_builtins = NULL;
3377
3378 static bool builtin_function_disabled_p (const char *);
3379
3380 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3381    begins with "__builtin_", give an error.  */
3382
3383 void
3384 disable_builtin_function (const char *name)
3385 {
3386   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3387     error ("cannot disable built-in function %qs", name);
3388   else
3389     {
3390       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3391       new_disabled_builtin->name = name;
3392       new_disabled_builtin->next = disabled_builtins;
3393       disabled_builtins = new_disabled_builtin;
3394     }
3395 }
3396
3397
3398 /* Return true if the built-in function NAME has been disabled, false
3399    otherwise.  */
3400
3401 static bool
3402 builtin_function_disabled_p (const char *name)
3403 {
3404   disabled_builtin *p;
3405   for (p = disabled_builtins; p != NULL; p = p->next)
3406     {
3407       if (strcmp (name, p->name) == 0)
3408         return true;
3409     }
3410   return false;
3411 }
3412
3413
3414 /* Worker for DEF_BUILTIN.
3415    Possibly define a builtin function with one or two names.
3416    Does not declare a non-__builtin_ function if flag_no_builtin, or if
3417    nonansi_p and flag_no_nonansi_builtin.  */
3418
3419 static void
3420 def_builtin_1 (enum built_in_function fncode,
3421                const char *name,
3422                enum built_in_class fnclass,
3423                tree fntype, tree libtype,
3424                bool both_p, bool fallback_p, bool nonansi_p,
3425                tree fnattrs, bool implicit_p)
3426 {
3427   tree decl;
3428   const char *libname;
3429
3430   gcc_assert ((!both_p && !fallback_p)
3431               || !strncmp (name, "__builtin_",
3432                            strlen ("__builtin_")));
3433
3434   libname = name + strlen ("__builtin_");
3435   decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3436                                       (fallback_p ? libname : NULL),
3437                                       fnattrs);
3438   if (both_p
3439       && !flag_no_builtin && !builtin_function_disabled_p (libname)
3440       && !(nonansi_p && flag_no_nonansi_builtin))
3441     lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3442                                  NULL, fnattrs);
3443
3444   built_in_decls[(int) fncode] = decl;
3445   if (implicit_p)
3446     implicit_built_in_decls[(int) fncode] = decl;
3447 }
3448 \f
3449 /* Nonzero if the type T promotes to int.  This is (nearly) the
3450    integral promotions defined in ISO C99 6.3.1.1/2.  */
3451
3452 bool
3453 c_promoting_integer_type_p (tree t)
3454 {
3455   switch (TREE_CODE (t))
3456     {
3457     case INTEGER_TYPE:
3458       return (TYPE_MAIN_VARIANT (t) == char_type_node
3459               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3460               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3461               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3462               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3463               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3464
3465     case ENUMERAL_TYPE:
3466       /* ??? Technically all enumerations not larger than an int
3467          promote to an int.  But this is used along code paths
3468          that only want to notice a size change.  */
3469       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3470
3471     case BOOLEAN_TYPE:
3472       return 1;
3473
3474     default:
3475       return 0;
3476     }
3477 }
3478
3479 /* Return 1 if PARMS specifies a fixed number of parameters
3480    and none of their types is affected by default promotions.  */
3481
3482 int
3483 self_promoting_args_p (tree parms)
3484 {
3485   tree t;
3486   for (t = parms; t; t = TREE_CHAIN (t))
3487     {
3488       tree type = TREE_VALUE (t);
3489
3490       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3491         return 0;
3492
3493       if (type == 0)
3494         return 0;
3495
3496       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3497         return 0;
3498
3499       if (c_promoting_integer_type_p (type))
3500         return 0;
3501     }
3502   return 1;
3503 }
3504
3505 /* Recursively examines the array elements of TYPE, until a non-array
3506    element type is found.  */
3507
3508 tree
3509 strip_array_types (tree type)
3510 {
3511   while (TREE_CODE (type) == ARRAY_TYPE)
3512     type = TREE_TYPE (type);
3513
3514   return type;
3515 }
3516
3517 /* Recursively remove any '*' or '&' operator from TYPE.  */
3518 tree
3519 strip_pointer_operator (tree t)
3520 {
3521   while (POINTER_TYPE_P (t))
3522     t = TREE_TYPE (t);
3523   return t;
3524 }
3525
3526 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3527    representing case labels, or NULL_TREE for a `default' label.
3528    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3529    K2, and 0 if K1 and K2 are equal.  */
3530
3531 int
3532 case_compare (splay_tree_key k1, splay_tree_key k2)
3533 {
3534   /* Consider a NULL key (such as arises with a `default' label) to be
3535      smaller than anything else.  */
3536   if (!k1)
3537     return k2 ? -1 : 0;
3538   else if (!k2)
3539     return k1 ? 1 : 0;
3540
3541   return tree_int_cst_compare ((tree) k1, (tree) k2);
3542 }
3543
3544 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3545    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3546    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3547    case label was declared using the usual C/C++ syntax, rather than
3548    the GNU case range extension.  CASES is a tree containing all the
3549    case ranges processed so far; COND is the condition for the
3550    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
3551    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
3552
3553 tree
3554 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3555                   tree low_value, tree high_value)
3556 {
3557   tree type;
3558   tree label;
3559   tree case_label;
3560   splay_tree_node node;
3561
3562   /* Create the LABEL_DECL itself.  */
3563   label = create_artificial_label ();
3564
3565   /* If there was an error processing the switch condition, bail now
3566      before we get more confused.  */
3567   if (!cond || cond == error_mark_node)
3568     goto error_out;
3569
3570   if ((low_value && TREE_TYPE (low_value)
3571        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3572       || (high_value && TREE_TYPE (high_value)
3573           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3574     {
3575       error ("pointers are not permitted as case values");
3576       goto error_out;
3577     }
3578
3579   /* Case ranges are a GNU extension.  */
3580   if (high_value && pedantic)
3581     pedwarn ("range expressions in switch statements are non-standard");
3582
3583   type = TREE_TYPE (cond);
3584   if (low_value)
3585     {
3586       low_value = check_case_value (low_value);
3587       low_value = convert_and_check (type, low_value);
3588     }
3589   if (high_value)
3590     {
3591       high_value = check_case_value (high_value);
3592       high_value = convert_and_check (type, high_value);
3593     }
3594
3595   /* If an error has occurred, bail out now.  */
3596   if (low_value == error_mark_node || high_value == error_mark_node)
3597     goto error_out;
3598
3599   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3600      really a case range, even though it was written that way.  Remove
3601      the HIGH_VALUE to simplify later processing.  */
3602   if (tree_int_cst_equal (low_value, high_value))
3603     high_value = NULL_TREE;
3604   if (low_value && high_value
3605       && !tree_int_cst_lt (low_value, high_value))
3606     warning (0, "empty range specified");
3607
3608   /* See if the case is in range of the type of the original testing
3609      expression.  If both low_value and high_value are out of range,
3610      don't insert the case label and return NULL_TREE.  */
3611   if (low_value
3612       && !check_case_bounds (type, orig_type,
3613                              &low_value, high_value ? &high_value : NULL))
3614     return NULL_TREE;
3615
3616   /* Look up the LOW_VALUE in the table of case labels we already
3617      have.  */
3618   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3619   /* If there was not an exact match, check for overlapping ranges.
3620      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3621      that's a `default' label and the only overlap is an exact match.  */
3622   if (!node && (low_value || high_value))
3623     {
3624       splay_tree_node low_bound;
3625       splay_tree_node high_bound;
3626
3627       /* Even though there wasn't an exact match, there might be an
3628          overlap between this case range and another case range.
3629          Since we've (inductively) not allowed any overlapping case
3630          ranges, we simply need to find the greatest low case label
3631          that is smaller that LOW_VALUE, and the smallest low case
3632          label that is greater than LOW_VALUE.  If there is an overlap
3633          it will occur in one of these two ranges.  */
3634       low_bound = splay_tree_predecessor (cases,
3635                                           (splay_tree_key) low_value);
3636       high_bound = splay_tree_successor (cases,
3637                                          (splay_tree_key) low_value);
3638
3639       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3640          the LOW_VALUE, so there is no need to check unless the
3641          LOW_BOUND is in fact itself a case range.  */
3642       if (low_bound
3643           && CASE_HIGH ((tree) low_bound->value)
3644           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3645                                     low_value) >= 0)
3646         node = low_bound;
3647       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3648          range is bigger than the low end of the current range, so we
3649          are only interested if the current range is a real range, and
3650          not an ordinary case label.  */
3651       else if (high_bound
3652                && high_value
3653                && (tree_int_cst_compare ((tree) high_bound->key,
3654                                          high_value)
3655                    <= 0))
3656         node = high_bound;
3657     }
3658   /* If there was an overlap, issue an error.  */
3659   if (node)
3660     {
3661       tree duplicate = CASE_LABEL ((tree) node->value);
3662
3663       if (high_value)
3664         {
3665           error ("duplicate (or overlapping) case value");
3666           error ("%Jthis is the first entry overlapping that value", duplicate);
3667         }
3668       else if (low_value)
3669         {
3670           error ("duplicate case value") ;
3671           error ("%Jpreviously used here", duplicate);
3672         }
3673       else
3674         {
3675           error ("multiple default labels in one switch");
3676           error ("%Jthis is the first default label", duplicate);
3677         }
3678       goto error_out;
3679     }
3680
3681   /* Add a CASE_LABEL to the statement-tree.  */
3682   case_label = add_stmt (build_case_label (low_value, high_value, label));
3683   /* Register this case label in the splay tree.  */
3684   splay_tree_insert (cases,
3685                      (splay_tree_key) low_value,
3686                      (splay_tree_value) case_label);
3687
3688   return case_label;
3689
3690  error_out:
3691   /* Add a label so that the back-end doesn't think that the beginning of
3692      the switch is unreachable.  Note that we do not add a case label, as
3693      that just leads to duplicates and thence to failure later on.  */
3694   if (!cases->root)
3695     {
3696       tree t = create_artificial_label ();
3697       add_stmt (build_stmt (LABEL_EXPR, t));
3698     }
3699   return error_mark_node;
3700 }
3701
3702 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3703    Used to verify that case values match up with enumerator values.  */
3704
3705 static void
3706 match_case_to_enum_1 (tree key, tree type, tree label)
3707 {
3708   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3709
3710   /* ??? Not working too hard to print the double-word value.
3711      Should perhaps be done with %lwd in the diagnostic routines?  */
3712   if (TREE_INT_CST_HIGH (key) == 0)
3713     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3714               TREE_INT_CST_LOW (key));
3715   else if (!TYPE_UNSIGNED (type)
3716            && TREE_INT_CST_HIGH (key) == -1
3717            && TREE_INT_CST_LOW (key) != 0)
3718     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3719               -TREE_INT_CST_LOW (key));
3720   else
3721     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3722               TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3723
3724   if (TYPE_NAME (type) == 0)
3725     warning (0, "%Jcase value %qs not in enumerated type",
3726              CASE_LABEL (label), buf);
3727   else
3728     warning (0, "%Jcase value %qs not in enumerated type %qT",
3729              CASE_LABEL (label), buf, type);
3730 }
3731
3732 static int
3733 match_case_to_enum (splay_tree_node node, void *data)
3734 {
3735   tree label = (tree) node->value;
3736   tree type = (tree) data;
3737
3738   /* Skip default case.  */
3739   if (!CASE_LOW (label))
3740     return 0;
3741
3742   /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3743      when we did our enum->case scan.  Reset our scratch bit after.  */
3744   if (!TREE_ADDRESSABLE (label))
3745     match_case_to_enum_1 (CASE_LOW (label), type, label);
3746   else
3747     TREE_ADDRESSABLE (label) = 0;
3748
3749   /* If CASE_HIGH is non-null, we have a range.  Here we must search.
3750      Note that the old code in stmt.c did not check for the values in
3751      the range either, just the endpoints.  */
3752   if (CASE_HIGH (label))
3753     {
3754       tree chain, key = CASE_HIGH (label);
3755
3756       for (chain = TYPE_VALUES (type);
3757            chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3758            chain = TREE_CHAIN (chain))
3759         continue;
3760       if (!chain)
3761         match_case_to_enum_1 (key, type, label);
3762     }
3763
3764   return 0;
3765 }
3766
3767 /* Handle -Wswitch*.  Called from the front end after parsing the
3768    switch construct.  */
3769 /* ??? Should probably be somewhere generic, since other languages
3770    besides C and C++ would want this.  At the moment, however, C/C++
3771    are the only tree-ssa languages that support enumerations at all,
3772    so the point is moot.  */
3773
3774 void
3775 c_do_switch_warnings (splay_tree cases, location_t switch_location,
3776                       tree type, tree cond)
3777 {
3778   splay_tree_node default_node;
3779
3780   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3781     return;
3782
3783   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3784   if (!default_node)
3785     warning (OPT_Wswitch_default, "%Hswitch missing default case",
3786              &switch_location);
3787
3788   /* If the switch expression was an enumerated type, check that
3789      exactly all enumeration literals are covered by the cases.
3790      The check is made when -Wswitch was specified and there is no
3791      default case, or when -Wswitch-enum was specified.  */
3792   if (((warn_switch && !default_node) || warn_switch_enum)
3793       && type && TREE_CODE (type) == ENUMERAL_TYPE
3794       && TREE_CODE (cond) != INTEGER_CST)
3795     {
3796       tree chain;
3797
3798       /* The time complexity here is O(N*lg(N)) worst case, but for the
3799          common case of monotonically increasing enumerators, it is
3800          O(N), since the nature of the splay tree will keep the next
3801          element adjacent to the root at all times.  */
3802
3803       for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3804         {
3805           splay_tree_node node
3806             = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3807
3808           if (node)
3809             {
3810               /* Mark the CASE_LOW part of the case entry as seen, so
3811                  that we save time later.  Choose TREE_ADDRESSABLE
3812                  randomly as a bit that won't have been set to-date.  */
3813               tree label = (tree) node->value;
3814               TREE_ADDRESSABLE (label) = 1;
3815             }
3816           else
3817             {
3818               /* Warn if there are enumerators that don't correspond to
3819                  case expressions.  */
3820               warning (0, "%Henumeration value %qE not handled in switch",
3821                        &switch_location, TREE_PURPOSE (chain));
3822             }
3823         }
3824
3825       /* Warn if there are case expressions that don't correspond to
3826          enumerators.  This can occur since C and C++ don't enforce
3827          type-checking of assignments to enumeration variables.
3828
3829          The time complexity here is O(N**2) worst case, since we've
3830          not sorted the enumeration values.  However, in the absence
3831          of case ranges this is O(N), since all single cases that
3832          corresponded to enumerations have been marked above.  */
3833
3834       splay_tree_foreach (cases, match_case_to_enum, type);
3835     }
3836 }
3837
3838 /* Finish an expression taking the address of LABEL (an
3839    IDENTIFIER_NODE).  Returns an expression for the address.  */
3840
3841 tree
3842 finish_label_address_expr (tree label)
3843 {
3844   tree result;
3845
3846   if (pedantic)
3847     pedwarn ("taking the address of a label is non-standard");
3848
3849   if (label == error_mark_node)
3850     return error_mark_node;
3851
3852   label = lookup_label (label);
3853   if (label == NULL_TREE)
3854     result = null_pointer_node;
3855   else
3856     {
3857       TREE_USED (label) = 1;
3858       result = build1 (ADDR_EXPR, ptr_type_node, label);
3859       /* The current function in not necessarily uninlinable.
3860          Computed gotos are incompatible with inlining, but the value
3861          here could be used only in a diagnostic, for example.  */
3862     }
3863
3864   return result;
3865 }
3866
3867 /* Hook used by expand_expr to expand language-specific tree codes.  */
3868 /* The only things that should go here are bits needed to expand
3869    constant initializers.  Everything else should be handled by the
3870    gimplification routines.  */
3871
3872 rtx
3873 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3874                int modifier /* Actually enum_modifier.  */,
3875                rtx *alt_rtl)
3876 {
3877   switch (TREE_CODE (exp))
3878     {
3879     case COMPOUND_LITERAL_EXPR:
3880       {
3881         /* Initialize the anonymous variable declared in the compound
3882            literal, then return the variable.  */
3883         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3884         emit_local_var (decl);
3885         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3886       }
3887
3888     default:
3889       gcc_unreachable ();
3890     }
3891 }
3892
3893 /* Hook used by staticp to handle language-specific tree codes.  */
3894
3895 tree
3896 c_staticp (tree exp)
3897 {
3898   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3899           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
3900           ? exp : NULL);
3901 }
3902 \f
3903
3904 /* Given a boolean expression ARG, return a tree representing an increment
3905    or decrement (as indicated by CODE) of ARG.  The front end must check for
3906    invalid cases (e.g., decrement in C++).  */
3907 tree
3908 boolean_increment (enum tree_code code, tree arg)
3909 {
3910   tree val;
3911   tree true_res = boolean_true_node;
3912
3913   arg = stabilize_reference (arg);
3914   switch (code)
3915     {
3916     case PREINCREMENT_EXPR:
3917       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3918       break;
3919     case POSTINCREMENT_EXPR:
3920       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3921       arg = save_expr (arg);
3922       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3923       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3924       break;
3925     case PREDECREMENT_EXPR:
3926       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3927                     invert_truthvalue (arg));
3928       break;
3929     case POSTDECREMENT_EXPR:
3930       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3931                     invert_truthvalue (arg));
3932       arg = save_expr (arg);
3933       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3934       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3935       break;
3936     default:
3937       gcc_unreachable ();
3938     }
3939   TREE_SIDE_EFFECTS (val) = 1;
3940   return val;
3941 }
3942 \f
3943 /* Built-in macros for stddef.h, that require macros defined in this
3944    file.  */
3945 void
3946 c_stddef_cpp_builtins(void)
3947 {
3948   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
3949   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
3950   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
3951   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
3952   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
3953   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
3954 }
3955
3956 static void
3957 c_init_attributes (void)
3958 {
3959   /* Fill in the built_in_attributes array.  */
3960 #define DEF_ATTR_NULL_TREE(ENUM)                                \
3961   built_in_attributes[(int) ENUM] = NULL_TREE;
3962 #define DEF_ATTR_INT(ENUM, VALUE)                               \
3963   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
3964 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
3965   built_in_attributes[(int) ENUM] = get_identifier (STRING);
3966 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3967   built_in_attributes[(int) ENUM]                       \
3968     = tree_cons (built_in_attributes[(int) PURPOSE],    \
3969                  built_in_attributes[(int) VALUE],      \
3970                  built_in_attributes[(int) CHAIN]);
3971 #include "builtin-attrs.def"
3972 #undef DEF_ATTR_NULL_TREE
3973 #undef DEF_ATTR_INT
3974 #undef DEF_ATTR_IDENT
3975 #undef DEF_ATTR_TREE_LIST
3976 }
3977
3978 /* Attribute handlers common to C front ends.  */
3979
3980 /* Handle a "packed" attribute; arguments as in
3981    struct attribute_spec.handler.  */
3982
3983 static tree
3984 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3985                          int flags, bool *no_add_attrs)
3986 {
3987   if (TYPE_P (*node))
3988     {
3989       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3990         *node = build_variant_type_copy (*node);
3991       TYPE_PACKED (*node) = 1;
3992       if (TYPE_MAIN_VARIANT (*node) == *node)
3993         {
3994           /* If it is the main variant, then pack the other variants
3995              too. This happens in,
3996
3997              struct Foo {
3998                struct Foo const *ptr; // creates a variant w/o packed flag
3999                } __ attribute__((packed)); // packs it now.
4000           */
4001           tree probe;
4002
4003           for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4004             TYPE_PACKED (probe) = 1;
4005         }
4006
4007     }
4008   else if (TREE_CODE (*node) == FIELD_DECL)
4009     DECL_PACKED (*node) = 1;
4010   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4011      used for DECL_REGISTER.  It wouldn't mean anything anyway.
4012      We can't set DECL_PACKED on the type of a TYPE_DECL, because
4013      that changes what the typedef is typing.  */
4014   else
4015     {
4016       warning (OPT_Wattributes, "%qE attribute ignored", name);
4017       *no_add_attrs = true;
4018     }
4019
4020   return NULL_TREE;
4021 }
4022
4023 /* Handle a "nocommon" attribute; arguments as in
4024    struct attribute_spec.handler.  */
4025
4026 static tree
4027 handle_nocommon_attribute (tree *node, tree name,
4028                            tree ARG_UNUSED (args),
4029                            int ARG_UNUSED (flags), bool *no_add_attrs)
4030 {
4031   if (TREE_CODE (*node) == VAR_DECL)
4032     DECL_COMMON (*node) = 0;
4033   else
4034     {
4035       warning (OPT_Wattributes, "%qE attribute ignored", name);
4036       *no_add_attrs = true;
4037     }
4038
4039   return NULL_TREE;
4040 }
4041
4042 /* Handle a "common" attribute; arguments as in
4043    struct attribute_spec.handler.  */
4044
4045 static tree
4046 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4047                          int ARG_UNUSED (flags), bool *no_add_attrs)
4048 {
4049   if (TREE_CODE (*node) == VAR_DECL)
4050     DECL_COMMON (*node) = 1;
4051   else
4052     {
4053       warning (OPT_Wattributes, "%qE attribute ignored", name);
4054       *no_add_attrs = true;
4055     }
4056
4057   return NULL_TREE;
4058 }
4059
4060 /* Handle a "noreturn" attribute; arguments as in
4061    struct attribute_spec.handler.  */
4062
4063 static tree
4064 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4065                            int ARG_UNUSED (flags), bool *no_add_attrs)
4066 {
4067   tree type = TREE_TYPE (*node);
4068
4069   /* See FIXME comment in c_common_attribute_table.  */
4070   if (TREE_CODE (*node) == FUNCTION_DECL)
4071     TREE_THIS_VOLATILE (*node) = 1;
4072   else if (TREE_CODE (type) == POINTER_TYPE
4073            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4074     TREE_TYPE (*node)
4075       = build_pointer_type
4076         (build_type_variant (TREE_TYPE (type),
4077                              TYPE_READONLY (TREE_TYPE (type)), 1));
4078   else
4079     {
4080       warning (OPT_Wattributes, "%qE attribute ignored", name);
4081       *no_add_attrs = true;
4082     }
4083
4084   return NULL_TREE;
4085 }
4086
4087 /* Handle a "noinline" attribute; arguments as in
4088    struct attribute_spec.handler.  */
4089
4090 static tree
4091 handle_noinline_attribute (tree *node, tree name,
4092                            tree ARG_UNUSED (args),
4093                            int ARG_UNUSED (flags), bool *no_add_attrs)
4094 {
4095   if (TREE_CODE (*node) == FUNCTION_DECL)
4096     DECL_UNINLINABLE (*node) = 1;
4097   else
4098     {
4099       warning (OPT_Wattributes, "%qE attribute ignored", name);
4100       *no_add_attrs = true;
4101     }
4102
4103   return NULL_TREE;
4104 }
4105
4106 /* Handle a "always_inline" attribute; arguments as in
4107    struct attribute_spec.handler.  */
4108
4109 static tree
4110 handle_always_inline_attribute (tree *node, tree name,
4111                                 tree ARG_UNUSED (args),
4112                                 int ARG_UNUSED (flags),
4113                                 bool *no_add_attrs)
4114 {
4115   if (TREE_CODE (*node) == FUNCTION_DECL)
4116     {
4117       /* Do nothing else, just set the attribute.  We'll get at
4118          it later with lookup_attribute.  */
4119     }
4120   else
4121     {
4122       warning (OPT_Wattributes, "%qE attribute ignored", name);
4123       *no_add_attrs = true;
4124     }
4125
4126   return NULL_TREE;
4127 }
4128
4129 /* Handle a "flatten" attribute; arguments as in
4130    struct attribute_spec.handler.  */
4131
4132 static tree
4133 handle_flatten_attribute (tree *node, tree name,
4134                           tree args ATTRIBUTE_UNUSED,
4135                           int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4136 {
4137   if (TREE_CODE (*node) == FUNCTION_DECL)
4138     /* Do nothing else, just set the attribute.  We'll get at
4139        it later with lookup_attribute.  */
4140     ;
4141   else
4142     {
4143       warning (OPT_Wattributes, "%qE attribute ignored", name);
4144       *no_add_attrs = true;
4145     }
4146
4147   return NULL_TREE;
4148 }
4149
4150
4151 /* Handle a "used" attribute; arguments as in
4152    struct attribute_spec.handler.  */
4153
4154 static tree
4155 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4156                        int ARG_UNUSED (flags), bool *no_add_attrs)
4157 {
4158   tree node = *pnode;
4159
4160   if (TREE_CODE (node) == FUNCTION_DECL
4161       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4162     {
4163       TREE_USED (node) = 1;
4164       DECL_PRESERVE_P (node) = 1;
4165     }
4166   else
4167     {
4168       warning (OPT_Wattributes, "%qE attribute ignored", name);
4169       *no_add_attrs = true;
4170     }
4171
4172   return NULL_TREE;
4173 }
4174
4175 /* Handle a "unused" attribute; arguments as in
4176    struct attribute_spec.handler.  */
4177
4178 static tree
4179 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4180                          int flags, bool *no_add_attrs)
4181 {
4182   if (DECL_P (*node))
4183     {
4184       tree decl = *node;
4185
4186       if (TREE_CODE (decl) == PARM_DECL
4187           || TREE_CODE (decl) == VAR_DECL
4188           || TREE_CODE (decl) == FUNCTION_DECL
4189           || TREE_CODE (decl) == LABEL_DECL
4190           || TREE_CODE (decl) == TYPE_DECL)
4191         TREE_USED (decl) = 1;
4192       else
4193         {
4194           warning (OPT_Wattributes, "%qE attribute ignored", name);
4195           *no_add_attrs = true;
4196         }
4197     }
4198   else
4199     {
4200       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4201         *node = build_variant_type_copy (*node);
4202       TREE_USED (*node) = 1;
4203     }
4204
4205   return NULL_TREE;
4206 }
4207
4208 /* Handle a "externally_visible" attribute; arguments as in
4209    struct attribute_spec.handler.  */
4210
4211 static tree
4212 handle_externally_visible_attribute (tree *pnode, tree name,
4213                                      tree ARG_UNUSED (args),
4214                                      int ARG_UNUSED (flags),
4215                                      bool *no_add_attrs)
4216 {
4217   tree node = *pnode;
4218
4219   if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL)
4220       || !TREE_PUBLIC (node))
4221     {
4222       warning (OPT_Wattributes,
4223                "%qE attribute have effect only on public objects", name);
4224       *no_add_attrs = true;
4225     }
4226   else if (TREE_CODE (node) == FUNCTION_DECL)
4227     {
4228       struct cgraph_node *n = cgraph_node (node);
4229       n->local.externally_visible = true;
4230       if (n->local.finalized)
4231         cgraph_mark_needed_node (n);
4232     }
4233   else if (TREE_CODE (node) == VAR_DECL)
4234     {
4235       struct cgraph_varpool_node *n = cgraph_varpool_node (node);
4236       n->externally_visible = true;
4237       if (n->finalized)
4238         cgraph_varpool_mark_needed_node (n);
4239     }
4240   else
4241     {
4242       warning (OPT_Wattributes, "%qE attribute ignored", name);
4243       *no_add_attrs = true;
4244     }
4245
4246   return NULL_TREE;
4247 }
4248
4249 /* Handle a "const" attribute; arguments as in
4250    struct attribute_spec.handler.  */
4251
4252 static tree
4253 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4254                         int ARG_UNUSED (flags), bool *no_add_attrs)
4255 {
4256   tree type = TREE_TYPE (*node);
4257
4258   /* See FIXME comment on noreturn in c_common_attribute_table.  */
4259   if (TREE_CODE (*node) == FUNCTION_DECL)
4260     TREE_READONLY (*node) = 1;
4261   else if (TREE_CODE (type) == POINTER_TYPE
4262            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4263     TREE_TYPE (*node)
4264       = build_pointer_type
4265         (build_type_variant (TREE_TYPE (type), 1,
4266                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
4267   else
4268     {
4269       warning (OPT_Wattributes, "%qE attribute ignored", name);
4270       *no_add_attrs = true;
4271     }
4272
4273   return NULL_TREE;
4274 }
4275
4276 /* Handle a "transparent_union" attribute; arguments as in
4277    struct attribute_spec.handler.  */
4278
4279 static tree
4280 handle_transparent_union_attribute (tree *node, tree name,
4281                                     tree ARG_UNUSED (args), int flags,
4282                                     bool *no_add_attrs)
4283 {
4284   tree decl = NULL_TREE;
4285   tree *type = NULL;
4286   int is_type = 0;
4287
4288   if (DECL_P (*node))
4289     {
4290       decl = *node;
4291       type = &TREE_TYPE (decl);
4292       is_type = TREE_CODE (*node) == TYPE_DECL;
4293     }
4294   else if (TYPE_P (*node))
4295     type = node, is_type = 1;
4296
4297   if (is_type
4298       && TREE_CODE (*type) == UNION_TYPE
4299       && (decl == 0
4300           || (TYPE_FIELDS (*type) != 0
4301               && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4302     {
4303       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4304         *type = build_variant_type_copy (*type);
4305       TYPE_TRANSPARENT_UNION (*type) = 1;
4306     }
4307   else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4308            && TREE_CODE (*type) == UNION_TYPE
4309            && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4310     DECL_TRANSPARENT_UNION (decl) = 1;
4311   else
4312     {
4313       warning (OPT_Wattributes, "%qE attribute ignored", name);
4314       *no_add_attrs = true;
4315     }
4316
4317   return NULL_TREE;
4318 }
4319
4320 /* Handle a "constructor" attribute; arguments as in
4321    struct attribute_spec.handler.  */
4322
4323 static tree
4324 handle_constructor_attribute (tree *node, tree name,
4325                               tree ARG_UNUSED (args),
4326                               int ARG_UNUSED (flags),
4327                               bool *no_add_attrs)
4328 {
4329   tree decl = *node;
4330   tree type = TREE_TYPE (decl);
4331
4332   if (TREE_CODE (decl) == FUNCTION_DECL
4333       && TREE_CODE (type) == FUNCTION_TYPE
4334       && decl_function_context (decl) == 0)
4335     {
4336       DECL_STATIC_CONSTRUCTOR (decl) = 1;
4337       TREE_USED (decl) = 1;
4338     }
4339   else
4340     {
4341       warning (OPT_Wattributes, "%qE attribute ignored", name);
4342       *no_add_attrs = true;
4343     }
4344
4345   return NULL_TREE;
4346 }
4347
4348 /* Handle a "destructor" attribute; arguments as in
4349    struct attribute_spec.handler.  */
4350
4351 static tree
4352 handle_destructor_attribute (tree *node, tree name,
4353                              tree ARG_UNUSED (args),
4354                              int ARG_UNUSED (flags),
4355                              bool *no_add_attrs)
4356 {
4357   tree decl = *node;
4358   tree type = TREE_TYPE (decl);
4359
4360   if (TREE_CODE (decl) == FUNCTION_DECL
4361       && TREE_CODE (type) == FUNCTION_TYPE
4362       && decl_function_context (decl) == 0)
4363     {
4364       DECL_STATIC_DESTRUCTOR (decl) = 1;
4365       TREE_USED (decl) = 1;
4366     }
4367   else
4368     {
4369       warning (OPT_Wattributes, "%qE attribute ignored", name);
4370       *no_add_attrs = true;
4371     }
4372
4373   return NULL_TREE;
4374 }
4375
4376 /* Handle a "mode" attribute; arguments as in
4377    struct attribute_spec.handler.  */
4378
4379 static tree
4380 handle_mode_attribute (tree *node, tree name, tree args,
4381                        int ARG_UNUSED (flags), bool *no_add_attrs)
4382 {
4383   tree type = *node;
4384
4385   *no_add_attrs = true;
4386
4387   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4388     warning (OPT_Wattributes, "%qE attribute ignored", name);
4389   else
4390     {
4391       int j;
4392       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4393       int len = strlen (p);
4394       enum machine_mode mode = VOIDmode;
4395       tree typefm;
4396       bool valid_mode;
4397
4398       if (len > 4 && p[0] == '_' && p[1] == '_'
4399           && p[len - 1] == '_' && p[len - 2] == '_')
4400         {
4401           char *newp = (char *) alloca (len - 1);
4402
4403           strcpy (newp, &p[2]);
4404           newp[len - 4] = '\0';
4405           p = newp;
4406         }
4407
4408       /* Change this type to have a type with the specified mode.
4409          First check for the special modes.  */
4410       if (!strcmp (p, "byte"))
4411         mode = byte_mode;
4412       else if (!strcmp (p, "word"))
4413         mode = word_mode;
4414       else if (!strcmp (p, "pointer"))
4415         mode = ptr_mode;
4416       else
4417         for (j = 0; j < NUM_MACHINE_MODES; j++)
4418           if (!strcmp (p, GET_MODE_NAME (j)))
4419             {
4420               mode = (enum machine_mode) j;
4421               break;
4422             }
4423
4424       if (mode == VOIDmode)
4425         {
4426           error ("unknown machine mode %qs", p);
4427           return NULL_TREE;
4428         }
4429
4430       valid_mode = false;
4431       switch (GET_MODE_CLASS (mode))
4432         {
4433         case MODE_INT:
4434         case MODE_PARTIAL_INT:
4435         case MODE_FLOAT:
4436           valid_mode = targetm.scalar_mode_supported_p (mode);
4437           break;
4438
4439         case MODE_COMPLEX_INT:
4440         case MODE_COMPLEX_FLOAT:
4441           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4442           break;
4443
4444         case MODE_VECTOR_INT:
4445         case MODE_VECTOR_FLOAT:
4446           warning (OPT_Wattributes, "specifying vector types with "
4447                    "__attribute__ ((mode)) is deprecated");
4448           warning (OPT_Wattributes,
4449                    "use __attribute__ ((vector_size)) instead");
4450           valid_mode = vector_mode_valid_p (mode);
4451           break;
4452
4453         default:
4454           break;
4455         }
4456       if (!valid_mode)
4457         {
4458           error ("unable to emulate %qs", p);
4459           return NULL_TREE;
4460         }
4461
4462       if (POINTER_TYPE_P (type))
4463         {
4464           tree (*fn)(tree, enum machine_mode, bool);
4465
4466           if (!targetm.valid_pointer_mode (mode))
4467             {
4468               error ("invalid pointer mode %qs", p);
4469               return NULL_TREE;
4470             }
4471
4472           if (TREE_CODE (type) == POINTER_TYPE)
4473             fn = build_pointer_type_for_mode;
4474           else
4475             fn = build_reference_type_for_mode;
4476           typefm = fn (TREE_TYPE (type), mode, false);
4477         }
4478       else
4479         typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4480
4481       if (typefm == NULL_TREE)
4482         {
4483           error ("no data type for mode %qs", p);
4484           return NULL_TREE;
4485         }
4486       else if (TREE_CODE (type) == ENUMERAL_TYPE)
4487         {
4488           /* For enumeral types, copy the precision from the integer
4489              type returned above.  If not an INTEGER_TYPE, we can't use
4490              this mode for this type.  */
4491           if (TREE_CODE (typefm) != INTEGER_TYPE)
4492             {
4493               error ("cannot use mode %qs for enumeral types", p);
4494               return NULL_TREE;
4495             }
4496
4497           if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4498             type = build_variant_type_copy (type);
4499
4500           /* We cannot use layout_type here, because that will attempt
4501              to re-layout all variants, corrupting our original.  */
4502           TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4503           TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
4504           TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
4505           TYPE_SIZE (type) = TYPE_SIZE (typefm);
4506           TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
4507           TYPE_MODE (type) = TYPE_MODE (typefm);
4508           if (!TYPE_USER_ALIGN (type))
4509             TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
4510
4511           typefm = type;
4512         }
4513       else if (VECTOR_MODE_P (mode)
4514                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4515                : TREE_CODE (type) != TREE_CODE (typefm))
4516         {
4517           error ("mode %qs applied to inappropriate type", p);
4518           return NULL_TREE;
4519         }
4520
4521       *node = typefm;
4522     }
4523
4524   return NULL_TREE;
4525 }
4526
4527 /* Handle a "section" attribute; arguments as in
4528    struct attribute_spec.handler.  */
4529
4530 static tree
4531 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4532                           int ARG_UNUSED (flags), bool *no_add_attrs)
4533 {
4534   tree decl = *node;
4535
4536   if (targetm.have_named_sections)
4537     {
4538       user_defined_section_attribute = true;
4539
4540       if ((TREE_CODE (decl) == FUNCTION_DECL
4541            || TREE_CODE (decl) == VAR_DECL)
4542           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4543         {
4544           if (TREE_CODE (decl) == VAR_DECL
4545               && current_function_decl != NULL_TREE
4546               && !TREE_STATIC (decl))
4547             {
4548               error ("%Jsection attribute cannot be specified for "
4549                      "local variables", decl);
4550               *no_add_attrs = true;
4551             }
4552
4553           /* The decl may have already been given a section attribute
4554              from a previous declaration.  Ensure they match.  */
4555           else if (DECL_SECTION_NAME (decl) != NULL_TREE
4556                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4557                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4558             {
4559               error ("section of %q+D conflicts with previous declaration",
4560                      *node);
4561               *no_add_attrs = true;
4562             }
4563           else
4564             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4565         }
4566       else
4567         {
4568           error ("section attribute not allowed for %q+D", *node);
4569           *no_add_attrs = true;
4570         }
4571     }
4572   else
4573     {
4574       error ("%Jsection attributes are not supported for this target", *node);
4575       *no_add_attrs = true;
4576     }
4577
4578   return NULL_TREE;
4579 }
4580
4581 /* Handle a "aligned" attribute; arguments as in
4582    struct attribute_spec.handler.  */
4583
4584 static tree
4585 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4586                           int flags, bool *no_add_attrs)
4587 {
4588   tree decl = NULL_TREE;
4589   tree *type = NULL;
4590   int is_type = 0;
4591   tree align_expr = (args ? TREE_VALUE (args)
4592                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4593   int i;
4594
4595   if (DECL_P (*node))
4596     {
4597       decl = *node;
4598       type = &TREE_TYPE (decl);
4599       is_type = TREE_CODE (*node) == TYPE_DECL;
4600     }
4601   else if (TYPE_P (*node))
4602     type = node, is_type = 1;
4603
4604   if (TREE_CODE (align_expr) != INTEGER_CST)
4605     {
4606       error ("requested alignment is not a constant");
4607       *no_add_attrs = true;
4608     }
4609   else if ((i = tree_log2 (align_expr)) == -1)
4610     {
4611       error ("requested alignment is not a power of 2");
4612       *no_add_attrs = true;
4613     }
4614   else if (i > HOST_BITS_PER_INT - 2)
4615     {
4616       error ("requested alignment is too large");
4617       *no_add_attrs = true;
4618     }
4619   else if (is_type)
4620     {
4621       /* If we have a TYPE_DECL, then copy the type, so that we
4622          don't accidentally modify a builtin type.  See pushdecl.  */
4623       if (decl && TREE_TYPE (decl) != error_mark_node
4624           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4625         {
4626           tree tt = TREE_TYPE (decl);
4627           *type = build_variant_type_copy (*type);
4628           DECL_ORIGINAL_TYPE (decl) = tt;
4629           TYPE_NAME (*type) = decl;
4630           TREE_USED (*type) = TREE_USED (decl);
4631           TREE_TYPE (decl) = *type;
4632         }
4633       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4634         *type = build_variant_type_copy (*type);
4635
4636       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4637       TYPE_USER_ALIGN (*type) = 1;
4638     }
4639   else if (TREE_CODE (decl) != VAR_DECL
4640            && TREE_CODE (decl) != FIELD_DECL)
4641     {
4642       error ("alignment may not be specified for %q+D", decl);
4643       *no_add_attrs = true;
4644     }
4645   else
4646     {
4647       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4648       DECL_USER_ALIGN (decl) = 1;
4649     }
4650
4651   return NULL_TREE;
4652 }
4653
4654 /* Handle a "weak" attribute; arguments as in
4655    struct attribute_spec.handler.  */
4656
4657 static tree
4658 handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
4659                        tree ARG_UNUSED (args),
4660                        int ARG_UNUSED (flags),
4661                        bool * ARG_UNUSED (no_add_attrs))
4662 {
4663   declare_weak (*node);
4664
4665   return NULL_TREE;
4666 }
4667
4668 /* Handle an "alias" attribute; arguments as in
4669    struct attribute_spec.handler.  */
4670
4671 static tree
4672 handle_alias_attribute (tree *node, tree name, tree args,
4673                         int ARG_UNUSED (flags), bool *no_add_attrs)
4674 {
4675   tree decl = *node;
4676
4677   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4678       || (TREE_CODE (decl) != FUNCTION_DECL && !DECL_EXTERNAL (decl)))
4679     {
4680       error ("%q+D defined both normally and as an alias", decl);
4681       *no_add_attrs = true;
4682     }
4683
4684   /* Note that the very first time we process a nested declaration,
4685      decl_function_context will not be set.  Indeed, *would* never
4686      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4687      we do below.  After such frobbery, pushdecl would set the context.
4688      In any case, this is never what we want.  */
4689   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4690     {
4691       tree id;
4692
4693       id = TREE_VALUE (args);
4694       if (TREE_CODE (id) != STRING_CST)
4695         {
4696           error ("alias argument not a string");
4697           *no_add_attrs = true;
4698           return NULL_TREE;
4699         }
4700       id = get_identifier (TREE_STRING_POINTER (id));
4701       /* This counts as a use of the object pointed to.  */
4702       TREE_USED (id) = 1;
4703
4704       if (TREE_CODE (decl) == FUNCTION_DECL)
4705         DECL_INITIAL (decl) = error_mark_node;
4706       else
4707         {
4708           DECL_EXTERNAL (decl) = 0;
4709           TREE_STATIC (decl) = 1;
4710         }
4711     }
4712   else
4713     {
4714       warning (OPT_Wattributes, "%qE attribute ignored", name);
4715       *no_add_attrs = true;
4716     }
4717
4718   return NULL_TREE;
4719 }
4720
4721 /* Handle an "visibility" attribute; arguments as in
4722    struct attribute_spec.handler.  */
4723
4724 static tree
4725 handle_visibility_attribute (tree *node, tree name, tree args,
4726                              int ARG_UNUSED (flags),
4727                              bool *no_add_attrs)
4728 {
4729   tree decl = *node;
4730   tree id = TREE_VALUE (args);
4731
4732   *no_add_attrs = true;
4733
4734   if (TYPE_P (*node))
4735     {
4736       if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4737        {
4738          warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
4739                   name);
4740          return NULL_TREE;
4741        }
4742     }
4743   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4744     {
4745       warning (OPT_Wattributes, "%qE attribute ignored", name);
4746       return NULL_TREE;
4747     }
4748
4749   if (TREE_CODE (id) != STRING_CST)
4750     {
4751       error ("visibility argument not a string");
4752       return NULL_TREE;
4753     }
4754
4755   /*  If this is a type, set the visibility on the type decl.  */
4756   if (TYPE_P (decl))
4757     {
4758       decl = TYPE_NAME (decl);
4759       if (!decl)
4760         return NULL_TREE;
4761       if (TREE_CODE (decl) == IDENTIFIER_NODE)
4762         {
4763            warning (OPT_Wattributes, "%qE attribute ignored on types",
4764                     name);
4765            return NULL_TREE;
4766         }
4767     }
4768
4769   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4770     DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4771   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4772     DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4773   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4774     DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4775   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4776     DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4777   else
4778     error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4779   DECL_VISIBILITY_SPECIFIED (decl) = 1;
4780
4781   /* For decls only, go ahead and attach the attribute to the node as well.
4782      This is needed so we can determine whether we have VISIBILITY_DEFAULT
4783      because the visibility was not specified, or because it was explicitly
4784      overridden from the class visibility.  */
4785   if (DECL_P (*node))
4786     *no_add_attrs = false;
4787
4788   return NULL_TREE;
4789 }
4790
4791 /* Determine the ELF symbol visibility for DECL, which is either a
4792    variable or a function.  It is an error to use this function if a
4793    definition of DECL is not available in this translation unit.
4794    Returns true if the final visibility has been determined by this
4795    function; false if the caller is free to make additional
4796    modifications.  */
4797
4798 bool
4799 c_determine_visibility (tree decl)
4800 {
4801   gcc_assert (TREE_CODE (decl) == VAR_DECL
4802               || TREE_CODE (decl) == FUNCTION_DECL);
4803
4804   /* If the user explicitly specified the visibility with an
4805      attribute, honor that.  DECL_VISIBILITY will have been set during
4806      the processing of the attribute.  We check for an explicit
4807      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
4808      to distinguish the use of an attribute from the use of a "#pragma
4809      GCC visibility push(...)"; in the latter case we still want other
4810      considerations to be able to overrule the #pragma.  */
4811   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
4812     return true;
4813
4814   /* Anything that is exported must have default visibility.  */
4815   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
4816       && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
4817     {
4818       DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4819       DECL_VISIBILITY_SPECIFIED (decl) = 1;
4820       return true;
4821     }
4822
4823   return false;
4824 }
4825
4826 /* Handle an "tls_model" attribute; arguments as in
4827    struct attribute_spec.handler.  */
4828
4829 static tree
4830 handle_tls_model_attribute (tree *node, tree name, tree args,
4831                             int ARG_UNUSED (flags), bool *no_add_attrs)
4832 {
4833   tree id;
4834   tree decl = *node;
4835   enum tls_model kind;
4836
4837   *no_add_attrs = true;
4838
4839   if (!DECL_THREAD_LOCAL_P (decl))
4840     {
4841       warning (OPT_Wattributes, "%qE attribute ignored", name);
4842       return NULL_TREE;
4843     }
4844
4845   kind = DECL_TLS_MODEL (decl);
4846   id = TREE_VALUE (args);
4847   if (TREE_CODE (id) != STRING_CST)
4848     {
4849       error ("tls_model argument not a string");
4850       return NULL_TREE;
4851     }
4852
4853   if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
4854     kind = TLS_MODEL_LOCAL_EXEC;
4855   else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
4856     kind = TLS_MODEL_INITIAL_EXEC;
4857   else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
4858     kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
4859   else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4860     kind = TLS_MODEL_GLOBAL_DYNAMIC;
4861   else
4862     error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4863
4864   DECL_TLS_MODEL (decl) = kind;
4865   return NULL_TREE;
4866 }
4867
4868 /* Handle a "no_instrument_function" attribute; arguments as in
4869    struct attribute_spec.handler.  */
4870
4871 static tree
4872 handle_no_instrument_function_attribute (tree *node, tree name,
4873                                          tree ARG_UNUSED (args),
4874                                          int ARG_UNUSED (flags),
4875                                          bool *no_add_attrs)
4876 {
4877   tree decl = *node;
4878
4879   if (TREE_CODE (decl) != FUNCTION_DECL)
4880     {
4881       error ("%J%qE attribute applies only to functions", decl, name);
4882       *no_add_attrs = true;
4883     }
4884   else if (DECL_INITIAL (decl))
4885     {
4886       error ("%Jcan%'t set %qE attribute after definition", decl, name);
4887       *no_add_attrs = true;
4888     }
4889   else
4890     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4891
4892   return NULL_TREE;
4893 }
4894
4895 /* Handle a "malloc" attribute; arguments as in
4896    struct attribute_spec.handler.  */
4897
4898 static tree
4899 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4900                          int ARG_UNUSED (flags), bool *no_add_attrs)
4901 {
4902   if (TREE_CODE (*node) == FUNCTION_DECL
4903       && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
4904     DECL_IS_MALLOC (*node) = 1;
4905   else
4906     {
4907       warning (OPT_Wattributes, "%qE attribute ignored", name);
4908       *no_add_attrs = true;
4909     }
4910
4911   return NULL_TREE;
4912 }
4913
4914 /* Handle a "returns_twice" attribute; arguments as in
4915    struct attribute_spec.handler.  */
4916
4917 static tree
4918 handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4919                          int ARG_UNUSED (flags), bool *no_add_attrs)
4920 {
4921   if (TREE_CODE (*node) == FUNCTION_DECL)
4922     DECL_IS_RETURNS_TWICE (*node) = 1;
4923   else
4924     {
4925       warning (OPT_Wattributes, "%qE attribute ignored", name);
4926       *no_add_attrs = true;
4927     }
4928
4929   return NULL_TREE;
4930 }
4931
4932 /* Handle a "no_limit_stack" attribute; arguments as in
4933    struct attribute_spec.handler.  */
4934
4935 static tree
4936 handle_no_limit_stack_attribute (tree *node, tree name,
4937                                  tree ARG_UNUSED (args),
4938                                  int ARG_UNUSED (flags),
4939                                  bool *no_add_attrs)
4940 {
4941   tree decl = *node;
4942
4943   if (TREE_CODE (decl) != FUNCTION_DECL)
4944     {
4945       error ("%J%qE attribute applies only to functions", decl, name);
4946       *no_add_attrs = true;
4947     }
4948   else if (DECL_INITIAL (decl))
4949     {
4950       error ("%Jcan%'t set %qE attribute after definition", decl, name);
4951       *no_add_attrs = true;
4952     }
4953   else
4954     DECL_NO_LIMIT_STACK (decl) = 1;
4955
4956   return NULL_TREE;
4957 }
4958
4959 /* Handle a "pure" attribute; arguments as in
4960    struct attribute_spec.handler.  */
4961
4962 static tree
4963 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4964                        int ARG_UNUSED (flags), bool *no_add_attrs)
4965 {
4966   if (TREE_CODE (*node) == FUNCTION_DECL)
4967     DECL_IS_PURE (*node) = 1;
4968   /* ??? TODO: Support types.  */
4969   else
4970     {
4971       warning (OPT_Wattributes, "%qE attribute ignored", name);
4972       *no_add_attrs = true;
4973     }
4974
4975   return NULL_TREE;
4976 }
4977
4978 /* Handle a "no vops" attribute; arguments as in
4979    struct attribute_spec.handler.  */
4980
4981 static tree
4982 handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
4983                          tree ARG_UNUSED (args), int ARG_UNUSED (flags),
4984                          bool *ARG_UNUSED (no_add_attrs))
4985 {
4986   gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
4987   DECL_IS_NOVOPS (*node) = 1;
4988   return NULL_TREE;
4989 }
4990
4991 /* Handle a "deprecated" attribute; arguments as in
4992    struct attribute_spec.handler.  */
4993
4994 static tree
4995 handle_deprecated_attribute (tree *node, tree name,
4996                              tree ARG_UNUSED (args), int flags,
4997                              bool *no_add_attrs)
4998 {
4999   tree type = NULL_TREE;
5000   int warn = 0;
5001   tree what = NULL_TREE;
5002
5003   if (DECL_P (*node))
5004     {
5005       tree decl = *node;
5006       type = TREE_TYPE (decl);
5007
5008       if (TREE_CODE (decl) == TYPE_DECL
5009           || TREE_CODE (decl) == PARM_DECL
5010           || TREE_CODE (decl) == VAR_DECL
5011           || TREE_CODE (decl) == FUNCTION_DECL
5012           || TREE_CODE (decl) == FIELD_DECL)
5013         TREE_DEPRECATED (decl) = 1;
5014       else
5015         warn = 1;
5016     }
5017   else if (TYPE_P (*node))
5018     {
5019       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5020         *node = build_variant_type_copy (*node);
5021       TREE_DEPRECATED (*node) = 1;
5022       type = *node;
5023     }
5024   else
5025     warn = 1;
5026
5027   if (warn)
5028     {
5029       *no_add_attrs = true;
5030       if (type && TYPE_NAME (type))
5031         {
5032           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5033             what = TYPE_NAME (*node);
5034           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5035                    && DECL_NAME (TYPE_NAME (type)))
5036             what = DECL_NAME (TYPE_NAME (type));
5037         }
5038       if (what)
5039         warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5040       else
5041         warning (OPT_Wattributes, "%qE attribute ignored", name);
5042     }
5043
5044   return NULL_TREE;
5045 }
5046
5047 /* Handle a "vector_size" attribute; arguments as in
5048    struct attribute_spec.handler.  */
5049
5050 static tree
5051 handle_vector_size_attribute (tree *node, tree name, tree args,
5052                               int ARG_UNUSED (flags),
5053                               bool *no_add_attrs)
5054 {
5055   unsigned HOST_WIDE_INT vecsize, nunits;
5056   enum machine_mode orig_mode;
5057   tree type = *node, new_type, size;
5058
5059   *no_add_attrs = true;
5060
5061   size = TREE_VALUE (args);
5062
5063   if (!host_integerp (size, 1))
5064     {
5065       warning (OPT_Wattributes, "%qE attribute ignored", name);
5066       return NULL_TREE;
5067     }
5068
5069   /* Get the vector size (in bytes).  */
5070   vecsize = tree_low_cst (size, 1);
5071
5072   /* We need to provide for vector pointers, vector arrays, and
5073      functions returning vectors.  For example:
5074
5075        __attribute__((vector_size(16))) short *foo;
5076
5077      In this case, the mode is SI, but the type being modified is
5078      HI, so we need to look further.  */
5079
5080   while (POINTER_TYPE_P (type)
5081          || TREE_CODE (type) == FUNCTION_TYPE
5082          || TREE_CODE (type) == METHOD_TYPE
5083          || TREE_CODE (type) == ARRAY_TYPE)
5084     type = TREE_TYPE (type);
5085
5086   /* Get the mode of the type being modified.  */
5087   orig_mode = TYPE_MODE (type);
5088
5089   if (TREE_CODE (type) == RECORD_TYPE
5090       || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5091           && GET_MODE_CLASS (orig_mode) != MODE_INT)
5092       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5093     {
5094       error ("invalid vector type for attribute %qE", name);
5095       return NULL_TREE;
5096     }
5097
5098   /* Calculate how many units fit in the vector.  */
5099   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5100   if (nunits & (nunits - 1))
5101     {
5102       error ("number of components of the vector not a power of two");
5103       return NULL_TREE;
5104     }
5105
5106   new_type = build_vector_type (type, nunits);
5107
5108   /* Build back pointers if needed.  */
5109   *node = reconstruct_complex_type (*node, new_type);
5110
5111   return NULL_TREE;
5112 }
5113
5114 /* Handle the "nonnull" attribute.  */
5115 static tree
5116 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5117                           tree args, int ARG_UNUSED (flags),
5118                           bool *no_add_attrs)
5119 {
5120   tree type = *node;
5121   unsigned HOST_WIDE_INT attr_arg_num;
5122
5123   /* If no arguments are specified, all pointer arguments should be
5124      non-null.  Verify a full prototype is given so that the arguments
5125      will have the correct types when we actually check them later.  */
5126   if (!args)
5127     {
5128       if (!TYPE_ARG_TYPES (type))
5129         {
5130           error ("nonnull attribute without arguments on a non-prototype");
5131           *no_add_attrs = true;
5132         }
5133       return NULL_TREE;
5134     }
5135
5136   /* Argument list specified.  Verify that each argument number references
5137      a pointer argument.  */
5138   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5139     {
5140       tree argument;
5141       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5142
5143       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5144         {
5145           error ("nonnull argument has invalid operand number (argument %lu)",
5146                  (unsigned long) attr_arg_num);
5147           *no_add_attrs = true;
5148           return NULL_TREE;
5149         }
5150
5151       argument = TYPE_ARG_TYPES (type);
5152       if (argument)
5153         {
5154           for (ck_num = 1; ; ck_num++)
5155             {
5156               if (!argument || ck_num == arg_num)
5157                 break;
5158               argument = TREE_CHAIN (argument);
5159             }
5160
5161           if (!argument
5162               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5163             {
5164               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5165                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
5166               *no_add_attrs = true;
5167               return NULL_TREE;
5168             }
5169
5170           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5171             {
5172               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5173                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
5174               *no_add_attrs = true;
5175               return NULL_TREE;
5176             }
5177         }
5178     }
5179
5180   return NULL_TREE;
5181 }
5182
5183 /* Check the argument list of a function call for null in argument slots
5184    that are marked as requiring a non-null pointer argument.  */
5185
5186 static void
5187 check_function_nonnull (tree attrs, tree params)
5188 {
5189   tree a, args, param;
5190   int param_num;
5191
5192   for (a = attrs; a; a = TREE_CHAIN (a))
5193     {
5194       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5195         {
5196           args = TREE_VALUE (a);
5197
5198           /* Walk the argument list.  If we encounter an argument number we
5199              should check for non-null, do it.  If the attribute has no args,
5200              then every pointer argument is checked (in which case the check
5201              for pointer type is done in check_nonnull_arg).  */
5202           for (param = params, param_num = 1; ;
5203                param_num++, param = TREE_CHAIN (param))
5204             {
5205               if (!param)
5206         break;
5207               if (!args || nonnull_check_p (args, param_num))
5208         check_function_arguments_recurse (check_nonnull_arg, NULL,
5209                                           TREE_VALUE (param),
5210                                           param_num);
5211             }
5212         }
5213     }
5214 }
5215
5216 /* Check that the Nth argument of a function call (counting backwards
5217    from the end) is a (pointer)0.  */
5218
5219 static void
5220 check_function_sentinel (tree attrs, tree params, tree typelist)
5221 {
5222   tree attr = lookup_attribute ("sentinel", attrs);
5223
5224   if (attr)
5225     {
5226       /* Skip over the named arguments.  */
5227       while (typelist && params)
5228       {
5229         typelist = TREE_CHAIN (typelist);
5230         params = TREE_CHAIN (params);
5231       }
5232
5233       if (typelist || !params)
5234         warning (OPT_Wformat,
5235                  "not enough variable arguments to fit a sentinel");
5236       else
5237         {
5238           tree sentinel, end;
5239           unsigned pos = 0;
5240
5241           if (TREE_VALUE (attr))
5242             {
5243               tree p = TREE_VALUE (TREE_VALUE (attr));
5244               pos = TREE_INT_CST_LOW (p);
5245             }
5246
5247           sentinel = end = params;
5248
5249           /* Advance `end' ahead of `sentinel' by `pos' positions.  */
5250           while (pos > 0 && TREE_CHAIN (end))
5251             {
5252               pos--;
5253               end = TREE_CHAIN (end);
5254             }
5255           if (pos > 0)
5256             {
5257               warning (OPT_Wformat,
5258                        "not enough variable arguments to fit a sentinel");
5259               return;
5260             }
5261
5262           /* Now advance both until we find the last parameter.  */
5263           while (TREE_CHAIN (end))
5264             {
5265               end = TREE_CHAIN (end);
5266               sentinel = TREE_CHAIN (sentinel);
5267             }
5268
5269           /* Validate the sentinel.  */
5270           if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5271                || !integer_zerop (TREE_VALUE (sentinel)))
5272               /* Although __null (in C++) is only an integer we allow it
5273                  nevertheless, as we are guaranteed that it's exactly
5274                  as wide as a pointer, and we don't want to force
5275                  users to cast the NULL they have written there.
5276                  We warn with -Wstrict-null-sentinel, though.  */
5277               && (warn_strict_null_sentinel
5278                   || null_node != TREE_VALUE (sentinel)))
5279             warning (OPT_Wformat, "missing sentinel in function call");
5280         }
5281     }
5282 }
5283
5284 /* Helper for check_function_nonnull; given a list of operands which
5285    must be non-null in ARGS, determine if operand PARAM_NUM should be
5286    checked.  */
5287
5288 static bool
5289 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5290 {
5291   unsigned HOST_WIDE_INT arg_num = 0;
5292
5293   for (; args; args = TREE_CHAIN (args))
5294     {
5295       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5296
5297       gcc_assert (found);
5298
5299       if (arg_num == param_num)
5300         return true;
5301     }
5302   return false;
5303 }
5304
5305 /* Check that the function argument PARAM (which is operand number
5306    PARAM_NUM) is non-null.  This is called by check_function_nonnull
5307    via check_function_arguments_recurse.  */
5308
5309 static void
5310 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5311                    unsigned HOST_WIDE_INT param_num)
5312 {
5313   /* Just skip checking the argument if it's not a pointer.  This can
5314      happen if the "nonnull" attribute was given without an operand
5315      list (which means to check every pointer argument).  */
5316
5317   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5318     return;
5319
5320   if (integer_zerop (param))
5321     warning (OPT_Wnonnull, "null argument where non-null required "
5322              "(argument %lu)", (unsigned long) param_num);
5323 }
5324
5325 /* Helper for nonnull attribute handling; fetch the operand number
5326    from the attribute argument list.  */
5327
5328 static bool
5329 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5330 {
5331   /* Verify the arg number is a constant.  */
5332   if (TREE_CODE (arg_num_expr) != INTEGER_CST
5333       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5334     return false;
5335
5336   *valp = TREE_INT_CST_LOW (arg_num_expr);
5337   return true;
5338 }
5339
5340 /* Handle a "nothrow" attribute; arguments as in
5341    struct attribute_spec.handler.  */
5342
5343 static tree
5344 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5345                           int ARG_UNUSED (flags), bool *no_add_attrs)
5346 {
5347   if (TREE_CODE (*node) == FUNCTION_DECL)
5348     TREE_NOTHROW (*node) = 1;
5349   /* ??? TODO: Support types.  */
5350   else
5351     {
5352       warning (OPT_Wattributes, "%qE attribute ignored", name);
5353       *no_add_attrs = true;
5354     }
5355
5356   return NULL_TREE;
5357 }
5358
5359 /* Handle a "cleanup" attribute; arguments as in
5360    struct attribute_spec.handler.  */
5361
5362 static tree
5363 handle_cleanup_attribute (tree *node, tree name, tree args,
5364                           int ARG_UNUSED (flags), bool *no_add_attrs)
5365 {
5366   tree decl = *node;
5367   tree cleanup_id, cleanup_decl;
5368
5369   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5370      for global destructors in C++.  This requires infrastructure that
5371      we don't have generically at the moment.  It's also not a feature
5372      we'd be missing too much, since we do have attribute constructor.  */
5373   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5374     {
5375       warning (OPT_Wattributes, "%qE attribute ignored", name);
5376       *no_add_attrs = true;
5377       return NULL_TREE;
5378     }
5379
5380   /* Verify that the argument is a function in scope.  */
5381   /* ??? We could support pointers to functions here as well, if
5382      that was considered desirable.  */
5383   cleanup_id = TREE_VALUE (args);
5384   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5385     {
5386       error ("cleanup argument not an identifier");
5387       *no_add_attrs = true;
5388       return NULL_TREE;
5389     }
5390   cleanup_decl = lookup_name (cleanup_id);
5391   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5392     {
5393       error ("cleanup argument not a function");
5394       *no_add_attrs = true;
5395       return NULL_TREE;
5396     }
5397
5398   /* That the function has proper type is checked with the
5399      eventual call to build_function_call.  */
5400
5401   return NULL_TREE;
5402 }
5403
5404 /* Handle a "warn_unused_result" attribute.  No special handling.  */
5405
5406 static tree
5407 handle_warn_unused_result_attribute (tree *node, tree name,
5408                                tree ARG_UNUSED (args),
5409                                int ARG_UNUSED (flags), bool *no_add_attrs)
5410 {
5411   /* Ignore the attribute for functions not returning any value.  */
5412   if (VOID_TYPE_P (TREE_TYPE (*node)))
5413     {
5414       warning (OPT_Wattributes, "%qE attribute ignored", name);
5415       *no_add_attrs = true;
5416     }
5417
5418   return NULL_TREE;
5419 }
5420
5421 /* Handle a "sentinel" attribute.  */
5422
5423 static tree
5424 handle_sentinel_attribute (tree *node, tree name, tree args,
5425                            int ARG_UNUSED (flags), bool *no_add_attrs)
5426 {
5427   tree params = TYPE_ARG_TYPES (*node);
5428
5429   if (!params)
5430     {
5431       warning (OPT_Wattributes,
5432                "%qE attribute requires prototypes with named arguments", name);
5433       *no_add_attrs = true;
5434     }
5435   else
5436     {
5437       while (TREE_CHAIN (params))
5438         params = TREE_CHAIN (params);
5439
5440       if (VOID_TYPE_P (TREE_VALUE (params)))
5441         {
5442           warning (OPT_Wattributes,
5443                    "%qE attribute only applies to variadic functions", name);
5444           *no_add_attrs = true;
5445         }
5446     }
5447
5448   if (args)
5449     {
5450       tree position = TREE_VALUE (args);
5451
5452       if (TREE_CODE (position) != INTEGER_CST)
5453         {
5454           warning (0, "requested position is not an integer constant");
5455           *no_add_attrs = true;
5456         }
5457       else
5458         {
5459           if (tree_int_cst_lt (position, integer_zero_node))
5460             {
5461               warning (0, "requested position is less than zero");
5462               *no_add_attrs = true;
5463             }
5464         }
5465     }
5466
5467   return NULL_TREE;
5468 }
5469 \f
5470 /* Check for valid arguments being passed to a function.  */
5471 void
5472 check_function_arguments (tree attrs, tree params, tree typelist)
5473 {
5474   /* Check for null being passed in a pointer argument that must be
5475      non-null.  We also need to do this if format checking is enabled.  */
5476
5477   if (warn_nonnull)
5478     check_function_nonnull (attrs, params);
5479
5480   /* Check for errors in format strings.  */
5481
5482   if (warn_format || warn_missing_format_attribute)
5483       check_function_format (attrs, params);
5484
5485   if (warn_format)
5486     check_function_sentinel (attrs, params, typelist);
5487 }
5488
5489 /* Generic argument checking recursion routine.  PARAM is the argument to
5490    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
5491    once the argument is resolved.  CTX is context for the callback.  */
5492 void
5493 check_function_arguments_recurse (void (*callback)
5494                                   (void *, tree, unsigned HOST_WIDE_INT),
5495                                   void *ctx, tree param,
5496                                   unsigned HOST_WIDE_INT param_num)
5497 {
5498   if (TREE_CODE (param) == NOP_EXPR)
5499     {
5500       /* Strip coercion.  */
5501       check_function_arguments_recurse (callback, ctx,
5502                                         TREE_OPERAND (param, 0), param_num);
5503       return;
5504     }
5505
5506   if (TREE_CODE (param) == CALL_EXPR)
5507     {
5508       tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5509       tree attrs;
5510       bool found_format_arg = false;
5511
5512       /* See if this is a call to a known internationalization function
5513          that modifies a format arg.  Such a function may have multiple
5514          format_arg attributes (for example, ngettext).  */
5515
5516       for (attrs = TYPE_ATTRIBUTES (type);
5517            attrs;
5518            attrs = TREE_CHAIN (attrs))
5519         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5520           {
5521             tree inner_args;
5522             tree format_num_expr;
5523             int format_num;
5524             int i;
5525
5526             /* Extract the argument number, which was previously checked
5527                to be valid.  */
5528             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5529
5530             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5531                         && !TREE_INT_CST_HIGH (format_num_expr));
5532
5533             format_num = TREE_INT_CST_LOW (format_num_expr);
5534
5535             for (inner_args = TREE_OPERAND (param, 1), i = 1;
5536                  inner_args != 0;
5537                  inner_args = TREE_CHAIN (inner_args), i++)
5538               if (i == format_num)
5539                 {
5540                   check_function_arguments_recurse (callback, ctx,
5541                                                     TREE_VALUE (inner_args),
5542                                                     param_num);
5543                   found_format_arg = true;
5544                   break;
5545                 }
5546           }
5547
5548       /* If we found a format_arg attribute and did a recursive check,
5549          we are done with checking this argument.  Otherwise, we continue
5550          and this will be considered a non-literal.  */
5551       if (found_format_arg)
5552         return;
5553     }
5554
5555   if (TREE_CODE (param) == COND_EXPR)
5556     {
5557       /* Check both halves of the conditional expression.  */
5558       check_function_arguments_recurse (callback, ctx,
5559                                         TREE_OPERAND (param, 1), param_num);
5560       check_function_arguments_recurse (callback, ctx,
5561                                         TREE_OPERAND (param, 2), param_num);
5562       return;
5563     }
5564
5565   (*callback) (ctx, param, param_num);
5566 }
5567
5568 /* Function to help qsort sort FIELD_DECLs by name order.  */
5569
5570 int
5571 field_decl_cmp (const void *x_p, const void *y_p)
5572 {
5573   const tree *const x = (const tree *const) x_p;
5574   const tree *const y = (const tree *const) y_p;
5575
5576   if (DECL_NAME (*x) == DECL_NAME (*y))
5577     /* A nontype is "greater" than a type.  */
5578     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5579   if (DECL_NAME (*x) == NULL_TREE)
5580     return -1;
5581   if (DECL_NAME (*y) == NULL_TREE)
5582     return 1;
5583   if (DECL_NAME (*x) < DECL_NAME (*y))
5584     return -1;
5585   return 1;
5586 }
5587
5588 static struct {
5589   gt_pointer_operator new_value;
5590   void *cookie;
5591 } resort_data;
5592
5593 /* This routine compares two fields like field_decl_cmp but using the
5594 pointer operator in resort_data.  */
5595
5596 static int
5597 resort_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   {
5610     tree d1 = DECL_NAME (*x);
5611     tree d2 = DECL_NAME (*y);
5612     resort_data.new_value (&d1, resort_data.cookie);
5613     resort_data.new_value (&d2, resort_data.cookie);
5614     if (d1 < d2)
5615       return -1;
5616   }
5617   return 1;
5618 }
5619
5620 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
5621
5622 void
5623 resort_sorted_fields (void *obj,
5624                       void * ARG_UNUSED (orig_obj),
5625                       gt_pointer_operator new_value,
5626                       void *cookie)
5627 {
5628   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5629   resort_data.new_value = new_value;
5630   resort_data.cookie = cookie;
5631   qsort (&sf->elts[0], sf->len, sizeof (tree),
5632          resort_field_decl_cmp);
5633 }
5634
5635 /* Subroutine of c_parse_error.
5636    Return the result of concatenating LHS and RHS. RHS is really
5637    a string literal, its first character is indicated by RHS_START and
5638    RHS_SIZE is its length (including the terminating NUL character).
5639
5640    The caller is responsible for deleting the returned pointer.  */
5641
5642 static char *
5643 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5644 {
5645   const int lhs_size = strlen (lhs);
5646   char *result = XNEWVEC (char, lhs_size + rhs_size);
5647   strncpy (result, lhs, lhs_size);
5648   strncpy (result + lhs_size, rhs_start, rhs_size);
5649   return result;
5650 }
5651
5652 /* Issue the error given by GMSGID, indicating that it occurred before
5653    TOKEN, which had the associated VALUE.  */
5654
5655 void
5656 c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
5657 {
5658 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5659
5660   char *message = NULL;
5661
5662   if (token == CPP_EOF)
5663     message = catenate_messages (gmsgid, " at end of input");
5664   else if (token == CPP_CHAR || token == CPP_WCHAR)
5665     {
5666       unsigned int val = TREE_INT_CST_LOW (value);
5667       const char *const ell = (token == CPP_CHAR) ? "" : "L";
5668       if (val <= UCHAR_MAX && ISGRAPH (val))
5669         message = catenate_messages (gmsgid, " before %s'%c'");
5670       else
5671         message = catenate_messages (gmsgid, " before %s'\\x%x'");
5672
5673       error (message, ell, val);
5674       free (message);
5675       message = NULL;
5676     }
5677   else if (token == CPP_STRING || token == CPP_WSTRING)
5678     message = catenate_messages (gmsgid, " before string constant");
5679   else if (token == CPP_NUMBER)
5680     message = catenate_messages (gmsgid, " before numeric constant");
5681   else if (token == CPP_NAME)
5682     {
5683       message = catenate_messages (gmsgid, " before %qE");
5684       error (message, value);
5685       free (message);
5686       message = NULL;
5687     }
5688   else if (token < N_TTYPES)
5689     {
5690       message = catenate_messages (gmsgid, " before %qs token");
5691       error (message, cpp_type2name (token));
5692       free (message);
5693       message = NULL;
5694     }
5695   else
5696     error (gmsgid);
5697
5698   if (message)
5699     {
5700       error (message);
5701       free (message);
5702     }
5703 #undef catenate_messages
5704 }
5705
5706 /* Walk a gimplified function and warn for functions whose return value is
5707    ignored and attribute((warn_unused_result)) is set.  This is done before
5708    inlining, so we don't have to worry about that.  */
5709
5710 void
5711 c_warn_unused_result (tree *top_p)
5712 {
5713   tree t = *top_p;
5714   tree_stmt_iterator i;
5715   tree fdecl, ftype;
5716
5717   switch (TREE_CODE (t))
5718     {
5719     case STATEMENT_LIST:
5720       for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5721         c_warn_unused_result (tsi_stmt_ptr (i));
5722       break;
5723
5724     case COND_EXPR:
5725       c_warn_unused_result (&COND_EXPR_THEN (t));
5726       c_warn_unused_result (&COND_EXPR_ELSE (t));
5727       break;
5728     case BIND_EXPR:
5729       c_warn_unused_result (&BIND_EXPR_BODY (t));
5730       break;
5731     case TRY_FINALLY_EXPR:
5732     case TRY_CATCH_EXPR:
5733       c_warn_unused_result (&TREE_OPERAND (t, 0));
5734       c_warn_unused_result (&TREE_OPERAND (t, 1));
5735       break;
5736     case CATCH_EXPR:
5737       c_warn_unused_result (&CATCH_BODY (t));
5738       break;
5739     case EH_FILTER_EXPR:
5740       c_warn_unused_result (&EH_FILTER_FAILURE (t));
5741       break;
5742
5743     case CALL_EXPR:
5744       if (TREE_USED (t))
5745         break;
5746
5747       /* This is a naked call, as opposed to a CALL_EXPR nested inside
5748          a MODIFY_EXPR.  All calls whose value is ignored should be
5749          represented like this.  Look for the attribute.  */
5750       fdecl = get_callee_fndecl (t);
5751       if (fdecl)
5752         ftype = TREE_TYPE (fdecl);
5753       else
5754         {
5755           ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5756           /* Look past pointer-to-function to the function type itself.  */
5757           ftype = TREE_TYPE (ftype);
5758         }
5759
5760       if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5761         {
5762           if (fdecl)
5763             warning (0, "%Hignoring return value of %qD, "
5764                      "declared with attribute warn_unused_result",
5765                      EXPR_LOCUS (t), fdecl);
5766           else
5767             warning (0, "%Hignoring return value of function "
5768                      "declared with attribute warn_unused_result",
5769                      EXPR_LOCUS (t));
5770         }
5771       break;
5772
5773     default:
5774       /* Not a container, not a call, or a call whose value is used.  */
5775       break;
5776     }
5777 }
5778
5779 /* Convert a character from the host to the target execution character
5780    set.  cpplib handles this, mostly.  */
5781
5782 HOST_WIDE_INT
5783 c_common_to_target_charset (HOST_WIDE_INT c)
5784 {
5785   /* Character constants in GCC proper are sign-extended under -fsigned-char,
5786      zero-extended under -fno-signed-char.  cpplib insists that characters
5787      and character constants are always unsigned.  Hence we must convert
5788      back and forth.  */
5789   cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
5790
5791   uc = cpp_host_to_exec_charset (parse_in, uc);
5792
5793   if (flag_signed_char)
5794     return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
5795                                >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
5796   else
5797     return uc;
5798 }
5799
5800 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
5801    component references, with an INDIRECT_REF at the bottom; much like
5802    the traditional rendering of offsetof as a macro.  Returns the folded
5803    and properly cast result.  */
5804
5805 static tree
5806 fold_offsetof_1 (tree expr)
5807 {
5808   enum tree_code code = PLUS_EXPR;
5809   tree base, off, t;
5810
5811   switch (TREE_CODE (expr))
5812     {
5813     case ERROR_MARK:
5814       return expr;
5815
5816     case INDIRECT_REF:
5817       return size_zero_node;
5818
5819     case COMPONENT_REF:
5820       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5821       if (base == error_mark_node)
5822         return base;
5823
5824       t = TREE_OPERAND (expr, 1);
5825       if (DECL_C_BIT_FIELD (t))
5826         {
5827           error ("attempt to take address of bit-field structure "
5828                  "member %qD", t);
5829           return error_mark_node;
5830         }
5831       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
5832                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
5833                                   / BITS_PER_UNIT));
5834       break;
5835
5836     case ARRAY_REF:
5837       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5838       if (base == error_mark_node)
5839         return base;
5840
5841       t = TREE_OPERAND (expr, 1);
5842       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
5843         {
5844           code = MINUS_EXPR;
5845           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
5846         }
5847       t = convert (sizetype, t);
5848       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
5849       break;
5850
5851     default:
5852       gcc_unreachable ();
5853     }
5854
5855   return size_binop (code, base, off);
5856 }
5857
5858 tree
5859 fold_offsetof (tree expr)
5860 {
5861   /* Convert back from the internal sizetype to size_t.  */
5862   return convert (size_type_node, fold_offsetof_1 (expr));
5863 }
5864
5865 /* Print an error message for an invalid lvalue.  USE says
5866    how the lvalue is being used and so selects the error message.  */
5867
5868 void
5869 lvalue_error (enum lvalue_use use)
5870 {
5871   switch (use)
5872     {
5873     case lv_assign:
5874       error ("invalid lvalue in assignment");
5875       break;
5876     case lv_increment:
5877       error ("invalid lvalue in increment");
5878       break;
5879     case lv_decrement:
5880       error ("invalid lvalue in decrement");
5881       break;
5882     case lv_addressof:
5883       error ("invalid lvalue in unary %<&%>");
5884       break;
5885     case lv_asm:
5886       error ("invalid lvalue in asm statement");
5887       break;
5888     default:
5889       gcc_unreachable ();
5890     }
5891 }
5892 \f
5893 /* *PTYPE is an incomplete array.  Complete it with a domain based on
5894    INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
5895    is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5896    2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
5897
5898 int
5899 complete_array_type (tree *ptype, tree initial_value, bool do_default)
5900 {
5901   tree maxindex, type, main_type, elt, unqual_elt;
5902   int failure = 0, quals;
5903
5904   maxindex = size_zero_node;
5905   if (initial_value)
5906     {
5907       if (TREE_CODE (initial_value) == STRING_CST)
5908         {
5909           int eltsize
5910             = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5911           maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
5912         }
5913       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5914         {
5915           VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5916
5917           if (VEC_empty (constructor_elt, v))
5918             {
5919               if (pedantic)
5920                 failure = 3;
5921               maxindex = integer_minus_one_node;
5922             }
5923           else
5924             {
5925               tree curindex;
5926               unsigned HOST_WIDE_INT cnt;
5927               constructor_elt *ce;
5928
5929               if (VEC_index (constructor_elt, v, 0)->index)
5930                 maxindex = fold_convert (sizetype,
5931                                          VEC_index (constructor_elt,
5932                                                     v, 0)->index);
5933               curindex = maxindex;
5934
5935               for (cnt = 1;
5936                    VEC_iterate (constructor_elt, v, cnt, ce);
5937                    cnt++)
5938                 {
5939                   if (ce->index)
5940                     curindex = fold_convert (sizetype, ce->index);
5941                   else
5942                     curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
5943
5944                   if (tree_int_cst_lt (maxindex, curindex))
5945                     maxindex = curindex;
5946                 }
5947             }
5948         }
5949       else
5950         {
5951           /* Make an error message unless that happened already.  */
5952           if (initial_value != error_mark_node)
5953             failure = 1;
5954         }
5955     }
5956   else
5957     {
5958       failure = 2;
5959       if (!do_default)
5960         return failure;
5961     }
5962
5963   type = *ptype;
5964   elt = TREE_TYPE (type);
5965   quals = TYPE_QUALS (strip_array_types (elt));
5966   if (quals == 0)
5967     unqual_elt = elt;
5968   else
5969     unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
5970
5971   /* Using build_distinct_type_copy and modifying things afterward instead
5972      of using build_array_type to create a new type preserves all of the
5973      TYPE_LANG_FLAG_? bits that the front end may have set.  */
5974   main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5975   TREE_TYPE (main_type) = unqual_elt;
5976   TYPE_DOMAIN (main_type) = build_index_type (maxindex);
5977   layout_type (main_type);
5978
5979   if (quals == 0)
5980     type = main_type;
5981   else
5982     type = c_build_qualified_type (main_type, quals);
5983
5984   *ptype = type;
5985   return failure;
5986 }
5987
5988 \f
5989 /* Used to help initialize the builtin-types.def table.  When a type of
5990    the correct size doesn't exist, use error_mark_node instead of NULL.
5991    The later results in segfaults even when a decl using the type doesn't
5992    get invoked.  */
5993
5994 tree
5995 builtin_type_for_size (int size, bool unsignedp)
5996 {
5997   tree type = lang_hooks.types.type_for_size (size, unsignedp);
5998   return type ? type : error_mark_node;
5999 }
6000
6001 /* A helper function for resolve_overloaded_builtin in resolving the
6002    overloaded __sync_ builtins.  Returns a positive power of 2 if the
6003    first operand of PARAMS is a pointer to a supported data type.
6004    Returns 0 if an error is encountered.  */
6005
6006 static int
6007 sync_resolve_size (tree function, tree params)
6008 {
6009   tree type;
6010   int size;
6011
6012   if (params == NULL)
6013     {
6014       error ("too few arguments to function %qE", function);
6015       return 0;
6016     }
6017
6018   type = TREE_TYPE (TREE_VALUE (params));
6019   if (TREE_CODE (type) != POINTER_TYPE)
6020     goto incompatible;
6021
6022   type = TREE_TYPE (type);
6023   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6024     goto incompatible;
6025
6026   size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6027   if (size == 1 || size == 2 || size == 4 || size == 8)
6028     return size;
6029
6030  incompatible:
6031   error ("incompatible type for argument %d of %qE", 1, function);
6032   return 0;
6033 }
6034
6035 /* A helper function for resolve_overloaded_builtin.  Adds casts to
6036    PARAMS to make arguments match up with those of FUNCTION.  Drops
6037    the variadic arguments at the end.  Returns false if some error
6038    was encountered; true on success.  */
6039
6040 static bool
6041 sync_resolve_params (tree orig_function, tree function, tree params)
6042 {
6043   tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6044   tree ptype;
6045   int number;
6046
6047   /* We've declared the implementation functions to use "volatile void *"
6048      as the pointer parameter, so we shouldn't get any complaints from the
6049      call to check_function_arguments what ever type the user used.  */
6050   arg_types = TREE_CHAIN (arg_types);
6051   ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6052   number = 2;
6053
6054   /* For the rest of the values, we need to cast these to FTYPE, so that we
6055      don't get warnings for passing pointer types, etc.  */
6056   while (arg_types != void_list_node)
6057     {
6058       tree val;
6059
6060       params = TREE_CHAIN (params);
6061       if (params == NULL)
6062         {
6063           error ("too few arguments to function %qE", orig_function);
6064           return false;
6065         }
6066
6067       /* ??? Ideally for the first conversion we'd use convert_for_assignment
6068          so that we get warnings for anything that doesn't match the pointer
6069          type.  This isn't portable across the C and C++ front ends atm.  */
6070       val = TREE_VALUE (params);
6071       val = convert (ptype, val);
6072       val = convert (TREE_VALUE (arg_types), val);
6073       TREE_VALUE (params) = val;
6074
6075       arg_types = TREE_CHAIN (arg_types);
6076       number++;
6077     }
6078
6079   /* The definition of these primitives is variadic, with the remaining
6080      being "an optional list of variables protected by the memory barrier".
6081      No clue what that's supposed to mean, precisely, but we consider all
6082      call-clobbered variables to be protected so we're safe.  */
6083   TREE_CHAIN (params) = NULL;
6084
6085   return true;
6086 }
6087
6088 /* A helper function for resolve_overloaded_builtin.  Adds a cast to
6089    RESULT to make it match the type of the first pointer argument in
6090    PARAMS.  */
6091
6092 static tree
6093 sync_resolve_return (tree params, tree result)
6094 {
6095   tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6096   return convert (ptype, result);
6097 }
6098
6099 /* Some builtin functions are placeholders for other expressions.  This
6100    function should be called immediately after parsing the call expression
6101    before surrounding code has committed to the type of the expression.
6102
6103    FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6104    PARAMS is the argument list for the call.  The return value is non-null
6105    when expansion is complete, and null if normal processing should
6106    continue.  */
6107
6108 tree
6109 resolve_overloaded_builtin (tree function, tree params)
6110 {
6111   enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6112   switch (DECL_BUILT_IN_CLASS (function))
6113     {
6114     case BUILT_IN_NORMAL:
6115       break;
6116     case BUILT_IN_MD:
6117       if (targetm.resolve_overloaded_builtin)
6118         return targetm.resolve_overloaded_builtin (function, params);
6119       else
6120         return NULL_TREE;
6121     default:
6122       return NULL_TREE;
6123     }
6124
6125   /* Handle BUILT_IN_NORMAL here.  */
6126   switch (orig_code)
6127     {
6128     case BUILT_IN_FETCH_AND_ADD_N:
6129     case BUILT_IN_FETCH_AND_SUB_N:
6130     case BUILT_IN_FETCH_AND_OR_N:
6131     case BUILT_IN_FETCH_AND_AND_N:
6132     case BUILT_IN_FETCH_AND_XOR_N:
6133     case BUILT_IN_FETCH_AND_NAND_N:
6134     case BUILT_IN_ADD_AND_FETCH_N:
6135     case BUILT_IN_SUB_AND_FETCH_N:
6136     case BUILT_IN_OR_AND_FETCH_N:
6137     case BUILT_IN_AND_AND_FETCH_N:
6138     case BUILT_IN_XOR_AND_FETCH_N:
6139     case BUILT_IN_NAND_AND_FETCH_N:
6140     case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6141     case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6142     case BUILT_IN_LOCK_TEST_AND_SET_N:
6143     case BUILT_IN_LOCK_RELEASE_N:
6144       {
6145         int n = sync_resolve_size (function, params);
6146         tree new_function, result;
6147
6148         if (n == 0)
6149           return error_mark_node;
6150
6151         new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6152         if (!sync_resolve_params (function, new_function, params))
6153           return error_mark_node;
6154
6155         result = build_function_call (new_function, params);
6156         if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6157             && orig_code != BUILT_IN_LOCK_RELEASE_N)
6158           result = sync_resolve_return (params, result);
6159
6160         return result;
6161       }
6162
6163     default:
6164       return NULL_TREE;
6165     }
6166 }
6167
6168 /* Ignoring their sign, return true if two scalar types are the same.  */
6169 bool
6170 same_scalar_type_ignoring_signedness (tree t1, tree t2)
6171 {
6172   enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6173
6174   gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6175               && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6176
6177   /* Equality works here because c_common_signed_type uses
6178      TYPE_MAIN_VARIANT.  */
6179   return lang_hooks.types.signed_type (t1)
6180     == lang_hooks.types.signed_type (t2);
6181 }
6182
6183 /* Check for missing format attributes on function pointers.  LTYPE is
6184    the new type or left-hand side type.  RTYPE is the old type or
6185    right-hand side type.  Returns TRUE if LTYPE is missing the desired
6186    attribute.  */
6187
6188 bool
6189 check_missing_format_attribute (tree ltype, tree rtype)
6190 {
6191   tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6192   tree ra;
6193
6194   for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6195     if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6196       break;
6197   if (ra)
6198     {
6199       tree la;
6200       for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6201         if (is_attribute_p ("format", TREE_PURPOSE (la)))
6202           break;
6203       return !la;
6204     }
6205   else
6206     return false;
6207 }
6208
6209 #include "gt-c-common.h"