gcc/c-common.c

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