gcc/c-common.c

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