gcc/c-common.c

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