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 GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "toplev.h"
  27 #include "output.h"
  28 #include "c-pragma.h"
  29 #include "rtl.h"
  30 #include "ggc.h"
  31 #include "expr.h"
  32 #include "c-common.h"
  33 #include "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           if (targetm.have_named_sections)
 975             {
 976               if ((TREE_CODE (decl) == FUNCTION_DECL
 977                    || TREE_CODE (decl) == VAR_DECL)
 978                   && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 979                 {
 980                   if (TREE_CODE (decl) == VAR_DECL
 981                       && current_function_decl != NULL_TREE
 982                       && ! TREE_STATIC (decl))
 983                     error_with_decl (decl,
 984                                      "section attribute cannot be specified for local variables");
 985                   /* The decl may have already been given a section attribute
 986                      from a previous declaration.  Ensure they match.  */
 987                   else if (DECL_SECTION_NAME (decl) != NULL_TREE
 988                            && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 989                                       TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 990                     error_with_decl (*node,
 991                                      "section of `%s' conflicts with previous declaration");
 992                   else
 993                     DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 994                 }
 995               else
 996                 error_with_decl (*node,
 997                                  "section attribute not allowed for `%s'");
 998             }
 999           else
1000             error_with_decl (*node,
1001                              "section attributes are not supported for this target");
1002           break;
1003
1004         case A_ALIGNED:
1005           {
1006             tree align_expr
1007               = (args ? TREE_VALUE (args)
1008                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1009             int i;
1010
1011             /* Strip any NOPs of any kind.  */
1012             while (TREE_CODE (align_expr) == NOP_EXPR
1013                    || TREE_CODE (align_expr) == CONVERT_EXPR
1014                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
1015               align_expr = TREE_OPERAND (align_expr, 0);
1016
1017             if (TREE_CODE (align_expr) != INTEGER_CST)
1018               {
1019                 error ("requested alignment is not a constant");
1020                 continue;
1021               }
1022
1023             if ((i = tree_log2 (align_expr)) == -1)
1024               error ("requested alignment is not a power of 2");
1025             else if (i > HOST_BITS_PER_INT - 2)
1026               error ("requested alignment is too large");
1027             else if (is_type)
1028               {
1029                 /* If we have a TYPE_DECL, then copy the type, so that we
1030                    don't accidentally modify a builtin type.  See pushdecl.  */
1031                 if (decl && TREE_TYPE (decl) != error_mark_node
1032                     && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
1033                   {
1034                     tree tt = TREE_TYPE (decl);
1035                     DECL_ORIGINAL_TYPE (decl) = tt;
1036                     tt = build_type_copy (tt);
1037                     TYPE_NAME (tt) = decl;
1038                     TREE_USED (tt) = TREE_USED (decl);
1039                     TREE_TYPE (decl) = tt;
1040                     type = tt;
1041                   }
1042
1043                 TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
1044                 TYPE_USER_ALIGN (type) = 1;
1045               }
1046             else if (TREE_CODE (decl) != VAR_DECL
1047                      && TREE_CODE (decl) != FIELD_DECL)
1048               error_with_decl (decl,
1049                                "alignment may not be specified for `%s'");
1050             else
1051               {
1052                 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
1053                 DECL_USER_ALIGN (decl) = 1;
1054               }
1055           }
1056           break;
1057
1058         case A_FORMAT:
1059           decl_handle_format_attribute (decl, args);
1060           break;
1061
1062         case A_FORMAT_ARG:
1063           decl_handle_format_arg_attribute (decl, args);
1064           break;
1065
1066         case A_WEAK:
1067           declare_weak (decl);
1068           break;
1069
1070         case A_ALIAS:
1071           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
1072               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
1073             error_with_decl (decl,
1074                              "`%s' defined both normally and as an alias");
1075           else if (decl_function_context (decl) == 0)
1076             {
1077               tree id;
1078
1079               id = TREE_VALUE (args);
1080               if (TREE_CODE (id) != STRING_CST)
1081                 {
1082                   error ("alias arg not a string");
1083                   break;
1084                 }
1085               id = get_identifier (TREE_STRING_POINTER (id));
1086               /* This counts as a use of the object pointed to.  */
1087               TREE_USED (id) = 1;
1088
1089               if (TREE_CODE (decl) == FUNCTION_DECL)
1090                 DECL_INITIAL (decl) = error_mark_node;
1091               else
1092                 DECL_EXTERNAL (decl) = 0;
1093               assemble_alias (decl, id);
1094             }
1095           else
1096             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1097           break;
1098
1099         case A_NO_CHECK_MEMORY_USAGE:
1100           if (TREE_CODE (decl) != FUNCTION_DECL)
1101             {
1102               error_with_decl (decl,
1103                                "`%s' attribute applies only to functions",
1104                                IDENTIFIER_POINTER (name));
1105             }
1106           else if (DECL_INITIAL (decl))
1107             {
1108               error_with_decl (decl,
1109                                "can't set `%s' attribute after definition",
1110                                IDENTIFIER_POINTER (name));
1111             }
1112           else
1113             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1114           break;
1115
1116         case A_NO_INSTRUMENT_FUNCTION:
1117           if (TREE_CODE (decl) != FUNCTION_DECL)
1118             {
1119               error_with_decl (decl,
1120                                "`%s' attribute applies only to functions",
1121                                IDENTIFIER_POINTER (name));
1122             }
1123           else if (DECL_INITIAL (decl))
1124             {
1125               error_with_decl (decl,
1126                                "can't set `%s' attribute after definition",
1127                                IDENTIFIER_POINTER (name));
1128             }
1129           else
1130             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1131           break;
1132
1133         case A_NO_LIMIT_STACK:
1134           if (TREE_CODE (decl) != FUNCTION_DECL)
1135             {
1136               error_with_decl (decl,
1137                                "`%s' attribute applies only to functions",
1138                                IDENTIFIER_POINTER (name));
1139             }
1140           else if (DECL_INITIAL (decl))
1141             {
1142               error_with_decl (decl,
1143                                "can't set `%s' attribute after definition",
1144                                IDENTIFIER_POINTER (name));
1145             }
1146           else
1147             DECL_NO_LIMIT_STACK (decl) = 1;
1148           break;
1149         }
1150     }
1151   return NULL_TREE;
1152 }
1153
1154 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1155    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1156
1157    The head of the declspec list is stored in DECLSPECS.
1158    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1159
1160    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1161    the list elements.  We drop the containing TREE_LIST nodes and link the
1162    resulting attributes together the way decl_attributes expects them.  */
1163
1164 void
1165 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1166      tree specs_attrs;
1167      tree *declspecs, *prefix_attributes;
1168 {
1169   tree t, s, a, next, specs, attrs;
1170
1171   /* This can happen after an __extension__ in pedantic mode.  */
1172   if (specs_attrs != NULL_TREE
1173       && TREE_CODE (specs_attrs) == INTEGER_CST)
1174     {
1175       *declspecs = NULL_TREE;
1176       *prefix_attributes = NULL_TREE;
1177       return;
1178     }
1179
1180   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1181   if (specs_attrs != NULL_TREE
1182       && TREE_CODE (specs_attrs) != TREE_LIST)
1183     {
1184       *declspecs = specs_attrs;
1185       *prefix_attributes = NULL_TREE;
1186       return;
1187     }
1188
1189   /* Remember to keep the lists in the same order, element-wise.  */
1190
1191   specs = s = NULL_TREE;
1192   attrs = a = NULL_TREE;
1193   for (t = specs_attrs; t; t = next)
1194     {
1195       next = TREE_CHAIN (t);
1196       /* Declspecs have a non-NULL TREE_VALUE.  */
1197       if (TREE_VALUE (t) != NULL_TREE)
1198         {
1199           if (specs == NULL_TREE)
1200             specs = s = t;
1201           else
1202             {
1203               TREE_CHAIN (s) = t;
1204               s = t;
1205             }
1206         }
1207       /* The TREE_PURPOSE may also be empty in the case of
1208          __attribute__(()).  */
1209       else if (TREE_PURPOSE (t) != NULL_TREE)
1210         {
1211           if (attrs == NULL_TREE)
1212             attrs = a = TREE_PURPOSE (t);
1213           else
1214             {
1215               TREE_CHAIN (a) = TREE_PURPOSE (t);
1216               a = TREE_PURPOSE (t);
1217             }
1218           /* More attrs can be linked here, move A to the end.  */
1219           while (TREE_CHAIN (a) != NULL_TREE)
1220             a = TREE_CHAIN (a);
1221         }
1222     }
1223
1224   /* Terminate the lists.  */
1225   if (s != NULL_TREE)
1226     TREE_CHAIN (s) = NULL_TREE;
1227   if (a != NULL_TREE)
1228     TREE_CHAIN (a) = NULL_TREE;
1229
1230   /* All done.  */
1231   *declspecs = specs;
1232   *prefix_attributes = attrs;
1233 }
1234
1235 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1236    This function is used by the parser when a rule will accept attributes
1237    in a particular position, but we don't want to support that just yet.
1238
1239    A warning is issued for every ignored attribute.  */
1240
1241 tree
1242 strip_attrs (specs_attrs)
1243      tree specs_attrs;
1244 {
1245   tree specs, attrs;
1246
1247   split_specs_attrs (specs_attrs, &specs, &attrs);
1248
1249   while (attrs)
1250     {
1251       warning ("`%s' attribute ignored",
1252                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1253       attrs = TREE_CHAIN (attrs);
1254     }
1255
1256   return specs;
1257 }
1258 \f
1259 static int is_valid_printf_arglist PARAMS ((tree));
1260 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1261 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1262                                             enum expand_modifier, int));
1263 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
1264                                              enum expand_modifier, int));
1265 \f
1266 /* Print a warning if a constant expression had overflow in folding.
1267    Invoke this function on every expression that the language
1268    requires to be a constant expression.
1269    Note the ANSI C standard says it is erroneous for a
1270    constant expression to overflow.  */
1271
1272 void
1273 constant_expression_warning (value)
1274      tree value;
1275 {
1276   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1277        || TREE_CODE (value) == COMPLEX_CST)
1278       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1279     pedwarn ("overflow in constant expression");
1280 }
1281
1282 /* Print a warning if an expression had overflow in folding.
1283    Invoke this function on every expression that
1284    (1) appears in the source code, and
1285    (2) might be a constant expression that overflowed, and
1286    (3) is not already checked by convert_and_check;
1287    however, do not invoke this function on operands of explicit casts.  */
1288
1289 void
1290 overflow_warning (value)
1291      tree value;
1292 {
1293   if ((TREE_CODE (value) == INTEGER_CST
1294        || (TREE_CODE (value) == COMPLEX_CST
1295            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1296       && TREE_OVERFLOW (value))
1297     {
1298       TREE_OVERFLOW (value) = 0;
1299       if (skip_evaluation == 0)
1300         warning ("integer overflow in expression");
1301     }
1302   else if ((TREE_CODE (value) == REAL_CST
1303             || (TREE_CODE (value) == COMPLEX_CST
1304                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1305            && TREE_OVERFLOW (value))
1306     {
1307       TREE_OVERFLOW (value) = 0;
1308       if (skip_evaluation == 0)
1309         warning ("floating point overflow in expression");
1310     }
1311 }
1312
1313 /* Print a warning if a large constant is truncated to unsigned,
1314    or if -Wconversion is used and a constant < 0 is converted to unsigned.
1315    Invoke this function on every expression that might be implicitly
1316    converted to an unsigned type.  */
1317
1318 void
1319 unsigned_conversion_warning (result, operand)
1320      tree result, operand;
1321 {
1322   if (TREE_CODE (operand) == INTEGER_CST
1323       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
1324       && TREE_UNSIGNED (TREE_TYPE (result))
1325       && skip_evaluation == 0
1326       && !int_fits_type_p (operand, TREE_TYPE (result)))
1327     {
1328       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
1329         /* This detects cases like converting -129 or 256 to unsigned char.  */
1330         warning ("large integer implicitly truncated to unsigned type");
1331       else if (warn_conversion)
1332         warning ("negative integer implicitly converted to unsigned type");
1333     }
1334 }
1335
1336 /* Nonzero if constant C has a value that is permissible
1337    for type TYPE (an INTEGER_TYPE).  */
1338
1339 static int
1340 constant_fits_type_p (c, type)
1341      tree c, type;
1342 {
1343   if (TREE_CODE (c) == INTEGER_CST)
1344     return int_fits_type_p (c, type);
1345
1346   c = convert (type, c);
1347   return !TREE_OVERFLOW (c);
1348 }
1349
1350 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1351    Invoke this function on every expression that is converted implicitly,
1352    i.e. because of language rules and not because of an explicit cast.  */
1353
1354 tree
1355 convert_and_check (type, expr)
1356      tree type, expr;
1357 {
1358   tree t = convert (type, expr);
1359   if (TREE_CODE (t) == INTEGER_CST)
1360     {
1361       if (TREE_OVERFLOW (t))
1362         {
1363           TREE_OVERFLOW (t) = 0;
1364
1365           /* Do not diagnose overflow in a constant expression merely
1366              because a conversion overflowed.  */
1367           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1368
1369           /* No warning for converting 0x80000000 to int.  */
1370           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1371                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1372                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1373             /* If EXPR fits in the unsigned version of TYPE,
1374                don't warn unless pedantic.  */
1375             if ((pedantic
1376                  || TREE_UNSIGNED (type)
1377                  || ! constant_fits_type_p (expr, unsigned_type (type)))
1378                 && skip_evaluation == 0)
1379               warning ("overflow in implicit constant conversion");
1380         }
1381       else
1382         unsigned_conversion_warning (t, expr);
1383     }
1384   return t;
1385 }
1386 \f
1387 /* A node in a list that describes references to variables (EXPR), which are
1388    either read accesses if WRITER is zero, or write accesses, in which case
1389    WRITER is the parent of EXPR.  */
1390 struct tlist
1391 {
1392   struct tlist *next;
1393   tree expr, writer;
1394 };
1395
1396 /* Used to implement a cache the results of a call to verify_tree.  We only
1397    use this for SAVE_EXPRs.  */
1398 struct tlist_cache
1399 {
1400   struct tlist_cache *next;
1401   struct tlist *cache_before_sp;
1402   struct tlist *cache_after_sp;
1403   tree expr;
1404 };
1405
1406 /* Obstack to use when allocating tlist structures, and corresponding
1407    firstobj.  */
1408 static struct obstack tlist_obstack;
1409 static char *tlist_firstobj = 0;
1410
1411 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1412    warnings.  */
1413 static struct tlist *warned_ids;
1414 /* SAVE_EXPRs need special treatment.  We process them only once and then
1415    cache the results.  */
1416 static struct tlist_cache *save_expr_cache;
1417
1418 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
1419 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
1420 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
1421 static int warning_candidate_p PARAMS ((tree));
1422 static void warn_for_collisions PARAMS ((struct tlist *));
1423 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
1424 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
1425 static void verify_sequence_points PARAMS ((tree));
1426
1427 /* Create a new struct tlist and fill in its fields.  */
1428 static struct tlist *
1429 new_tlist (next, t, writer)
1430      struct tlist *next;
1431      tree t;
1432      tree writer;
1433 {
1434   struct tlist *l;
1435   l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1436   l->next = next;
1437   l->expr = t;
1438   l->writer = writer;
1439   return l;
1440 }
1441
1442 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1443    is nonnull, we ignore any node we find which has a writer equal to it.  */
1444
1445 static void
1446 add_tlist (to, add, exclude_writer, copy)
1447      struct tlist **to;
1448      struct tlist *add;
1449      tree exclude_writer;
1450      int copy;
1451 {
1452   while (add)
1453     {
1454       struct tlist *next = add->next;
1455       if (! copy)
1456         add->next = *to;
1457       if (! exclude_writer || add->writer != exclude_writer)
1458         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1459       add = next;
1460     }
1461 }
1462
1463 /* Merge the nodes of ADD into TO.  This merging process is done so that for
1464    each variable that already exists in TO, no new node is added; however if
1465    there is a write access recorded in ADD, and an occurrence on TO is only
1466    a read access, then the occurrence in TO will be modified to record the
1467    write.  */
1468
1469 static void
1470 merge_tlist (to, add, copy)
1471      struct tlist **to;
1472      struct tlist *add;
1473      int copy;
1474 {
1475   struct tlist **end = to;
1476
1477   while (*end)
1478     end = &(*end)->next;
1479
1480   while (add)
1481     {
1482       int found = 0;
1483       struct tlist *tmp2;
1484       struct tlist *next = add->next;
1485
1486       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1487         if (tmp2->expr == add->expr)
1488           {
1489             found = 1;
1490             if (! tmp2->writer)
1491               tmp2->writer = add->writer;
1492           }
1493       if (! found)
1494         {
1495           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1496           end = &(*end)->next;
1497           *end = 0;
1498         }
1499       add = next;
1500     }
1501 }
1502
1503 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1504    references in list LIST conflict with it, excluding reads if ONLY writers
1505    is nonzero.  */
1506
1507 static void
1508 warn_for_collisions_1 (written, writer, list, only_writes)
1509      tree written, writer;
1510      struct tlist *list;
1511      int only_writes;
1512 {
1513   struct tlist *tmp;
1514
1515   /* Avoid duplicate warnings.  */
1516   for (tmp = warned_ids; tmp; tmp = tmp->next)
1517     if (tmp->expr == written)
1518       return;
1519
1520   while (list)
1521     {
1522       if (list->expr == written
1523           && list->writer != writer
1524           && (! only_writes || list->writer))
1525         {
1526           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1527           warning ("operation on `%s' may be undefined",
1528                    IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1529         }
1530       list = list->next;
1531     }
1532 }
1533
1534 /* Given a list LIST of references to variables, find whether any of these
1535    can cause conflicts due to missing sequence points.  */
1536
1537 static void
1538 warn_for_collisions (list)
1539      struct tlist *list;
1540 {
1541   struct tlist *tmp;
1542
1543   for (tmp = list; tmp; tmp = tmp->next)
1544     {
1545       if (tmp->writer)
1546         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1547     }
1548 }
1549
1550 /* Return nonzero if X is a tree that can be verified by the sequence poitn
1551    warnings.  */
1552 static int
1553 warning_candidate_p (x)
1554      tree x;
1555 {
1556   return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1557 }
1558
1559 /* Walk the tree X, and record accesses to variables.  If X is written by the
1560    parent tree, WRITER is the parent.
1561    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1562    expression or its only operand forces a sequence point, then everything up
1563    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1564    in PNO_SP.
1565    Once we return, we will have emitted warnings if any subexpression before
1566    such a sequence point could be undefined.  On a higher level, however, the
1567    sequence point may not be relevant, and we'll merge the two lists.
1568
1569    Example: (b++, a) + b;
1570    The call that processes the COMPOUND_EXPR will store the increment of B
1571    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1572    processes the PLUS_EXPR will need to merge the two lists so that
1573    eventually, all accesses end up on the same list (and we'll warn about the
1574    unordered subexpressions b++ and b.
1575
1576    A note on merging.  If we modify the former example so that our expression
1577    becomes
1578      (b++, b) + a
1579    care must be taken not simply to add all three expressions into the final
1580    PNO_SP list.  The function merge_tlist takes care of that by merging the
1581    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1582    way, so that no more than one access to B is recorded.  */
1583
1584 static void
1585 verify_tree (x, pbefore_sp, pno_sp, writer)
1586      tree x;
1587      struct tlist **pbefore_sp, **pno_sp;
1588      tree writer;
1589 {
1590   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1591   enum tree_code code;
1592   char class;
1593
1594   /* X may be NULL if it is the operand of an empty statement expression
1595      ({ }).  */
1596   if (x == NULL)
1597     return;
1598
1599  restart:
1600   code = TREE_CODE (x);
1601   class = TREE_CODE_CLASS (code);
1602
1603   if (warning_candidate_p (x))
1604     {
1605       *pno_sp = new_tlist (*pno_sp, x, writer);
1606       return;
1607     }
1608
1609   switch (code)
1610     {
1611     case CONSTRUCTOR:
1612       return;
1613
1614     case COMPOUND_EXPR:
1615     case TRUTH_ANDIF_EXPR:
1616     case TRUTH_ORIF_EXPR:
1617       tmp_before = tmp_nosp = tmp_list3 = 0;
1618       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1619       warn_for_collisions (tmp_nosp);
1620       merge_tlist (pbefore_sp, tmp_before, 0);
1621       merge_tlist (pbefore_sp, tmp_nosp, 0);
1622       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1623       merge_tlist (pbefore_sp, tmp_list3, 0);
1624       return;
1625
1626     case COND_EXPR:
1627       tmp_before = tmp_list2 = 0;
1628       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1629       warn_for_collisions (tmp_list2);
1630       merge_tlist (pbefore_sp, tmp_before, 0);
1631       merge_tlist (pbefore_sp, tmp_list2, 1);
1632
1633       tmp_list3 = tmp_nosp = 0;
1634       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1635       warn_for_collisions (tmp_nosp);
1636       merge_tlist (pbefore_sp, tmp_list3, 0);
1637
1638       tmp_list3 = tmp_list2 = 0;
1639       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1640       warn_for_collisions (tmp_list2);
1641       merge_tlist (pbefore_sp, tmp_list3, 0);
1642       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1643          two first, to avoid warning for (a ? b++ : b++).  */
1644       merge_tlist (&tmp_nosp, tmp_list2, 0);
1645       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1646       return;
1647
1648     case PREDECREMENT_EXPR:
1649     case PREINCREMENT_EXPR:
1650     case POSTDECREMENT_EXPR:
1651     case POSTINCREMENT_EXPR:
1652       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1653       return;
1654
1655     case MODIFY_EXPR:
1656       tmp_before = tmp_nosp = tmp_list3 = 0;
1657       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1658       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1659       /* Expressions inside the LHS are not ordered wrt. the sequence points
1660          in the RHS.  Example:
1661            *a = (a++, 2)
1662          Despite the fact that the modification of "a" is in the before_sp
1663          list (tmp_before), it conflicts with the use of "a" in the LHS.
1664          We can handle this by adding the contents of tmp_list3
1665          to those of tmp_before, and redoing the collision warnings for that
1666          list.  */
1667       add_tlist (&tmp_before, tmp_list3, x, 1);
1668       warn_for_collisions (tmp_before);
1669       /* Exclude the LHS itself here; we first have to merge it into the
1670          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1671          didn't exclude the LHS, we'd get it twice, once as a read and once
1672          as a write.  */
1673       add_tlist (pno_sp, tmp_list3, x, 0);
1674       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1675
1676       merge_tlist (pbefore_sp, tmp_before, 0);
1677       if (warning_candidate_p (TREE_OPERAND (x, 0)))
1678         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1679       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1680       return;
1681
1682     case CALL_EXPR:
1683       /* We need to warn about conflicts among arguments and conflicts between
1684          args and the function address.  Side effects of the function address,
1685          however, are not ordered by the sequence point of the call.  */
1686       tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1687       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1688       if (TREE_OPERAND (x, 1))
1689         verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1690       merge_tlist (&tmp_list3, tmp_list2, 0);
1691       add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1692       add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1693       warn_for_collisions (tmp_before);
1694       add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1695       return;
1696
1697     case TREE_LIST:
1698       /* Scan all the list, e.g. indices of multi dimensional array.  */
1699       while (x)
1700         {
1701           tmp_before = tmp_nosp = 0;
1702           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1703           merge_tlist (&tmp_nosp, tmp_before, 0);
1704           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1705           x = TREE_CHAIN (x);
1706         }
1707       return;
1708
1709     case SAVE_EXPR:
1710       {
1711         struct tlist_cache *t;
1712         for (t = save_expr_cache; t; t = t->next)
1713           if (t->expr == x)
1714             break;
1715
1716         if (! t)
1717           {
1718             t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1719                                                       sizeof *t);
1720             t->next = save_expr_cache;
1721             t->expr = x;
1722             save_expr_cache = t;
1723
1724             tmp_before = tmp_nosp = 0;
1725             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1726             warn_for_collisions (tmp_nosp);
1727
1728             tmp_list3 = 0;
1729             while (tmp_nosp)
1730               {
1731                 struct tlist *t = tmp_nosp;
1732                 tmp_nosp = t->next;
1733                 merge_tlist (&tmp_list3, t, 0);
1734               }
1735             t->cache_before_sp = tmp_before;
1736             t->cache_after_sp = tmp_list3;
1737           }
1738         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1739         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1740         return;
1741       }
1742     default:
1743       break;
1744     }
1745
1746   if (class == '1')
1747     {
1748       if (first_rtl_op (code) == 0)
1749         return;
1750       x = TREE_OPERAND (x, 0);
1751       writer = 0;
1752       goto restart;
1753     }
1754
1755   switch (class)
1756     {
1757     case 'r':
1758     case '<':
1759     case '2':
1760     case 'b':
1761     case 'e':
1762     case 's':
1763     case 'x':
1764       {
1765         int lp;
1766         int max = first_rtl_op (TREE_CODE (x));
1767         for (lp = 0; lp < max; lp++)
1768           {
1769             tmp_before = tmp_nosp = 0;
1770             verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1771             merge_tlist (&tmp_nosp, tmp_before, 0);
1772             add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1773           }
1774         break;
1775       }
1776     }
1777 }
1778
1779 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1780    points.  */
1781
1782 static void
1783 verify_sequence_points (expr)
1784      tree expr;
1785 {
1786   struct tlist *before_sp = 0, *after_sp = 0;
1787
1788   warned_ids = 0;
1789   save_expr_cache = 0;
1790   if (tlist_firstobj == 0)
1791     {
1792       gcc_obstack_init (&tlist_obstack);
1793       tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1794     }
1795
1796   verify_tree (expr, &before_sp, &after_sp, 0);
1797   warn_for_collisions (after_sp);
1798   obstack_free (&tlist_obstack, tlist_firstobj);
1799 }
1800
1801 tree
1802 c_expand_expr_stmt (expr)
1803      tree expr;
1804 {
1805   /* Do default conversion if safe and possibly important,
1806      in case within ({...}).  */
1807   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1808       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1809     expr = default_conversion (expr);
1810
1811   if (warn_sequence_point)
1812     verify_sequence_points (expr);
1813
1814   if (TREE_TYPE (expr) != error_mark_node
1815       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1816       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1817     error ("expression statement has incomplete type");
1818
1819   last_expr_type = TREE_TYPE (expr);
1820   return add_stmt (build_stmt (EXPR_STMT, expr));
1821 }
1822 \f
1823 /* Validate the expression after `case' and apply default promotions.  */
1824
1825 tree
1826 check_case_value (value)
1827      tree value;
1828 {
1829   if (value == NULL_TREE)
1830     return value;
1831
1832   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1833   STRIP_TYPE_NOPS (value);
1834   /* In C++, the following is allowed:
1835
1836        const int i = 3;
1837        switch (...) { case i: ... }
1838
1839      So, we try to reduce the VALUE to a constant that way.  */
1840   if (c_language == clk_cplusplus)
1841     {
1842       value = decl_constant_value (value);
1843       STRIP_TYPE_NOPS (value);
1844       value = fold (value);
1845     }
1846
1847   if (TREE_CODE (value) != INTEGER_CST
1848       && value != error_mark_node)
1849     {
1850       error ("case label does not reduce to an integer constant");
1851       value = error_mark_node;
1852     }
1853   else
1854     /* Promote char or short to int.  */
1855     value = default_conversion (value);
1856
1857   constant_expression_warning (value);
1858
1859   return value;
1860 }
1861 \f
1862 /* Return an integer type with BITS bits of precision,
1863    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1864
1865 tree
1866 type_for_size (bits, unsignedp)
1867      unsigned bits;
1868      int unsignedp;
1869 {
1870   if (bits == TYPE_PRECISION (integer_type_node))
1871     return unsignedp ? unsigned_type_node : integer_type_node;
1872
1873   if (bits == TYPE_PRECISION (signed_char_type_node))
1874     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1875
1876   if (bits == TYPE_PRECISION (short_integer_type_node))
1877     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1878
1879   if (bits == TYPE_PRECISION (long_integer_type_node))
1880     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1881
1882   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1883     return (unsignedp ? long_long_unsigned_type_node
1884             : long_long_integer_type_node);
1885
1886   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1887     return (unsignedp ? widest_unsigned_literal_type_node
1888             : widest_integer_literal_type_node);
1889
1890   if (bits <= TYPE_PRECISION (intQI_type_node))
1891     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1892
1893   if (bits <= TYPE_PRECISION (intHI_type_node))
1894     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1895
1896   if (bits <= TYPE_PRECISION (intSI_type_node))
1897     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1898
1899   if (bits <= TYPE_PRECISION (intDI_type_node))
1900     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1901
1902   return 0;
1903 }
1904
1905 /* Return a data type that has machine mode MODE.
1906    If the mode is an integer,
1907    then UNSIGNEDP selects between signed and unsigned types.  */
1908
1909 tree
1910 type_for_mode (mode, unsignedp)
1911      enum machine_mode mode;
1912      int unsignedp;
1913 {
1914   if (mode == TYPE_MODE (integer_type_node))
1915     return unsignedp ? unsigned_type_node : integer_type_node;
1916
1917   if (mode == TYPE_MODE (signed_char_type_node))
1918     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1919
1920   if (mode == TYPE_MODE (short_integer_type_node))
1921     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1922
1923   if (mode == TYPE_MODE (long_integer_type_node))
1924     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1925
1926   if (mode == TYPE_MODE (long_long_integer_type_node))
1927     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1928
1929   if (mode == TYPE_MODE (widest_integer_literal_type_node))
1930     return unsignedp ? widest_unsigned_literal_type_node
1931                      : widest_integer_literal_type_node;
1932
1933   if (mode == TYPE_MODE (intQI_type_node))
1934     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1935
1936   if (mode == TYPE_MODE (intHI_type_node))
1937     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1938
1939   if (mode == TYPE_MODE (intSI_type_node))
1940     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1941
1942   if (mode == TYPE_MODE (intDI_type_node))
1943     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1944
1945 #if HOST_BITS_PER_WIDE_INT >= 64
1946   if (mode == TYPE_MODE (intTI_type_node))
1947     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1948 #endif
1949
1950   if (mode == TYPE_MODE (float_type_node))
1951     return float_type_node;
1952
1953   if (mode == TYPE_MODE (double_type_node))
1954     return double_type_node;
1955
1956   if (mode == TYPE_MODE (long_double_type_node))
1957     return long_double_type_node;
1958
1959   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1960     return build_pointer_type (char_type_node);
1961
1962   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1963     return build_pointer_type (integer_type_node);
1964
1965 #ifdef VECTOR_MODE_SUPPORTED_P
1966   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1967     return V4SF_type_node;
1968   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1969     return V4SI_type_node;
1970   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1971     return V2SI_type_node;
1972   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1973     return V4HI_type_node;
1974   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1975     return V8QI_type_node;
1976 #endif
1977
1978   return 0;
1979 }
1980
1981 /* Return an unsigned type the same as TYPE in other respects.  */
1982 tree
1983 unsigned_type (type)
1984      tree type;
1985 {
1986   tree type1 = TYPE_MAIN_VARIANT (type);
1987   if (type1 == signed_char_type_node || type1 == char_type_node)
1988     return unsigned_char_type_node;
1989   if (type1 == integer_type_node)
1990     return unsigned_type_node;
1991   if (type1 == short_integer_type_node)
1992     return short_unsigned_type_node;
1993   if (type1 == long_integer_type_node)
1994     return long_unsigned_type_node;
1995   if (type1 == long_long_integer_type_node)
1996     return long_long_unsigned_type_node;
1997   if (type1 == widest_integer_literal_type_node)
1998     return widest_unsigned_literal_type_node;
1999 #if HOST_BITS_PER_WIDE_INT >= 64
2000   if (type1 == intTI_type_node)
2001     return unsigned_intTI_type_node;
2002 #endif
2003   if (type1 == intDI_type_node)
2004     return unsigned_intDI_type_node;
2005   if (type1 == intSI_type_node)
2006     return unsigned_intSI_type_node;
2007   if (type1 == intHI_type_node)
2008     return unsigned_intHI_type_node;
2009   if (type1 == intQI_type_node)
2010     return unsigned_intQI_type_node;
2011
2012   return signed_or_unsigned_type (1, type);
2013 }
2014
2015 /* Return a signed type the same as TYPE in other respects.  */
2016
2017 tree
2018 signed_type (type)
2019      tree type;
2020 {
2021   tree type1 = TYPE_MAIN_VARIANT (type);
2022   if (type1 == unsigned_char_type_node || type1 == char_type_node)
2023     return signed_char_type_node;
2024   if (type1 == unsigned_type_node)
2025     return integer_type_node;
2026   if (type1 == short_unsigned_type_node)
2027     return short_integer_type_node;
2028   if (type1 == long_unsigned_type_node)
2029     return long_integer_type_node;
2030   if (type1 == long_long_unsigned_type_node)
2031     return long_long_integer_type_node;
2032   if (type1 == widest_unsigned_literal_type_node)
2033     return widest_integer_literal_type_node;
2034 #if HOST_BITS_PER_WIDE_INT >= 64
2035   if (type1 == unsigned_intTI_type_node)
2036     return intTI_type_node;
2037 #endif
2038   if (type1 == unsigned_intDI_type_node)
2039     return intDI_type_node;
2040   if (type1 == unsigned_intSI_type_node)
2041     return intSI_type_node;
2042   if (type1 == unsigned_intHI_type_node)
2043     return intHI_type_node;
2044   if (type1 == unsigned_intQI_type_node)
2045     return intQI_type_node;
2046
2047   return signed_or_unsigned_type (0, type);
2048 }
2049
2050 /* Return a type the same as TYPE except unsigned or
2051    signed according to UNSIGNEDP.  */
2052
2053 tree
2054 signed_or_unsigned_type (unsignedp, type)
2055      int unsignedp;
2056      tree type;
2057 {
2058   if (! INTEGRAL_TYPE_P (type)
2059       || TREE_UNSIGNED (type) == unsignedp)
2060     return type;
2061
2062   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2063     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2064   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2065     return unsignedp ? unsigned_type_node : integer_type_node;
2066   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2067     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2068   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2069     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2070   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2071     return (unsignedp ? long_long_unsigned_type_node
2072             : long_long_integer_type_node);
2073   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2074     return (unsignedp ? widest_unsigned_literal_type_node
2075             : widest_integer_literal_type_node);
2076
2077 #if HOST_BITS_PER_WIDE_INT >= 64
2078   if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
2079     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2080 #endif
2081   if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
2082     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2083   if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
2084     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2085   if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
2086     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2087   if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
2088     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2089
2090   return type;
2091 }
2092 \f
2093 /* Return the minimum number of bits needed to represent VALUE in a
2094    signed or unsigned type, UNSIGNEDP says which.  */
2095
2096 unsigned int
2097 min_precision (value, unsignedp)
2098      tree value;
2099      int unsignedp;
2100 {
2101   int log;
2102
2103   /* If the value is negative, compute its negative minus 1.  The latter
2104      adjustment is because the absolute value of the largest negative value
2105      is one larger than the largest positive value.  This is equivalent to
2106      a bit-wise negation, so use that operation instead.  */
2107
2108   if (tree_int_cst_sgn (value) < 0)
2109     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2110
2111   /* Return the number of bits needed, taking into account the fact
2112      that we need one more bit for a signed than unsigned type.  */
2113
2114   if (integer_zerop (value))
2115     log = 0;
2116   else
2117     log = tree_floor_log2 (value);
2118
2119   return log + 1 + ! unsignedp;
2120 }
2121 \f
2122 /* Print an error message for invalid operands to arith operation CODE.
2123    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2124
2125 void
2126 binary_op_error (code)
2127      enum tree_code code;
2128 {
2129   register const char *opname;
2130
2131   switch (code)
2132     {
2133     case NOP_EXPR:
2134       error ("invalid truth-value expression");
2135       return;
2136
2137     case PLUS_EXPR:
2138       opname = "+"; break;
2139     case MINUS_EXPR:
2140       opname = "-"; break;
2141     case MULT_EXPR:
2142       opname = "*"; break;
2143     case MAX_EXPR:
2144       opname = "max"; break;
2145     case MIN_EXPR:
2146       opname = "min"; break;
2147     case EQ_EXPR:
2148       opname = "=="; break;
2149     case NE_EXPR:
2150       opname = "!="; break;
2151     case LE_EXPR:
2152       opname = "<="; break;
2153     case GE_EXPR:
2154       opname = ">="; break;
2155     case LT_EXPR:
2156       opname = "<"; break;
2157     case GT_EXPR:
2158       opname = ">"; break;
2159     case LSHIFT_EXPR:
2160       opname = "<<"; break;
2161     case RSHIFT_EXPR:
2162       opname = ">>"; break;
2163     case TRUNC_MOD_EXPR:
2164     case FLOOR_MOD_EXPR:
2165       opname = "%"; break;
2166     case TRUNC_DIV_EXPR:
2167     case FLOOR_DIV_EXPR:
2168       opname = "/"; break;
2169     case BIT_AND_EXPR:
2170       opname = "&"; break;
2171     case BIT_IOR_EXPR:
2172       opname = "|"; break;
2173     case TRUTH_ANDIF_EXPR:
2174       opname = "&&"; break;
2175     case TRUTH_ORIF_EXPR:
2176       opname = "||"; break;
2177     case BIT_XOR_EXPR:
2178       opname = "^"; break;
2179     case LROTATE_EXPR:
2180     case RROTATE_EXPR:
2181       opname = "rotate"; break;
2182     default:
2183       opname = "unknown"; break;
2184     }
2185   error ("invalid operands to binary %s", opname);
2186 }
2187 \f
2188 /* Subroutine of build_binary_op, used for comparison operations.
2189    See if the operands have both been converted from subword integer types
2190    and, if so, perhaps change them both back to their original type.
2191    This function is also responsible for converting the two operands
2192    to the proper common type for comparison.
2193
2194    The arguments of this function are all pointers to local variables
2195    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2196    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2197
2198    If this function returns nonzero, it means that the comparison has
2199    a constant value.  What this function returns is an expression for
2200    that value.  */
2201
2202 tree
2203 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2204      tree *op0_ptr, *op1_ptr;
2205      tree *restype_ptr;
2206      enum tree_code *rescode_ptr;
2207 {
2208   register tree type;
2209   tree op0 = *op0_ptr;
2210   tree op1 = *op1_ptr;
2211   int unsignedp0, unsignedp1;
2212   int real1, real2;
2213   tree primop0, primop1;
2214   enum tree_code code = *rescode_ptr;
2215
2216   /* Throw away any conversions to wider types
2217      already present in the operands.  */
2218
2219   primop0 = get_narrower (op0, &unsignedp0);
2220   primop1 = get_narrower (op1, &unsignedp1);
2221
2222   /* Handle the case that OP0 does not *contain* a conversion
2223      but it *requires* conversion to FINAL_TYPE.  */
2224
2225   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2226     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2227   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2228     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2229
2230   /* If one of the operands must be floated, we cannot optimize.  */
2231   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2232   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2233
2234   /* If first arg is constant, swap the args (changing operation
2235      so value is preserved), for canonicalization.  Don't do this if
2236      the second arg is 0.  */
2237
2238   if (TREE_CONSTANT (primop0)
2239       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2240     {
2241       register tree tem = primop0;
2242       register int temi = unsignedp0;
2243       primop0 = primop1;
2244       primop1 = tem;
2245       tem = op0;
2246       op0 = op1;
2247       op1 = tem;
2248       *op0_ptr = op0;
2249       *op1_ptr = op1;
2250       unsignedp0 = unsignedp1;
2251       unsignedp1 = temi;
2252       temi = real1;
2253       real1 = real2;
2254       real2 = temi;
2255
2256       switch (code)
2257         {
2258         case LT_EXPR:
2259           code = GT_EXPR;
2260           break;
2261         case GT_EXPR:
2262           code = LT_EXPR;
2263           break;
2264         case LE_EXPR:
2265           code = GE_EXPR;
2266           break;
2267         case GE_EXPR:
2268           code = LE_EXPR;
2269           break;
2270         default:
2271           break;
2272         }
2273       *rescode_ptr = code;
2274     }
2275
2276   /* If comparing an integer against a constant more bits wide,
2277      maybe we can deduce a value of 1 or 0 independent of the data.
2278      Or else truncate the constant now
2279      rather than extend the variable at run time.
2280
2281      This is only interesting if the constant is the wider arg.
2282      Also, it is not safe if the constant is unsigned and the
2283      variable arg is signed, since in this case the variable
2284      would be sign-extended and then regarded as unsigned.
2285      Our technique fails in this case because the lowest/highest
2286      possible unsigned results don't follow naturally from the
2287      lowest/highest possible values of the variable operand.
2288      For just EQ_EXPR and NE_EXPR there is another technique that
2289      could be used: see if the constant can be faithfully represented
2290      in the other operand's type, by truncating it and reextending it
2291      and see if that preserves the constant's value.  */
2292
2293   if (!real1 && !real2
2294       && TREE_CODE (primop1) == INTEGER_CST
2295       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2296     {
2297       int min_gt, max_gt, min_lt, max_lt;
2298       tree maxval, minval;
2299       /* 1 if comparison is nominally unsigned.  */
2300       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2301       tree val;
2302
2303       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2304
2305       /* If TYPE is an enumeration, then we need to get its min/max
2306          values from it's underlying integral type, not the enumerated
2307          type itself.  */
2308       if (TREE_CODE (type) == ENUMERAL_TYPE)
2309         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
2310
2311       maxval = TYPE_MAX_VALUE (type);
2312       minval = TYPE_MIN_VALUE (type);
2313
2314       if (unsignedp && !unsignedp0)
2315         *restype_ptr = signed_type (*restype_ptr);
2316
2317       if (TREE_TYPE (primop1) != *restype_ptr)
2318         primop1 = convert (*restype_ptr, primop1);
2319       if (type != *restype_ptr)
2320         {
2321           minval = convert (*restype_ptr, minval);
2322           maxval = convert (*restype_ptr, maxval);
2323         }
2324
2325       if (unsignedp && unsignedp0)
2326         {
2327           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2328           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2329           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2330           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2331         }
2332       else
2333         {
2334           min_gt = INT_CST_LT (primop1, minval);
2335           max_gt = INT_CST_LT (primop1, maxval);
2336           min_lt = INT_CST_LT (minval, primop1);
2337           max_lt = INT_CST_LT (maxval, primop1);
2338         }
2339
2340       val = 0;
2341       /* This used to be a switch, but Genix compiler can't handle that.  */
2342       if (code == NE_EXPR)
2343         {
2344           if (max_lt || min_gt)
2345             val = boolean_true_node;
2346         }
2347       else if (code == EQ_EXPR)
2348         {
2349           if (max_lt || min_gt)
2350             val = boolean_false_node;
2351         }
2352       else if (code == LT_EXPR)
2353         {
2354           if (max_lt)
2355             val = boolean_true_node;
2356           if (!min_lt)
2357             val = boolean_false_node;
2358         }
2359       else if (code == GT_EXPR)
2360         {
2361           if (min_gt)
2362             val = boolean_true_node;
2363           if (!max_gt)
2364             val = boolean_false_node;
2365         }
2366       else if (code == LE_EXPR)
2367         {
2368           if (!max_gt)
2369             val = boolean_true_node;
2370           if (min_gt)
2371             val = boolean_false_node;
2372         }
2373       else if (code == GE_EXPR)
2374         {
2375           if (!min_lt)
2376             val = boolean_true_node;
2377           if (max_lt)
2378             val = boolean_false_node;
2379         }
2380
2381       /* If primop0 was sign-extended and unsigned comparison specd,
2382          we did a signed comparison above using the signed type bounds.
2383          But the comparison we output must be unsigned.
2384
2385          Also, for inequalities, VAL is no good; but if the signed
2386          comparison had *any* fixed result, it follows that the
2387          unsigned comparison just tests the sign in reverse
2388          (positive values are LE, negative ones GE).
2389          So we can generate an unsigned comparison
2390          against an extreme value of the signed type.  */
2391
2392       if (unsignedp && !unsignedp0)
2393         {
2394           if (val != 0)
2395             switch (code)
2396               {
2397               case LT_EXPR:
2398               case GE_EXPR:
2399                 primop1 = TYPE_MIN_VALUE (type);
2400                 val = 0;
2401                 break;
2402
2403               case LE_EXPR:
2404               case GT_EXPR:
2405                 primop1 = TYPE_MAX_VALUE (type);
2406                 val = 0;
2407                 break;
2408
2409               default:
2410                 break;
2411               }
2412           type = unsigned_type (type);
2413         }
2414
2415       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2416         {
2417           /* This is the case of (char)x >?< 0x80, which people used to use
2418              expecting old C compilers to change the 0x80 into -0x80.  */
2419           if (val == boolean_false_node)
2420             warning ("comparison is always false due to limited range of data type");
2421           if (val == boolean_true_node)
2422             warning ("comparison is always true due to limited range of data type");
2423         }
2424
2425       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2426         {
2427           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2428           if (val == boolean_false_node)
2429             warning ("comparison is always false due to limited range of data type");
2430           if (val == boolean_true_node)
2431             warning ("comparison is always true due to limited range of data type");
2432         }
2433
2434       if (val != 0)
2435         {
2436           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2437           if (TREE_SIDE_EFFECTS (primop0))
2438             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2439           return val;
2440         }
2441
2442       /* Value is not predetermined, but do the comparison
2443          in the type of the operand that is not constant.
2444          TYPE is already properly set.  */
2445     }
2446   else if (real1 && real2
2447            && (TYPE_PRECISION (TREE_TYPE (primop0))
2448                == TYPE_PRECISION (TREE_TYPE (primop1))))
2449     type = TREE_TYPE (primop0);
2450
2451   /* If args' natural types are both narrower than nominal type
2452      and both extend in the same manner, compare them
2453      in the type of the wider arg.
2454      Otherwise must actually extend both to the nominal
2455      common type lest different ways of extending
2456      alter the result.
2457      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2458
2459   else if (unsignedp0 == unsignedp1 && real1 == real2
2460            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2461            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2462     {
2463       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2464       type = signed_or_unsigned_type (unsignedp0
2465                                       || TREE_UNSIGNED (*restype_ptr),
2466                                       type);
2467       /* Make sure shorter operand is extended the right way
2468          to match the longer operand.  */
2469       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2470                          primop0);
2471       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2472                          primop1);
2473     }
2474   else
2475     {
2476       /* Here we must do the comparison on the nominal type
2477          using the args exactly as we received them.  */
2478       type = *restype_ptr;
2479       primop0 = op0;
2480       primop1 = op1;
2481
2482       if (!real1 && !real2 && integer_zerop (primop1)
2483           && TREE_UNSIGNED (*restype_ptr))
2484         {
2485           tree value = 0;
2486           switch (code)
2487             {
2488             case GE_EXPR:
2489               /* All unsigned values are >= 0, so we warn if extra warnings
2490                  are requested.  However, if OP0 is a constant that is
2491                  >= 0, the signedness of the comparison isn't an issue,
2492                  so suppress the warning.  */
2493               if (extra_warnings && !in_system_header
2494                   && ! (TREE_CODE (primop0) == INTEGER_CST
2495                         && ! TREE_OVERFLOW (convert (signed_type (type),
2496                                                      primop0))))
2497                 warning ("comparison of unsigned expression >= 0 is always true");
2498               value = boolean_true_node;
2499               break;
2500
2501             case LT_EXPR:
2502               if (extra_warnings && !in_system_header
2503                   && ! (TREE_CODE (primop0) == INTEGER_CST
2504                         && ! TREE_OVERFLOW (convert (signed_type (type),
2505                                                      primop0))))
2506                 warning ("comparison of unsigned expression < 0 is always false");
2507               value = boolean_false_node;
2508               break;
2509
2510             default:
2511               break;
2512             }
2513
2514           if (value != 0)
2515             {
2516               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2517               if (TREE_SIDE_EFFECTS (primop0))
2518                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2519                               primop0, value);
2520               return value;
2521             }
2522         }
2523     }
2524
2525   *op0_ptr = convert (type, primop0);
2526   *op1_ptr = convert (type, primop1);
2527
2528   *restype_ptr = boolean_type_node;
2529
2530   return 0;
2531 }
2532 \f
2533 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2534    or validate its data type for an `if' or `while' statement or ?..: exp.
2535
2536    This preparation consists of taking the ordinary
2537    representation of an expression expr and producing a valid tree
2538    boolean expression describing whether expr is nonzero.  We could
2539    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2540    but we optimize comparisons, &&, ||, and !.
2541
2542    The resulting type should always be `boolean_type_node'.  */
2543
2544 tree
2545 truthvalue_conversion (expr)
2546      tree expr;
2547 {
2548   if (TREE_CODE (expr) == ERROR_MARK)
2549     return expr;
2550
2551 #if 0 /* This appears to be wrong for C++.  */
2552   /* These really should return error_mark_node after 2.4 is stable.
2553      But not all callers handle ERROR_MARK properly.  */
2554   switch (TREE_CODE (TREE_TYPE (expr)))
2555     {
2556     case RECORD_TYPE:
2557       error ("struct type value used where scalar is required");
2558       return boolean_false_node;
2559
2560     case UNION_TYPE:
2561       error ("union type value used where scalar is required");
2562       return boolean_false_node;
2563
2564     case ARRAY_TYPE:
2565       error ("array type value used where scalar is required");
2566       return boolean_false_node;
2567
2568     default:
2569       break;
2570     }
2571 #endif /* 0 */
2572
2573   switch (TREE_CODE (expr))
2574     {
2575     case EQ_EXPR:
2576     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2577     case TRUTH_ANDIF_EXPR:
2578     case TRUTH_ORIF_EXPR:
2579     case TRUTH_AND_EXPR:
2580     case TRUTH_OR_EXPR:
2581     case TRUTH_XOR_EXPR:
2582     case TRUTH_NOT_EXPR:
2583       TREE_TYPE (expr) = boolean_type_node;
2584       return expr;
2585
2586     case ERROR_MARK:
2587       return expr;
2588
2589     case INTEGER_CST:
2590       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2591
2592     case REAL_CST:
2593       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2594
2595     case ADDR_EXPR:
2596       /* If we are taking the address of a external decl, it might be zero
2597          if it is weak, so we cannot optimize.  */
2598       if (DECL_P (TREE_OPERAND (expr, 0))
2599           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2600         break;
2601
2602       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2603         return build (COMPOUND_EXPR, boolean_type_node,
2604                       TREE_OPERAND (expr, 0), boolean_true_node);
2605       else
2606         return boolean_true_node;
2607
2608     case COMPLEX_EXPR:
2609       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2610                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2611                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2612                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2613                               0);
2614
2615     case NEGATE_EXPR:
2616     case ABS_EXPR:
2617     case FLOAT_EXPR:
2618     case FFS_EXPR:
2619       /* These don't change whether an object is non-zero or zero.  */
2620       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2621
2622     case LROTATE_EXPR:
2623     case RROTATE_EXPR:
2624       /* These don't change whether an object is zero or non-zero, but
2625          we can't ignore them if their second arg has side-effects.  */
2626       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2627         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2628                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2629       else
2630         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2631
2632     case COND_EXPR:
2633       /* Distribute the conversion into the arms of a COND_EXPR.  */
2634       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2635                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2636                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2637
2638     case CONVERT_EXPR:
2639       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2640          since that affects how `default_conversion' will behave.  */
2641       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2642           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2643         break;
2644       /* fall through...  */
2645     case NOP_EXPR:
2646       /* If this is widening the argument, we can ignore it.  */
2647       if (TYPE_PRECISION (TREE_TYPE (expr))
2648           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2649         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2650       break;
2651
2652     case MINUS_EXPR:
2653       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2654          this case.  */
2655       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2656           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2657         break;
2658       /* fall through...  */
2659     case BIT_XOR_EXPR:
2660       /* This and MINUS_EXPR can be changed into a comparison of the
2661          two objects.  */
2662       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2663           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2664         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2665                                 TREE_OPERAND (expr, 1), 1);
2666       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2667                               fold (build1 (NOP_EXPR,
2668                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2669                                             TREE_OPERAND (expr, 1))), 1);
2670
2671     case BIT_AND_EXPR:
2672       if (integer_onep (TREE_OPERAND (expr, 1))
2673           && TREE_TYPE (expr) != boolean_type_node)
2674         /* Using convert here would cause infinite recursion.  */
2675         return build1 (NOP_EXPR, boolean_type_node, expr);
2676       break;
2677
2678     case MODIFY_EXPR:
2679       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2680         warning ("suggest parentheses around assignment used as truth value");
2681       break;
2682
2683     default:
2684       break;
2685     }
2686
2687   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2688     {
2689       tree tem = save_expr (expr);
2690       return (build_binary_op
2691               ((TREE_SIDE_EFFECTS (expr)
2692                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2693                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2694                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2695                0));
2696     }
2697
2698   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2699 }
2700 \f
2701 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2702                                         int, enum built_in_class, int, int,
2703                                         int));
2704
2705 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2706    down to the element type of an array.  */
2707
2708 tree
2709 c_build_qualified_type (type, type_quals)
2710      tree type;
2711      int type_quals;
2712 {
2713   /* A restrict-qualified pointer type must be a pointer to object or
2714      incomplete type.  Note that the use of POINTER_TYPE_P also allows
2715      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
2716      the C++ front-end also use POINTER_TYPE for pointer-to-member
2717      values, so even though it should be illegal to use `restrict'
2718      with such an entity we don't flag that here.  Thus, special case
2719      code for that case is required in the C++ front-end.  */
2720   if ((type_quals & TYPE_QUAL_RESTRICT)
2721       && (!POINTER_TYPE_P (type)
2722           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2723     {
2724       error ("invalid use of `restrict'");
2725       type_quals &= ~TYPE_QUAL_RESTRICT;
2726     }
2727
2728   if (TREE_CODE (type) == ARRAY_TYPE)
2729     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2730                                                      type_quals),
2731                              TYPE_DOMAIN (type));
2732   return build_qualified_type (type, type_quals);
2733 }
2734
2735 /* Apply the TYPE_QUALS to the new DECL.  */
2736
2737 void
2738 c_apply_type_quals_to_decl (type_quals, decl)
2739      int type_quals;
2740      tree decl;
2741 {
2742   if ((type_quals & TYPE_QUAL_CONST)
2743       || (TREE_TYPE (decl)
2744           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2745     TREE_READONLY (decl) = 1;
2746   if (type_quals & TYPE_QUAL_VOLATILE)
2747     {
2748       TREE_SIDE_EFFECTS (decl) = 1;
2749       TREE_THIS_VOLATILE (decl) = 1;
2750     }
2751   if (type_quals & TYPE_QUAL_RESTRICT)
2752     {
2753       if (!TREE_TYPE (decl)
2754           || !POINTER_TYPE_P (TREE_TYPE (decl))
2755           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2756         error ("invalid use of `restrict'");
2757       else if (flag_strict_aliasing)
2758         {
2759           /* No two restricted pointers can point at the same thing.
2760              However, a restricted pointer can point at the same thing
2761              as an unrestricted pointer, if that unrestricted pointer
2762              is based on the restricted pointer.  So, we make the
2763              alias set for the restricted pointer a subset of the
2764              alias set for the type pointed to by the type of the
2765              decl.  */
2766
2767           HOST_WIDE_INT pointed_to_alias_set
2768             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
2769
2770           if (pointed_to_alias_set == 0)
2771             /* It's not legal to make a subset of alias set zero.  */
2772             ;
2773           else
2774             {
2775               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
2776               record_alias_subset  (pointed_to_alias_set,
2777                                     DECL_POINTER_ALIAS_SET (decl));
2778             }
2779         }
2780     }
2781 }
2782
2783
2784 /* Return the typed-based alias set for T, which may be an expression
2785    or a type.  Return -1 if we don't do anything special.  */
2786
2787 HOST_WIDE_INT
2788 lang_get_alias_set (t)
2789      tree t;
2790 {
2791   tree u;
2792
2793   /* We know nothing about vector types */
2794   if (TREE_CODE (t) == VECTOR_TYPE)
2795     return 0;
2796
2797   /* Permit type-punning when accessing a union, provided the access
2798      is directly through the union.  For example, this code does not
2799      permit taking the address of a union member and then storing
2800      through it.  Even the type-punning allowed here is a GCC
2801      extension, albeit a common and useful one; the C standard says
2802      that such accesses have implementation-defined behavior.  */
2803   for (u = t;
2804        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2805        u = TREE_OPERAND (u, 0))
2806     if (TREE_CODE (u) == COMPONENT_REF
2807         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2808       return 0;
2809
2810   /* If this is a char *, the ANSI C standard says it can alias
2811      anything.  Note that all references need do this.  */
2812   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2813       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2814       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2815     return 0;
2816
2817   /* That's all the expressions we handle specially.  */
2818   if (! TYPE_P (t))
2819     return -1;
2820
2821   /* The C standard specifically allows aliasing between signed and
2822      unsigned variants of the same type.  We treat the signed
2823      variant as canonical.  */
2824   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2825     {
2826       tree t1 = signed_type (t);
2827
2828       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2829       if (t1 != t)
2830         return get_alias_set (t1);
2831     }
2832   else if (POINTER_TYPE_P (t))
2833     {
2834       tree t1;
2835
2836       /* Unfortunately, there is no canonical form of a pointer type.
2837          In particular, if we have `typedef int I', then `int *', and
2838          `I *' are different types.  So, we have to pick a canonical
2839          representative.  We do this below.
2840
2841          Technically, this approach is actually more conservative that
2842          it needs to be.  In particular, `const int *' and `int *'
2843          chould be in different alias sets, according to the C and C++
2844          standard, since their types are not the same, and so,
2845          technically, an `int **' and `const int **' cannot point at
2846          the same thing.
2847
2848          But, the standard is wrong.  In particular, this code is
2849          legal C++:
2850
2851             int *ip;
2852             int **ipp = &ip;
2853             const int* const* cipp = &ipp;
2854
2855          And, it doesn't make sense for that to be legal unless you
2856          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2857          the pointed-to types.  This issue has been reported to the
2858          C++ committee.  */
2859       t1 = build_type_no_quals (t);
2860       if (t1 != t)
2861         return get_alias_set (t1);
2862     }
2863   /* It's not yet safe to use alias sets for classes in C++ because
2864      the TYPE_FIELDs list for a class doesn't mention base classes.  */
2865   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
2866     return 0;
2867
2868   return -1;
2869 }
2870 \f
2871 /* Implement the __alignof keyword: Return the minimum required
2872    alignment of TYPE, measured in bytes.  */
2873
2874 tree
2875 c_alignof (type)
2876      tree type;
2877 {
2878   enum tree_code code = TREE_CODE (type);
2879   tree t;
2880
2881   /* In C++, sizeof applies to the referent.  Handle alignof the same way.  */
2882   if (code == REFERENCE_TYPE)
2883     {
2884       type = TREE_TYPE (type);
2885       code = TREE_CODE (type);
2886     }
2887
2888   if (code == FUNCTION_TYPE)
2889     t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2890   else if (code == VOID_TYPE || code == ERROR_MARK)
2891     t = size_one_node;
2892   else if (!COMPLETE_TYPE_P (type))
2893     {
2894       error ("__alignof__ applied to an incomplete type");
2895       t = size_zero_node;
2896     }
2897   else
2898     t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2899
2900   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2901 }
2902
2903 /* Implement the __alignof keyword: Return the minimum required
2904    alignment of EXPR, measured in bytes.  For VAR_DECL's and
2905    FIELD_DECL's return DECL_ALIGN (which can be set from an
2906    "aligned" __attribute__ specification).  */
2907
2908 tree
2909 c_alignof_expr (expr)
2910      tree expr;
2911 {
2912   tree t;
2913
2914   if (TREE_CODE (expr) == VAR_DECL)
2915     t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2916
2917   else if (TREE_CODE (expr) == COMPONENT_REF
2918            && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2919     {
2920       error ("`__alignof' applied to a bit-field");
2921       t = size_one_node;
2922     }
2923   else if (TREE_CODE (expr) == COMPONENT_REF
2924       && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2925     t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2926
2927   else if (TREE_CODE (expr) == INDIRECT_REF)
2928     {
2929       tree t = TREE_OPERAND (expr, 0);
2930       tree best = t;
2931       int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2932
2933       while (TREE_CODE (t) == NOP_EXPR
2934               && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2935         {
2936           int thisalign;
2937
2938           t = TREE_OPERAND (t, 0);
2939           thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2940           if (thisalign > bestalign)
2941             best = t, bestalign = thisalign;
2942         }
2943       return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2944     }
2945   else
2946     return c_alignof (TREE_TYPE (expr));
2947
2948   return fold (build1 (NOP_EXPR, c_size_type_node, t));
2949 }
2950 \f
2951 /* Build tree nodes and builtin functions common to both C and C++ language
2952    frontends.  */
2953
2954 void
2955 c_common_nodes_and_builtins ()
2956 {
2957   enum builtin_type
2958   {
2959 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2960 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2961 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2962 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2963 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2964 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2965 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2966 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2967 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2968 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2969 #include "builtin-types.def"
2970 #undef DEF_PRIMITIVE_TYPE
2971 #undef DEF_FUNCTION_TYPE_0
2972 #undef DEF_FUNCTION_TYPE_1
2973 #undef DEF_FUNCTION_TYPE_2
2974 #undef DEF_FUNCTION_TYPE_3
2975 #undef DEF_FUNCTION_TYPE_4
2976 #undef DEF_FUNCTION_TYPE_VAR_0
2977 #undef DEF_FUNCTION_TYPE_VAR_1
2978 #undef DEF_FUNCTION_TYPE_VAR_2
2979 #undef DEF_POINTER_TYPE
2980     BT_LAST
2981   };
2982
2983   typedef enum builtin_type builtin_type;
2984
2985   tree builtin_types[(int)BT_LAST];
2986   int wchar_type_size;
2987   tree array_domain_type;
2988   /* Either char* or void*.  */
2989   tree traditional_ptr_type_node;
2990   /* Either const char* or const void*.  */
2991   tree traditional_cptr_type_node;
2992   tree traditional_len_type_node;
2993   tree va_list_ref_type_node;
2994   tree va_list_arg_type_node;
2995
2996   /* Define `int' and `char' first so that dbx will output them first.  */
2997   record_builtin_type (RID_INT, NULL, integer_type_node);
2998   record_builtin_type (RID_CHAR, "char", char_type_node);
2999
3000   /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
3001      "unsigned long", "long long unsigned" and "unsigned short" were in C++
3002      but not C.  Are the conditionals here needed?  */
3003   if (c_language == clk_cplusplus)
3004     record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3005   record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3006   record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3007   record_builtin_type (RID_MAX, "long unsigned int",
3008                        long_unsigned_type_node);
3009   if (c_language == clk_cplusplus)
3010     record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3011   record_builtin_type (RID_MAX, "long long int",
3012                        long_long_integer_type_node);
3013   record_builtin_type (RID_MAX, "long long unsigned int",
3014                        long_long_unsigned_type_node);
3015   if (c_language == clk_cplusplus)
3016     record_builtin_type (RID_MAX, "long long unsigned",
3017                          long_long_unsigned_type_node);
3018   record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3019   record_builtin_type (RID_MAX, "short unsigned int",
3020                        short_unsigned_type_node);
3021   if (c_language == clk_cplusplus)
3022     record_builtin_type (RID_MAX, "unsigned short",
3023                          short_unsigned_type_node);
3024
3025   /* Define both `signed char' and `unsigned char'.  */
3026   record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3027   record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3028
3029   /* These are types that type_for_size and type_for_mode use.  */
3030   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
3031   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
3032   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
3033   pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
3034 #if HOST_BITS_PER_WIDE_INT >= 64
3035   pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
3036 #endif
3037   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
3038   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
3039   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
3040   pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
3041 #if HOST_BITS_PER_WIDE_INT >= 64
3042   pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
3043 #endif
3044
3045   /* Create the widest literal types.  */
3046   widest_integer_literal_type_node
3047     = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3048   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3049                         widest_integer_literal_type_node));
3050
3051   widest_unsigned_literal_type_node
3052     = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3053   pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3054                         widest_unsigned_literal_type_node));
3055
3056   /* `unsigned long' is the standard type for sizeof.
3057      Note that stddef.h uses `unsigned long',
3058      and this must agree, even if long and int are the same size.  */
3059   c_size_type_node =
3060     TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3061   signed_size_type_node = signed_type (c_size_type_node);
3062   if (flag_traditional)
3063     c_size_type_node = signed_size_type_node;
3064   set_sizetype (c_size_type_node);
3065
3066   build_common_tree_nodes_2 (flag_short_double);
3067
3068   record_builtin_type (RID_FLOAT, NULL, float_type_node);
3069   record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3070   record_builtin_type (RID_MAX, "long double", long_double_type_node);
3071
3072   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
3073                         complex_integer_type_node));
3074   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
3075                         complex_float_type_node));
3076   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
3077                         complex_double_type_node));
3078   pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3079                         complex_long_double_type_node));
3080
3081   record_builtin_type (RID_VOID, NULL, void_type_node);
3082
3083   void_zero_node = build_int_2 (0, 0);
3084   TREE_TYPE (void_zero_node) = void_type_node;
3085
3086   void_list_node = build_void_list_node ();
3087
3088   /* Make a type to be the domain of a few array types
3089      whose domains don't really matter.
3090      200 is small enough that it always fits in size_t
3091      and large enough that it can hold most function names for the
3092      initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3093   array_domain_type = build_index_type (size_int (200));
3094
3095   /* Make a type for arrays of characters.
3096      With luck nothing will ever really depend on the length of this
3097      array type.  */
3098   char_array_type_node
3099     = build_array_type (char_type_node, array_domain_type);
3100
3101   /* Likewise for arrays of ints.  */
3102   int_array_type_node
3103     = build_array_type (integer_type_node, array_domain_type);
3104
3105   string_type_node = build_pointer_type (char_type_node);
3106   const_string_type_node
3107     = build_pointer_type (build_qualified_type
3108                           (char_type_node, TYPE_QUAL_CONST));
3109
3110   traditional_ptr_type_node = ((flag_traditional &&
3111                                 c_language != clk_cplusplus)
3112                                ? string_type_node : ptr_type_node);
3113   traditional_cptr_type_node = ((flag_traditional &&
3114                                  c_language != clk_cplusplus)
3115                                ? const_string_type_node : const_ptr_type_node);
3116
3117   (*targetm.init_builtins) ();
3118
3119   /* This is special for C++ so functions can be overloaded.  */
3120   wchar_type_node = get_identifier (flag_short_wchar
3121                                     ? "short unsigned int"
3122                                     : WCHAR_TYPE);
3123   wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3124   wchar_type_size = TYPE_PRECISION (wchar_type_node);
3125   if (c_language == clk_cplusplus)
3126     {
3127       if (TREE_UNSIGNED (wchar_type_node))
3128         wchar_type_node = make_unsigned_type (wchar_type_size);
3129       else
3130         wchar_type_node = make_signed_type (wchar_type_size);
3131       record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3132     }
3133   else
3134     {
3135       signed_wchar_type_node = signed_type (wchar_type_node);
3136       unsigned_wchar_type_node = unsigned_type (wchar_type_node);
3137     }
3138
3139   /* This is for wide string constants.  */
3140   wchar_array_type_node
3141     = build_array_type (wchar_type_node, array_domain_type);
3142
3143   wint_type_node =
3144     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3145
3146   intmax_type_node =
3147     TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3148   uintmax_type_node =
3149     TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3150
3151   default_function_type = build_function_type (integer_type_node, NULL_TREE);
3152   ptrdiff_type_node
3153     = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3154   unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
3155
3156   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3157                         va_list_type_node));
3158
3159   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3160                         ptrdiff_type_node));
3161
3162   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3163                         sizetype));
3164
3165   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3166     {
3167       va_list_arg_type_node = va_list_ref_type_node =
3168         build_pointer_type (TREE_TYPE (va_list_type_node));
3169     }
3170   else
3171     {
3172       va_list_arg_type_node = va_list_type_node;
3173       va_list_ref_type_node = build_reference_type (va_list_type_node);
3174     }
3175
3176   traditional_len_type_node = ((flag_traditional &&
3177                                 c_language != clk_cplusplus)
3178                                ? integer_type_node : sizetype);
3179
3180 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3181   builtin_types[(int) ENUM] = VALUE;
3182 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN)               \
3183   builtin_types[(int) ENUM]                             \
3184     = build_function_type (builtin_types[(int) RETURN], \
3185                            void_list_node);
3186 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1)                         \
3187   builtin_types[(int) ENUM]                                             \
3188     = build_function_type (builtin_types[(int) RETURN],                 \
3189                            tree_cons (NULL_TREE,                        \
3190                                       builtin_types[(int) ARG1],        \
3191                                       void_list_node));
3192 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2)   \
3193   builtin_types[(int) ENUM]                             \
3194     = build_function_type                               \
3195       (builtin_types[(int) RETURN],                     \
3196        tree_cons (NULL_TREE,                            \
3197                   builtin_types[(int) ARG1],            \
3198                   tree_cons (NULL_TREE,                 \
3199                              builtin_types[(int) ARG2], \
3200                              void_list_node)));
3201 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3)              \
3202   builtin_types[(int) ENUM]                                              \
3203     = build_function_type                                                \
3204       (builtin_types[(int) RETURN],                                      \
3205        tree_cons (NULL_TREE,                                             \
3206                   builtin_types[(int) ARG1],                             \
3207                   tree_cons (NULL_TREE,                                  \
3208                              builtin_types[(int) ARG2],                  \
3209                              tree_cons (NULL_TREE,                       \
3210                                         builtin_types[(int) ARG3],       \
3211                                         void_list_node))));
3212 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4)       \
3213   builtin_types[(int) ENUM]                                             \
3214     = build_function_type                                               \
3215       (builtin_types[(int) RETURN],                                     \
3216        tree_cons (NULL_TREE,                                            \
3217                   builtin_types[(int) ARG1],                            \
3218                   tree_cons (NULL_TREE,                                 \
3219                              builtin_types[(int) ARG2],                 \
3220                              tree_cons                                  \
3221                              (NULL_TREE,                                \
3222                               builtin_types[(int) ARG3],                \
3223                               tree_cons (NULL_TREE,                     \
3224                                          builtin_types[(int) ARG4],     \
3225                                          void_list_node)))));
3226 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN)                           \
3227   builtin_types[(int) ENUM]                                             \
3228     = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3229 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1)                      \
3230    builtin_types[(int) ENUM]                                             \
3231     = build_function_type (builtin_types[(int) RETURN],                  \
3232                            tree_cons (NULL_TREE,                         \
3233                                       builtin_types[(int) ARG1],         \
3234                                       NULL_TREE));
3235
3236 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2)       \
3237    builtin_types[(int) ENUM]                                    \
3238     = build_function_type                                       \
3239       (builtin_types[(int) RETURN],                             \
3240        tree_cons (NULL_TREE,                                    \
3241                   builtin_types[(int) ARG1],                    \
3242                   tree_cons (NULL_TREE,                         \
3243                              builtin_types[(int) ARG2],         \
3244                              NULL_TREE)));
3245 #define DEF_POINTER_TYPE(ENUM, TYPE)                    \
3246   builtin_types[(int) ENUM]                             \
3247     = build_pointer_type (builtin_types[(int) TYPE]);
3248 #include "builtin-types.def"
3249 #undef DEF_PRIMITIVE_TYPE
3250 #undef DEF_FUNCTION_TYPE_1
3251 #undef DEF_FUNCTION_TYPE_2
3252 #undef DEF_FUNCTION_TYPE_3
3253 #undef DEF_FUNCTION_TYPE_4
3254 #undef DEF_FUNCTION_TYPE_VAR_0
3255 #undef DEF_FUNCTION_TYPE_VAR_1
3256 #undef DEF_POINTER_TYPE
3257
3258 #define DEF_BUILTIN(ENUM, NAME, CLASS,                                  \
3259                     TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P)       \
3260   if (NAME)                                                             \
3261     {                                                                   \
3262       tree decl;                                                        \
3263                                                                         \
3264       if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)     \
3265         abort ();                                                       \
3266                                                                         \
3267       if (!BOTH_P)                                                      \
3268         decl = builtin_function (NAME, builtin_types[TYPE], ENUM,       \
3269                                  CLASS,                                 \
3270                                  (FALLBACK_P                            \
3271                                   ? (NAME + strlen ("__builtin_"))      \
3272                                   : NULL));                             \
3273       else                                                              \
3274         decl = builtin_function_2 (NAME,                                \
3275                                    NAME + strlen ("__builtin_"),        \
3276                                    builtin_types[TYPE],                 \
3277                                    builtin_types[LIBTYPE],              \
3278                                    ENUM,                                \
3279                                    CLASS,                               \
3280                                    FALLBACK_P,                          \
3281                                    NONANSI_P,                           \
3282                                    /*noreturn_p=*/0);                   \
3283                                                                         \
3284       built_in_decls[(int) ENUM] = decl;                                \
3285     }
3286 #include "builtins.def"
3287 #undef DEF_BUILTIN
3288
3289   /* Declare _exit and _Exit just to mark them as non-returning.  */
3290   builtin_function_2 (NULL, "_exit", NULL_TREE,
3291                       builtin_types[BT_FN_VOID_INT],
3292                       0, NOT_BUILT_IN, 0, 1, 1);
3293   builtin_function_2 (NULL, "_Exit", NULL_TREE,
3294                       builtin_types[BT_FN_VOID_INT],
3295                       0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
3296
3297   /* Declare these functions non-returning
3298      to avoid spurious "control drops through" warnings.  */
3299   builtin_function_2 (NULL, "abort",
3300                       NULL_TREE, ((c_language == clk_cplusplus)
3301                                   ? builtin_types[BT_FN_VOID]
3302                                   : builtin_types[BT_FN_VOID_VAR]),
3303                       0, NOT_BUILT_IN, 0, 0, 1);
3304
3305   builtin_function_2 (NULL, "exit",
3306                       NULL_TREE, ((c_language == clk_cplusplus)
3307                                   ? builtin_types[BT_FN_VOID_INT]
3308                                   : builtin_types[BT_FN_VOID_VAR]),
3309                       0, NOT_BUILT_IN, 0, 0, 1);
3310
3311   main_identifier_node = get_identifier ("main");
3312
3313   /* ??? Perhaps there's a better place to do this.  But it is related
3314      to __builtin_va_arg, so it isn't that off-the-wall.  */
3315   lang_type_promotes_to = simple_type_promotes_to;
3316 }
3317
3318 tree
3319 build_va_arg (expr, type)
3320      tree expr, type;
3321 {
3322   return build1 (VA_ARG_EXPR, type, expr);
3323 }
3324
3325
3326 /* Possibly define a builtin function with one or two names.  BUILTIN_NAME
3327    is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3328    of these may be NULL (though both being NULL is useless).
3329    BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3330    TYPE is the type of the function with the ordinary name.  These
3331    may differ if the ordinary name is declared with a looser type to avoid
3332    conflicts with headers.  FUNCTION_CODE and CLASS are as for
3333    builtin_function.  If LIBRARY_NAME_P is nonzero, NAME is passed as
3334    the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3335    If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3336    NORETURN_P is nonzero, the function is marked as non-returning.
3337    Returns the declaration of BUILTIN_NAME, if any, otherwise
3338    the declaration of NAME.  Does not declare NAME if flag_no_builtin,
3339    or if NONANSI_P and flag_no_nonansi_builtin.  */
3340
3341 static tree
3342 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3343                     class, library_name_p, nonansi_p, noreturn_p)
3344      const char *builtin_name;
3345      const char *name;
3346      tree builtin_type;
3347      tree type;
3348      int function_code;
3349      enum built_in_class class;
3350      int library_name_p;
3351      int nonansi_p;
3352      int noreturn_p;
3353 {
3354   tree bdecl = NULL_TREE;
3355   tree decl = NULL_TREE;
3356   if (builtin_name != 0)
3357     {
3358       bdecl = builtin_function (builtin_name, builtin_type, function_code,
3359                                 class, library_name_p ? name : NULL);
3360       if (noreturn_p)
3361         {
3362           TREE_THIS_VOLATILE (bdecl) = 1;
3363           TREE_SIDE_EFFECTS (bdecl) = 1;
3364         }
3365     }
3366   if (name != 0 && !flag_no_builtin && !(nonansi_p && flag_no_nonansi_builtin))
3367     {
3368       decl = builtin_function (name, type, function_code, class, NULL);
3369       if (nonansi_p)
3370         DECL_BUILT_IN_NONANSI (decl) = 1;
3371       if (noreturn_p)
3372         {
3373           TREE_THIS_VOLATILE (decl) = 1;
3374           TREE_SIDE_EFFECTS (decl) = 1;
3375         }
3376     }
3377   return (bdecl != 0 ? bdecl : decl);
3378 }
3379 \f
3380 /* Nonzero if the type T promotes to int.  This is (nearly) the
3381    integral promotions defined in ISO C99 6.3.1.1/2.  */
3382
3383 bool
3384 c_promoting_integer_type_p (t)
3385      tree t;
3386 {
3387   switch (TREE_CODE (t))
3388     {
3389     case INTEGER_TYPE:
3390       return (TYPE_MAIN_VARIANT (t) == char_type_node
3391               || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3392               || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3393               || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3394               || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node);
3395
3396     case ENUMERAL_TYPE:
3397       /* ??? Technically all enumerations not larger than an int
3398          promote to an int.  But this is used along code paths
3399          that only want to notice a size change.  */
3400       return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3401
3402     case BOOLEAN_TYPE:
3403       return 1;
3404
3405     default:
3406       return 0;
3407     }
3408 }
3409
3410 /* Given a type, apply default promotions wrt unnamed function arguments
3411    and return the new type.  Return NULL_TREE if no change.  */
3412 /* ??? There is a function of the same name in the C++ front end that
3413    does something similar, but is more thorough and does not return NULL
3414    if no change.  We could perhaps share code, but it would make the
3415    self_promoting_type property harder to identify.  */
3416
3417 tree
3418 simple_type_promotes_to (type)
3419      tree type;
3420 {
3421   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3422     return double_type_node;
3423
3424   if (c_promoting_integer_type_p (type))
3425     {
3426       /* Traditionally, unsignedness is preserved in default promotions.
3427          Also preserve unsignedness if not really getting any wider.  */
3428       if (TREE_UNSIGNED (type)
3429           && (flag_traditional
3430               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3431         return unsigned_type_node;
3432       return integer_type_node;
3433     }
3434
3435   return NULL_TREE;
3436 }
3437
3438 /* Return 1 if PARMS specifies a fixed number of parameters
3439    and none of their types is affected by default promotions.  */
3440
3441 int
3442 self_promoting_args_p (parms)
3443      tree parms;
3444 {
3445   register tree t;
3446   for (t = parms; t; t = TREE_CHAIN (t))
3447     {
3448       register tree type = TREE_VALUE (t);
3449
3450       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3451         return 0;
3452
3453       if (type == 0)
3454         return 0;
3455
3456       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3457         return 0;
3458
3459       if (c_promoting_integer_type_p (type))
3460         return 0;
3461     }
3462   return 1;
3463 }
3464
3465 /* Recursively examines the array elements of TYPE, until a non-array
3466    element type is found.  */
3467
3468 tree
3469 strip_array_types (type)
3470      tree type;
3471 {
3472   while (TREE_CODE (type) == ARRAY_TYPE)
3473     type = TREE_TYPE (type);
3474
3475   return type;
3476 }
3477
3478 /* Recognize certain built-in functions so we can make tree-codes
3479    other than CALL_EXPR.  We do this when it enables fold-const.c
3480    to do something useful.  */
3481 /* ??? By rights this should go in builtins.c, but only C and C++
3482    implement build_{binary,unary}_op.  Not exactly sure what bits
3483    of functionality are actually needed from those functions, or
3484    where the similar functionality exists in the other front ends.  */
3485
3486 tree
3487 expand_tree_builtin (function, params, coerced_params)
3488      tree function, params, coerced_params;
3489 {
3490   enum tree_code code;
3491
3492   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3493     return NULL_TREE;
3494
3495   switch (DECL_FUNCTION_CODE (function))
3496     {
3497     case BUILT_IN_ABS:
3498     case BUILT_IN_LABS:
3499     case BUILT_IN_LLABS:
3500     case BUILT_IN_IMAXABS:
3501     case BUILT_IN_FABS:
3502     case BUILT_IN_FABSL:
3503     case BUILT_IN_FABSF:
3504       if (coerced_params == 0)
3505         return integer_zero_node;
3506       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3507
3508     case BUILT_IN_CONJ:
3509     case BUILT_IN_CONJF:
3510     case BUILT_IN_CONJL:
3511       if (coerced_params == 0)
3512         return integer_zero_node;
3513       return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3514
3515     case BUILT_IN_CREAL:
3516     case BUILT_IN_CREALF:
3517     case BUILT_IN_CREALL:
3518       if (coerced_params == 0)
3519         return integer_zero_node;
3520       return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3521
3522     case BUILT_IN_CIMAG:
3523     case BUILT_IN_CIMAGF:
3524     case BUILT_IN_CIMAGL:
3525       if (coerced_params == 0)
3526         return integer_zero_node;
3527       return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3528
3529     case BUILT_IN_ISGREATER:
3530       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3531         code = UNLE_EXPR;
3532       else
3533         code = LE_EXPR;
3534       goto unordered_cmp;
3535
3536     case BUILT_IN_ISGREATEREQUAL:
3537       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3538         code = UNLT_EXPR;
3539       else
3540         code = LT_EXPR;
3541       goto unordered_cmp;
3542
3543     case BUILT_IN_ISLESS:
3544       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3545         code = UNGE_EXPR;
3546       else
3547         code = GE_EXPR;
3548       goto unordered_cmp;
3549
3550     case BUILT_IN_ISLESSEQUAL:
3551       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3552         code = UNGT_EXPR;
3553       else
3554         code = GT_EXPR;
3555       goto unordered_cmp;
3556
3557     case BUILT_IN_ISLESSGREATER:
3558       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3559         code = UNEQ_EXPR;
3560       else
3561         code = EQ_EXPR;
3562       goto unordered_cmp;
3563
3564     case BUILT_IN_ISUNORDERED:
3565       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3566         return integer_zero_node;
3567       code = UNORDERED_EXPR;
3568       goto unordered_cmp;
3569
3570     unordered_cmp:
3571       {
3572         tree arg0, arg1;
3573
3574         if (params == 0
3575             || TREE_CHAIN (params) == 0)
3576           {
3577             error ("too few arguments to function `%s'",
3578                    IDENTIFIER_POINTER (DECL_NAME (function)));
3579             return error_mark_node;
3580           }
3581         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3582           {
3583             error ("too many arguments to function `%s'",
3584                    IDENTIFIER_POINTER (DECL_NAME (function)));
3585             return error_mark_node;
3586           }
3587
3588         arg0 = TREE_VALUE (params);
3589         arg1 = TREE_VALUE (TREE_CHAIN (params));
3590         arg0 = build_binary_op (code, arg0, arg1, 0);
3591         if (code != UNORDERED_EXPR)
3592           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3593         return arg0;
3594       }
3595       break;
3596
3597     default:
3598       break;
3599     }
3600
3601   return NULL_TREE;
3602 }
3603
3604 /* Returns non-zero if CODE is the code for a statement.  */
3605
3606 int
3607 statement_code_p (code)
3608      enum tree_code code;
3609 {
3610   switch (code)
3611     {
3612     case EXPR_STMT:
3613     case COMPOUND_STMT:
3614     case DECL_STMT:
3615     case IF_STMT:
3616     case FOR_STMT:
3617     case WHILE_STMT:
3618     case DO_STMT:
3619     case RETURN_STMT:
3620     case BREAK_STMT:
3621     case CONTINUE_STMT:
3622     case SCOPE_STMT:
3623     case SWITCH_STMT:
3624     case GOTO_STMT:
3625     case LABEL_STMT:
3626     case ASM_STMT:
3627     case CASE_LABEL:
3628       return 1;
3629
3630     default:
3631       if (lang_statement_code_p)
3632         return (*lang_statement_code_p) (code);
3633       return 0;
3634     }
3635 }
3636
3637 /* Walk the statement tree, rooted at *tp.  Apply FUNC to all the
3638    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
3639    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
3640    value, the traversal is aborted, and the value returned by FUNC is
3641    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3642    the node being visited are not walked.
3643
3644    We don't need a without_duplicates variant of this one because the
3645    statement tree is a tree, not a graph.  */
3646
3647 tree
3648 walk_stmt_tree (tp, func, data)
3649      tree *tp;
3650      walk_tree_fn func;
3651      void *data;
3652 {
3653   enum tree_code code;
3654   int walk_subtrees;
3655   tree result;
3656   int i, len;
3657
3658 #define WALK_SUBTREE(NODE)                              \
3659   do                                                    \
3660     {                                                   \
3661       result = walk_stmt_tree (&(NODE), func, data);    \
3662       if (result)                                       \
3663         return result;                                  \
3664     }                                                   \
3665   while (0)
3666
3667   /* Skip empty subtrees.  */
3668   if (!*tp)
3669     return NULL_TREE;
3670
3671   /* Skip subtrees below non-statement nodes.  */
3672   if (!statement_code_p (TREE_CODE (*tp)))
3673     return NULL_TREE;
3674
3675   /* Call the function.  */
3676   walk_subtrees = 1;
3677   result = (*func) (tp, &walk_subtrees, data);
3678
3679   /* If we found something, return it.  */
3680   if (result)
3681     return result;
3682
3683   /* FUNC may have modified the tree, recheck that we're looking at a
3684      statement node.  */
3685   code = TREE_CODE (*tp);
3686   if (!statement_code_p (code))
3687     return NULL_TREE;
3688
3689   /* Visit the subtrees unless FUNC decided that there was nothing
3690      interesting below this point in the tree.  */
3691   if (walk_subtrees)
3692     {
3693       /* Walk over all the sub-trees of this operand.  Statement nodes
3694          never contain RTL, and we needn't worry about TARGET_EXPRs.  */
3695       len = TREE_CODE_LENGTH (code);
3696
3697       /* Go through the subtrees.  We need to do this in forward order so
3698          that the scope of a FOR_EXPR is handled properly.  */
3699       for (i = 0; i < len; ++i)
3700         WALK_SUBTREE (TREE_OPERAND (*tp, i));
3701     }
3702
3703   /* Finally visit the chain.  This can be tail-recursion optimized if
3704      we write it this way.  */
3705   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3706
3707 #undef WALK_SUBTREE
3708 }
3709
3710 /* Used to compare case labels.  K1 and K2 are actually tree nodes
3711    representing case labels, or NULL_TREE for a `default' label.
3712    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3713    K2, and 0 if K1 and K2 are equal.  */
3714
3715 int
3716 case_compare (k1, k2)
3717      splay_tree_key k1;
3718      splay_tree_key k2;
3719 {
3720   /* Consider a NULL key (such as arises with a `default' label) to be
3721      smaller than anything else.  */
3722   if (!k1)
3723     return k2 ? -1 : 0;
3724   else if (!k2)
3725     return k1 ? 1 : 0;
3726
3727   return tree_int_cst_compare ((tree) k1, (tree) k2);
3728 }
3729
3730 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3731    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3732    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3733    case label was declared using the usual C/C++ syntax, rather than
3734    the GNU case range extension.  CASES is a tree containing all the
3735    case ranges processed so far; COND is the condition for the
3736    switch-statement itself.  Returns the CASE_LABEL created, or
3737    ERROR_MARK_NODE if no CASE_LABEL is created.  */
3738
3739 tree
3740 c_add_case_label (cases, cond, low_value, high_value)
3741      splay_tree cases;
3742      tree cond;
3743      tree low_value;
3744      tree high_value;
3745 {
3746   tree type;
3747   tree label;
3748   tree case_label;
3749   splay_tree_node node;
3750
3751   /* Create the LABEL_DECL itself.  */
3752   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3753   DECL_CONTEXT (label) = current_function_decl;
3754
3755   /* If there was an error processing the switch condition, bail now
3756      before we get more confused.  */
3757   if (!cond || cond == error_mark_node)
3758     {
3759       /* Add a label anyhow so that the back-end doesn't think that
3760          the beginning of the switch is unreachable.  */
3761       if (!cases->root)
3762         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3763       return error_mark_node;
3764     }
3765
3766   if ((low_value && TREE_TYPE (low_value)
3767        && POINTER_TYPE_P (TREE_TYPE (low_value)))
3768       || (high_value && TREE_TYPE (high_value)
3769           && POINTER_TYPE_P (TREE_TYPE (high_value))))
3770     error ("pointers are not permitted as case values");
3771
3772   /* Case ranges are a GNU extension.  */
3773   if (high_value && pedantic)
3774     {
3775       if (c_language == clk_cplusplus)
3776         pedwarn ("ISO C++ forbids range expressions in switch statements");
3777       else
3778         pedwarn ("ISO C forbids range expressions in switch statements");
3779     }
3780
3781   type = TREE_TYPE (cond);
3782   if (low_value)
3783     {
3784       low_value = check_case_value (low_value);
3785       low_value = convert_and_check (type, low_value);
3786     }
3787   if (high_value)
3788     {
3789       high_value = check_case_value (high_value);
3790       high_value = convert_and_check (type, high_value);
3791     }
3792
3793   /* If an error has occurred, bail out now.  */
3794   if (low_value == error_mark_node || high_value == error_mark_node)
3795     {
3796       if (!cases->root)
3797         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3798       return error_mark_node;
3799     }
3800
3801   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3802      really a case range, even though it was written that way.  Remove
3803      the HIGH_VALUE to simplify later processing.  */
3804   if (tree_int_cst_equal (low_value, high_value))
3805     high_value = NULL_TREE;
3806   if (low_value && high_value
3807       && !tree_int_cst_lt (low_value, high_value))
3808     warning ("empty range specified");
3809
3810   /* Look up the LOW_VALUE in the table of case labels we already
3811      have.  */
3812   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3813   /* If there was not an exact match, check for overlapping ranges.
3814      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3815      that's a `default' label and the only overlap is an exact match.  */
3816   if (!node && (low_value || high_value))
3817     {
3818       splay_tree_node low_bound;
3819       splay_tree_node high_bound;
3820
3821       /* Even though there wasn't an exact match, there might be an
3822          overlap between this case range and another case range.
3823          Since we've (inductively) not allowed any overlapping case
3824          ranges, we simply need to find the greatest low case label
3825          that is smaller that LOW_VALUE, and the smallest low case
3826          label that is greater than LOW_VALUE.  If there is an overlap
3827          it will occur in one of these two ranges.  */
3828       low_bound = splay_tree_predecessor (cases,
3829                                           (splay_tree_key) low_value);
3830       high_bound = splay_tree_successor (cases,
3831                                          (splay_tree_key) low_value);
3832
3833       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3834          the LOW_VALUE, so there is no need to check unless the
3835          LOW_BOUND is in fact itself a case range.  */
3836       if (low_bound
3837           && CASE_HIGH ((tree) low_bound->value)
3838           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3839                                     low_value) >= 0)
3840         node = low_bound;
3841       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3842          range is bigger than the low end of the current range, so we
3843          are only interested if the current range is a real range, and
3844          not an ordinary case label.  */
3845       else if (high_bound
3846                && high_value
3847                && (tree_int_cst_compare ((tree) high_bound->key,
3848                                          high_value)
3849                    <= 0))
3850         node = high_bound;
3851     }
3852   /* If there was an overlap, issue an error.  */
3853   if (node)
3854     {
3855       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3856
3857       if (high_value)
3858         {
3859           error ("duplicate (or overlapping) case value");
3860           error_with_decl (duplicate,
3861                            "this is the first entry overlapping that value");
3862         }
3863       else if (low_value)
3864         {
3865           error ("duplicate case value") ;
3866           error_with_decl (duplicate, "previously used here");
3867         }
3868       else
3869         {
3870           error ("multiple default labels in one switch");
3871           error_with_decl (duplicate, "this is the first default label");
3872         }
3873       if (!cases->root)
3874         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3875     }
3876
3877   /* Add a CASE_LABEL to the statement-tree.  */
3878   case_label = add_stmt (build_case_label (low_value, high_value, label));
3879   /* Register this case label in the splay tree.  */
3880   splay_tree_insert (cases,
3881                      (splay_tree_key) low_value,
3882                      (splay_tree_value) case_label);
3883
3884   return case_label;
3885 }
3886
3887 /* Finish an expression taking the address of LABEL.  Returns an
3888    expression for the address.  */
3889
3890 tree
3891 finish_label_address_expr (label)
3892      tree label;
3893 {
3894   tree result;
3895
3896   if (pedantic)
3897     {
3898       if (c_language == clk_cplusplus)
3899         pedwarn ("ISO C++ forbids taking the address of a label");
3900       else
3901         pedwarn ("ISO C forbids taking the address of a label");
3902     }
3903
3904   label = lookup_label (label);
3905   if (label == NULL_TREE)
3906     result = null_pointer_node;
3907   else
3908     {
3909       TREE_USED (label) = 1;
3910       result = build1 (ADDR_EXPR, ptr_type_node, label);
3911       TREE_CONSTANT (result) = 1;
3912       /* The current function in not necessarily uninlinable.
3913          Computed gotos are incompatible with inlining, but the value
3914          here could be used only in a diagnostic, for example.  */
3915     }
3916
3917   return result;
3918 }
3919
3920 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
3921    parameter allows this function to be used as a GC-marking
3922    function.  */
3923
3924 void
3925 mark_stmt_tree (p)
3926      void *p;
3927 {
3928   stmt_tree st = (stmt_tree) p;
3929
3930   ggc_mark_tree (st->x_last_stmt);
3931   ggc_mark_tree (st->x_last_expr_type);
3932 }
3933
3934 /* Mark LD for GC.  */
3935
3936 void
3937 c_mark_lang_decl (c)
3938      struct c_lang_decl *c;
3939 {
3940   ggc_mark_tree (c->saved_tree);
3941 }
3942
3943 /* Mark F for GC.  */
3944
3945 void
3946 mark_c_language_function (f)
3947      struct language_function *f;
3948 {
3949   if (!f)
3950     return;
3951
3952   mark_stmt_tree (&f->x_stmt_tree);
3953   ggc_mark_tree (f->x_scope_stmt_stack);
3954 }
3955
3956 /* Hook used by expand_expr to expand language-specific tree codes.  */
3957
3958 rtx
3959 c_expand_expr (exp, target, tmode, modifier)
3960      tree exp;
3961      rtx target;
3962      enum machine_mode tmode;
3963      enum expand_modifier modifier;
3964 {
3965   switch (TREE_CODE (exp))
3966     {
3967     case STMT_EXPR:
3968       {
3969         tree rtl_expr;
3970         rtx result;
3971
3972         /* Since expand_expr_stmt calls free_temp_slots after every
3973            expression statement, we must call push_temp_slots here.
3974            Otherwise, any temporaries in use now would be considered
3975            out-of-scope after the first EXPR_STMT from within the
3976            STMT_EXPR.  */
3977         push_temp_slots ();
3978         rtl_expr = expand_start_stmt_expr ();
3979         expand_stmt (STMT_EXPR_STMT (exp));
3980         expand_end_stmt_expr (rtl_expr);
3981         result = expand_expr (rtl_expr, target, tmode, modifier);
3982         pop_temp_slots ();
3983         return result;
3984       }
3985       break;
3986
3987     case CALL_EXPR:
3988       {
3989         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3990             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3991                 == FUNCTION_DECL)
3992             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3993             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3994                 == BUILT_IN_FRONTEND))
3995           return c_expand_builtin (exp, target, tmode, modifier);
3996         else
3997           abort();
3998       }
3999       break;
4000
4001     default:
4002       abort ();
4003     }
4004
4005   abort ();
4006   return NULL;
4007 }
4008
4009 /* Hook used by safe_from_p to handle language-specific tree codes.  */
4010
4011 int
4012 c_safe_from_p (target, exp)
4013      rtx target;
4014      tree exp;
4015 {
4016   /* We can see statements here when processing the body of a
4017      statement-expression.  For a declaration statement declaring a
4018      variable, look at the variable's initializer.  */
4019   if (TREE_CODE (exp) == DECL_STMT)
4020     {
4021       tree decl = DECL_STMT_DECL (exp);
4022
4023       if (TREE_CODE (decl) == VAR_DECL
4024           && DECL_INITIAL (decl)
4025           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4026         return 0;
4027     }
4028
4029   /* For any statement, we must follow the statement-chain.  */
4030   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
4031     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4032
4033   /* Assume everything else is safe.  */
4034   return 1;
4035 }
4036
4037 /* Hook used by unsafe_for_reeval to handle language-specific tree codes.  */
4038
4039 int
4040 c_unsafe_for_reeval (exp)
4041      tree exp;
4042 {
4043   /* Statement expressions may not be reevaluated.  */
4044   if (TREE_CODE (exp) == STMT_EXPR)
4045     return 2;
4046
4047   /* Walk all other expressions.  */
4048   return -1;
4049 }
4050
4051 /* Tree code classes.  */
4052
4053 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
4054
4055 static char c_tree_code_type[] = {
4056   'x',
4057 #include "c-common.def"
4058 };
4059 #undef DEFTREECODE
4060
4061 /* Table indexed by tree code giving number of expression
4062    operands beyond the fixed part of the node structure.
4063    Not used for types or decls.  */
4064
4065 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
4066
4067 static int c_tree_code_length[] = {
4068   0,
4069 #include "c-common.def"
4070 };
4071 #undef DEFTREECODE
4072
4073 /* Names of tree components.
4074    Used for printing out the tree and error messages.  */
4075 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
4076
4077 static const char *const c_tree_code_name[] = {
4078   "@@dummy",
4079 #include "c-common.def"
4080 };
4081 #undef DEFTREECODE
4082
4083 /* Adds the tree codes specific to the C front end to the list of all
4084    tree codes.  */
4085
4086 void
4087 add_c_tree_codes ()
4088 {
4089   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
4090           c_tree_code_type,
4091           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
4092   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
4093           c_tree_code_length,
4094           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
4095   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
4096           c_tree_code_name,
4097           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
4098   lang_unsafe_for_reeval = c_unsafe_for_reeval;
4099 }
4100
4101 #define CALLED_AS_BUILT_IN(NODE) \
4102    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4103
4104 static rtx
4105 c_expand_builtin (exp, target, tmode, modifier)
4106      tree exp;
4107      rtx target;
4108      enum machine_mode tmode;
4109      enum expand_modifier modifier;
4110 {
4111   tree type = TREE_TYPE (exp);
4112   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
4113   tree arglist = TREE_OPERAND (exp, 1);
4114   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4115   enum tree_code code = TREE_CODE (exp);
4116   const int ignore = (target == const0_rtx
4117                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
4118                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
4119                            || code == COND_EXPR)
4120                           && TREE_CODE (type) == VOID_TYPE));
4121
4122   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
4123     return expand_call (exp, target, ignore);
4124
4125   switch (fcode)
4126     {
4127     case BUILT_IN_PRINTF:
4128       target = c_expand_builtin_printf (arglist, target, tmode,
4129                                         modifier, ignore);
4130       if (target)
4131         return target;
4132       break;
4133
4134     case BUILT_IN_FPRINTF:
4135       target = c_expand_builtin_fprintf (arglist, target, tmode,
4136                                          modifier, ignore);
4137       if (target)
4138         return target;
4139       break;
4140
4141     default:                    /* just do library call, if unknown builtin */
4142       error ("built-in function `%s' not currently supported",
4143              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
4144     }
4145
4146   /* The switch statement above can drop through to cause the function
4147      to be called normally.  */
4148   return expand_call (exp, target, ignore);
4149 }
4150
4151 /* Check an arglist to *printf for problems.  The arglist should start
4152    at the format specifier, with the remaining arguments immediately
4153    following it.  */
4154 static int
4155 is_valid_printf_arglist (arglist)
4156   tree arglist;
4157 {
4158   /* Save this value so we can restore it later.  */
4159   const int SAVE_pedantic = pedantic;
4160   int diagnostic_occurred = 0;
4161
4162   /* Set this to a known value so the user setting won't affect code
4163      generation.  */
4164   pedantic = 1;
4165   /* Check to make sure there are no format specifier errors.  */
4166   check_function_format (&diagnostic_occurred,
4167                          maybe_get_identifier("printf"),
4168                          NULL_TREE, arglist);
4169
4170   /* Restore the value of `pedantic'.  */
4171   pedantic = SAVE_pedantic;
4172
4173   /* If calling `check_function_format_ptr' produces a warning, we
4174      return false, otherwise we return true.  */
4175   return ! diagnostic_occurred;
4176 }
4177
4178 /* If the arguments passed to printf are suitable for optimizations,
4179    we attempt to transform the call.  */
4180 static rtx
4181 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
4182      tree arglist;
4183      rtx target;
4184      enum machine_mode tmode;
4185      enum expand_modifier modifier;
4186      int ignore;
4187 {
4188   tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
4189     fn_puts = built_in_decls[BUILT_IN_PUTS];
4190   tree fn, format_arg, stripped_string;
4191
4192   /* If the return value is used, or the replacement _DECL isn't
4193      initialized, don't do the transformation.  */
4194   if (!ignore || !fn_putchar || !fn_puts)
4195     return 0;
4196
4197   /* Verify the required arguments in the original call.  */
4198   if (arglist == 0
4199       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
4200     return 0;
4201
4202   /* Check the specifier vs. the parameters.  */
4203   if (!is_valid_printf_arglist (arglist))
4204     return 0;
4205
4206   format_arg = TREE_VALUE (arglist);
4207   stripped_string = format_arg;
4208   STRIP_NOPS (stripped_string);
4209   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4210     stripped_string = TREE_OPERAND (stripped_string, 0);
4211
4212   /* If the format specifier isn't a STRING_CST, punt.  */
4213   if (TREE_CODE (stripped_string) != STRING_CST)
4214     return 0;
4215
4216   /* OK!  We can attempt optimization.  */
4217
4218   /* If the format specifier was "%s\n", call __builtin_puts(arg2).  */
4219   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4220     {
4221       arglist = TREE_CHAIN (arglist);
4222       fn = fn_puts;
4223     }
4224   /* If the format specifier was "%c", call __builtin_putchar (arg2).  */
4225   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4226     {
4227       arglist = TREE_CHAIN (arglist);
4228       fn = fn_putchar;
4229     }
4230   else
4231     {
4232      /* We can't handle anything else with % args or %% ... yet.  */
4233       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4234         return 0;
4235
4236       /* If the resulting constant string has a length of 1, call
4237          putchar.  Note, TREE_STRING_LENGTH includes the terminating
4238          NULL in its count.  */
4239       if (TREE_STRING_LENGTH (stripped_string) == 2)
4240         {
4241           /* Given printf("c"), (where c is any one character,)
4242              convert "c"[0] to an int and pass that to the replacement
4243              function.  */
4244           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4245           arglist = build_tree_list (NULL_TREE, arglist);
4246
4247           fn = fn_putchar;
4248         }
4249       /* If the resulting constant was "string\n", call
4250          __builtin_puts("string").  Ensure "string" has at least one
4251          character besides the trailing \n.  Note, TREE_STRING_LENGTH
4252          includes the terminating NULL in its count.  */
4253       else if (TREE_STRING_LENGTH (stripped_string) > 2
4254                && TREE_STRING_POINTER (stripped_string)
4255                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4256         {
4257           /* Create a NULL-terminated string that's one char shorter
4258              than the original, stripping off the trailing '\n'.  */
4259           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4260           char *newstr = (char *) alloca (newlen);
4261           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4262           newstr[newlen - 1] = 0;
4263
4264           arglist = combine_strings (build_string (newlen, newstr));
4265           arglist = build_tree_list (NULL_TREE, arglist);
4266           fn = fn_puts;
4267         }
4268       else
4269         /* We'd like to arrange to call fputs(string) here, but we
4270            need stdout and don't have a way to get it ... yet.  */
4271         return 0;
4272     }
4273
4274   return expand_expr (build_function_call (fn, arglist),
4275                       (ignore ? const0_rtx : target),
4276                       tmode, modifier);
4277 }
4278
4279 /* If the arguments passed to fprintf are suitable for optimizations,
4280    we attempt to transform the call.  */
4281 static rtx
4282 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
4283      tree arglist;
4284      rtx target;
4285      enum machine_mode tmode;
4286      enum expand_modifier modifier;
4287      int ignore;
4288 {
4289   tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
4290     fn_fputs = built_in_decls[BUILT_IN_FPUTS];
4291   tree fn, format_arg, stripped_string;
4292
4293   /* If the return value is used, or the replacement _DECL isn't
4294      initialized, don't do the transformation.  */
4295   if (!ignore || !fn_fputc || !fn_fputs)
4296     return 0;
4297
4298   /* Verify the required arguments in the original call.  */
4299   if (arglist == 0
4300       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4301       || (TREE_CHAIN (arglist) == 0)
4302       || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4303           POINTER_TYPE))
4304     return 0;
4305
4306   /* Check the specifier vs. the parameters.  */
4307   if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4308     return 0;
4309
4310   format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4311   stripped_string = format_arg;
4312   STRIP_NOPS (stripped_string);
4313   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4314     stripped_string = TREE_OPERAND (stripped_string, 0);
4315
4316   /* If the format specifier isn't a STRING_CST, punt.  */
4317   if (TREE_CODE (stripped_string) != STRING_CST)
4318     return 0;
4319
4320   /* OK!  We can attempt optimization.  */
4321
4322   /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1).  */
4323   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4324     {
4325       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4326       arglist = tree_cons (NULL_TREE,
4327                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4328                            newarglist);
4329       fn = fn_fputs;
4330     }
4331   /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1).  */
4332   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4333     {
4334       tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4335       arglist = tree_cons (NULL_TREE,
4336                            TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4337                            newarglist);
4338       fn = fn_fputc;
4339     }
4340   else
4341     {
4342      /* We can't handle anything else with % args or %% ... yet.  */
4343       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4344         return 0;
4345
4346       /* When "string" doesn't contain %, replace all cases of
4347          fprintf(stream,string) with fputs(string,stream).  The fputs
4348          builtin will take take of special cases like length==1.  */
4349       arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4350                            build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4351       fn = fn_fputs;
4352     }
4353
4354   return expand_expr (build_function_call (fn, arglist),
4355                       (ignore ? const0_rtx : target),
4356                       tmode, modifier);
4357 }
4358 \f
4359
4360 /* Given a boolean expression ARG, return a tree representing an increment
4361    or decrement (as indicated by CODE) of ARG.  The front end must check for
4362    invalid cases (e.g., decrement in C++).  */
4363 tree
4364 boolean_increment (code, arg)
4365      enum tree_code code;
4366      tree arg;
4367 {
4368   tree val;
4369   tree true_res = (c_language == clk_cplusplus
4370                    ? boolean_true_node
4371                    : c_bool_true_node);
4372   arg = stabilize_reference (arg);
4373   switch (code)
4374     {
4375     case PREINCREMENT_EXPR:
4376       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4377       break;
4378     case POSTINCREMENT_EXPR:
4379       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4380       arg = save_expr (arg);
4381       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4382       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4383       break;
4384     case PREDECREMENT_EXPR:
4385       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4386       break;
4387     case POSTDECREMENT_EXPR:
4388       val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4389       arg = save_expr (arg);
4390       val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4391       val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4392       break;
4393     default:
4394       abort ();
4395     }
4396   TREE_SIDE_EFFECTS (val) = 1;
4397   return val;
4398 }
4399 \f
4400
4401 /* Do the parts of lang_init common to C and C++.  */
4402 void
4403 c_common_lang_init ()
4404 {
4405   /* If still "unspecified", make it match -fbounded-pointers.  */
4406   if (flag_bounds_check < 0)
4407     flag_bounds_check = flag_bounded_pointers;
4408
4409   /* Special format checking options don't work without -Wformat; warn if
4410      they are used.  */
4411   if (warn_format_y2k && !warn_format)
4412     warning ("-Wformat-y2k ignored without -Wformat");
4413   if (warn_format_extra_args && !warn_format)
4414     warning ("-Wformat-extra-args ignored without -Wformat");
4415   if (warn_format_nonliteral && !warn_format)
4416     warning ("-Wformat-nonliteral ignored without -Wformat");
4417   if (warn_format_security && !warn_format)
4418     warning ("-Wformat-security ignored without -Wformat");
4419   if (warn_missing_format_attribute && !warn_format)
4420     warning ("-Wmissing-format-attribute ignored without -Wformat");
4421 }