gcc/c-common.c

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