gcc/c-common.c

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