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