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