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