gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "intl.h"
  27 #include "tree.h"
  28 #include "flags.h"
  29 #include "output.h"
  30 #include "c-pragma.h"
  31 #include "rtl.h"
  32 #include "ggc.h"
  33 #include "varray.h"
  34 #include "expr.h"
  35 #include "c-common.h"
  36 #include "diagnostic.h"
  37 #include "tm_p.h"
  38 #include "obstack.h"
  39 #include "cpplib.h"
  40 #include "target.h"
  41 #include "langhooks.h"
  42 #include "tree-inline.h"
  43 #include "c-tree.h"
  44 #include "toplev.h"
  45 #include "tree-iterator.h"
  46 #include "hashtab.h"
  47 #include "tree-mudflap.h"
  48 #include "opts.h"
  49 #include "real.h"
  50
  51 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  52
  53 /* We let tm.h override the types used here, to handle trivial differences
  54    such as the choice of unsigned int or long unsigned int for size_t.
  55    When machines start needing nontrivial differences in the size type,
  56    it would be best to do something here to figure out automatically
  57    from other information what type to use.  */
  58
  59 #ifndef SIZE_TYPE
  60 #define SIZE_TYPE "long unsigned int"
  61 #endif
  62
  63 #ifndef PID_TYPE
  64 #define PID_TYPE "int"
  65 #endif
  66
  67 #ifndef WCHAR_TYPE
  68 #define WCHAR_TYPE "int"
  69 #endif
  70
  71 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  72 #define MODIFIED_WCHAR_TYPE \
  73         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  74
  75 #ifndef PTRDIFF_TYPE
  76 #define PTRDIFF_TYPE "long int"
  77 #endif
  78
  79 #ifndef WINT_TYPE
  80 #define WINT_TYPE "unsigned int"
  81 #endif
  82
  83 #ifndef INTMAX_TYPE
  84 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  85                      ? "int"                                    \
  86                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  87                         ? "long int"                            \
  88                         : "long long int"))
  89 #endif
  90
  91 #ifndef UINTMAX_TYPE
  92 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  93                      ? "unsigned int"                           \
  94                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  95                         ? "long unsigned int"                   \
  96                         : "long long unsigned int"))
  97 #endif
  98
  99 /* The following symbols are subsumed in the c_global_trees array, and
 100    listed here individually for documentation purposes.
 101
 102    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
 103
 104         tree short_integer_type_node;
 105         tree long_integer_type_node;
 106         tree long_long_integer_type_node;
 107
 108         tree short_unsigned_type_node;
 109         tree long_unsigned_type_node;
 110         tree long_long_unsigned_type_node;
 111
 112         tree truthvalue_type_node;
 113         tree truthvalue_false_node;
 114         tree truthvalue_true_node;
 115
 116         tree ptrdiff_type_node;
 117
 118         tree unsigned_char_type_node;
 119         tree signed_char_type_node;
 120         tree wchar_type_node;
 121         tree signed_wchar_type_node;
 122         tree unsigned_wchar_type_node;
 123
 124         tree float_type_node;
 125         tree double_type_node;
 126         tree long_double_type_node;
 127
 128         tree complex_integer_type_node;
 129         tree complex_float_type_node;
 130         tree complex_double_type_node;
 131         tree complex_long_double_type_node;
 132
 133         tree intQI_type_node;
 134         tree intHI_type_node;
 135         tree intSI_type_node;
 136         tree intDI_type_node;
 137         tree intTI_type_node;
 138
 139         tree unsigned_intQI_type_node;
 140         tree unsigned_intHI_type_node;
 141         tree unsigned_intSI_type_node;
 142         tree unsigned_intDI_type_node;
 143         tree unsigned_intTI_type_node;
 144
 145         tree widest_integer_literal_type_node;
 146         tree widest_unsigned_literal_type_node;
 147
 148    Nodes for types `void *' and `const void *'.
 149
 150         tree ptr_type_node, const_ptr_type_node;
 151
 152    Nodes for types `char *' and `const char *'.
 153
 154         tree string_type_node, const_string_type_node;
 155
 156    Type `char[SOMENUMBER]'.
 157    Used when an array of char is needed and the size is irrelevant.
 158
 159         tree char_array_type_node;
 160
 161    Type `int[SOMENUMBER]' or something like it.
 162    Used when an array of int needed and the size is irrelevant.
 163
 164         tree int_array_type_node;
 165
 166    Type `wchar_t[SOMENUMBER]' or something like it.
 167    Used when a wide string literal is created.
 168
 169         tree wchar_array_type_node;
 170
 171    Type `int ()' -- used for implicit declaration of functions.
 172
 173         tree default_function_type;
 174
 175    A VOID_TYPE node, packaged in a TREE_LIST.
 176
 177         tree void_list_node;
 178
 179   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 180   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 181   VAR_DECLS, but C++ does.)
 182
 183         tree function_name_decl_node;
 184         tree pretty_function_name_decl_node;
 185         tree c99_function_name_decl_node;
 186
 187   Stack of nested function name VAR_DECLs.
 188
 189         tree saved_function_name_decls;
 190
 191 */
 192
 193 tree c_global_trees[CTI_MAX];
 194
 195 /* TRUE if a code represents a statement.  The front end init
 196    langhook should take care of initialization of this array.  */
 197
 198 bool statement_code_p[MAX_TREE_CODES];
 199 \f
 200 /* Switches common to the C front ends.  */
 201
 202 /* Nonzero if prepreprocessing only.  */
 203
 204 int flag_preprocess_only;
 205
 206 /* Nonzero means don't output line number information.  */
 207
 208 char flag_no_line_commands;
 209
 210 /* Nonzero causes -E output not to be done, but directives such as
 211    #define that have side effects are still obeyed.  */
 212
 213 char flag_no_output;
 214
 215 /* Nonzero means dump macros in some fashion.  */
 216
 217 char flag_dump_macros;
 218
 219 /* Nonzero means pass #include lines through to the output.  */
 220
 221 char flag_dump_includes;
 222
 223 /* Nonzero means process PCH files while preprocessing.  */
 224
 225 bool flag_pch_preprocess;
 226
 227 /* The file name to which we should write a precompiled header, or
 228    NULL if no header will be written in this compile.  */
 229
 230 const char *pch_file;
 231
 232 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 233    user's namespace.  */
 234 int flag_iso;
 235
 236 /* Nonzero if -undef was given.  It suppresses target built-in macros
 237    and assertions.  */
 238 int flag_undef;
 239
 240 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 241
 242 int flag_no_builtin;
 243
 244 /* Nonzero means don't recognize the non-ANSI builtin functions.
 245    -ansi sets this.  */
 246
 247 int flag_no_nonansi_builtin;
 248
 249 /* Nonzero means give `double' the same size as `float'.  */
 250
 251 int flag_short_double;
 252
 253 /* Nonzero means give `wchar_t' the same size as `short'.  */
 254
 255 int flag_short_wchar;
 256
 257 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
 258 int flag_ms_extensions;
 259
 260 /* Nonzero means don't recognize the keyword `asm'.  */
 261
 262 int flag_no_asm;
 263
 264 /* Nonzero means give string constants the type `const char *', as mandated
 265    by the standard.  */
 266
 267 int flag_const_strings;
 268
 269 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
 270
 271 int flag_signed_bitfields = 1;
 272 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       if (TREE_TYPE (expr) != truthvalue_type_node)
2330         return build2 (TREE_CODE (expr), truthvalue_type_node,
2331                        TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2332       return expr;
2333
2334     case TRUTH_NOT_EXPR:
2335       if (TREE_TYPE (expr) != truthvalue_type_node)
2336         return build1 (TREE_CODE (expr), truthvalue_type_node,
2337                        TREE_OPERAND (expr, 0));
2338       return expr;
2339
2340     case ERROR_MARK:
2341       return expr;
2342
2343     case INTEGER_CST:
2344       /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW.  */
2345       return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2346              ? truthvalue_true_node
2347              : truthvalue_false_node;
2348
2349     case REAL_CST:
2350       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2351              ? truthvalue_true_node
2352              : truthvalue_false_node;
2353
2354     case ADDR_EXPR:
2355       {
2356         if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2357             && !DECL_WEAK (TREE_OPERAND (expr, 0)))
2358           {
2359             /* Common Ada/Pascal programmer's mistake.  We always warn
2360                about this since it is so bad.  */
2361             warning ("the address of %qD, will always evaluate as %<true%>",
2362                      TREE_OPERAND (expr, 0));
2363             return truthvalue_true_node;
2364           }
2365
2366         /* If we are taking the address of an external decl, it might be
2367            zero if it is weak, so we cannot optimize.  */
2368         if (DECL_P (TREE_OPERAND (expr, 0))
2369             && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2370           break;
2371
2372         if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2373           return build2 (COMPOUND_EXPR, truthvalue_type_node,
2374                          TREE_OPERAND (expr, 0), truthvalue_true_node);
2375         else
2376           return truthvalue_true_node;
2377       }
2378
2379     case COMPLEX_EXPR:
2380       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2381                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2382                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)),
2383                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2384                               0);
2385
2386     case NEGATE_EXPR:
2387     case ABS_EXPR:
2388     case FLOAT_EXPR:
2389       /* These don't change whether an object is nonzero or zero.  */
2390       return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2391
2392     case LROTATE_EXPR:
2393     case RROTATE_EXPR:
2394       /* These don't change whether an object is zero or nonzero, but
2395          we can't ignore them if their second arg has side-effects.  */
2396       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2397         return build2 (COMPOUND_EXPR, truthvalue_type_node,
2398                        TREE_OPERAND (expr, 1),
2399                        lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)));
2400       else
2401         return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2402
2403     case COND_EXPR:
2404       /* Distribute the conversion into the arms of a COND_EXPR.  */
2405       return fold (build3 (COND_EXPR, truthvalue_type_node,
2406                 TREE_OPERAND (expr, 0),
2407                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)),
2408                 lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2))));
2409
2410     case CONVERT_EXPR:
2411       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2412          since that affects how `default_conversion' will behave.  */
2413       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2414           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2415         break;
2416       /* Fall through....  */
2417     case NOP_EXPR:
2418       /* If this is widening the argument, we can ignore it.  */
2419       if (TYPE_PRECISION (TREE_TYPE (expr))
2420           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2421         return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0));
2422       break;
2423
2424     case MINUS_EXPR:
2425       /* Perhaps reduce (x - y) != 0 to (x != y).  The expressions
2426          aren't guaranteed to the be same for modes that can represent
2427          infinity, since if x and y are both +infinity, or both
2428          -infinity, then x - y is not a number.
2429
2430          Note that this transformation is safe when x or y is NaN.
2431          (x - y) is then NaN, and both (x - y) != 0 and x != y will
2432          be false.  */
2433       if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2434         break;
2435       /* Fall through....  */
2436     case BIT_XOR_EXPR:
2437       /* This and MINUS_EXPR can be changed into a comparison of the
2438          two objects.  */
2439       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2440           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2441         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2442                                 TREE_OPERAND (expr, 1), 1);
2443       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2444                               fold (build1 (NOP_EXPR,
2445                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2446                                             TREE_OPERAND (expr, 1))), 1);
2447
2448     case BIT_AND_EXPR:
2449       if (integer_onep (TREE_OPERAND (expr, 1))
2450           && TREE_TYPE (expr) != truthvalue_type_node)
2451         /* Using convert here would cause infinite recursion.  */
2452         return build1 (NOP_EXPR, truthvalue_type_node, expr);
2453       break;
2454
2455     case MODIFY_EXPR:
2456       if (warn_parentheses && !TREE_NO_WARNING (expr))
2457         warning ("suggest parentheses around assignment used as truth value");
2458       break;
2459
2460     default:
2461       break;
2462     }
2463
2464   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2465     {
2466       tree t = save_expr (expr);
2467       return (build_binary_op
2468               ((TREE_SIDE_EFFECTS (expr)
2469                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2470         lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2471         lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2472                0));
2473     }
2474
2475   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2476 }
2477 \f
2478 static tree builtin_function_2 (const char *builtin_name, const char *name,
2479                                 tree builtin_type, tree type,
2480                                 enum built_in_function function_code,
2481                                 enum built_in_class cl, int library_name_p,
2482                                 bool nonansi_p,
2483                                 tree attrs);
2484
2485 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2486    down to the element type of an array.  */
2487
2488 tree
2489 c_build_qualified_type (tree type, int type_quals)
2490 {
2491   if (type == error_mark_node)
2492     return type;
2493
2494   if (TREE_CODE (type) == ARRAY_TYPE)
2495     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2496                                                      type_quals),
2497                              TYPE_DOMAIN (type));
2498
2499   /* A restrict-qualified pointer type must be a pointer to object or
2500      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2501      REFERENCE_TYPEs, which is appropriate for C++.  */
2502   if ((type_quals & TYPE_QUAL_RESTRICT)
2503       && (!POINTER_TYPE_P (type)
2504           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2505     {
2506       error ("invalid use of %<restrict%>");
2507       type_quals &= ~TYPE_QUAL_RESTRICT;
2508     }
2509
2510   return build_qualified_type (type, type_quals);
2511 }
2512
2513 /* Apply the TYPE_QUALS to the new DECL.  */
2514
2515 void
2516 c_apply_type_quals_to_decl (int type_quals, tree decl)
2517 {
2518   tree type = TREE_TYPE (decl);
2519
2520   if (type == error_mark_node)
2521     return;
2522
2523   if (((type_quals & TYPE_QUAL_CONST)
2524        || (type && TREE_CODE (type) == REFERENCE_TYPE))
2525       /* An object declared 'const' is only readonly after it is
2526          initialized.  We don't have any way of expressing this currently,
2527          so we need to be conservative and unset TREE_READONLY for types
2528          with constructors.  Otherwise aliasing code will ignore stores in
2529          an inline constructor.  */
2530       && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2531     TREE_READONLY (decl) = 1;
2532   if (type_quals & TYPE_QUAL_VOLATILE)
2533     {
2534       TREE_SIDE_EFFECTS (decl) = 1;
2535       TREE_THIS_VOLATILE (decl) = 1;
2536     }
2537   if (type_quals & TYPE_QUAL_RESTRICT)
2538     {
2539       while (type && TREE_CODE (type) == ARRAY_TYPE)
2540         /* Allow 'restrict' on arrays of pointers.
2541            FIXME currently we just ignore it.  */
2542         type = TREE_TYPE (type);
2543       if (!type
2544           || !POINTER_TYPE_P (type)
2545           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2546         error ("invalid use of %<restrict%>");
2547       else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2548         /* Indicate we need to make a unique alias set for this pointer.
2549            We can't do it here because it might be pointing to an
2550            incomplete type.  */
2551         DECL_POINTER_ALIAS_SET (decl) = -2;
2552     }
2553 }
2554
2555 /* Hash function for the problem of multiple type definitions in
2556    different files.  This must hash all types that will compare
2557    equal via comptypes to the same value.  In practice it hashes
2558    on some of the simple stuff and leaves the details to comptypes.  */
2559
2560 static hashval_t
2561 c_type_hash (const void *p)
2562 {
2563   int i = 0;
2564   int shift, size;
2565   tree t = (tree) p;
2566   tree t2;
2567   switch (TREE_CODE (t))
2568     {
2569     /* For pointers, hash on pointee type plus some swizzling.  */
2570     case POINTER_TYPE:
2571       return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2572     /* Hash on number of elements and total size.  */
2573     case ENUMERAL_TYPE:
2574       shift = 3;
2575       t2 = TYPE_VALUES (t);
2576       break;
2577     case RECORD_TYPE:
2578       shift = 0;
2579       t2 = TYPE_FIELDS (t);
2580       break;
2581     case QUAL_UNION_TYPE:
2582       shift = 1;
2583       t2 = TYPE_FIELDS (t);
2584       break;
2585     case UNION_TYPE:
2586       shift = 2;
2587       t2 = TYPE_FIELDS (t);
2588       break;
2589     default:
2590       gcc_unreachable ();
2591     }
2592   for (; t2; t2 = TREE_CHAIN (t2))
2593     i++;
2594   size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2595   return ((size << 24) | (i << shift));
2596 }
2597
2598 static GTY((param_is (union tree_node))) htab_t type_hash_table;
2599
2600 /* Return the typed-based alias set for T, which may be an expression
2601    or a type.  Return -1 if we don't do anything special.  */
2602
2603 HOST_WIDE_INT
2604 c_common_get_alias_set (tree t)
2605 {
2606   tree u;
2607   PTR *slot;
2608
2609   /* Permit type-punning when accessing a union, provided the access
2610      is directly through the union.  For example, this code does not
2611      permit taking the address of a union member and then storing
2612      through it.  Even the type-punning allowed here is a GCC
2613      extension, albeit a common and useful one; the C standard says
2614      that such accesses have implementation-defined behavior.  */
2615   for (u = t;
2616        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2617        u = TREE_OPERAND (u, 0))
2618     if (TREE_CODE (u) == COMPONENT_REF
2619         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2620       return 0;
2621
2622   /* That's all the expressions we handle specially.  */
2623   if (!TYPE_P (t))
2624     return -1;
2625
2626   /* The C standard guarantees that any object may be accessed via an
2627      lvalue that has character type.  */
2628   if (t == char_type_node
2629       || t == signed_char_type_node
2630       || t == unsigned_char_type_node)
2631     return 0;
2632
2633   /* If it has the may_alias attribute, it can alias anything.  */
2634   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2635     return 0;
2636
2637   /* The C standard specifically allows aliasing between signed and
2638      unsigned variants of the same type.  We treat the signed
2639      variant as canonical.  */
2640   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2641     {
2642       tree t1 = c_common_signed_type (t);
2643
2644       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2645       if (t1 != t)
2646         return get_alias_set (t1);
2647     }
2648   else if (POINTER_TYPE_P (t))
2649     {
2650       tree t1;
2651
2652       /* Unfortunately, there is no canonical form of a pointer type.
2653          In particular, if we have `typedef int I', then `int *', and
2654          `I *' are different types.  So, we have to pick a canonical
2655          representative.  We do this below.
2656
2657          Technically, this approach is actually more conservative that
2658          it needs to be.  In particular, `const int *' and `int *'
2659          should be in different alias sets, according to the C and C++
2660          standard, since their types are not the same, and so,
2661          technically, an `int **' and `const int **' cannot point at
2662          the same thing.
2663
2664          But, the standard is wrong.  In particular, this code is
2665          legal C++:
2666
2667             int *ip;
2668             int **ipp = &ip;
2669             const int* const* cipp = ipp;
2670
2671          And, it doesn't make sense for that to be legal unless you
2672          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2673          the pointed-to types.  This issue has been reported to the
2674          C++ committee.  */
2675       t1 = build_type_no_quals (t);
2676       if (t1 != t)
2677         return get_alias_set (t1);
2678     }
2679
2680   /* Handle the case of multiple type nodes referring to "the same" type,
2681      which occurs with IMA.  These share an alias set.  FIXME:  Currently only
2682      C90 is handled.  (In C99 type compatibility is not transitive, which
2683      complicates things mightily. The alias set splay trees can theoretically
2684      represent this, but insertion is tricky when you consider all the
2685      different orders things might arrive in.) */
2686
2687   if (c_language != clk_c || flag_isoc99)
2688     return -1;
2689
2690   /* Save time if there's only one input file.  */
2691   if (num_in_fnames == 1)
2692     return -1;
2693
2694   /* Pointers need special handling if they point to any type that
2695      needs special handling (below).  */
2696   if (TREE_CODE (t) == POINTER_TYPE)
2697     {
2698       tree t2;
2699       /* Find bottom type under any nested POINTERs.  */
2700       for (t2 = TREE_TYPE (t);
2701      TREE_CODE (t2) == POINTER_TYPE;
2702      t2 = TREE_TYPE (t2))
2703   ;
2704       if (TREE_CODE (t2) != RECORD_TYPE
2705     && TREE_CODE (t2) != ENUMERAL_TYPE
2706     && TREE_CODE (t2) != QUAL_UNION_TYPE
2707     && TREE_CODE (t2) != UNION_TYPE)
2708   return -1;
2709       if (TYPE_SIZE (t2) == 0)
2710   return -1;
2711     }
2712   /* These are the only cases that need special handling.  */
2713   if (TREE_CODE (t) != RECORD_TYPE
2714       && TREE_CODE (t) != ENUMERAL_TYPE
2715       && TREE_CODE (t) != QUAL_UNION_TYPE
2716       && TREE_CODE (t) != UNION_TYPE
2717       && TREE_CODE (t) != POINTER_TYPE)
2718     return -1;
2719   /* Undefined? */
2720   if (TYPE_SIZE (t) == 0)
2721     return -1;
2722
2723   /* Look up t in hash table.  Only one of the compatible types within each
2724      alias set is recorded in the table.  */
2725   if (!type_hash_table)
2726     type_hash_table = htab_create_ggc (1021, c_type_hash,
2727             (htab_eq) lang_hooks.types_compatible_p,
2728             NULL);
2729   slot = htab_find_slot (type_hash_table, t, INSERT);
2730   if (*slot != NULL)
2731     {
2732       TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2733       return TYPE_ALIAS_SET ((tree)*slot);
2734     }
2735   else
2736     /* Our caller will assign and record (in t) a new alias set; all we need
2737        to do is remember t in the hash table.  */
2738     *slot = t;
2739
2740   return -1;
2741 }
2742 \f
2743 /* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2744    second parameter indicates which OPERATOR is being applied.  The COMPLAIN
2745    flag controls whether we should diagnose possibly ill-formed
2746    constructs or not.  */
2747 tree
2748 c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2749 {
2750   const char *op_name;
2751   tree value = NULL;
2752   enum tree_code type_code = TREE_CODE (type);
2753
2754   gcc_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR);
2755   op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2756
2757   if (type_code == FUNCTION_TYPE)
2758     {
2759       if (op == SIZEOF_EXPR)
2760         {
2761           if (complain && (pedantic || warn_pointer_arith))
2762             pedwarn ("invalid application of %<sizeof%> to a function type");
2763           value = size_one_node;
2764         }
2765       else
2766         value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2767     }
2768   else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2769     {
2770       if (type_code == VOID_TYPE
2771           && complain && (pedantic || warn_pointer_arith))
2772         pedwarn ("invalid application of %qs to a void type", op_name);
2773       value = size_one_node;
2774     }
2775   else if (!COMPLETE_TYPE_P (type))
2776     {
2777       if (complain)
2778         error ("invalid application of %qs to incomplete type %qT ",
2779                op_name, type);
2780       value = size_zero_node;
2781     }
2782   else
2783     {
2784       if (op == (enum tree_code) SIZEOF_EXPR)
2785         /* Convert in case a char is more than one unit.  */
2786         value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2787                             size_int (TYPE_PRECISION (char_type_node)
2788                                       / BITS_PER_UNIT));
2789       else
2790         value = size_int (TYPE_ALIGN_UNIT (type));
2791     }
2792
2793   /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2794      TYPE_IS_SIZETYPE means that certain things (like overflow) will
2795      never happen.  However, this node should really have type
2796      `size_t', which is just a typedef for an ordinary integer type.  */
2797   value = fold (build1 (NOP_EXPR, size_type_node, value));
2798   gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2799
2800   return value;
2801 }
2802
2803 /* Implement the __alignof keyword: Return the minimum required
2804    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2805    FIELD_DECL's return DECL_ALIGN (which can be set from an
2806    "aligned" __attribute__ specification).  */
2807
2808 tree
2809 c_alignof_expr (tree expr)
2810 {
2811   tree t;
2812
2813   if (TREE_CODE (expr) == VAR_DECL)
2814     t = size_int (DECL_ALIGN_UNIT (expr));
2815
2816   else if (TREE_CODE (expr) == COMPONENT_REF
2817            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2818     {
2819       error ("%<__alignof%> applied to a bit-field");
2820       t = size_one_node;
2821     }
2822   else if (TREE_CODE (expr) == COMPONENT_REF
2823            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2824     t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
2825
2826   else if (TREE_CODE (expr) == INDIRECT_REF)
2827     {
2828       tree t = TREE_OPERAND (expr, 0);
2829       tree best = t;
2830       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2831
2832       while (TREE_CODE (t) == NOP_EXPR
2833              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2834         {
2835           int thisalign;
2836
2837           t = TREE_OPERAND (t, 0);
2838           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2839           if (thisalign > bestalign)
2840             best = t, bestalign = thisalign;
2841         }
2842       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2843     }
2844   else
2845     return c_alignof (TREE_TYPE (expr));
2846
2847   return fold (build1 (NOP_EXPR, size_type_node, t));
2848 }
2849 \f
2850 /* Handle C and C++ default attributes.  */
2851
2852 enum built_in_attribute
2853 {
2854 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
2855 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
2856 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
2857 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
2858 #include "builtin-attrs.def"
2859 #undef DEF_ATTR_NULL_TREE
2860 #undef DEF_ATTR_INT
2861 #undef DEF_ATTR_IDENT
2862 #undef DEF_ATTR_TREE_LIST
2863   ATTR_LAST
2864 };
2865
2866 static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
2867
2868 static void c_init_attributes (void);
2869
2870 /* Build tree nodes and builtin functions common to both C and C++ language
2871    frontends.  */
2872
2873 void
2874 c_common_nodes_and_builtins (void)
2875 {
2876   enum builtin_type
2877   {
2878 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2879 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2880 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2881 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2882 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2883 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2884 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2885 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2886 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2887 #define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2888 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2889 #include "builtin-types.def"
2890 #undef DEF_PRIMITIVE_TYPE
2891 #undef DEF_FUNCTION_TYPE_0
2892 #undef DEF_FUNCTION_TYPE_1
2893 #undef DEF_FUNCTION_TYPE_2
2894 #undef DEF_FUNCTION_TYPE_3
2895 #undef DEF_FUNCTION_TYPE_4
2896 #undef DEF_FUNCTION_TYPE_VAR_0
2897 #undef DEF_FUNCTION_TYPE_VAR_1
2898 #undef DEF_FUNCTION_TYPE_VAR_2
2899 #undef DEF_FUNCTION_TYPE_VAR_3
2900 #undef DEF_POINTER_TYPE
2901     BT_LAST
2902   };
2903
2904   typedef enum builtin_type builtin_type;
2905
2906   tree builtin_types[(int) BT_LAST];
2907   int wchar_type_size;
2908   tree array_domain_type;
2909   tree va_list_ref_type_node;
2910   tree va_list_arg_type_node;
2911
2912   /* Define `int' and `char' first so that dbx will output them first.  */
2913   record_builtin_type (RID_INT, NULL, integer_type_node);
2914   record_builtin_type (RID_CHAR, "char", char_type_node);
2915
2916   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2917      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2918      but not C.  Are the conditionals here needed?  */
2919   if (c_dialect_cxx ())
2920     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2921   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2922   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2923   record_builtin_type (RID_MAX, "long unsigned int",
2924                        long_unsigned_type_node);
2925   if (c_dialect_cxx ())
2926     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2927   record_builtin_type (RID_MAX, "long long int",
2928                        long_long_integer_type_node);
2929   record_builtin_type (RID_MAX, "long long unsigned int",
2930                        long_long_unsigned_type_node);
2931   if (c_dialect_cxx ())
2932     record_builtin_type (RID_MAX, "long long unsigned",
2933                          long_long_unsigned_type_node);
2934   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2935   record_builtin_type (RID_MAX, "short unsigned int",
2936                        short_unsigned_type_node);
2937   if (c_dialect_cxx ())
2938     record_builtin_type (RID_MAX, "unsigned short",
2939                          short_unsigned_type_node);
2940
2941   /* Define both `signed char' and `unsigned char'.  */
2942   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2943   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2944
2945   /* These are types that c_common_type_for_size and
2946      c_common_type_for_mode use.  */
2947   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2948                                          intQI_type_node));
2949   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2950                                          intHI_type_node));
2951   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2952                                          intSI_type_node));
2953   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2954                                          intDI_type_node));
2955 #if HOST_BITS_PER_WIDE_INT >= 64
2956   if (targetm.scalar_mode_supported_p (TImode))
2957     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2958                                            get_identifier ("__int128_t"),
2959                                            intTI_type_node));
2960 #endif
2961   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2962                                          unsigned_intQI_type_node));
2963   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2964                                          unsigned_intHI_type_node));
2965   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2966                                          unsigned_intSI_type_node));
2967   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2968                                          unsigned_intDI_type_node));
2969 #if HOST_BITS_PER_WIDE_INT >= 64
2970   if (targetm.scalar_mode_supported_p (TImode))
2971     lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
2972                                            get_identifier ("__uint128_t"),
2973                                            unsigned_intTI_type_node));
2974 #endif
2975
2976   /* Create the widest literal types.  */
2977   widest_integer_literal_type_node
2978     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2979   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2980                                          widest_integer_literal_type_node));
2981
2982   widest_unsigned_literal_type_node
2983     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2984   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2985                                          widest_unsigned_literal_type_node));
2986
2987   /* `unsigned long' is the standard type for sizeof.
2988      Note that stddef.h uses `unsigned long',
2989      and this must agree, even if long and int are the same size.  */
2990   size_type_node =
2991     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2992   signed_size_type_node = c_common_signed_type (size_type_node);
2993   set_sizetype (size_type_node);
2994
2995   pid_type_node =
2996     TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
2997
2998   build_common_tree_nodes_2 (flag_short_double);
2999
3000   record_builtin_type (RID_FLOAT, NULL, float_type_node);
3001   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3002   record_builtin_type (RID_MAX, "long double", long_double_type_node);
3003
3004   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3005                                          get_identifier ("complex int"),
3006                                          complex_integer_type_node));
3007   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3008                                          get_identifier ("complex float"),
3009                                          complex_float_type_node));
3010   lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3011                                          get_identifier ("complex double"),
3012                                          complex_double_type_node));
3013   lang_hooks.decls.pushdecl
3014     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3015                  complex_long_double_type_node));
3016
3017   if (c_dialect_cxx ())
3018     /* For C++, make fileptr_type_node a distinct void * type until
3019        FILE type is defined.  */
3020     fileptr_type_node = build_variant_type_copy (ptr_type_node);
3021
3022   record_builtin_type (RID_VOID, NULL, void_type_node);
3023
3024   /* This node must not be shared.  */
3025   void_zero_node = make_node (INTEGER_CST);
3026   TREE_TYPE (void_zero_node) = void_type_node;
3027
3028   void_list_node = build_void_list_node ();
3029
3030   /* Make a type to be the domain of a few array types
3031      whose domains don't really matter.
3032      200 is small enough that it always fits in size_t
3033      and large enough that it can hold most function names for the
3034      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3035   array_domain_type = build_index_type (size_int (200));
3036
3037   /* Make a type for arrays of characters.
3038      With luck nothing will ever really depend on the length of this
3039      array type.  */
3040   char_array_type_node
3041     = build_array_type (char_type_node, array_domain_type);
3042
3043   /* Likewise for arrays of ints.  */
3044   int_array_type_node
3045     = build_array_type (integer_type_node, array_domain_type);
3046
3047   string_type_node = build_pointer_type (char_type_node);
3048   const_string_type_node
3049     = build_pointer_type (build_qualified_type
3050                           (char_type_node, TYPE_QUAL_CONST));
3051
3052   /* This is special for C++ so functions can be overloaded.  */
3053   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3054   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3055   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3056   if (c_dialect_cxx ())
3057     {
3058       if (TYPE_UNSIGNED (wchar_type_node))
3059         wchar_type_node = make_unsigned_type (wchar_type_size);
3060       else
3061         wchar_type_node = make_signed_type (wchar_type_size);
3062       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3063     }
3064   else
3065     {
3066       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3067       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3068     }
3069
3070   /* This is for wide string constants.  */
3071   wchar_array_type_node
3072     = build_array_type (wchar_type_node, array_domain_type);
3073
3074   wint_type_node =
3075     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3076
3077   intmax_type_node =
3078     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3079   uintmax_type_node =
3080     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3081
3082   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3083   ptrdiff_type_node
3084     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3085   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3086
3087   lang_hooks.decls.pushdecl
3088     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3089                  va_list_type_node));
3090
3091   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3092     {
3093       va_list_arg_type_node = va_list_ref_type_node =
3094         build_pointer_type (TREE_TYPE (va_list_type_node));
3095     }
3096   else
3097     {
3098       va_list_arg_type_node = va_list_type_node;
3099       va_list_ref_type_node = build_reference_type (va_list_type_node);
3100     }
3101
3102 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3103   builtin_types[(int) ENUM] = VALUE;
3104 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3105   builtin_types[(int) ENUM]                             \
3106     = build_function_type (builtin_types[(int) RETURN], \
3107                            void_list_node);
3108 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3109   builtin_types[(int) ENUM]                                             \
3110     = build_function_type (builtin_types[(int) RETURN],                 \
3111                            tree_cons (NULL_TREE,                        \
3112                                       builtin_types[(int) ARG1],        \
3113                                       void_list_node));
3114 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3115   builtin_types[(int) ENUM]                             \
3116     = build_function_type                               \
3117       (builtin_types[(int) RETURN],                     \
3118        tree_cons (NULL_TREE,                            \
3119                   builtin_types[(int) ARG1],            \
3120                   tree_cons (NULL_TREE,                 \
3121                              builtin_types[(int) ARG2], \
3122                              void_list_node)));
3123 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3124   builtin_types[(int) ENUM]                                              \
3125     = build_function_type                                                \
3126       (builtin_types[(int) RETURN],                                      \
3127        tree_cons (NULL_TREE,                                             \
3128                   builtin_types[(int) ARG1],                             \
3129                   tree_cons (NULL_TREE,                                  \
3130                              builtin_types[(int) ARG2],                  \
3131                              tree_cons (NULL_TREE,                       \
3132                                         builtin_types[(int) ARG3],       \
3133                                         void_list_node))));
3134 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3135   builtin_types[(int) ENUM]                                             \
3136     = build_function_type                                               \
3137       (builtin_types[(int) RETURN],                                     \
3138        tree_cons (NULL_TREE,                                            \
3139                   builtin_types[(int) ARG1],                            \
3140                   tree_cons (NULL_TREE,                                 \
3141                              builtin_types[(int) ARG2],                 \
3142                              tree_cons                                  \
3143                              (NULL_TREE,                                \
3144                               builtin_types[(int) ARG3],                \
3145                               tree_cons (NULL_TREE,                     \
3146                                          builtin_types[(int) ARG4],     \
3147                                          void_list_node)))));
3148 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3149   builtin_types[(int) ENUM]                                             \
3150     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3151 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3152    builtin_types[(int) ENUM]                                             \
3153     = build_function_type (builtin_types[(int) RETURN],          \
3154                            tree_cons (NULL_TREE,                         \
3155                                       builtin_types[(int) ARG1],         \
3156                                       NULL_TREE));
3157
3158 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3159    builtin_types[(int) ENUM]                                    \
3160     = build_function_type                                       \
3161       (builtin_types[(int) RETURN],                             \
3162        tree_cons (NULL_TREE,                                    \
3163                   builtin_types[(int) ARG1],                    \
3164                   tree_cons (NULL_TREE,                         \
3165                              builtin_types[(int) ARG2],         \
3166                              NULL_TREE)));
3167
3168 #define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3)         \
3169    builtin_types[(int) ENUM]                                            \
3170     = build_function_type                                               \
3171       (builtin_types[(int) RETURN],                                     \
3172        tree_cons (NULL_TREE,                                            \
3173                   builtin_types[(int) ARG1],                            \
3174                   tree_cons (NULL_TREE,                                 \
3175                              builtin_types[(int) ARG2],                 \
3176                              tree_cons (NULL_TREE,                      \
3177                                         builtin_types[(int) ARG3],      \
3178                                         NULL_TREE))));
3179
3180 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3181   builtin_types[(int) ENUM]                             \
3182     = build_pointer_type (builtin_types[(int) TYPE]);
3183 #include "builtin-types.def"
3184 #undef DEF_PRIMITIVE_TYPE
3185 #undef DEF_FUNCTION_TYPE_1
3186 #undef DEF_FUNCTION_TYPE_2
3187 #undef DEF_FUNCTION_TYPE_3
3188 #undef DEF_FUNCTION_TYPE_4
3189 #undef DEF_FUNCTION_TYPE_VAR_0
3190 #undef DEF_FUNCTION_TYPE_VAR_1
3191 #undef DEF_FUNCTION_TYPE_VAR_2
3192 #undef DEF_FUNCTION_TYPE_VAR_3
3193 #undef DEF_POINTER_TYPE
3194
3195   c_init_attributes ();
3196
3197 #define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE,                   \
3198                     BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT)     \
3199   if (NAME)                                                             \
3200     {                                                                   \
3201       tree decl;                                                        \
3202                                                                         \
3203       gcc_assert (!strncmp (NAME, "__builtin_",                         \
3204                             strlen ("__builtin_")));                    \
3205                                                                         \
3206       if (!BOTH_P)                                                      \
3207         decl = lang_hooks.builtin_function (NAME, builtin_types[TYPE],  \
3208                                  ENUM,                                  \
3209                                  CLASS,                                 \
3210                                  (FALLBACK_P                            \
3211                                   ? (NAME + strlen ("__builtin_"))      \
3212                                   : NULL),                              \
3213                                  built_in_attributes[(int) ATTRS]);     \
3214       else                                                              \
3215         decl = builtin_function_2 (NAME,                                \
3216                                    NAME + strlen ("__builtin_"),        \
3217                                    builtin_types[TYPE],                 \
3218                                    builtin_types[LIBTYPE],              \
3219                                    ENUM,                                \
3220                                    CLASS,                               \
3221                                    FALLBACK_P,                          \
3222                                    NONANSI_P,                           \
3223                                    built_in_attributes[(int) ATTRS]);   \
3224                                                                         \
3225       built_in_decls[(int) ENUM] = decl;                                \
3226       if (IMPLICIT)                                                     \
3227         implicit_built_in_decls[(int) ENUM] = decl;                     \
3228     }
3229 #include "builtins.def"
3230 #undef DEF_BUILTIN
3231
3232   targetm.init_builtins ();
3233   if (flag_mudflap)
3234     mudflap_init ();
3235
3236   main_identifier_node = get_identifier ("main");
3237 }
3238
3239 /* Look up the function in built_in_decls that corresponds to DECL
3240    and set ASMSPEC as its user assembler name.  DECL must be a
3241    function decl that declares a builtin. */
3242
3243 void
3244 set_builtin_user_assembler_name (tree decl, const char *asmspec)
3245 {
3246   tree builtin;
3247   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3248               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3249               && asmspec != 0);
3250
3251   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3252   set_user_assembler_name (builtin, asmspec);
3253   if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3254     init_block_move_fn (asmspec);
3255   else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3256     init_block_clear_fn (asmspec);
3257 }
3258
3259 tree
3260 build_va_arg (tree expr, tree type)
3261 {
3262   return build1 (VA_ARG_EXPR, type, expr);
3263 }
3264
3265
3266 /* Linked list of disabled built-in functions.  */
3267
3268 typedef struct disabled_builtin
3269 {
3270   const char *name;
3271   struct disabled_builtin *next;
3272 } disabled_builtin;
3273 static disabled_builtin *disabled_builtins = NULL;
3274
3275 static bool builtin_function_disabled_p (const char *);
3276
3277 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3278    begins with "__builtin_", give an error.  */
3279
3280 void
3281 disable_builtin_function (const char *name)
3282 {
3283   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3284     error ("cannot disable built-in function %qs", name);
3285   else
3286     {
3287       disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3288       new_disabled_builtin->name = name;
3289       new_disabled_builtin->next = disabled_builtins;
3290       disabled_builtins = new_disabled_builtin;
3291     }
3292 }
3293
3294
3295 /* Return true if the built-in function NAME has been disabled, false
3296    otherwise.  */
3297
3298 static bool
3299 builtin_function_disabled_p (const char *name)
3300 {
3301   disabled_builtin *p;
3302   for (p = disabled_builtins; p != NULL; p = p->next)
3303     {
3304       if (strcmp (name, p->name) == 0)
3305         return true;
3306     }
3307   return false;
3308 }
3309
3310
3311 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3312    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3313    of these may be NULL (though both being NULL is useless).
3314    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3315    TYPE is the type of the function with the ordinary name.  These
3316    may differ if the ordinary name is declared with a looser type to avoid
3317    conflicts with headers.  FUNCTION_CODE and CL are as for
3318    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3319    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3320    If NONANSI_P is true, the name NAME is treated as a non-ANSI name;
3321    ATTRS is the tree list representing the builtin's function attributes.
3322    Returns the declaration of BUILTIN_NAME, if any, otherwise
3323    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3324    or if NONANSI_P and flag_no_nonansi_builtin.  */
3325
3326 static tree
3327 builtin_function_2 (const char *builtin_name, const char *name,
3328                     tree builtin_type, tree type,
3329                     enum built_in_function function_code,
3330                     enum built_in_class cl, int library_name_p,
3331                     bool nonansi_p, tree attrs)
3332 {
3333   tree bdecl = NULL_TREE;
3334   tree decl = NULL_TREE;
3335
3336   if (builtin_name != 0)
3337     bdecl = lang_hooks.builtin_function (builtin_name, builtin_type,
3338                                          function_code, cl,
3339                                          library_name_p ? name : NULL, attrs);
3340
3341   if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3342       && !(nonansi_p && flag_no_nonansi_builtin))
3343     decl = lang_hooks.builtin_function (name, type, function_code, cl,
3344                                         NULL, attrs);
3345
3346   return (bdecl != 0 ? bdecl : decl);
3347 }
3348 \f
3349 /* Nonzero if the type T promotes to int.  This is (nearly) the
3350    integral promotions defined in ISO C99 6.3.1.1/2.  */
3351
3352 bool
3353 c_promoting_integer_type_p (tree t)
3354 {
3355   switch (TREE_CODE (t))
3356     {
3357     case INTEGER_TYPE:
3358       return (TYPE_MAIN_VARIANT (t) == char_type_node
3359               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3360               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3361               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3362               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3363               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3364
3365     case ENUMERAL_TYPE:
3366       /* ??? Technically all enumerations not larger than an int
3367          promote to an int.  But this is used along code paths
3368          that only want to notice a size change.  */
3369       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3370
3371     case BOOLEAN_TYPE:
3372       return 1;
3373
3374     default:
3375       return 0;
3376     }
3377 }
3378
3379 /* Return 1 if PARMS specifies a fixed number of parameters
3380    and none of their types is affected by default promotions.  */
3381
3382 int
3383 self_promoting_args_p (tree parms)
3384 {
3385   tree t;
3386   for (t = parms; t; t = TREE_CHAIN (t))
3387     {
3388       tree type = TREE_VALUE (t);
3389
3390       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3391         return 0;
3392
3393       if (type == 0)
3394         return 0;
3395
3396       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3397         return 0;
3398
3399       if (c_promoting_integer_type_p (type))
3400         return 0;
3401     }
3402   return 1;
3403 }
3404
3405 /* Recursively examines the array elements of TYPE, until a non-array
3406    element type is found.  */
3407
3408 tree
3409 strip_array_types (tree type)
3410 {
3411   while (TREE_CODE (type) == ARRAY_TYPE)
3412     type = TREE_TYPE (type);
3413
3414   return type;
3415 }
3416
3417 /* Recursively remove any '*' or '&' operator from TYPE.  */
3418 tree
3419 strip_pointer_operator (tree t)
3420 {
3421   while (POINTER_TYPE_P (t))
3422     t = TREE_TYPE (t);
3423   return t;
3424 }
3425
3426 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3427    representing case labels, or NULL_TREE for a `default' label.
3428    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3429    K2, and 0 if K1 and K2 are equal.  */
3430
3431 int
3432 case_compare (splay_tree_key k1, splay_tree_key k2)
3433 {
3434   /* Consider a NULL key (such as arises with a `default' label) to be
3435      smaller than anything else.  */
3436   if (!k1)
3437     return k2 ? -1 : 0;
3438   else if (!k2)
3439     return k1 ? 1 : 0;
3440
3441   return tree_int_cst_compare ((tree) k1, (tree) k2);
3442 }
3443
3444 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3445    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3446    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3447    case label was declared using the usual C/C++ syntax, rather than
3448    the GNU case range extension.  CASES is a tree containing all the
3449    case ranges processed so far; COND is the condition for the
3450    switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
3451    ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
3452
3453 tree
3454 c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3455                   tree low_value, tree high_value)
3456 {
3457   tree type;
3458   tree label;
3459   tree case_label;
3460   splay_tree_node node;
3461
3462   /* Create the LABEL_DECL itself.  */
3463   label = create_artificial_label ();
3464
3465   /* If there was an error processing the switch condition, bail now
3466      before we get more confused.  */
3467   if (!cond || cond == error_mark_node)
3468     goto error_out;
3469
3470   if ((low_value && TREE_TYPE (low_value)
3471        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3472       || (high_value && TREE_TYPE (high_value)
3473           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3474     error ("pointers are not permitted as case values");
3475
3476   /* Case ranges are a GNU extension.  */
3477   if (high_value && pedantic)
3478     pedwarn ("range expressions in switch statements are non-standard");
3479
3480   type = TREE_TYPE (cond);
3481   if (low_value)
3482     {
3483       low_value = check_case_value (low_value);
3484       low_value = convert_and_check (type, low_value);
3485     }
3486   if (high_value)
3487     {
3488       high_value = check_case_value (high_value);
3489       high_value = convert_and_check (type, high_value);
3490     }
3491
3492   /* If an error has occurred, bail out now.  */
3493   if (low_value == error_mark_node || high_value == error_mark_node)
3494     goto error_out;
3495
3496   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3497      really a case range, even though it was written that way.  Remove
3498      the HIGH_VALUE to simplify later processing.  */
3499   if (tree_int_cst_equal (low_value, high_value))
3500     high_value = NULL_TREE;
3501   if (low_value && high_value
3502       && !tree_int_cst_lt (low_value, high_value))
3503     warning ("empty range specified");
3504
3505   /* See if the case is in range of the type of the original testing
3506      expression.  If both low_value and high_value are out of range,
3507      don't insert the case label and return NULL_TREE.  */
3508   if (low_value
3509       && !check_case_bounds (type, orig_type,
3510                              &low_value, high_value ? &high_value : NULL))
3511     return NULL_TREE;
3512
3513   /* Look up the LOW_VALUE in the table of case labels we already
3514      have.  */
3515   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3516   /* If there was not an exact match, check for overlapping ranges.
3517      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3518      that's a `default' label and the only overlap is an exact match.  */
3519   if (!node && (low_value || high_value))
3520     {
3521       splay_tree_node low_bound;
3522       splay_tree_node high_bound;
3523
3524       /* Even though there wasn't an exact match, there might be an
3525          overlap between this case range and another case range.
3526          Since we've (inductively) not allowed any overlapping case
3527          ranges, we simply need to find the greatest low case label
3528          that is smaller that LOW_VALUE, and the smallest low case
3529          label that is greater than LOW_VALUE.  If there is an overlap
3530          it will occur in one of these two ranges.  */
3531       low_bound = splay_tree_predecessor (cases,
3532                                           (splay_tree_key) low_value);
3533       high_bound = splay_tree_successor (cases,
3534                                          (splay_tree_key) low_value);
3535
3536       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3537          the LOW_VALUE, so there is no need to check unless the
3538          LOW_BOUND is in fact itself a case range.  */
3539       if (low_bound
3540           && CASE_HIGH ((tree) low_bound->value)
3541           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3542                                     low_value) >= 0)
3543         node = low_bound;
3544       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3545          range is bigger than the low end of the current range, so we
3546          are only interested if the current range is a real range, and
3547          not an ordinary case label.  */
3548       else if (high_bound
3549                && high_value
3550                && (tree_int_cst_compare ((tree) high_bound->key,
3551                                          high_value)
3552                    <= 0))
3553         node = high_bound;
3554     }
3555   /* If there was an overlap, issue an error.  */
3556   if (node)
3557     {
3558       tree duplicate = CASE_LABEL ((tree) node->value);
3559
3560       if (high_value)
3561         {
3562           error ("duplicate (or overlapping) case value");
3563           error ("%Jthis is the first entry overlapping that value", duplicate);
3564         }
3565       else if (low_value)
3566         {
3567           error ("duplicate case value") ;
3568           error ("%Jpreviously used here", duplicate);
3569         }
3570       else
3571         {
3572           error ("multiple default labels in one switch");
3573           error ("%Jthis is the first default label", duplicate);
3574         }
3575       goto error_out;
3576     }
3577
3578   /* Add a CASE_LABEL to the statement-tree.  */
3579   case_label = add_stmt (build_case_label (low_value, high_value, label));
3580   /* Register this case label in the splay tree.  */
3581   splay_tree_insert (cases,
3582                      (splay_tree_key) low_value,
3583                      (splay_tree_value) case_label);
3584
3585   return case_label;
3586
3587  error_out:
3588   /* Add a label so that the back-end doesn't think that the beginning of
3589      the switch is unreachable.  Note that we do not add a case label, as
3590      that just leads to duplicates and thence to aborts later on.  */
3591   if (!cases->root)
3592     {
3593       tree t = create_artificial_label ();
3594       add_stmt (build_stmt (LABEL_EXPR, t));
3595     }
3596   return error_mark_node;
3597 }
3598
3599 /* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3600    Used to verify that case values match up with enumerator values.  */
3601
3602 static void
3603 match_case_to_enum_1 (tree key, tree type, tree label)
3604 {
3605   char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3606
3607   /* ??? Not working too hard to print the double-word value.
3608      Should perhaps be done with %lwd in the diagnostic routines?  */
3609   if (TREE_INT_CST_HIGH (key) == 0)
3610     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3611               TREE_INT_CST_LOW (key));
3612   else if (!TYPE_UNSIGNED (type)
3613            && TREE_INT_CST_HIGH (key) == -1
3614            && TREE_INT_CST_LOW (key) != 0)
3615     snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3616               -TREE_INT_CST_LOW (key));
3617   else
3618     snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3619               TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3620
3621   if (TYPE_NAME (type) == 0)
3622     warning ("%Jcase value %qs not in enumerated type",
3623              CASE_LABEL (label), buf);
3624   else
3625     warning ("%Jcase value %qs not in enumerated type %qT",
3626              CASE_LABEL (label), buf, type);
3627 }
3628
3629 static int
3630 match_case_to_enum (splay_tree_node node, void *data)
3631 {
3632   tree label = (tree) node->value;
3633   tree type = (tree) data;
3634
3635   /* Skip default case.  */
3636   if (!CASE_LOW (label))
3637     return 0;
3638
3639   /* If TREE_ADDRESSABLE is not set, that means CASE_LOW did not appear
3640      when we did our enum->case scan.  Reset our scratch bit after.  */
3641   if (!TREE_ADDRESSABLE (label))
3642     match_case_to_enum_1 (CASE_LOW (label), type, label);
3643   else
3644     TREE_ADDRESSABLE (label) = 0;
3645
3646   /* If CASE_HIGH is non-null, we have a range.  Here we must search.
3647      Note that the old code in stmt.c did not check for the values in
3648      the range either, just the endpoints.  */
3649   if (CASE_HIGH (label))
3650     {
3651       tree chain, key = CASE_HIGH (label);
3652
3653       for (chain = TYPE_VALUES (type);
3654            chain && !tree_int_cst_equal (key, TREE_VALUE (chain));
3655            chain = TREE_CHAIN (chain))
3656         continue;
3657       if (!chain)
3658         match_case_to_enum_1 (key, type, label);
3659     }
3660
3661   return 0;
3662 }
3663
3664 /* Handle -Wswitch*.  Called from the front end after parsing the switch
3665    construct.  */
3666 /* ??? Should probably be somewhere generic, since other languages besides
3667    C and C++ would want this.  We'd want to agree on the datastructure,
3668    however, which is a problem.  Alternately, we operate on gimplified
3669    switch_exprs, which I don't especially like.  At the moment, however,
3670    C/C++ are the only tree-ssa languages that support enumerations at all,
3671    so the point is moot.  */
3672
3673 void
3674 c_do_switch_warnings (splay_tree cases, tree switch_stmt)
3675 {
3676   splay_tree_node default_node;
3677   location_t switch_location;
3678   tree type;
3679
3680   if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3681     return;
3682
3683   if (EXPR_HAS_LOCATION (switch_stmt))
3684     switch_location = EXPR_LOCATION (switch_stmt);
3685   else
3686     switch_location = input_location;
3687
3688   type = SWITCH_TYPE (switch_stmt);
3689
3690   default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3691   if (warn_switch_default && !default_node)
3692     warning ("%Hswitch missing default case", &switch_location);
3693
3694   /* If the switch expression was an enumerated type, check that
3695      exactly all enumeration literals are covered by the cases.
3696      The check is made when -Wswitch was specified and there is no
3697      default case, or when -Wswitch-enum was specified.  */
3698   if (((warn_switch && !default_node) || warn_switch_enum)
3699       && type && TREE_CODE (type) == ENUMERAL_TYPE
3700       && TREE_CODE (SWITCH_COND (switch_stmt)) != INTEGER_CST)
3701     {
3702       tree chain;
3703
3704       /* The time complexity here is O(N*lg(N)) worst case, but for the
3705          common case of monotonically increasing enumerators, it is
3706          O(N), since the nature of the splay tree will keep the next
3707          element adjacent to the root at all times.  */
3708
3709       for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3710         {
3711           splay_tree_node node
3712             = splay_tree_lookup (cases, (splay_tree_key) TREE_VALUE (chain));
3713
3714           if (node)
3715             {
3716               /* Mark the CASE_LOW part of the case entry as seen, so
3717                  that we save time later.  Choose TREE_ADDRESSABLE
3718                  randomly as a bit that won't have been set to-date.  */
3719               tree label = (tree) node->value;
3720               TREE_ADDRESSABLE (label) = 1;
3721             }
3722           else
3723             {
3724               /* Warn if there are enumerators that don't correspond to
3725                  case expressions.  */
3726               warning ("%Henumeration value %qE not handled in switch",
3727                        &switch_location, TREE_PURPOSE (chain));
3728             }
3729         }
3730
3731       /* Warn if there are case expressions that don't correspond to
3732          enumerators.  This can occur since C and C++ don't enforce
3733          type-checking of assignments to enumeration variables.
3734
3735          The time complexity here is O(N**2) worst case, since we've
3736          not sorted the enumeration values.  However, in the absence
3737          of case ranges this is O(N), since all single cases that
3738          corresponded to enumerations have been marked above.  */
3739
3740       splay_tree_foreach (cases, match_case_to_enum, type);
3741     }
3742 }
3743
3744 /* Finish an expression taking the address of LABEL (an
3745    IDENTIFIER_NODE).  Returns an expression for the address.  */
3746
3747 tree
3748 finish_label_address_expr (tree label)
3749 {
3750   tree result;
3751
3752   if (pedantic)
3753     pedwarn ("taking the address of a label is non-standard");
3754
3755   if (label == error_mark_node)
3756     return error_mark_node;
3757
3758   label = lookup_label (label);
3759   if (label == NULL_TREE)
3760     result = null_pointer_node;
3761   else
3762     {
3763       TREE_USED (label) = 1;
3764       result = build1 (ADDR_EXPR, ptr_type_node, label);
3765       /* The current function in not necessarily uninlinable.
3766          Computed gotos are incompatible with inlining, but the value
3767          here could be used only in a diagnostic, for example.  */
3768     }
3769
3770   return result;
3771 }
3772
3773 /* Hook used by expand_expr to expand language-specific tree codes.  */
3774 /* The only things that should go here are bits needed to expand
3775    constant initializers.  Everything else should be handled by the
3776    gimplification routines.  */
3777
3778 rtx
3779 c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3780                int modifier /* Actually enum_modifier.  */,
3781                rtx *alt_rtl)
3782 {
3783   switch (TREE_CODE (exp))
3784     {
3785     case COMPOUND_LITERAL_EXPR:
3786       {
3787         /* Initialize the anonymous variable declared in the compound
3788            literal, then return the variable.  */
3789         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3790         emit_local_var (decl);
3791         return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3792       }
3793
3794     default:
3795       gcc_unreachable ();
3796     }
3797 }
3798
3799 /* Hook used by staticp to handle language-specific tree codes.  */
3800
3801 tree
3802 c_staticp (tree exp)
3803 {
3804   return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3805           && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
3806           ? exp : NULL);
3807 }
3808 \f
3809
3810 /* Given a boolean expression ARG, return a tree representing an increment
3811    or decrement (as indicated by CODE) of ARG.  The front end must check for
3812    invalid cases (e.g., decrement in C++).  */
3813 tree
3814 boolean_increment (enum tree_code code, tree arg)
3815 {
3816   tree val;
3817   tree true_res = boolean_true_node;
3818
3819   arg = stabilize_reference (arg);
3820   switch (code)
3821     {
3822     case PREINCREMENT_EXPR:
3823       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3824       break;
3825     case POSTINCREMENT_EXPR:
3826       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3827       arg = save_expr (arg);
3828       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3829       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3830       break;
3831     case PREDECREMENT_EXPR:
3832       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3833                     invert_truthvalue (arg));
3834       break;
3835     case POSTDECREMENT_EXPR:
3836       val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
3837                     invert_truthvalue (arg));
3838       arg = save_expr (arg);
3839       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3840       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3841       break;
3842     default:
3843       gcc_unreachable ();
3844     }
3845   TREE_SIDE_EFFECTS (val) = 1;
3846   return val;
3847 }
3848 \f
3849 /* Built-in macros for stddef.h, that require macros defined in this
3850    file.  */
3851 void
3852 c_stddef_cpp_builtins(void)
3853 {
3854   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
3855   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
3856   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
3857   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
3858   builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
3859   builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
3860 }
3861
3862 static void
3863 c_init_attributes (void)
3864 {
3865   /* Fill in the built_in_attributes array.  */
3866 #define DEF_ATTR_NULL_TREE(ENUM)                                \
3867   built_in_attributes[(int) ENUM] = NULL_TREE;
3868 #define DEF_ATTR_INT(ENUM, VALUE)                               \
3869   built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
3870 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
3871   built_in_attributes[(int) ENUM] = get_identifier (STRING);
3872 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3873   built_in_attributes[(int) ENUM]                       \
3874     = tree_cons (built_in_attributes[(int) PURPOSE],    \
3875                  built_in_attributes[(int) VALUE],      \
3876                  built_in_attributes[(int) CHAIN]);
3877 #include "builtin-attrs.def"
3878 #undef DEF_ATTR_NULL_TREE
3879 #undef DEF_ATTR_INT
3880 #undef DEF_ATTR_IDENT
3881 #undef DEF_ATTR_TREE_LIST
3882 }
3883
3884 /* Attribute handlers common to C front ends.  */
3885
3886 /* Handle a "packed" attribute; arguments as in
3887    struct attribute_spec.handler.  */
3888
3889 static tree
3890 handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3891                          int flags, bool *no_add_attrs)
3892 {
3893   if (TYPE_P (*node))
3894     {
3895       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
3896         *node = build_variant_type_copy (*node);
3897       TYPE_PACKED (*node) = 1;
3898       if (TYPE_MAIN_VARIANT (*node) == *node)
3899         {
3900           /* If it is the main variant, then pack the other variants
3901              too. This happens in,
3902
3903              struct Foo {
3904                struct Foo const *ptr; // creates a variant w/o packed flag
3905                } __ attribute__((packed)); // packs it now.
3906           */
3907           tree probe;
3908
3909           for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
3910             TYPE_PACKED (probe) = 1;
3911         }
3912
3913     }
3914   else if (TREE_CODE (*node) == FIELD_DECL)
3915     DECL_PACKED (*node) = 1;
3916   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
3917      used for DECL_REGISTER.  It wouldn't mean anything anyway.
3918      We can't set DECL_PACKED on the type of a TYPE_DECL, because
3919      that changes what the typedef is typing.  */
3920   else
3921     {
3922       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
3923       *no_add_attrs = true;
3924     }
3925
3926   return NULL_TREE;
3927 }
3928
3929 /* Handle a "nocommon" attribute; arguments as in
3930    struct attribute_spec.handler.  */
3931
3932 static tree
3933 handle_nocommon_attribute (tree *node, tree name,
3934                            tree ARG_UNUSED (args),
3935                            int ARG_UNUSED (flags), bool *no_add_attrs)
3936 {
3937   if (TREE_CODE (*node) == VAR_DECL)
3938     DECL_COMMON (*node) = 0;
3939   else
3940     {
3941       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
3942       *no_add_attrs = true;
3943     }
3944
3945   return NULL_TREE;
3946 }
3947
3948 /* Handle a "common" attribute; arguments as in
3949    struct attribute_spec.handler.  */
3950
3951 static tree
3952 handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3953                          int ARG_UNUSED (flags), bool *no_add_attrs)
3954 {
3955   if (TREE_CODE (*node) == VAR_DECL)
3956     DECL_COMMON (*node) = 1;
3957   else
3958     {
3959       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
3960       *no_add_attrs = true;
3961     }
3962
3963   return NULL_TREE;
3964 }
3965
3966 /* Handle a "noreturn" attribute; arguments as in
3967    struct attribute_spec.handler.  */
3968
3969 static tree
3970 handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
3971                            int ARG_UNUSED (flags), bool *no_add_attrs)
3972 {
3973   tree type = TREE_TYPE (*node);
3974
3975   /* See FIXME comment in c_common_attribute_table.  */
3976   if (TREE_CODE (*node) == FUNCTION_DECL)
3977     TREE_THIS_VOLATILE (*node) = 1;
3978   else if (TREE_CODE (type) == POINTER_TYPE
3979            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
3980     TREE_TYPE (*node)
3981       = build_pointer_type
3982         (build_type_variant (TREE_TYPE (type),
3983                              TYPE_READONLY (TREE_TYPE (type)), 1));
3984   else
3985     {
3986       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
3987       *no_add_attrs = true;
3988     }
3989
3990   return NULL_TREE;
3991 }
3992
3993 /* Handle a "noinline" attribute; arguments as in
3994    struct attribute_spec.handler.  */
3995
3996 static tree
3997 handle_noinline_attribute (tree *node, tree name,
3998                            tree ARG_UNUSED (args),
3999                            int ARG_UNUSED (flags), bool *no_add_attrs)
4000 {
4001   if (TREE_CODE (*node) == FUNCTION_DECL)
4002     DECL_UNINLINABLE (*node) = 1;
4003   else
4004     {
4005       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4006       *no_add_attrs = true;
4007     }
4008
4009   return NULL_TREE;
4010 }
4011
4012 /* Handle a "always_inline" attribute; arguments as in
4013    struct attribute_spec.handler.  */
4014
4015 static tree
4016 handle_always_inline_attribute (tree *node, tree name,
4017                                 tree ARG_UNUSED (args),
4018                                 int ARG_UNUSED (flags),
4019                                 bool *no_add_attrs)
4020 {
4021   if (TREE_CODE (*node) == FUNCTION_DECL)
4022     {
4023       /* Do nothing else, just set the attribute.  We'll get at
4024          it later with lookup_attribute.  */
4025     }
4026   else
4027     {
4028       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4029       *no_add_attrs = true;
4030     }
4031
4032   return NULL_TREE;
4033 }
4034
4035 /* Handle a "used" attribute; arguments as in
4036    struct attribute_spec.handler.  */
4037
4038 static tree
4039 handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4040                        int ARG_UNUSED (flags), bool *no_add_attrs)
4041 {
4042   tree node = *pnode;
4043
4044   if (TREE_CODE (node) == FUNCTION_DECL
4045       || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4046     {
4047       TREE_USED (node) = 1;
4048       DECL_PRESERVE_P (node) = 1;
4049     }
4050   else
4051     {
4052       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4053       *no_add_attrs = true;
4054     }
4055
4056   return NULL_TREE;
4057 }
4058
4059 /* Handle a "unused" attribute; arguments as in
4060    struct attribute_spec.handler.  */
4061
4062 static tree
4063 handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4064                          int flags, bool *no_add_attrs)
4065 {
4066   if (DECL_P (*node))
4067     {
4068       tree decl = *node;
4069
4070       if (TREE_CODE (decl) == PARM_DECL
4071           || TREE_CODE (decl) == VAR_DECL
4072           || TREE_CODE (decl) == FUNCTION_DECL
4073           || TREE_CODE (decl) == LABEL_DECL
4074           || TREE_CODE (decl) == TYPE_DECL)
4075         TREE_USED (decl) = 1;
4076       else
4077         {
4078           warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4079           *no_add_attrs = true;
4080         }
4081     }
4082   else
4083     {
4084       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4085         *node = build_variant_type_copy (*node);
4086       TREE_USED (*node) = 1;
4087     }
4088
4089   return NULL_TREE;
4090 }
4091
4092 /* Handle a "const" attribute; arguments as in
4093    struct attribute_spec.handler.  */
4094
4095 static tree
4096 handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4097                         int ARG_UNUSED (flags), bool *no_add_attrs)
4098 {
4099   tree type = TREE_TYPE (*node);
4100
4101   /* See FIXME comment on noreturn in c_common_attribute_table.  */
4102   if (TREE_CODE (*node) == FUNCTION_DECL)
4103     TREE_READONLY (*node) = 1;
4104   else if (TREE_CODE (type) == POINTER_TYPE
4105            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4106     TREE_TYPE (*node)
4107       = build_pointer_type
4108         (build_type_variant (TREE_TYPE (type), 1,
4109                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
4110   else
4111     {
4112       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4113       *no_add_attrs = true;
4114     }
4115
4116   return NULL_TREE;
4117 }
4118
4119 /* Handle a "transparent_union" attribute; arguments as in
4120    struct attribute_spec.handler.  */
4121
4122 static tree
4123 handle_transparent_union_attribute (tree *node, tree name,
4124                                     tree ARG_UNUSED (args), int flags,
4125                                     bool *no_add_attrs)
4126 {
4127   tree decl = NULL_TREE;
4128   tree *type = NULL;
4129   int is_type = 0;
4130
4131   if (DECL_P (*node))
4132     {
4133       decl = *node;
4134       type = &TREE_TYPE (decl);
4135       is_type = TREE_CODE (*node) == TYPE_DECL;
4136     }
4137   else if (TYPE_P (*node))
4138     type = node, is_type = 1;
4139
4140   if (is_type
4141       && TREE_CODE (*type) == UNION_TYPE
4142       && (decl == 0
4143           || (TYPE_FIELDS (*type) != 0
4144               && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4145     {
4146       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4147         *type = build_variant_type_copy (*type);
4148       TYPE_TRANSPARENT_UNION (*type) = 1;
4149     }
4150   else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4151            && TREE_CODE (*type) == UNION_TYPE
4152            && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4153     DECL_TRANSPARENT_UNION (decl) = 1;
4154   else
4155     {
4156       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4157       *no_add_attrs = true;
4158     }
4159
4160   return NULL_TREE;
4161 }
4162
4163 /* Handle a "constructor" attribute; arguments as in
4164    struct attribute_spec.handler.  */
4165
4166 static tree
4167 handle_constructor_attribute (tree *node, tree name,
4168                               tree ARG_UNUSED (args),
4169                               int ARG_UNUSED (flags),
4170                               bool *no_add_attrs)
4171 {
4172   tree decl = *node;
4173   tree type = TREE_TYPE (decl);
4174
4175   if (TREE_CODE (decl) == FUNCTION_DECL
4176       && TREE_CODE (type) == FUNCTION_TYPE
4177       && decl_function_context (decl) == 0)
4178     {
4179       DECL_STATIC_CONSTRUCTOR (decl) = 1;
4180       TREE_USED (decl) = 1;
4181     }
4182   else
4183     {
4184       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4185       *no_add_attrs = true;
4186     }
4187
4188   return NULL_TREE;
4189 }
4190
4191 /* Handle a "destructor" attribute; arguments as in
4192    struct attribute_spec.handler.  */
4193
4194 static tree
4195 handle_destructor_attribute (tree *node, tree name,
4196                              tree ARG_UNUSED (args),
4197                              int ARG_UNUSED (flags),
4198                              bool *no_add_attrs)
4199 {
4200   tree decl = *node;
4201   tree type = TREE_TYPE (decl);
4202
4203   if (TREE_CODE (decl) == FUNCTION_DECL
4204       && TREE_CODE (type) == FUNCTION_TYPE
4205       && decl_function_context (decl) == 0)
4206     {
4207       DECL_STATIC_DESTRUCTOR (decl) = 1;
4208       TREE_USED (decl) = 1;
4209     }
4210   else
4211     {
4212       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4213       *no_add_attrs = true;
4214     }
4215
4216   return NULL_TREE;
4217 }
4218
4219 /* Handle a "mode" attribute; arguments as in
4220    struct attribute_spec.handler.  */
4221
4222 static tree
4223 handle_mode_attribute (tree *node, tree name, tree args,
4224                        int ARG_UNUSED (flags), bool *no_add_attrs)
4225 {
4226   tree type = *node;
4227
4228   *no_add_attrs = true;
4229
4230   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4231     warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4232   else
4233     {
4234       int j;
4235       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4236       int len = strlen (p);
4237       enum machine_mode mode = VOIDmode;
4238       tree typefm;
4239       bool valid_mode;
4240
4241       if (len > 4 && p[0] == '_' && p[1] == '_'
4242           && p[len - 1] == '_' && p[len - 2] == '_')
4243         {
4244           char *newp = (char *) alloca (len - 1);
4245
4246           strcpy (newp, &p[2]);
4247           newp[len - 4] = '\0';
4248           p = newp;
4249         }
4250
4251       /* Change this type to have a type with the specified mode.
4252          First check for the special modes.  */
4253       if (!strcmp (p, "byte"))
4254         mode = byte_mode;
4255       else if (!strcmp (p, "word"))
4256         mode = word_mode;
4257       else if (!strcmp (p, "pointer"))
4258         mode = ptr_mode;
4259       else
4260         for (j = 0; j < NUM_MACHINE_MODES; j++)
4261           if (!strcmp (p, GET_MODE_NAME (j)))
4262             {
4263               mode = (enum machine_mode) j;
4264               break;
4265             }
4266
4267       if (mode == VOIDmode)
4268         {
4269           error ("unknown machine mode %qs", p);
4270           return NULL_TREE;
4271         }
4272
4273       valid_mode = false;
4274       switch (GET_MODE_CLASS (mode))
4275         {
4276         case MODE_INT:
4277         case MODE_PARTIAL_INT:
4278         case MODE_FLOAT:
4279           valid_mode = targetm.scalar_mode_supported_p (mode);
4280           break;
4281
4282         case MODE_COMPLEX_INT:
4283         case MODE_COMPLEX_FLOAT:
4284           valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4285           break;
4286
4287         case MODE_VECTOR_INT:
4288         case MODE_VECTOR_FLOAT:
4289           warning ("specifying vector types with __attribute__ ((mode)) "
4290                    "is deprecated");
4291           warning ("use __attribute__ ((vector_size)) instead");
4292           valid_mode = vector_mode_valid_p (mode);
4293           break;
4294
4295         default:
4296           break;
4297         }
4298       if (!valid_mode)
4299         {
4300           error ("unable to emulate %qs", p);
4301           return NULL_TREE;
4302         }
4303
4304       if (POINTER_TYPE_P (type))
4305         {
4306           tree (*fn)(tree, enum machine_mode, bool);
4307
4308           if (!targetm.valid_pointer_mode (mode))
4309             {
4310               error ("invalid pointer mode %qs", p);
4311               return NULL_TREE;
4312             }
4313
4314           if (TREE_CODE (type) == POINTER_TYPE)
4315             fn = build_pointer_type_for_mode;
4316           else
4317             fn = build_reference_type_for_mode;
4318           typefm = fn (TREE_TYPE (type), mode, false);
4319         }
4320       else
4321         typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4322
4323       if (typefm == NULL_TREE)
4324         {
4325           error ("no data type for mode %qs", p);
4326           return NULL_TREE;
4327         }
4328       else if (TREE_CODE (type) == ENUMERAL_TYPE)
4329         {
4330           /* For enumeral types, copy the precision from the integer
4331              type returned above.  If not an INTEGER_TYPE, we can't use
4332              this mode for this type.  */
4333           if (TREE_CODE (typefm) != INTEGER_TYPE)
4334             {
4335               error ("cannot use mode %qs for enumeral types", p);
4336               return NULL_TREE;
4337             }
4338
4339           if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4340             type = build_variant_type_copy (type);
4341
4342           /* We cannot use layout_type here, because that will attempt
4343              to re-layout all variants, corrupting our original.  */
4344           TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4345           TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
4346           TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
4347           TYPE_SIZE (type) = TYPE_SIZE (typefm);
4348           TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
4349           TYPE_MODE (type) = TYPE_MODE (typefm);
4350           if (!TYPE_USER_ALIGN (type))
4351             TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
4352
4353           typefm = type;
4354         }
4355       else if (VECTOR_MODE_P (mode)
4356                ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4357                : TREE_CODE (type) != TREE_CODE (typefm))
4358         {
4359           error ("mode %qs applied to inappropriate type", p);
4360           return NULL_TREE;
4361         }
4362
4363       *node = typefm;
4364     }
4365
4366   return NULL_TREE;
4367 }
4368
4369 /* Handle a "section" attribute; arguments as in
4370    struct attribute_spec.handler.  */
4371
4372 static tree
4373 handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4374                           int ARG_UNUSED (flags), bool *no_add_attrs)
4375 {
4376   tree decl = *node;
4377
4378   if (targetm.have_named_sections)
4379     {
4380       user_defined_section_attribute = true;
4381
4382       if ((TREE_CODE (decl) == FUNCTION_DECL
4383            || TREE_CODE (decl) == VAR_DECL)
4384           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4385         {
4386           if (TREE_CODE (decl) == VAR_DECL
4387               && current_function_decl != NULL_TREE
4388               && !TREE_STATIC (decl))
4389             {
4390               error ("%Jsection attribute cannot be specified for "
4391                      "local variables", decl);
4392               *no_add_attrs = true;
4393             }
4394
4395           /* The decl may have already been given a section attribute
4396              from a previous declaration.  Ensure they match.  */
4397           else if (DECL_SECTION_NAME (decl) != NULL_TREE
4398                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4399                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4400             {
4401               error ("%Jsection of %qD conflicts with previous declaration",
4402                      *node, *node);
4403               *no_add_attrs = true;
4404             }
4405           else
4406             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4407         }
4408       else
4409         {
4410           error ("%Jsection attribute not allowed for %qD", *node, *node);
4411           *no_add_attrs = true;
4412         }
4413     }
4414   else
4415     {
4416       error ("%Jsection attributes are not supported for this target", *node);
4417       *no_add_attrs = true;
4418     }
4419
4420   return NULL_TREE;
4421 }
4422
4423 /* Handle a "aligned" attribute; arguments as in
4424    struct attribute_spec.handler.  */
4425
4426 static tree
4427 handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4428                           int flags, bool *no_add_attrs)
4429 {
4430   tree decl = NULL_TREE;
4431   tree *type = NULL;
4432   int is_type = 0;
4433   tree align_expr = (args ? TREE_VALUE (args)
4434                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4435   int i;
4436
4437   if (DECL_P (*node))
4438     {
4439       decl = *node;
4440       type = &TREE_TYPE (decl);
4441       is_type = TREE_CODE (*node) == TYPE_DECL;
4442     }
4443   else if (TYPE_P (*node))
4444     type = node, is_type = 1;
4445
4446   /* Strip any NOPs of any kind.  */
4447   while (TREE_CODE (align_expr) == NOP_EXPR
4448          || TREE_CODE (align_expr) == CONVERT_EXPR
4449          || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4450     align_expr = TREE_OPERAND (align_expr, 0);
4451
4452   if (TREE_CODE (align_expr) != INTEGER_CST)
4453     {
4454       error ("requested alignment is not a constant");
4455       *no_add_attrs = true;
4456     }
4457   else if ((i = tree_log2 (align_expr)) == -1)
4458     {
4459       error ("requested alignment is not a power of 2");
4460       *no_add_attrs = true;
4461     }
4462   else if (i > HOST_BITS_PER_INT - 2)
4463     {
4464       error ("requested alignment is too large");
4465       *no_add_attrs = true;
4466     }
4467   else if (is_type)
4468     {
4469       /* If we have a TYPE_DECL, then copy the type, so that we
4470          don't accidentally modify a builtin type.  See pushdecl.  */
4471       if (decl && TREE_TYPE (decl) != error_mark_node
4472           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4473         {
4474           tree tt = TREE_TYPE (decl);
4475           *type = build_variant_type_copy (*type);
4476           DECL_ORIGINAL_TYPE (decl) = tt;
4477           TYPE_NAME (*type) = decl;
4478           TREE_USED (*type) = TREE_USED (decl);
4479           TREE_TYPE (decl) = *type;
4480         }
4481       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4482         *type = build_variant_type_copy (*type);
4483
4484       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4485       TYPE_USER_ALIGN (*type) = 1;
4486     }
4487   else if (TREE_CODE (decl) != VAR_DECL
4488            && TREE_CODE (decl) != FIELD_DECL)
4489     {
4490       error ("%Jalignment may not be specified for %qD", decl, decl);
4491       *no_add_attrs = true;
4492     }
4493   else
4494     {
4495       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4496       DECL_USER_ALIGN (decl) = 1;
4497     }
4498
4499   return NULL_TREE;
4500 }
4501
4502 /* Handle a "weak" attribute; arguments as in
4503    struct attribute_spec.handler.  */
4504
4505 static tree
4506 handle_weak_attribute (tree *node, tree ARG_UNUSED (name),
4507                        tree ARG_UNUSED (args),
4508                        int ARG_UNUSED (flags),
4509                        bool * ARG_UNUSED (no_add_attrs))
4510 {
4511   declare_weak (*node);
4512
4513   return NULL_TREE;
4514 }
4515
4516 /* Handle an "alias" attribute; arguments as in
4517    struct attribute_spec.handler.  */
4518
4519 static tree
4520 handle_alias_attribute (tree *node, tree name, tree args,
4521                         int ARG_UNUSED (flags), bool *no_add_attrs)
4522 {
4523   tree decl = *node;
4524
4525   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4526       || (TREE_CODE (decl) != FUNCTION_DECL && !DECL_EXTERNAL (decl)))
4527     {
4528       error ("%J%qD defined both normally and as an alias", decl, decl);
4529       *no_add_attrs = true;
4530     }
4531
4532   /* Note that the very first time we process a nested declaration,
4533      decl_function_context will not be set.  Indeed, *would* never
4534      be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4535      we do below.  After such frobbery, pushdecl would set the context.
4536      In any case, this is never what we want.  */
4537   else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4538     {
4539       tree id;
4540
4541       id = TREE_VALUE (args);
4542       if (TREE_CODE (id) != STRING_CST)
4543         {
4544           error ("alias argument not a string");
4545           *no_add_attrs = true;
4546           return NULL_TREE;
4547         }
4548       id = get_identifier (TREE_STRING_POINTER (id));
4549       /* This counts as a use of the object pointed to.  */
4550       TREE_USED (id) = 1;
4551
4552       if (TREE_CODE (decl) == FUNCTION_DECL)
4553         DECL_INITIAL (decl) = error_mark_node;
4554       else
4555         {
4556           DECL_EXTERNAL (decl) = 0;
4557           TREE_STATIC (decl) = 1;
4558         }
4559     }
4560   else
4561     {
4562       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4563       *no_add_attrs = true;
4564     }
4565
4566   return NULL_TREE;
4567 }
4568
4569 /* Handle an "visibility" attribute; arguments as in
4570    struct attribute_spec.handler.  */
4571
4572 static tree
4573 handle_visibility_attribute (tree *node, tree name, tree args,
4574                              int ARG_UNUSED (flags),
4575                              bool *no_add_attrs)
4576 {
4577   tree decl = *node;
4578   tree id = TREE_VALUE (args);
4579
4580   *no_add_attrs = true;
4581
4582   if (TYPE_P (*node))
4583     {
4584       if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4585        {
4586          warning ("%qs attribute ignored on non-class types",
4587                   IDENTIFIER_POINTER (name));
4588          return NULL_TREE;
4589        }
4590     }
4591   else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4592     {
4593       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4594       return NULL_TREE;
4595     }
4596
4597   if (TREE_CODE (id) != STRING_CST)
4598     {
4599       error ("visibility argument not a string");
4600       return NULL_TREE;
4601     }
4602
4603   /*  If this is a type, set the visibility on the type decl.  */
4604   if (TYPE_P (decl))
4605     {
4606       decl = TYPE_NAME (decl);
4607       if (!decl)
4608         return NULL_TREE;
4609       if (TREE_CODE (decl) == IDENTIFIER_NODE)
4610         {
4611            warning ("%qE attribute ignored on types",
4612                     name);
4613            return NULL_TREE;
4614         }
4615     }
4616
4617   if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4618     DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4619   else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4620     DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4621   else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4622     DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4623   else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4624     DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4625   else
4626     error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4627   DECL_VISIBILITY_SPECIFIED (decl) = 1;
4628
4629   /* For decls only, go ahead and attach the attribute to the node as well.
4630      This is needed so we can determine whether we have VISIBILITY_DEFAULT
4631      because the visibility was not specified, or because it was explicitly
4632      overridden from the class visibility.  */
4633   if (DECL_P (*node))
4634     *no_add_attrs = false;
4635
4636   return NULL_TREE;
4637 }
4638
4639 /* Determine the ELF symbol visibility for DECL, which is either a
4640    variable or a function.  It is an error to use this function if a
4641    definition of DECL is not available in this translation unit.
4642    Returns true if the final visibility has been determined by this
4643    function; false if the caller is free to make additional
4644    modifications.  */
4645
4646 bool
4647 c_determine_visibility (tree decl)
4648 {
4649   gcc_assert (TREE_CODE (decl) == VAR_DECL
4650               || TREE_CODE (decl) == FUNCTION_DECL);
4651
4652   /* If the user explicitly specified the visibility with an
4653      attribute, honor that.  DECL_VISIBILITY will have been set during
4654      the processing of the attribute.  We check for an explicit
4655      attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
4656      to distinguish the use of an attribute from the use of a "#pragma
4657      GCC visibility push(...)"; in the latter case we still want other
4658      considerations to be able to overrule the #pragma.  */
4659   if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
4660     return true;
4661
4662   /* Anything that is exported must have default visibility.  */
4663   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
4664       && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
4665     {
4666       DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4667       DECL_VISIBILITY_SPECIFIED (decl) = 1;
4668       return true;
4669     }
4670
4671   return false;
4672 }
4673
4674 /* Handle an "tls_model" attribute; arguments as in
4675    struct attribute_spec.handler.  */
4676
4677 static tree
4678 handle_tls_model_attribute (tree *node, tree name, tree args,
4679                             int ARG_UNUSED (flags), bool *no_add_attrs)
4680 {
4681   tree decl = *node;
4682
4683   if (!DECL_THREAD_LOCAL (decl))
4684     {
4685       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4686       *no_add_attrs = true;
4687     }
4688   else
4689     {
4690       tree id;
4691
4692       id = TREE_VALUE (args);
4693       if (TREE_CODE (id) != STRING_CST)
4694         {
4695           error ("tls_model argument not a string");
4696           *no_add_attrs = true;
4697           return NULL_TREE;
4698         }
4699       if (strcmp (TREE_STRING_POINTER (id), "local-exec")
4700           && strcmp (TREE_STRING_POINTER (id), "initial-exec")
4701           && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
4702           && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
4703         {
4704           error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
4705           *no_add_attrs = true;
4706           return NULL_TREE;
4707         }
4708     }
4709
4710   return NULL_TREE;
4711 }
4712
4713 /* Handle a "no_instrument_function" attribute; arguments as in
4714    struct attribute_spec.handler.  */
4715
4716 static tree
4717 handle_no_instrument_function_attribute (tree *node, tree name,
4718                                          tree ARG_UNUSED (args),
4719                                          int ARG_UNUSED (flags),
4720                                          bool *no_add_attrs)
4721 {
4722   tree decl = *node;
4723
4724   if (TREE_CODE (decl) != FUNCTION_DECL)
4725     {
4726       error ("%J%qE attribute applies only to functions", decl, name);
4727       *no_add_attrs = true;
4728     }
4729   else if (DECL_INITIAL (decl))
4730     {
4731       error ("%Jcan%'t set %qE attribute after definition", decl, name);
4732       *no_add_attrs = true;
4733     }
4734   else
4735     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
4736
4737   return NULL_TREE;
4738 }
4739
4740 /* Handle a "malloc" attribute; arguments as in
4741    struct attribute_spec.handler.  */
4742
4743 static tree
4744 handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4745                          int ARG_UNUSED (flags), bool *no_add_attrs)
4746 {
4747   if (TREE_CODE (*node) == FUNCTION_DECL)
4748     DECL_IS_MALLOC (*node) = 1;
4749   /* ??? TODO: Support types.  */
4750   else
4751     {
4752       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4753       *no_add_attrs = true;
4754     }
4755
4756   return NULL_TREE;
4757 }
4758
4759 /* Handle a "no_limit_stack" attribute; arguments as in
4760    struct attribute_spec.handler.  */
4761
4762 static tree
4763 handle_no_limit_stack_attribute (tree *node, tree name,
4764                                  tree ARG_UNUSED (args),
4765                                  int ARG_UNUSED (flags),
4766                                  bool *no_add_attrs)
4767 {
4768   tree decl = *node;
4769
4770   if (TREE_CODE (decl) != FUNCTION_DECL)
4771     {
4772       error ("%J%qE attribute applies only to functions", decl, name);
4773       *no_add_attrs = true;
4774     }
4775   else if (DECL_INITIAL (decl))
4776     {
4777       error ("%Jcan%'t set %qE attribute after definition", decl, name);
4778       *no_add_attrs = true;
4779     }
4780   else
4781     DECL_NO_LIMIT_STACK (decl) = 1;
4782
4783   return NULL_TREE;
4784 }
4785
4786 /* Handle a "pure" attribute; arguments as in
4787    struct attribute_spec.handler.  */
4788
4789 static tree
4790 handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4791                        int ARG_UNUSED (flags), bool *no_add_attrs)
4792 {
4793   if (TREE_CODE (*node) == FUNCTION_DECL)
4794     DECL_IS_PURE (*node) = 1;
4795   /* ??? TODO: Support types.  */
4796   else
4797     {
4798       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4799       *no_add_attrs = true;
4800     }
4801
4802   return NULL_TREE;
4803 }
4804
4805 /* Handle a "deprecated" attribute; arguments as in
4806    struct attribute_spec.handler.  */
4807
4808 static tree
4809 handle_deprecated_attribute (tree *node, tree name,
4810                              tree ARG_UNUSED (args), int flags,
4811                              bool *no_add_attrs)
4812 {
4813   tree type = NULL_TREE;
4814   int warn = 0;
4815   const char *what = NULL;
4816
4817   if (DECL_P (*node))
4818     {
4819       tree decl = *node;
4820       type = TREE_TYPE (decl);
4821
4822       if (TREE_CODE (decl) == TYPE_DECL
4823           || TREE_CODE (decl) == PARM_DECL
4824           || TREE_CODE (decl) == VAR_DECL
4825           || TREE_CODE (decl) == FUNCTION_DECL
4826           || TREE_CODE (decl) == FIELD_DECL)
4827         TREE_DEPRECATED (decl) = 1;
4828       else
4829         warn = 1;
4830     }
4831   else if (TYPE_P (*node))
4832     {
4833       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4834         *node = build_variant_type_copy (*node);
4835       TREE_DEPRECATED (*node) = 1;
4836       type = *node;
4837     }
4838   else
4839     warn = 1;
4840
4841   if (warn)
4842     {
4843       *no_add_attrs = true;
4844       if (type && TYPE_NAME (type))
4845         {
4846           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
4847             what = IDENTIFIER_POINTER (TYPE_NAME (*node));
4848           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
4849                    && DECL_NAME (TYPE_NAME (type)))
4850             what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
4851         }
4852       if (what)
4853         warning ("%qs attribute ignored for %qs",
4854                   IDENTIFIER_POINTER (name), what);
4855       else
4856         warning ("%qs attribute ignored",
4857                       IDENTIFIER_POINTER (name));
4858     }
4859
4860   return NULL_TREE;
4861 }
4862
4863 /* Handle a "vector_size" attribute; arguments as in
4864    struct attribute_spec.handler.  */
4865
4866 static tree
4867 handle_vector_size_attribute (tree *node, tree name, tree args,
4868                               int ARG_UNUSED (flags),
4869                               bool *no_add_attrs)
4870 {
4871   unsigned HOST_WIDE_INT vecsize, nunits;
4872   enum machine_mode orig_mode;
4873   tree type = *node, new_type, size;
4874
4875   *no_add_attrs = true;
4876
4877   /* Stripping NON_LVALUE_EXPR allows declarations such as
4878      typedef short v4si __attribute__((vector_size (4 * sizeof(short)))).  */
4879   size = TREE_VALUE (args);
4880   if (TREE_CODE (size) == NON_LVALUE_EXPR)
4881     size = TREE_OPERAND (size, 0);
4882
4883   if (!host_integerp (size, 1))
4884     {
4885       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
4886       return NULL_TREE;
4887     }
4888
4889   /* Get the vector size (in bytes).  */
4890   vecsize = tree_low_cst (size, 1);
4891
4892   /* We need to provide for vector pointers, vector arrays, and
4893      functions returning vectors.  For example:
4894
4895        __attribute__((vector_size(16))) short *foo;
4896
4897      In this case, the mode is SI, but the type being modified is
4898      HI, so we need to look further.  */
4899
4900   while (POINTER_TYPE_P (type)
4901          || TREE_CODE (type) == FUNCTION_TYPE
4902          || TREE_CODE (type) == METHOD_TYPE
4903          || TREE_CODE (type) == ARRAY_TYPE)
4904     type = TREE_TYPE (type);
4905
4906   /* Get the mode of the type being modified.  */
4907   orig_mode = TYPE_MODE (type);
4908
4909   if (TREE_CODE (type) == RECORD_TYPE
4910       || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
4911           && GET_MODE_CLASS (orig_mode) != MODE_INT)
4912       || !host_integerp (TYPE_SIZE_UNIT (type), 1))
4913     {
4914       error ("invalid vector type for attribute %qs",
4915              IDENTIFIER_POINTER (name));
4916       return NULL_TREE;
4917     }
4918
4919   /* Calculate how many units fit in the vector.  */
4920   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
4921   if (nunits & (nunits - 1))
4922     {
4923       error ("number of components of the vector not a power of two");
4924       return NULL_TREE;
4925     }
4926
4927   new_type = build_vector_type (type, nunits);
4928
4929   /* Build back pointers if needed.  */
4930   *node = reconstruct_complex_type (*node, new_type);
4931
4932   return NULL_TREE;
4933 }
4934
4935 /* Handle the "nonnull" attribute.  */
4936 static tree
4937 handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
4938                           tree args, int ARG_UNUSED (flags),
4939                           bool *no_add_attrs)
4940 {
4941   tree type = *node;
4942   unsigned HOST_WIDE_INT attr_arg_num;
4943
4944   /* If no arguments are specified, all pointer arguments should be
4945      non-null.  Verify a full prototype is given so that the arguments
4946      will have the correct types when we actually check them later.  */
4947   if (!args)
4948     {
4949       if (!TYPE_ARG_TYPES (type))
4950         {
4951           error ("nonnull attribute without arguments on a non-prototype");
4952           *no_add_attrs = true;
4953         }
4954       return NULL_TREE;
4955     }
4956
4957   /* Argument list specified.  Verify that each argument number references
4958      a pointer argument.  */
4959   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
4960     {
4961       tree argument;
4962       unsigned HOST_WIDE_INT arg_num = 0, ck_num;
4963
4964       if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
4965         {
4966           error ("nonnull argument has invalid operand number (argument %lu)",
4967                  (unsigned long) attr_arg_num);
4968           *no_add_attrs = true;
4969           return NULL_TREE;
4970         }
4971
4972       argument = TYPE_ARG_TYPES (type);
4973       if (argument)
4974         {
4975           for (ck_num = 1; ; ck_num++)
4976             {
4977               if (!argument || ck_num == arg_num)
4978                 break;
4979               argument = TREE_CHAIN (argument);
4980             }
4981
4982           if (!argument
4983               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
4984             {
4985               error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
4986                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
4987               *no_add_attrs = true;
4988               return NULL_TREE;
4989             }
4990
4991           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
4992             {
4993               error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
4994                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
4995               *no_add_attrs = true;
4996               return NULL_TREE;
4997             }
4998         }
4999     }
5000
5001   return NULL_TREE;
5002 }
5003
5004 /* Check the argument list of a function call for null in argument slots
5005    that are marked as requiring a non-null pointer argument.  */
5006
5007 static void
5008 check_function_nonnull (tree attrs, tree params)
5009 {
5010   tree a, args, param;
5011   int param_num;
5012
5013   for (a = attrs; a; a = TREE_CHAIN (a))
5014     {
5015       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5016         {
5017           args = TREE_VALUE (a);
5018
5019           /* Walk the argument list.  If we encounter an argument number we
5020              should check for non-null, do it.  If the attribute has no args,
5021              then every pointer argument is checked (in which case the check
5022              for pointer type is done in check_nonnull_arg).  */
5023           for (param = params, param_num = 1; ;
5024                param_num++, param = TREE_CHAIN (param))
5025             {
5026               if (!param)
5027         break;
5028               if (!args || nonnull_check_p (args, param_num))
5029         check_function_arguments_recurse (check_nonnull_arg, NULL,
5030                                           TREE_VALUE (param),
5031                                           param_num);
5032             }
5033         }
5034     }
5035 }
5036
5037 /* Check that the Nth argument of a function call (counting backwards
5038    from the end) is a (pointer)0.  */
5039
5040 static void
5041 check_function_sentinel (tree attrs, tree params)
5042 {
5043   tree attr = lookup_attribute ("sentinel", attrs);
5044
5045   if (attr)
5046     {
5047       if (!params)
5048         warning ("missing sentinel in function call");
5049       else
5050         {
5051           tree sentinel, end;
5052           unsigned pos = 0;
5053
5054           if (TREE_VALUE (attr))
5055             {
5056               tree p = TREE_VALUE (TREE_VALUE (attr));
5057               STRIP_NOPS (p);
5058               pos = TREE_INT_CST_LOW (p);
5059             }
5060
5061           sentinel = end = params;
5062
5063           /* Advance `end' ahead of `sentinel' by `pos' positions.  */
5064           while (pos > 0 && TREE_CHAIN (end))
5065             {
5066               pos--;
5067               end = TREE_CHAIN (end);
5068             }
5069           if (pos > 0)
5070             {
5071               warning ("not enough arguments to fit a sentinel");
5072               return;
5073             }
5074
5075           /* Now advance both until we find the last parameter.  */
5076           while (TREE_CHAIN (end))
5077             {
5078               end = TREE_CHAIN (end);
5079               sentinel = TREE_CHAIN (sentinel);
5080             }
5081
5082           /* Validate the sentinel.  */
5083           if (!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5084               || !integer_zerop (TREE_VALUE (sentinel)))
5085             warning ("missing sentinel in function call");
5086         }
5087     }
5088 }
5089
5090 /* Helper for check_function_nonnull; given a list of operands which
5091    must be non-null in ARGS, determine if operand PARAM_NUM should be
5092    checked.  */
5093
5094 static bool
5095 nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5096 {
5097   unsigned HOST_WIDE_INT arg_num = 0;
5098
5099   for (; args; args = TREE_CHAIN (args))
5100     {
5101       bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5102
5103       gcc_assert (found);
5104
5105       if (arg_num == param_num)
5106         return true;
5107     }
5108   return false;
5109 }
5110
5111 /* Check that the function argument PARAM (which is operand number
5112    PARAM_NUM) is non-null.  This is called by check_function_nonnull
5113    via check_function_arguments_recurse.  */
5114
5115 static void
5116 check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5117                    unsigned HOST_WIDE_INT param_num)
5118 {
5119   /* Just skip checking the argument if it's not a pointer.  This can
5120      happen if the "nonnull" attribute was given without an operand
5121      list (which means to check every pointer argument).  */
5122
5123   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5124     return;
5125
5126   if (integer_zerop (param))
5127     warning ("null argument where non-null required (argument %lu)",
5128              (unsigned long) param_num);
5129 }
5130
5131 /* Helper for nonnull attribute handling; fetch the operand number
5132    from the attribute argument list.  */
5133
5134 static bool
5135 get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5136 {
5137   /* Strip any conversions from the arg number and verify they
5138      are constants.  */
5139   while (TREE_CODE (arg_num_expr) == NOP_EXPR
5140          || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5141          || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5142     arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5143
5144   if (TREE_CODE (arg_num_expr) != INTEGER_CST
5145       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5146     return false;
5147
5148   *valp = TREE_INT_CST_LOW (arg_num_expr);
5149   return true;
5150 }
5151
5152 /* Handle a "nothrow" attribute; arguments as in
5153    struct attribute_spec.handler.  */
5154
5155 static tree
5156 handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5157                           int ARG_UNUSED (flags), bool *no_add_attrs)
5158 {
5159   if (TREE_CODE (*node) == FUNCTION_DECL)
5160     TREE_NOTHROW (*node) = 1;
5161   /* ??? TODO: Support types.  */
5162   else
5163     {
5164       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
5165       *no_add_attrs = true;
5166     }
5167
5168   return NULL_TREE;
5169 }
5170
5171 /* Handle a "cleanup" attribute; arguments as in
5172    struct attribute_spec.handler.  */
5173
5174 static tree
5175 handle_cleanup_attribute (tree *node, tree name, tree args,
5176                           int ARG_UNUSED (flags), bool *no_add_attrs)
5177 {
5178   tree decl = *node;
5179   tree cleanup_id, cleanup_decl;
5180
5181   /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5182      for global destructors in C++.  This requires infrastructure that
5183      we don't have generically at the moment.  It's also not a feature
5184      we'd be missing too much, since we do have attribute constructor.  */
5185   if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5186     {
5187       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
5188       *no_add_attrs = true;
5189       return NULL_TREE;
5190     }
5191
5192   /* Verify that the argument is a function in scope.  */
5193   /* ??? We could support pointers to functions here as well, if
5194      that was considered desirable.  */
5195   cleanup_id = TREE_VALUE (args);
5196   if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5197     {
5198       error ("cleanup argument not an identifier");
5199       *no_add_attrs = true;
5200       return NULL_TREE;
5201     }
5202   cleanup_decl = lookup_name (cleanup_id);
5203   if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5204     {
5205       error ("cleanup argument not a function");
5206       *no_add_attrs = true;
5207       return NULL_TREE;
5208     }
5209
5210   /* That the function has proper type is checked with the
5211      eventual call to build_function_call.  */
5212
5213   return NULL_TREE;
5214 }
5215
5216 /* Handle a "warn_unused_result" attribute.  No special handling.  */
5217
5218 static tree
5219 handle_warn_unused_result_attribute (tree *node, tree name,
5220                                tree ARG_UNUSED (args),
5221                                int ARG_UNUSED (flags), bool *no_add_attrs)
5222 {
5223   /* Ignore the attribute for functions not returning any value.  */
5224   if (VOID_TYPE_P (TREE_TYPE (*node)))
5225     {
5226       warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
5227       *no_add_attrs = true;
5228     }
5229
5230   return NULL_TREE;
5231 }
5232
5233 /* Handle a "sentinel" attribute.  */
5234
5235 static tree
5236 handle_sentinel_attribute (tree *node, tree name, tree args,
5237                            int ARG_UNUSED (flags), bool *no_add_attrs)
5238 {
5239   tree params = TYPE_ARG_TYPES (*node);
5240
5241   if (!params)
5242     {
5243       warning ("%qs attribute requires prototypes with named arguments",
5244                IDENTIFIER_POINTER (name));
5245       *no_add_attrs = true;
5246     }
5247   else
5248     {
5249       while (TREE_CHAIN (params))
5250         params = TREE_CHAIN (params);
5251
5252       if (VOID_TYPE_P (TREE_VALUE (params)))
5253         {
5254           warning ("%qs attribute only applies to variadic functions",
5255                    IDENTIFIER_POINTER (name));
5256           *no_add_attrs = true;
5257         }
5258     }
5259
5260   if (args)
5261     {
5262       tree position = TREE_VALUE (args);
5263
5264       STRIP_NOPS (position);
5265       if (TREE_CODE (position) != INTEGER_CST)
5266         {
5267           warning ("requested position is not an integer constant");
5268           *no_add_attrs = true;
5269         }
5270       else
5271         {
5272           if (tree_int_cst_lt (position, integer_zero_node))
5273             {
5274               warning ("requested position is less than zero");
5275               *no_add_attrs = true;
5276             }
5277         }
5278     }
5279
5280   return NULL_TREE;
5281 }
5282 \f
5283 /* Check for valid arguments being passed to a function.  */
5284 void
5285 check_function_arguments (tree attrs, tree params)
5286 {
5287   /* Check for null being passed in a pointer argument that must be
5288      non-null.  We also need to do this if format checking is enabled.  */
5289
5290   if (warn_nonnull)
5291     check_function_nonnull (attrs, params);
5292
5293   /* Check for errors in format strings.  */
5294
5295   if (warn_format)
5296     {
5297       check_function_format (attrs, params);
5298       check_function_sentinel (attrs, params);
5299     }
5300 }
5301
5302 /* Generic argument checking recursion routine.  PARAM is the argument to
5303    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
5304    once the argument is resolved.  CTX is context for the callback.  */
5305 void
5306 check_function_arguments_recurse (void (*callback)
5307                                   (void *, tree, unsigned HOST_WIDE_INT),
5308                                   void *ctx, tree param,
5309                                   unsigned HOST_WIDE_INT param_num)
5310 {
5311   if (TREE_CODE (param) == NOP_EXPR)
5312     {
5313       /* Strip coercion.  */
5314       check_function_arguments_recurse (callback, ctx,
5315                                         TREE_OPERAND (param, 0), param_num);
5316       return;
5317     }
5318
5319   if (TREE_CODE (param) == CALL_EXPR)
5320     {
5321       tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5322       tree attrs;
5323       bool found_format_arg = false;
5324
5325       /* See if this is a call to a known internationalization function
5326          that modifies a format arg.  Such a function may have multiple
5327          format_arg attributes (for example, ngettext).  */
5328
5329       for (attrs = TYPE_ATTRIBUTES (type);
5330            attrs;
5331            attrs = TREE_CHAIN (attrs))
5332         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5333           {
5334             tree inner_args;
5335             tree format_num_expr;
5336             int format_num;
5337             int i;
5338
5339             /* Extract the argument number, which was previously checked
5340                to be valid.  */
5341             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5342             while (TREE_CODE (format_num_expr) == NOP_EXPR
5343                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
5344                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5345               format_num_expr = TREE_OPERAND (format_num_expr, 0);
5346
5347             gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5348                         && !TREE_INT_CST_HIGH (format_num_expr));
5349
5350             format_num = TREE_INT_CST_LOW (format_num_expr);
5351
5352             for (inner_args = TREE_OPERAND (param, 1), i = 1;
5353                  inner_args != 0;
5354                  inner_args = TREE_CHAIN (inner_args), i++)
5355               if (i == format_num)
5356                 {
5357                   check_function_arguments_recurse (callback, ctx,
5358                                                     TREE_VALUE (inner_args),
5359                                                     param_num);
5360                   found_format_arg = true;
5361                   break;
5362                 }
5363           }
5364
5365       /* If we found a format_arg attribute and did a recursive check,
5366          we are done with checking this argument.  Otherwise, we continue
5367          and this will be considered a non-literal.  */
5368       if (found_format_arg)
5369         return;
5370     }
5371
5372   if (TREE_CODE (param) == COND_EXPR)
5373     {
5374       /* Check both halves of the conditional expression.  */
5375       check_function_arguments_recurse (callback, ctx,
5376                                         TREE_OPERAND (param, 1), param_num);
5377       check_function_arguments_recurse (callback, ctx,
5378                                         TREE_OPERAND (param, 2), param_num);
5379       return;
5380     }
5381
5382   (*callback) (ctx, param, param_num);
5383 }
5384
5385 /* Function to help qsort sort FIELD_DECLs by name order.  */
5386
5387 int
5388 field_decl_cmp (const void *x_p, const void *y_p)
5389 {
5390   const tree *const x = (const tree *const) x_p;
5391   const tree *const y = (const tree *const) y_p;
5392
5393   if (DECL_NAME (*x) == DECL_NAME (*y))
5394     /* A nontype is "greater" than a type.  */
5395     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5396   if (DECL_NAME (*x) == NULL_TREE)
5397     return -1;
5398   if (DECL_NAME (*y) == NULL_TREE)
5399     return 1;
5400   if (DECL_NAME (*x) < DECL_NAME (*y))
5401     return -1;
5402   return 1;
5403 }
5404
5405 static struct {
5406   gt_pointer_operator new_value;
5407   void *cookie;
5408 } resort_data;
5409
5410 /* This routine compares two fields like field_decl_cmp but using the
5411 pointer operator in resort_data.  */
5412
5413 static int
5414 resort_field_decl_cmp (const void *x_p, const void *y_p)
5415 {
5416   const tree *const x = (const tree *const) x_p;
5417   const tree *const y = (const tree *const) y_p;
5418
5419   if (DECL_NAME (*x) == DECL_NAME (*y))
5420     /* A nontype is "greater" than a type.  */
5421     return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5422   if (DECL_NAME (*x) == NULL_TREE)
5423     return -1;
5424   if (DECL_NAME (*y) == NULL_TREE)
5425     return 1;
5426   {
5427     tree d1 = DECL_NAME (*x);
5428     tree d2 = DECL_NAME (*y);
5429     resort_data.new_value (&d1, resort_data.cookie);
5430     resort_data.new_value (&d2, resort_data.cookie);
5431     if (d1 < d2)
5432       return -1;
5433   }
5434   return 1;
5435 }
5436
5437 /* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
5438
5439 void
5440 resort_sorted_fields (void *obj,
5441                       void * ARG_UNUSED (orig_obj),
5442                       gt_pointer_operator new_value,
5443                       void *cookie)
5444 {
5445   struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5446   resort_data.new_value = new_value;
5447   resort_data.cookie = cookie;
5448   qsort (&sf->elts[0], sf->len, sizeof (tree),
5449          resort_field_decl_cmp);
5450 }
5451
5452 /* Subroutine of c_parse_error.
5453    Return the result of concatenating LHS and RHS. RHS is really
5454    a string literal, its first character is indicated by RHS_START and
5455    RHS_SIZE is its length (including the terminating NUL character).
5456
5457    The caller is responsible for deleting the returned pointer.  */
5458
5459 static char *
5460 catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5461 {
5462   const int lhs_size = strlen (lhs);
5463   char *result = XNEWVEC (char, lhs_size + rhs_size);
5464   strncpy (result, lhs, lhs_size);
5465   strncpy (result + lhs_size, rhs_start, rhs_size);
5466   return result;
5467 }
5468
5469 /* Issue the error given by MSGID, indicating that it occurred before
5470    TOKEN, which had the associated VALUE.  */
5471
5472 void
5473 c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
5474 {
5475 #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5476
5477   char *message = NULL;
5478
5479   if (token == CPP_EOF)
5480     message = catenate_messages (msgid, " at end of input");
5481   else if (token == CPP_CHAR || token == CPP_WCHAR)
5482     {
5483       unsigned int val = TREE_INT_CST_LOW (value);
5484       const char *const ell = (token == CPP_CHAR) ? "" : "L";
5485       if (val <= UCHAR_MAX && ISGRAPH (val))
5486         message = catenate_messages (msgid, " before %s'%c'");
5487       else
5488         message = catenate_messages (msgid, " before %s'\\x%x'");
5489
5490       error (message, ell, val);
5491       free (message);
5492       message = NULL;
5493     }
5494   else if (token == CPP_STRING || token == CPP_WSTRING)
5495     message = catenate_messages (msgid, " before string constant");
5496   else if (token == CPP_NUMBER)
5497     message = catenate_messages (msgid, " before numeric constant");
5498   else if (token == CPP_NAME)
5499     {
5500       message = catenate_messages (msgid, " before %qs");
5501       error (message, IDENTIFIER_POINTER (value));
5502       free (message);
5503       message = NULL;
5504     }
5505   else if (token < N_TTYPES)
5506     {
5507       message = catenate_messages (msgid, " before %qs token");
5508       error (message, cpp_type2name (token));
5509       free (message);
5510       message = NULL;
5511     }
5512   else
5513     error (msgid);
5514
5515   if (message)
5516     {
5517       error (message);
5518       free (message);
5519     }
5520 #undef catenate_messages
5521 }
5522
5523 /* Walk a gimplified function and warn for functions whose return value is
5524    ignored and attribute((warn_unused_result)) is set.  This is done before
5525    inlining, so we don't have to worry about that.  */
5526
5527 void
5528 c_warn_unused_result (tree *top_p)
5529 {
5530   tree t = *top_p;
5531   tree_stmt_iterator i;
5532   tree fdecl, ftype;
5533
5534   switch (TREE_CODE (t))
5535     {
5536     case STATEMENT_LIST:
5537       for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5538         c_warn_unused_result (tsi_stmt_ptr (i));
5539       break;
5540
5541     case COND_EXPR:
5542       c_warn_unused_result (&COND_EXPR_THEN (t));
5543       c_warn_unused_result (&COND_EXPR_ELSE (t));
5544       break;
5545     case BIND_EXPR:
5546       c_warn_unused_result (&BIND_EXPR_BODY (t));
5547       break;
5548     case TRY_FINALLY_EXPR:
5549     case TRY_CATCH_EXPR:
5550       c_warn_unused_result (&TREE_OPERAND (t, 0));
5551       c_warn_unused_result (&TREE_OPERAND (t, 1));
5552       break;
5553     case CATCH_EXPR:
5554       c_warn_unused_result (&CATCH_BODY (t));
5555       break;
5556     case EH_FILTER_EXPR:
5557       c_warn_unused_result (&EH_FILTER_FAILURE (t));
5558       break;
5559
5560     case CALL_EXPR:
5561       if (TREE_USED (t))
5562         break;
5563
5564       /* This is a naked call, as opposed to a CALL_EXPR nested inside
5565          a MODIFY_EXPR.  All calls whose value is ignored should be
5566          represented like this.  Look for the attribute.  */
5567       fdecl = get_callee_fndecl (t);
5568       if (fdecl)
5569         ftype = TREE_TYPE (fdecl);
5570       else
5571         {
5572           ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5573           /* Look past pointer-to-function to the function type itself.  */
5574           ftype = TREE_TYPE (ftype);
5575         }
5576
5577       if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5578         {
5579           if (fdecl)
5580             warning ("%Hignoring return value of %qD, "
5581                      "declared with attribute warn_unused_result",
5582                      EXPR_LOCUS (t), fdecl);
5583           else
5584             warning ("%Hignoring return value of function "
5585                      "declared with attribute warn_unused_result",
5586                      EXPR_LOCUS (t));
5587         }
5588       break;
5589
5590     default:
5591       /* Not a container, not a call, or a call whose value is used.  */
5592       break;
5593     }
5594 }
5595
5596 /* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
5597    component references, with an INDIRECT_REF at the bottom; much like
5598    the traditional rendering of offsetof as a macro.  Returns the folded
5599    and properly cast result.  */
5600
5601 static tree
5602 fold_offsetof_1 (tree expr)
5603 {
5604   enum tree_code code = PLUS_EXPR;
5605   tree base, off, t;
5606
5607   switch (TREE_CODE (expr))
5608     {
5609     case ERROR_MARK:
5610       return expr;
5611
5612     case INDIRECT_REF:
5613       return size_zero_node;
5614
5615     case COMPONENT_REF:
5616       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5617       if (base == error_mark_node)
5618         return base;
5619
5620       t = TREE_OPERAND (expr, 1);
5621       if (DECL_C_BIT_FIELD (t))
5622         {
5623           error ("attempt to take address of bit-field structure "
5624                  "member %qs", IDENTIFIER_POINTER (DECL_NAME (t)));
5625           return error_mark_node;
5626         }
5627       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
5628                         size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
5629                                   / BITS_PER_UNIT));
5630       break;
5631
5632     case ARRAY_REF:
5633       base = fold_offsetof_1 (TREE_OPERAND (expr, 0));
5634       if (base == error_mark_node)
5635         return base;
5636
5637       t = TREE_OPERAND (expr, 1);
5638       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
5639         {
5640           code = MINUS_EXPR;
5641           t = fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t));
5642         }
5643       t = convert (sizetype, t);
5644       off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
5645       break;
5646
5647     default:
5648       gcc_unreachable ();
5649     }
5650
5651   return size_binop (code, base, off);
5652 }
5653
5654 tree
5655 fold_offsetof (tree expr)
5656 {
5657   /* Convert back from the internal sizetype to size_t.  */
5658   return convert (size_type_node, fold_offsetof_1 (expr));
5659 }
5660
5661 /* Return nonzero if REF is an lvalue valid for this language;
5662    otherwise, print an error message and return zero.  USE says
5663    how the lvalue is being used and so selects the error message.  */
5664
5665 int
5666 lvalue_or_else (tree ref, enum lvalue_use use)
5667 {
5668   int win = lvalue_p (ref);
5669
5670   if (!win)
5671     {
5672       switch (use)
5673         {
5674         case lv_assign:
5675           error ("invalid lvalue in assignment");
5676           break;
5677         case lv_increment:
5678           error ("invalid lvalue in increment");
5679           break;
5680         case lv_decrement:
5681           error ("invalid lvalue in decrement");
5682           break;
5683         case lv_addressof:
5684           error ("invalid lvalue in unary %<&%>");
5685           break;
5686         case lv_asm:
5687           error ("invalid lvalue in asm statement");
5688           break;
5689         default:
5690           gcc_unreachable ();
5691         }
5692     }
5693
5694   return win;
5695 }
5696
5697 #include "gt-c-common.h"