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