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