gcc/c-common.c

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