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