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