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