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 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 "tree.h"
  25 #include "real.h"
  26 #include "flags.h"
  27 #include "toplev.h"
  28 #include "output.h"
  29 #include "c-pragma.h"
  30 #include "rtl.h"
  31 #include "ggc.h"
  32 #include "expr.h"
  33 #include "c-common.h"
  34 #include "tree-inline.h"
  35 #include "diagnostic.h"
  36 #include "tm_p.h"
  37 #include "obstack.h"
  38 #include "cpplib.h"
  39 #include "target.h"
  40 #include "langhooks.h"
  41 #include "except.h"             /* For USING_SJLJ_EXCEPTIONS.  */
  42
  43 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
  44
  45 /* We let tm.h override the types used here, to handle trivial differences
  46    such as the choice of unsigned int or long unsigned int for size_t.
  47    When machines start needing nontrivial differences in the size type,
  48    it would be best to do something here to figure out automatically
  49    from other information what type to use.  */
  50
  51 #ifndef SIZE_TYPE
  52 #define SIZE_TYPE "long unsigned int"
  53 #endif
  54
  55 #ifndef WCHAR_TYPE
  56 #define WCHAR_TYPE "int"
  57 #endif
  58
  59 /* WCHAR_TYPE gets overridden by -fshort-wchar.  */
  60 #define MODIFIED_WCHAR_TYPE \
  61         (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
  62
  63 #ifndef PTRDIFF_TYPE
  64 #define PTRDIFF_TYPE "long int"
  65 #endif
  66
  67 #ifndef WINT_TYPE
  68 #define WINT_TYPE "unsigned int"
  69 #endif
  70
  71 #ifndef INTMAX_TYPE
  72 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  73                      ? "int"                                    \
  74                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  75                         ? "long int"                            \
  76                         : "long long int"))
  77 #endif
  78
  79 #ifndef UINTMAX_TYPE
  80 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  81                      ? "unsigned int"                           \
  82                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  83                         ? "long unsigned int"                   \
  84                         : "long long unsigned int"))
  85 #endif
  86
  87 #ifndef STDC_0_IN_SYSTEM_HEADERS
  88 #define STDC_0_IN_SYSTEM_HEADERS 0
  89 #endif
  90
  91 #ifndef REGISTER_PREFIX
  92 #define REGISTER_PREFIX ""
  93 #endif
  94
  95 /* The variant of the C language being processed.  */
  96
  97 enum c_language_kind c_language;
  98
  99 /* The following symbols are subsumed in the c_global_trees array, and
 100    listed here individually for documentation purposes.
 101
 102    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
 103
 104         tree short_integer_type_node;
 105         tree long_integer_type_node;
 106         tree long_long_integer_type_node;
 107
 108         tree short_unsigned_type_node;
 109         tree long_unsigned_type_node;
 110         tree long_long_unsigned_type_node;
 111
 112         tree boolean_type_node;
 113         tree boolean_false_node;
 114         tree boolean_true_node;
 115
 116         tree ptrdiff_type_node;
 117
 118         tree unsigned_char_type_node;
 119         tree signed_char_type_node;
 120         tree wchar_type_node;
 121         tree signed_wchar_type_node;
 122         tree unsigned_wchar_type_node;
 123
 124         tree float_type_node;
 125         tree double_type_node;
 126         tree long_double_type_node;
 127
 128         tree complex_integer_type_node;
 129         tree complex_float_type_node;
 130         tree complex_double_type_node;
 131         tree complex_long_double_type_node;
 132
 133         tree intQI_type_node;
 134         tree intHI_type_node;
 135         tree intSI_type_node;
 136         tree intDI_type_node;
 137         tree intTI_type_node;
 138
 139         tree unsigned_intQI_type_node;
 140         tree unsigned_intHI_type_node;
 141         tree unsigned_intSI_type_node;
 142         tree unsigned_intDI_type_node;
 143         tree unsigned_intTI_type_node;
 144
 145         tree widest_integer_literal_type_node;
 146         tree widest_unsigned_literal_type_node;
 147
 148    Nodes for types `void *' and `const void *'.
 149
 150         tree ptr_type_node, const_ptr_type_node;
 151
 152    Nodes for types `char *' and `const char *'.
 153
 154         tree string_type_node, const_string_type_node;
 155
 156    Type `char[SOMENUMBER]'.
 157    Used when an array of char is needed and the size is irrelevant.
 158
 159         tree char_array_type_node;
 160
 161    Type `int[SOMENUMBER]' or something like it.
 162    Used when an array of int needed and the size is irrelevant.
 163
 164         tree int_array_type_node;
 165
 166    Type `wchar_t[SOMENUMBER]' or something like it.
 167    Used when a wide string literal is created.
 168
 169         tree wchar_array_type_node;
 170
 171    Type `int ()' -- used for implicit declaration of functions.
 172
 173         tree default_function_type;
 174
 175    A VOID_TYPE node, packaged in a TREE_LIST.
 176
 177         tree void_list_node;
 178
 179   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
 180   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 181   VAR_DECLS, but C++ does.)
 182
 183         tree function_name_decl_node;
 184         tree pretty_function_name_decl_node;
 185         tree c99_function_name_decl_node;
 186
 187   Stack of nested function name VAR_DECLs.
 188
 189         tree saved_function_name_decls;
 190
 191 */
 192
 193 tree c_global_trees[CTI_MAX];
 194
 195 /* Nonzero if prepreprocessing only.  */
 196 int flag_preprocess_only;
 197
 198 /* Nonzero if an ISO standard was selected.  It rejects macros in the
 199    user's namespace.  */
 200 int flag_iso;
 201
 202 /* Nonzero if -undef was given.  It suppresses target built-in macros
 203    and assertions.  */
 204 int flag_undef;
 205
 206 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 207
 208 int flag_no_builtin;
 209
 210 /* Nonzero means don't recognize the non-ANSI builtin functions.
 211    -ansi sets this.  */
 212
 213 int flag_no_nonansi_builtin;
 214
 215 /* Nonzero means give `double' the same size as `float'.  */
 216
 217 int flag_short_double;
 218
 219 /* Nonzero means give `wchar_t' the same size as `short'.  */
 220
 221 int flag_short_wchar;
 222
 223 /* Nonzero means warn about use of multicharacter literals.  */
 224
 225 int warn_multichar = 1;
 226
 227 /* Nonzero means warn about possible violations of sequence point rules.  */
 228
 229 int warn_sequence_point;
 230
 231 /* Nonzero means to warn about compile-time division by zero.  */
 232 int warn_div_by_zero = 1;
 233
 234 /* Warn about NULL being passed to argument slots marked as requiring
 235    non-NULL.  */
 236
 237 int warn_nonnull;
 238
 239 /* The elements of `ridpointers' are identifier nodes for the reserved
 240    type names and storage classes.  It is indexed by a RID_... value.  */
 241 tree *ridpointers;
 242
 243 tree (*make_fname_decl)                PARAMS ((tree, int));
 244
 245 /* If non-NULL, the address of a language-specific function that
 246    returns 1 for language-specific statement codes.  */
 247 int (*lang_statement_code_p)           PARAMS ((enum tree_code));
 248
 249 /* If non-NULL, the address of a language-specific function that takes
 250    any action required right before expand_function_end is called.  */
 251 void (*lang_expand_function_end)       PARAMS ((void));
 252
 253 /* Nonzero means the expression being parsed will never be evaluated.
 254    This is a count, since unevaluated expressions can nest.  */
 255 int skip_evaluation;
 256
 257 /* Information about how a function name is generated.  */
 258 struct fname_var_t
 259 {
 260   tree *const decl;     /* pointer to the VAR_DECL.  */
 261   const unsigned rid;   /* RID number for the identifier.  */
 262   const int pretty;     /* How pretty is it? */
 263 };
 264
 265 /* The three ways of getting then name of the current function.  */
 266
 267 const struct fname_var_t fname_vars[] =
 268 {
 269   /* C99 compliant __func__, must be first.  */
 270   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 271   /* GCC __FUNCTION__ compliant.  */
 272   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 273   /* GCC __PRETTY_FUNCTION__ compliant.  */
 274   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 275   {NULL, 0, 0},
 276 };
 277
 278 static int constant_fits_type_p         PARAMS ((tree, tree));
 279
 280 /* Keep a stack of if statements.  We record the number of compound
 281    statements seen up to the if keyword, as well as the line number
 282    and file of the if.  If a potentially ambiguous else is seen, that
 283    fact is recorded; the warning is issued when we can be sure that
 284    the enclosing if statement does not have an else branch.  */
 285 typedef struct
 286 {
 287   int compstmt_count;
 288   int line;
 289   const char *file;
 290   int needs_warning;
 291   tree if_stmt;
 292 } if_elt;
 293
 294 static if_elt *if_stack;
 295
 296 /* Amount of space in the if statement stack.  */
 297 static int if_stack_space = 0;
 298
 299 /* Stack pointer.  */
 300 static int if_stack_pointer = 0;
 301
 302 static void cb_register_builtins PARAMS ((cpp_reader *));
 303
 304 static tree handle_packed_attribute     PARAMS ((tree *, tree, tree, int,
 305                                                  bool *));
 306 static tree handle_nocommon_attribute   PARAMS ((tree *, tree, tree, int,
 307                                                  bool *));
 308 static tree handle_common_attribute     PARAMS ((tree *, tree, tree, int,
 309                                                  bool *));
 310 static tree handle_noreturn_attribute   PARAMS ((tree *, tree, tree, int,
 311                                                  bool *));
 312 static tree handle_noinline_attribute   PARAMS ((tree *, tree, tree, int,
 313                                                  bool *));
 314 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
 315                                                     bool *));
 316 static tree handle_used_attribute       PARAMS ((tree *, tree, tree, int,
 317                                                  bool *));
 318 static tree handle_unused_attribute     PARAMS ((tree *, tree, tree, int,
 319                                                  bool *));
 320 static tree handle_const_attribute      PARAMS ((tree *, tree, tree, int,
 321                                                  bool *));
 322 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
 323                                                         int, bool *));
 324 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
 325                                                   bool *));
 326 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
 327                                                  bool *));
 328 static tree handle_mode_attribute       PARAMS ((tree *, tree, tree, int,
 329                                                  bool *));
 330 static tree handle_section_attribute    PARAMS ((tree *, tree, tree, int,
 331                                                  bool *));
 332 static tree handle_aligned_attribute    PARAMS ((tree *, tree, tree, int,
 333                                                  bool *));
 334 static tree handle_weak_attribute       PARAMS ((tree *, tree, tree, int,
 335                                                  bool *));
 336 static tree handle_alias_attribute      PARAMS ((tree *, tree, tree, int,
 337                                                  bool *));
 338 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
 339                                                  bool *));
 340 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
 341                                                              tree, int,
 342                                                              bool *));
 343 static tree handle_malloc_attribute     PARAMS ((tree *, tree, tree, int,
 344                                                  bool *));
 345 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
 346                                                      bool *));
 347 static tree handle_pure_attribute       PARAMS ((tree *, tree, tree, int,
 348                                                  bool *));
 349 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
 350                                                  bool *));
 351 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
 352                                                   bool *));
 353 static tree handle_nonnull_attribute    PARAMS ((tree *, tree, tree, int,
 354                                                  bool *));
 355 static tree handle_nothrow_attribute    PARAMS ((tree *, tree, tree, int,
 356                                                  bool *));
 357 static tree vector_size_helper PARAMS ((tree, tree));
 358
 359 static void check_function_nonnull      PARAMS ((tree, tree));
 360 static void check_nonnull_arg           PARAMS ((void *, tree,
 361                                                  unsigned HOST_WIDE_INT));
 362 static bool nonnull_check_p             PARAMS ((tree, unsigned HOST_WIDE_INT));
 363 static bool get_nonnull_operand         PARAMS ((tree,
 364                                                  unsigned HOST_WIDE_INT *));
 365 void builtin_define_std PARAMS ((const char *));
 366 static void builtin_define_with_value PARAMS ((const char *, const char *,
 367                                                int));
 368
 369 /* Table of machine-independent attributes common to all C-like languages.  */
 370 const struct attribute_spec c_common_attribute_table[] =
 371 {
 372   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 373   { "packed",                 0, 0, false, false, false,
 374                               handle_packed_attribute },
 375   { "nocommon",               0, 0, true,  false, false,
 376                               handle_nocommon_attribute },
 377   { "common",                 0, 0, true,  false, false,
 378                               handle_common_attribute },
 379   /* FIXME: logically, noreturn attributes should be listed as
 380      "false, true, true" and apply to function types.  But implementing this
 381      would require all the places in the compiler that use TREE_THIS_VOLATILE
 382      on a decl to identify non-returning functions to be located and fixed
 383      to check the function type instead.  */
 384   { "noreturn",               0, 0, true,  false, false,
 385                               handle_noreturn_attribute },
 386   { "volatile",               0, 0, true,  false, false,
 387                               handle_noreturn_attribute },
 388   { "noinline",               0, 0, true,  false, false,
 389                               handle_noinline_attribute },
 390   { "always_inline",          0, 0, true,  false, false,
 391                               handle_always_inline_attribute },
 392   { "used",                   0, 0, true,  false, false,
 393                               handle_used_attribute },
 394   { "unused",                 0, 0, false, false, false,
 395                               handle_unused_attribute },
 396   /* The same comments as for noreturn attributes apply to const ones.  */
 397   { "const",                  0, 0, true,  false, false,
 398                               handle_const_attribute },
 399   { "transparent_union",      0, 0, false, false, false,
 400                               handle_transparent_union_attribute },
 401   { "constructor",            0, 0, true,  false, false,
 402                               handle_constructor_attribute },
 403   { "destructor",             0, 0, true,  false, false,
 404                               handle_destructor_attribute },
 405   { "mode",                   1, 1, false,  true, false,
 406                               handle_mode_attribute },
 407   { "section",                1, 1, true,  false, false,
 408                               handle_section_attribute },
 409   { "aligned",                0, 1, false, false, false,
 410                               handle_aligned_attribute },
 411   { "weak",                   0, 0, true,  false, false,
 412                               handle_weak_attribute },
 413   { "alias",                  1, 1, true,  false, false,
 414                               handle_alias_attribute },
 415   { "no_instrument_function", 0, 0, true,  false, false,
 416                               handle_no_instrument_function_attribute },
 417   { "malloc",                 0, 0, true,  false, false,
 418                               handle_malloc_attribute },
 419   { "no_stack_limit",         0, 0, true,  false, false,
 420                               handle_no_limit_stack_attribute },
 421   { "pure",                   0, 0, true,  false, false,
 422                               handle_pure_attribute },
 423   { "deprecated",             0, 0, false, false, false,
 424                               handle_deprecated_attribute },
 425   { "vector_size",            1, 1, false, true, false,
 426                               handle_vector_size_attribute },
 427   { "visibility",             1, 1, true,  false, false,
 428                               handle_visibility_attribute },
 429   { "nonnull",                0, -1, false, true, true,
 430                               handle_nonnull_attribute },
 431   { "nothrow",                0, 0, true,  false, false,
 432                               handle_nothrow_attribute },
 433   { NULL,                     0, 0, false, false, false, NULL }
 434 };
 435
 436 /* Give the specifications for the format attributes, used by C and all
 437    descendents.  */
 438
 439 const struct attribute_spec c_common_format_attribute_table[] =
 440 {
 441   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 442   { "format",                 3, 3, false, true,  true,
 443                               handle_format_attribute },
 444   { "format_arg",             1, 1, false, true,  true,
 445                               handle_format_arg_attribute },
 446   { NULL,                     0, 0, false, false, false, NULL }
 447 };
 448
 449 /* Record the start of an if-then, and record the start of it
 450    for ambiguous else detection.
 451
 452    COND is the condition for the if-then statement.
 453
 454    IF_STMT is the statement node that has already been created for
 455    this if-then statement.  It is created before parsing the
 456    condition to keep line number information accurate.  */
 457
 458 void
 459 c_expand_start_cond (cond, compstmt_count, if_stmt)
 460      tree cond;
 461      int compstmt_count;
 462      tree if_stmt;
 463 {
 464   /* Make sure there is enough space on the stack.  */
 465   if (if_stack_space == 0)
 466     {
 467       if_stack_space = 10;
 468       if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
 469     }
 470   else if (if_stack_space == if_stack_pointer)
 471     {
 472       if_stack_space += 10;
 473       if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 474     }
 475
 476   IF_COND (if_stmt) = cond;
 477   add_stmt (if_stmt);
 478
 479   /* Record this if statement.  */
 480   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 481   if_stack[if_stack_pointer].file = input_filename;
 482   if_stack[if_stack_pointer].line = lineno;
 483   if_stack[if_stack_pointer].needs_warning = 0;
 484   if_stack[if_stack_pointer].if_stmt = if_stmt;
 485   if_stack_pointer++;
 486 }
 487
 488 /* Called after the then-clause for an if-statement is processed.  */
 489
 490 void
 491 c_finish_then ()
 492 {
 493   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 494   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 495 }
 496
 497 /* Record the end of an if-then.  Optionally warn if a nested
 498    if statement had an ambiguous else clause.  */
 499
 500 void
 501 c_expand_end_cond ()
 502 {
 503   if_stack_pointer--;
 504   if (if_stack[if_stack_pointer].needs_warning)
 505     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 506                                 if_stack[if_stack_pointer].line,
 507                                 "suggest explicit braces to avoid ambiguous `else'");
 508   last_expr_type = NULL_TREE;
 509 }
 510
 511 /* Called between the then-clause and the else-clause
 512    of an if-then-else.  */
 513
 514 void
 515 c_expand_start_else ()
 516 {
 517   /* An ambiguous else warning must be generated for the enclosing if
 518      statement, unless we see an else branch for that one, too.  */
 519   if (warn_parentheses
 520       && if_stack_pointer > 1
 521       && (if_stack[if_stack_pointer - 1].compstmt_count
 522           == if_stack[if_stack_pointer - 2].compstmt_count))
 523     if_stack[if_stack_pointer - 2].needs_warning = 1;
 524
 525   /* Even if a nested if statement had an else branch, it can't be
 526      ambiguous if this one also has an else.  So don't warn in that
 527      case.  Also don't warn for any if statements nested in this else.  */
 528   if_stack[if_stack_pointer - 1].needs_warning = 0;
 529   if_stack[if_stack_pointer - 1].compstmt_count--;
 530 }
 531
 532 /* Called after the else-clause for an if-statement is processed.  */
 533
 534 void
 535 c_finish_else ()
 536 {
 537   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 538   RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 539 }
 540
 541 /* Begin an if-statement.  Returns a newly created IF_STMT if
 542    appropriate.
 543
 544    Unlike the C++ front-end, we do not call add_stmt here; it is
 545    probably safe to do so, but I am not very familiar with this
 546    code so I am being extra careful not to change its behavior
 547    beyond what is strictly necessary for correctness.  */
 548
 549 tree
 550 c_begin_if_stmt ()
 551 {
 552   tree r;
 553   r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 554   return r;
 555 }
 556
 557 /* Begin a while statement.  Returns a newly created WHILE_STMT if
 558    appropriate.
 559
 560    Unlike the C++ front-end, we do not call add_stmt here; it is
 561    probably safe to do so, but I am not very familiar with this
 562    code so I am being extra careful not to change its behavior
 563    beyond what is strictly necessary for correctness.  */
 564
 565 tree
 566 c_begin_while_stmt ()
 567 {
 568   tree r;
 569   r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
 570   return r;
 571 }
 572
 573 void
 574 c_finish_while_stmt_cond (cond, while_stmt)
 575      tree while_stmt;
 576      tree cond;
 577 {
 578   WHILE_COND (while_stmt) = cond;
 579 }
 580
 581 /* Push current bindings for the function name VAR_DECLS.  */
 582
 583 void
 584 start_fname_decls ()
 585 {
 586   unsigned ix;
 587   tree saved = NULL_TREE;
 588
 589   for (ix = 0; fname_vars[ix].decl; ix++)
 590     {
 591       tree decl = *fname_vars[ix].decl;
 592
 593       if (decl)
 594         {
 595           saved = tree_cons (decl, build_int_2 (ix, 0), saved);
 596           *fname_vars[ix].decl = NULL_TREE;
 597         }
 598     }
 599   if (saved || saved_function_name_decls)
 600     /* Normally they'll have been NULL, so only push if we've got a
 601        stack, or they are non-NULL.  */
 602     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 603                                            saved_function_name_decls);
 604 }
 605
 606 /* Finish up the current bindings, adding them into the
 607    current function's statement tree. This is done by wrapping the
 608    function's body in a COMPOUND_STMT containing these decls too. This
 609    must be done _before_ finish_stmt_tree is called. If there is no
 610    current function, we must be at file scope and no statements are
 611    involved. Pop the previous bindings.  */
 612
 613 void
 614 finish_fname_decls ()
 615 {
 616   unsigned ix;
 617   tree body = NULL_TREE;
 618   tree stack = saved_function_name_decls;
 619
 620   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 621     body = chainon (TREE_VALUE (stack), body);
 622
 623   if (body)
 624     {
 625       /* They were called into existence, so add to statement tree.  */
 626       body = chainon (body,
 627                       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
 628       body = build_stmt (COMPOUND_STMT, body);
 629
 630       COMPOUND_STMT_NO_SCOPE (body) = 1;
 631       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
 632     }
 633
 634   for (ix = 0; fname_vars[ix].decl; ix++)
 635     *fname_vars[ix].decl = NULL_TREE;
 636
 637   if (stack)
 638     {
 639       /* We had saved values, restore them.  */
 640       tree saved;
 641
 642       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 643         {
 644           tree decl = TREE_PURPOSE (saved);
 645           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 646
 647           *fname_vars[ix].decl = decl;
 648         }
 649       stack = TREE_CHAIN (stack);
 650     }
 651   saved_function_name_decls = stack;
 652 }
 653
 654 /* Return the text name of the current function, suitable prettified
 655    by PRETTY_P.  */
 656
 657 const char *
 658 fname_as_string (pretty_p)
 659      int pretty_p;
 660 {
 661   const char *name = NULL;
 662
 663   if (pretty_p)
 664     name = (current_function_decl
 665             ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
 666             : "top level");
 667   else if (current_function_decl && DECL_NAME (current_function_decl))
 668     name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 669   else
 670     name = "";
 671   return name;
 672 }
 673
 674 /* Return the text name of the current function, formatted as
 675    required by the supplied RID value.  */
 676
 677 const char *
 678 fname_string (rid)
 679      unsigned rid;
 680 {
 681   unsigned ix;
 682
 683   for (ix = 0; fname_vars[ix].decl; ix++)
 684     if (fname_vars[ix].rid == rid)
 685       break;
 686   return fname_as_string (fname_vars[ix].pretty);
 687 }
 688
 689 /* Return the VAR_DECL for a const char array naming the current
 690    function. If the VAR_DECL has not yet been created, create it
 691    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 692    ID is its name (unfortunately C and C++ hold the RID values of
 693    keywords in different places, so we can't derive RID from ID in
 694    this language independent code.  */
 695
 696 tree
 697 fname_decl (rid, id)
 698      unsigned rid;
 699      tree id;
 700 {
 701   unsigned ix;
 702   tree decl = NULL_TREE;
 703
 704   for (ix = 0; fname_vars[ix].decl; ix++)
 705     if (fname_vars[ix].rid == rid)
 706       break;
 707
 708   decl = *fname_vars[ix].decl;
 709   if (!decl)
 710     {
 711       tree saved_last_tree = last_tree;
 712
 713       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 714       if (last_tree != saved_last_tree)
 715         {
 716           /* We created some statement tree for the decl. This belongs
 717              at the start of the function, so remove it now and reinsert
 718              it after the function is complete.  */
 719           tree stmts = TREE_CHAIN (saved_last_tree);
 720
 721           TREE_CHAIN (saved_last_tree) = NULL_TREE;
 722           last_tree = saved_last_tree;
 723           saved_function_name_decls = tree_cons (decl, stmts,
 724                                                  saved_function_name_decls);
 725         }
 726       *fname_vars[ix].decl = decl;
 727     }
 728   if (!ix && !current_function_decl)
 729     pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
 730
 731   return decl;
 732 }
 733
 734 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
 735
 736 tree
 737 fix_string_type (value)
 738       tree value;
 739 {
 740   const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 741   const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
 742   const int nchars_max = flag_isoc99 ? 4095 : 509;
 743   int length = TREE_STRING_LENGTH (value);
 744   int nchars;
 745
 746   /* Compute the number of elements, for the array type.  */
 747   nchars = wide_flag ? length / wchar_bytes : length;
 748
 749   if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
 750     pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
 751              nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
 752
 753   /* Create the array type for the string constant.
 754      -Wwrite-strings says make the string constant an array of const char
 755      so that copying it to a non-const pointer will get a warning.
 756      For C++, this is the standard behavior.  */
 757   if (flag_const_strings && ! flag_writable_strings)
 758     {
 759       tree elements
 760         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 761                               1, 0);
 762       TREE_TYPE (value)
 763         = build_array_type (elements,
 764                             build_index_type (build_int_2 (nchars - 1, 0)));
 765     }
 766   else
 767     TREE_TYPE (value)
 768       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 769                           build_index_type (build_int_2 (nchars - 1, 0)));
 770
 771   TREE_CONSTANT (value) = 1;
 772   TREE_READONLY (value) = ! flag_writable_strings;
 773   TREE_STATIC (value) = 1;
 774   return value;
 775 }
 776
 777 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
 778    STRING_CST.  */
 779
 780 tree
 781 combine_strings (strings)
 782      varray_type strings;
 783 {
 784   const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 785   const int nstrings = VARRAY_ACTIVE_SIZE (strings);
 786   tree value, t;
 787   int length = 1;
 788   int wide_length = 0;
 789   int wide_flag = 0;
 790   int i;
 791   char *p, *q;
 792
 793   /* Don't include the \0 at the end of each substring.  Count wide
 794      strings and ordinary strings separately.  */
 795   for (i = 0; i < nstrings; ++i)
 796     {
 797       t = VARRAY_TREE (strings, i);
 798
 799       if (TREE_TYPE (t) == wchar_array_type_node)
 800         {
 801           wide_length += TREE_STRING_LENGTH (t) - wchar_bytes;
 802           wide_flag = 1;
 803         }
 804       else
 805         {
 806           length += (TREE_STRING_LENGTH (t) - 1);
 807           if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
 808             warning ("concatenation of string literals with __FUNCTION__ is deprecated");
 809         }
 810     }
 811
 812   /* If anything is wide, the non-wides will be converted,
 813      which makes them take more space.  */
 814   if (wide_flag)
 815     length = length * wchar_bytes + wide_length;
 816
 817   p = xmalloc (length);
 818
 819   /* Copy the individual strings into the new combined string.
 820      If the combined string is wide, convert the chars to ints
 821      for any individual strings that are not wide.  */
 822
 823   q = p;
 824   for (i = 0; i < nstrings; ++i)
 825     {
 826       int len, this_wide;
 827
 828       t = VARRAY_TREE (strings, i);
 829       this_wide = TREE_TYPE (t) == wchar_array_type_node;
 830       len = TREE_STRING_LENGTH (t) - (this_wide ? wchar_bytes : 1);
 831       if (this_wide == wide_flag)
 832         {
 833           memcpy (q, TREE_STRING_POINTER (t), len);
 834           q += len;
 835         }
 836       else
 837         {
 838           const int nzeros = (TYPE_PRECISION (wchar_type_node)
 839                               / BITS_PER_UNIT) - 1;
 840           int j, k;
 841
 842           if (BYTES_BIG_ENDIAN)
 843             {
 844               for (k = 0; k < len; k++)
 845                 {
 846                   for (j = 0; j < nzeros; j++)
 847                     *q++ = 0;
 848                   *q++ = TREE_STRING_POINTER (t)[k];
 849                 }
 850             }
 851           else
 852             {
 853               for (k = 0; k < len; k++)
 854                 {
 855                   *q++ = TREE_STRING_POINTER (t)[k];
 856                   for (j = 0; j < nzeros; j++)
 857                     *q++ = 0;
 858                 }
 859             }
 860         }
 861     }
 862
 863   /* Nul terminate the string.  */
 864   if (wide_flag)
 865     {
 866       for (i = 0; i < wchar_bytes; i++)
 867         *q++ = 0;
 868     }
 869   else
 870     *q = 0;
 871
 872   value = build_string (length, p);
 873   free (p);
 874
 875   if (wide_flag)
 876     TREE_TYPE (value) = wchar_array_type_node;
 877   else
 878     TREE_TYPE (value) = char_array_type_node;
 879
 880   return value;
 881 }
 882 \f
 883 static int is_valid_printf_arglist PARAMS ((tree));
 884 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
 885 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
 886                                             enum expand_modifier, int, int));
 887 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
 888                                              enum expand_modifier, int, int));
 889 \f
 890 /* Print a warning if a constant expression had overflow in folding.
 891    Invoke this function on every expression that the language
 892    requires to be a constant expression.
 893    Note the ANSI C standard says it is erroneous for a
 894    constant expression to overflow.  */
 895
 896 void
 897 constant_expression_warning (value)
 898      tree value;
 899 {
 900   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
 901        || TREE_CODE (value) == VECTOR_CST
 902        || TREE_CODE (value) == COMPLEX_CST)
 903       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
 904     pedwarn ("overflow in constant expression");
 905 }
 906
 907 /* Print a warning if an expression had overflow in folding.
 908    Invoke this function on every expression that
 909    (1) appears in the source code, and
 910    (2) might be a constant expression that overflowed, and
 911    (3) is not already checked by convert_and_check;
 912    however, do not invoke this function on operands of explicit casts.  */
 913
 914 void
 915 overflow_warning (value)
 916      tree value;
 917 {
 918   if ((TREE_CODE (value) == INTEGER_CST
 919        || (TREE_CODE (value) == COMPLEX_CST
 920            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
 921       && TREE_OVERFLOW (value))
 922     {
 923       TREE_OVERFLOW (value) = 0;
 924       if (skip_evaluation == 0)
 925         warning ("integer overflow in expression");
 926     }
 927   else if ((TREE_CODE (value) == REAL_CST
 928             || (TREE_CODE (value) == COMPLEX_CST
 929                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
 930            && TREE_OVERFLOW (value))
 931     {
 932       TREE_OVERFLOW (value) = 0;
 933       if (skip_evaluation == 0)
 934         warning ("floating point overflow in expression");
 935     }
 936   else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
 937     {
 938       TREE_OVERFLOW (value) = 0;
 939       if (skip_evaluation == 0)
 940         warning ("vector overflow in expression");
 941     }
 942 }
 943
 944 /* Print a warning if a large constant is truncated to unsigned,
 945    or if -Wconversion is used and a constant < 0 is converted to unsigned.
 946    Invoke this function on every expression that might be implicitly
 947    converted to an unsigned type.  */
 948
 949 void
 950 unsigned_conversion_warning (result, operand)
 951      tree result, operand;
 952 {
 953   tree type = TREE_TYPE (result);
 954
 955   if (TREE_CODE (operand) == INTEGER_CST
 956       && TREE_CODE (type) == INTEGER_TYPE
 957       && TREE_UNSIGNED (type)
 958       && skip_evaluation == 0
 959       && !int_fits_type_p (operand, type))
 960     {
 961       if (!int_fits_type_p (operand, c_common_signed_type (type)))
 962         /* This detects cases like converting -129 or 256 to unsigned char.  */
 963         warning ("large integer implicitly truncated to unsigned type");
 964       else if (warn_conversion)
 965         warning ("negative integer implicitly converted to unsigned type");
 966     }
 967 }
 968
 969 /* Nonzero if constant C has a value that is permissible
 970    for type TYPE (an INTEGER_TYPE).  */
 971
 972 static int
 973 constant_fits_type_p (c, type)
 974      tree c, type;
 975 {
 976   if (TREE_CODE (c) == INTEGER_CST)
 977     return int_fits_type_p (c, type);
 978
 979   c = convert (type, c);
 980   return !TREE_OVERFLOW (c);
 981 }
 982
 983 /* Convert EXPR to TYPE, warning about conversion problems with constants.
 984    Invoke this function on every expression that is converted implicitly,
 985    i.e. because of language rules and not because of an explicit cast.  */
 986
 987 tree
 988 convert_and_check (type, expr)
 989      tree type, expr;
 990 {
 991   tree t = convert (type, expr);
 992   if (TREE_CODE (t) == INTEGER_CST)
 993     {
 994       if (TREE_OVERFLOW (t))
 995         {
 996           TREE_OVERFLOW (t) = 0;
 997
 998           /* Do not diagnose overflow in a constant expression merely
 999              because a conversion overflowed.  */
1000           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1001
1002           /* No warning for converting 0x80000000 to int.  */
1003           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1004                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1005                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1006             /* If EXPR fits in the unsigned version of TYPE,
1007                don't warn unless pedantic.  */
1008             if ((pedantic
1009                  || TREE_UNSIGNED (type)
1010                  || ! constant_fits_type_p (expr,
1011                                             c_common_unsigned_type (type)))
1012                 && skip_evaluation == 0)
1013               warning ("overflow in implicit constant conversion");
1014         }
1015       else
1016         unsigned_conversion_warning (t, expr);
1017     }
1018   return t;
1019 }
1020 \f
1021 /* A node in a list that describes references to variables (EXPR), which are
1022    either read accesses if WRITER is zero, or write accesses, in which case
1023    WRITER is the parent of EXPR.  */
1024 struct tlist
1025 {
1026   struct tlist *next;
1027   tree expr, writer;
1028 };
1029
1030 /* Used to implement a cache the results of a call to verify_tree.  We only
1031    use this for SAVE_EXPRs.  */
1032 struct tlist_cache
1033 {
1034   struct tlist_cache *next;
1035   struct tlist *cache_before_sp;
1036   struct tlist *cache_after_sp;
1037   tree expr;
1038 };
1039
1040 /* Obstack to use when allocating tlist structures, and corresponding
1041    firstobj.  */
1042 static struct obstack tlist_obstack;
1043 static char *tlist_firstobj = 0;
1044
1045 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1046    warnings.  */
1047 static struct tlist *warned_ids;
1048 /* SAVE_EXPRs need special treatment.  We process them only once and then
1049    cache the results.  */
1050 static struct tlist_cache *save_expr_cache;
1051
1052 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1053 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1054 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1055 static int warning_candidate_p PARAMS ((tree));
1056 static void warn_for_collisions PARAMS ((struct tlist *));
1057 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1058 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1059 static void verify_sequence_points PARAMS ((tree));
1060
1061 /* Create a new struct tlist and fill in its fields.  */
1062 static struct tlist *
1063 new_tlist (next, t, writer)
1064      struct tlist *next;
1065      tree t;
1066      tree writer;
1067 {
1068   struct tlist *l;
1069   l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1070   l->next = next;
1071   l->expr = t;
1072   l->writer = writer;
1073   return l;
1074 }
1075
1076 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1077    is nonnull, we ignore any node we find which has a writer equal to it.  */
1078
1079 static void
1080 add_tlist (to, add, exclude_writer, copy)
1081      struct tlist **to;
1082      struct tlist *add;
1083      tree exclude_writer;
1084      int copy;
1085 {
1086   while (add)
1087     {
1088       struct tlist *next = add->next;
1089       if (! copy)
1090         add->next = *to;
1091       if (! exclude_writer || add->writer != exclude_writer)
1092         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1093       add = next;
1094     }
1095 }
1096
1097 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1098    each variable that already exists in TO, no new node is added; however if
1099    there is a write access recorded in ADD, and an occurrence on TO is only
1100    a read access, then the occurrence in TO will be modified to record the
1101    write.  */
1102
1103 static void
1104 merge_tlist (to, add, copy)
1105      struct tlist **to;
1106      struct tlist *add;
1107      int copy;
1108 {
1109   struct tlist **end = to;
1110
1111   while (*end)
1112     end = &(*end)->next;
1113
1114   while (add)
1115     {
1116       int found = 0;
1117       struct tlist *tmp2;
1118       struct tlist *next = add->next;
1119
1120       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1121         if (tmp2->expr == add->expr)
1122           {
1123             found = 1;
1124             if (! tmp2->writer)
1125               tmp2->writer = add->writer;
1126           }
1127       if (! found)
1128         {
1129           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1130           end = &(*end)->next;
1131           *end = 0;
1132         }
1133       add = next;
1134     }
1135 }
1136
1137 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1138    references in list LIST conflict with it, excluding reads if ONLY writers
1139    is nonzero.  */
1140
1141 static void
1142 warn_for_collisions_1 (written, writer, list, only_writes)
1143      tree written, writer;
1144      struct tlist *list;
1145      int only_writes;
1146 {
1147   struct tlist *tmp;
1148
1149   /* Avoid duplicate warnings.  */
1150   for (tmp = warned_ids; tmp; tmp = tmp->next)
1151     if (tmp->expr == written)
1152       return;
1153
1154   while (list)
1155     {
1156       if (list->expr == written
1157           && list->writer != writer
1158           && (! only_writes || list->writer))
1159         {
1160           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1161           warning ("operation on `%s' may be undefined",
1162                    IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1163         }
1164       list = list->next;
1165     }
1166 }
1167
1168 /* Given a list LIST of references to variables, find whether any of these
1169    can cause conflicts due to missing sequence points.  */
1170
1171 static void
1172 warn_for_collisions (list)
1173      struct tlist *list;
1174 {
1175   struct tlist *tmp;
1176
1177   for (tmp = list; tmp; tmp = tmp->next)
1178     {
1179       if (tmp->writer)
1180         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1181     }
1182 }
1183
1184 /* Return nonzero if X is a tree that can be verified by the sequence point
1185    warnings.  */
1186 static int
1187 warning_candidate_p (x)
1188      tree x;
1189 {
1190   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1191 }
1192
1193 /* Walk the tree X, and record accesses to variables.  If X is written by the
1194    parent tree, WRITER is the parent.
1195    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1196    expression or its only operand forces a sequence point, then everything up
1197    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1198    in PNO_SP.
1199    Once we return, we will have emitted warnings if any subexpression before
1200    such a sequence point could be undefined.  On a higher level, however, the
1201    sequence point may not be relevant, and we'll merge the two lists.
1202
1203    Example: (b++, a) + b;
1204    The call that processes the COMPOUND_EXPR will store the increment of B
1205    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1206    processes the PLUS_EXPR will need to merge the two lists so that
1207    eventually, all accesses end up on the same list (and we'll warn about the
1208    unordered subexpressions b++ and b.
1209
1210    A note on merging.  If we modify the former example so that our expression
1211    becomes
1212      (b++, b) + a
1213    care must be taken not simply to add all three expressions into the final
1214    PNO_SP list.  The function merge_tlist takes care of that by merging the
1215    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1216    way, so that no more than one access to B is recorded.  */
1217
1218 static void
1219 verify_tree (x, pbefore_sp, pno_sp, writer)
1220      tree x;
1221      struct tlist **pbefore_sp, **pno_sp;
1222      tree writer;
1223 {
1224   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1225   enum tree_code code;
1226   char class;
1227
1228   /* X may be NULL if it is the operand of an empty statement expression
1229      ({ }).  */
1230   if (x == NULL)
1231     return;
1232
1233  restart:
1234   code = TREE_CODE (x);
1235   class = TREE_CODE_CLASS (code);
1236
1237   if (warning_candidate_p (x))
1238     {
1239       *pno_sp = new_tlist (*pno_sp, x, writer);
1240       return;
1241     }
1242
1243   switch (code)
1244     {
1245     case CONSTRUCTOR:
1246       return;
1247
1248     case COMPOUND_EXPR:
1249     case TRUTH_ANDIF_EXPR:
1250     case TRUTH_ORIF_EXPR:
1251       tmp_before = tmp_nosp = tmp_list3 = 0;
1252       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1253       warn_for_collisions (tmp_nosp);
1254       merge_tlist (pbefore_sp, tmp_before, 0);
1255       merge_tlist (pbefore_sp, tmp_nosp, 0);
1256       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1257       merge_tlist (pbefore_sp, tmp_list3, 0);
1258       return;
1259
1260     case COND_EXPR:
1261       tmp_before = tmp_list2 = 0;
1262       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1263       warn_for_collisions (tmp_list2);
1264       merge_tlist (pbefore_sp, tmp_before, 0);
1265       merge_tlist (pbefore_sp, tmp_list2, 1);
1266
1267       tmp_list3 = tmp_nosp = 0;
1268       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1269       warn_for_collisions (tmp_nosp);
1270       merge_tlist (pbefore_sp, tmp_list3, 0);
1271
1272       tmp_list3 = tmp_list2 = 0;
1273       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1274       warn_for_collisions (tmp_list2);
1275       merge_tlist (pbefore_sp, tmp_list3, 0);
1276       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1277          two first, to avoid warning for (a ? b++ : b++).  */
1278       merge_tlist (&tmp_nosp, tmp_list2, 0);
1279       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1280       return;
1281
1282     case PREDECREMENT_EXPR:
1283     case PREINCREMENT_EXPR:
1284     case POSTDECREMENT_EXPR:
1285     case POSTINCREMENT_EXPR:
1286       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1287       return;
1288
1289     case MODIFY_EXPR:
1290       tmp_before = tmp_nosp = tmp_list3 = 0;
1291       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1292       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1293       /* Expressions inside the LHS are not ordered wrt. the sequence points
1294          in the RHS.  Example:
1295            *a = (a++, 2)
1296          Despite the fact that the modification of "a" is in the before_sp
1297          list (tmp_before), it conflicts with the use of "a" in the LHS.
1298          We can handle this by adding the contents of tmp_list3
1299          to those of tmp_before, and redoing the collision warnings for that
1300          list.  */
1301       add_tlist (&tmp_before, tmp_list3, x, 1);
1302       warn_for_collisions (tmp_before);
1303       /* Exclude the LHS itself here; we first have to merge it into the
1304          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1305          didn't exclude the LHS, we'd get it twice, once as a read and once
1306          as a write.  */
1307       add_tlist (pno_sp, tmp_list3, x, 0);
1308       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1309
1310       merge_tlist (pbefore_sp, tmp_before, 0);
1311       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1312         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1313       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1314       return;
1315
1316     case CALL_EXPR:
1317       /* We need to warn about conflicts among arguments and conflicts between
1318          args and the function address.  Side effects of the function address,
1319          however, are not ordered by the sequence point of the call.  */
1320       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1321       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1322       if (TREE_OPERAND (x, 1))
1323         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1324       merge_tlist (&tmp_list3, tmp_list2, 0);
1325       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1326       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1327       warn_for_collisions (tmp_before);
1328       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1329       return;
1330
1331     case TREE_LIST:
1332       /* Scan all the list, e.g. indices of multi dimensional array.  */
1333       while (x)
1334         {
1335           tmp_before = tmp_nosp = 0;
1336           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1337           merge_tlist (&tmp_nosp, tmp_before, 0);
1338           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1339           x = TREE_CHAIN (x);
1340         }
1341       return;
1342
1343     case SAVE_EXPR:
1344       {
1345         struct tlist_cache *t;
1346         for (t = save_expr_cache; t; t = t->next)
1347           if (t->expr == x)
1348             break;
1349
1350         if (! t)
1351           {
1352             t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1353                                                       sizeof *t);
1354             t->next = save_expr_cache;
1355             t->expr = x;
1356             save_expr_cache = t;
1357
1358             tmp_before = tmp_nosp = 0;
1359             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1360             warn_for_collisions (tmp_nosp);
1361
1362             tmp_list3 = 0;
1363             while (tmp_nosp)
1364               {
1365                 struct tlist *t = tmp_nosp;
1366                 tmp_nosp = t->next;
1367                 merge_tlist (&tmp_list3, t, 0);
1368               }
1369             t->cache_before_sp = tmp_before;
1370             t->cache_after_sp = tmp_list3;
1371           }
1372         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1373         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1374         return;
1375       }
1376     default:
1377       break;
1378     }
1379
1380   if (class == '1')
1381     {
1382       if (first_rtl_op (code) == 0)
1383         return;
1384       x = TREE_OPERAND (x, 0);
1385       writer = 0;
1386       goto restart;
1387     }
1388
1389   switch (class)
1390     {
1391     case 'r':
1392     case '<':
1393     case '2':
1394     case 'b':
1395     case 'e':
1396     case 's':
1397     case 'x':
1398       {
1399         int lp;
1400         int max = first_rtl_op (TREE_CODE (x));
1401         for (lp = 0; lp < max; lp++)
1402           {
1403             tmp_before = tmp_nosp = 0;
1404             verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1405             merge_tlist (&tmp_nosp, tmp_before, 0);
1406             add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1407           }
1408         break;
1409       }
1410     }
1411 }
1412
1413 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1414    points.  */
1415
1416 static void
1417 verify_sequence_points (expr)
1418      tree expr;
1419 {
1420   struct tlist *before_sp = 0, *after_sp = 0;
1421
1422   warned_ids = 0;
1423   save_expr_cache = 0;
1424   if (tlist_firstobj == 0)
1425     {
1426       gcc_obstack_init (&tlist_obstack);
1427       tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1428     }
1429
1430   verify_tree (expr, &before_sp, &after_sp, 0);
1431   warn_for_collisions (after_sp);
1432   obstack_free (&tlist_obstack, tlist_firstobj);
1433 }
1434
1435 tree
1436 c_expand_expr_stmt (expr)
1437      tree expr;
1438 {
1439   /* Do default conversion if safe and possibly important,
1440      in case within ({...}).  */
1441   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1442        && (flag_isoc99 || lvalue_p (expr)))
1443       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1444     expr = default_conversion (expr);
1445
1446   if (warn_sequence_point)
1447     verify_sequence_points (expr);
1448
1449   if (TREE_TYPE (expr) != error_mark_node
1450       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1451       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1452     error ("expression statement has incomplete type");
1453
1454   last_expr_type = TREE_TYPE (expr);
1455   return add_stmt (build_stmt (EXPR_STMT, expr));
1456 }
1457 \f
1458 /* Validate the expression after `case' and apply default promotions.  */
1459
1460 tree
1461 check_case_value (value)
1462      tree value;
1463 {
1464   if (value == NULL_TREE)
1465     return value;
1466
1467   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1468   STRIP_TYPE_NOPS (value);
1469   /* In C++, the following is allowed:
1470
1471        const int i = 3;
1472        switch (...) { case i: ... }
1473
1474      So, we try to reduce the VALUE to a constant that way.  */
1475   if (c_language == clk_cplusplus)
1476     {
1477       value = decl_constant_value (value);
1478       STRIP_TYPE_NOPS (value);
1479       value = fold (value);
1480     }
1481
1482   if (TREE_CODE (value) != INTEGER_CST
1483       && value != error_mark_node)
1484     {
1485       error ("case label does not reduce to an integer constant");
1486       value = error_mark_node;
1487     }
1488   else
1489     /* Promote char or short to int.  */
1490     value = default_conversion (value);
1491
1492   constant_expression_warning (value);
1493
1494   return value;
1495 }
1496 \f
1497 /* Return an integer type with BITS bits of precision,
1498    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1499
1500 tree
1501 c_common_type_for_size (bits, unsignedp)
1502      unsigned bits;
1503      int unsignedp;
1504 {
1505   if (bits == TYPE_PRECISION (integer_type_node))
1506     return unsignedp ? unsigned_type_node : integer_type_node;
1507
1508   if (bits == TYPE_PRECISION (signed_char_type_node))
1509     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1510
1511   if (bits == TYPE_PRECISION (short_integer_type_node))
1512     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1513
1514   if (bits == TYPE_PRECISION (long_integer_type_node))
1515     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1516
1517   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1518     return (unsignedp ? long_long_unsigned_type_node
1519             : long_long_integer_type_node);
1520
1521   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1522     return (unsignedp ? widest_unsigned_literal_type_node
1523             : widest_integer_literal_type_node);
1524
1525   if (bits <= TYPE_PRECISION (intQI_type_node))
1526     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1527
1528   if (bits <= TYPE_PRECISION (intHI_type_node))
1529     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1530
1531   if (bits <= TYPE_PRECISION (intSI_type_node))
1532     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1533
1534   if (bits <= TYPE_PRECISION (intDI_type_node))
1535     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1536
1537   return 0;
1538 }
1539
1540 /* Return a data type that has machine mode MODE.
1541    If the mode is an integer,
1542    then UNSIGNEDP selects between signed and unsigned types.  */
1543
1544 tree
1545 c_common_type_for_mode (mode, unsignedp)
1546      enum machine_mode mode;
1547      int unsignedp;
1548 {
1549   if (mode == TYPE_MODE (integer_type_node))
1550     return unsignedp ? unsigned_type_node : integer_type_node;
1551
1552   if (mode == TYPE_MODE (signed_char_type_node))
1553     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1554
1555   if (mode == TYPE_MODE (short_integer_type_node))
1556     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1557
1558   if (mode == TYPE_MODE (long_integer_type_node))
1559     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1560
1561   if (mode == TYPE_MODE (long_long_integer_type_node))
1562     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1563
1564   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1565     return unsignedp ? widest_unsigned_literal_type_node
1566                      : widest_integer_literal_type_node;
1567
1568   if (mode == QImode)
1569     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1570
1571   if (mode == HImode)
1572     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1573
1574   if (mode == SImode)
1575     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1576
1577   if (mode == DImode)
1578     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1579
1580 #if HOST_BITS_PER_WIDE_INT >= 64
1581   if (mode == TYPE_MODE (intTI_type_node))
1582     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1583 #endif
1584
1585   if (mode == TYPE_MODE (float_type_node))
1586     return float_type_node;
1587
1588   if (mode == TYPE_MODE (double_type_node))
1589     return double_type_node;
1590
1591   if (mode == TYPE_MODE (long_double_type_node))
1592     return long_double_type_node;
1593
1594   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1595     return build_pointer_type (char_type_node);
1596
1597   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1598     return build_pointer_type (integer_type_node);
1599
1600 #ifdef VECTOR_MODE_SUPPORTED_P
1601   if (VECTOR_MODE_SUPPORTED_P (mode))
1602     {
1603       switch (mode)
1604         {
1605         case V16QImode:
1606           return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1607         case V8HImode:
1608           return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1609         case V4SImode:
1610           return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1611         case V2DImode:
1612           return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
1613         case V2SImode:
1614           return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1615         case V4HImode:
1616           return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1617         case V8QImode:
1618           return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1619         case V16SFmode:
1620           return V16SF_type_node;
1621         case V4SFmode:
1622           return V4SF_type_node;
1623         case V2SFmode:
1624           return V2SF_type_node;
1625         case V2DFmode:
1626           return V2DF_type_node;
1627         default:
1628           break;
1629         }
1630     }
1631 #endif
1632
1633   return 0;
1634 }
1635
1636 /* Return an unsigned type the same as TYPE in other respects.  */
1637 tree
1638 c_common_unsigned_type (type)
1639      tree type;
1640 {
1641   tree type1 = TYPE_MAIN_VARIANT (type);
1642   if (type1 == signed_char_type_node || type1 == char_type_node)
1643     return unsigned_char_type_node;
1644   if (type1 == integer_type_node)
1645     return unsigned_type_node;
1646   if (type1 == short_integer_type_node)
1647     return short_unsigned_type_node;
1648   if (type1 == long_integer_type_node)
1649     return long_unsigned_type_node;
1650   if (type1 == long_long_integer_type_node)
1651     return long_long_unsigned_type_node;
1652   if (type1 == widest_integer_literal_type_node)
1653     return widest_unsigned_literal_type_node;
1654 #if HOST_BITS_PER_WIDE_INT >= 64
1655   if (type1 == intTI_type_node)
1656     return unsigned_intTI_type_node;
1657 #endif
1658   if (type1 == intDI_type_node)
1659     return unsigned_intDI_type_node;
1660   if (type1 == intSI_type_node)
1661     return unsigned_intSI_type_node;
1662   if (type1 == intHI_type_node)
1663     return unsigned_intHI_type_node;
1664   if (type1 == intQI_type_node)
1665     return unsigned_intQI_type_node;
1666
1667   return c_common_signed_or_unsigned_type (1, type);
1668 }
1669
1670 /* Return a signed type the same as TYPE in other respects.  */
1671
1672 tree
1673 c_common_signed_type (type)
1674      tree type;
1675 {
1676   tree type1 = TYPE_MAIN_VARIANT (type);
1677   if (type1 == unsigned_char_type_node || type1 == char_type_node)
1678     return signed_char_type_node;
1679   if (type1 == unsigned_type_node)
1680     return integer_type_node;
1681   if (type1 == short_unsigned_type_node)
1682     return short_integer_type_node;
1683   if (type1 == long_unsigned_type_node)
1684     return long_integer_type_node;
1685   if (type1 == long_long_unsigned_type_node)
1686     return long_long_integer_type_node;
1687   if (type1 == widest_unsigned_literal_type_node)
1688     return widest_integer_literal_type_node;
1689 #if HOST_BITS_PER_WIDE_INT >= 64
1690   if (type1 == unsigned_intTI_type_node)
1691     return intTI_type_node;
1692 #endif
1693   if (type1 == unsigned_intDI_type_node)
1694     return intDI_type_node;
1695   if (type1 == unsigned_intSI_type_node)
1696     return intSI_type_node;
1697   if (type1 == unsigned_intHI_type_node)
1698     return intHI_type_node;
1699   if (type1 == unsigned_intQI_type_node)
1700     return intQI_type_node;
1701
1702   return c_common_signed_or_unsigned_type (0, type);
1703 }
1704
1705 /* Return a type the same as TYPE except unsigned or
1706    signed according to UNSIGNEDP.  */
1707
1708 tree
1709 c_common_signed_or_unsigned_type (unsignedp, type)
1710      int unsignedp;
1711      tree type;
1712 {
1713   if (! INTEGRAL_TYPE_P (type)
1714       || TREE_UNSIGNED (type) == unsignedp)
1715     return type;
1716
1717   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1718     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1719   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1720     return unsignedp ? unsigned_type_node : integer_type_node;
1721   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1722     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1723   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1724     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1725   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1726     return (unsignedp ? long_long_unsigned_type_node
1727             : long_long_integer_type_node);
1728   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1729     return (unsignedp ? widest_unsigned_literal_type_node
1730             : widest_integer_literal_type_node);
1731
1732 #if HOST_BITS_PER_WIDE_INT >= 64
1733   if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1734     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1735 #endif
1736   if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1737     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1738   if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1739     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1740   if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1741     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1742   if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1743     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1744
1745   return type;
1746 }
1747 \f
1748 /* Return the minimum number of bits needed to represent VALUE in a
1749    signed or unsigned type, UNSIGNEDP says which.  */
1750
1751 unsigned int
1752 min_precision (value, unsignedp)
1753      tree value;
1754      int unsignedp;
1755 {
1756   int log;
1757
1758   /* If the value is negative, compute its negative minus 1.  The latter
1759      adjustment is because the absolute value of the largest negative value
1760      is one larger than the largest positive value.  This is equivalent to
1761      a bit-wise negation, so use that operation instead.  */
1762
1763   if (tree_int_cst_sgn (value) < 0)
1764     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1765
1766   /* Return the number of bits needed, taking into account the fact
1767      that we need one more bit for a signed than unsigned type.  */
1768
1769   if (integer_zerop (value))
1770     log = 0;
1771   else
1772     log = tree_floor_log2 (value);
1773
1774   return log + 1 + ! unsignedp;
1775 }
1776 \f
1777 /* Print an error message for invalid operands to arith operation
1778    CODE.  NOP_EXPR is used as a special case (see
1779    c_common_truthvalue_conversion).  */
1780
1781 void
1782 binary_op_error (code)
1783      enum tree_code code;
1784 {
1785   const char *opname;
1786
1787   switch (code)
1788     {
1789     case NOP_EXPR:
1790       error ("invalid truth-value expression");
1791       return;
1792
1793     case PLUS_EXPR:
1794       opname = "+"; break;
1795     case MINUS_EXPR:
1796       opname = "-"; break;
1797     case MULT_EXPR:
1798       opname = "*"; break;
1799     case MAX_EXPR:
1800       opname = "max"; break;
1801     case MIN_EXPR:
1802       opname = "min"; break;
1803     case EQ_EXPR:
1804       opname = "=="; break;
1805     case NE_EXPR:
1806       opname = "!="; break;
1807     case LE_EXPR:
1808       opname = "<="; break;
1809     case GE_EXPR:
1810       opname = ">="; break;
1811     case LT_EXPR:
1812       opname = "<"; break;
1813     case GT_EXPR:
1814       opname = ">"; break;
1815     case LSHIFT_EXPR:
1816       opname = "<<"; break;
1817     case RSHIFT_EXPR:
1818       opname = ">>"; break;
1819     case TRUNC_MOD_EXPR:
1820     case FLOOR_MOD_EXPR:
1821       opname = "%"; break;
1822     case TRUNC_DIV_EXPR:
1823     case FLOOR_DIV_EXPR:
1824       opname = "/"; break;
1825     case BIT_AND_EXPR:
1826       opname = "&"; break;
1827     case BIT_IOR_EXPR:
1828       opname = "|"; break;
1829     case TRUTH_ANDIF_EXPR:
1830       opname = "&&"; break;
1831     case TRUTH_ORIF_EXPR:
1832       opname = "||"; break;
1833     case BIT_XOR_EXPR:
1834       opname = "^"; break;
1835     case LROTATE_EXPR:
1836     case RROTATE_EXPR:
1837       opname = "rotate"; break;
1838     default:
1839       opname = "unknown"; break;
1840     }
1841   error ("invalid operands to binary %s", opname);
1842 }
1843 \f
1844 /* Subroutine of build_binary_op, used for comparison operations.
1845    See if the operands have both been converted from subword integer types
1846    and, if so, perhaps change them both back to their original type.
1847    This function is also responsible for converting the two operands
1848    to the proper common type for comparison.
1849
1850    The arguments of this function are all pointers to local variables
1851    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1852    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1853
1854    If this function returns nonzero, it means that the comparison has
1855    a constant value.  What this function returns is an expression for
1856    that value.  */
1857
1858 tree
1859 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1860      tree *op0_ptr, *op1_ptr;
1861      tree *restype_ptr;
1862      enum tree_code *rescode_ptr;
1863 {
1864   tree type;
1865   tree op0 = *op0_ptr;
1866   tree op1 = *op1_ptr;
1867   int unsignedp0, unsignedp1;
1868   int real1, real2;
1869   tree primop0, primop1;
1870   enum tree_code code = *rescode_ptr;
1871
1872   /* Throw away any conversions to wider types
1873      already present in the operands.  */
1874
1875   primop0 = get_narrower (op0, &unsignedp0);
1876   primop1 = get_narrower (op1, &unsignedp1);
1877
1878   /* Handle the case that OP0 does not *contain* a conversion
1879      but it *requires* conversion to FINAL_TYPE.  */
1880
1881   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1882     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1883   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1884     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1885
1886   /* If one of the operands must be floated, we cannot optimize.  */
1887   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1888   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1889
1890   /* If first arg is constant, swap the args (changing operation
1891      so value is preserved), for canonicalization.  Don't do this if
1892      the second arg is 0.  */
1893
1894   if (TREE_CONSTANT (primop0)
1895       && ! integer_zerop (primop1) && ! real_zerop (primop1))
1896     {
1897       tree tem = primop0;
1898       int temi = unsignedp0;
1899       primop0 = primop1;
1900       primop1 = tem;
1901       tem = op0;
1902       op0 = op1;
1903       op1 = tem;
1904       *op0_ptr = op0;
1905       *op1_ptr = op1;
1906       unsignedp0 = unsignedp1;
1907       unsignedp1 = temi;
1908       temi = real1;
1909       real1 = real2;
1910       real2 = temi;
1911
1912       switch (code)
1913         {
1914         case LT_EXPR:
1915           code = GT_EXPR;
1916           break;
1917         case GT_EXPR:
1918           code = LT_EXPR;
1919           break;
1920         case LE_EXPR:
1921           code = GE_EXPR;
1922           break;
1923         case GE_EXPR:
1924           code = LE_EXPR;
1925           break;
1926         default:
1927           break;
1928         }
1929       *rescode_ptr = code;
1930     }
1931
1932   /* If comparing an integer against a constant more bits wide,
1933      maybe we can deduce a value of 1 or 0 independent of the data.
1934      Or else truncate the constant now
1935      rather than extend the variable at run time.
1936
1937      This is only interesting if the constant is the wider arg.
1938      Also, it is not safe if the constant is unsigned and the
1939      variable arg is signed, since in this case the variable
1940      would be sign-extended and then regarded as unsigned.
1941      Our technique fails in this case because the lowest/highest
1942      possible unsigned results don't follow naturally from the
1943      lowest/highest possible values of the variable operand.
1944      For just EQ_EXPR and NE_EXPR there is another technique that
1945      could be used: see if the constant can be faithfully represented
1946      in the other operand's type, by truncating it and reextending it
1947      and see if that preserves the constant's value.  */
1948
1949   if (!real1 && !real2
1950       && TREE_CODE (primop1) == INTEGER_CST
1951       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1952     {
1953       int min_gt, max_gt, min_lt, max_lt;
1954       tree maxval, minval;
1955       /* 1 if comparison is nominally unsigned.  */
1956       int unsignedp = TREE_UNSIGNED (*restype_ptr);
1957       tree val;
1958
1959       type = c_common_signed_or_unsigned_type (unsignedp0,
1960                                                TREE_TYPE (primop0));
1961
1962       /* If TYPE is an enumeration, then we need to get its min/max
1963          values from it's underlying integral type, not the enumerated
1964          type itself.  */
1965       if (TREE_CODE (type) == ENUMERAL_TYPE)
1966         type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1967
1968       maxval = TYPE_MAX_VALUE (type);
1969       minval = TYPE_MIN_VALUE (type);
1970
1971       if (unsignedp && !unsignedp0)
1972         *restype_ptr = c_common_signed_type (*restype_ptr);
1973
1974       if (TREE_TYPE (primop1) != *restype_ptr)
1975         primop1 = convert (*restype_ptr, primop1);
1976       if (type != *restype_ptr)
1977         {
1978           minval = convert (*restype_ptr, minval);
1979           maxval = convert (*restype_ptr, maxval);
1980         }
1981
1982       if (unsignedp && unsignedp0)
1983         {
1984           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1985           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1986           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1987           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1988         }
1989       else
1990         {
1991           min_gt = INT_CST_LT (primop1, minval);
1992           max_gt = INT_CST_LT (primop1, maxval);
1993           min_lt = INT_CST_LT (minval, primop1);
1994           max_lt = INT_CST_LT (maxval, primop1);
1995         }
1996
1997       val = 0;
1998       /* This used to be a switch, but Genix compiler can't handle that.  */
1999       if (code == NE_EXPR)
2000         {
2001           if (max_lt || min_gt)
2002             val = boolean_true_node;
2003         }
2004       else if (code == EQ_EXPR)
2005         {
2006           if (max_lt || min_gt)
2007             val = boolean_false_node;
2008         }
2009       else if (code == LT_EXPR)
2010         {
2011           if (max_lt)
2012             val = boolean_true_node;
2013           if (!min_lt)
2014             val = boolean_false_node;
2015         }
2016       else if (code == GT_EXPR)
2017         {
2018           if (min_gt)
2019             val = boolean_true_node;
2020           if (!max_gt)
2021             val = boolean_false_node;
2022         }
2023       else if (code == LE_EXPR)
2024         {
2025           if (!max_gt)
2026             val = boolean_true_node;
2027           if (min_gt)
2028             val = boolean_false_node;
2029         }
2030       else if (code == GE_EXPR)
2031         {
2032           if (!min_lt)
2033             val = boolean_true_node;
2034           if (max_lt)
2035             val = boolean_false_node;
2036         }
2037
2038       /* If primop0 was sign-extended and unsigned comparison specd,
2039          we did a signed comparison above using the signed type bounds.
2040          But the comparison we output must be unsigned.
2041
2042          Also, for inequalities, VAL is no good; but if the signed
2043          comparison had *any* fixed result, it follows that the
2044          unsigned comparison just tests the sign in reverse
2045          (positive values are LE, negative ones GE).
2046          So we can generate an unsigned comparison
2047          against an extreme value of the signed type.  */
2048
2049       if (unsignedp && !unsignedp0)
2050         {
2051           if (val != 0)
2052             switch (code)
2053               {
2054               case LT_EXPR:
2055               case GE_EXPR:
2056                 primop1 = TYPE_MIN_VALUE (type);
2057                 val = 0;
2058                 break;
2059
2060               case LE_EXPR:
2061               case GT_EXPR:
2062                 primop1 = TYPE_MAX_VALUE (type);
2063                 val = 0;
2064                 break;
2065
2066               default:
2067                 break;
2068               }
2069           type = c_common_unsigned_type (type);
2070         }
2071
2072       if (TREE_CODE (primop0) != INTEGER_CST)
2073         {
2074           if (val == boolean_false_node)
2075             warning ("comparison is always false due to limited range of data type");
2076           if (val == boolean_true_node)
2077             warning ("comparison is always true due to limited range of data type");
2078         }
2079
2080       if (val != 0)
2081         {
2082           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2083           if (TREE_SIDE_EFFECTS (primop0))
2084             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2085           return val;
2086         }
2087
2088       /* Value is not predetermined, but do the comparison
2089          in the type of the operand that is not constant.
2090          TYPE is already properly set.  */
2091     }
2092   else if (real1 && real2
2093            && (TYPE_PRECISION (TREE_TYPE (primop0))
2094                == TYPE_PRECISION (TREE_TYPE (primop1))))
2095     type = TREE_TYPE (primop0);
2096
2097   /* If args' natural types are both narrower than nominal type
2098      and both extend in the same manner, compare them
2099      in the type of the wider arg.
2100      Otherwise must actually extend both to the nominal
2101      common type lest different ways of extending
2102      alter the result.
2103      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2104
2105   else if (unsignedp0 == unsignedp1 && real1 == real2
2106            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2107            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2108     {
2109       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2110       type = c_common_signed_or_unsigned_type (unsignedp0
2111                                                || TREE_UNSIGNED (*restype_ptr),
2112                                                type);
2113       /* Make sure shorter operand is extended the right way
2114          to match the longer operand.  */
2115       primop0
2116         = convert (c_common_signed_or_unsigned_type (unsignedp0,
2117                                                      TREE_TYPE (primop0)),
2118                    primop0);
2119       primop1
2120         = convert (c_common_signed_or_unsigned_type (unsignedp1,
2121                                                      TREE_TYPE (primop1)),
2122                    primop1);
2123     }
2124   else
2125     {
2126       /* Here we must do the comparison on the nominal type
2127          using the args exactly as we received them.  */
2128       type = *restype_ptr;
2129       primop0 = op0;
2130       primop1 = op1;
2131
2132       if (!real1 && !real2 && integer_zerop (primop1)
2133           && TREE_UNSIGNED (*restype_ptr))
2134         {
2135           tree value = 0;
2136           switch (code)
2137             {
2138             case GE_EXPR:
2139               /* All unsigned values are >= 0, so we warn if extra warnings
2140                  are requested.  However, if OP0 is a constant that is
2141                  >= 0, the signedness of the comparison isn't an issue,
2142                  so suppress the warning.  */
2143               if (extra_warnings && !in_system_header
2144                   && ! (TREE_CODE (primop0) == INTEGER_CST
2145                         && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2146                                                      primop0))))
2147                 warning ("comparison of unsigned expression >= 0 is always true");
2148               value = boolean_true_node;
2149               break;
2150
2151             case LT_EXPR:
2152               if (extra_warnings && !in_system_header
2153                   && ! (TREE_CODE (primop0) == INTEGER_CST
2154                         && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2155                                                      primop0))))
2156                 warning ("comparison of unsigned expression < 0 is always false");
2157               value = boolean_false_node;
2158               break;
2159
2160             default:
2161               break;
2162             }
2163
2164           if (value != 0)
2165             {
2166               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2167               if (TREE_SIDE_EFFECTS (primop0))
2168                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2169                               primop0, value);
2170               return value;
2171             }
2172         }
2173     }
2174
2175   *op0_ptr = convert (type, primop0);
2176   *op1_ptr = convert (type, primop1);
2177
2178   *restype_ptr = boolean_type_node;
2179
2180   return 0;
2181 }
2182 \f
2183 /* Return a tree for the sum or difference (RESULTCODE says which)
2184    of pointer PTROP and integer INTOP.  */
2185
2186 tree
2187 pointer_int_sum (resultcode, ptrop, intop)
2188      enum tree_code resultcode;
2189      tree ptrop, intop;
2190 {
2191   tree size_exp;
2192
2193   tree result;
2194   tree folded;
2195
2196   /* The result is a pointer of the same type that is being added.  */
2197
2198   tree result_type = TREE_TYPE (ptrop);
2199
2200   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2201     {
2202       if (pedantic || warn_pointer_arith)
2203         pedwarn ("pointer of type `void *' used in arithmetic");
2204       size_exp = integer_one_node;
2205     }
2206   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2207     {
2208       if (pedantic || warn_pointer_arith)
2209         pedwarn ("pointer to a function used in arithmetic");
2210       size_exp = integer_one_node;
2211     }
2212   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2213     {
2214       if (pedantic || warn_pointer_arith)
2215         pedwarn ("pointer to member function used in arithmetic");
2216       size_exp = integer_one_node;
2217     }
2218   else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2219     {
2220       if (pedantic || warn_pointer_arith)
2221         pedwarn ("pointer to a member used in arithmetic");
2222       size_exp = integer_one_node;
2223     }
2224   else
2225     size_exp = size_in_bytes (TREE_TYPE (result_type));
2226
2227   /* If what we are about to multiply by the size of the elements
2228      contains a constant term, apply distributive law
2229      and multiply that constant term separately.
2230      This helps produce common subexpressions.  */
2231
2232   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2233       && ! TREE_CONSTANT (intop)
2234       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2235       && TREE_CONSTANT (size_exp)
2236       /* If the constant comes from pointer subtraction,
2237          skip this optimization--it would cause an error.  */
2238       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2239       /* If the constant is unsigned, and smaller than the pointer size,
2240          then we must skip this optimization.  This is because it could cause
2241          an overflow error if the constant is negative but INTOP is not.  */
2242       && (! TREE_UNSIGNED (TREE_TYPE (intop))
2243           || (TYPE_PRECISION (TREE_TYPE (intop))
2244               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2245     {
2246       enum tree_code subcode = resultcode;
2247       tree int_type = TREE_TYPE (intop);
2248       if (TREE_CODE (intop) == MINUS_EXPR)
2249         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2250       /* Convert both subexpression types to the type of intop,
2251          because weird cases involving pointer arithmetic
2252          can result in a sum or difference with different type args.  */
2253       ptrop = build_binary_op (subcode, ptrop,
2254                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
2255       intop = convert (int_type, TREE_OPERAND (intop, 0));
2256     }
2257
2258   /* Convert the integer argument to a type the same size as sizetype
2259      so the multiply won't overflow spuriously.  */
2260
2261   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2262       || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2263     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2264                                              TREE_UNSIGNED (sizetype)), intop);
2265
2266   /* Replace the integer argument with a suitable product by the object size.
2267      Do this multiplication as signed, then convert to the appropriate
2268      pointer type (actually unsigned integral).  */
2269
2270   intop = convert (result_type,
2271                    build_binary_op (MULT_EXPR, intop,
2272                                     convert (TREE_TYPE (intop), size_exp), 1));
2273
2274   /* Create the sum or difference.  */
2275
2276   result = build (resultcode, result_type, ptrop, intop);
2277
2278   folded = fold (result);
2279   if (folded == result)
2280     TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2281   return folded;
2282 }
2283 \f
2284 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2285    or validate its data type for an `if' or `while' statement or ?..: exp.
2286
2287    This preparation consists of taking the ordinary
2288    representation of an expression expr and producing a valid tree
2289    boolean expression describing whether expr is nonzero.  We could
2290    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2291    but we optimize comparisons, &&, ||, and !.
2292
2293    The resulting type should always be `boolean_type_node'.  */
2294
2295 tree
2296 c_common_truthvalue_conversion (expr)
2297      tree expr;
2298 {
2299   if (TREE_CODE (expr) == ERROR_MARK)
2300     return expr;
2301
2302 #if 0 /* This appears to be wrong for C++.  */
2303   /* These really should return error_mark_node after 2.4 is stable.
2304      But not all callers handle ERROR_MARK properly.  */
2305   switch (TREE_CODE (TREE_TYPE (expr)))
2306     {
2307     case RECORD_TYPE:
2308       error ("struct type value used where scalar is required");
2309       return boolean_false_node;
2310
2311     case UNION_TYPE:
2312       error ("union type value used where scalar is required");
2313       return boolean_false_node;
2314
2315     case ARRAY_TYPE:
2316       error ("array type value used where scalar is required");
2317       return boolean_false_node;
2318
2319     default:
2320       break;
2321     }
2322 #endif /* 0 */
2323
2324   switch (TREE_CODE (expr))
2325     {
2326     case EQ_EXPR:
2327     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2328     case TRUTH_ANDIF_EXPR:
2329     case TRUTH_ORIF_EXPR:
2330     case TRUTH_AND_EXPR:
2331     case TRUTH_OR_EXPR:
2332     case TRUTH_XOR_EXPR:
2333     case TRUTH_NOT_EXPR:
2334       TREE_TYPE (expr) = boolean_type_node;
2335       return expr;
2336
2337     case ERROR_MARK:
2338       return expr;
2339
2340     case INTEGER_CST:
2341       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2342
2343     case REAL_CST:
2344       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2345
2346     case ADDR_EXPR:
2347       /* If we are taking the address of an external decl, it might be zero
2348          if it is weak, so we cannot optimize.  */
2349       if (DECL_P (TREE_OPERAND (expr, 0))
2350           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2351         break;
2352
2353       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2354         return build (COMPOUND_EXPR, boolean_type_node,
2355                       TREE_OPERAND (expr, 0), boolean_true_node);
2356       else
2357         return boolean_true_node;
2358
2359     case COMPLEX_EXPR:
2360       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2361                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2362                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2363                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2364                               0);
2365
2366     case NEGATE_EXPR:
2367     case ABS_EXPR:
2368     case FLOAT_EXPR:
2369     case FFS_EXPR:
2370       /* These don't change whether an object is non-zero or zero.  */
2371       return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2372
2373     case LROTATE_EXPR:
2374     case RROTATE_EXPR:
2375       /* These don't change whether an object is zero or non-zero, but
2376          we can't ignore them if their second arg has side-effects.  */
2377       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2378         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2379                       c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2380       else
2381         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2382
2383     case COND_EXPR:
2384       /* Distribute the conversion into the arms of a COND_EXPR.  */
2385       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2386                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2387                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2388
2389     case CONVERT_EXPR:
2390       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2391          since that affects how `default_conversion' will behave.  */
2392       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2393           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2394         break;
2395       /* fall through...  */
2396     case NOP_EXPR:
2397       /* If this is widening the argument, we can ignore it.  */
2398       if (TYPE_PRECISION (TREE_TYPE (expr))
2399           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2400         return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2401       break;
2402
2403     case MINUS_EXPR:
2404       /* Perhaps reduce (x - y) != 0 to (x != y).  The expressions
2405          aren't guaranteed to the be same for modes that can represent
2406          infinity, since if x and y are both +infinity, or both
2407          -infinity, then x - y is not a number.
2408
2409          Note that this transformation is safe when x or y is NaN.
2410          (x - y) is then NaN, and both (x - y) != 0 and x != y will
2411          be false.  */
2412       if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2413         break;
2414       /* fall through...  */
2415     case BIT_XOR_EXPR:
2416       /* This and MINUS_EXPR can be changed into a comparison of the
2417          two objects.  */
2418       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2419           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2420         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2421                                 TREE_OPERAND (expr, 1), 1);
2422       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2423                               fold (build1 (NOP_EXPR,
2424                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2425                                             TREE_OPERAND (expr, 1))), 1);
2426
2427     case BIT_AND_EXPR:
2428       if (integer_onep (TREE_OPERAND (expr, 1))
2429           && TREE_TYPE (expr) != boolean_type_node)
2430         /* Using convert here would cause infinite recursion.  */
2431         return build1 (NOP_EXPR, boolean_type_node, expr);
2432       break;
2433
2434     case MODIFY_EXPR:
2435       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2436         warning ("suggest parentheses around assignment used as truth value");
2437       break;
2438
2439     default:
2440       break;
2441     }
2442
2443   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2444     {
2445       tree t = save_expr (expr);
2446       return (build_binary_op
2447               ((TREE_SIDE_EFFECTS (expr)
2448                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2449         c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2450         c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2451                0));
2452     }
2453
2454   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2455 }
2456 \f
2457 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2458                                         int, enum built_in_class, int, int,
2459                                         int));
2460
2461 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2462    down to the element type of an array.  */
2463
2464 tree
2465 c_build_qualified_type (type, type_quals)
2466      tree type;
2467      int type_quals;
2468 {
2469   /* A restrict-qualified pointer type must be a pointer to object or
2470      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2471      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
2472      the C++ front-end also use POINTER_TYPE for pointer-to-member
2473      values, so even though it should be illegal to use `restrict'
2474      with such an entity we don't flag that here.  Thus, special case
2475      code for that case is required in the C++ front-end.  */
2476   if ((type_quals & TYPE_QUAL_RESTRICT)
2477       && (!POINTER_TYPE_P (type)
2478           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2479     {
2480       error ("invalid use of `restrict'");
2481       type_quals &= ~TYPE_QUAL_RESTRICT;
2482     }
2483
2484   if (TREE_CODE (type) == ARRAY_TYPE)
2485     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2486                                                      type_quals),
2487                              TYPE_DOMAIN (type));
2488   return build_qualified_type (type, type_quals);
2489 }
2490
2491 /* Apply the TYPE_QUALS to the new DECL.  */
2492
2493 void
2494 c_apply_type_quals_to_decl (type_quals, decl)
2495      int type_quals;
2496      tree decl;
2497 {
2498   if ((type_quals & TYPE_QUAL_CONST)
2499       || (TREE_TYPE (decl)
2500           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2501     TREE_READONLY (decl) = 1;
2502   if (type_quals & TYPE_QUAL_VOLATILE)
2503     {
2504       TREE_SIDE_EFFECTS (decl) = 1;
2505       TREE_THIS_VOLATILE (decl) = 1;
2506     }
2507   if (type_quals & TYPE_QUAL_RESTRICT)
2508     {
2509       if (!TREE_TYPE (decl)
2510           || !POINTER_TYPE_P (TREE_TYPE (decl))
2511           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2512         error ("invalid use of `restrict'");
2513       else if (flag_strict_aliasing)
2514         /* Indicate we need to make a unique alias set for this pointer.
2515            We can't do it here because it might be pointing to an
2516            incomplete type.  */
2517         DECL_POINTER_ALIAS_SET (decl) = -2;
2518     }
2519 }
2520
2521 /* Return the typed-based alias set for T, which may be an expression
2522    or a type.  Return -1 if we don't do anything special.  */
2523
2524 HOST_WIDE_INT
2525 c_common_get_alias_set (t)
2526      tree t;
2527 {
2528   tree u;
2529
2530   /* We know nothing about vector types */
2531   if (TREE_CODE (t) == VECTOR_TYPE)
2532     return 0;
2533
2534   /* Permit type-punning when accessing a union, provided the access
2535      is directly through the union.  For example, this code does not
2536      permit taking the address of a union member and then storing
2537      through it.  Even the type-punning allowed here is a GCC
2538      extension, albeit a common and useful one; the C standard says
2539      that such accesses have implementation-defined behavior.  */
2540   for (u = t;
2541        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2542        u = TREE_OPERAND (u, 0))
2543     if (TREE_CODE (u) == COMPONENT_REF
2544         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2545       return 0;
2546
2547   /* If this is a char *, the ANSI C standard says it can alias
2548      anything.  Note that all references need do this.  */
2549   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2550       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2551       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2552     return 0;
2553
2554   /* That's all the expressions we handle specially.  */
2555   if (! TYPE_P (t))
2556     return -1;
2557
2558   /* The C standard specifically allows aliasing between signed and
2559      unsigned variants of the same type.  We treat the signed
2560      variant as canonical.  */
2561   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2562     {
2563       tree t1 = c_common_signed_type (t);
2564
2565       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2566       if (t1 != t)
2567         return get_alias_set (t1);
2568     }
2569   else if (POINTER_TYPE_P (t))
2570     {
2571       tree t1;
2572
2573       /* Unfortunately, there is no canonical form of a pointer type.
2574          In particular, if we have `typedef int I', then `int *', and
2575          `I *' are different types.  So, we have to pick a canonical
2576          representative.  We do this below.
2577
2578          Technically, this approach is actually more conservative that
2579          it needs to be.  In particular, `const int *' and `int *'
2580          should be in different alias sets, according to the C and C++
2581          standard, since their types are not the same, and so,
2582          technically, an `int **' and `const int **' cannot point at
2583          the same thing.
2584
2585          But, the standard is wrong.  In particular, this code is
2586          legal C++:
2587
2588             int *ip;
2589             int **ipp = &ip;
2590             const int* const* cipp = &ipp;
2591
2592          And, it doesn't make sense for that to be legal unless you
2593          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2594          the pointed-to types.  This issue has been reported to the
2595          C++ committee.  */
2596       t1 = build_type_no_quals (t);
2597       if (t1 != t)
2598         return get_alias_set (t1);
2599     }
2600
2601   return -1;
2602 }
2603 \f
2604 /* Implement the __alignof keyword: Return the minimum required
2605    alignment of TYPE, measured in bytes.  */
2606
2607 tree
2608 c_alignof (type)
2609      tree type;
2610 {
2611   enum tree_code code = TREE_CODE (type);
2612   tree t;
2613
2614   /* In C++, sizeof applies to the referent.  Handle alignof the same way.  */
2615   if (code == REFERENCE_TYPE)
2616     {
2617       type = TREE_TYPE (type);
2618       code = TREE_CODE (type);
2619     }
2620
2621   if (code == FUNCTION_TYPE)
2622     t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2623   else if (code == VOID_TYPE || code == ERROR_MARK)
2624     t = size_one_node;
2625   else if (!COMPLETE_TYPE_P (type))
2626     {
2627       error ("__alignof__ applied to an incomplete type");
2628       t = size_zero_node;
2629     }
2630   else
2631     t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2632
2633   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2634 }
2635
2636 /* Implement the __alignof keyword: Return the minimum required
2637    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2638    FIELD_DECL's return DECL_ALIGN (which can be set from an
2639    "aligned" __attribute__ specification).  */
2640
2641 tree
2642 c_alignof_expr (expr)
2643      tree expr;
2644 {
2645   tree t;
2646
2647   if (TREE_CODE (expr) == VAR_DECL)
2648     t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2649
2650   else if (TREE_CODE (expr) == COMPONENT_REF
2651            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2652     {
2653       error ("`__alignof' applied to a bit-field");
2654       t = size_one_node;
2655     }
2656   else if (TREE_CODE (expr) == COMPONENT_REF
2657            && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2658     t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2659
2660   else if (TREE_CODE (expr) == INDIRECT_REF)
2661     {
2662       tree t = TREE_OPERAND (expr, 0);
2663       tree best = t;
2664       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2665
2666       while (TREE_CODE (t) == NOP_EXPR
2667              && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2668         {
2669           int thisalign;
2670
2671           t = TREE_OPERAND (t, 0);
2672           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2673           if (thisalign > bestalign)
2674             best = t, bestalign = thisalign;
2675         }
2676       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2677     }
2678   else
2679     return c_alignof (TREE_TYPE (expr));
2680
2681   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2682 }
2683 \f
2684 /* Build tree nodes and builtin functions common to both C and C++ language
2685    frontends.  */
2686
2687 void
2688 c_common_nodes_and_builtins ()
2689 {
2690   enum builtin_type
2691   {
2692 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2693 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2694 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2695 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2696 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2697 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2698 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2699 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2700 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2701 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2702 #include "builtin-types.def"
2703 #undef DEF_PRIMITIVE_TYPE
2704 #undef DEF_FUNCTION_TYPE_0
2705 #undef DEF_FUNCTION_TYPE_1
2706 #undef DEF_FUNCTION_TYPE_2
2707 #undef DEF_FUNCTION_TYPE_3
2708 #undef DEF_FUNCTION_TYPE_4
2709 #undef DEF_FUNCTION_TYPE_VAR_0
2710 #undef DEF_FUNCTION_TYPE_VAR_1
2711 #undef DEF_FUNCTION_TYPE_VAR_2
2712 #undef DEF_POINTER_TYPE
2713     BT_LAST
2714   };
2715
2716   typedef enum builtin_type builtin_type;
2717
2718   tree builtin_types[(int) BT_LAST];
2719   int wchar_type_size;
2720   tree array_domain_type;
2721   tree va_list_ref_type_node;
2722   tree va_list_arg_type_node;
2723
2724   /* Define `int' and `char' first so that dbx will output them first.  */
2725   record_builtin_type (RID_INT, NULL, integer_type_node);
2726   record_builtin_type (RID_CHAR, "char", char_type_node);
2727
2728   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2729      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2730      but not C.  Are the conditionals here needed?  */
2731   if (c_language == clk_cplusplus)
2732     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2733   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2734   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2735   record_builtin_type (RID_MAX, "long unsigned int",
2736                        long_unsigned_type_node);
2737   if (c_language == clk_cplusplus)
2738     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2739   record_builtin_type (RID_MAX, "long long int",
2740                        long_long_integer_type_node);
2741   record_builtin_type (RID_MAX, "long long unsigned int",
2742                        long_long_unsigned_type_node);
2743   if (c_language == clk_cplusplus)
2744     record_builtin_type (RID_MAX, "long long unsigned",
2745                          long_long_unsigned_type_node);
2746   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2747   record_builtin_type (RID_MAX, "short unsigned int",
2748                        short_unsigned_type_node);
2749   if (c_language == clk_cplusplus)
2750     record_builtin_type (RID_MAX, "unsigned short",
2751                          short_unsigned_type_node);
2752
2753   /* Define both `signed char' and `unsigned char'.  */
2754   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2755   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2756
2757   /* These are types that c_common_type_for_size and
2758      c_common_type_for_mode use.  */
2759   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2760                                             intQI_type_node));
2761   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2762                                             intHI_type_node));
2763   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2764                                             intSI_type_node));
2765   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2766                                             intDI_type_node));
2767 #if HOST_BITS_PER_WIDE_INT >= 64
2768   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2769                                             get_identifier ("__int128_t"),
2770                                             intTI_type_node));
2771 #endif
2772   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2773                                             unsigned_intQI_type_node));
2774   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2775                                             unsigned_intHI_type_node));
2776   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2777                                             unsigned_intSI_type_node));
2778   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2779                                             unsigned_intDI_type_node));
2780 #if HOST_BITS_PER_WIDE_INT >= 64
2781   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2782                                             get_identifier ("__uint128_t"),
2783                                             unsigned_intTI_type_node));
2784 #endif
2785
2786   /* Create the widest literal types.  */
2787   widest_integer_literal_type_node
2788     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2789   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2790                                             widest_integer_literal_type_node));
2791
2792   widest_unsigned_literal_type_node
2793     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2794   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2795                                             widest_unsigned_literal_type_node));
2796
2797   /* `unsigned long' is the standard type for sizeof.
2798      Note that stddef.h uses `unsigned long',
2799      and this must agree, even if long and int are the same size.  */
2800   c_size_type_node =
2801     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2802   signed_size_type_node = c_common_signed_type (c_size_type_node);
2803   set_sizetype (c_size_type_node);
2804
2805   build_common_tree_nodes_2 (flag_short_double);
2806
2807   record_builtin_type (RID_FLOAT, NULL, float_type_node);
2808   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2809   record_builtin_type (RID_MAX, "long double", long_double_type_node);
2810
2811   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2812                                             get_identifier ("complex int"),
2813                                             complex_integer_type_node));
2814   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2815                                             get_identifier ("complex float"),
2816                                             complex_float_type_node));
2817   (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2818                                             get_identifier ("complex double"),
2819                                             complex_double_type_node));
2820   (*lang_hooks.decls.pushdecl)
2821     (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2822                  complex_long_double_type_node));
2823
2824   /* Types which are common to the fortran compiler and libf2c.  When
2825      changing these, you also need to be concerned with f/com.h.  */
2826
2827   if (TYPE_PRECISION (float_type_node)
2828       == TYPE_PRECISION (long_integer_type_node))
2829     {
2830       g77_integer_type_node = long_integer_type_node;
2831       g77_uinteger_type_node = long_unsigned_type_node;
2832     }
2833   else if (TYPE_PRECISION (float_type_node)
2834            == TYPE_PRECISION (integer_type_node))
2835     {
2836       g77_integer_type_node = integer_type_node;
2837       g77_uinteger_type_node = unsigned_type_node;
2838     }
2839   else
2840     g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
2841
2842   if (g77_integer_type_node != NULL_TREE)
2843     {
2844       (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2845                                                 get_identifier ("__g77_integer"),
2846                                                 g77_integer_type_node));
2847       (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2848                                                 get_identifier ("__g77_uinteger"),
2849                                                 g77_uinteger_type_node));
2850     }
2851
2852   if (TYPE_PRECISION (float_type_node) * 2
2853       == TYPE_PRECISION (long_integer_type_node))
2854     {
2855       g77_longint_type_node = long_integer_type_node;
2856       g77_ulongint_type_node = long_unsigned_type_node;
2857     }
2858   else if (TYPE_PRECISION (float_type_node) * 2
2859            == TYPE_PRECISION (long_long_integer_type_node))
2860     {
2861       g77_longint_type_node = long_long_integer_type_node;
2862       g77_ulongint_type_node = long_long_unsigned_type_node;
2863     }
2864   else
2865     g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
2866
2867   if (g77_longint_type_node != NULL_TREE)
2868     {
2869       (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2870                                                 get_identifier ("__g77_longint"),
2871                                                 g77_longint_type_node));
2872       (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2873                                                 get_identifier ("__g77_ulongint"),
2874                                                 g77_ulongint_type_node));
2875     }
2876
2877   record_builtin_type (RID_VOID, NULL, void_type_node);
2878
2879   void_zero_node = build_int_2 (0, 0);
2880   TREE_TYPE (void_zero_node) = void_type_node;
2881
2882   void_list_node = build_void_list_node ();
2883
2884   /* Make a type to be the domain of a few array types
2885      whose domains don't really matter.
2886      200 is small enough that it always fits in size_t
2887      and large enough that it can hold most function names for the
2888      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
2889   array_domain_type = build_index_type (size_int (200));
2890
2891   /* Make a type for arrays of characters.
2892      With luck nothing will ever really depend on the length of this
2893      array type.  */
2894   char_array_type_node
2895     = build_array_type (char_type_node, array_domain_type);
2896
2897   /* Likewise for arrays of ints.  */
2898   int_array_type_node
2899     = build_array_type (integer_type_node, array_domain_type);
2900
2901   string_type_node = build_pointer_type (char_type_node);
2902   const_string_type_node
2903     = build_pointer_type (build_qualified_type
2904                           (char_type_node, TYPE_QUAL_CONST));
2905
2906   (*targetm.init_builtins) ();
2907
2908   /* This is special for C++ so functions can be overloaded.  */
2909   wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
2910   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2911   wchar_type_size = TYPE_PRECISION (wchar_type_node);
2912   if (c_language == clk_cplusplus)
2913     {
2914       if (TREE_UNSIGNED (wchar_type_node))
2915         wchar_type_node = make_unsigned_type (wchar_type_size);
2916       else
2917         wchar_type_node = make_signed_type (wchar_type_size);
2918       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2919     }
2920   else
2921     {
2922       signed_wchar_type_node = c_common_signed_type (wchar_type_node);
2923       unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
2924     }
2925
2926   /* This is for wide string constants.  */
2927   wchar_array_type_node
2928     = build_array_type (wchar_type_node, array_domain_type);
2929
2930   wint_type_node =
2931     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2932
2933   intmax_type_node =
2934     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2935   uintmax_type_node =
2936     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2937
2938   default_function_type = build_function_type (integer_type_node, NULL_TREE);
2939   ptrdiff_type_node
2940     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2941   unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
2942
2943   (*lang_hooks.decls.pushdecl)
2944     (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2945                  va_list_type_node));
2946
2947   (*lang_hooks.decls.pushdecl)
2948     (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2949                  ptrdiff_type_node));
2950
2951   (*lang_hooks.decls.pushdecl)
2952     (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2953                  sizetype));
2954
2955   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2956     {
2957       va_list_arg_type_node = va_list_ref_type_node =
2958         build_pointer_type (TREE_TYPE (va_list_type_node));
2959     }
2960   else
2961     {
2962       va_list_arg_type_node = va_list_type_node;
2963       va_list_ref_type_node = build_reference_type (va_list_type_node);
2964     }
2965
2966 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2967   builtin_types[(int) ENUM] = VALUE;
2968 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
2969   builtin_types[(int) ENUM]                             \
2970     = build_function_type (builtin_types[(int) RETURN], \
2971                            void_list_node);
2972 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
2973   builtin_types[(int) ENUM]                                             \
2974     = build_function_type (builtin_types[(int) RETURN],                 \
2975                            tree_cons (NULL_TREE,                        \
2976                                       builtin_types[(int) ARG1],        \
2977                                       void_list_node));
2978 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
2979   builtin_types[(int) ENUM]                             \
2980     = build_function_type                               \
2981       (builtin_types[(int) RETURN],                     \
2982        tree_cons (NULL_TREE,                            \
2983                   builtin_types[(int) ARG1],            \
2984                   tree_cons (NULL_TREE,                 \
2985                              builtin_types[(int) ARG2], \
2986                              void_list_node)));
2987 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
2988   builtin_types[(int) ENUM]                                              \
2989     = build_function_type                                                \
2990       (builtin_types[(int) RETURN],                                      \
2991        tree_cons (NULL_TREE,                                             \
2992                   builtin_types[(int) ARG1],                             \
2993                   tree_cons (NULL_TREE,                                  \
2994                              builtin_types[(int) ARG2],                  \
2995                              tree_cons (NULL_TREE,                       \
2996                                         builtin_types[(int) ARG3],       \
2997                                         void_list_node))));
2998 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
2999   builtin_types[(int) ENUM]                                             \
3000     = build_function_type                                               \
3001       (builtin_types[(int) RETURN],                                     \
3002        tree_cons (NULL_TREE,                                            \
3003                   builtin_types[(int) ARG1],                            \
3004                   tree_cons (NULL_TREE,                                 \
3005                              builtin_types[(int) ARG2],                 \
3006                              tree_cons                                  \
3007                              (NULL_TREE,                                \
3008                               builtin_types[(int) ARG3],                \
3009                               tree_cons (NULL_TREE,                     \
3010                                          builtin_types[(int) ARG4],     \
3011                                          void_list_node)))));
3012 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3013   builtin_types[(int) ENUM]                                             \
3014     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3015 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3016    builtin_types[(int) ENUM]                                             \
3017     = build_function_type (builtin_types[(int) RETURN],                  \
3018                            tree_cons (NULL_TREE,                         \
3019                                       builtin_types[(int) ARG1],         \
3020                                       NULL_TREE));
3021
3022 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3023    builtin_types[(int) ENUM]                                    \
3024     = build_function_type                                       \
3025       (builtin_types[(int) RETURN],                             \
3026        tree_cons (NULL_TREE,                                    \
3027                   builtin_types[(int) ARG1],                    \
3028                   tree_cons (NULL_TREE,                         \
3029                              builtin_types[(int) ARG2],         \
3030                              NULL_TREE)));
3031 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3032   builtin_types[(int) ENUM]                             \
3033     = build_pointer_type (builtin_types[(int) TYPE]);
3034 #include "builtin-types.def"
3035 #undef DEF_PRIMITIVE_TYPE
3036 #undef DEF_FUNCTION_TYPE_1
3037 #undef DEF_FUNCTION_TYPE_2
3038 #undef DEF_FUNCTION_TYPE_3
3039 #undef DEF_FUNCTION_TYPE_4
3040 #undef DEF_FUNCTION_TYPE_VAR_0
3041 #undef DEF_FUNCTION_TYPE_VAR_1
3042 #undef DEF_POINTER_TYPE
3043
3044 #define DEF_BUILTIN(ENUM, NAME, CLASS,                                  \
3045                     TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P)       \
3046   if (NAME)                                                             \
3047     {                                                                   \
3048       tree decl;                                                        \
3049                                                                         \
3050       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
3051         abort ();                                                       \
3052                                                                         \
3053       if (!BOTH_P)                                                      \
3054         decl = builtin_function (NAME, builtin_types[TYPE], ENUM,       \
3055                                  CLASS,                                 \
3056                                  (FALLBACK_P                            \
3057                                   ? (NAME + strlen ("__builtin_"))      \
3058                                   : NULL));                             \
3059       else                                                              \
3060         decl = builtin_function_2 (NAME,                                \
3061                                    NAME + strlen ("__builtin_"),        \
3062                                    builtin_types[TYPE],                 \
3063                                    builtin_types[LIBTYPE],              \
3064                                    ENUM,                                \
3065                                    CLASS,                               \
3066                                    FALLBACK_P,                          \
3067                                    NONANSI_P,                           \
3068                                    /*noreturn_p=*/0);                   \
3069                                                                         \
3070       built_in_decls[(int) ENUM] = decl;                                \
3071     }
3072 #include "builtins.def"
3073 #undef DEF_BUILTIN
3074
3075   /* Declare _exit and _Exit just to mark them as non-returning.  */
3076   builtin_function_2 (NULL, "_exit", NULL_TREE,
3077                       builtin_types[BT_FN_VOID_INT],
3078                       0, NOT_BUILT_IN, 0, 1, 1);
3079   builtin_function_2 (NULL, "_Exit", NULL_TREE,
3080                       builtin_types[BT_FN_VOID_INT],
3081                       0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
3082
3083   /* Declare these functions non-returning
3084      to avoid spurious "control drops through" warnings.  */
3085   builtin_function_2 (NULL, "abort",
3086                       NULL_TREE, ((c_language == clk_cplusplus)
3087                                   ? builtin_types[BT_FN_VOID]
3088                                   : builtin_types[BT_FN_VOID_VAR]),
3089                       0, NOT_BUILT_IN, 0, 0, 1);
3090
3091   builtin_function_2 (NULL, "exit",
3092                       NULL_TREE, ((c_language == clk_cplusplus)
3093                                   ? builtin_types[BT_FN_VOID_INT]
3094                                   : builtin_types[BT_FN_VOID_VAR]),
3095                       0, NOT_BUILT_IN, 0, 0, 1);
3096
3097   main_identifier_node = get_identifier ("main");
3098 }
3099
3100 tree
3101 build_va_arg (expr, type)
3102      tree expr, type;
3103 {
3104   return build1 (VA_ARG_EXPR, type, expr);
3105 }
3106
3107
3108 /* Linked list of disabled built-in functions.  */
3109
3110 typedef struct disabled_builtin
3111 {
3112   const char *name;
3113   struct disabled_builtin *next;
3114 } disabled_builtin;
3115 static disabled_builtin *disabled_builtins = NULL;
3116
3117 static bool builtin_function_disabled_p PARAMS ((const char *));
3118
3119 /* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3120    begins with "__builtin_", give an error.  */
3121
3122 void
3123 disable_builtin_function (name)
3124      const char *name;
3125 {
3126   if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3127     error ("cannot disable built-in function `%s'", name);
3128   else
3129     {
3130       disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3131       new->name = name;
3132       new->next = disabled_builtins;
3133       disabled_builtins = new;
3134     }
3135 }
3136
3137
3138 /* Return true if the built-in function NAME has been disabled, false
3139    otherwise.  */
3140
3141 static bool
3142 builtin_function_disabled_p (name)
3143      const char *name;
3144 {
3145   disabled_builtin *p;
3146   for (p = disabled_builtins; p != NULL; p = p->next)
3147     {
3148       if (strcmp (name, p->name) == 0)
3149         return true;
3150     }
3151   return false;
3152 }
3153
3154
3155 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3156    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3157    of these may be NULL (though both being NULL is useless).
3158    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3159    TYPE is the type of the function with the ordinary name.  These
3160    may differ if the ordinary name is declared with a looser type to avoid
3161    conflicts with headers.  FUNCTION_CODE and CLASS are as for
3162    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3163    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3164    If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3165    NORETURN_P is nonzero, the function is marked as non-returning.
3166    Returns the declaration of BUILTIN_NAME, if any, otherwise
3167    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3168    or if NONANSI_P and flag_no_nonansi_builtin.  */
3169
3170 static tree
3171 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3172                     class, library_name_p, nonansi_p, noreturn_p)
3173      const char *builtin_name;
3174      const char *name;
3175      tree builtin_type;
3176      tree type;
3177      int function_code;
3178      enum built_in_class class;
3179      int library_name_p;
3180      int nonansi_p;
3181      int noreturn_p;
3182 {
3183   tree bdecl = NULL_TREE;
3184   tree decl = NULL_TREE;
3185   if (builtin_name != 0)
3186     {
3187       bdecl = builtin_function (builtin_name, builtin_type, function_code,
3188                                 class, library_name_p ? name : NULL);
3189       if (noreturn_p)
3190         {
3191           TREE_THIS_VOLATILE (bdecl) = 1;
3192           TREE_SIDE_EFFECTS (bdecl) = 1;
3193         }
3194     }
3195   if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3196       && !(nonansi_p && flag_no_nonansi_builtin))
3197     {
3198       decl = builtin_function (name, type, function_code, class, NULL);
3199       if (nonansi_p)
3200         DECL_BUILT_IN_NONANSI (decl) = 1;
3201       if (noreturn_p)
3202         {
3203           TREE_THIS_VOLATILE (decl) = 1;
3204           TREE_SIDE_EFFECTS (decl) = 1;
3205         }
3206     }
3207   return (bdecl != 0 ? bdecl : decl);
3208 }
3209 \f
3210 /* Nonzero if the type T promotes to int.  This is (nearly) the
3211    integral promotions defined in ISO C99 6.3.1.1/2.  */
3212
3213 bool
3214 c_promoting_integer_type_p (t)
3215      tree t;
3216 {
3217   switch (TREE_CODE (t))
3218     {
3219     case INTEGER_TYPE:
3220       return (TYPE_MAIN_VARIANT (t) == char_type_node
3221               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3222               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3223               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3224               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3225               || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3226
3227     case ENUMERAL_TYPE:
3228       /* ??? Technically all enumerations not larger than an int
3229          promote to an int.  But this is used along code paths
3230          that only want to notice a size change.  */
3231       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3232
3233     case BOOLEAN_TYPE:
3234       return 1;
3235
3236     default:
3237       return 0;
3238     }
3239 }
3240
3241 /* Return 1 if PARMS specifies a fixed number of parameters
3242    and none of their types is affected by default promotions.  */
3243
3244 int
3245 self_promoting_args_p (parms)
3246      tree parms;
3247 {
3248   tree t;
3249   for (t = parms; t; t = TREE_CHAIN (t))
3250     {
3251       tree type = TREE_VALUE (t);
3252
3253       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3254         return 0;
3255
3256       if (type == 0)
3257         return 0;
3258
3259       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3260         return 0;
3261
3262       if (c_promoting_integer_type_p (type))
3263         return 0;
3264     }
3265   return 1;
3266 }
3267
3268 /* Recursively examines the array elements of TYPE, until a non-array
3269    element type is found.  */
3270
3271 tree
3272 strip_array_types (type)
3273      tree type;
3274 {
3275   while (TREE_CODE (type) == ARRAY_TYPE)
3276     type = TREE_TYPE (type);
3277
3278   return type;
3279 }
3280
3281 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3282                                           enum tree_code));
3283
3284 /* Expand a call to an unordered comparison function such as
3285    __builtin_isgreater().  FUNCTION is the function's declaration and
3286    PARAMS a list of the values passed.  For __builtin_isunordered(),
3287    UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR.  In
3288    other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3289    that give the opposite of the desired result.  UNORDERED_CODE is
3290    used for modes that can hold NaNs and ORDERED_CODE is used for the
3291    rest.  */
3292
3293 static tree
3294 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3295      tree function, params;
3296      enum tree_code unordered_code, ordered_code;
3297 {
3298   tree arg0, arg1, type;
3299   enum tree_code code0, code1;
3300
3301   /* Check that we have exactly two arguments.  */
3302   if (params == 0 || TREE_CHAIN (params) == 0)
3303     {
3304       error ("too few arguments to function `%s'",
3305              IDENTIFIER_POINTER (DECL_NAME (function)));
3306       return error_mark_node;
3307     }
3308   else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3309     {
3310       error ("too many arguments to function `%s'",
3311              IDENTIFIER_POINTER (DECL_NAME (function)));
3312       return error_mark_node;
3313     }
3314
3315   arg0 = TREE_VALUE (params);
3316   arg1 = TREE_VALUE (TREE_CHAIN (params));
3317
3318   code0 = TREE_CODE (TREE_TYPE (arg0));
3319   code1 = TREE_CODE (TREE_TYPE (arg1));
3320
3321   /* Make sure that the arguments have a common type of REAL.  */
3322   type = 0;
3323   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3324       && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3325     type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3326
3327   if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3328     {
3329       error ("non-floating-point argument to function `%s'",
3330              IDENTIFIER_POINTER (DECL_NAME (function)));
3331       return error_mark_node;
3332     }
3333
3334   if (unordered_code == UNORDERED_EXPR)
3335     {
3336       if (MODE_HAS_NANS (TYPE_MODE (type)))
3337         return build_binary_op (unordered_code,
3338                                 convert (type, arg0),
3339                                 convert (type, arg1),
3340                                 0);
3341       else
3342         return integer_zero_node;
3343     }
3344
3345   return build_unary_op (TRUTH_NOT_EXPR,
3346                          build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3347                                           ? unordered_code
3348                                           : ordered_code,
3349                                           convert (type, arg0),
3350                                           convert (type, arg1),
3351                                           0),
3352                          0);
3353 }
3354
3355
3356 /* Recognize certain built-in functions so we can make tree-codes
3357    other than CALL_EXPR.  We do this when it enables fold-const.c
3358    to do something useful.  */
3359 /* ??? By rights this should go in builtins.c, but only C and C++
3360    implement build_{binary,unary}_op.  Not exactly sure what bits
3361    of functionality are actually needed from those functions, or
3362    where the similar functionality exists in the other front ends.  */
3363
3364 tree
3365 expand_tree_builtin (function, params, coerced_params)
3366      tree function, params, coerced_params;
3367 {
3368   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3369     return NULL_TREE;
3370
3371   switch (DECL_FUNCTION_CODE (function))
3372     {
3373     case BUILT_IN_ABS:
3374     case BUILT_IN_LABS:
3375     case BUILT_IN_LLABS:
3376     case BUILT_IN_IMAXABS:
3377     case BUILT_IN_FABS:
3378     case BUILT_IN_FABSL:
3379     case BUILT_IN_FABSF:
3380       if (coerced_params == 0)
3381         return integer_zero_node;
3382       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3383
3384     case BUILT_IN_CONJ:
3385     case BUILT_IN_CONJF:
3386     case BUILT_IN_CONJL:
3387       if (coerced_params == 0)
3388         return integer_zero_node;
3389       return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3390
3391     case BUILT_IN_CREAL:
3392     case BUILT_IN_CREALF:
3393     case BUILT_IN_CREALL:
3394       if (coerced_params == 0)
3395         return integer_zero_node;
3396       return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3397
3398     case BUILT_IN_CIMAG:
3399     case BUILT_IN_CIMAGF:
3400     case BUILT_IN_CIMAGL:
3401       if (coerced_params == 0)
3402         return integer_zero_node;
3403       return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3404
3405     case BUILT_IN_ISGREATER:
3406       return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3407
3408     case BUILT_IN_ISGREATEREQUAL:
3409       return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3410
3411     case BUILT_IN_ISLESS:
3412       return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3413
3414     case BUILT_IN_ISLESSEQUAL:
3415       return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3416
3417     case BUILT_IN_ISLESSGREATER:
3418       return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3419
3420     case BUILT_IN_ISUNORDERED:
3421       return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3422
3423     default:
3424       break;
3425     }
3426
3427   return NULL_TREE;
3428 }
3429
3430 /* Returns non-zero if CODE is the code for a statement.  */
3431
3432 int
3433 statement_code_p (code)
3434      enum tree_code code;
3435 {
3436   switch (code)
3437     {
3438     case CLEANUP_STMT:
3439     case EXPR_STMT:
3440     case COMPOUND_STMT:
3441     case DECL_STMT:
3442     case IF_STMT:
3443     case FOR_STMT:
3444     case WHILE_STMT:
3445     case DO_STMT:
3446     case RETURN_STMT:
3447     case BREAK_STMT:
3448     case CONTINUE_STMT:
3449     case SCOPE_STMT:
3450     case SWITCH_STMT:
3451     case GOTO_STMT:
3452     case LABEL_STMT:
3453     case ASM_STMT:
3454     case FILE_STMT:
3455     case CASE_LABEL:
3456       return 1;
3457
3458     default:
3459       if (lang_statement_code_p)
3460         return (*lang_statement_code_p) (code);
3461       return 0;
3462     }
3463 }
3464
3465 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3466    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3467    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3468    value, the traversal is aborted, and the value returned by FUNC is
3469    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3470    the node being visited are not walked.
3471
3472    We don't need a without_duplicates variant of this one because the
3473    statement tree is a tree, not a graph.  */
3474
3475 tree
3476 walk_stmt_tree (tp, func, data)
3477      tree *tp;
3478      walk_tree_fn func;
3479      void *data;
3480 {
3481   enum tree_code code;
3482   int walk_subtrees;
3483   tree result;
3484   int i, len;
3485
3486 #define WALK_SUBTREE(NODE)                              \
3487   do                                                    \
3488     {                                                   \
3489       result = walk_stmt_tree (&(NODE), func, data);    \
3490       if (result)                                       \
3491         return result;                                  \
3492     }                                                   \
3493   while (0)
3494
3495   /* Skip empty subtrees.  */
3496   if (!*tp)
3497     return NULL_TREE;
3498
3499   /* Skip subtrees below non-statement nodes.  */
3500   if (!statement_code_p (TREE_CODE (*tp)))
3501     return NULL_TREE;
3502
3503   /* Call the function.  */
3504   walk_subtrees = 1;
3505   result = (*func) (tp, &walk_subtrees, data);
3506
3507   /* If we found something, return it.  */
3508   if (result)
3509     return result;
3510
3511   /* FUNC may have modified the tree, recheck that we're looking at a
3512      statement node.  */
3513   code = TREE_CODE (*tp);
3514   if (!statement_code_p (code))
3515     return NULL_TREE;
3516
3517   /* Visit the subtrees unless FUNC decided that there was nothing
3518      interesting below this point in the tree.  */
3519   if (walk_subtrees)
3520     {
3521       /* Walk over all the sub-trees of this operand.  Statement nodes
3522          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3523       len = TREE_CODE_LENGTH (code);
3524
3525       /* Go through the subtrees.  We need to do this in forward order so
3526          that the scope of a FOR_EXPR is handled properly.  */
3527       for (i = 0; i < len; ++i)
3528         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3529     }
3530
3531   /* Finally visit the chain.  This can be tail-recursion optimized if
3532      we write it this way.  */
3533   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3534
3535 #undef WALK_SUBTREE
3536 }
3537
3538 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3539    representing case labels, or NULL_TREE for a `default' label.
3540    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3541    K2, and 0 if K1 and K2 are equal.  */
3542
3543 int
3544 case_compare (k1, k2)
3545      splay_tree_key k1;
3546      splay_tree_key k2;
3547 {
3548   /* Consider a NULL key (such as arises with a `default' label) to be
3549      smaller than anything else.  */
3550   if (!k1)
3551     return k2 ? -1 : 0;
3552   else if (!k2)
3553     return k1 ? 1 : 0;
3554
3555   return tree_int_cst_compare ((tree) k1, (tree) k2);
3556 }
3557
3558 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3559    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3560    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3561    case label was declared using the usual C/C++ syntax, rather than
3562    the GNU case range extension.  CASES is a tree containing all the
3563    case ranges processed so far; COND is the condition for the
3564    switch-statement itself.  Returns the CASE_LABEL created, or
3565    ERROR_MARK_NODE if no CASE_LABEL is created.  */
3566
3567 tree
3568 c_add_case_label (cases, cond, low_value, high_value)
3569      splay_tree cases;
3570      tree cond;
3571      tree low_value;
3572      tree high_value;
3573 {
3574   tree type;
3575   tree label;
3576   tree case_label;
3577   splay_tree_node node;
3578
3579   /* Create the LABEL_DECL itself.  */
3580   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3581   DECL_CONTEXT (label) = current_function_decl;
3582
3583   /* If there was an error processing the switch condition, bail now
3584      before we get more confused.  */
3585   if (!cond || cond == error_mark_node)
3586     {
3587       /* Add a label anyhow so that the back-end doesn't think that
3588          the beginning of the switch is unreachable.  */
3589       if (!cases->root)
3590         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3591       return error_mark_node;
3592     }
3593
3594   if ((low_value && TREE_TYPE (low_value)
3595        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3596       || (high_value && TREE_TYPE (high_value)
3597           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3598     error ("pointers are not permitted as case values");
3599
3600   /* Case ranges are a GNU extension.  */
3601   if (high_value && pedantic)
3602     {
3603       if (c_language == clk_cplusplus)
3604         pedwarn ("ISO C++ forbids range expressions in switch statements");
3605       else
3606         pedwarn ("ISO C forbids range expressions in switch statements");
3607     }
3608
3609   type = TREE_TYPE (cond);
3610   if (low_value)
3611     {
3612       low_value = check_case_value (low_value);
3613       low_value = convert_and_check (type, low_value);
3614     }
3615   if (high_value)
3616     {
3617       high_value = check_case_value (high_value);
3618       high_value = convert_and_check (type, high_value);
3619     }
3620
3621   /* If an error has occurred, bail out now.  */
3622   if (low_value == error_mark_node || high_value == error_mark_node)
3623     {
3624       if (!cases->root)
3625         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3626       return error_mark_node;
3627     }
3628
3629   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3630      really a case range, even though it was written that way.  Remove
3631      the HIGH_VALUE to simplify later processing.  */
3632   if (tree_int_cst_equal (low_value, high_value))
3633     high_value = NULL_TREE;
3634   if (low_value && high_value
3635       && !tree_int_cst_lt (low_value, high_value))
3636     warning ("empty range specified");
3637
3638   /* Look up the LOW_VALUE in the table of case labels we already
3639      have.  */
3640   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3641   /* If there was not an exact match, check for overlapping ranges.
3642      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3643      that's a `default' label and the only overlap is an exact match.  */
3644   if (!node && (low_value || high_value))
3645     {
3646       splay_tree_node low_bound;
3647       splay_tree_node high_bound;
3648
3649       /* Even though there wasn't an exact match, there might be an
3650          overlap between this case range and another case range.
3651          Since we've (inductively) not allowed any overlapping case
3652          ranges, we simply need to find the greatest low case label
3653          that is smaller that LOW_VALUE, and the smallest low case
3654          label that is greater than LOW_VALUE.  If there is an overlap
3655          it will occur in one of these two ranges.  */
3656       low_bound = splay_tree_predecessor (cases,
3657                                           (splay_tree_key) low_value);
3658       high_bound = splay_tree_successor (cases,
3659                                          (splay_tree_key) low_value);
3660
3661       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3662          the LOW_VALUE, so there is no need to check unless the
3663          LOW_BOUND is in fact itself a case range.  */
3664       if (low_bound
3665           && CASE_HIGH ((tree) low_bound->value)
3666           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3667                                     low_value) >= 0)
3668         node = low_bound;
3669       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3670          range is bigger than the low end of the current range, so we
3671          are only interested if the current range is a real range, and
3672          not an ordinary case label.  */
3673       else if (high_bound
3674                && high_value
3675                && (tree_int_cst_compare ((tree) high_bound->key,
3676                                          high_value)
3677                    <= 0))
3678         node = high_bound;
3679     }
3680   /* If there was an overlap, issue an error.  */
3681   if (node)
3682     {
3683       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3684
3685       if (high_value)
3686         {
3687           error ("duplicate (or overlapping) case value");
3688           error_with_decl (duplicate,
3689                            "this is the first entry overlapping that value");
3690         }
3691       else if (low_value)
3692         {
3693           error ("duplicate case value") ;
3694           error_with_decl (duplicate, "previously used here");
3695         }
3696       else
3697         {
3698           error ("multiple default labels in one switch");
3699           error_with_decl (duplicate, "this is the first default label");
3700         }
3701       if (!cases->root)
3702         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3703     }
3704
3705   /* Add a CASE_LABEL to the statement-tree.  */
3706   case_label = add_stmt (build_case_label (low_value, high_value, label));
3707   /* Register this case label in the splay tree.  */
3708   splay_tree_insert (cases,
3709                      (splay_tree_key) low_value,
3710                      (splay_tree_value) case_label);
3711
3712   return case_label;
3713 }
3714
3715 /* Finish an expression taking the address of LABEL.  Returns an
3716    expression for the address.  */
3717
3718 tree
3719 finish_label_address_expr (label)
3720      tree label;
3721 {
3722   tree result;
3723
3724   if (pedantic)
3725     {
3726       if (c_language == clk_cplusplus)
3727         pedwarn ("ISO C++ forbids taking the address of a label");
3728       else
3729         pedwarn ("ISO C forbids taking the address of a label");
3730     }
3731
3732   label = lookup_label (label);
3733   if (label == NULL_TREE)
3734     result = null_pointer_node;
3735   else
3736     {
3737       TREE_USED (label) = 1;
3738       result = build1 (ADDR_EXPR, ptr_type_node, label);
3739       TREE_CONSTANT (result) = 1;
3740       /* The current function in not necessarily uninlinable.
3741          Computed gotos are incompatible with inlining, but the value
3742          here could be used only in a diagnostic, for example.  */
3743     }
3744
3745   return result;
3746 }
3747
3748 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
3749    parameter allows this function to be used as a GC-marking
3750    function.  */
3751
3752 void
3753 mark_stmt_tree (p)
3754      void *p;
3755 {
3756   stmt_tree st = (stmt_tree) p;
3757
3758   ggc_mark_tree (st->x_last_stmt);
3759   ggc_mark_tree (st->x_last_expr_type);
3760 }
3761
3762 /* Mark LD for GC.  */
3763
3764 void
3765 c_mark_lang_decl (c)
3766      struct c_lang_decl *c ATTRIBUTE_UNUSED;
3767 {
3768 }
3769
3770 /* Mark F for GC.  */
3771
3772 void
3773 mark_c_language_function (f)
3774      struct language_function *f;
3775 {
3776   if (!f)
3777     return;
3778
3779   mark_stmt_tree (&f->x_stmt_tree);
3780   ggc_mark_tree (f->x_scope_stmt_stack);
3781 }
3782
3783 /* Hook used by expand_expr to expand language-specific tree codes.  */
3784
3785 rtx
3786 c_expand_expr (exp, target, tmode, modifier)
3787      tree exp;
3788      rtx target;
3789      enum machine_mode tmode;
3790      int modifier;  /* Actually enum_modifier.  */
3791 {
3792   switch (TREE_CODE (exp))
3793     {
3794     case STMT_EXPR:
3795       {
3796         tree rtl_expr;
3797         rtx result;
3798         bool preserve_result = false;
3799
3800         /* Since expand_expr_stmt calls free_temp_slots after every
3801            expression statement, we must call push_temp_slots here.
3802            Otherwise, any temporaries in use now would be considered
3803            out-of-scope after the first EXPR_STMT from within the
3804            STMT_EXPR.  */
3805         push_temp_slots ();
3806         rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
3807
3808         /* If we want the result of this expression, find the last
3809            EXPR_STMT in the COMPOUND_STMT and mark it as addressable.  */
3810         if (target != const0_rtx
3811             && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3812             && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3813           {
3814             tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3815             tree last = TREE_CHAIN (expr);
3816
3817             while (TREE_CHAIN (last))
3818               {
3819                 expr = last;
3820                 last = TREE_CHAIN (last);
3821               }
3822
3823             if (TREE_CODE (last) == SCOPE_STMT
3824                 && TREE_CODE (expr) == EXPR_STMT)
3825               {
3826                 TREE_ADDRESSABLE (expr) = 1;
3827                 preserve_result = true;
3828               }
3829           }
3830
3831         expand_stmt (STMT_EXPR_STMT (exp));
3832         expand_end_stmt_expr (rtl_expr);
3833
3834         result = expand_expr (rtl_expr, target, tmode, modifier);
3835         if (preserve_result && GET_CODE (result) == MEM)
3836           {
3837             if (GET_MODE (result) != BLKmode)
3838               result = copy_to_reg (result);
3839             else
3840               preserve_temp_slots (result);
3841           }
3842
3843         /* If the statment-expression does not have a scope, then the
3844            new temporaries we created within it must live beyond the
3845            statement-expression.  */
3846         if (STMT_EXPR_NO_SCOPE (exp))
3847           preserve_temp_slots (NULL_RTX);
3848
3849         pop_temp_slots ();
3850         return result;
3851       }
3852       break;
3853
3854     case CALL_EXPR:
3855       {
3856         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3857             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3858                 == FUNCTION_DECL)
3859             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3860             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3861                 == BUILT_IN_FRONTEND))
3862           return c_expand_builtin (exp, target, tmode, modifier);
3863         else
3864           abort ();
3865       }
3866       break;
3867
3868     case COMPOUND_LITERAL_EXPR:
3869       {
3870         /* Initialize the anonymous variable declared in the compound
3871            literal, then return the variable.  */
3872         tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3873         emit_local_var (decl);
3874         return expand_expr (decl, target, tmode, modifier);
3875       }
3876
3877     default:
3878       abort ();
3879     }
3880
3881   abort ();
3882   return NULL;
3883 }
3884
3885 /* Hook used by safe_from_p to handle language-specific tree codes.  */
3886
3887 int
3888 c_safe_from_p (target, exp)
3889      rtx target;
3890      tree exp;
3891 {
3892   /* We can see statements here when processing the body of a
3893      statement-expression.  For a declaration statement declaring a
3894      variable, look at the variable's initializer.  */
3895   if (TREE_CODE (exp) == DECL_STMT)
3896     {
3897       tree decl = DECL_STMT_DECL (exp);
3898
3899       if (TREE_CODE (decl) == VAR_DECL
3900           && DECL_INITIAL (decl)
3901           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3902         return 0;
3903     }
3904
3905   /* For any statement, we must follow the statement-chain.  */
3906   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3907     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3908
3909   /* Assume everything else is safe.  */
3910   return 1;
3911 }
3912
3913 /* Hook used by unsafe_for_reeval to handle language-specific tree codes.  */
3914
3915 int
3916 c_common_unsafe_for_reeval (exp)
3917      tree exp;
3918 {
3919   /* Statement expressions may not be reevaluated, likewise compound
3920      literals.  */
3921   if (TREE_CODE (exp) == STMT_EXPR
3922       || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3923     return 2;
3924
3925   /* Walk all other expressions.  */
3926   return -1;
3927 }
3928
3929 /* Hook used by staticp to handle language-specific tree codes.  */
3930
3931 int
3932 c_staticp (exp)
3933      tree exp;
3934 {
3935   if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3936       && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3937     return 1;
3938   return 0;
3939 }
3940
3941 #define CALLED_AS_BUILT_IN(NODE) \
3942    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3943
3944 static rtx
3945 c_expand_builtin (exp, target, tmode, modifier)
3946      tree exp;
3947      rtx target;
3948      enum machine_mode tmode;
3949      enum expand_modifier modifier;
3950 {
3951   tree type = TREE_TYPE (exp);
3952   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3953   tree arglist = TREE_OPERAND (exp, 1);
3954   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3955   enum tree_code code = TREE_CODE (exp);
3956   const int ignore = (target == const0_rtx
3957                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3958                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
3959                            || code == COND_EXPR)
3960                           && TREE_CODE (type) == VOID_TYPE));
3961
3962   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3963     return expand_call (exp, target, ignore);
3964
3965   switch (fcode)
3966     {
3967     case BUILT_IN_PRINTF:
3968       target = c_expand_builtin_printf (arglist, target, tmode,
3969                                         modifier, ignore, /*unlocked=*/ 0);
3970       if (target)
3971         return target;
3972       break;
3973
3974     case BUILT_IN_PRINTF_UNLOCKED:
3975       target = c_expand_builtin_printf (arglist, target, tmode,
3976                                         modifier, ignore, /*unlocked=*/ 1);
3977       if (target)
3978         return target;
3979       break;
3980
3981     case BUILT_IN_FPRINTF:
3982       target = c_expand_builtin_fprintf (arglist, target, tmode,
3983                                          modifier, ignore, /*unlocked=*/ 0);
3984       if (target)
3985         return target;
3986       break;
3987
3988     case BUILT_IN_FPRINTF_UNLOCKED:
3989       target = c_expand_builtin_fprintf (arglist, target, tmode,
3990                                          modifier, ignore, /*unlocked=*/ 1);
3991       if (target)
3992         return target;
3993       break;
3994
3995     default:                    /* just do library call, if unknown builtin */
3996       error ("built-in function `%s' not currently supported",
3997              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3998     }
3999
4000   /* The switch statement above can drop through to cause the function
4001      to be called normally.  */
4002   return expand_call (exp, target, ignore);
4003 }
4004
4005 /* Check an arglist to *printf for problems.  The arglist should start
4006    at the format specifier, with the remaining arguments immediately
4007    following it.  */
4008 static int
4009 is_valid_printf_arglist (arglist)
4010      tree arglist;
4011 {
4012   /* Save this value so we can restore it later.  */
4013   const int SAVE_pedantic = pedantic;
4014   int diagnostic_occurred = 0;
4015   tree attrs;
4016
4017   /* Set this to a known value so the user setting won't affect code
4018      generation.  */
4019   pedantic = 1;
4020   /* Check to make sure there are no format specifier errors.  */
4021   attrs = tree_cons (get_identifier ("format"),
4022                      tree_cons (NULL_TREE,
4023                                 get_identifier ("printf"),
4024                                 tree_cons (NULL_TREE,
4025                                            integer_one_node,
4026                                            tree_cons (NULL_TREE,
4027                                                       build_int_2 (2, 0),
4028                                                       NULL_TREE))),
4029                      NULL_TREE);
4030   check_function_format (&diagnostic_occurred, attrs, arglist);
4031
4032   /* Restore the value of `pedantic'.  */
4033   pedantic = SAVE_pedantic;
4034
4035   /* If calling `check_function_format_ptr' produces a warning, we
4036      return false, otherwise we return true.  */
4037   return ! diagnostic_occurred;
4038 }
4039
4040 /* If the arguments passed to printf are suitable for optimizations,
4041    we attempt to transform the call.  */
4042 static rtx
4043 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
4044      tree arglist;
4045      rtx target;
4046      enum machine_mode tmode;
4047      enum expand_modifier modifier;
4048      int ignore;
4049      int unlocked;
4050 {
4051   tree fn_putchar = unlocked ?
4052     built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
4053   tree fn_puts = unlocked ?
4054     built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
4055   tree fn, format_arg, stripped_string;
4056
4057   /* If the return value is used, or the replacement _DECL isn't
4058      initialized, don't do the transformation.  */
4059   if (!ignore || !fn_putchar || !fn_puts)
4060     return 0;
4061
4062   /* Verify the required arguments in the original call.  */
4063   if (arglist == 0
4064       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4065     return 0;
4066
4067   /* Check the specifier vs. the parameters.  */
4068   if (!is_valid_printf_arglist (arglist))
4069     return 0;
4070
4071   format_arg = TREE_VALUE (arglist);
4072   stripped_string = format_arg;
4073   STRIP_NOPS (stripped_string);
4074   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4075     stripped_string = TREE_OPERAND (stripped_string, 0);
4076
4077   /* If the format specifier isn't a STRING_CST, punt.  */
4078   if (TREE_CODE (stripped_string) != STRING_CST)
4079     return 0;
4080
4081   /* OK!  We can attempt optimization.  */
4082
4083   /* If the format specifier was "%s\n", call __builtin_puts(arg2).  */
4084   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4085     {
4086       arglist = TREE_CHAIN (arglist);
4087       fn = fn_puts;
4088     }
4089   /* If the format specifier was "%c", call __builtin_putchar (arg2).  */
4090   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4091     {
4092       arglist = TREE_CHAIN (arglist);
4093       fn = fn_putchar;
4094     }
4095   else
4096     {
4097       /* We can't handle anything else with % args or %% ... yet.  */
4098       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4099         return 0;
4100
4101       /* If the resulting constant string has a length of 1, call
4102          putchar.  Note, TREE_STRING_LENGTH includes the terminating
4103          NULL in its count.  */
4104       if (TREE_STRING_LENGTH (stripped_string) == 2)
4105         {
4106           /* Given printf("c"), (where c is any one character,)
4107              convert "c"[0] to an int and pass that to the replacement
4108              function.  */
4109           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4110           arglist = build_tree_list (NULL_TREE, arglist);
4111
4112           fn = fn_putchar;
4113         }
4114       /* If the resulting constant was "string\n", call
4115          __builtin_puts("string").  Ensure "string" has at least one
4116          character besides the trailing \n.  Note, TREE_STRING_LENGTH
4117          includes the terminating NULL in its count.  */
4118       else if (TREE_STRING_LENGTH (stripped_string) > 2
4119                && TREE_STRING_POINTER (stripped_string)
4120                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4121         {
4122           /* Create a NULL-terminated string that's one char shorter
4123              than the original, stripping off the trailing '\n'.  */
4124           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4125           char *newstr = (char *) alloca (newlen);
4126           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4127           newstr[newlen - 1] = 0;
4128
4129           arglist = fix_string_type (build_string (newlen, newstr));
4130           arglist = build_tree_list (NULL_TREE, arglist);
4131           fn = fn_puts;
4132         }
4133       else
4134         /* We'd like to arrange to call fputs(string) here, but we
4135            need stdout and don't have a way to get it ... yet.  */
4136         return 0;
4137     }
4138
4139   return expand_expr (build_function_call (fn, arglist),
4140                       (ignore ? const0_rtx : target),
4141                       tmode, modifier);
4142 }
4143
4144 /* If the arguments passed to fprintf are suitable for optimizations,
4145    we attempt to transform the call.  */
4146 static rtx
4147 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4148      tree arglist;
4149      rtx target;
4150      enum machine_mode tmode;
4151      enum expand_modifier modifier;
4152      int ignore;
4153      int unlocked;
4154 {
4155   tree fn_fputc = unlocked ?
4156     built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4157   tree fn_fputs = unlocked ?
4158     built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4159   tree fn, format_arg, stripped_string;
4160
4161   /* If the return value is used, or the replacement _DECL isn't
4162      initialized, don't do the transformation.  */
4163   if (!ignore || !fn_fputc || !fn_fputs)
4164     return 0;
4165
4166   /* Verify the required arguments in the original call.  */
4167   if (arglist == 0
4168       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4169       || (TREE_CHAIN (arglist) == 0)
4170       || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4171           POINTER_TYPE))
4172     return 0;
4173
4174   /* Check the specifier vs. the parameters.  */
4175   if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4176     return 0;
4177
4178   format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4179   stripped_string = format_arg;
4180   STRIP_NOPS (stripped_string);
4181   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4182     stripped_string = TREE_OPERAND (stripped_string, 0);
4183
4184   /* If the format specifier isn't a STRING_CST, punt.  */
4185   if (TREE_CODE (stripped_string) != STRING_CST)
4186     return 0;
4187
4188   /* OK!  We can attempt optimization.  */
4189
4190   /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1).  */
4191   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4192     {
4193       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4194       arglist = tree_cons (NULL_TREE,
4195                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4196                            newarglist);
4197       fn = fn_fputs;
4198     }
4199   /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1).  */
4200   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4201     {
4202       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4203       arglist = tree_cons (NULL_TREE,
4204                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4205                            newarglist);
4206       fn = fn_fputc;
4207     }
4208   else
4209     {
4210       /* We can't handle anything else with % args or %% ... yet.  */
4211       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4212         return 0;
4213
4214       /* When "string" doesn't contain %, replace all cases of
4215          fprintf(stream,string) with fputs(string,stream).  The fputs
4216          builtin will take take of special cases like length==1.  */
4217       arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4218                            build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4219       fn = fn_fputs;
4220     }
4221
4222   return expand_expr (build_function_call (fn, arglist),
4223                       (ignore ? const0_rtx : target),
4224                       tmode, modifier);
4225 }
4226 \f
4227
4228 /* Given a boolean expression ARG, return a tree representing an increment
4229    or decrement (as indicated by CODE) of ARG.  The front end must check for
4230    invalid cases (e.g., decrement in C++).  */
4231 tree
4232 boolean_increment (code, arg)
4233      enum tree_code code;
4234      tree arg;
4235 {
4236   tree val;
4237   tree true_res = (c_language == clk_cplusplus
4238                    ? boolean_true_node
4239                    : c_bool_true_node);
4240   arg = stabilize_reference (arg);
4241   switch (code)
4242     {
4243     case PREINCREMENT_EXPR:
4244       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4245       break;
4246     case POSTINCREMENT_EXPR:
4247       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4248       arg = save_expr (arg);
4249       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4250       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4251       break;
4252     case PREDECREMENT_EXPR:
4253       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4254       break;
4255     case POSTDECREMENT_EXPR:
4256       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4257       arg = save_expr (arg);
4258       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4259       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4260       break;
4261     default:
4262       abort ();
4263     }
4264   TREE_SIDE_EFFECTS (val) = 1;
4265   return val;
4266 }
4267 \f
4268 /* Handle C and C++ default attributes.  */
4269
4270 enum built_in_attribute
4271 {
4272 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4273 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4274 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4275 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4276 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum.  */
4277 #include "builtin-attrs.def"
4278 #undef DEF_ATTR_NULL_TREE
4279 #undef DEF_ATTR_INT
4280 #undef DEF_ATTR_IDENT
4281 #undef DEF_ATTR_TREE_LIST
4282 #undef DEF_FN_ATTR
4283   ATTR_LAST
4284 };
4285
4286 static tree built_in_attributes[(int) ATTR_LAST];
4287
4288 static bool c_attrs_initialized = false;
4289
4290 static void c_init_attributes PARAMS ((void));
4291
4292 /* Common initialization before parsing options.  */
4293 void
4294 c_common_init_options (lang)
4295      enum c_language_kind lang;
4296 {
4297   c_language = lang;
4298   parse_in = cpp_create_reader (lang == clk_c || lang == clk_objective_c
4299                                 ? CLK_GNUC89 : CLK_GNUCXX);
4300   if (lang == clk_objective_c)
4301     cpp_get_options (parse_in)->objc = 1;
4302
4303   /* Mark as "unspecified" (see c_common_post_options).  */
4304   flag_bounds_check = -1;
4305 }
4306
4307 /* Post-switch processing.  */
4308 void
4309 c_common_post_options ()
4310 {
4311   cpp_post_options (parse_in);
4312
4313   flag_inline_trees = 1;
4314
4315   /* Use tree inlining if possible.  Function instrumentation is only
4316      done in the RTL level, so we disable tree inlining.  */
4317   if (! flag_instrument_function_entry_exit)
4318     {
4319       if (!flag_no_inline)
4320         flag_no_inline = 1;
4321       if (flag_inline_functions)
4322         {
4323           flag_inline_trees = 2;
4324           flag_inline_functions = 0;
4325         }
4326     }
4327
4328   /* If still "unspecified", make it match -fbounded-pointers.  */
4329   if (flag_bounds_check == -1)
4330     flag_bounds_check = flag_bounded_pointers;
4331
4332   /* Special format checking options don't work without -Wformat; warn if
4333      they are used.  */
4334   if (warn_format_y2k && !warn_format)
4335     warning ("-Wformat-y2k ignored without -Wformat");
4336   if (warn_format_extra_args && !warn_format)
4337     warning ("-Wformat-extra-args ignored without -Wformat");
4338   if (warn_format_zero_length && !warn_format)
4339     warning ("-Wformat-zero-length ignored without -Wformat");
4340   if (warn_format_nonliteral && !warn_format)
4341     warning ("-Wformat-nonliteral ignored without -Wformat");
4342   if (warn_format_security && !warn_format)
4343     warning ("-Wformat-security ignored without -Wformat");
4344   if (warn_missing_format_attribute && !warn_format)
4345     warning ("-Wmissing-format-attribute ignored without -Wformat");
4346
4347   /* If an error has occurred in cpplib, note it so we fail
4348      immediately.  */
4349   errorcount += cpp_errors (parse_in);
4350 }
4351
4352 /* Hook that registers front end and target-specific built-ins.  */
4353 static void
4354 cb_register_builtins (pfile)
4355      cpp_reader *pfile;
4356 {
4357   /* -undef turns off target-specific built-ins.  */
4358   if (flag_undef)
4359     return;
4360
4361   if (c_language == clk_cplusplus)
4362     {
4363       if (SUPPORTS_ONE_ONLY)
4364         cpp_define (pfile, "__GXX_WEAK__=1");
4365       else
4366         cpp_define (pfile, "__GXX_WEAK__=0");
4367     }
4368
4369   /* libgcc needs to know this.  */
4370   if (USING_SJLJ_EXCEPTIONS)
4371     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
4372
4373   /* stddef.h needs to know these.  */
4374   builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4375   builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4376   builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4377   builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4378
4379   /* For use in assembly language.  */
4380   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
4381   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
4382
4383   /* Misc.  */
4384   builtin_define_with_value ("__VERSION__", version_string, 1);
4385
4386   /* Other target-independent built-ins determined by command-line
4387      options.  */
4388   if (optimize_size)
4389     cpp_define (pfile, "__OPTIMIZE_SIZE__");
4390   if (optimize)
4391     cpp_define (pfile, "__OPTIMIZE__");
4392
4393   if (flag_hosted)
4394     cpp_define (pfile, "__STDC_HOSTED__=1");
4395   else
4396     cpp_define (pfile, "__STDC_HOSTED__=0");
4397
4398   if (fast_math_flags_set_p ())
4399     cpp_define (pfile, "__FAST_MATH__");
4400   if (flag_no_inline)
4401     cpp_define (pfile, "__NO_INLINE__");
4402
4403   if (flag_iso)
4404     cpp_define (pfile, "__STRICT_ANSI__");
4405
4406   if (!flag_signed_char)
4407     cpp_define (pfile, "__CHAR_UNSIGNED__");
4408
4409   /* A straightforward target hook doesn't work, because of problems
4410      linking that hook's body when part of non-C front ends.  */
4411 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
4412 # define builtin_define(TXT) cpp_define (pfile, TXT)
4413 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
4414   TARGET_CPU_CPP_BUILTINS ();
4415   TARGET_OS_CPP_BUILTINS ();
4416 }
4417
4418 /* Pass an object-like macro.  If it doesn't lie in the user's
4419    namespace, defines it unconditionally.  Otherwise define a version
4420    with two leading underscores, and another version with two leading
4421    and trailing underscores, and define the original only if an ISO
4422    standard was not nominated.
4423
4424    e.g. passing "unix" defines "__unix", "__unix__" and possibly
4425    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
4426    "_mips".  */
4427 void
4428 builtin_define_std (macro)
4429      const char *macro;
4430 {
4431   size_t len = strlen (macro);
4432   char *buff = alloca (len + 5);
4433   char *p = buff + 2;
4434   char *q = p + len;
4435
4436   /* prepend __ (or maybe just _) if in user's namespace.  */
4437   memcpy (p, macro, len + 1);
4438   if (*p != '_')
4439     *--p = '_';
4440   if (p[1] != '_' && !ISUPPER (p[1]))
4441     *--p = '_';
4442   cpp_define (parse_in, p);
4443
4444   /* If it was in user's namespace...  */
4445   if (p != buff + 2)
4446     {
4447       /* Define the macro with leading and following __.  */
4448       if (q[-1] != '_')
4449         *q++ = '_';
4450       if (q[-2] != '_')
4451         *q++ = '_';
4452       *q = '\0';
4453       cpp_define (parse_in, p);
4454
4455       /* Finally, define the original macro if permitted.  */
4456       if (!flag_iso)
4457         cpp_define (parse_in, macro);
4458     }
4459 }
4460
4461 /* Pass an object-like macro and a value to define it to.  The third
4462    parameter says whether or not to turn the value into a string
4463    constant.  */
4464 static void
4465 builtin_define_with_value (macro, expansion, is_str)
4466      const char *macro;
4467      const char *expansion;
4468      int is_str;
4469 {
4470   char *buf;
4471   size_t mlen = strlen (macro);
4472   size_t elen = strlen (expansion);
4473   size_t extra = 2;  /* space for an = and a NUL */
4474
4475   if (is_str)
4476     extra += 2;  /* space for two quote marks */
4477
4478   buf = alloca (mlen + elen + extra);
4479   if (is_str)
4480     sprintf (buf, "%s=\"%s\"", macro, expansion);
4481   else
4482     sprintf (buf, "%s=%s", macro, expansion);
4483
4484   cpp_define (parse_in, buf);
4485 }
4486
4487 /* Front end initialization common to C, ObjC and C++.  */
4488 const char *
4489 c_common_init (filename)
4490      const char *filename;
4491 {
4492   cpp_options *options = cpp_get_options (parse_in);
4493
4494   /* Set up preprocessor arithmetic.  Must be done after call to
4495      c_common_nodes_and_builtins for wchar_type_node to be good.  */
4496   options->precision = TYPE_PRECISION (intmax_type_node);
4497   options->char_precision = TYPE_PRECISION (char_type_node);
4498   options->int_precision = TYPE_PRECISION (integer_type_node);
4499   options->wchar_precision = TYPE_PRECISION (wchar_type_node);
4500   options->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);
4501   options->unsigned_char = !flag_signed_char;
4502   options->warn_multichar = warn_multichar;
4503   options->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
4504
4505   /* Register preprocessor built-ins before calls to
4506      cpp_main_file.  */
4507   cpp_get_callbacks (parse_in)->register_builtins = cb_register_builtins;
4508
4509   /* NULL is passed up to toplev.c and we exit quickly.  */
4510   if (flag_preprocess_only)
4511     {
4512       cpp_preprocess_file (parse_in);
4513       return NULL;
4514     }
4515
4516   /* Do this before initializing pragmas, as then cpplib's hash table
4517      has been set up.  */
4518   filename = init_c_lex (filename);
4519
4520   init_pragma ();
4521
4522   if (!c_attrs_initialized)
4523     c_init_attributes ();
4524
4525   return filename;
4526 }
4527
4528 /* Common finish hook for the C, ObjC and C++ front ends.  */
4529 void
4530 c_common_finish ()
4531 {
4532   cpp_finish (parse_in);
4533
4534   /* For performance, avoid tearing down cpplib's internal structures.
4535      Call cpp_errors () instead of cpp_destroy ().  */
4536   errorcount += cpp_errors (parse_in);
4537 }
4538
4539 static void
4540 c_init_attributes ()
4541 {
4542   /* Fill in the built_in_attributes array.  */
4543 #define DEF_ATTR_NULL_TREE(ENUM)                \
4544   built_in_attributes[(int) ENUM] = NULL_TREE;
4545 #define DEF_ATTR_INT(ENUM, VALUE)                                            \
4546   built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4547 #define DEF_ATTR_IDENT(ENUM, STRING)                            \
4548   built_in_attributes[(int) ENUM] = get_identifier (STRING);
4549 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4550   built_in_attributes[(int) ENUM]                       \
4551     = tree_cons (built_in_attributes[(int) PURPOSE],    \
4552                  built_in_attributes[(int) VALUE],      \
4553                  built_in_attributes[(int) CHAIN]);
4554 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed.  */
4555 #include "builtin-attrs.def"
4556 #undef DEF_ATTR_NULL_TREE
4557 #undef DEF_ATTR_INT
4558 #undef DEF_ATTR_IDENT
4559 #undef DEF_ATTR_TREE_LIST
4560 #undef DEF_FN_ATTR
4561   ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4562   c_attrs_initialized = true;
4563 }
4564
4565 /* Depending on the name of DECL, apply default attributes to it.  */
4566
4567 void
4568 c_common_insert_default_attributes (decl)
4569      tree decl;
4570 {
4571   tree name = DECL_NAME (decl);
4572
4573   if (!c_attrs_initialized)
4574     c_init_attributes ();
4575
4576 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization.  */
4577 #define DEF_ATTR_INT(ENUM, VALUE)
4578 #define DEF_ATTR_IDENT(ENUM, STRING)
4579 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4580 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE)                     \
4581   if ((PREDICATE) && name == built_in_attributes[(int) NAME])   \
4582     decl_attributes (&decl, built_in_attributes[(int) ATTRS],   \
4583                      ATTR_FLAG_BUILT_IN);
4584 #include "builtin-attrs.def"
4585 #undef DEF_ATTR_NULL_TREE
4586 #undef DEF_ATTR_INT
4587 #undef DEF_ATTR_IDENT
4588 #undef DEF_ATTR_TREE_LIST
4589 #undef DEF_FN_ATTR
4590 }
4591
4592 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4593    additionally give the location of the previous declaration DECL.  */
4594 void
4595 shadow_warning (msgid, name, decl)
4596      const char *msgid;
4597      tree name, decl;
4598 {
4599   warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4600   warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4601                               DECL_SOURCE_LINE (decl),
4602                               "shadowed declaration is here");
4603 }
4604
4605 /* Attribute handlers common to C front ends.  */
4606
4607 /* Handle a "packed" attribute; arguments as in
4608    struct attribute_spec.handler.  */
4609
4610 static tree
4611 handle_packed_attribute (node, name, args, flags, no_add_attrs)
4612      tree *node;
4613      tree name;
4614      tree args ATTRIBUTE_UNUSED;
4615      int flags;
4616      bool *no_add_attrs;
4617 {
4618   tree *type = NULL;
4619   if (DECL_P (*node))
4620     {
4621       if (TREE_CODE (*node) == TYPE_DECL)
4622         type = &TREE_TYPE (*node);
4623     }
4624   else
4625     type = node;
4626
4627   if (type)
4628     {
4629       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4630         *type = build_type_copy (*type);
4631       TYPE_PACKED (*type) = 1;
4632     }
4633   else if (TREE_CODE (*node) == FIELD_DECL)
4634     DECL_PACKED (*node) = 1;
4635   /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4636      used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
4637   else
4638     {
4639       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4640       *no_add_attrs = true;
4641     }
4642
4643   return NULL_TREE;
4644 }
4645
4646 /* Handle a "nocommon" attribute; arguments as in
4647    struct attribute_spec.handler.  */
4648
4649 static tree
4650 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
4651      tree *node;
4652      tree name;
4653      tree args ATTRIBUTE_UNUSED;
4654      int flags ATTRIBUTE_UNUSED;
4655      bool *no_add_attrs;
4656 {
4657   if (TREE_CODE (*node) == VAR_DECL)
4658     DECL_COMMON (*node) = 0;
4659   else
4660     {
4661       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4662       *no_add_attrs = true;
4663     }
4664
4665   return NULL_TREE;
4666 }
4667
4668 /* Handle a "common" attribute; arguments as in
4669    struct attribute_spec.handler.  */
4670
4671 static tree
4672 handle_common_attribute (node, name, args, flags, no_add_attrs)
4673      tree *node;
4674      tree name;
4675      tree args ATTRIBUTE_UNUSED;
4676      int flags ATTRIBUTE_UNUSED;
4677      bool *no_add_attrs;
4678 {
4679   if (TREE_CODE (*node) == VAR_DECL)
4680     DECL_COMMON (*node) = 1;
4681   else
4682     {
4683       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4684       *no_add_attrs = true;
4685     }
4686
4687   return NULL_TREE;
4688 }
4689
4690 /* Handle a "noreturn" attribute; arguments as in
4691    struct attribute_spec.handler.  */
4692
4693 static tree
4694 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
4695      tree *node;
4696      tree name;
4697      tree args ATTRIBUTE_UNUSED;
4698      int flags ATTRIBUTE_UNUSED;
4699      bool *no_add_attrs;
4700 {
4701   tree type = TREE_TYPE (*node);
4702
4703   /* See FIXME comment in c_common_attribute_table.  */
4704   if (TREE_CODE (*node) == FUNCTION_DECL)
4705     TREE_THIS_VOLATILE (*node) = 1;
4706   else if (TREE_CODE (type) == POINTER_TYPE
4707            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4708     TREE_TYPE (*node)
4709       = build_pointer_type
4710         (build_type_variant (TREE_TYPE (type),
4711                              TREE_READONLY (TREE_TYPE (type)), 1));
4712   else
4713     {
4714       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4715       *no_add_attrs = true;
4716     }
4717
4718   return NULL_TREE;
4719 }
4720
4721 /* Handle a "noinline" attribute; arguments as in
4722    struct attribute_spec.handler.  */
4723
4724 static tree
4725 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
4726      tree *node;
4727      tree name;
4728      tree args ATTRIBUTE_UNUSED;
4729      int flags ATTRIBUTE_UNUSED;
4730      bool *no_add_attrs;
4731 {
4732   if (TREE_CODE (*node) == FUNCTION_DECL)
4733     DECL_UNINLINABLE (*node) = 1;
4734   else
4735     {
4736       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4737       *no_add_attrs = true;
4738     }
4739
4740   return NULL_TREE;
4741 }
4742
4743 /* Handle a "always_inline" attribute; arguments as in
4744    struct attribute_spec.handler.  */
4745
4746 static tree
4747 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
4748      tree *node;
4749      tree name;
4750      tree args ATTRIBUTE_UNUSED;
4751      int flags ATTRIBUTE_UNUSED;
4752      bool *no_add_attrs;
4753 {
4754   if (TREE_CODE (*node) == FUNCTION_DECL)
4755     {
4756       /* Do nothing else, just set the attribute.  We'll get at
4757          it later with lookup_attribute.  */
4758     }
4759   else
4760     {
4761       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4762       *no_add_attrs = true;
4763     }
4764
4765   return NULL_TREE;
4766 }
4767
4768 /* Handle a "used" attribute; arguments as in
4769    struct attribute_spec.handler.  */
4770
4771 static tree
4772 handle_used_attribute (node, name, args, flags, no_add_attrs)
4773      tree *node;
4774      tree name;
4775      tree args ATTRIBUTE_UNUSED;
4776      int flags ATTRIBUTE_UNUSED;
4777      bool *no_add_attrs;
4778 {
4779   if (TREE_CODE (*node) == FUNCTION_DECL)
4780     TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
4781       = TREE_USED (*node) = 1;
4782   else
4783     {
4784       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4785       *no_add_attrs = true;
4786     }
4787
4788   return NULL_TREE;
4789 }
4790
4791 /* Handle a "unused" attribute; arguments as in
4792    struct attribute_spec.handler.  */
4793
4794 static tree
4795 handle_unused_attribute (node, name, args, flags, no_add_attrs)
4796      tree *node;
4797      tree name;
4798      tree args ATTRIBUTE_UNUSED;
4799      int flags;
4800      bool *no_add_attrs;
4801 {
4802   if (DECL_P (*node))
4803     {
4804       tree decl = *node;
4805
4806       if (TREE_CODE (decl) == PARM_DECL
4807           || TREE_CODE (decl) == VAR_DECL
4808           || TREE_CODE (decl) == FUNCTION_DECL
4809           || TREE_CODE (decl) == LABEL_DECL
4810           || TREE_CODE (decl) == TYPE_DECL)
4811         TREE_USED (decl) = 1;
4812       else
4813         {
4814           warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4815           *no_add_attrs = true;
4816         }
4817     }
4818   else
4819     {
4820       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4821         *node = build_type_copy (*node);
4822       TREE_USED (*node) = 1;
4823     }
4824
4825   return NULL_TREE;
4826 }
4827
4828 /* Handle a "const" attribute; arguments as in
4829    struct attribute_spec.handler.  */
4830
4831 static tree
4832 handle_const_attribute (node, name, args, flags, no_add_attrs)
4833      tree *node;
4834      tree name;
4835      tree args ATTRIBUTE_UNUSED;
4836      int flags ATTRIBUTE_UNUSED;
4837      bool *no_add_attrs;
4838 {
4839   tree type = TREE_TYPE (*node);
4840
4841   /* See FIXME comment on noreturn in c_common_attribute_table.  */
4842   if (TREE_CODE (*node) == FUNCTION_DECL)
4843     TREE_READONLY (*node) = 1;
4844   else if (TREE_CODE (type) == POINTER_TYPE
4845            && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4846     TREE_TYPE (*node)
4847       = build_pointer_type
4848         (build_type_variant (TREE_TYPE (type), 1,
4849                              TREE_THIS_VOLATILE (TREE_TYPE (type))));
4850   else
4851     {
4852       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4853       *no_add_attrs = true;
4854     }
4855
4856   return NULL_TREE;
4857 }
4858
4859 /* Handle a "transparent_union" attribute; arguments as in
4860    struct attribute_spec.handler.  */
4861
4862 static tree
4863 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
4864      tree *node;
4865      tree name;
4866      tree args ATTRIBUTE_UNUSED;
4867      int flags;
4868      bool *no_add_attrs;
4869 {
4870   tree decl = NULL_TREE;
4871   tree *type = NULL;
4872   int is_type = 0;
4873
4874   if (DECL_P (*node))
4875     {
4876       decl = *node;
4877       type = &TREE_TYPE (decl);
4878       is_type = TREE_CODE (*node) == TYPE_DECL;
4879     }
4880   else if (TYPE_P (*node))
4881     type = node, is_type = 1;
4882
4883   if (is_type
4884       && TREE_CODE (*type) == UNION_TYPE
4885       && (decl == 0
4886           || (TYPE_FIELDS (*type) != 0
4887               && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4888     {
4889       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4890         *type = build_type_copy (*type);
4891       TYPE_TRANSPARENT_UNION (*type) = 1;
4892     }
4893   else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4894            && TREE_CODE (*type) == UNION_TYPE
4895            && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4896     DECL_TRANSPARENT_UNION (decl) = 1;
4897   else
4898     {
4899       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4900       *no_add_attrs = true;
4901     }
4902
4903   return NULL_TREE;
4904 }
4905
4906 /* Handle a "constructor" attribute; arguments as in
4907    struct attribute_spec.handler.  */
4908
4909 static tree
4910 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
4911      tree *node;
4912      tree name;
4913      tree args ATTRIBUTE_UNUSED;
4914      int flags ATTRIBUTE_UNUSED;
4915      bool *no_add_attrs;
4916 {
4917   tree decl = *node;
4918   tree type = TREE_TYPE (decl);
4919
4920   if (TREE_CODE (decl) == FUNCTION_DECL
4921       && TREE_CODE (type) == FUNCTION_TYPE
4922       && decl_function_context (decl) == 0)
4923     {
4924       DECL_STATIC_CONSTRUCTOR (decl) = 1;
4925       TREE_USED (decl) = 1;
4926     }
4927   else
4928     {
4929       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4930       *no_add_attrs = true;
4931     }
4932
4933   return NULL_TREE;
4934 }
4935
4936 /* Handle a "destructor" attribute; arguments as in
4937    struct attribute_spec.handler.  */
4938
4939 static tree
4940 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
4941      tree *node;
4942      tree name;
4943      tree args ATTRIBUTE_UNUSED;
4944      int flags ATTRIBUTE_UNUSED;
4945      bool *no_add_attrs;
4946 {
4947   tree decl = *node;
4948   tree type = TREE_TYPE (decl);
4949
4950   if (TREE_CODE (decl) == FUNCTION_DECL
4951       && TREE_CODE (type) == FUNCTION_TYPE
4952       && decl_function_context (decl) == 0)
4953     {
4954       DECL_STATIC_DESTRUCTOR (decl) = 1;
4955       TREE_USED (decl) = 1;
4956     }
4957   else
4958     {
4959       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4960       *no_add_attrs = true;
4961     }
4962
4963   return NULL_TREE;
4964 }
4965
4966 /* Handle a "mode" attribute; arguments as in
4967    struct attribute_spec.handler.  */
4968
4969 static tree
4970 handle_mode_attribute (node, name, args, flags, no_add_attrs)
4971      tree *node;
4972      tree name;
4973      tree args;
4974      int flags ATTRIBUTE_UNUSED;
4975      bool *no_add_attrs;
4976 {
4977   tree type = *node;
4978
4979   *no_add_attrs = true;
4980
4981   if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4982     warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4983   else
4984     {
4985       int j;
4986       const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4987       int len = strlen (p);
4988       enum machine_mode mode = VOIDmode;
4989       tree typefm;
4990
4991       if (len > 4 && p[0] == '_' && p[1] == '_'
4992           && p[len - 1] == '_' && p[len - 2] == '_')
4993         {
4994           char *newp = (char *) alloca (len - 1);
4995
4996           strcpy (newp, &p[2]);
4997           newp[len - 4] = '\0';
4998           p = newp;
4999         }
5000
5001       /* Change this type to have a type with the specified mode.
5002          First check for the special modes.  */
5003       if (! strcmp (p, "byte"))
5004         mode = byte_mode;
5005       else if (!strcmp (p, "word"))
5006         mode = word_mode;
5007       else if (! strcmp (p, "pointer"))
5008         mode = ptr_mode;
5009       else
5010         for (j = 0; j < NUM_MACHINE_MODES; j++)
5011           if (!strcmp (p, GET_MODE_NAME (j)))
5012             mode = (enum machine_mode) j;
5013
5014       if (mode == VOIDmode)
5015         error ("unknown machine mode `%s'", p);
5016       else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
5017                      (mode, TREE_UNSIGNED (type))))
5018         error ("no data type for mode `%s'", p);
5019       else
5020         *node = typefm;
5021         /* No need to layout the type here.  The caller should do this.  */
5022     }
5023
5024   return NULL_TREE;
5025 }
5026
5027 /* Handle a "section" attribute; arguments as in
5028    struct attribute_spec.handler.  */
5029
5030 static tree
5031 handle_section_attribute (node, name, args, flags, no_add_attrs)
5032      tree *node;
5033      tree name ATTRIBUTE_UNUSED;
5034      tree args;
5035      int flags ATTRIBUTE_UNUSED;
5036      bool *no_add_attrs;
5037 {
5038   tree decl = *node;
5039
5040   if (targetm.have_named_sections)
5041     {
5042       if ((TREE_CODE (decl) == FUNCTION_DECL
5043            || TREE_CODE (decl) == VAR_DECL)
5044           && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
5045         {
5046           if (TREE_CODE (decl) == VAR_DECL
5047               && current_function_decl != NULL_TREE
5048               && ! TREE_STATIC (decl))
5049             {
5050               error_with_decl (decl,
5051                                "section attribute cannot be specified for local variables");
5052               *no_add_attrs = true;
5053             }
5054
5055           /* The decl may have already been given a section attribute
5056              from a previous declaration.  Ensure they match.  */
5057           else if (DECL_SECTION_NAME (decl) != NULL_TREE
5058                    && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5059                               TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
5060             {
5061               error_with_decl (*node,
5062                                "section of `%s' conflicts with previous declaration");
5063               *no_add_attrs = true;
5064             }
5065           else
5066             DECL_SECTION_NAME (decl) = TREE_VALUE (args);
5067         }
5068       else
5069         {
5070           error_with_decl (*node,
5071                            "section attribute not allowed for `%s'");
5072           *no_add_attrs = true;
5073         }
5074     }
5075   else
5076     {
5077       error_with_decl (*node,
5078                        "section attributes are not supported for this target");
5079       *no_add_attrs = true;
5080     }
5081
5082   return NULL_TREE;
5083 }
5084
5085 /* Handle a "aligned" attribute; arguments as in
5086    struct attribute_spec.handler.  */
5087
5088 static tree
5089 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
5090      tree *node;
5091      tree name ATTRIBUTE_UNUSED;
5092      tree args;
5093      int flags;
5094      bool *no_add_attrs;
5095 {
5096   tree decl = NULL_TREE;
5097   tree *type = NULL;
5098   int is_type = 0;
5099   tree align_expr = (args ? TREE_VALUE (args)
5100                      : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
5101   int i;
5102
5103   if (DECL_P (*node))
5104     {
5105       decl = *node;
5106       type = &TREE_TYPE (decl);
5107       is_type = TREE_CODE (*node) == TYPE_DECL;
5108     }
5109   else if (TYPE_P (*node))
5110     type = node, is_type = 1;
5111
5112   /* Strip any NOPs of any kind.  */
5113   while (TREE_CODE (align_expr) == NOP_EXPR
5114          || TREE_CODE (align_expr) == CONVERT_EXPR
5115          || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
5116     align_expr = TREE_OPERAND (align_expr, 0);
5117
5118   if (TREE_CODE (align_expr) != INTEGER_CST)
5119     {
5120       error ("requested alignment is not a constant");
5121       *no_add_attrs = true;
5122     }
5123   else if ((i = tree_log2 (align_expr)) == -1)
5124     {
5125       error ("requested alignment is not a power of 2");
5126       *no_add_attrs = true;
5127     }
5128   else if (i > HOST_BITS_PER_INT - 2)
5129     {
5130       error ("requested alignment is too large");
5131       *no_add_attrs = true;
5132     }
5133   else if (is_type)
5134     {
5135       /* If we have a TYPE_DECL, then copy the type, so that we
5136          don't accidentally modify a builtin type.  See pushdecl.  */
5137       if (decl && TREE_TYPE (decl) != error_mark_node
5138           && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
5139         {
5140           tree tt = TREE_TYPE (decl);
5141           *type = build_type_copy (*type);
5142           DECL_ORIGINAL_TYPE (decl) = tt;
5143           TYPE_NAME (*type) = decl;
5144           TREE_USED (*type) = TREE_USED (decl);
5145           TREE_TYPE (decl) = *type;
5146         }
5147       else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5148         *type = build_type_copy (*type);
5149
5150       TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
5151       TYPE_USER_ALIGN (*type) = 1;
5152     }
5153   else if (TREE_CODE (decl) != VAR_DECL
5154            && TREE_CODE (decl) != FIELD_DECL)
5155     {
5156       error_with_decl (decl,
5157                        "alignment may not be specified for `%s'");
5158       *no_add_attrs = true;
5159     }
5160   else
5161     {
5162       DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
5163       DECL_USER_ALIGN (decl) = 1;
5164     }
5165
5166   return NULL_TREE;
5167 }
5168
5169 /* Handle a "weak" attribute; arguments as in
5170    struct attribute_spec.handler.  */
5171
5172 static tree
5173 handle_weak_attribute (node, name, args, flags, no_add_attrs)
5174      tree *node;
5175      tree name ATTRIBUTE_UNUSED;
5176      tree args ATTRIBUTE_UNUSED;
5177      int flags ATTRIBUTE_UNUSED;
5178      bool *no_add_attrs ATTRIBUTE_UNUSED;
5179 {
5180   declare_weak (*node);
5181
5182   return NULL_TREE;
5183 }
5184
5185 /* Handle an "alias" attribute; arguments as in
5186    struct attribute_spec.handler.  */
5187
5188 static tree
5189 handle_alias_attribute (node, name, args, flags, no_add_attrs)
5190      tree *node;
5191      tree name;
5192      tree args;
5193      int flags ATTRIBUTE_UNUSED;
5194      bool *no_add_attrs;
5195 {
5196   tree decl = *node;
5197
5198   if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
5199       || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
5200     {
5201       error_with_decl (decl,
5202                        "`%s' defined both normally and as an alias");
5203       *no_add_attrs = true;
5204     }
5205   else if (decl_function_context (decl) == 0)
5206     {
5207       tree id;
5208
5209       id = TREE_VALUE (args);
5210       if (TREE_CODE (id) != STRING_CST)
5211         {
5212           error ("alias arg not a string");
5213           *no_add_attrs = true;
5214           return NULL_TREE;
5215         }
5216       id = get_identifier (TREE_STRING_POINTER (id));
5217       /* This counts as a use of the object pointed to.  */
5218       TREE_USED (id) = 1;
5219
5220       if (TREE_CODE (decl) == FUNCTION_DECL)
5221         DECL_INITIAL (decl) = error_mark_node;
5222       else
5223         DECL_EXTERNAL (decl) = 0;
5224     }
5225   else
5226     {
5227       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5228       *no_add_attrs = true;
5229     }
5230
5231   return NULL_TREE;
5232 }
5233
5234 /* Handle an "visibility" attribute; arguments as in
5235    struct attribute_spec.handler.  */
5236
5237 static tree
5238 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5239      tree *node;
5240      tree name;
5241      tree args;
5242      int flags ATTRIBUTE_UNUSED;
5243      bool *no_add_attrs;
5244 {
5245   tree decl = *node;
5246
5247   if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5248     {
5249       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5250       *no_add_attrs = true;
5251     }
5252   else
5253     {
5254       tree id;
5255
5256       id = TREE_VALUE (args);
5257       if (TREE_CODE (id) != STRING_CST)
5258         {
5259           error ("visibility arg not a string");
5260           *no_add_attrs = true;
5261           return NULL_TREE;
5262         }
5263       if (strcmp (TREE_STRING_POINTER (id), "hidden")
5264           && strcmp (TREE_STRING_POINTER (id), "protected")
5265           && strcmp (TREE_STRING_POINTER (id), "internal"))
5266         {
5267           error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5268           *no_add_attrs = true;
5269           return NULL_TREE;
5270         }
5271     }
5272
5273   return NULL_TREE;
5274 }
5275
5276 /* Handle a "no_instrument_function" attribute; arguments as in
5277    struct attribute_spec.handler.  */
5278
5279 static tree
5280 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5281      tree *node;
5282      tree name;
5283      tree args ATTRIBUTE_UNUSED;
5284      int flags ATTRIBUTE_UNUSED;
5285      bool *no_add_attrs;
5286 {
5287   tree decl = *node;
5288
5289   if (TREE_CODE (decl) != FUNCTION_DECL)
5290     {
5291       error_with_decl (decl,
5292                        "`%s' attribute applies only to functions",
5293                        IDENTIFIER_POINTER (name));
5294       *no_add_attrs = true;
5295     }
5296   else if (DECL_INITIAL (decl))
5297     {
5298       error_with_decl (decl,
5299                        "can't set `%s' attribute after definition",
5300                        IDENTIFIER_POINTER (name));
5301       *no_add_attrs = true;
5302     }
5303   else
5304     DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5305
5306   return NULL_TREE;
5307 }
5308
5309 /* Handle a "malloc" attribute; arguments as in
5310    struct attribute_spec.handler.  */
5311
5312 static tree
5313 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5314      tree *node;
5315      tree name;
5316      tree args ATTRIBUTE_UNUSED;
5317      int flags ATTRIBUTE_UNUSED;
5318      bool *no_add_attrs;
5319 {
5320   if (TREE_CODE (*node) == FUNCTION_DECL)
5321     DECL_IS_MALLOC (*node) = 1;
5322   /* ??? TODO: Support types.  */
5323   else
5324     {
5325       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5326       *no_add_attrs = true;
5327     }
5328
5329   return NULL_TREE;
5330 }
5331
5332 /* Handle a "no_limit_stack" attribute; arguments as in
5333    struct attribute_spec.handler.  */
5334
5335 static tree
5336 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5337      tree *node;
5338      tree name;
5339      tree args ATTRIBUTE_UNUSED;
5340      int flags ATTRIBUTE_UNUSED;
5341      bool *no_add_attrs;
5342 {
5343   tree decl = *node;
5344
5345   if (TREE_CODE (decl) != FUNCTION_DECL)
5346     {
5347       error_with_decl (decl,
5348                        "`%s' attribute applies only to functions",
5349                        IDENTIFIER_POINTER (name));
5350       *no_add_attrs = true;
5351     }
5352   else if (DECL_INITIAL (decl))
5353     {
5354       error_with_decl (decl,
5355                        "can't set `%s' attribute after definition",
5356                        IDENTIFIER_POINTER (name));
5357       *no_add_attrs = true;
5358     }
5359   else
5360     DECL_NO_LIMIT_STACK (decl) = 1;
5361
5362   return NULL_TREE;
5363 }
5364
5365 /* Handle a "pure" attribute; arguments as in
5366    struct attribute_spec.handler.  */
5367
5368 static tree
5369 handle_pure_attribute (node, name, args, flags, no_add_attrs)
5370      tree *node;
5371      tree name;
5372      tree args ATTRIBUTE_UNUSED;
5373      int flags ATTRIBUTE_UNUSED;
5374      bool *no_add_attrs;
5375 {
5376   if (TREE_CODE (*node) == FUNCTION_DECL)
5377     DECL_IS_PURE (*node) = 1;
5378   /* ??? TODO: Support types.  */
5379   else
5380     {
5381       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5382       *no_add_attrs = true;
5383     }
5384
5385   return NULL_TREE;
5386 }
5387
5388 /* Handle a "deprecated" attribute; arguments as in
5389    struct attribute_spec.handler.  */
5390
5391 static tree
5392 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
5393      tree *node;
5394      tree name;
5395      tree args ATTRIBUTE_UNUSED;
5396      int flags;
5397      bool *no_add_attrs;
5398 {
5399   tree type = NULL_TREE;
5400   int warn = 0;
5401   const char *what = NULL;
5402
5403   if (DECL_P (*node))
5404     {
5405       tree decl = *node;
5406       type = TREE_TYPE (decl);
5407
5408       if (TREE_CODE (decl) == TYPE_DECL
5409           || TREE_CODE (decl) == PARM_DECL
5410           || TREE_CODE (decl) == VAR_DECL
5411           || TREE_CODE (decl) == FUNCTION_DECL
5412           || TREE_CODE (decl) == FIELD_DECL)
5413         TREE_DEPRECATED (decl) = 1;
5414       else
5415         warn = 1;
5416     }
5417   else if (TYPE_P (*node))
5418     {
5419       if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5420         *node = build_type_copy (*node);
5421       TREE_DEPRECATED (*node) = 1;
5422       type = *node;
5423     }
5424   else
5425     warn = 1;
5426
5427   if (warn)
5428     {
5429       *no_add_attrs = true;
5430       if (type && TYPE_NAME (type))
5431         {
5432           if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5433             what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5434           else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5435                    && DECL_NAME (TYPE_NAME (type)))
5436             what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5437         }
5438       if (what)
5439         warning ("`%s' attribute ignored for `%s'",
5440                   IDENTIFIER_POINTER (name), what);
5441       else
5442         warning ("`%s' attribute ignored",
5443                       IDENTIFIER_POINTER (name));
5444     }
5445
5446   return NULL_TREE;
5447 }
5448
5449 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5450    to prevent us from duplicating type nodes unnecessarily.
5451    The normal mechanism to prevent duplicates is to use type_hash_canon, but
5452    since we want to distinguish types that are essentially identical (except
5453    for their debug representation), we use a local list here.  */
5454 static tree vector_type_node_list = 0;
5455
5456 /* Handle a "vector_size" attribute; arguments as in
5457    struct attribute_spec.handler.  */
5458
5459 static tree
5460 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
5461      tree *node;
5462      tree name;
5463      tree args;
5464      int flags ATTRIBUTE_UNUSED;
5465      bool *no_add_attrs;
5466 {
5467   unsigned HOST_WIDE_INT vecsize, nunits;
5468   enum machine_mode mode, orig_mode, new_mode;
5469   tree type = *node, new_type = NULL_TREE;
5470   tree type_list_node;
5471
5472   *no_add_attrs = true;
5473
5474   if (! host_integerp (TREE_VALUE (args), 1))
5475     {
5476       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5477       return NULL_TREE;
5478     }
5479
5480   /* Get the vector size (in bytes).  */
5481   vecsize = tree_low_cst (TREE_VALUE (args), 1);
5482
5483   /* We need to provide for vector pointers, vector arrays, and
5484      functions returning vectors.  For example:
5485
5486        __attribute__((vector_size(16))) short *foo;
5487
5488      In this case, the mode is SI, but the type being modified is
5489      HI, so we need to look further.  */
5490
5491   while (POINTER_TYPE_P (type)
5492          || TREE_CODE (type) == FUNCTION_TYPE
5493          || TREE_CODE (type) == ARRAY_TYPE)
5494     type = TREE_TYPE (type);
5495
5496   /* Get the mode of the type being modified.  */
5497   orig_mode = TYPE_MODE (type);
5498
5499   if (TREE_CODE (type) == RECORD_TYPE
5500       || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5501           && GET_MODE_CLASS (orig_mode) != MODE_INT)
5502       || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5503     {
5504       error ("invalid vector type for attribute `%s'",
5505              IDENTIFIER_POINTER (name));
5506       return NULL_TREE;
5507     }
5508
5509   /* Calculate how many units fit in the vector.  */
5510   nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5511
5512   /* Find a suitably sized vector.  */
5513   new_mode = VOIDmode;
5514   for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5515                                         ? MODE_VECTOR_INT
5516                                         : MODE_VECTOR_FLOAT);
5517        mode != VOIDmode;
5518        mode = GET_MODE_WIDER_MODE (mode))
5519     if (vecsize == GET_MODE_SIZE (mode)
5520         && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5521       {
5522         new_mode = mode;
5523         break;
5524       }
5525
5526     if (new_mode == VOIDmode)
5527     {
5528       error ("no vector mode with the size and type specified could be found");
5529       return NULL_TREE;
5530     }
5531
5532   for (type_list_node = vector_type_node_list; type_list_node;
5533        type_list_node = TREE_CHAIN (type_list_node))
5534     {
5535       tree other_type = TREE_VALUE (type_list_node);
5536       tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5537       tree fields = TYPE_FIELDS (record);
5538       tree field_type = TREE_TYPE (fields);
5539       tree array_type = TREE_TYPE (field_type);
5540       if (TREE_CODE (fields) != FIELD_DECL
5541           || TREE_CODE (field_type) != ARRAY_TYPE)
5542         abort ();
5543
5544       if (TYPE_MODE (other_type) == mode && type == array_type)
5545         {
5546           new_type = other_type;
5547           break;
5548         }
5549     }
5550
5551   if (new_type == NULL_TREE)
5552     {
5553       tree index, array, rt, list_node;
5554
5555       new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5556                                                     TREE_UNSIGNED (type));
5557
5558       if (!new_type)
5559         {
5560           error ("no vector mode with the size and type specified could be found");
5561           return NULL_TREE;
5562         }
5563
5564       new_type = build_type_copy (new_type);
5565
5566       /* Set the debug information here, because this is the only
5567          place where we know the underlying type for a vector made
5568          with vector_size.  For debugging purposes we pretend a vector
5569          is an array within a structure.  */
5570       index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5571       array = build_array_type (type, build_index_type (index));
5572       rt = make_node (RECORD_TYPE);
5573
5574       TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5575       DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5576       layout_type (rt);
5577       TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5578
5579       list_node = build_tree_list (NULL, new_type);
5580       TREE_CHAIN (list_node) = vector_type_node_list;
5581       vector_type_node_list = list_node;
5582     }
5583
5584   /* Build back pointers if needed.  */
5585   *node = vector_size_helper (*node, new_type);
5586
5587   return NULL_TREE;
5588 }
5589
5590 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
5591    better way.
5592
5593    If we requested a pointer to a vector, build up the pointers that
5594    we stripped off while looking for the inner type.  Similarly for
5595    return values from functions.
5596
5597    The argument "type" is the top of the chain, and "bottom" is the
5598    new type which we will point to.  */
5599
5600 static tree
5601 vector_size_helper (type, bottom)
5602      tree type, bottom;
5603 {
5604   tree inner, outer;
5605
5606   if (POINTER_TYPE_P (type))
5607     {
5608       inner = vector_size_helper (TREE_TYPE (type), bottom);
5609       outer = build_pointer_type (inner);
5610     }
5611   else if (TREE_CODE (type) == ARRAY_TYPE)
5612     {
5613       inner = vector_size_helper (TREE_TYPE (type), bottom);
5614       outer = build_array_type (inner, TYPE_VALUES (type));
5615     }
5616   else if (TREE_CODE (type) == FUNCTION_TYPE)
5617     {
5618       inner = vector_size_helper (TREE_TYPE (type), bottom);
5619       outer = build_function_type (inner, TYPE_VALUES (type));
5620     }
5621   else
5622     return bottom;
5623
5624   TREE_READONLY (outer) = TREE_READONLY (type);
5625   TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);
5626
5627   return outer;
5628 }
5629
5630 /* Handle the "nonnull" attribute.  */
5631 static tree
5632 handle_nonnull_attribute (node, name, args, flags, no_add_attrs)
5633      tree *node;
5634      tree name ATTRIBUTE_UNUSED;
5635      tree args;
5636      int flags ATTRIBUTE_UNUSED;
5637      bool *no_add_attrs;
5638 {
5639   tree type = *node;
5640   unsigned HOST_WIDE_INT attr_arg_num;
5641
5642   /* If no arguments are specified, all pointer arguments should be
5643      non-null.  Veryify a full prototype is given so that the arguments
5644      will have the correct types when we actually check them later.  */
5645   if (! args)
5646     {
5647       if (! TYPE_ARG_TYPES (type))
5648         {
5649           error ("nonnull attribute without arguments on a non-prototype");
5650           *no_add_attrs = true;
5651         }
5652       return NULL_TREE;
5653     }
5654
5655   /* Argument list specified.  Verify that each argument number references
5656      a pointer argument.  */
5657   for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5658     {
5659       tree argument;
5660       unsigned HOST_WIDE_INT arg_num, ck_num;
5661
5662       if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5663         {
5664           error ("nonnull argument has invalid operand number (arg %lu)",
5665                  (unsigned long) attr_arg_num);
5666           *no_add_attrs = true;
5667           return NULL_TREE;
5668         }
5669
5670       argument = TYPE_ARG_TYPES (type);
5671       if (argument)
5672         {
5673           for (ck_num = 1; ; ck_num++)
5674             {
5675               if (! argument || ck_num == arg_num)
5676                 break;
5677               argument = TREE_CHAIN (argument);
5678             }
5679
5680           if (! argument
5681               || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5682             {
5683               error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5684                      (unsigned long) attr_arg_num, (unsigned long) arg_num);
5685               *no_add_attrs = true;
5686               return NULL_TREE;
5687             }
5688
5689           if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5690             {
5691               error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5692                    (unsigned long) attr_arg_num, (unsigned long) arg_num);
5693               *no_add_attrs = true;
5694               return NULL_TREE;
5695             }
5696         }
5697     }
5698
5699   return NULL_TREE;
5700 }
5701
5702 /* Check the argument list of a function call for null in argument slots
5703    that are marked as requiring a non-null pointer argument.  */
5704
5705 static void
5706 check_function_nonnull (attrs, params)
5707      tree attrs;
5708      tree params;
5709 {
5710   tree a, args, param;
5711   int param_num;
5712
5713   for (a = attrs; a; a = TREE_CHAIN (a))
5714     {
5715       if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5716         {
5717           args = TREE_VALUE (a);
5718
5719           /* Walk the argument list.  If we encounter an argument number we
5720              should check for non-null, do it.  If the attribute has no args,
5721              then every pointer argument is checked (in which case the check
5722              for pointer type is done in check_nonnull_arg).  */
5723           for (param = params, param_num = 1; ;
5724                param_num++, param = TREE_CHAIN (param))
5725             {
5726               if (! param)
5727                 break;
5728               if (! args || nonnull_check_p (args, param_num))
5729                 check_function_arguments_recurse (check_nonnull_arg, NULL,
5730                                                   TREE_VALUE (param),
5731                                                   param_num);
5732             }
5733         }
5734     }
5735 }
5736
5737 /* Helper for check_function_nonnull; given a list of operands which
5738    must be non-null in ARGS, determine if operand PARAM_NUM should be
5739    checked.  */
5740
5741 static bool
5742 nonnull_check_p (args, param_num)
5743      tree args;
5744      unsigned HOST_WIDE_INT param_num;
5745 {
5746   unsigned HOST_WIDE_INT arg_num;
5747
5748   for (; args; args = TREE_CHAIN (args))
5749     {
5750       if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5751         abort ();
5752
5753       if (arg_num == param_num)
5754         return true;
5755     }
5756   return false;
5757 }
5758
5759 /* Check that the function argument PARAM (which is operand number
5760    PARAM_NUM) is non-null.  This is called by check_function_nonnull
5761    via check_function_arguments_recurse.  */
5762
5763 static void
5764 check_nonnull_arg (ctx, param, param_num)
5765      void *ctx ATTRIBUTE_UNUSED;
5766      tree param;
5767      unsigned HOST_WIDE_INT param_num;
5768 {
5769   /* Just skip checking the argument if it's not a pointer.  This can
5770      happen if the "nonnull" attribute was given without an operand
5771      list (which means to check every pointer argument).  */
5772
5773   if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5774     return;
5775
5776   if (integer_zerop (param))
5777     warning ("null argument where non-null required (arg %lu)",
5778              (unsigned long) param_num);
5779 }
5780
5781 /* Helper for nonnull attribute handling; fetch the operand number
5782    from the attribute argument list.  */
5783
5784 static bool
5785 get_nonnull_operand (arg_num_expr, valp)
5786      tree arg_num_expr;
5787      unsigned HOST_WIDE_INT *valp;
5788 {
5789   /* Strip any conversions from the arg number and verify they
5790      are constants.  */
5791   while (TREE_CODE (arg_num_expr) == NOP_EXPR
5792          || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5793          || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5794     arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5795
5796   if (TREE_CODE (arg_num_expr) != INTEGER_CST
5797       || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5798     return false;
5799
5800   *valp = TREE_INT_CST_LOW (arg_num_expr);
5801   return true;
5802 }
5803
5804 /* Handle a "nothrow" attribute; arguments as in
5805    struct attribute_spec.handler.  */
5806
5807 static tree
5808 handle_nothrow_attribute (node, name, args, flags, no_add_attrs)
5809      tree *node;
5810      tree name;
5811      tree args ATTRIBUTE_UNUSED;
5812      int flags ATTRIBUTE_UNUSED;
5813      bool *no_add_attrs;
5814 {
5815   if (TREE_CODE (*node) == FUNCTION_DECL)
5816     TREE_NOTHROW (*node) = 1;
5817   /* ??? TODO: Support types.  */
5818   else
5819     {
5820       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5821       *no_add_attrs = true;
5822     }
5823
5824   return NULL_TREE;
5825 }
5826 \f
5827 /* Check for valid arguments being passed to a function.  */
5828 void
5829 check_function_arguments (attrs, params)
5830      tree attrs;
5831      tree params;
5832 {
5833   /* Check for null being passed in a pointer argument that must be
5834      non-null.  We also need to do this if format checking is enabled.  */
5835
5836   if (warn_nonnull)
5837     check_function_nonnull (attrs, params);
5838
5839   /* Check for errors in format strings.  */
5840
5841   if (warn_format)
5842     check_function_format (NULL, attrs, params);
5843 }
5844
5845 /* Generic argument checking recursion routine.  PARAM is the argument to
5846    be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
5847    once the argument is resolved.  CTX is context for the callback.  */
5848 void
5849 check_function_arguments_recurse (callback, ctx, param, param_num)
5850      void (*callback) PARAMS ((void *, tree, unsigned HOST_WIDE_INT));
5851      void *ctx;
5852      tree param;
5853      unsigned HOST_WIDE_INT param_num;
5854 {
5855   if (TREE_CODE (param) == NOP_EXPR)
5856     {
5857       /* Strip coercion.  */
5858       check_function_arguments_recurse (callback, ctx,
5859                                         TREE_OPERAND (param, 0), param_num);
5860       return;
5861     }
5862
5863   if (TREE_CODE (param) == CALL_EXPR)
5864     {
5865       tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5866       tree attrs;
5867       bool found_format_arg = false;
5868
5869       /* See if this is a call to a known internationalization function
5870          that modifies a format arg.  Such a function may have multiple
5871          format_arg attributes (for example, ngettext).  */
5872
5873       for (attrs = TYPE_ATTRIBUTES (type);
5874            attrs;
5875            attrs = TREE_CHAIN (attrs))
5876         if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5877           {
5878             tree inner_args;
5879             tree format_num_expr;
5880             int format_num;
5881             int i;
5882
5883             /* Extract the argument number, which was previously checked
5884                to be valid.  */
5885             format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5886             while (TREE_CODE (format_num_expr) == NOP_EXPR
5887                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
5888                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5889               format_num_expr = TREE_OPERAND (format_num_expr, 0);
5890
5891             if (TREE_CODE (format_num_expr) != INTEGER_CST
5892                 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5893               abort ();
5894
5895             format_num = TREE_INT_CST_LOW (format_num_expr);
5896
5897             for (inner_args = TREE_OPERAND (param, 1), i = 1;
5898                  inner_args != 0;
5899                  inner_args = TREE_CHAIN (inner_args), i++)
5900               if (i == format_num)
5901                 {
5902                   check_function_arguments_recurse (callback, ctx,
5903                                                     TREE_VALUE (inner_args),
5904                                                     param_num);
5905                   found_format_arg = true;
5906                   break;
5907                 }
5908           }
5909
5910       /* If we found a format_arg attribute and did a recursive check,
5911          we are done with checking this argument.  Otherwise, we continue
5912          and this will be considered a non-literal.  */
5913       if (found_format_arg)
5914         return;
5915     }
5916
5917   if (TREE_CODE (param) == COND_EXPR)
5918     {
5919       /* Check both halves of the conditional expression.  */
5920       check_function_arguments_recurse (callback, ctx,
5921                                         TREE_OPERAND (param, 1), param_num);
5922       check_function_arguments_recurse (callback, ctx,
5923                                         TREE_OPERAND (param, 2), param_num);
5924       return;
5925     }
5926
5927   (*callback) (ctx, param, param_num);
5928 }