gcc/c-common.c

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