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