gcc/c-common.c

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