gcc/c-common.c

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