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