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, 2001
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 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 "tm_p.h"
  34 #include "obstack.h"
  35 #include "cpplib.h"
  36 #include "target.h"
  37 cpp_reader *parse_in;           /* Declared in c-lex.h.  */
  38
  39 #undef WCHAR_TYPE_SIZE
  40 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  41
  42 /* We let tm.h override the types used here, to handle trivial differences
  43    such as the choice of unsigned int or long unsigned int for size_t.
  44    When machines start needing nontrivial differences in the size type,
  45    it would be best to do something here to figure out automatically
  46    from other information what type to use.  */
  47
  48 #ifndef SIZE_TYPE
  49 #define SIZE_TYPE "long unsigned int"
  50 #endif
  51
  52 #ifndef WCHAR_TYPE
  53 #define WCHAR_TYPE "int"
  54 #endif
  55
  56 #ifndef PTRDIFF_TYPE
  57 #define PTRDIFF_TYPE "long int"
  58 #endif
  59
  60 #ifndef WINT_TYPE
  61 #define WINT_TYPE "unsigned int"
  62 #endif
  63
  64 #ifndef INTMAX_TYPE
  65 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
  66                      ? "int"                                    \
  67                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  68                         ? "long int"                            \
  69                         : "long long int"))
  70 #endif
  71
  72 #ifndef UINTMAX_TYPE
  73 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
  74                      ? "unsigned int"                           \
  75                      : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
  76                         ? "long unsigned int"                   \
  77                         : "long long unsigned int"))
  78 #endif
  79
  80 /* The following symbols are subsumed in the c_global_trees array, and
  81    listed here individually for documentation purposes.
  82
  83    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  84
  85         tree short_integer_type_node;
  86         tree long_integer_type_node;
  87         tree long_long_integer_type_node;
  88
  89         tree short_unsigned_type_node;
  90         tree long_unsigned_type_node;
  91         tree long_long_unsigned_type_node;
  92
  93         tree boolean_type_node;
  94         tree boolean_false_node;
  95         tree boolean_true_node;
  96
  97         tree ptrdiff_type_node;
  98
  99         tree unsigned_char_type_node;
 100         tree signed_char_type_node;
 101         tree wchar_type_node;
 102         tree signed_wchar_type_node;
 103         tree unsigned_wchar_type_node;
 104
 105         tree float_type_node;
 106         tree double_type_node;
 107         tree long_double_type_node;
 108
 109         tree complex_integer_type_node;
 110         tree complex_float_type_node;
 111         tree complex_double_type_node;
 112         tree complex_long_double_type_node;
 113
 114         tree intQI_type_node;
 115         tree intHI_type_node;
 116         tree intSI_type_node;
 117         tree intDI_type_node;
 118         tree intTI_type_node;
 119
 120         tree unsigned_intQI_type_node;
 121         tree unsigned_intHI_type_node;
 122         tree unsigned_intSI_type_node;
 123         tree unsigned_intDI_type_node;
 124         tree unsigned_intTI_type_node;
 125
 126         tree widest_integer_literal_type_node;
 127         tree widest_unsigned_literal_type_node;
 128
 129    Nodes for types `void *' and `const void *'.
 130
 131         tree ptr_type_node, const_ptr_type_node;
 132
 133    Nodes for types `char *' and `const char *'.
 134
 135         tree string_type_node, const_string_type_node;
 136
 137    Type `char[SOMENUMBER]'.
 138    Used when an array of char is needed and the size is irrelevant.
 139
 140         tree char_array_type_node;
 141
 142    Type `int[SOMENUMBER]' or something like it.
 143    Used when an array of int needed and the size is irrelevant.
 144
 145         tree int_array_type_node;
 146
 147    Type `wchar_t[SOMENUMBER]' or something like it.
 148    Used when a wide string literal is created.
 149
 150         tree wchar_array_type_node;
 151
 152    Type `int ()' -- used for implicit declaration of functions.
 153
 154         tree default_function_type;
 155
 156    A VOID_TYPE node, packaged in a TREE_LIST.
 157
 158         tree void_list_node;
 159
 160   The lazily created VAR_DECLS for __FUNCTION__, __PRETTY_FUNCTION__,
 161   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
 162   VAR_DECLS, but C++ does.)
 163
 164         tree function_name_decl_node;
 165         tree pretty_function_name_declnode;
 166         tree c99_function_name_decl_node;
 167
 168   Stack of nested function name VAR_DECLs.
 169
 170         tree saved_function_name_decls;
 171
 172 */
 173
 174 tree c_global_trees[CTI_MAX];
 175
 176 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 177
 178 int flag_no_builtin;
 179
 180 /* Nonzero means don't recognize the non-ANSI builtin functions.
 181    -ansi sets this.  */
 182
 183 int flag_no_nonansi_builtin;
 184
 185 /* Nonzero means give `double' the same size as `float'.  */
 186
 187 int flag_short_double;
 188
 189 /* Nonzero means give `wchar_t' the same size as `short'.  */
 190
 191 int flag_short_wchar;
 192
 193 /* Nonzero means warn about possible violations of sequence point rules.  */
 194
 195 int warn_sequence_point;
 196
 197 /* The elements of `ridpointers' are identifier nodes for the reserved
 198    type names and storage classes.  It is indexed by a RID_... value.  */
 199 tree *ridpointers;
 200
 201 tree (*make_fname_decl)                PARAMS ((tree, int));
 202
 203 /* If non-NULL, the address of a language-specific function that
 204    returns 1 for language-specific statement codes.  */
 205 int (*lang_statement_code_p)           PARAMS ((enum tree_code));
 206
 207 /* If non-NULL, the address of a language-specific function that takes
 208    any action required right before expand_function_end is called.  */
 209 void (*lang_expand_function_end)       PARAMS ((void));
 210
 211 /* If this variable is defined to a non-NULL value, it will be called
 212    after the file has been completely parsed.  */
 213 void (*back_end_hook) PARAMS ((tree));
 214
 215 /* Nonzero means the expression being parsed will never be evaluated.
 216    This is a count, since unevaluated expressions can nest.  */
 217 int skip_evaluation;
 218
 219 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
 220             A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
 221             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
 222             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS, A_MALLOC,
 223             A_NO_LIMIT_STACK, A_PURE};
 224
 225 /* Information about how a function name is generated. */
 226 struct fname_var_t
 227 {
 228   tree *decl;   /* pointer to the VAR_DECL. */
 229   unsigned rid; /* RID number for the identifier. */
 230   int pretty;   /* How pretty is it? */
 231 };
 232
 233 /* The three ways of getting then name of the current function. */
 234
 235 const struct fname_var_t fname_vars[] =
 236 {
 237   /* C99 compliant __func__, must be first. */
 238   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
 239   /* GCC __FUNCTION__ compliant. */
 240   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
 241   /* GCC __PRETTY_FUNCTION__ compliant. */
 242   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
 243   {NULL, 0, 0},
 244 };
 245
 246 static void add_attribute               PARAMS ((enum attrs, const char *,
 247                                                  int, int, int));
 248 static void init_attributes             PARAMS ((void));
 249 static int default_valid_lang_attribute PARAMS ((tree, tree, tree, tree));
 250 static int constant_fits_type_p         PARAMS ((tree, tree));
 251
 252 /* Keep a stack of if statements.  We record the number of compound
 253    statements seen up to the if keyword, as well as the line number
 254    and file of the if.  If a potentially ambiguous else is seen, that
 255    fact is recorded; the warning is issued when we can be sure that
 256    the enclosing if statement does not have an else branch.  */
 257 typedef struct
 258 {
 259   int compstmt_count;
 260   int line;
 261   const char *file;
 262   int needs_warning;
 263   tree if_stmt;
 264 } if_elt;
 265
 266 static if_elt *if_stack;
 267
 268 /* Amount of space in the if statement stack.  */
 269 static int if_stack_space = 0;
 270
 271 /* Stack pointer.  */
 272 static int if_stack_pointer = 0;
 273
 274 /* Record the start of an if-then, and record the start of it
 275    for ambiguous else detection.  */
 276
 277 void
 278 c_expand_start_cond (cond, compstmt_count)
 279      tree cond;
 280      int compstmt_count;
 281 {
 282   tree if_stmt;
 283
 284   /* Make sure there is enough space on the stack.  */
 285   if (if_stack_space == 0)
 286     {
 287       if_stack_space = 10;
 288       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 289     }
 290   else if (if_stack_space == if_stack_pointer)
 291     {
 292       if_stack_space += 10;
 293       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 294     }
 295
 296   if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 297   IF_COND (if_stmt) = cond;
 298   add_stmt (if_stmt);
 299
 300   /* Record this if statement.  */
 301   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 302   if_stack[if_stack_pointer].file = input_filename;
 303   if_stack[if_stack_pointer].line = lineno;
 304   if_stack[if_stack_pointer].needs_warning = 0;
 305   if_stack[if_stack_pointer].if_stmt = if_stmt;
 306   if_stack_pointer++;
 307 }
 308
 309 /* Called after the then-clause for an if-statement is processed.  */
 310
 311 void
 312 c_finish_then ()
 313 {
 314   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 315   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 316 }
 317
 318 /* Record the end of an if-then.  Optionally warn if a nested
 319    if statement had an ambiguous else clause.  */
 320
 321 void
 322 c_expand_end_cond ()
 323 {
 324   if_stack_pointer--;
 325   if (if_stack[if_stack_pointer].needs_warning)
 326     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 327                                 if_stack[if_stack_pointer].line,
 328                                 "suggest explicit braces to avoid ambiguous `else'");
 329   last_expr_type = NULL_TREE;
 330 }
 331
 332 /* Called between the then-clause and the else-clause
 333    of an if-then-else.  */
 334
 335 void
 336 c_expand_start_else ()
 337 {
 338   /* An ambiguous else warning must be generated for the enclosing if
 339      statement, unless we see an else branch for that one, too.  */
 340   if (warn_parentheses
 341       && if_stack_pointer > 1
 342       && (if_stack[if_stack_pointer - 1].compstmt_count
 343           == if_stack[if_stack_pointer - 2].compstmt_count))
 344     if_stack[if_stack_pointer - 2].needs_warning = 1;
 345
 346   /* Even if a nested if statement had an else branch, it can't be
 347      ambiguous if this one also has an else.  So don't warn in that
 348      case.  Also don't warn for any if statements nested in this else.  */
 349   if_stack[if_stack_pointer - 1].needs_warning = 0;
 350   if_stack[if_stack_pointer - 1].compstmt_count--;
 351 }
 352
 353 /* Called after the else-clause for an if-statement is processed.  */
 354
 355 void
 356 c_finish_else ()
 357 {
 358   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 359   RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 360 }
 361
 362 /* Push current bindings for the function name VAR_DECLS. */
 363
 364 void
 365 start_fname_decls ()
 366 {
 367   unsigned ix;
 368   tree saved = NULL_TREE;
 369
 370   for (ix = 0; fname_vars[ix].decl; ix++)
 371     {
 372       tree decl = *fname_vars[ix].decl;
 373
 374       if (decl)
 375         {
 376           saved = tree_cons (decl, build_int_2 (ix, 0), saved);
 377           *fname_vars[ix].decl = NULL_TREE;
 378         }
 379     }
 380   if (saved || saved_function_name_decls)
 381     /* Normally they'll have been NULL, so only push if we've got a
 382        stack, or they are non-NULL.  */
 383     saved_function_name_decls = tree_cons (saved, NULL_TREE,
 384                                            saved_function_name_decls);
 385 }
 386
 387 /* Finish up the current bindings, adding them into the
 388    current function's statement tree. This is done by wrapping the
 389    function's body in a COMPOUND_STMT containing these decls too. This
 390    must be done _before_ finish_stmt_tree is called. If there is no
 391    current function, we must be at file scope and no statements are
 392    involved. Pop the previous bindings. */
 393
 394 void
 395 finish_fname_decls ()
 396 {
 397   unsigned ix;
 398   tree body = NULL_TREE;
 399   tree stack = saved_function_name_decls;
 400
 401   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
 402     body = chainon (TREE_VALUE (stack), body);
 403
 404   if (body)
 405     {
 406       /* They were called into existance, so add to statement tree. */
 407       body = chainon (body,
 408                       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
 409       body = build_stmt (COMPOUND_STMT, body);
 410
 411       COMPOUND_STMT_NO_SCOPE (body) = 1;
 412       TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
 413     }
 414
 415   for (ix = 0; fname_vars[ix].decl; ix++)
 416     *fname_vars[ix].decl = NULL_TREE;
 417
 418   if (stack)
 419     {
 420       /* We had saved values, restore them. */
 421       tree saved;
 422
 423       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
 424         {
 425           tree decl = TREE_PURPOSE (saved);
 426           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
 427
 428           *fname_vars[ix].decl = decl;
 429         }
 430       stack = TREE_CHAIN (stack);
 431     }
 432   saved_function_name_decls = stack;
 433 }
 434
 435 /* Return the text name of the current function, suitable prettified
 436    by PRETTY_P. */
 437
 438 const char *
 439 fname_as_string (pretty_p)
 440      int pretty_p;
 441 {
 442   const char *name = NULL;
 443
 444   if (pretty_p)
 445     name = (current_function_decl
 446             ? (*decl_printable_name) (current_function_decl, 2)
 447             : "top level");
 448   else if (current_function_decl && DECL_NAME (current_function_decl))
 449     name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 450   else
 451     name = "";
 452   return name;
 453 }
 454
 455 /* Return the text name of the current function, formatted as
 456    required by the supplied RID value.  */
 457
 458 const char *
 459 fname_string (rid)
 460      unsigned rid;
 461 {
 462   unsigned ix;
 463
 464   for (ix = 0; fname_vars[ix].decl; ix++)
 465     if (fname_vars[ix].rid == rid)
 466       break;
 467   return fname_as_string (fname_vars[ix].pretty);
 468 }
 469
 470 /* Return the VAR_DECL for a const char array naming the current
 471    function. If the VAR_DECL has not yet been created, create it
 472    now. RID indicates how it should be formatted and IDENTIFIER_NODE
 473    ID is its name (unfortunately C and C++ hold the RID values of
 474    keywords in different places, so we can't derive RID from ID in
 475    this language independant code.  */
 476
 477 tree
 478 fname_decl (rid, id)
 479      unsigned rid;
 480      tree id;
 481 {
 482   unsigned ix;
 483   tree decl = NULL_TREE;
 484
 485   for (ix = 0; fname_vars[ix].decl; ix++)
 486     if (fname_vars[ix].rid == rid)
 487       break;
 488
 489   decl = *fname_vars[ix].decl;
 490   if (!decl)
 491     {
 492       tree saved_last_tree = last_tree;
 493
 494       decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
 495       if (last_tree != saved_last_tree)
 496         {
 497           /* We created some statement tree for the decl. This belongs
 498              at the start of the function, so remove it now and reinsert
 499              it after the function is complete. */
 500           tree stmts = TREE_CHAIN (saved_last_tree);
 501
 502           TREE_CHAIN (saved_last_tree) = NULL_TREE;
 503           last_tree = saved_last_tree;
 504           saved_function_name_decls = tree_cons (decl, stmts,
 505                                                  saved_function_name_decls);
 506         }
 507       *fname_vars[ix].decl = decl;
 508     }
 509   if (!ix && !current_function_decl)
 510     pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
 511
 512   return decl;
 513 }
 514
 515 /* Given a chain of STRING_CST nodes,
 516    concatenate them into one STRING_CST
 517    and give it a suitable array-of-chars data type.  */
 518
 519 tree
 520 combine_strings (strings)
 521      tree strings;
 522 {
 523   register tree value, t;
 524   register int length = 1;
 525   int wide_length = 0;
 526   int wide_flag = 0;
 527   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 528   int nchars;
 529   const int nchars_max = flag_isoc99 ? 4095 : 509;
 530
 531   if (TREE_CHAIN (strings))
 532     {
 533       /* More than one in the chain, so concatenate.  */
 534       register char *p, *q;
 535
 536       /* Don't include the \0 at the end of each substring,
 537          except for the last one.
 538          Count wide strings and ordinary strings separately.  */
 539       for (t = strings; t; t = TREE_CHAIN (t))
 540         {
 541           if (TREE_TYPE (t) == wchar_array_type_node)
 542             {
 543               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 544               wide_flag = 1;
 545             }
 546           else
 547             length += (TREE_STRING_LENGTH (t) - 1);
 548         }
 549
 550       /* If anything is wide, the non-wides will be converted,
 551          which makes them take more space.  */
 552       if (wide_flag)
 553         length = length * wchar_bytes + wide_length;
 554
 555       p = alloca (length);
 556
 557       /* Copy the individual strings into the new combined string.
 558          If the combined string is wide, convert the chars to ints
 559          for any individual strings that are not wide.  */
 560
 561       q = p;
 562       for (t = strings; t; t = TREE_CHAIN (t))
 563         {
 564           int len = (TREE_STRING_LENGTH (t)
 565                      - ((TREE_TYPE (t) == wchar_array_type_node)
 566                         ? wchar_bytes : 1));
 567           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 568             {
 569               memcpy (q, TREE_STRING_POINTER (t), len);
 570               q += len;
 571             }
 572           else
 573             {
 574               int i, j;
 575               for (i = 0; i < len; i++)
 576                 {
 577                   if (BYTES_BIG_ENDIAN)
 578                     {
 579                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 580                         *q++ = 0;
 581                       *q++ = TREE_STRING_POINTER (t)[i];
 582                     }
 583                   else
 584                     {
 585                       *q++ = TREE_STRING_POINTER (t)[i];
 586                       for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
 587                         *q++ = 0;
 588                     }
 589                 }
 590             }
 591         }
 592       if (wide_flag)
 593         {
 594           int i;
 595           for (i = 0; i < wchar_bytes; i++)
 596             *q++ = 0;
 597         }
 598       else
 599         *q = 0;
 600
 601       value = build_string (length, p);
 602     }
 603   else
 604     {
 605       value = strings;
 606       length = TREE_STRING_LENGTH (value);
 607       if (TREE_TYPE (value) == wchar_array_type_node)
 608         wide_flag = 1;
 609     }
 610
 611   /* Compute the number of elements, for the array type.  */
 612   nchars = wide_flag ? length / wchar_bytes : length;
 613
 614   if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
 615     pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
 616              nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
 617
 618   /* Create the array type for the string constant.
 619      -Wwrite-strings says make the string constant an array of const char
 620      so that copying it to a non-const pointer will get a warning.
 621      For C++, this is the standard behavior.  */
 622   if (flag_const_strings
 623       && (! flag_traditional  && ! flag_writable_strings))
 624     {
 625       tree elements
 626         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 627                               1, 0);
 628       TREE_TYPE (value)
 629         = build_array_type (elements,
 630                             build_index_type (build_int_2 (nchars - 1, 0)));
 631     }
 632   else
 633     TREE_TYPE (value)
 634       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 635                           build_index_type (build_int_2 (nchars - 1, 0)));
 636
 637   TREE_CONSTANT (value) = 1;
 638   TREE_READONLY (value) = ! flag_writable_strings;
 639   TREE_STATIC (value) = 1;
 640   return value;
 641 }
 642 \f
 643 /* To speed up processing of attributes, we maintain an array of
 644    IDENTIFIER_NODES and the corresponding attribute types.  */
 645
 646 /* Array to hold attribute information.  */
 647
 648 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 649
 650 static int attrtab_idx = 0;
 651
 652 /* Add an entry to the attribute table above.  */
 653
 654 static void
 655 add_attribute (id, string, min_len, max_len, decl_req)
 656      enum attrs id;
 657      const char *string;
 658      int min_len, max_len;
 659      int decl_req;
 660 {
 661   char buf[100];
 662
 663   attrtab[attrtab_idx].id = id;
 664   attrtab[attrtab_idx].name = get_identifier (string);
 665   attrtab[attrtab_idx].min = min_len;
 666   attrtab[attrtab_idx].max = max_len;
 667   attrtab[attrtab_idx++].decl_req = decl_req;
 668
 669   sprintf (buf, "__%s__", string);
 670
 671   attrtab[attrtab_idx].id = id;
 672   attrtab[attrtab_idx].name = get_identifier (buf);
 673   attrtab[attrtab_idx].min = min_len;
 674   attrtab[attrtab_idx].max = max_len;
 675   attrtab[attrtab_idx++].decl_req = decl_req;
 676 }
 677
 678 /* Initialize attribute table.  */
 679
 680 static void
 681 init_attributes ()
 682 {
 683   add_attribute (A_PACKED, "packed", 0, 0, 0);
 684   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 685   add_attribute (A_COMMON, "common", 0, 0, 1);
 686   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 687   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 688   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 689   add_attribute (A_CONST, "const", 0, 0, 1);
 690   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 691   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 692   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 693   add_attribute (A_MODE, "mode", 1, 1, 1);
 694   add_attribute (A_SECTION, "section", 1, 1, 1);
 695   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 696   add_attribute (A_FORMAT, "format", 3, 3, 1);
 697   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 698   add_attribute (A_WEAK, "weak", 0, 0, 1);
 699   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 700   add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
 701   add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
 702   add_attribute (A_MALLOC, "malloc", 0, 0, 1);
 703   add_attribute (A_NO_LIMIT_STACK, "no_stack_limit", 0, 0, 1);
 704   add_attribute (A_PURE, "pure", 0, 0, 1);
 705 }
 706 \f
 707 /* Default implementation of valid_lang_attribute, below.  By default, there
 708    are no language-specific attributes.  */
 709
 710 static int
 711 default_valid_lang_attribute (attr_name, attr_args, decl, type)
 712   tree attr_name ATTRIBUTE_UNUSED;
 713   tree attr_args ATTRIBUTE_UNUSED;
 714   tree decl ATTRIBUTE_UNUSED;
 715   tree type ATTRIBUTE_UNUSED;
 716 {
 717   return 0;
 718 }
 719
 720 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
 721    attribute for either declaration DECL or type TYPE and 0 otherwise.  */
 722
 723 int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree))
 724      = default_valid_lang_attribute;
 725
 726 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
 727    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
 728    it should be modified in place; if a TYPE, a copy should be created.
 729    FLAGS gives further information, in the form of a bitwise OR of flags
 730    in enum attribute_flags from c-common.h.  Depending on these flags,
 731    some attributes may be returned to be applied at a later stage (for
 732    example, to apply a decl attribute to the declaration rather than to
 733    its type).  */
 734
 735 tree
 736 decl_attributes (node, attributes, flags)
 737      tree *node, attributes;
 738      int flags ATTRIBUTE_UNUSED;
 739 {
 740   tree decl = 0, type = 0;
 741   int is_type = 0;
 742   tree a;
 743
 744   if (attrtab_idx == 0)
 745     init_attributes ();
 746
 747   if (DECL_P (*node))
 748     {
 749       decl = *node;
 750       type = TREE_TYPE (decl);
 751       is_type = TREE_CODE (*node) == TYPE_DECL;
 752     }
 753   else if (TYPE_P (*node))
 754     type = *node, is_type = 1;
 755
 756   (*targetm.insert_attributes) (*node, &attributes);
 757
 758   for (a = attributes; a; a = TREE_CHAIN (a))
 759     {
 760       tree name = TREE_PURPOSE (a);
 761       tree args = TREE_VALUE (a);
 762       int i;
 763       enum attrs id;
 764
 765       for (i = 0; i < attrtab_idx; i++)
 766         if (attrtab[i].name == name)
 767           break;
 768
 769       if (i == attrtab_idx)
 770         {
 771           if (! valid_machine_attribute (name, args, decl, type)
 772               && ! (* valid_lang_attribute) (name, args, decl, type))
 773             warning ("`%s' attribute directive ignored",
 774                      IDENTIFIER_POINTER (name));
 775           else if (decl != 0)
 776             type = TREE_TYPE (decl);
 777           continue;
 778         }
 779       else if (attrtab[i].decl_req && decl == 0)
 780         {
 781           warning ("`%s' attribute does not apply to types",
 782                    IDENTIFIER_POINTER (name));
 783           continue;
 784         }
 785       else if (list_length (args) < attrtab[i].min
 786                || list_length (args) > attrtab[i].max)
 787         {
 788           error ("wrong number of arguments specified for `%s' attribute",
 789                  IDENTIFIER_POINTER (name));
 790           continue;
 791         }
 792
 793       id = attrtab[i].id;
 794       switch (id)
 795         {
 796         case A_PACKED:
 797           if (is_type)
 798             TYPE_PACKED (type) = 1;
 799           else if (TREE_CODE (decl) == FIELD_DECL)
 800             DECL_PACKED (decl) = 1;
 801           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 802              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 803           else
 804             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 805           break;
 806
 807         case A_NOCOMMON:
 808           if (TREE_CODE (decl) == VAR_DECL)
 809             DECL_COMMON (decl) = 0;
 810           else
 811             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 812           break;
 813
 814         case A_COMMON:
 815           if (TREE_CODE (decl) == VAR_DECL)
 816             DECL_COMMON (decl) = 1;
 817           else
 818             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 819           break;
 820
 821         case A_NORETURN:
 822           if (TREE_CODE (decl) == FUNCTION_DECL)
 823             TREE_THIS_VOLATILE (decl) = 1;
 824           else if (TREE_CODE (type) == POINTER_TYPE
 825                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 826             TREE_TYPE (decl) = type
 827               = build_pointer_type
 828                 (build_type_variant (TREE_TYPE (type),
 829                                      TREE_READONLY (TREE_TYPE (type)), 1));
 830           else
 831             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 832           break;
 833
 834         case A_MALLOC:
 835           if (TREE_CODE (decl) == FUNCTION_DECL)
 836             DECL_IS_MALLOC (decl) = 1;
 837           /* ??? TODO: Support types.  */
 838           else
 839             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 840           break;
 841
 842         case A_UNUSED:
 843           if (is_type)
 844             if (decl)
 845               TREE_USED (decl) = 1;
 846             else
 847               TREE_USED (type) = 1;
 848           else if (TREE_CODE (decl) == PARM_DECL
 849                    || TREE_CODE (decl) == VAR_DECL
 850                    || TREE_CODE (decl) == FUNCTION_DECL
 851                    || TREE_CODE (decl) == LABEL_DECL)
 852             TREE_USED (decl) = 1;
 853           else
 854             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 855           break;
 856
 857         case A_CONST:
 858           if (TREE_CODE (decl) == FUNCTION_DECL)
 859             TREE_READONLY (decl) = 1;
 860           else if (TREE_CODE (type) == POINTER_TYPE
 861                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 862             TREE_TYPE (decl) = type
 863               = build_pointer_type
 864                 (build_type_variant (TREE_TYPE (type), 1,
 865                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 866           else
 867             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 868           break;
 869
 870         case A_PURE:
 871           if (TREE_CODE (decl) == FUNCTION_DECL)
 872             DECL_IS_PURE (decl) = 1;
 873           /* ??? TODO: Support types.  */
 874           else
 875             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 876           break;
 877
 878
 879         case A_T_UNION:
 880           if (is_type
 881               && TREE_CODE (type) == UNION_TYPE
 882               && (decl == 0
 883                   || (TYPE_FIELDS (type) != 0
 884                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 885             TYPE_TRANSPARENT_UNION (type) = 1;
 886           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 887                    && TREE_CODE (type) == UNION_TYPE
 888                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 889             DECL_TRANSPARENT_UNION (decl) = 1;
 890           else
 891             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 892           break;
 893
 894         case A_CONSTRUCTOR:
 895           if (TREE_CODE (decl) == FUNCTION_DECL
 896               && TREE_CODE (type) == FUNCTION_TYPE
 897               && decl_function_context (decl) == 0)
 898             {
 899               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 900               TREE_USED (decl) = 1;
 901             }
 902           else
 903             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 904           break;
 905
 906         case A_DESTRUCTOR:
 907           if (TREE_CODE (decl) == FUNCTION_DECL
 908               && TREE_CODE (type) == FUNCTION_TYPE
 909               && decl_function_context (decl) == 0)
 910             {
 911               DECL_STATIC_DESTRUCTOR (decl) = 1;
 912               TREE_USED (decl) = 1;
 913             }
 914           else
 915             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 916           break;
 917
 918         case A_MODE:
 919           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 920             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 921           else
 922             {
 923               int j;
 924               const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 925               int len = strlen (p);
 926               enum machine_mode mode = VOIDmode;
 927               tree typefm;
 928
 929               if (len > 4 && p[0] == '_' && p[1] == '_'
 930                   && p[len - 1] == '_' && p[len - 2] == '_')
 931                 {
 932                   char *newp = (char *) alloca (len - 1);
 933
 934                   strcpy (newp, &p[2]);
 935                   newp[len - 4] = '\0';
 936                   p = newp;
 937                 }
 938
 939               /* Give this decl a type with the specified mode.
 940                  First check for the special modes.  */
 941               if (! strcmp (p, "byte"))
 942                 mode = byte_mode;
 943               else if (!strcmp (p, "word"))
 944                 mode = word_mode;
 945               else if (! strcmp (p, "pointer"))
 946                 mode = ptr_mode;
 947               else
 948                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 949                   if (!strcmp (p, GET_MODE_NAME (j)))
 950                     mode = (enum machine_mode) j;
 951
 952               if (mode == VOIDmode)
 953                 error ("unknown machine mode `%s'", p);
 954               else if (0 == (typefm = type_for_mode (mode,
 955                                                      TREE_UNSIGNED (type))))
 956                 error ("no data type for mode `%s'", p);
 957               else
 958                 {
 959                   if (TYPE_PRECISION (typefm) > (TREE_UNSIGNED (type)
 960                                                  ? TYPE_PRECISION(uintmax_type_node)
 961                                                  : TYPE_PRECISION(intmax_type_node))
 962                       && pedantic)
 963                     pedwarn ("type with more precision than %s",
 964                              TREE_UNSIGNED (type) ? "uintmax_t" : "intmax_t");
 965                   TREE_TYPE (decl) = type = typefm;
 966                   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
 967                   if (TREE_CODE (decl) != FIELD_DECL)
 968                     layout_decl (decl, 0);
 969                 }
 970             }
 971           break;
 972
 973         case A_SECTION:
 974 #ifdef ASM_OUTPUT_SECTION_NAME
 975           if ((TREE_CODE (decl) == FUNCTION_DECL
 976                || TREE_CODE (decl) == VAR_DECL)
 977               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 978             {
 979               if (TREE_CODE (decl) == VAR_DECL
 980                   && current_function_decl != NULL_TREE
 981                   && ! TREE_STATIC (decl))
 982                 error_with_decl (decl,
 983                   "section attribute cannot be specified for local variables");
 984               /* The decl may have already been given a section attribute from
 985                  a previous declaration.  Ensure they match.  */
 986               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 987                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 988                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 989                 error_with_decl (*node,
 990                                  "section of `%s' conflicts with previous declaration");
 991               else
 992                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 993             }
 994           else
 995             error_with_decl (*node,
 996                            "section attribute not allowed for `%s'");
 997 #else
 998           error_with_decl (*node,
 999                   "section attributes are not supported for this target");
1000 #endif
1001           break;
1002
1003         case A_ALIGNED:
1004           {
1005             tree align_expr
1006               = (args ? TREE_VALUE (args)
1007                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1008             int i;
1009
1010             /* Strip any NOPs of any kind.  */
1011             while (TREE_CODE (align_expr) == NOP_EXPR
1012                    || TREE_CODE (align_expr) == CONVERT_EXPR
1013                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
1014               align_expr = TREE_OPERAND (align_expr, 0);
1015
1016             if (TREE_CODE (align_expr) != INTEGER_CST)
1017               {
1018                 error ("requested alignment is not a constant");
1019                 continue;
1020               }
1021
1022             if ((i = tree_log2 (align_expr)) == -1)
1023               error ("requested alignment is not a power of 2");
1024             else if (i > HOST_BITS_PER_INT - 2)
1025               error ("requested alignment is too large");
1026             else if (is_type)
1027               {
1028                 /* If we have a TYPE_DECL, then copy the type, so that we
1029                    don't accidentally modify a builtin type.  See pushdecl.  */
1030                 if (decl && TREE_TYPE (decl) != error_mark_node
1031                     && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
1032                   {
1033                     tree tt = TREE_TYPE (decl);
1034                     DECL_ORIGINAL_TYPE (decl) = tt;
1035                     tt = build_type_copy (tt);
1036                     TYPE_NAME (tt) = decl;
1037                     TREE_USED (tt) = TREE_USED (decl);
1038                     TREE_TYPE (decl) = tt;
1039                     type = tt;
1040                   }
1041
1042                 TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
1043                 TYPE_USER_ALIGN (type) = 1;
1044               }
1045             else if (TREE_CODE (decl) != VAR_DECL
1046                      && TREE_CODE (decl) != FIELD_DECL)
1047               error_with_decl (decl,
1048                                "alignment may not be specified for `%s'");
1049             else
1050               {
1051                 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
1052                 DECL_USER_ALIGN (decl) = 1;
1053               }
1054           }
1055           break;
1056
1057         case A_FORMAT:
1058           decl_handle_format_attribute (decl, args);
1059           break;
1060
1061         case A_FORMAT_ARG:
1062           decl_handle_format_arg_attribute (decl, args);
1063           break;
1064
1065         case A_WEAK:
1066           declare_weak (decl);
1067           break;
1068
1069         case A_ALIAS:
1070           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
1071               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
1072             error_with_decl (decl,
1073                              "`%s' defined both normally and as an alias");
1074           else if (decl_function_context (decl) == 0)
1075             {
1076               tree id;
1077
1078               id = TREE_VALUE (args);
1079               if (TREE_CODE (id) != STRING_CST)
1080                 {
1081                   error ("alias arg not a string");
1082                   break;
1083                 }
1084               id = get_identifier (TREE_STRING_POINTER (id));
1085               /* This counts as a use of the object pointed to.  */
1086               TREE_USED (id) = 1;
1087
1088               if (TREE_CODE (decl) == FUNCTION_DECL)
1089                 DECL_INITIAL (decl) = error_mark_node;
1090               else
1091                 DECL_EXTERNAL (decl) = 0;
1092               assemble_alias (decl, id);
1093             }
1094           else
1095             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1096           break;
1097
1098         case A_NO_CHECK_MEMORY_USAGE:
1099           if (TREE_CODE (decl) != FUNCTION_DECL)
1100             {
1101               error_with_decl (decl,
1102                                "`%s' attribute applies only to functions",
1103                                IDENTIFIER_POINTER (name));
1104             }
1105           else if (DECL_INITIAL (decl))
1106             {
1107               error_with_decl (decl,
1108                                "can't set `%s' attribute after definition",
1109                                IDENTIFIER_POINTER (name));
1110             }
1111           else
1112             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1113           break;
1114
1115         case A_NO_INSTRUMENT_FUNCTION:
1116           if (TREE_CODE (decl) != FUNCTION_DECL)
1117             {
1118               error_with_decl (decl,
1119                                "`%s' attribute applies only to functions",
1120                                IDENTIFIER_POINTER (name));
1121             }
1122           else if (DECL_INITIAL (decl))
1123             {
1124               error_with_decl (decl,
1125                                "can't set `%s' attribute after definition",
1126                                IDENTIFIER_POINTER (name));
1127             }
1128           else
1129             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1130           break;
1131
1132         case A_NO_LIMIT_STACK:
1133           if (TREE_CODE (decl) != FUNCTION_DECL)
1134             {
1135               error_with_decl (decl,
1136                                "`%s' attribute applies only to functions",
1137                                IDENTIFIER_POINTER (name));
1138             }
1139           else if (DECL_INITIAL (decl))
1140             {
1141               error_with_decl (decl,
1142                                "can't set `%s' attribute after definition",
1143                                IDENTIFIER_POINTER (name));
1144             }
1145           else
1146             DECL_NO_LIMIT_STACK (decl) = 1;
1147           break;
1148         }
1149     }
1150   return NULL_TREE;
1151 }
1152
1153 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1154    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1155
1156    The head of the declspec list is stored in DECLSPECS.
1157    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1158
1159    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1160    the list elements.  We drop the containing TREE_LIST nodes and link the
1161    resulting attributes together the way decl_attributes expects them.  */
1162
1163 void
1164 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1165      tree specs_attrs;
1166      tree *declspecs, *prefix_attributes;
1167 {
1168   tree t, s, a, next, specs, attrs;
1169
1170   /* This can happen after an __extension__ in pedantic mode.  */
1171   if (specs_attrs != NULL_TREE
1172       && TREE_CODE (specs_attrs) == INTEGER_CST)
1173     {
1174       *declspecs = NULL_TREE;
1175       *prefix_attributes = NULL_TREE;
1176       return;
1177     }
1178
1179   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1180   if (specs_attrs != NULL_TREE
1181       && TREE_CODE (specs_attrs) != TREE_LIST)
1182     {
1183       *declspecs = specs_attrs;
1184       *prefix_attributes = NULL_TREE;
1185       return;
1186     }
1187
1188   /* Remember to keep the lists in the same order, element-wise.  */
1189
1190   specs = s = NULL_TREE;
1191   attrs = a = NULL_TREE;
1192   for (t = specs_attrs; t; t = next)
1193     {
1194       next = TREE_CHAIN (t);
1195       /* Declspecs have a non-NULL TREE_VALUE.  */
1196       if (TREE_VALUE (t) != NULL_TREE)
1197         {
1198           if (specs == NULL_TREE)
1199             specs = s = t;
1200           else
1201             {
1202               TREE_CHAIN (s) = t;
1203               s = t;
1204             }
1205         }
1206       else
1207         {
1208           if (attrs == NULL_TREE)
1209             attrs = a = TREE_PURPOSE (t);
1210           else
1211             {
1212               TREE_CHAIN (a) = TREE_PURPOSE (t);
1213               a = TREE_PURPOSE (t);
1214             }
1215           /* More attrs can be linked here, move A to the end.  */
1216           while (TREE_CHAIN (a) != NULL_TREE)
1217             a = TREE_CHAIN (a);
1218         }
1219     }
1220
1221   /* Terminate the lists.  */
1222   if (s != NULL_TREE)
1223     TREE_CHAIN (s) = NULL_TREE;
1224   if (a != NULL_TREE)
1225     TREE_CHAIN (a) = NULL_TREE;
1226
1227   /* All done.  */
1228   *declspecs = specs;
1229   *prefix_attributes = attrs;
1230 }
1231
1232 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1233    This function is used by the parser when a rule will accept attributes
1234    in a particular position, but we don't want to support that just yet.
1235
1236    A warning is issued for every ignored attribute.  */
1237
1238 tree
1239 strip_attrs (specs_attrs)
1240      tree specs_attrs;
1241 {
1242   tree specs, attrs;
1243
1244   split_specs_attrs (specs_attrs, &specs, &attrs);
1245
1246   while (attrs)
1247     {
1248       warning ("`%s' attribute ignored",
1249                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1250       attrs = TREE_CHAIN (attrs);
1251     }
1252
1253   return specs;
1254 }
1255 \f
1256 static int is_valid_printf_arglist PARAMS ((tree));
1257 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1258 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1259                                             enum expand_modifier, int));
1260 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1261                                              enum expand_modifier, int));
1262 \f
1263 /* Print a warning if a constant expression had overflow in folding.
1264    Invoke this function on every expression that the language
1265    requires to be a constant expression.
1266    Note the ANSI C standard says it is erroneous for a
1267    constant expression to overflow.  */
1268
1269 void
1270 constant_expression_warning (value)
1271      tree value;
1272 {
1273   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1274        || TREE_CODE (value) == COMPLEX_CST)
1275       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1276     pedwarn ("overflow in constant expression");
1277 }
1278
1279 /* Print a warning if an expression had overflow in folding.
1280    Invoke this function on every expression that
1281    (1) appears in the source code, and
1282    (2) might be a constant expression that overflowed, and
1283    (3) is not already checked by convert_and_check;
1284    however, do not invoke this function on operands of explicit casts.  */
1285
1286 void
1287 overflow_warning (value)
1288      tree value;
1289 {
1290   if ((TREE_CODE (value) == INTEGER_CST
1291        || (TREE_CODE (value) == COMPLEX_CST
1292            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1293       && TREE_OVERFLOW (value))
1294     {
1295       TREE_OVERFLOW (value) = 0;
1296       if (skip_evaluation == 0)
1297         warning ("integer overflow in expression");
1298     }
1299   else if ((TREE_CODE (value) == REAL_CST
1300             || (TREE_CODE (value) == COMPLEX_CST
1301                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1302            && TREE_OVERFLOW (value))
1303     {
1304       TREE_OVERFLOW (value) = 0;
1305       if (skip_evaluation == 0)
1306         warning ("floating point overflow in expression");
1307     }
1308 }
1309
1310 /* Print a warning if a large constant is truncated to unsigned,
1311    or if -Wconversion is used and a constant < 0 is converted to unsigned.
1312    Invoke this function on every expression that might be implicitly
1313    converted to an unsigned type.  */
1314
1315 void
1316 unsigned_conversion_warning (result, operand)
1317      tree result, operand;
1318 {
1319   if (TREE_CODE (operand) == INTEGER_CST
1320       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
1321       && TREE_UNSIGNED (TREE_TYPE (result))
1322       && skip_evaluation == 0
1323       && !int_fits_type_p (operand, TREE_TYPE (result)))
1324     {
1325       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
1326         /* This detects cases like converting -129 or 256 to unsigned char.  */
1327         warning ("large integer implicitly truncated to unsigned type");
1328       else if (warn_conversion)
1329         warning ("negative integer implicitly converted to unsigned type");
1330     }
1331 }
1332
1333 /* Nonzero if constant C has a value that is permissible
1334    for type TYPE (an INTEGER_TYPE).  */
1335
1336 static int
1337 constant_fits_type_p (c, type)
1338      tree c, type;
1339 {
1340   if (TREE_CODE (c) == INTEGER_CST)
1341     return int_fits_type_p (c, type);
1342
1343   c = convert (type, c);
1344   return !TREE_OVERFLOW (c);
1345 }
1346
1347 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1348    Invoke this function on every expression that is converted implicitly,
1349    i.e. because of language rules and not because of an explicit cast.  */
1350
1351 tree
1352 convert_and_check (type, expr)
1353      tree type, expr;
1354 {
1355   tree t = convert (type, expr);
1356   if (TREE_CODE (t) == INTEGER_CST)
1357     {
1358       if (TREE_OVERFLOW (t))
1359         {
1360           TREE_OVERFLOW (t) = 0;
1361
1362           /* Do not diagnose overflow in a constant expression merely
1363              because a conversion overflowed.  */
1364           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1365
1366           /* No warning for converting 0x80000000 to int.  */
1367           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1368                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1369                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1370             /* If EXPR fits in the unsigned version of TYPE,
1371                don't warn unless pedantic.  */
1372             if ((pedantic
1373                  || TREE_UNSIGNED (type)
1374                  || ! constant_fits_type_p (expr, unsigned_type (type)))
1375                 && skip_evaluation == 0)
1376               warning ("overflow in implicit constant conversion");
1377         }
1378       else
1379         unsigned_conversion_warning (t, expr);
1380     }
1381   return t;
1382 }
1383 \f
1384 /* A node in a list that describes references to variables (EXPR), which are
1385    either read accesses if WRITER is zero, or write accesses, in which case
1386    WRITER is the parent of EXPR.  */
1387 struct tlist
1388 {
1389   struct tlist *next;
1390   tree expr, writer;
1391 };
1392
1393 /* Used to implement a cache the results of a call to verify_tree.  We only
1394    use this for SAVE_EXPRs.  */
1395 struct tlist_cache
1396 {
1397   struct tlist_cache *next;
1398   struct tlist *cache_before_sp;
1399   struct tlist *cache_after_sp;
1400   tree expr;
1401 };
1402
1403 /* Obstack to use when allocating tlist structures, and corresponding
1404    firstobj.  */
1405 static struct obstack tlist_obstack;
1406 static char *tlist_firstobj = 0;
1407
1408 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1409    warnings.  */
1410 static struct tlist *warned_ids;
1411 /* SAVE_EXPRs need special treatment.  We process them only once and then
1412    cache the results.  */
1413 static struct tlist_cache *save_expr_cache;
1414
1415 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1416 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1417 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1418 static int warning_candidate_p PARAMS ((tree));
1419 static void warn_for_collisions PARAMS ((struct tlist *));
1420 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1421 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1422 static void verify_sequence_points PARAMS ((tree));
1423
1424 /* Create a new struct tlist and fill in its fields.  */
1425 static struct tlist *
1426 new_tlist (next, t, writer)
1427      struct tlist *next;
1428      tree t;
1429      tree writer;
1430 {
1431   struct tlist *l;
1432   l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1433   l->next = next;
1434   l->expr = t;
1435   l->writer = writer;
1436   return l;
1437 }
1438
1439 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1440    is nonnull, we ignore any node we find which has a writer equal to it.  */
1441
1442 static void
1443 add_tlist (to, add, exclude_writer, copy)
1444      struct tlist **to;
1445      struct tlist *add;
1446      tree exclude_writer;
1447      int copy;
1448 {
1449   while (add)
1450     {
1451       struct tlist *next = add->next;
1452       if (! copy)
1453         add->next = *to;
1454       if (! exclude_writer || add->writer != exclude_writer)
1455         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1456       add = next;
1457     }
1458 }
1459
1460 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1461    each variable that already exists in TO, no new node is added; however if
1462    there is a write access recorded in ADD, and an occurrence on TO is only
1463    a read access, then the occurrence in TO will be modified to record the
1464    write.  */
1465
1466 static void
1467 merge_tlist (to, add, copy)
1468      struct tlist **to;
1469      struct tlist *add;
1470      int copy;
1471 {
1472   struct tlist **end = to;
1473
1474   while (*end)
1475     end = &(*end)->next;
1476
1477   while (add)
1478     {
1479       int found = 0;
1480       struct tlist *tmp2;
1481       struct tlist *next = add->next;
1482
1483       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1484         if (tmp2->expr == add->expr)
1485           {
1486             found = 1;
1487             if (! tmp2->writer)
1488               tmp2->writer = add->writer;
1489           }
1490       if (! found)
1491         {
1492           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1493           end = &(*end)->next;
1494           *end = 0;
1495         }
1496       add = next;
1497     }
1498 }
1499
1500 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1501    references in list LIST conflict with it, excluding reads if ONLY writers
1502    is nonzero.  */
1503
1504 static void
1505 warn_for_collisions_1 (written, writer, list, only_writes)
1506      tree written, writer;
1507      struct tlist *list;
1508      int only_writes;
1509 {
1510   struct tlist *tmp;
1511
1512   /* Avoid duplicate warnings.  */
1513   for (tmp = warned_ids; tmp; tmp = tmp->next)
1514     if (tmp->expr == written)
1515       return;
1516
1517   while (list)
1518     {
1519       if (list->expr == written
1520           && list->writer != writer
1521           && (! only_writes || list->writer))
1522         {
1523           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1524           warning ("operation on `%s' may be undefined",
1525                    IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1526         }
1527       list = list->next;
1528     }
1529 }
1530
1531 /* Given a list LIST of references to variables, find whether any of these
1532    can cause conflicts due to missing sequence points.  */
1533
1534 static void
1535 warn_for_collisions (list)
1536      struct tlist *list;
1537 {
1538   struct tlist *tmp;
1539
1540   for (tmp = list; tmp; tmp = tmp->next)
1541     {
1542       if (tmp->writer)
1543         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1544     }
1545 }
1546
1547 /* Return nonzero if X is a tree that can be verified by the sequence poitn
1548    warnings.  */
1549 static int
1550 warning_candidate_p (x)
1551      tree x;
1552 {
1553   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1554 }
1555
1556 /* Walk the tree X, and record accesses to variables.  If X is written by the
1557    parent tree, WRITER is the parent.
1558    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1559    expression or its only operand forces a sequence point, then everything up
1560    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1561    in PNO_SP.
1562    Once we return, we will have emitted warnings if any subexpression before
1563    such a sequence point could be undefined.  On a higher level, however, the
1564    sequence point may not be relevant, and we'll merge the two lists.
1565
1566    Example: (b++, a) + b;
1567    The call that processes the COMPOUND_EXPR will store the increment of B
1568    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1569    processes the PLUS_EXPR will need to merge the two lists so that
1570    eventually, all accesses end up on the same list (and we'll warn about the
1571    unordered subexpressions b++ and b.
1572
1573    A note on merging.  If we modify the former example so that our expression
1574    becomes
1575      (b++, b) + a
1576    care must be taken not simply to add all three expressions into the final
1577    PNO_SP list.  The function merge_tlist takes care of that by merging the
1578    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1579    way, so that no more than one access to B is recorded.  */
1580
1581 static void
1582 verify_tree (x, pbefore_sp, pno_sp, writer)
1583      tree x;
1584      struct tlist **pbefore_sp, **pno_sp;
1585      tree writer;
1586 {
1587   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1588   enum tree_code code;
1589   char class;
1590
1591   /* X may be NULL if it is the operand of an empty statement expression
1592      ({ }).  */
1593   if (x == NULL)
1594     return;
1595
1596  restart:
1597   code = TREE_CODE (x);
1598   class = TREE_CODE_CLASS (code);
1599
1600   if (warning_candidate_p (x))
1601     {
1602       *pno_sp = new_tlist (*pno_sp, x, writer);
1603       return;
1604     }
1605
1606   switch (code)
1607     {
1608     case CONSTRUCTOR:
1609       return;
1610
1611     case COMPOUND_EXPR:
1612     case TRUTH_ANDIF_EXPR:
1613     case TRUTH_ORIF_EXPR:
1614       tmp_before = tmp_nosp = tmp_list3 = 0;
1615       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1616       warn_for_collisions (tmp_nosp);
1617       merge_tlist (pbefore_sp, tmp_before, 0);
1618       merge_tlist (pbefore_sp, tmp_nosp, 0);
1619       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1620       merge_tlist (pbefore_sp, tmp_list3, 0);
1621       return;
1622
1623     case COND_EXPR:
1624       tmp_before = tmp_list2 = 0;
1625       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1626       warn_for_collisions (tmp_list2);
1627       merge_tlist (pbefore_sp, tmp_before, 0);
1628       merge_tlist (pbefore_sp, tmp_list2, 1);
1629
1630       tmp_list3 = tmp_nosp = 0;
1631       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1632       warn_for_collisions (tmp_nosp);
1633       merge_tlist (pbefore_sp, tmp_list3, 0);
1634
1635       tmp_list3 = tmp_list2 = 0;
1636       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1637       warn_for_collisions (tmp_list2);
1638       merge_tlist (pbefore_sp, tmp_list3, 0);
1639       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1640          two first, to avoid warning for (a ? b++ : b++).  */
1641       merge_tlist (&tmp_nosp, tmp_list2, 0);
1642       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1643       return;
1644
1645     case PREDECREMENT_EXPR:
1646     case PREINCREMENT_EXPR:
1647     case POSTDECREMENT_EXPR:
1648     case POSTINCREMENT_EXPR:
1649       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1650       return;
1651
1652     case MODIFY_EXPR:
1653       tmp_before = tmp_nosp = tmp_list3 = 0;
1654       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1655       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1656       /* Expressions inside the LHS are not ordered wrt. the sequence points
1657          in the RHS.  Example:
1658            *a = (a++, 2)
1659          Despite the fact that the modification of "a" is in the before_sp
1660          list (tmp_before), it conflicts with the use of "a" in the LHS.
1661          We can handle this by adding the contents of tmp_list3
1662          to those of tmp_before, and redoing the collision warnings for that
1663          list.  */
1664       add_tlist (&tmp_before, tmp_list3, x, 1);
1665       warn_for_collisions (tmp_before);
1666       /* Exclude the LHS itself here; we first have to merge it into the
1667          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1668          didn't exclude the LHS, we'd get it twice, once as a read and once
1669          as a write.  */
1670       add_tlist (pno_sp, tmp_list3, x, 0);
1671       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1672
1673       merge_tlist (pbefore_sp, tmp_before, 0);
1674       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1675         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1676       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1677       return;
1678
1679     case CALL_EXPR:
1680       /* We need to warn about conflicts among arguments and conflicts between
1681          args and the function address.  Side effects of the function address,
1682          however, are not ordered by the sequence point of the call.  */
1683       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1684       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1685       if (TREE_OPERAND (x, 1))
1686         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1687       merge_tlist (&tmp_list3, tmp_list2, 0);
1688       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1689       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1690       warn_for_collisions (tmp_before);
1691       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1692       return;
1693
1694     case TREE_LIST:
1695       /* Scan all the list, e.g. indices of multi dimensional array.  */
1696       while (x)
1697         {
1698           tmp_before = tmp_nosp = 0;
1699           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1700           merge_tlist (&tmp_nosp, tmp_before, 0);
1701           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1702           x = TREE_CHAIN (x);
1703         }
1704       return;
1705
1706     case SAVE_EXPR:
1707       {
1708         struct tlist_cache *t;
1709         for (t = save_expr_cache; t; t = t->next)
1710           if (t->expr == x)
1711             break;
1712
1713         if (! t)
1714           {
1715             t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1716                                                       sizeof *t);
1717             t->next = save_expr_cache;
1718             t->expr = x;
1719             save_expr_cache = t;
1720
1721             tmp_before = tmp_nosp = 0;
1722             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1723             warn_for_collisions (tmp_nosp);
1724
1725             tmp_list3 = 0;
1726             while (tmp_nosp)
1727               {
1728                 struct tlist *t = tmp_nosp;
1729                 tmp_nosp = t->next;
1730                 merge_tlist (&tmp_list3, t, 0);
1731               }
1732             t->cache_before_sp = tmp_before;
1733             t->cache_after_sp = tmp_list3;
1734           }
1735         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1736         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1737         return;
1738       }
1739     default:
1740       break;
1741     }
1742
1743   if (class == '1')
1744     {
1745       if (first_rtl_op (code) == 0)
1746         return;
1747       x = TREE_OPERAND (x, 0);
1748       writer = 0;
1749       goto restart;
1750     }
1751
1752   switch (class)
1753     {
1754     case 'r':
1755     case '<':
1756     case '2':
1757     case 'b':
1758     case 'e':
1759     case 's':
1760     case 'x':
1761       {
1762         int lp;
1763         int max = first_rtl_op (TREE_CODE (x));
1764         for (lp = 0; lp < max; lp++)
1765           {
1766             tmp_before = tmp_nosp = 0;
1767             verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1768             merge_tlist (&tmp_nosp, tmp_before, 0);
1769             add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1770           }
1771         break;
1772       }
1773     }
1774 }
1775
1776 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1777    points.  */
1778
1779 static void
1780 verify_sequence_points (expr)
1781      tree expr;
1782 {
1783   struct tlist *before_sp = 0, *after_sp = 0;
1784
1785   warned_ids = 0;
1786   save_expr_cache = 0;
1787   if (tlist_firstobj == 0)
1788     {
1789       gcc_obstack_init (&tlist_obstack);
1790       tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1791     }
1792
1793   verify_tree (expr, &before_sp, &after_sp, 0);
1794   warn_for_collisions (after_sp);
1795   obstack_free (&tlist_obstack, tlist_firstobj);
1796 }
1797
1798 tree
1799 c_expand_expr_stmt (expr)
1800      tree expr;
1801 {
1802   /* Do default conversion if safe and possibly important,
1803      in case within ({...}).  */
1804   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1805       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1806     expr = default_conversion (expr);
1807
1808   if (warn_sequence_point)
1809     verify_sequence_points (expr);
1810
1811   if (TREE_TYPE (expr) != error_mark_node
1812       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1813       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1814     error ("expression statement has incomplete type");
1815
1816   last_expr_type = TREE_TYPE (expr);
1817   return add_stmt (build_stmt (EXPR_STMT, expr));
1818 }
1819 \f
1820 /* Validate the expression after `case' and apply default promotions.  */
1821
1822 tree
1823 check_case_value (value)
1824      tree value;
1825 {
1826   if (value == NULL_TREE)
1827     return value;
1828
1829   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1830   STRIP_TYPE_NOPS (value);
1831   /* In C++, the following is allowed:
1832
1833        const int i = 3;
1834        switch (...) { case i: ... }
1835
1836      So, we try to reduce the VALUE to a constant that way.  */
1837   if (c_language == clk_cplusplus)
1838     {
1839       value = decl_constant_value (value);
1840       STRIP_TYPE_NOPS (value);
1841       value = fold (value);
1842     }
1843
1844   if (TREE_CODE (value) != INTEGER_CST
1845       && value != error_mark_node)
1846     {
1847       error ("case label does not reduce to an integer constant");
1848       value = error_mark_node;
1849     }
1850   else
1851     /* Promote char or short to int.  */
1852     value = default_conversion (value);
1853
1854   constant_expression_warning (value);
1855
1856   return value;
1857 }
1858 \f
1859 /* Return an integer type with BITS bits of precision,
1860    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1861
1862 tree
1863 type_for_size (bits, unsignedp)
1864      unsigned bits;
1865      int unsignedp;
1866 {
1867   if (bits == TYPE_PRECISION (integer_type_node))
1868     return unsignedp ? unsigned_type_node : integer_type_node;
1869
1870   if (bits == TYPE_PRECISION (signed_char_type_node))
1871     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1872
1873   if (bits == TYPE_PRECISION (short_integer_type_node))
1874     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1875
1876   if (bits == TYPE_PRECISION (long_integer_type_node))
1877     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1878
1879   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1880     return (unsignedp ? long_long_unsigned_type_node
1881             : long_long_integer_type_node);
1882
1883   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1884     return (unsignedp ? widest_unsigned_literal_type_node
1885             : widest_integer_literal_type_node);
1886
1887   if (bits <= TYPE_PRECISION (intQI_type_node))
1888     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1889
1890   if (bits <= TYPE_PRECISION (intHI_type_node))
1891     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1892
1893   if (bits <= TYPE_PRECISION (intSI_type_node))
1894     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1895
1896   if (bits <= TYPE_PRECISION (intDI_type_node))
1897     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1898
1899   return 0;
1900 }
1901
1902 /* Return a data type that has machine mode MODE.
1903    If the mode is an integer,
1904    then UNSIGNEDP selects between signed and unsigned types.  */
1905
1906 tree
1907 type_for_mode (mode, unsignedp)
1908      enum machine_mode mode;
1909      int unsignedp;
1910 {
1911   if (mode == TYPE_MODE (integer_type_node))
1912     return unsignedp ? unsigned_type_node : integer_type_node;
1913
1914   if (mode == TYPE_MODE (signed_char_type_node))
1915     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1916
1917   if (mode == TYPE_MODE (short_integer_type_node))
1918     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1919
1920   if (mode == TYPE_MODE (long_integer_type_node))
1921     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1922
1923   if (mode == TYPE_MODE (long_long_integer_type_node))
1924     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1925
1926   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1927     return unsignedp ? widest_unsigned_literal_type_node
1928                      : widest_integer_literal_type_node;
1929
1930   if (mode == TYPE_MODE (intQI_type_node))
1931     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1932
1933   if (mode == TYPE_MODE (intHI_type_node))
1934     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1935
1936   if (mode == TYPE_MODE (intSI_type_node))
1937     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1938
1939   if (mode == TYPE_MODE (intDI_type_node))
1940     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1941
1942 #if HOST_BITS_PER_WIDE_INT >= 64
1943   if (mode == TYPE_MODE (intTI_type_node))
1944     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1945 #endif
1946
1947   if (mode == TYPE_MODE (float_type_node))
1948     return float_type_node;
1949
1950   if (mode == TYPE_MODE (double_type_node))
1951     return double_type_node;
1952
1953   if (mode == TYPE_MODE (long_double_type_node))
1954     return long_double_type_node;
1955
1956   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1957     return build_pointer_type (char_type_node);
1958
1959   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1960     return build_pointer_type (integer_type_node);
1961
1962 #ifdef VECTOR_MODE_SUPPORTED_P
1963   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1964     return V4SF_type_node;
1965   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1966     return V4SI_type_node;
1967   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1968     return V2SI_type_node;
1969   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1970     return V4HI_type_node;
1971   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1972     return V8QI_type_node;
1973 #endif
1974
1975   return 0;
1976 }
1977
1978 /* Return an unsigned type the same as TYPE in other respects. */
1979 tree
1980 unsigned_type (type)
1981      tree type;
1982 {
1983   tree type1 = TYPE_MAIN_VARIANT (type);
1984   if (type1 == signed_char_type_node || type1 == char_type_node)
1985     return unsigned_char_type_node;
1986   if (type1 == integer_type_node)
1987     return unsigned_type_node;
1988   if (type1 == short_integer_type_node)
1989     return short_unsigned_type_node;
1990   if (type1 == long_integer_type_node)
1991     return long_unsigned_type_node;
1992   if (type1 == long_long_integer_type_node)
1993     return long_long_unsigned_type_node;
1994   if (type1 == widest_integer_literal_type_node)
1995     return widest_unsigned_literal_type_node;
1996 #if HOST_BITS_PER_WIDE_INT >= 64
1997   if (type1 == intTI_type_node)
1998     return unsigned_intTI_type_node;
1999 #endif
2000   if (type1 == intDI_type_node)
2001     return unsigned_intDI_type_node;
2002   if (type1 == intSI_type_node)
2003     return unsigned_intSI_type_node;
2004   if (type1 == intHI_type_node)
2005     return unsigned_intHI_type_node;
2006   if (type1 == intQI_type_node)
2007     return unsigned_intQI_type_node;
2008
2009   return signed_or_unsigned_type (1, type);
2010 }
2011
2012 /* Return a signed type the same as TYPE in other respects.  */
2013
2014 tree
2015 signed_type (type)
2016      tree type;
2017 {
2018   tree type1 = TYPE_MAIN_VARIANT (type);
2019   if (type1 == unsigned_char_type_node || type1 == char_type_node)
2020     return signed_char_type_node;
2021   if (type1 == unsigned_type_node)
2022     return integer_type_node;
2023   if (type1 == short_unsigned_type_node)
2024     return short_integer_type_node;
2025   if (type1 == long_unsigned_type_node)
2026     return long_integer_type_node;
2027   if (type1 == long_long_unsigned_type_node)
2028     return long_long_integer_type_node;
2029   if (type1 == widest_unsigned_literal_type_node)
2030     return widest_integer_literal_type_node;
2031 #if HOST_BITS_PER_WIDE_INT >= 64
2032   if (type1 == unsigned_intTI_type_node)
2033     return intTI_type_node;
2034 #endif
2035   if (type1 == unsigned_intDI_type_node)
2036     return intDI_type_node;
2037   if (type1 == unsigned_intSI_type_node)
2038     return intSI_type_node;
2039   if (type1 == unsigned_intHI_type_node)
2040     return intHI_type_node;
2041   if (type1 == unsigned_intQI_type_node)
2042     return intQI_type_node;
2043
2044   return signed_or_unsigned_type (0, type);
2045 }
2046
2047 /* Return a type the same as TYPE except unsigned or
2048    signed according to UNSIGNEDP.  */
2049
2050 tree
2051 signed_or_unsigned_type (unsignedp, type)
2052      int unsignedp;
2053      tree type;
2054 {
2055   if (! INTEGRAL_TYPE_P (type)
2056       || TREE_UNSIGNED (type) == unsignedp)
2057     return type;
2058
2059   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2060     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2061   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2062     return unsignedp ? unsigned_type_node : integer_type_node;
2063   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2064     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2065   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2066     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2067   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2068     return (unsignedp ? long_long_unsigned_type_node
2069             : long_long_integer_type_node);
2070   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2071     return (unsignedp ? widest_unsigned_literal_type_node
2072             : widest_integer_literal_type_node);
2073   return type;
2074 }
2075 \f
2076 /* Return the minimum number of bits needed to represent VALUE in a
2077    signed or unsigned type, UNSIGNEDP says which.  */
2078
2079 unsigned int
2080 min_precision (value, unsignedp)
2081      tree value;
2082      int unsignedp;
2083 {
2084   int log;
2085
2086   /* If the value is negative, compute its negative minus 1.  The latter
2087      adjustment is because the absolute value of the largest negative value
2088      is one larger than the largest positive value.  This is equivalent to
2089      a bit-wise negation, so use that operation instead.  */
2090
2091   if (tree_int_cst_sgn (value) < 0)
2092     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2093
2094   /* Return the number of bits needed, taking into account the fact
2095      that we need one more bit for a signed than unsigned type.  */
2096
2097   if (integer_zerop (value))
2098     log = 0;
2099   else
2100     log = tree_floor_log2 (value);
2101
2102   return log + 1 + ! unsignedp;
2103 }
2104 \f
2105 /* Print an error message for invalid operands to arith operation CODE.
2106    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2107
2108 void
2109 binary_op_error (code)
2110      enum tree_code code;
2111 {
2112   register const char *opname;
2113
2114   switch (code)
2115     {
2116     case NOP_EXPR:
2117       error ("invalid truth-value expression");
2118       return;
2119
2120     case PLUS_EXPR:
2121       opname = "+"; break;
2122     case MINUS_EXPR:
2123       opname = "-"; break;
2124     case MULT_EXPR:
2125       opname = "*"; break;
2126     case MAX_EXPR:
2127       opname = "max"; break;
2128     case MIN_EXPR:
2129       opname = "min"; break;
2130     case EQ_EXPR:
2131       opname = "=="; break;
2132     case NE_EXPR:
2133       opname = "!="; break;
2134     case LE_EXPR:
2135       opname = "<="; break;
2136     case GE_EXPR:
2137       opname = ">="; break;
2138     case LT_EXPR:
2139       opname = "<"; break;
2140     case GT_EXPR:
2141       opname = ">"; break;
2142     case LSHIFT_EXPR:
2143       opname = "<<"; break;
2144     case RSHIFT_EXPR:
2145       opname = ">>"; break;
2146     case TRUNC_MOD_EXPR:
2147     case FLOOR_MOD_EXPR:
2148       opname = "%"; break;
2149     case TRUNC_DIV_EXPR:
2150     case FLOOR_DIV_EXPR:
2151       opname = "/"; break;
2152     case BIT_AND_EXPR:
2153       opname = "&"; break;
2154     case BIT_IOR_EXPR:
2155       opname = "|"; break;
2156     case TRUTH_ANDIF_EXPR:
2157       opname = "&&"; break;
2158     case TRUTH_ORIF_EXPR:
2159       opname = "||"; break;
2160     case BIT_XOR_EXPR:
2161       opname = "^"; break;
2162     case LROTATE_EXPR:
2163     case RROTATE_EXPR:
2164       opname = "rotate"; break;
2165     default:
2166       opname = "unknown"; break;
2167     }
2168   error ("invalid operands to binary %s", opname);
2169 }
2170 \f
2171 /* Subroutine of build_binary_op, used for comparison operations.
2172    See if the operands have both been converted from subword integer types
2173    and, if so, perhaps change them both back to their original type.
2174    This function is also responsible for converting the two operands
2175    to the proper common type for comparison.
2176
2177    The arguments of this function are all pointers to local variables
2178    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2179    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2180
2181    If this function returns nonzero, it means that the comparison has
2182    a constant value.  What this function returns is an expression for
2183    that value.  */
2184
2185 tree
2186 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2187      tree *op0_ptr, *op1_ptr;
2188      tree *restype_ptr;
2189      enum tree_code *rescode_ptr;
2190 {
2191   register tree type;
2192   tree op0 = *op0_ptr;
2193   tree op1 = *op1_ptr;
2194   int unsignedp0, unsignedp1;
2195   int real1, real2;
2196   tree primop0, primop1;
2197   enum tree_code code = *rescode_ptr;
2198
2199   /* Throw away any conversions to wider types
2200      already present in the operands.  */
2201
2202   primop0 = get_narrower (op0, &unsignedp0);
2203   primop1 = get_narrower (op1, &unsignedp1);
2204
2205   /* Handle the case that OP0 does not *contain* a conversion
2206      but it *requires* conversion to FINAL_TYPE.  */
2207
2208   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2209     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2210   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2211     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2212
2213   /* If one of the operands must be floated, we cannot optimize.  */
2214   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2215   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2216
2217   /* If first arg is constant, swap the args (changing operation
2218      so value is preserved), for canonicalization.  Don't do this if
2219      the second arg is 0.  */
2220
2221   if (TREE_CONSTANT (primop0)
2222       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2223     {
2224       register tree tem = primop0;
2225       register int temi = unsignedp0;
2226       primop0 = primop1;
2227       primop1 = tem;
2228       tem = op0;
2229       op0 = op1;
2230       op1 = tem;
2231       *op0_ptr = op0;
2232       *op1_ptr = op1;
2233       unsignedp0 = unsignedp1;
2234       unsignedp1 = temi;
2235       temi = real1;
2236       real1 = real2;
2237       real2 = temi;
2238
2239       switch (code)
2240         {
2241         case LT_EXPR:
2242           code = GT_EXPR;
2243           break;
2244         case GT_EXPR:
2245           code = LT_EXPR;
2246           break;
2247         case LE_EXPR:
2248           code = GE_EXPR;
2249           break;
2250         case GE_EXPR:
2251           code = LE_EXPR;
2252           break;
2253         default:
2254           break;
2255         }
2256       *rescode_ptr = code;
2257     }
2258
2259   /* If comparing an integer against a constant more bits wide,
2260      maybe we can deduce a value of 1 or 0 independent of the data.
2261      Or else truncate the constant now
2262      rather than extend the variable at run time.
2263
2264      This is only interesting if the constant is the wider arg.
2265      Also, it is not safe if the constant is unsigned and the
2266      variable arg is signed, since in this case the variable
2267      would be sign-extended and then regarded as unsigned.
2268      Our technique fails in this case because the lowest/highest
2269      possible unsigned results don't follow naturally from the
2270      lowest/highest possible values of the variable operand.
2271      For just EQ_EXPR and NE_EXPR there is another technique that
2272      could be used: see if the constant can be faithfully represented
2273      in the other operand's type, by truncating it and reextending it
2274      and see if that preserves the constant's value.  */
2275
2276   if (!real1 && !real2
2277       && TREE_CODE (primop1) == INTEGER_CST
2278       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2279     {
2280       int min_gt, max_gt, min_lt, max_lt;
2281       tree maxval, minval;
2282       /* 1 if comparison is nominally unsigned.  */
2283       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2284       tree val;
2285
2286       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2287
2288       /* If TYPE is an enumeration, then we need to get its min/max
2289          values from it's underlying integral type, not the enumerated
2290          type itself.  */
2291       if (TREE_CODE (type) == ENUMERAL_TYPE)
2292         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
2293
2294       maxval = TYPE_MAX_VALUE (type);
2295       minval = TYPE_MIN_VALUE (type);
2296
2297       if (unsignedp && !unsignedp0)
2298         *restype_ptr = signed_type (*restype_ptr);
2299
2300       if (TREE_TYPE (primop1) != *restype_ptr)
2301         primop1 = convert (*restype_ptr, primop1);
2302       if (type != *restype_ptr)
2303         {
2304           minval = convert (*restype_ptr, minval);
2305           maxval = convert (*restype_ptr, maxval);
2306         }
2307
2308       if (unsignedp && unsignedp0)
2309         {
2310           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2311           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2312           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2313           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2314         }
2315       else
2316         {
2317           min_gt = INT_CST_LT (primop1, minval);
2318           max_gt = INT_CST_LT (primop1, maxval);
2319           min_lt = INT_CST_LT (minval, primop1);
2320           max_lt = INT_CST_LT (maxval, primop1);
2321         }
2322
2323       val = 0;
2324       /* This used to be a switch, but Genix compiler can't handle that.  */
2325       if (code == NE_EXPR)
2326         {
2327           if (max_lt || min_gt)
2328             val = boolean_true_node;
2329         }
2330       else if (code == EQ_EXPR)
2331         {
2332           if (max_lt || min_gt)
2333             val = boolean_false_node;
2334         }
2335       else if (code == LT_EXPR)
2336         {
2337           if (max_lt)
2338             val = boolean_true_node;
2339           if (!min_lt)
2340             val = boolean_false_node;
2341         }
2342       else if (code == GT_EXPR)
2343         {
2344           if (min_gt)
2345             val = boolean_true_node;
2346           if (!max_gt)
2347             val = boolean_false_node;
2348         }
2349       else if (code == LE_EXPR)
2350         {
2351           if (!max_gt)
2352             val = boolean_true_node;
2353           if (min_gt)
2354             val = boolean_false_node;
2355         }
2356       else if (code == GE_EXPR)
2357         {
2358           if (!min_lt)
2359             val = boolean_true_node;
2360           if (max_lt)
2361             val = boolean_false_node;
2362         }
2363
2364       /* If primop0 was sign-extended and unsigned comparison specd,
2365          we did a signed comparison above using the signed type bounds.
2366          But the comparison we output must be unsigned.
2367
2368          Also, for inequalities, VAL is no good; but if the signed
2369          comparison had *any* fixed result, it follows that the
2370          unsigned comparison just tests the sign in reverse
2371          (positive values are LE, negative ones GE).
2372          So we can generate an unsigned comparison
2373          against an extreme value of the signed type.  */
2374
2375       if (unsignedp && !unsignedp0)
2376         {
2377           if (val != 0)
2378             switch (code)
2379               {
2380               case LT_EXPR:
2381               case GE_EXPR:
2382                 primop1 = TYPE_MIN_VALUE (type);
2383                 val = 0;
2384                 break;
2385
2386               case LE_EXPR:
2387               case GT_EXPR:
2388                 primop1 = TYPE_MAX_VALUE (type);
2389                 val = 0;
2390                 break;
2391
2392               default:
2393                 break;
2394               }
2395           type = unsigned_type (type);
2396         }
2397
2398       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2399         {
2400           /* This is the case of (char)x >?< 0x80, which people used to use
2401              expecting old C compilers to change the 0x80 into -0x80.  */
2402           if (val == boolean_false_node)
2403             warning ("comparison is always false due to limited range of data type");
2404           if (val == boolean_true_node)
2405             warning ("comparison is always true due to limited range of data type");
2406         }
2407
2408       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2409         {
2410           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2411           if (val == boolean_false_node)
2412             warning ("comparison is always false due to limited range of data type");
2413           if (val == boolean_true_node)
2414             warning ("comparison is always true due to limited range of data type");
2415         }
2416
2417       if (val != 0)
2418         {
2419           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2420           if (TREE_SIDE_EFFECTS (primop0))
2421             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2422           return val;
2423         }
2424
2425       /* Value is not predetermined, but do the comparison
2426          in the type of the operand that is not constant.
2427          TYPE is already properly set.  */
2428     }
2429   else if (real1 && real2
2430            && (TYPE_PRECISION (TREE_TYPE (primop0))
2431                == TYPE_PRECISION (TREE_TYPE (primop1))))
2432     type = TREE_TYPE (primop0);
2433
2434   /* If args' natural types are both narrower than nominal type
2435      and both extend in the same manner, compare them
2436      in the type of the wider arg.
2437      Otherwise must actually extend both to the nominal
2438      common type lest different ways of extending
2439      alter the result.
2440      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2441
2442   else if (unsignedp0 == unsignedp1 && real1 == real2
2443            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2444            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2445     {
2446       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2447       type = signed_or_unsigned_type (unsignedp0
2448                                       || TREE_UNSIGNED (*restype_ptr),
2449                                       type);
2450       /* Make sure shorter operand is extended the right way
2451          to match the longer operand.  */
2452       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2453                          primop0);
2454       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2455                          primop1);
2456     }
2457   else
2458     {
2459       /* Here we must do the comparison on the nominal type
2460          using the args exactly as we received them.  */
2461       type = *restype_ptr;
2462       primop0 = op0;
2463       primop1 = op1;
2464
2465       if (!real1 && !real2 && integer_zerop (primop1)
2466           && TREE_UNSIGNED (*restype_ptr))
2467         {
2468           tree value = 0;
2469           switch (code)
2470             {
2471             case GE_EXPR:
2472               /* All unsigned values are >= 0, so we warn if extra warnings
2473                  are requested.  However, if OP0 is a constant that is
2474                  >= 0, the signedness of the comparison isn't an issue,
2475                  so suppress the warning.  */
2476               if (extra_warnings && !in_system_header
2477                   && ! (TREE_CODE (primop0) == INTEGER_CST
2478                         && ! TREE_OVERFLOW (convert (signed_type (type),
2479                                                      primop0))))
2480                 warning ("comparison of unsigned expression >= 0 is always true");
2481               value = boolean_true_node;
2482               break;
2483
2484             case LT_EXPR:
2485               if (extra_warnings && !in_system_header
2486                   && ! (TREE_CODE (primop0) == INTEGER_CST
2487                         && ! TREE_OVERFLOW (convert (signed_type (type),
2488                                                      primop0))))
2489                 warning ("comparison of unsigned expression < 0 is always false");
2490               value = boolean_false_node;
2491               break;
2492
2493             default:
2494               break;
2495             }
2496
2497           if (value != 0)
2498             {
2499               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2500               if (TREE_SIDE_EFFECTS (primop0))
2501                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2502                               primop0, value);
2503               return value;
2504             }
2505         }
2506     }
2507
2508   *op0_ptr = convert (type, primop0);
2509   *op1_ptr = convert (type, primop1);
2510
2511   *restype_ptr = boolean_type_node;
2512
2513   return 0;
2514 }
2515 \f
2516 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2517    or validate its data type for an `if' or `while' statement or ?..: exp.
2518
2519    This preparation consists of taking the ordinary
2520    representation of an expression expr and producing a valid tree
2521    boolean expression describing whether expr is nonzero.  We could
2522    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2523    but we optimize comparisons, &&, ||, and !.
2524
2525    The resulting type should always be `boolean_type_node'.  */
2526
2527 tree
2528 truthvalue_conversion (expr)
2529      tree expr;
2530 {
2531   if (TREE_CODE (expr) == ERROR_MARK)
2532     return expr;
2533
2534 #if 0 /* This appears to be wrong for C++.  */
2535   /* These really should return error_mark_node after 2.4 is stable.
2536      But not all callers handle ERROR_MARK properly.  */
2537   switch (TREE_CODE (TREE_TYPE (expr)))
2538     {
2539     case RECORD_TYPE:
2540       error ("struct type value used where scalar is required");
2541       return boolean_false_node;
2542
2543     case UNION_TYPE:
2544       error ("union type value used where scalar is required");
2545       return boolean_false_node;
2546
2547     case ARRAY_TYPE:
2548       error ("array type value used where scalar is required");
2549       return boolean_false_node;
2550
2551     default:
2552       break;
2553     }
2554 #endif /* 0 */
2555
2556   switch (TREE_CODE (expr))
2557     {
2558     case EQ_EXPR:
2559     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2560     case TRUTH_ANDIF_EXPR:
2561     case TRUTH_ORIF_EXPR:
2562     case TRUTH_AND_EXPR:
2563     case TRUTH_OR_EXPR:
2564     case TRUTH_XOR_EXPR:
2565     case TRUTH_NOT_EXPR:
2566       TREE_TYPE (expr) = boolean_type_node;
2567       return expr;
2568
2569     case ERROR_MARK:
2570       return expr;
2571
2572     case INTEGER_CST:
2573       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2574
2575     case REAL_CST:
2576       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2577
2578     case ADDR_EXPR:
2579       /* If we are taking the address of a external decl, it might be zero
2580          if it is weak, so we cannot optimize.  */
2581       if (DECL_P (TREE_OPERAND (expr, 0))
2582           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2583         break;
2584
2585       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2586         return build (COMPOUND_EXPR, boolean_type_node,
2587                       TREE_OPERAND (expr, 0), boolean_true_node);
2588       else
2589         return boolean_true_node;
2590
2591     case COMPLEX_EXPR:
2592       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2593                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2594                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2595                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2596                               0);
2597
2598     case NEGATE_EXPR:
2599     case ABS_EXPR:
2600     case FLOAT_EXPR:
2601     case FFS_EXPR:
2602       /* These don't change whether an object is non-zero or zero.  */
2603       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2604
2605     case LROTATE_EXPR:
2606     case RROTATE_EXPR:
2607       /* These don't change whether an object is zero or non-zero, but
2608          we can't ignore them if their second arg has side-effects.  */
2609       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2610         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2611                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2612       else
2613         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2614
2615     case COND_EXPR:
2616       /* Distribute the conversion into the arms of a COND_EXPR.  */
2617       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2618                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2619                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2620
2621     case CONVERT_EXPR:
2622       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2623          since that affects how `default_conversion' will behave.  */
2624       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2625           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2626         break;
2627       /* fall through...  */
2628     case NOP_EXPR:
2629       /* If this is widening the argument, we can ignore it.  */
2630       if (TYPE_PRECISION (TREE_TYPE (expr))
2631           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2632         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2633       break;
2634
2635     case MINUS_EXPR:
2636       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2637          this case.  */
2638       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2639           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2640         break;
2641       /* fall through...  */
2642     case BIT_XOR_EXPR:
2643       /* This and MINUS_EXPR can be changed into a comparison of the
2644          two objects.  */
2645       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2646           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2647         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2648                                 TREE_OPERAND (expr, 1), 1);
2649       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2650                               fold (build1 (NOP_EXPR,
2651                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2652                                             TREE_OPERAND (expr, 1))), 1);
2653
2654     case BIT_AND_EXPR:
2655       if (integer_onep (TREE_OPERAND (expr, 1))
2656           && TREE_TYPE (expr) != boolean_type_node)
2657         /* Using convert here would cause infinite recursion.  */
2658         return build1 (NOP_EXPR, boolean_type_node, expr);
2659       break;
2660
2661     case MODIFY_EXPR:
2662       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2663         warning ("suggest parentheses around assignment used as truth value");
2664       break;
2665
2666     default:
2667       break;
2668     }
2669
2670   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2671     {
2672       tree tem = save_expr (expr);
2673       return (build_binary_op
2674               ((TREE_SIDE_EFFECTS (expr)
2675                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2676                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2677                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2678                0));
2679     }
2680
2681   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2682 }
2683 \f
2684 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2685                                         int, enum built_in_class, int, int,
2686                                         int));
2687
2688 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2689    down to the element type of an array.  */
2690
2691 tree
2692 c_build_qualified_type (type, type_quals)
2693      tree type;
2694      int type_quals;
2695 {
2696   /* A restrict-qualified pointer type must be a pointer to object or
2697      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2698      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
2699      the C++ front-end also use POINTER_TYPE for pointer-to-member
2700      values, so even though it should be illegal to use `restrict'
2701      with such an entity we don't flag that here.  Thus, special case
2702      code for that case is required in the C++ front-end.  */
2703   if ((type_quals & TYPE_QUAL_RESTRICT)
2704       && (!POINTER_TYPE_P (type)
2705           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2706     {
2707       error ("invalid use of `restrict'");
2708       type_quals &= ~TYPE_QUAL_RESTRICT;
2709     }
2710
2711   if (TREE_CODE (type) == ARRAY_TYPE)
2712     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2713                                                      type_quals),
2714                              TYPE_DOMAIN (type));
2715   return build_qualified_type (type, type_quals);
2716 }
2717
2718 /* Apply the TYPE_QUALS to the new DECL.  */
2719
2720 void
2721 c_apply_type_quals_to_decl (type_quals, decl)
2722      int type_quals;
2723      tree decl;
2724 {
2725   if ((type_quals & TYPE_QUAL_CONST)
2726       || (TREE_TYPE (decl)
2727           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2728     TREE_READONLY (decl) = 1;
2729   if (type_quals & TYPE_QUAL_VOLATILE)
2730     {
2731       TREE_SIDE_EFFECTS (decl) = 1;
2732       TREE_THIS_VOLATILE (decl) = 1;
2733     }
2734   if (type_quals & TYPE_QUAL_RESTRICT)
2735     {
2736       if (!TREE_TYPE (decl)
2737           || !POINTER_TYPE_P (TREE_TYPE (decl))
2738           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2739         error ("invalid use of `restrict'");
2740       else if (flag_strict_aliasing)
2741         {
2742           /* No two restricted pointers can point at the same thing.
2743              However, a restricted pointer can point at the same thing
2744              as an unrestricted pointer, if that unrestricted pointer
2745              is based on the restricted pointer.  So, we make the
2746              alias set for the restricted pointer a subset of the
2747              alias set for the type pointed to by the type of the
2748              decl.  */
2749
2750           HOST_WIDE_INT pointed_to_alias_set
2751             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
2752
2753           if (pointed_to_alias_set == 0)
2754             /* It's not legal to make a subset of alias set zero.  */
2755             ;
2756           else
2757             {
2758               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
2759               record_alias_subset  (pointed_to_alias_set,
2760                                     DECL_POINTER_ALIAS_SET (decl));
2761             }
2762         }
2763     }
2764 }
2765
2766
2767 /* Return the typed-based alias set for T, which may be an expression
2768    or a type.  Return -1 if we don't do anything special.  */
2769
2770 HOST_WIDE_INT
2771 lang_get_alias_set (t)
2772      tree t;
2773 {
2774   tree u;
2775
2776   /* We know nothing about vector types */
2777   if (TREE_CODE (t) == VECTOR_TYPE)
2778     return 0;
2779
2780   /* Permit type-punning when accessing a union, provided the access
2781      is directly through the union.  For example, this code does not
2782      permit taking the address of a union member and then storing
2783      through it.  Even the type-punning allowed here is a GCC
2784      extension, albeit a common and useful one; the C standard says
2785      that such accesses have implementation-defined behavior.  */
2786   for (u = t;
2787        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2788        u = TREE_OPERAND (u, 0))
2789     if (TREE_CODE (u) == COMPONENT_REF
2790         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2791       return 0;
2792
2793   /* If this is a char *, the ANSI C standard says it can alias
2794      anything.  Note that all references need do this.  */
2795   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2796       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2797       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2798     return 0;
2799
2800   /* That's all the expressions we handle specially.  */
2801   if (! TYPE_P (t))
2802     return -1;
2803
2804   /* The C standard specifically allows aliasing between signed and
2805      unsigned variants of the same type.  We treat the signed
2806      variant as canonical.  */
2807   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2808     {
2809       tree t1 = signed_type (t);
2810
2811       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2812       if (t1 != t)
2813         return get_alias_set (t1);
2814     }
2815   else if (POINTER_TYPE_P (t))
2816     {
2817       tree t1;
2818
2819       /* Unfortunately, there is no canonical form of a pointer type.
2820          In particular, if we have `typedef int I', then `int *', and
2821          `I *' are different types.  So, we have to pick a canonical
2822          representative.  We do this below.
2823
2824          Technically, this approach is actually more conservative that
2825          it needs to be.  In particular, `const int *' and `int *'
2826          chould be in different alias sets, according to the C and C++
2827          standard, since their types are not the same, and so,
2828          technically, an `int **' and `const int **' cannot point at
2829          the same thing.
2830
2831          But, the standard is wrong.  In particular, this code is
2832          legal C++:
2833
2834             int *ip;
2835             int **ipp = &ip;
2836             const int* const* cipp = &ipp;
2837
2838          And, it doesn't make sense for that to be legal unless you
2839          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2840          the pointed-to types.  This issue has been reported to the
2841          C++ committee.  */
2842       t1 = build_type_no_quals (t);
2843       if (t1 != t)
2844         return get_alias_set (t1);
2845     }
2846   /* It's not yet safe to use alias sets for classes in C++ because
2847      the TYPE_FIELDs list for a class doesn't mention base classes.  */
2848   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
2849     return 0;
2850
2851   return -1;
2852 }
2853
2854 /* Build tree nodes and builtin functions common to both C and C++ language
2855    frontends.  */
2856
2857 void
2858 c_common_nodes_and_builtins ()
2859 {
2860   enum builtin_type
2861   {
2862 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2863 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2864 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2865 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2866 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2867 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2868 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2869 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2870 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2871 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2872 #include "builtin-types.def"
2873 #undef DEF_PRIMITIVE_TYPE
2874 #undef DEF_FUNCTION_TYPE_0
2875 #undef DEF_FUNCTION_TYPE_1
2876 #undef DEF_FUNCTION_TYPE_2
2877 #undef DEF_FUNCTION_TYPE_3
2878 #undef DEF_FUNCTION_TYPE_4
2879 #undef DEF_FUNCTION_TYPE_VAR_0
2880 #undef DEF_FUNCTION_TYPE_VAR_1
2881 #undef DEF_FUNCTION_TYPE_VAR_2
2882 #undef DEF_POINTER_TYPE
2883     BT_LAST
2884   };
2885
2886   typedef enum builtin_type builtin_type;
2887
2888   tree builtin_types[(int)BT_LAST];
2889   int wchar_type_size;
2890   tree array_domain_type;
2891   /* Either char* or void*.  */
2892   tree traditional_ptr_type_node;
2893   /* Either const char* or const void*.  */
2894   tree traditional_cptr_type_node;
2895   tree traditional_len_type_node;
2896   tree va_list_ref_type_node;
2897   tree va_list_arg_type_node;
2898
2899   /* Define `int' and `char' first so that dbx will output them first.  */
2900   record_builtin_type (RID_INT, NULL, integer_type_node);
2901   record_builtin_type (RID_CHAR, "char", char_type_node);
2902
2903   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
2904      "unsigned long", "long long unsigned" and "unsigned short" were in C++
2905      but not C.  Are the conditionals here needed?  */
2906   if (c_language == clk_cplusplus)
2907     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2908   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2909   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2910   record_builtin_type (RID_MAX, "long unsigned int",
2911                        long_unsigned_type_node);
2912   if (c_language == clk_cplusplus)
2913     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2914   record_builtin_type (RID_MAX, "long long int",
2915                        long_long_integer_type_node);
2916   record_builtin_type (RID_MAX, "long long unsigned int",
2917                        long_long_unsigned_type_node);
2918   if (c_language == clk_cplusplus)
2919     record_builtin_type (RID_MAX, "long long unsigned",
2920                          long_long_unsigned_type_node);
2921   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2922   record_builtin_type (RID_MAX, "short unsigned int",
2923                        short_unsigned_type_node);
2924   if (c_language == clk_cplusplus)
2925     record_builtin_type (RID_MAX, "unsigned short",
2926                          short_unsigned_type_node);
2927
2928   /* Define both `signed char' and `unsigned char'.  */
2929   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2930   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2931
2932   /* These are types that type_for_size and type_for_mode use.  */
2933   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2934   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2935   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2936   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2937 #if HOST_BITS_PER_WIDE_INT >= 64
2938   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2939 #endif
2940   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2941   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2942   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2943   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2944 #if HOST_BITS_PER_WIDE_INT >= 64
2945   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2946 #endif
2947
2948   /* Create the widest literal types.  */
2949   widest_integer_literal_type_node
2950     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2951   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2952                         widest_integer_literal_type_node));
2953
2954   widest_unsigned_literal_type_node
2955     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2956   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2957                         widest_unsigned_literal_type_node));
2958
2959   /* `unsigned long' is the standard type for sizeof.
2960      Note that stddef.h uses `unsigned long',
2961      and this must agree, even if long and int are the same size.  */
2962   c_size_type_node =
2963     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2964   signed_size_type_node = signed_type (c_size_type_node);
2965   if (flag_traditional)
2966     c_size_type_node = signed_size_type_node;
2967   set_sizetype (c_size_type_node);
2968
2969   build_common_tree_nodes_2 (flag_short_double);
2970
2971   record_builtin_type (RID_FLOAT, NULL, float_type_node);
2972   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2973   record_builtin_type (RID_MAX, "long double", long_double_type_node);
2974
2975   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2976                         complex_integer_type_node));
2977   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2978                         complex_float_type_node));
2979   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2980                         complex_double_type_node));
2981   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2982                         complex_long_double_type_node));
2983
2984   record_builtin_type (RID_VOID, NULL, void_type_node);
2985
2986   void_zero_node = build_int_2 (0, 0);
2987   TREE_TYPE (void_zero_node) = void_type_node;
2988
2989   void_list_node = build_void_list_node ();
2990
2991   /* Make a type to be the domain of a few array types
2992      whose domains don't really matter.
2993      200 is small enough that it always fits in size_t
2994      and large enough that it can hold most function names for the
2995      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
2996   array_domain_type = build_index_type (size_int (200));
2997
2998   /* Make a type for arrays of characters.
2999      With luck nothing will ever really depend on the length of this
3000      array type.  */
3001   char_array_type_node
3002     = build_array_type (char_type_node, array_domain_type);
3003
3004   /* Likewise for arrays of ints.  */
3005   int_array_type_node
3006     = build_array_type (integer_type_node, array_domain_type);
3007
3008   string_type_node = build_pointer_type (char_type_node);
3009   const_string_type_node
3010     = build_pointer_type (build_qualified_type
3011                           (char_type_node, TYPE_QUAL_CONST));
3012
3013   traditional_ptr_type_node = ((flag_traditional &&
3014                                 c_language != clk_cplusplus)
3015                                ? string_type_node : ptr_type_node);
3016   traditional_cptr_type_node = ((flag_traditional &&
3017                                  c_language != clk_cplusplus)
3018                                ? const_string_type_node : const_ptr_type_node);
3019
3020   (*targetm.init_builtins) ();
3021
3022   /* This is special for C++ so functions can be overloaded.  */
3023   wchar_type_node = get_identifier (flag_short_wchar
3024                                     ? "short unsigned int"
3025                                     : WCHAR_TYPE);
3026   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3027   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3028   if (c_language == clk_cplusplus)
3029     {
3030       if (TREE_UNSIGNED (wchar_type_node))
3031         wchar_type_node = make_unsigned_type (wchar_type_size);
3032       else
3033         wchar_type_node = make_signed_type (wchar_type_size);
3034       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3035     }
3036   else
3037     {
3038       signed_wchar_type_node = signed_type (wchar_type_node);
3039       unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3040     }
3041
3042   /* This is for wide string constants.  */
3043   wchar_array_type_node
3044     = build_array_type (wchar_type_node, array_domain_type);
3045
3046   wint_type_node =
3047     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3048
3049   intmax_type_node =
3050     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3051   uintmax_type_node =
3052     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3053
3054   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3055   ptrdiff_type_node
3056     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3057   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
3058
3059   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3060                         va_list_type_node));
3061
3062   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3063                         ptrdiff_type_node));
3064
3065   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3066                         sizetype));
3067
3068   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3069     {
3070       va_list_arg_type_node = va_list_ref_type_node =
3071         build_pointer_type (TREE_TYPE (va_list_type_node));
3072     }
3073   else
3074     {
3075       va_list_arg_type_node = va_list_type_node;
3076       va_list_ref_type_node = build_reference_type (va_list_type_node);
3077     }
3078
3079   traditional_len_type_node = ((flag_traditional &&
3080                                 c_language != clk_cplusplus)
3081                                ? integer_type_node : sizetype);
3082
3083 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3084   builtin_types[(int) ENUM] = VALUE;
3085 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3086   builtin_types[(int) ENUM]                             \
3087     = build_function_type (builtin_types[(int) RETURN], \
3088                            void_list_node);
3089 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3090   builtin_types[(int) ENUM]                                             \
3091     = build_function_type (builtin_types[(int) RETURN],                 \
3092                            tree_cons (NULL_TREE,                        \
3093                                       builtin_types[(int) ARG1],        \
3094                                       void_list_node));
3095 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3096   builtin_types[(int) ENUM]                             \
3097     = build_function_type                               \
3098       (builtin_types[(int) RETURN],                     \
3099        tree_cons (NULL_TREE,                            \
3100                   builtin_types[(int) ARG1],            \
3101                   tree_cons (NULL_TREE,                 \
3102                              builtin_types[(int) ARG2], \
3103                              void_list_node)));
3104 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3105   builtin_types[(int) ENUM]                                              \
3106     = build_function_type                                                \
3107       (builtin_types[(int) RETURN],                                      \
3108        tree_cons (NULL_TREE,                                             \
3109                   builtin_types[(int) ARG1],                             \
3110                   tree_cons (NULL_TREE,                                  \
3111                              builtin_types[(int) ARG2],                  \
3112                              tree_cons (NULL_TREE,                       \
3113                                         builtin_types[(int) ARG3],       \
3114                                         void_list_node))));
3115 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3116   builtin_types[(int) ENUM]                                             \
3117     = build_function_type                                               \
3118       (builtin_types[(int) RETURN],                                     \
3119        tree_cons (NULL_TREE,                                            \
3120                   builtin_types[(int) ARG1],                            \
3121                   tree_cons (NULL_TREE,                                 \
3122                              builtin_types[(int) ARG2],                 \
3123                              tree_cons                                  \
3124                              (NULL_TREE,                                \
3125                               builtin_types[(int) ARG3],                \
3126                               tree_cons (NULL_TREE,                     \
3127                                          builtin_types[(int) ARG4],     \
3128                                          void_list_node)))));
3129 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3130   builtin_types[(int) ENUM]                                             \
3131     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3132 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3133    builtin_types[(int) ENUM]                                             \
3134     = build_function_type (builtin_types[(int) RETURN],                  \
3135                            tree_cons (NULL_TREE,                         \
3136                                       builtin_types[(int) ARG1],         \
3137                                       NULL_TREE));
3138
3139 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3140    builtin_types[(int) ENUM]                                    \
3141     = build_function_type                                       \
3142       (builtin_types[(int) RETURN],                             \
3143        tree_cons (NULL_TREE,                                    \
3144                   builtin_types[(int) ARG1],                    \
3145                   tree_cons (NULL_TREE,                         \
3146                              builtin_types[(int) ARG2],         \
3147                              NULL_TREE)));
3148 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3149   builtin_types[(int) ENUM]                             \
3150     = build_pointer_type (builtin_types[(int) TYPE]);
3151 #include "builtin-types.def"
3152 #undef DEF_PRIMITIVE_TYPE
3153 #undef DEF_FUNCTION_TYPE_1
3154 #undef DEF_FUNCTION_TYPE_2
3155 #undef DEF_FUNCTION_TYPE_3
3156 #undef DEF_FUNCTION_TYPE_4
3157 #undef DEF_FUNCTION_TYPE_VAR_0
3158 #undef DEF_FUNCTION_TYPE_VAR_1
3159 #undef DEF_POINTER_TYPE
3160
3161 #define DEF_BUILTIN(ENUM, NAME, CLASS,                                  \
3162                     TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P)       \
3163   if (NAME)                                                             \
3164     {                                                                   \
3165       tree decl;                                                        \
3166                                                                         \
3167       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
3168         abort ();                                                       \
3169                                                                         \
3170       if (!BOTH_P)                                                      \
3171         decl = builtin_function (NAME, builtin_types[TYPE], ENUM,       \
3172                                  CLASS,                                 \
3173                                  (FALLBACK_P                            \
3174                                   ? (NAME + strlen ("__builtin_"))      \
3175                                   : NULL));                             \
3176       else                                                              \
3177         decl = builtin_function_2 (NAME,                                \
3178                                    NAME + strlen ("__builtin_"),        \
3179                                    builtin_types[TYPE],                 \
3180                                    builtin_types[LIBTYPE],              \
3181                                    ENUM,                                \
3182                                    CLASS,                               \
3183                                    FALLBACK_P,                          \
3184                                    NONANSI_P,                           \
3185                                    /*noreturn_p=*/0);                   \
3186                                                                         \
3187       built_in_decls[(int) ENUM] = decl;                                \
3188     }
3189 #include "builtins.def"
3190 #undef DEF_BUILTIN
3191
3192   /* Declare _exit and _Exit just to mark them as non-returning.  */
3193   builtin_function_2 (NULL, "_exit", NULL_TREE,
3194                       builtin_types[BT_FN_VOID_INT],
3195                       0, NOT_BUILT_IN, 0, 1, 1);
3196   builtin_function_2 (NULL, "_Exit", NULL_TREE,
3197                       builtin_types[BT_FN_VOID_INT],
3198                       0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
3199
3200   /* Declare these functions non-returning
3201      to avoid spurious "control drops through" warnings.  */
3202   builtin_function_2 (NULL, "abort",
3203                       NULL_TREE, ((c_language == clk_cplusplus)
3204                                   ? builtin_types[BT_FN_VOID]
3205                                   : builtin_types[BT_FN_VOID_VAR]),
3206                       0, NOT_BUILT_IN, 0, 0, 1);
3207
3208   builtin_function_2 (NULL, "exit",
3209                       NULL_TREE, ((c_language == clk_cplusplus)
3210                                   ? builtin_types[BT_FN_VOID_INT]
3211                                   : builtin_types[BT_FN_VOID_VAR]),
3212                       0, NOT_BUILT_IN, 0, 0, 1);
3213
3214   main_identifier_node = get_identifier ("main");
3215
3216   /* ??? Perhaps there's a better place to do this.  But it is related
3217      to __builtin_va_arg, so it isn't that off-the-wall.  */
3218   lang_type_promotes_to = simple_type_promotes_to;
3219 }
3220
3221 tree
3222 build_va_arg (expr, type)
3223      tree expr, type;
3224 {
3225   return build1 (VA_ARG_EXPR, type, expr);
3226 }
3227
3228
3229 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3230    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3231    of these may be NULL (though both being NULL is useless).
3232    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3233    TYPE is the type of the function with the ordinary name.  These
3234    may differ if the ordinary name is declared with a looser type to avoid
3235    conflicts with headers.  FUNCTION_CODE and CLASS are as for
3236    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3237    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3238    If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3239    NORETURN_P is nonzero, the function is marked as non-returning.
3240    Returns the declaration of BUILTIN_NAME, if any, otherwise
3241    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3242    or if NONANSI_P and flag_no_nonansi_builtin.  */
3243
3244 static tree
3245 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3246                     class, library_name_p, nonansi_p, noreturn_p)
3247      const char *builtin_name;
3248      const char *name;
3249      tree builtin_type;
3250      tree type;
3251      int function_code;
3252      enum built_in_class class;
3253      int library_name_p;
3254      int nonansi_p;
3255      int noreturn_p;
3256 {
3257   tree bdecl = NULL_TREE;
3258   tree decl = NULL_TREE;
3259   if (builtin_name != 0)
3260     {
3261       bdecl = builtin_function (builtin_name, builtin_type, function_code,
3262                                 class, library_name_p ? name : NULL);
3263       if (noreturn_p)
3264         {
3265           TREE_THIS_VOLATILE (bdecl) = 1;
3266           TREE_SIDE_EFFECTS (bdecl) = 1;
3267         }
3268     }
3269   if (name != 0 && !flag_no_builtin && !(nonansi_p && flag_no_nonansi_builtin))
3270     {
3271       decl = builtin_function (name, type, function_code, class, NULL);
3272       if (nonansi_p)
3273         DECL_BUILT_IN_NONANSI (decl) = 1;
3274       if (noreturn_p)
3275         {
3276           TREE_THIS_VOLATILE (decl) = 1;
3277           TREE_SIDE_EFFECTS (decl) = 1;
3278         }
3279     }
3280   return (bdecl != 0 ? bdecl : decl);
3281 }
3282 \f
3283 /* Nonzero if the type T promotes to int.  This is (nearly) the
3284    integral promotions defined in ISO C99 6.3.1.1/2.  */
3285
3286 bool
3287 c_promoting_integer_type_p (t)
3288      tree t;
3289 {
3290   switch (TREE_CODE (t))
3291     {
3292     case INTEGER_TYPE:
3293       return (TYPE_MAIN_VARIANT (t) == char_type_node
3294               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3295               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3296               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3297               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node);
3298
3299     case ENUMERAL_TYPE:
3300       /* ??? Technically all enumerations not larger than an int
3301          promote to an int.  But this is used along code paths
3302          that only want to notice a size change.  */
3303       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3304
3305     case BOOLEAN_TYPE:
3306       return 1;
3307
3308     default:
3309       return 0;
3310     }
3311 }
3312
3313 /* Given a type, apply default promotions wrt unnamed function arguments
3314    and return the new type.  Return NULL_TREE if no change.  */
3315 /* ??? There is a function of the same name in the C++ front end that
3316    does something similar, but is more thorough and does not return NULL
3317    if no change.  We could perhaps share code, but it would make the
3318    self_promoting_type property harder to identify.  */
3319
3320 tree
3321 simple_type_promotes_to (type)
3322      tree type;
3323 {
3324   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3325     return double_type_node;
3326
3327   if (c_promoting_integer_type_p (type))
3328     {
3329       /* Traditionally, unsignedness is preserved in default promotions.
3330          Also preserve unsignedness if not really getting any wider.  */
3331       if (TREE_UNSIGNED (type)
3332           && (flag_traditional
3333               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3334         return unsigned_type_node;
3335       return integer_type_node;
3336     }
3337
3338   return NULL_TREE;
3339 }
3340
3341 /* Return 1 if PARMS specifies a fixed number of parameters
3342    and none of their types is affected by default promotions.  */
3343
3344 int
3345 self_promoting_args_p (parms)
3346      tree parms;
3347 {
3348   register tree t;
3349   for (t = parms; t; t = TREE_CHAIN (t))
3350     {
3351       register tree type = TREE_VALUE (t);
3352
3353       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3354         return 0;
3355
3356       if (type == 0)
3357         return 0;
3358
3359       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3360         return 0;
3361
3362       if (c_promoting_integer_type_p (type))
3363         return 0;
3364     }
3365   return 1;
3366 }
3367
3368 /* Recursively examines the array elements of TYPE, until a non-array
3369    element type is found.  */
3370
3371 tree
3372 strip_array_types (type)
3373      tree type;
3374 {
3375   while (TREE_CODE (type) == ARRAY_TYPE)
3376     type = TREE_TYPE (type);
3377
3378   return type;
3379 }
3380
3381 /* Recognize certain built-in functions so we can make tree-codes
3382    other than CALL_EXPR.  We do this when it enables fold-const.c
3383    to do something useful.  */
3384 /* ??? By rights this should go in builtins.c, but only C and C++
3385    implement build_{binary,unary}_op.  Not exactly sure what bits
3386    of functionality are actually needed from those functions, or
3387    where the similar functionality exists in the other front ends.  */
3388
3389 tree
3390 expand_tree_builtin (function, params, coerced_params)
3391      tree function, params, coerced_params;
3392 {
3393   enum tree_code code;
3394
3395   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3396     return NULL_TREE;
3397
3398   switch (DECL_FUNCTION_CODE (function))
3399     {
3400     case BUILT_IN_ABS:
3401     case BUILT_IN_LABS:
3402     case BUILT_IN_LLABS:
3403     case BUILT_IN_IMAXABS:
3404     case BUILT_IN_FABS:
3405     case BUILT_IN_FABSL:
3406     case BUILT_IN_FABSF:
3407       if (coerced_params == 0)
3408         return integer_zero_node;
3409       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3410
3411     case BUILT_IN_CONJ:
3412     case BUILT_IN_CONJF:
3413     case BUILT_IN_CONJL:
3414       if (coerced_params == 0)
3415         return integer_zero_node;
3416       return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3417
3418     case BUILT_IN_CREAL:
3419     case BUILT_IN_CREALF:
3420     case BUILT_IN_CREALL:
3421       if (coerced_params == 0)
3422         return integer_zero_node;
3423       return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3424
3425     case BUILT_IN_CIMAG:
3426     case BUILT_IN_CIMAGF:
3427     case BUILT_IN_CIMAGL:
3428       if (coerced_params == 0)
3429         return integer_zero_node;
3430       return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3431
3432     case BUILT_IN_ISGREATER:
3433       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3434         code = UNLE_EXPR;
3435       else
3436         code = LE_EXPR;
3437       goto unordered_cmp;
3438
3439     case BUILT_IN_ISGREATEREQUAL:
3440       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3441         code = UNLT_EXPR;
3442       else
3443         code = LT_EXPR;
3444       goto unordered_cmp;
3445
3446     case BUILT_IN_ISLESS:
3447       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3448         code = UNGE_EXPR;
3449       else
3450         code = GE_EXPR;
3451       goto unordered_cmp;
3452
3453     case BUILT_IN_ISLESSEQUAL:
3454       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3455         code = UNGT_EXPR;
3456       else
3457         code = GT_EXPR;
3458       goto unordered_cmp;
3459
3460     case BUILT_IN_ISLESSGREATER:
3461       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3462         code = UNEQ_EXPR;
3463       else
3464         code = EQ_EXPR;
3465       goto unordered_cmp;
3466
3467     case BUILT_IN_ISUNORDERED:
3468       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3469         return integer_zero_node;
3470       code = UNORDERED_EXPR;
3471       goto unordered_cmp;
3472
3473     unordered_cmp:
3474       {
3475         tree arg0, arg1;
3476
3477         if (params == 0
3478             || TREE_CHAIN (params) == 0)
3479           {
3480             error ("too few arguments to function `%s'",
3481                    IDENTIFIER_POINTER (DECL_NAME (function)));
3482             return error_mark_node;
3483           }
3484         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3485           {
3486             error ("too many arguments to function `%s'",
3487                    IDENTIFIER_POINTER (DECL_NAME (function)));
3488             return error_mark_node;
3489           }
3490
3491         arg0 = TREE_VALUE (params);
3492         arg1 = TREE_VALUE (TREE_CHAIN (params));
3493         arg0 = build_binary_op (code, arg0, arg1, 0);
3494         if (code != UNORDERED_EXPR)
3495           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3496         return arg0;
3497       }
3498       break;
3499
3500     default:
3501       break;
3502     }
3503
3504   return NULL_TREE;
3505 }
3506
3507 /* Returns non-zero if CODE is the code for a statement.  */
3508
3509 int
3510 statement_code_p (code)
3511      enum tree_code code;
3512 {
3513   switch (code)
3514     {
3515     case EXPR_STMT:
3516     case COMPOUND_STMT:
3517     case DECL_STMT:
3518     case IF_STMT:
3519     case FOR_STMT:
3520     case WHILE_STMT:
3521     case DO_STMT:
3522     case RETURN_STMT:
3523     case BREAK_STMT:
3524     case CONTINUE_STMT:
3525     case SCOPE_STMT:
3526     case SWITCH_STMT:
3527     case GOTO_STMT:
3528     case LABEL_STMT:
3529     case ASM_STMT:
3530     case CASE_LABEL:
3531       return 1;
3532
3533     default:
3534       if (lang_statement_code_p)
3535         return (*lang_statement_code_p) (code);
3536       return 0;
3537     }
3538 }
3539
3540 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3541    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3542    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3543    value, the traversal is aborted, and the value returned by FUNC is
3544    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3545    the node being visited are not walked.
3546
3547    We don't need a without_duplicates variant of this one because the
3548    statement tree is a tree, not a graph.  */
3549
3550 tree
3551 walk_stmt_tree (tp, func, data)
3552      tree *tp;
3553      walk_tree_fn func;
3554      void *data;
3555 {
3556   enum tree_code code;
3557   int walk_subtrees;
3558   tree result;
3559   int i, len;
3560
3561 #define WALK_SUBTREE(NODE)                              \
3562   do                                                    \
3563     {                                                   \
3564       result = walk_stmt_tree (&(NODE), func, data);    \
3565       if (result)                                       \
3566         return result;                                  \
3567     }                                                   \
3568   while (0)
3569
3570   /* Skip empty subtrees.  */
3571   if (!*tp)
3572     return NULL_TREE;
3573
3574   /* Skip subtrees below non-statement nodes.  */
3575   if (!statement_code_p (TREE_CODE (*tp)))
3576     return NULL_TREE;
3577
3578   /* Call the function.  */
3579   walk_subtrees = 1;
3580   result = (*func) (tp, &walk_subtrees, data);
3581
3582   /* If we found something, return it.  */
3583   if (result)
3584     return result;
3585
3586   /* FUNC may have modified the tree, recheck that we're looking at a
3587      statement node.  */
3588   code = TREE_CODE (*tp);
3589   if (!statement_code_p (code))
3590     return NULL_TREE;
3591
3592   /* Visit the subtrees unless FUNC decided that there was nothing
3593      interesting below this point in the tree.  */
3594   if (walk_subtrees)
3595     {
3596       /* Walk over all the sub-trees of this operand.  Statement nodes
3597          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3598       len = TREE_CODE_LENGTH (code);
3599
3600       /* Go through the subtrees.  We need to do this in forward order so
3601          that the scope of a FOR_EXPR is handled properly.  */
3602       for (i = 0; i < len; ++i)
3603         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3604     }
3605
3606   /* Finally visit the chain.  This can be tail-recursion optimized if
3607      we write it this way.  */
3608   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3609
3610 #undef WALK_SUBTREE
3611 }
3612
3613 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3614    representing case labels, or NULL_TREE for a `default' label.
3615    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3616    K2, and 0 if K1 and K2 are equal.  */
3617
3618 int
3619 case_compare (k1, k2)
3620      splay_tree_key k1;
3621      splay_tree_key k2;
3622 {
3623   /* Consider a NULL key (such as arises with a `default' label) to be
3624      smaller than anything else.  */
3625   if (!k1)
3626     return k2 ? -1 : 0;
3627   else if (!k2)
3628     return k1 ? 1 : 0;
3629
3630   return tree_int_cst_compare ((tree) k1, (tree) k2);
3631 }
3632
3633 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3634    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3635    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3636    case label was declared using the usual C/C++ syntax, rather than
3637    the GNU case range extension.  CASES is a tree containing all the
3638    case ranges processed so far; COND is the condition for the
3639    switch-statement itself.  Returns the CASE_LABEL created, or
3640    ERROR_MARK_NODE if no CASE_LABEL is created.  */
3641
3642 tree
3643 c_add_case_label (cases, cond, low_value, high_value)
3644      splay_tree cases;
3645      tree cond;
3646      tree low_value;
3647      tree high_value;
3648 {
3649   tree type;
3650   tree label;
3651   tree case_label;
3652   splay_tree_node node;
3653
3654   /* Create the LABEL_DECL itself.  */
3655   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3656   DECL_CONTEXT (label) = current_function_decl;
3657
3658   /* If there was an error processing the switch condition, bail now
3659      before we get more confused.  */
3660   if (!cond || cond == error_mark_node)
3661     {
3662       /* Add a label anyhow so that the back-end doesn't think that
3663          the beginning of the switch is unreachable.  */
3664       if (!cases->root)
3665         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3666       return error_mark_node;
3667     }
3668
3669   if ((low_value && TREE_TYPE (low_value)
3670        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3671       || (high_value && TREE_TYPE (high_value)
3672           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3673     error ("pointers are not permitted as case values");
3674
3675   /* Case ranges are a GNU extension.  */
3676   if (high_value && pedantic)
3677     {
3678       if (c_language == clk_cplusplus)
3679         pedwarn ("ISO C++ forbids range expressions in switch statements");
3680       else
3681         pedwarn ("ISO C forbids range expressions in switch statements");
3682     }
3683
3684   type = TREE_TYPE (cond);
3685   if (low_value)
3686     {
3687       low_value = check_case_value (low_value);
3688       low_value = convert_and_check (type, low_value);
3689     }
3690   if (high_value)
3691     {
3692       high_value = check_case_value (high_value);
3693       high_value = convert_and_check (type, high_value);
3694     }
3695
3696   /* If an error has occurred, bail out now.  */
3697   if (low_value == error_mark_node || high_value == error_mark_node)
3698     {
3699       if (!cases->root)
3700         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3701       return error_mark_node;
3702     }
3703
3704   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3705      really a case range, even though it was written that way.  Remove
3706      the HIGH_VALUE to simplify later processing.  */
3707   if (tree_int_cst_equal (low_value, high_value))
3708     high_value = NULL_TREE;
3709   if (low_value && high_value
3710       && !tree_int_cst_lt (low_value, high_value))
3711     warning ("empty range specified");
3712
3713   /* Look up the LOW_VALUE in the table of case labels we already
3714      have.  */
3715   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3716   /* If there was not an exact match, check for overlapping ranges.
3717      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3718      that's a `default' label and the only overlap is an exact match.  */
3719   if (!node && (low_value || high_value))
3720     {
3721       splay_tree_node low_bound;
3722       splay_tree_node high_bound;
3723
3724       /* Even though there wasn't an exact match, there might be an
3725          overlap between this case range and another case range.
3726          Since we've (inductively) not allowed any overlapping case
3727          ranges, we simply need to find the greatest low case label
3728          that is smaller that LOW_VALUE, and the smallest low case
3729          label that is greater than LOW_VALUE.  If there is an overlap
3730          it will occur in one of these two ranges.  */
3731       low_bound = splay_tree_predecessor (cases,
3732                                           (splay_tree_key) low_value);
3733       high_bound = splay_tree_successor (cases,
3734                                          (splay_tree_key) low_value);
3735
3736       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3737          the LOW_VALUE, so there is no need to check unless the
3738          LOW_BOUND is in fact itself a case range.  */
3739       if (low_bound
3740           && CASE_HIGH ((tree) low_bound->value)
3741           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3742                                     low_value) >= 0)
3743         node = low_bound;
3744       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3745          range is bigger than the low end of the current range, so we
3746          are only interested if the current range is a real range, and
3747          not an ordinary case label.  */
3748       else if (high_bound
3749                && high_value
3750                && (tree_int_cst_compare ((tree) high_bound->key,
3751                                          high_value)
3752                    <= 0))
3753         node = high_bound;
3754     }
3755   /* If there was an overlap, issue an error.  */
3756   if (node)
3757     {
3758       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3759
3760       if (high_value)
3761         {
3762           error ("duplicate (or overlapping) case value");
3763           error_with_decl (duplicate,
3764                            "this is the first entry overlapping that value");
3765         }
3766       else if (low_value)
3767         {
3768           error ("duplicate case value") ;
3769           error_with_decl (duplicate, "previously used here");
3770         }
3771       else
3772         {
3773           error ("multiple default labels in one switch");
3774           error_with_decl (duplicate, "this is the first default label");
3775         }
3776       if (!cases->root)
3777         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3778     }
3779
3780   /* Add a CASE_LABEL to the statement-tree.  */
3781   case_label = add_stmt (build_case_label (low_value, high_value, label));
3782   /* Register this case label in the splay tree.  */
3783   splay_tree_insert (cases,
3784                      (splay_tree_key) low_value,
3785                      (splay_tree_value) case_label);
3786
3787   return case_label;
3788 }
3789
3790 /* Finish an expression taking the address of LABEL.  Returns an
3791    expression for the address.  */
3792
3793 tree
3794 finish_label_address_expr (label)
3795      tree label;
3796 {
3797   tree result;
3798
3799   if (pedantic)
3800     {
3801       if (c_language == clk_cplusplus)
3802         pedwarn ("ISO C++ forbids taking the address of a label");
3803       else
3804         pedwarn ("ISO C forbids taking the address of a label");
3805     }
3806
3807   label = lookup_label (label);
3808   if (label == NULL_TREE)
3809     result = null_pointer_node;
3810   else
3811     {
3812       TREE_USED (label) = 1;
3813       result = build1 (ADDR_EXPR, ptr_type_node, label);
3814       TREE_CONSTANT (result) = 1;
3815       /* The current function in not necessarily uninlinable.
3816          Computed gotos are incompatible with inlining, but the value
3817          here could be used only in a diagnostic, for example.  */
3818     }
3819
3820   return result;
3821 }
3822
3823 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
3824    parameter allows this function to be used as a GC-marking
3825    function.  */
3826
3827 void
3828 mark_stmt_tree (p)
3829      void *p;
3830 {
3831   stmt_tree st = (stmt_tree) p;
3832
3833   ggc_mark_tree (st->x_last_stmt);
3834   ggc_mark_tree (st->x_last_expr_type);
3835 }
3836
3837 /* Mark LD for GC.  */
3838
3839 void
3840 c_mark_lang_decl (c)
3841      struct c_lang_decl *c;
3842 {
3843   ggc_mark_tree (c->saved_tree);
3844 }
3845
3846 /* Mark F for GC.  */
3847
3848 void
3849 mark_c_language_function (f)
3850      struct language_function *f;
3851 {
3852   if (!f)
3853     return;
3854
3855   mark_stmt_tree (&f->x_stmt_tree);
3856   ggc_mark_tree (f->x_scope_stmt_stack);
3857 }
3858
3859 /* Hook used by expand_expr to expand language-specific tree codes.  */
3860
3861 rtx
3862 c_expand_expr (exp, target, tmode, modifier)
3863      tree exp;
3864      rtx target;
3865      enum machine_mode tmode;
3866      enum expand_modifier modifier;
3867 {
3868   switch (TREE_CODE (exp))
3869     {
3870     case STMT_EXPR:
3871       {
3872         tree rtl_expr;
3873         rtx result;
3874
3875         /* Since expand_expr_stmt calls free_temp_slots after every
3876            expression statement, we must call push_temp_slots here.
3877            Otherwise, any temporaries in use now would be considered
3878            out-of-scope after the first EXPR_STMT from within the
3879            STMT_EXPR.  */
3880         push_temp_slots ();
3881         rtl_expr = expand_start_stmt_expr ();
3882         expand_stmt (STMT_EXPR_STMT (exp));
3883         expand_end_stmt_expr (rtl_expr);
3884         result = expand_expr (rtl_expr, target, tmode, modifier);
3885         pop_temp_slots ();
3886         return result;
3887       }
3888       break;
3889
3890     case CALL_EXPR:
3891       {
3892         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3893             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3894                 == FUNCTION_DECL)
3895             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3896             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3897                 == BUILT_IN_FRONTEND))
3898           return c_expand_builtin (exp, target, tmode, modifier);
3899         else
3900           abort();
3901       }
3902       break;
3903
3904     default:
3905       abort ();
3906     }
3907
3908   abort ();
3909   return NULL;
3910 }
3911
3912 /* Hook used by safe_from_p to handle language-specific tree codes.  */
3913
3914 int
3915 c_safe_from_p (target, exp)
3916      rtx target;
3917      tree exp;
3918 {
3919   /* We can see statements here when processing the body of a
3920      statement-expression.  For a declaration statement declaring a
3921      variable, look at the variable's initializer.  */
3922   if (TREE_CODE (exp) == DECL_STMT)
3923     {
3924       tree decl = DECL_STMT_DECL (exp);
3925
3926       if (TREE_CODE (decl) == VAR_DECL
3927           && DECL_INITIAL (decl)
3928           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3929         return 0;
3930     }
3931
3932   /* For any statement, we must follow the statement-chain.  */
3933   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3934     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3935
3936   /* Assume everything else is safe.  */
3937   return 1;
3938 }
3939
3940 /* Hook used by unsafe_for_reeval to handle language-specific tree codes.  */
3941
3942 int
3943 c_unsafe_for_reeval (exp)
3944      tree exp;
3945 {
3946   /* Statement expressions may not be reevaluated.  */
3947   if (TREE_CODE (exp) == STMT_EXPR)
3948     return 2;
3949
3950   /* Walk all other expressions.  */
3951   return -1;
3952 }
3953
3954 /* Tree code classes. */
3955
3956 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3957
3958 static char c_tree_code_type[] = {
3959   'x',
3960 #include "c-common.def"
3961 };
3962 #undef DEFTREECODE
3963
3964 /* Table indexed by tree code giving number of expression
3965    operands beyond the fixed part of the node structure.
3966    Not used for types or decls.  */
3967
3968 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3969
3970 static int c_tree_code_length[] = {
3971   0,
3972 #include "c-common.def"
3973 };
3974 #undef DEFTREECODE
3975
3976 /* Names of tree components.
3977    Used for printing out the tree and error messages.  */
3978 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3979
3980 static const char *c_tree_code_name[] = {
3981   "@@dummy",
3982 #include "c-common.def"
3983 };
3984 #undef DEFTREECODE
3985
3986 /* Adds the tree codes specific to the C front end to the list of all
3987    tree codes. */
3988
3989 void
3990 add_c_tree_codes ()
3991 {
3992   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3993           c_tree_code_type,
3994           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3995   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3996           c_tree_code_length,
3997           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3998   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3999           c_tree_code_name,
4000           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
4001   lang_unsafe_for_reeval = c_unsafe_for_reeval;
4002 }
4003
4004 #define CALLED_AS_BUILT_IN(NODE) \
4005    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4006
4007 static rtx
4008 c_expand_builtin (exp, target, tmode, modifier)
4009      tree exp;
4010      rtx target;
4011      enum machine_mode tmode;
4012      enum expand_modifier modifier;
4013 {
4014   tree type = TREE_TYPE (exp);
4015   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4016   tree arglist = TREE_OPERAND (exp, 1);
4017   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4018   enum tree_code code = TREE_CODE (exp);
4019   const int ignore = (target == const0_rtx
4020                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4021                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
4022                            || code == COND_EXPR)
4023                           && TREE_CODE (type) == VOID_TYPE));
4024
4025   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4026     return expand_call (exp, target, ignore);
4027
4028   switch (fcode)
4029     {
4030     case BUILT_IN_PRINTF:
4031       target = c_expand_builtin_printf (arglist, target, tmode,
4032                                         modifier, ignore);
4033       if (target)
4034         return target;
4035       break;
4036
4037     case BUILT_IN_FPRINTF:
4038       target = c_expand_builtin_fprintf (arglist, target, tmode,
4039                                          modifier, ignore);
4040       if (target)
4041         return target;
4042       break;
4043
4044     default:                    /* just do library call, if unknown builtin */
4045       error ("built-in function `%s' not currently supported",
4046              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4047     }
4048
4049   /* The switch statement above can drop through to cause the function
4050      to be called normally.  */
4051   return expand_call (exp, target, ignore);
4052 }
4053
4054 /* Check an arglist to *printf for problems.  The arglist should start
4055    at the format specifier, with the remaining arguments immediately
4056    following it. */
4057 static int
4058 is_valid_printf_arglist (arglist)
4059   tree arglist;
4060 {
4061   /* Save this value so we can restore it later. */
4062   const int SAVE_pedantic = pedantic;
4063   int diagnostic_occurred = 0;
4064
4065   /* Set this to a known value so the user setting won't affect code
4066      generation.  */
4067   pedantic = 1;
4068   /* Check to make sure there are no format specifier errors. */
4069   check_function_format (&diagnostic_occurred,
4070                          maybe_get_identifier("printf"),
4071                          NULL_TREE, arglist);
4072
4073   /* Restore the value of `pedantic'. */
4074   pedantic = SAVE_pedantic;
4075
4076   /* If calling `check_function_format_ptr' produces a warning, we
4077      return false, otherwise we return true. */
4078   return ! diagnostic_occurred;
4079 }
4080
4081 /* If the arguments passed to printf are suitable for optimizations,
4082    we attempt to transform the call. */
4083 static rtx
4084 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
4085      tree arglist;
4086      rtx target;
4087      enum machine_mode tmode;
4088      enum expand_modifier modifier;
4089      int ignore;
4090 {
4091   tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
4092     fn_puts = built_in_decls[BUILT_IN_PUTS];
4093   tree fn, format_arg, stripped_string;
4094
4095   /* If the return value is used, or the replacement _DECL isn't
4096      initialized, don't do the transformation. */
4097   if (!ignore || !fn_putchar || !fn_puts)
4098     return 0;
4099
4100   /* Verify the required arguments in the original call. */
4101   if (arglist == 0
4102       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4103     return 0;
4104
4105   /* Check the specifier vs. the parameters. */
4106   if (!is_valid_printf_arglist (arglist))
4107     return 0;
4108
4109   format_arg = TREE_VALUE (arglist);
4110   stripped_string = format_arg;
4111   STRIP_NOPS (stripped_string);
4112   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4113     stripped_string = TREE_OPERAND (stripped_string, 0);
4114
4115   /* If the format specifier isn't a STRING_CST, punt.  */
4116   if (TREE_CODE (stripped_string) != STRING_CST)
4117     return 0;
4118
4119   /* OK!  We can attempt optimization.  */
4120
4121   /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4122   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4123     {
4124       arglist = TREE_CHAIN (arglist);
4125       fn = fn_puts;
4126     }
4127   /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4128   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4129     {
4130       arglist = TREE_CHAIN (arglist);
4131       fn = fn_putchar;
4132     }
4133   else
4134     {
4135      /* We can't handle anything else with % args or %% ... yet. */
4136       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4137         return 0;
4138
4139       /* If the resulting constant string has a length of 1, call
4140          putchar.  Note, TREE_STRING_LENGTH includes the terminating
4141          NULL in its count.  */
4142       if (TREE_STRING_LENGTH (stripped_string) == 2)
4143         {
4144           /* Given printf("c"), (where c is any one character,)
4145              convert "c"[0] to an int and pass that to the replacement
4146              function. */
4147           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4148           arglist = build_tree_list (NULL_TREE, arglist);
4149
4150           fn = fn_putchar;
4151         }
4152       /* If the resulting constant was "string\n", call
4153          __builtin_puts("string").  Ensure "string" has at least one
4154          character besides the trailing \n.  Note, TREE_STRING_LENGTH
4155          includes the terminating NULL in its count.  */
4156       else if (TREE_STRING_LENGTH (stripped_string) > 2
4157                && TREE_STRING_POINTER (stripped_string)
4158                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4159         {
4160           /* Create a NULL-terminated string that's one char shorter
4161              than the original, stripping off the trailing '\n'.  */
4162           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4163           char *newstr = (char *) alloca (newlen);
4164           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4165           newstr[newlen - 1] = 0;
4166
4167           arglist = combine_strings (build_string (newlen, newstr));
4168           arglist = build_tree_list (NULL_TREE, arglist);
4169           fn = fn_puts;
4170         }
4171       else
4172         /* We'd like to arrange to call fputs(string) here, but we
4173            need stdout and don't have a way to get it ... yet.  */
4174         return 0;
4175     }
4176
4177   return expand_expr (build_function_call (fn, arglist),
4178                       (ignore ? const0_rtx : target),
4179                       tmode, modifier);
4180 }
4181
4182 /* If the arguments passed to fprintf are suitable for optimizations,
4183    we attempt to transform the call. */
4184 static rtx
4185 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
4186      tree arglist;
4187      rtx target;
4188      enum machine_mode tmode;
4189      enum expand_modifier modifier;
4190      int ignore;
4191 {
4192   tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
4193     fn_fputs = built_in_decls[BUILT_IN_FPUTS];
4194   tree fn, format_arg, stripped_string;
4195
4196   /* If the return value is used, or the replacement _DECL isn't
4197      initialized, don't do the transformation. */
4198   if (!ignore || !fn_fputc || !fn_fputs)
4199     return 0;
4200
4201   /* Verify the required arguments in the original call. */
4202   if (arglist == 0
4203       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4204       || (TREE_CHAIN (arglist) == 0)
4205       || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4206           POINTER_TYPE))
4207     return 0;
4208
4209   /* Check the specifier vs. the parameters. */
4210   if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4211     return 0;
4212
4213   format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4214   stripped_string = format_arg;
4215   STRIP_NOPS (stripped_string);
4216   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4217     stripped_string = TREE_OPERAND (stripped_string, 0);
4218
4219   /* If the format specifier isn't a STRING_CST, punt.  */
4220   if (TREE_CODE (stripped_string) != STRING_CST)
4221     return 0;
4222
4223   /* OK!  We can attempt optimization.  */
4224
4225   /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4226   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4227     {
4228       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4229       arglist = tree_cons (NULL_TREE,
4230                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4231                            newarglist);
4232       fn = fn_fputs;
4233     }
4234   /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4235   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4236     {
4237       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4238       arglist = tree_cons (NULL_TREE,
4239                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4240                            newarglist);
4241       fn = fn_fputc;
4242     }
4243   else
4244     {
4245      /* We can't handle anything else with % args or %% ... yet. */
4246       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4247         return 0;
4248
4249       /* When "string" doesn't contain %, replace all cases of
4250          fprintf(stream,string) with fputs(string,stream).  The fputs
4251          builtin will take take of special cases like length==1.  */
4252       arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4253                            build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4254       fn = fn_fputs;
4255     }
4256
4257   return expand_expr (build_function_call (fn, arglist),
4258                       (ignore ? const0_rtx : target),
4259                       tmode, modifier);
4260 }
4261 \f
4262
4263 /* Given a boolean expression ARG, return a tree representing an increment
4264    or decrement (as indicated by CODE) of ARG.  The front end must check for
4265    invalid cases (e.g., decrement in C++).  */
4266 tree
4267 boolean_increment (code, arg)
4268      enum tree_code code;
4269      tree arg;
4270 {
4271   tree val;
4272   tree true_res = (c_language == clk_cplusplus
4273                    ? boolean_true_node
4274                    : c_bool_true_node);
4275   arg = stabilize_reference (arg);
4276   switch (code)
4277     {
4278     case PREINCREMENT_EXPR:
4279       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4280       break;
4281     case POSTINCREMENT_EXPR:
4282       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4283       arg = save_expr (arg);
4284       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4285       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4286       break;
4287     case PREDECREMENT_EXPR:
4288       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4289       break;
4290     case POSTDECREMENT_EXPR:
4291       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4292       arg = save_expr (arg);
4293       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4294       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4295       break;
4296     default:
4297       abort ();
4298     }
4299   TREE_SIDE_EFFECTS (val) = 1;
4300   return val;
4301 }
4302 \f
4303
4304 /* Do the parts of lang_init common to C and C++.  */
4305 void
4306 c_common_lang_init ()
4307 {
4308   /* If still "unspecified", make it match -fbounded-pointers.  */
4309   if (flag_bounds_check < 0)
4310     flag_bounds_check = flag_bounded_pointers;
4311
4312   /* Special format checking options don't work without -Wformat; warn if
4313      they are used.  */
4314   if (warn_format_y2k && !warn_format)
4315     warning ("-Wformat-y2k ignored without -Wformat");
4316   if (warn_format_extra_args && !warn_format)
4317     warning ("-Wformat-extra-args ignored without -Wformat");
4318   if (warn_format_nonliteral && !warn_format)
4319     warning ("-Wformat-nonliteral ignored without -Wformat");
4320   if (warn_format_security && !warn_format)
4321     warning ("-Wformat-security ignored without -Wformat");
4322   if (warn_missing_format_attribute && !warn_format)
4323     warning ("-Wmissing-format-attribute ignored without -Wformat");
4324 }