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