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
   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 "intl.h"
  35 #include "diagnostic.h"
  36
  37 #if USE_CPPLIB
  38 #include "cpplib.h"
  39 cpp_reader  parse_in;
  40 #endif
  41
  42 #undef WCHAR_TYPE_SIZE
  43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  44
  45 /* The following symbols are subsumed in the c_global_trees array, and
  46    listed here individually for documentation purposes.
  47
  48    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  49
  50         tree short_integer_type_node;
  51         tree long_integer_type_node;
  52         tree long_long_integer_type_node;
  53
  54         tree short_unsigned_type_node;
  55         tree long_unsigned_type_node;
  56         tree long_long_unsigned_type_node;
  57
  58         tree boolean_type_node;
  59         tree boolean_false_node;
  60         tree boolean_true_node;
  61
  62         tree ptrdiff_type_node;
  63
  64         tree unsigned_char_type_node;
  65         tree signed_char_type_node;
  66         tree wchar_type_node;
  67         tree signed_wchar_type_node;
  68         tree unsigned_wchar_type_node;
  69
  70         tree float_type_node;
  71         tree double_type_node;
  72         tree long_double_type_node;
  73
  74         tree complex_integer_type_node;
  75         tree complex_float_type_node;
  76         tree complex_double_type_node;
  77         tree complex_long_double_type_node;
  78
  79         tree intQI_type_node;
  80         tree intHI_type_node;
  81         tree intSI_type_node;
  82         tree intDI_type_node;
  83         tree intTI_type_node;
  84
  85         tree unsigned_intQI_type_node;
  86         tree unsigned_intHI_type_node;
  87         tree unsigned_intSI_type_node;
  88         tree unsigned_intDI_type_node;
  89         tree unsigned_intTI_type_node;
  90
  91         tree widest_integer_literal_type_node;
  92         tree widest_unsigned_literal_type_node;
  93
  94    Nodes for types `void *' and `const void *'.
  95
  96         tree ptr_type_node, const_ptr_type_node;
  97
  98    Nodes for types `char *' and `const char *'.
  99
 100         tree string_type_node, const_string_type_node;
 101
 102    Type `char[SOMENUMBER]'.
 103    Used when an array of char is needed and the size is irrelevant.
 104
 105         tree char_array_type_node;
 106
 107    Type `int[SOMENUMBER]' or something like it.
 108    Used when an array of int needed and the size is irrelevant.
 109
 110         tree int_array_type_node;
 111
 112    Type `wchar_t[SOMENUMBER]' or something like it.
 113    Used when a wide string literal is created.
 114
 115         tree wchar_array_type_node;
 116
 117    Type `int ()' -- used for implicit declaration of functions.
 118
 119         tree default_function_type;
 120
 121    Function types `int (int)', etc.
 122
 123         tree int_ftype_int;
 124         tree void_ftype;
 125         tree void_ftype_ptr;
 126         tree int_ftype_int;
 127         tree ptr_ftype_sizetype;
 128
 129    A VOID_TYPE node, packaged in a TREE_LIST.
 130
 131         tree void_list_node;
 132
 133   The identifiers __FUNCTION__, __PRETTY_FUNCTION__, and __func__.
 134
 135         tree function_id_node;
 136         tree pretty_function_id_node;
 137         tree func_id_node;
 138
 139 */
 140
 141 tree c_global_trees[CTI_MAX];
 142
 143 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
 144
 145 int flag_no_builtin;
 146
 147 /* Nonzero means don't recognize the non-ANSI builtin functions.
 148    -ansi sets this.  */
 149
 150 int flag_no_nonansi_builtin;
 151
 152 /* Nonzero means warn about possible violations of sequence point rules.  */
 153
 154 int warn_sequence_point;
 155
 156 /* The elements of `ridpointers' are identifier nodes for the reserved
 157    type names and storage classes.  It is indexed by a RID_... value.  */
 158 tree *ridpointers;
 159
 160 tree (*make_fname_decl)                PARAMS ((tree, const char *, int));
 161
 162 /* If non-NULL, the address of a language-specific function that
 163    returns 1 for language-specific statement codes.  */
 164 int (*lang_statement_code_p)           PARAMS ((enum tree_code));
 165
 166 /* If non-NULL, the address of a language-specific function that takes
 167    any action required right before expand_function_end is called.  */
 168 void (*lang_expand_function_end)       PARAMS ((void));
 169
 170 /* If this variable is defined to a non-NULL value, it will be called
 171    after the file has been completely parsed.  */
 172 void (*back_end_hook) PARAMS ((tree));
 173
 174 /* Nonzero means the expression being parsed will never be evaluated.
 175    This is a count, since unevaluated expressions can nest.  */
 176 int skip_evaluation;
 177
 178 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
 179             A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
 180             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
 181             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS, A_MALLOC,
 182             A_NO_LIMIT_STACK, A_PURE};
 183
 184 enum format_type { printf_format_type, scanf_format_type,
 185                    strftime_format_type };
 186
 187 static void add_attribute               PARAMS ((enum attrs, const char *,
 188                                                  int, int, int));
 189 static void init_attributes             PARAMS ((void));
 190 static void record_function_format      PARAMS ((tree, tree, enum format_type,
 191                                                  int, int));
 192 static void record_international_format PARAMS ((tree, tree, int));
 193 static int default_valid_lang_attribute PARAMS ((tree, tree, tree, tree));
 194
 195 /* Keep a stack of if statements.  We record the number of compound
 196    statements seen up to the if keyword, as well as the line number
 197    and file of the if.  If a potentially ambiguous else is seen, that
 198    fact is recorded; the warning is issued when we can be sure that
 199    the enclosing if statement does not have an else branch.  */
 200 typedef struct
 201 {
 202   int compstmt_count;
 203   int line;
 204   const char *file;
 205   int needs_warning;
 206   tree if_stmt;
 207 } if_elt;
 208
 209 static if_elt *if_stack;
 210
 211 /* Amount of space in the if statement stack.  */
 212 static int if_stack_space = 0;
 213
 214 /* Stack pointer.  */
 215 static int if_stack_pointer = 0;
 216
 217 /* Record the start of an if-then, and record the start of it
 218    for ambiguous else detection.  */
 219
 220 void
 221 c_expand_start_cond (cond, compstmt_count)
 222      tree cond;
 223      int compstmt_count;
 224 {
 225   tree if_stmt;
 226
 227   /* Make sure there is enough space on the stack.  */
 228   if (if_stack_space == 0)
 229     {
 230       if_stack_space = 10;
 231       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 232     }
 233   else if (if_stack_space == if_stack_pointer)
 234     {
 235       if_stack_space += 10;
 236       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 237     }
 238
 239   if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
 240   IF_COND (if_stmt) = cond;
 241   add_stmt (if_stmt);
 242
 243   /* Record this if statement.  */
 244   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 245   if_stack[if_stack_pointer].file = input_filename;
 246   if_stack[if_stack_pointer].line = lineno;
 247   if_stack[if_stack_pointer].needs_warning = 0;
 248   if_stack[if_stack_pointer].if_stmt = if_stmt;
 249   if_stack_pointer++;
 250 }
 251
 252 /* Called after the then-clause for an if-statement is processed.  */
 253
 254 void
 255 c_finish_then ()
 256 {
 257   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 258   RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
 259 }
 260
 261 /* Record the end of an if-then.  Optionally warn if a nested
 262    if statement had an ambiguous else clause.  */
 263
 264 void
 265 c_expand_end_cond ()
 266 {
 267   if_stack_pointer--;
 268   if (if_stack[if_stack_pointer].needs_warning)
 269     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 270                                 if_stack[if_stack_pointer].line,
 271                                 "suggest explicit braces to avoid ambiguous `else'");
 272   last_expr_type = NULL_TREE;
 273 }
 274
 275 /* Called between the then-clause and the else-clause
 276    of an if-then-else.  */
 277
 278 void
 279 c_expand_start_else ()
 280 {
 281   /* An ambiguous else warning must be generated for the enclosing if
 282      statement, unless we see an else branch for that one, too.  */
 283   if (warn_parentheses
 284       && if_stack_pointer > 1
 285       && (if_stack[if_stack_pointer - 1].compstmt_count
 286           == if_stack[if_stack_pointer - 2].compstmt_count))
 287     if_stack[if_stack_pointer - 2].needs_warning = 1;
 288
 289   /* Even if a nested if statement had an else branch, it can't be
 290      ambiguous if this one also has an else.  So don't warn in that
 291      case.  Also don't warn for any if statements nested in this else.  */
 292   if_stack[if_stack_pointer - 1].needs_warning = 0;
 293   if_stack[if_stack_pointer - 1].compstmt_count--;
 294 }
 295
 296 /* Called after the else-clause for an if-statement is processed.  */
 297
 298 void
 299 c_finish_else ()
 300 {
 301   tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
 302   RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
 303 }
 304
 305 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__.  */
 306
 307 void
 308 declare_function_name ()
 309 {
 310   const char *name, *printable_name;
 311
 312   if (current_function_decl == NULL)
 313     {
 314       name = "";
 315       printable_name = "top level";
 316     }
 317   else
 318     {
 319       /* Allow functions to be nameless (such as artificial ones).  */
 320       if (DECL_NAME (current_function_decl))
 321         name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 322       else
 323         name = "";
 324       printable_name = (*decl_printable_name) (current_function_decl, 2);
 325
 326       /* ISO C99 defines __func__, which is a variable, not a string
 327          constant, and which is not a defined symbol at file scope.  */
 328       (*make_fname_decl) (func_id_node, name, 0);
 329     }
 330
 331   (*make_fname_decl) (function_id_node, name, 0);
 332   (*make_fname_decl) (pretty_function_id_node, printable_name, 1);
 333 }
 334
 335 /* Given a chain of STRING_CST nodes,
 336    concatenate them into one STRING_CST
 337    and give it a suitable array-of-chars data type.  */
 338
 339 tree
 340 combine_strings (strings)
 341      tree strings;
 342 {
 343   register tree value, t;
 344   register int length = 1;
 345   int wide_length = 0;
 346   int wide_flag = 0;
 347   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 348   int nchars;
 349   const int nchars_max = flag_isoc99 ? 4095 : 509;
 350
 351   if (TREE_CHAIN (strings))
 352     {
 353       /* More than one in the chain, so concatenate.  */
 354       register char *p, *q;
 355
 356       /* Don't include the \0 at the end of each substring,
 357          except for the last one.
 358          Count wide strings and ordinary strings separately.  */
 359       for (t = strings; t; t = TREE_CHAIN (t))
 360         {
 361           if (TREE_TYPE (t) == wchar_array_type_node)
 362             {
 363               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 364               wide_flag = 1;
 365             }
 366           else
 367             length += (TREE_STRING_LENGTH (t) - 1);
 368         }
 369
 370       /* If anything is wide, the non-wides will be converted,
 371          which makes them take more space.  */
 372       if (wide_flag)
 373         length = length * wchar_bytes + wide_length;
 374
 375       p = ggc_alloc_string (NULL, length);
 376
 377       /* Copy the individual strings into the new combined string.
 378          If the combined string is wide, convert the chars to ints
 379          for any individual strings that are not wide.  */
 380
 381       q = p;
 382       for (t = strings; t; t = TREE_CHAIN (t))
 383         {
 384           int len = (TREE_STRING_LENGTH (t)
 385                      - ((TREE_TYPE (t) == wchar_array_type_node)
 386                         ? wchar_bytes : 1));
 387           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 388             {
 389               memcpy (q, TREE_STRING_POINTER (t), len);
 390               q += len;
 391             }
 392           else
 393             {
 394               int i;
 395               for (i = 0; i < len; i++)
 396                 {
 397                   if (WCHAR_TYPE_SIZE == HOST_BITS_PER_SHORT)
 398                     ((short *) q)[i] = TREE_STRING_POINTER (t)[i];
 399                   else
 400                     ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
 401                 }
 402               q += len * wchar_bytes;
 403             }
 404         }
 405       if (wide_flag)
 406         {
 407           int i;
 408           for (i = 0; i < wchar_bytes; i++)
 409             *q++ = 0;
 410         }
 411       else
 412         *q = 0;
 413
 414       value = make_node (STRING_CST);
 415       TREE_STRING_POINTER (value) = p;
 416       TREE_STRING_LENGTH (value) = length;
 417     }
 418   else
 419     {
 420       value = strings;
 421       length = TREE_STRING_LENGTH (value);
 422       if (TREE_TYPE (value) == wchar_array_type_node)
 423         wide_flag = 1;
 424     }
 425
 426   /* Compute the number of elements, for the array type.  */
 427   nchars = wide_flag ? length / wchar_bytes : length;
 428
 429   if (pedantic && nchars > nchars_max)
 430     pedwarn ("string length `%d' is greater than the minimum length `%d' ISO C%d is required to support",
 431              nchars, nchars_max, flag_isoc99 ? 99 : 89);
 432
 433   /* Create the array type for the string constant.
 434      -Wwrite-strings says make the string constant an array of const char
 435      so that copying it to a non-const pointer will get a warning.
 436      For C++, this is the standard behavior.  */
 437   if (flag_const_strings
 438       && (! flag_traditional  && ! flag_writable_strings))
 439     {
 440       tree elements
 441         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 442                               1, 0);
 443       TREE_TYPE (value)
 444         = build_array_type (elements,
 445                             build_index_type (build_int_2 (nchars - 1, 0)));
 446     }
 447   else
 448     TREE_TYPE (value)
 449       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 450                           build_index_type (build_int_2 (nchars - 1, 0)));
 451
 452   TREE_CONSTANT (value) = 1;
 453   TREE_READONLY (value) = ! flag_writable_strings;
 454   TREE_STATIC (value) = 1;
 455   return value;
 456 }
 457 \f
 458 /* To speed up processing of attributes, we maintain an array of
 459    IDENTIFIER_NODES and the corresponding attribute types.  */
 460
 461 /* Array to hold attribute information.  */
 462
 463 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 464
 465 static int attrtab_idx = 0;
 466
 467 /* Add an entry to the attribute table above.  */
 468
 469 static void
 470 add_attribute (id, string, min_len, max_len, decl_req)
 471      enum attrs id;
 472      const char *string;
 473      int min_len, max_len;
 474      int decl_req;
 475 {
 476   char buf[100];
 477
 478   attrtab[attrtab_idx].id = id;
 479   attrtab[attrtab_idx].name = get_identifier (string);
 480   attrtab[attrtab_idx].min = min_len;
 481   attrtab[attrtab_idx].max = max_len;
 482   attrtab[attrtab_idx++].decl_req = decl_req;
 483
 484   sprintf (buf, "__%s__", string);
 485
 486   attrtab[attrtab_idx].id = id;
 487   attrtab[attrtab_idx].name = get_identifier (buf);
 488   attrtab[attrtab_idx].min = min_len;
 489   attrtab[attrtab_idx].max = max_len;
 490   attrtab[attrtab_idx++].decl_req = decl_req;
 491 }
 492
 493 /* Initialize attribute table.  */
 494
 495 static void
 496 init_attributes ()
 497 {
 498   add_attribute (A_PACKED, "packed", 0, 0, 0);
 499   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 500   add_attribute (A_COMMON, "common", 0, 0, 1);
 501   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 502   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 503   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 504   add_attribute (A_CONST, "const", 0, 0, 1);
 505   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 506   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 507   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 508   add_attribute (A_MODE, "mode", 1, 1, 1);
 509   add_attribute (A_SECTION, "section", 1, 1, 1);
 510   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 511   add_attribute (A_FORMAT, "format", 3, 3, 1);
 512   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 513   add_attribute (A_WEAK, "weak", 0, 0, 1);
 514   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 515   add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
 516   add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
 517   add_attribute (A_MALLOC, "malloc", 0, 0, 1);
 518   add_attribute (A_NO_LIMIT_STACK, "no_stack_limit", 0, 0, 1);
 519   add_attribute (A_PURE, "pure", 0, 0, 1);
 520 }
 521 \f
 522 /* Default implementation of valid_lang_attribute, below.  By default, there
 523    are no language-specific attributes.  */
 524
 525 static int
 526 default_valid_lang_attribute (attr_name, attr_args, decl, type)
 527   tree attr_name ATTRIBUTE_UNUSED;
 528   tree attr_args ATTRIBUTE_UNUSED;
 529   tree decl ATTRIBUTE_UNUSED;
 530   tree type ATTRIBUTE_UNUSED;
 531 {
 532   return 0;
 533 }
 534
 535 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
 536    attribute for either declaration DECL or type TYPE and 0 otherwise.  */
 537
 538 int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree))
 539      = default_valid_lang_attribute;
 540
 541 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
 542    and install them in NODE, which is either a DECL (including a TYPE_DECL)
 543    or a TYPE.  PREFIX_ATTRIBUTES can appear after the declaration specifiers
 544    and declaration modifiers but before the declaration proper.  */
 545
 546 void
 547 decl_attributes (node, attributes, prefix_attributes)
 548      tree node, attributes, prefix_attributes;
 549 {
 550   tree decl = 0, type = 0;
 551   int is_type = 0;
 552   tree a;
 553
 554   if (attrtab_idx == 0)
 555     init_attributes ();
 556
 557   if (DECL_P (node))
 558     {
 559       decl = node;
 560       type = TREE_TYPE (decl);
 561       is_type = TREE_CODE (node) == TYPE_DECL;
 562     }
 563   else if (TYPE_P (node))
 564     type = node, is_type = 1;
 565
 566 #ifdef PRAGMA_INSERT_ATTRIBUTES
 567   /* If the code in c-pragma.c wants to insert some attributes then
 568      allow it to do so.  Do this before allowing machine back ends to
 569      insert attributes, so that they have the opportunity to override
 570      anything done here.  */
 571   PRAGMA_INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 572 #endif
 573
 574 #ifdef INSERT_ATTRIBUTES
 575   INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 576 #endif
 577
 578   attributes = chainon (prefix_attributes, attributes);
 579
 580   for (a = attributes; a; a = TREE_CHAIN (a))
 581     {
 582       tree name = TREE_PURPOSE (a);
 583       tree args = TREE_VALUE (a);
 584       int i;
 585       enum attrs id;
 586
 587       for (i = 0; i < attrtab_idx; i++)
 588         if (attrtab[i].name == name)
 589           break;
 590
 591       if (i == attrtab_idx)
 592         {
 593           if (! valid_machine_attribute (name, args, decl, type)
 594               && ! (* valid_lang_attribute) (name, args, decl, type))
 595             warning ("`%s' attribute directive ignored",
 596                      IDENTIFIER_POINTER (name));
 597           else if (decl != 0)
 598             type = TREE_TYPE (decl);
 599           continue;
 600         }
 601       else if (attrtab[i].decl_req && decl == 0)
 602         {
 603           warning ("`%s' attribute does not apply to types",
 604                    IDENTIFIER_POINTER (name));
 605           continue;
 606         }
 607       else if (list_length (args) < attrtab[i].min
 608                || list_length (args) > attrtab[i].max)
 609         {
 610           error ("wrong number of arguments specified for `%s' attribute",
 611                  IDENTIFIER_POINTER (name));
 612           continue;
 613         }
 614
 615       id = attrtab[i].id;
 616       switch (id)
 617         {
 618         case A_PACKED:
 619           if (is_type)
 620             TYPE_PACKED (type) = 1;
 621           else if (TREE_CODE (decl) == FIELD_DECL)
 622             DECL_PACKED (decl) = 1;
 623           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 624              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 625           else
 626             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 627           break;
 628
 629         case A_NOCOMMON:
 630           if (TREE_CODE (decl) == VAR_DECL)
 631             DECL_COMMON (decl) = 0;
 632           else
 633             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 634           break;
 635
 636         case A_COMMON:
 637           if (TREE_CODE (decl) == VAR_DECL)
 638             DECL_COMMON (decl) = 1;
 639           else
 640             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 641           break;
 642
 643         case A_NORETURN:
 644           if (TREE_CODE (decl) == FUNCTION_DECL)
 645             TREE_THIS_VOLATILE (decl) = 1;
 646           else if (TREE_CODE (type) == POINTER_TYPE
 647                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 648             TREE_TYPE (decl) = type
 649               = build_pointer_type
 650                 (build_type_variant (TREE_TYPE (type),
 651                                      TREE_READONLY (TREE_TYPE (type)), 1));
 652           else
 653             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 654           break;
 655
 656         case A_MALLOC:
 657           if (TREE_CODE (decl) == FUNCTION_DECL)
 658             DECL_IS_MALLOC (decl) = 1;
 659           /* ??? TODO: Support types.  */
 660           else
 661             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 662           break;
 663
 664         case A_UNUSED:
 665           if (is_type)
 666             if (decl)
 667               TREE_USED (decl) = 1;
 668             else
 669               TREE_USED (type) = 1;
 670           else if (TREE_CODE (decl) == PARM_DECL
 671                    || TREE_CODE (decl) == VAR_DECL
 672                    || TREE_CODE (decl) == FUNCTION_DECL
 673                    || TREE_CODE (decl) == LABEL_DECL)
 674             TREE_USED (decl) = 1;
 675           else
 676             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 677           break;
 678
 679         case A_CONST:
 680           if (TREE_CODE (decl) == FUNCTION_DECL)
 681             TREE_READONLY (decl) = 1;
 682           else if (TREE_CODE (type) == POINTER_TYPE
 683                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 684             TREE_TYPE (decl) = type
 685               = build_pointer_type
 686                 (build_type_variant (TREE_TYPE (type), 1,
 687                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 688           else
 689             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 690           break;
 691
 692         case A_PURE:
 693           if (TREE_CODE (decl) == FUNCTION_DECL)
 694             DECL_IS_PURE (decl) = 1;
 695           /* ??? TODO: Support types.  */
 696           else
 697             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 698           break;
 699
 700
 701         case A_T_UNION:
 702           if (is_type
 703               && TREE_CODE (type) == UNION_TYPE
 704               && (decl == 0
 705                   || (TYPE_FIELDS (type) != 0
 706                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 707             TYPE_TRANSPARENT_UNION (type) = 1;
 708           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 709                    && TREE_CODE (type) == UNION_TYPE
 710                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 711             DECL_TRANSPARENT_UNION (decl) = 1;
 712           else
 713             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 714           break;
 715
 716         case A_CONSTRUCTOR:
 717           if (TREE_CODE (decl) == FUNCTION_DECL
 718               && TREE_CODE (type) == FUNCTION_TYPE
 719               && decl_function_context (decl) == 0)
 720             {
 721               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 722               TREE_USED (decl) = 1;
 723             }
 724           else
 725             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 726           break;
 727
 728         case A_DESTRUCTOR:
 729           if (TREE_CODE (decl) == FUNCTION_DECL
 730               && TREE_CODE (type) == FUNCTION_TYPE
 731               && decl_function_context (decl) == 0)
 732             {
 733               DECL_STATIC_DESTRUCTOR (decl) = 1;
 734               TREE_USED (decl) = 1;
 735             }
 736           else
 737             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 738           break;
 739
 740         case A_MODE:
 741           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 742             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 743           else
 744             {
 745               int j;
 746               const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 747               int len = strlen (p);
 748               enum machine_mode mode = VOIDmode;
 749               tree typefm;
 750
 751               if (len > 4 && p[0] == '_' && p[1] == '_'
 752                   && p[len - 1] == '_' && p[len - 2] == '_')
 753                 {
 754                   char *newp = (char *) alloca (len - 1);
 755
 756                   strcpy (newp, &p[2]);
 757                   newp[len - 4] = '\0';
 758                   p = newp;
 759                 }
 760
 761               /* Give this decl a type with the specified mode.
 762                  First check for the special modes.  */
 763               if (! strcmp (p, "byte"))
 764                 mode = byte_mode;
 765               else if (!strcmp (p, "word"))
 766                 mode = word_mode;
 767               else if (! strcmp (p, "pointer"))
 768                 mode = ptr_mode;
 769               else
 770                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 771                   if (!strcmp (p, GET_MODE_NAME (j)))
 772                     mode = (enum machine_mode) j;
 773
 774               if (mode == VOIDmode)
 775                 error ("unknown machine mode `%s'", p);
 776               else if (0 == (typefm = type_for_mode (mode,
 777                                                      TREE_UNSIGNED (type))))
 778                 error ("no data type for mode `%s'", p);
 779               else
 780                 {
 781                   if (TYPE_PRECISION (typefm) > (TREE_UNSIGNED (type)
 782                                                  ? TYPE_PRECISION(uintmax_type_node)
 783                                                  : TYPE_PRECISION(intmax_type_node))
 784                       && pedantic)
 785                     pedwarn ("type with more precision than %s",
 786                              TREE_UNSIGNED (type) ? "uintmax_t" : "intmax_t");
 787                   TREE_TYPE (decl) = type = typefm;
 788                   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
 789                   layout_decl (decl, 0);
 790                 }
 791             }
 792           break;
 793
 794         case A_SECTION:
 795 #ifdef ASM_OUTPUT_SECTION_NAME
 796           if ((TREE_CODE (decl) == FUNCTION_DECL
 797                || TREE_CODE (decl) == VAR_DECL)
 798               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 799             {
 800               if (TREE_CODE (decl) == VAR_DECL
 801                   && current_function_decl != NULL_TREE
 802                   && ! TREE_STATIC (decl))
 803                 error_with_decl (decl,
 804                   "section attribute cannot be specified for local variables");
 805               /* The decl may have already been given a section attribute from
 806                  a previous declaration.  Ensure they match.  */
 807               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 808                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 809                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 810                 error_with_decl (node,
 811                                  "section of `%s' conflicts with previous declaration");
 812               else
 813                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 814             }
 815           else
 816             error_with_decl (node,
 817                            "section attribute not allowed for `%s'");
 818 #else
 819           error_with_decl (node,
 820                   "section attributes are not supported for this target");
 821 #endif
 822           break;
 823
 824         case A_ALIGNED:
 825           {
 826             tree align_expr
 827               = (args ? TREE_VALUE (args)
 828                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 829             int i;
 830
 831             /* Strip any NOPs of any kind.  */
 832             while (TREE_CODE (align_expr) == NOP_EXPR
 833                    || TREE_CODE (align_expr) == CONVERT_EXPR
 834                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
 835               align_expr = TREE_OPERAND (align_expr, 0);
 836
 837             if (TREE_CODE (align_expr) != INTEGER_CST)
 838               {
 839                 error ("requested alignment is not a constant");
 840                 continue;
 841               }
 842
 843             if ((i = tree_log2 (align_expr)) == -1)
 844               error ("requested alignment is not a power of 2");
 845             else if (i > HOST_BITS_PER_INT - 2)
 846               error ("requested alignment is too large");
 847             else if (is_type)
 848               {
 849                 /* If we have a TYPE_DECL, then copy the type, so that we
 850                    don't accidentally modify a builtin type.  See pushdecl.  */
 851                 if (decl && TREE_TYPE (decl) != error_mark_node
 852                     && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
 853                   {
 854                     tree tt = TREE_TYPE (decl);
 855                     DECL_ORIGINAL_TYPE (decl) = tt;
 856                     tt = build_type_copy (tt);
 857                     TYPE_NAME (tt) = decl;
 858                     TREE_USED (tt) = TREE_USED (decl);
 859                     TREE_TYPE (decl) = tt;
 860                     type = tt;
 861                   }
 862
 863                 TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
 864                 TYPE_USER_ALIGN (type) = 1;
 865               }
 866             else if (TREE_CODE (decl) != VAR_DECL
 867                      && TREE_CODE (decl) != FIELD_DECL)
 868               error_with_decl (decl,
 869                                "alignment may not be specified for `%s'");
 870             else
 871               {
 872                 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
 873                 DECL_USER_ALIGN (decl) = 1;
 874               }
 875           }
 876           break;
 877
 878         case A_FORMAT:
 879           {
 880             tree format_type_id = TREE_VALUE (args);
 881             tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 882             tree first_arg_num_expr
 883               = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 884             unsigned HOST_WIDE_INT format_num, first_arg_num;
 885             enum format_type format_type;
 886             tree argument;
 887             unsigned int arg_num;
 888
 889             if (TREE_CODE (decl) != FUNCTION_DECL)
 890               {
 891                 error_with_decl (decl,
 892                          "argument format specified for non-function `%s'");
 893                 continue;
 894               }
 895
 896             if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
 897               {
 898                 error ("unrecognized format specifier");
 899                 continue;
 900               }
 901             else
 902               {
 903                 const char *p = IDENTIFIER_POINTER (format_type_id);
 904
 905                 if (!strcmp (p, "printf") || !strcmp (p, "__printf__"))
 906                   format_type = printf_format_type;
 907                 else if (!strcmp (p, "scanf") || !strcmp (p, "__scanf__"))
 908                   format_type = scanf_format_type;
 909                 else if (!strcmp (p, "strftime")
 910                          || !strcmp (p, "__strftime__"))
 911                   format_type = strftime_format_type;
 912                 else
 913                   {
 914                     warning ("`%s' is an unrecognized format function type", p);
 915                     continue;
 916                   }
 917               }
 918
 919             /* Strip any conversions from the string index and first arg number
 920                and verify they are constants.  */
 921             while (TREE_CODE (format_num_expr) == NOP_EXPR
 922                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 923                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 924               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 925
 926             while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
 927                    || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
 928                    || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
 929               first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
 930
 931             if (TREE_CODE (format_num_expr) != INTEGER_CST
 932                 || TREE_INT_CST_HIGH (format_num_expr) != 0
 933                 || TREE_CODE (first_arg_num_expr) != INTEGER_CST
 934                 || TREE_INT_CST_HIGH (first_arg_num_expr) != 0)
 935               {
 936                 error ("format string has invalid operand number");
 937                 continue;
 938               }
 939
 940             format_num = TREE_INT_CST_LOW (format_num_expr);
 941             first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
 942             if (first_arg_num != 0 && first_arg_num <= format_num)
 943               {
 944                 error ("format string arg follows the args to be formatted");
 945                 continue;
 946               }
 947
 948             /* If a parameter list is specified, verify that the format_num
 949                argument is actually a string, in case the format attribute
 950                is in error.  */
 951             argument = TYPE_ARG_TYPES (type);
 952             if (argument)
 953               {
 954                 for (arg_num = 1; argument != 0 && arg_num != format_num;
 955                      ++arg_num, argument = TREE_CHAIN (argument))
 956                   ;
 957
 958                 if (! argument
 959                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 960                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 961                       != char_type_node))
 962                   {
 963                     error ("format string arg not a string type");
 964                     continue;
 965                   }
 966
 967                 else if (first_arg_num != 0)
 968                   {
 969                     /* Verify that first_arg_num points to the last arg,
 970                        the ...  */
 971                     while (argument)
 972                       arg_num++, argument = TREE_CHAIN (argument);
 973
 974                     if (arg_num != first_arg_num)
 975                       {
 976                         error ("args to be formatted is not '...'");
 977                         continue;
 978                       }
 979                   }
 980               }
 981
 982             if (format_type == strftime_format_type && first_arg_num != 0)
 983               {
 984                 error ("strftime formats cannot format arguments");
 985                 continue;
 986               }
 987
 988             record_function_format (DECL_NAME (decl),
 989                                     DECL_ASSEMBLER_NAME (decl),
 990                                     format_type, format_num, first_arg_num);
 991             break;
 992           }
 993
 994         case A_FORMAT_ARG:
 995           {
 996             tree format_num_expr = TREE_VALUE (args);
 997             unsigned HOST_WIDE_INT format_num;
 998             unsigned int arg_num;
 999             tree argument;
1000
1001             if (TREE_CODE (decl) != FUNCTION_DECL)
1002               {
1003                 error_with_decl (decl,
1004                          "argument format specified for non-function `%s'");
1005                 continue;
1006               }
1007
1008             /* Strip any conversions from the first arg number and verify it
1009                is a constant.  */
1010             while (TREE_CODE (format_num_expr) == NOP_EXPR
1011                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
1012                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
1013               format_num_expr = TREE_OPERAND (format_num_expr, 0);
1014
1015             if (TREE_CODE (format_num_expr) != INTEGER_CST
1016                 || TREE_INT_CST_HIGH (format_num_expr) != 0)
1017               {
1018                 error ("format string has invalid operand number");
1019                 continue;
1020               }
1021
1022             format_num = TREE_INT_CST_LOW (format_num_expr);
1023
1024             /* If a parameter list is specified, verify that the format_num
1025                argument is actually a string, in case the format attribute
1026                is in error.  */
1027             argument = TYPE_ARG_TYPES (type);
1028             if (argument)
1029               {
1030                 for (arg_num = 1; argument != 0 && arg_num != format_num;
1031                      ++arg_num, argument = TREE_CHAIN (argument))
1032                   ;
1033
1034                 if (! argument
1035                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
1036                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
1037                       != char_type_node))
1038                   {
1039                     error ("format string arg not a string type");
1040                     continue;
1041                   }
1042               }
1043
1044             if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) != POINTER_TYPE
1045                 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl))))
1046                     != char_type_node))
1047               {
1048                 error ("function does not return string type");
1049                 continue;
1050               }
1051
1052             record_international_format (DECL_NAME (decl),
1053                                          DECL_ASSEMBLER_NAME (decl),
1054                                          format_num);
1055             break;
1056           }
1057
1058         case A_WEAK:
1059           declare_weak (decl);
1060           break;
1061
1062         case A_ALIAS:
1063           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
1064               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
1065             error_with_decl (decl,
1066                              "`%s' defined both normally and as an alias");
1067           else if (decl_function_context (decl) == 0)
1068             {
1069               tree id;
1070
1071               id = TREE_VALUE (args);
1072               if (TREE_CODE (id) != STRING_CST)
1073                 {
1074                   error ("alias arg not a string");
1075                   break;
1076                 }
1077               id = get_identifier (TREE_STRING_POINTER (id));
1078               /* This counts as a use of the object pointed to.  */
1079               TREE_USED (id) = 1;
1080
1081               if (TREE_CODE (decl) == FUNCTION_DECL)
1082                 DECL_INITIAL (decl) = error_mark_node;
1083               else
1084                 DECL_EXTERNAL (decl) = 0;
1085               assemble_alias (decl, id);
1086             }
1087           else
1088             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1089           break;
1090
1091         case A_NO_CHECK_MEMORY_USAGE:
1092           if (TREE_CODE (decl) != FUNCTION_DECL)
1093             {
1094               error_with_decl (decl,
1095                                "`%s' attribute applies only to functions",
1096                                IDENTIFIER_POINTER (name));
1097             }
1098           else if (DECL_INITIAL (decl))
1099             {
1100               error_with_decl (decl,
1101                                "can't set `%s' attribute after definition",
1102                                IDENTIFIER_POINTER (name));
1103             }
1104           else
1105             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1106           break;
1107
1108         case A_NO_INSTRUMENT_FUNCTION:
1109           if (TREE_CODE (decl) != FUNCTION_DECL)
1110             {
1111               error_with_decl (decl,
1112                                "`%s' attribute applies only to functions",
1113                                IDENTIFIER_POINTER (name));
1114             }
1115           else if (DECL_INITIAL (decl))
1116             {
1117               error_with_decl (decl,
1118                                "can't set `%s' attribute after definition",
1119                                IDENTIFIER_POINTER (name));
1120             }
1121           else
1122             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1123           break;
1124
1125         case A_NO_LIMIT_STACK:
1126           if (TREE_CODE (decl) != FUNCTION_DECL)
1127             {
1128               error_with_decl (decl,
1129                                "`%s' attribute applies only to functions",
1130                                IDENTIFIER_POINTER (name));
1131             }
1132           else if (DECL_INITIAL (decl))
1133             {
1134               error_with_decl (decl,
1135                                "can't set `%s' attribute after definition",
1136                                IDENTIFIER_POINTER (name));
1137             }
1138           else
1139             DECL_NO_LIMIT_STACK (decl) = 1;
1140           break;
1141         }
1142     }
1143 }
1144
1145 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1146    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1147
1148    The head of the declspec list is stored in DECLSPECS.
1149    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1150
1151    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1152    the list elements.  We drop the containing TREE_LIST nodes and link the
1153    resulting attributes together the way decl_attributes expects them.  */
1154
1155 void
1156 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1157      tree specs_attrs;
1158      tree *declspecs, *prefix_attributes;
1159 {
1160   tree t, s, a, next, specs, attrs;
1161
1162   /* This can happen after an __extension__ in pedantic mode.  */
1163   if (specs_attrs != NULL_TREE
1164       && TREE_CODE (specs_attrs) == INTEGER_CST)
1165     {
1166       *declspecs = NULL_TREE;
1167       *prefix_attributes = NULL_TREE;
1168       return;
1169     }
1170
1171   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1172   if (specs_attrs != NULL_TREE
1173       && TREE_CODE (specs_attrs) != TREE_LIST)
1174     {
1175       *declspecs = specs_attrs;
1176       *prefix_attributes = NULL_TREE;
1177       return;
1178     }
1179
1180   /* Remember to keep the lists in the same order, element-wise.  */
1181
1182   specs = s = NULL_TREE;
1183   attrs = a = NULL_TREE;
1184   for (t = specs_attrs; t; t = next)
1185     {
1186       next = TREE_CHAIN (t);
1187       /* Declspecs have a non-NULL TREE_VALUE.  */
1188       if (TREE_VALUE (t) != NULL_TREE)
1189         {
1190           if (specs == NULL_TREE)
1191             specs = s = t;
1192           else
1193             {
1194               TREE_CHAIN (s) = t;
1195               s = t;
1196             }
1197         }
1198       else
1199         {
1200           if (attrs == NULL_TREE)
1201             attrs = a = TREE_PURPOSE (t);
1202           else
1203             {
1204               TREE_CHAIN (a) = TREE_PURPOSE (t);
1205               a = TREE_PURPOSE (t);
1206             }
1207           /* More attrs can be linked here, move A to the end.  */
1208           while (TREE_CHAIN (a) != NULL_TREE)
1209             a = TREE_CHAIN (a);
1210         }
1211     }
1212
1213   /* Terminate the lists.  */
1214   if (s != NULL_TREE)
1215     TREE_CHAIN (s) = NULL_TREE;
1216   if (a != NULL_TREE)
1217     TREE_CHAIN (a) = NULL_TREE;
1218
1219   /* All done.  */
1220   *declspecs = specs;
1221   *prefix_attributes = attrs;
1222 }
1223
1224 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1225    This function is used by the parser when a rule will accept attributes
1226    in a particular position, but we don't want to support that just yet.
1227
1228    A warning is issued for every ignored attribute.  */
1229
1230 tree
1231 strip_attrs (specs_attrs)
1232      tree specs_attrs;
1233 {
1234   tree specs, attrs;
1235
1236   split_specs_attrs (specs_attrs, &specs, &attrs);
1237
1238   while (attrs)
1239     {
1240       warning ("`%s' attribute ignored",
1241                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1242       attrs = TREE_CHAIN (attrs);
1243     }
1244
1245   return specs;
1246 }
1247 \f
1248 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
1249    a parameter list.  */
1250
1251 /* The meaningfully distinct length modifiers for format checking recognised
1252    by GCC.  */
1253 enum format_lengths
1254 {
1255   FMT_LEN_none,
1256   FMT_LEN_hh,
1257   FMT_LEN_h,
1258   FMT_LEN_l,
1259   FMT_LEN_ll,
1260   FMT_LEN_L,
1261   FMT_LEN_z,
1262   FMT_LEN_t,
1263   FMT_LEN_j,
1264   FMT_LEN_MAX
1265 };
1266
1267
1268 /* The standard versions in which various format features appeared.  */
1269 enum format_std_version
1270 {
1271   STD_C89,
1272   STD_C94,
1273   STD_C99,
1274   STD_EXT
1275 };
1276
1277 /* The C standard version C++ is treated as equivalent to
1278    or inheriting from, for the purpose of format features supported.  */
1279 #define CPLUSPLUS_STD_VER       STD_C89
1280 /* The C standard version we are checking formats against when pedantic.  */
1281 #define C_STD_VER               (c_language == clk_cplusplus              \
1282                                  ? CPLUSPLUS_STD_VER                      \
1283                                  : (flag_isoc99                           \
1284                                     ? STD_C99                             \
1285                                     : (flag_isoc94 ? STD_C94 : STD_C89)))
1286 /* The name to give to the standard version we are warning about when
1287    pedantic.  FEATURE_VER is the version in which the feature warned out
1288    appeared, which is higher than C_STD_VER.  */
1289 #define C_STD_NAME(FEATURE_VER) (c_language == clk_cplusplus    \
1290                                  ? "ISO C++"                    \
1291                                  : ((FEATURE_VER) == STD_EXT    \
1292                                     ? "ISO C"                   \
1293                                     : "ISO C89"))
1294
1295 /* Flags that may apply to a particular kind of format checked by GCC.  */
1296 enum
1297 {
1298   /* This format converts arguments of types determined by the
1299      format string.  */
1300   FMT_FLAG_ARG_CONVERT = 1,
1301   /* The scanf allocation 'a' kludge applies to this format kind.  */
1302   FMT_FLAG_SCANF_A_KLUDGE = 2,
1303   /* A % during parsing a specifier is allowed to be a modified % rather
1304      that indicating the format is broken and we are out-of-sync.  */
1305   FMT_FLAG_FANCY_PERCENT_OK = 4,
1306   /* With $ operand numbers, it is OK to reference the same argument more
1307      than once.  */
1308   FMT_FLAG_DOLLAR_MULTIPLE = 8
1309   /* Not included here: details of whether width or precision may occur
1310      (controlled by width_char and precision_char); details of whether
1311      '*' can be used for these (width_type and precision_type); details
1312      of whether length modifiers can occur (length_char_specs); details
1313      of when $ operand numbers are allowed (always, for the formats
1314      supported, if arguments are converted).  */
1315 };
1316
1317
1318 /* Structure describing a length modifier supported in format checking, and
1319    possibly a doubled version such as "hh".  */
1320 typedef struct
1321 {
1322   /* Name of the single-character length modifier.  */
1323   const char *name;
1324   /* Index into a format_char_info.types array.  */
1325   enum format_lengths index;
1326   /* Standard version this length appears in.  */
1327   enum format_std_version std;
1328   /* Same, if the modifier can be repeated, or NULL if it can't.  */
1329   const char *double_name;
1330   enum format_lengths double_index;
1331   enum format_std_version double_std;
1332 } format_length_info;
1333
1334
1335 /* Structure desribing the combination of a conversion specifier
1336    (or a set of specifiers which act identically) and a length modifier.  */
1337 typedef struct
1338 {
1339   /* The standard version this combination of length and type appeared in.
1340      This is only relevant if greater than those for length and type
1341      individually; otherwise it is ignored.  */
1342   enum format_std_version std;
1343   /* The name to use for the type, if different from that generated internally
1344      (e.g., "signed size_t").  */
1345   const char *name;
1346   /* The type itself.  */
1347   tree *type;
1348 } format_type_detail;
1349
1350
1351 /* Macros to fill out tables of these.  */
1352 #define BADLEN  { 0, NULL, NULL }
1353 #define NOLENGTHS       { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
1354
1355
1356 /* Structure desribing a format conversion specifier (or a set of specifiers
1357    which act identically), and the length modifiers used with it.  */
1358 typedef struct
1359 {
1360   const char *format_chars;
1361   int pointer_count;
1362   enum format_std_version std;
1363   /* Types accepted for each length modifier.  */
1364   format_type_detail types[FMT_LEN_MAX];
1365   /* List of other modifier characters allowed with these specifiers.
1366      This lists flags, and additionally "w" for width, "p" for precision,
1367      "a" for scanf "a" allocation extension (not applicable in C99 mode),
1368      "*" for scanf suppression, and "E" and "O" for those strftime
1369      modifiers.  */
1370   const char *flag_chars;
1371   /* List of additional flags describing these conversion specifiers.
1372      "c" for generic character pointers being allowed, "2" for strftime
1373      two digit year formats, "3" for strftime formats giving two digit
1374      years in some locales, "4" for "2" which becomes "3" with an "E" modifier,
1375      "o" if use of strftime "O" is a GNU extension beyond C99,
1376      "W" if the argument is a pointer which is dereferenced and written into,
1377      "i" for printf integer formats where the '0' flag is ignored with
1378      precision, and "[" for the starting character of a scanf scanset.  */
1379   const char *flags2;
1380 } format_char_info;
1381
1382
1383 /* Structure describing a flag accepted by some kind of format.  */
1384 typedef struct
1385 {
1386   /* The flag character in question (0 for end of array).  */
1387   int flag_char;
1388   /* Zero if this entry describes the flag character in general, or a
1389      non-zero character that may be found in flags2 if it describes the
1390      flag when used with certain formats only.  If the latter, only
1391      the first such entry found that applies to the current conversion
1392      specifier is used; the values of `name' and `long_name' it supplies
1393      will be used, if non-NULL and the standard version is higher than
1394      the unpredicated one, for any pedantic warning.  For example, 'o'
1395      for strftime formats (meaning 'O' is an extension over C99).  */
1396   int predicate;
1397   /* The name to use for this flag in diagnostic messages.  For example,
1398      N_("`0' flag"), N_("field width").  */
1399   const char *name;
1400   /* Long name for this flag in diagnostic messages; currently only used for
1401      "ISO C does not support ...".  For example, N_("the `I' printf flag").  */
1402   const char *long_name;
1403   /* The standard version in which it appeared.  */
1404   enum format_std_version std;
1405 } format_flag_spec;
1406
1407
1408 /* Structure describing a combination of flags that is bad for some kind
1409    of format.  */
1410 typedef struct
1411 {
1412   /* The first flag character in question (0 for end of array).  */
1413   int flag_char1;
1414   /* The second flag character.  */
1415   int flag_char2;
1416   /* Non-zero if the message should say that the first flag is ignored with
1417      the second, zero if the combination should simply be objected to.  */
1418   int ignored;
1419   /* Zero if this entry applies whenever this flag combination occurs,
1420      a non-zero character from flags2 if it only applies in some
1421      circumstances (e.g. 'i' for printf formats ignoring 0 with precision).  */
1422   int predicate;
1423 } format_flag_pair;
1424
1425
1426 /* Structure describing a particular kind of format processed by GCC.  */
1427 typedef struct
1428 {
1429   /* The name of this kind of format, for use in diagnostics.  */
1430   const char *name;
1431   /* Specifications of the length modifiers accepted; possibly NULL.  */
1432   const format_length_info *length_char_specs;
1433   /* Details of the conversion specification characters accepted.  */
1434   const format_char_info *conversion_specs;
1435   /* String listing the flag characters that are accepted.  */
1436   const char *flag_chars;
1437   /* String listing modifier characters (strftime) accepted.  May be NULL.  */
1438   const char *modifier_chars;
1439   /* Details of the flag characters, including pseudo-flags.  */
1440   const format_flag_spec *flag_specs;
1441   /* Details of bad combinations of flags.  */
1442   const format_flag_pair *bad_flag_pairs;
1443   /* Flags applicable to this kind of format.  */
1444   int flags;
1445   /* Flag character to treat a width as, or 0 if width not used.  */
1446   int width_char;
1447   /* Flag character to treat a precision as, or 0 if precision not used.  */
1448   int precision_char;
1449   /* If a flag character has the effect of suppressing the conversion of
1450      an argument ('*' in scanf), that flag character, otherwise 0.  */
1451   int suppression_char;
1452   /* Flag character to treat a length modifier as (ignored if length
1453      modifiers not used).  Need not be placed in flag_chars for conversion
1454      specifiers, but is used to check for bad combinations such as length
1455      modifier with assignment suppression in scanf.  */
1456   int length_code_char;
1457   /* Pointer to type of argument expected if '*' is used for a width,
1458      or NULL if '*' not used for widths.  */
1459   tree *width_type;
1460   /* Pointer to type of argument expected if '*' is used for a precision,
1461      or NULL if '*' not used for precisions.  */
1462   tree *precision_type;
1463 } format_kind_info;
1464
1465
1466 /* Structure describing details of a type expected in format checking,
1467    and the type to check against it.  */
1468 typedef struct format_wanted_type
1469 {
1470   /* The type wanted.  */
1471   tree wanted_type;
1472   /* The name of this type to use in diagnostics.  */
1473   const char *wanted_type_name;
1474   /* The level of indirection through pointers at which this type occurs.  */
1475   int pointer_count;
1476   /* Whether, when pointer_count is 1, to allow any character type when
1477      pedantic, rather than just the character or void type specified.  */
1478   int char_lenient_flag;
1479   /* Whether the argument, dereferenced once, is written into and so the
1480      argument must not be a pointer to a const-qualified type.  */
1481   int writing_in_flag;
1482   /* If warnings should be of the form "field precision is not type int",
1483      the name to use (in this case "field precision"), otherwise NULL,
1484      for "%s format, %s arg" type messages.  If (in an extension), this
1485      is a pointer type, wanted_type_name should be set to include the
1486      terminating '*' characters of the type name to give a correct
1487      message.  */
1488   const char *name;
1489   /* The actual parameter to check against the wanted type.  */
1490   tree param;
1491   /* The argument number of that parameter.  */
1492   int arg_num;
1493   /* The next type to check for this format conversion, or NULL if none.  */
1494   struct format_wanted_type *next;
1495 } format_wanted_type;
1496
1497
1498 static const format_length_info printf_length_specs[] =
1499 {
1500   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
1501   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C99 },
1502   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
1503   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
1504   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
1505   { "Z", FMT_LEN_z, STD_EXT, NULL, 0, 0 },
1506   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
1507   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
1508   { NULL, 0, 0, NULL, 0, 0 }
1509 };
1510
1511
1512 /* This differs from printf_length_specs only in that "Z" is not accepted.  */
1513 static const format_length_info scanf_length_specs[] =
1514 {
1515   { "h", FMT_LEN_h, STD_C89, "hh", FMT_LEN_hh, STD_C99 },
1516   { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C99 },
1517   { "q", FMT_LEN_ll, STD_EXT, NULL, 0, 0 },
1518   { "L", FMT_LEN_L, STD_C89, NULL, 0, 0 },
1519   { "z", FMT_LEN_z, STD_C99, NULL, 0, 0 },
1520   { "t", FMT_LEN_t, STD_C99, NULL, 0, 0 },
1521   { "j", FMT_LEN_j, STD_C99, NULL, 0, 0 },
1522   { NULL, 0, 0, NULL, 0, 0 }
1523 };
1524
1525
1526 static const format_flag_spec printf_flag_specs[] =
1527 {
1528   { ' ',  0, N_("` ' flag"),        N_("the ` ' printf flag"),              STD_C89 },
1529   { '+',  0, N_("`+' flag"),        N_("the `+' printf flag"),              STD_C89 },
1530   { '#',  0, N_("`#' flag"),        N_("the `#' printf flag"),              STD_C89 },
1531   { '0',  0, N_("`0' flag"),        N_("the `0' printf flag"),              STD_C89 },
1532   { '-',  0, N_("`-' flag"),        N_("the `-' printf flag"),              STD_C89 },
1533   { '\'', 0, N_("`'' flag"),        N_("the `'' printf flag"),              STD_EXT },
1534   { 'I',  0, N_("`I' flag"),        N_("the `I' printf flag"),              STD_EXT },
1535   { 'w',  0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
1536   { 'p',  0, N_("precision"),       N_("precision in printf format"),       STD_C89 },
1537   { 'L',  0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
1538   { 0, 0, NULL, NULL, 0 }
1539 };
1540
1541
1542 static const format_flag_pair printf_flag_pairs[] =
1543 {
1544   { ' ', '+', 1, 0   },
1545   { '0', '-', 1, 0   },
1546   { '0', 'p', 1, 'i' },
1547   { 0, 0, 0, 0 }
1548 };
1549
1550
1551 static const format_flag_spec scanf_flag_specs[] =
1552 {
1553   { '*',  0, N_("assignment suppression"), N_("assignment suppression"),          STD_C89 },
1554   { 'a',  0, N_("`a' flag"),               N_("the `a' scanf flag"),              STD_EXT },
1555   { 'w',  0, N_("field width"),            N_("field width in scanf format"),     STD_C89 },
1556   { 'L',  0, N_("length modifier"),        N_("length modifier in scanf format"), STD_C89 },
1557   { '\'', 0, N_("`'' flag"),               N_("the `'' scanf flag"),              STD_EXT },
1558   { 'I',  0, N_("`I' flag"),               N_("the `I' scanf flag"),              STD_EXT },
1559   { 0, 0, NULL, NULL, 0 }
1560 };
1561
1562
1563 static const format_flag_pair scanf_flag_pairs[] =
1564 {
1565   { '*', 'L', 0, 0 },
1566   { 0, 0, 0, 0 }
1567 };
1568
1569
1570 static const format_flag_spec strftime_flag_specs[] =
1571 {
1572   { '_', 0,   N_("`_' flag"),     N_("the `_' strftime flag"),          STD_EXT },
1573   { '-', 0,   N_("`-' flag"),     N_("the `-' strftime flag"),          STD_EXT },
1574   { '0', 0,   N_("`0' flag"),     N_("the `0' strftime flag"),          STD_EXT },
1575   { '^', 0,   N_("`^' flag"),     N_("the `^' strftime flag"),          STD_EXT },
1576   { '#', 0,   N_("`#' flag"),     N_("the `#' strftime flag"),          STD_EXT },
1577   { 'w', 0,   N_("field width"),  N_("field width in strftime format"), STD_EXT },
1578   { 'E', 0,   N_("`E' modifier"), N_("the `E' strftime modifier"),      STD_C99 },
1579   { 'O', 0,   N_("`O' modifier"), N_("the `O' strftime modifier"),      STD_C99 },
1580   { 'O', 'o', NULL,               N_("the `O' modifier"),               STD_EXT },
1581   { 0, 0, NULL, NULL, 0 }
1582 };
1583
1584
1585 static const format_flag_pair strftime_flag_pairs[] =
1586 {
1587   { 'E', 'O', 0, 0 },
1588   { '_', '-', 0, 0 },
1589   { '_', '0', 0, 0 },
1590   { '-', '0', 0, 0 },
1591   { '^', '#', 0, 0 },
1592   { 0, 0, 0, 0 }
1593 };
1594
1595
1596 #define T_I     &integer_type_node
1597 #define T89_I   { STD_C89, NULL, T_I }
1598 #define T99_I   { STD_C99, NULL, T_I }
1599 #define T_L     &long_integer_type_node
1600 #define T89_L   { STD_C89, NULL, T_L }
1601 #define T_LL    &long_long_integer_type_node
1602 #define T99_LL  { STD_C99, NULL, T_LL }
1603 #define TEX_LL  { STD_EXT, NULL, T_LL }
1604 #define T_S     &short_integer_type_node
1605 #define T89_S   { STD_C89, NULL, T_S }
1606 #define T_UI    &unsigned_type_node
1607 #define T89_UI  { STD_C89, NULL, T_UI }
1608 #define T99_UI  { STD_C99, NULL, T_UI }
1609 #define T_UL    &long_unsigned_type_node
1610 #define T89_UL  { STD_C89, NULL, T_UL }
1611 #define T_ULL   &long_long_unsigned_type_node
1612 #define T99_ULL { STD_C99, NULL, T_ULL }
1613 #define TEX_ULL { STD_EXT, NULL, T_ULL }
1614 #define T_US    &short_unsigned_type_node
1615 #define T89_US  { STD_C89, NULL, T_US }
1616 #define T_F     &float_type_node
1617 #define T89_F   { STD_C89, NULL, T_F }
1618 #define T99_F   { STD_C99, NULL, T_F }
1619 #define T_D     &double_type_node
1620 #define T89_D   { STD_C89, NULL, T_D }
1621 #define T99_D   { STD_C99, NULL, T_D }
1622 #define T_LD    &long_double_type_node
1623 #define T89_LD  { STD_C89, NULL, T_LD }
1624 #define T99_LD  { STD_C99, NULL, T_LD }
1625 #define T_C     &char_type_node
1626 #define T89_C   { STD_C89, NULL, T_C }
1627 #define T_SC    &signed_char_type_node
1628 #define T99_SC  { STD_C99, NULL, T_SC }
1629 #define T_UC    &unsigned_char_type_node
1630 #define T99_UC  { STD_C99, NULL, T_UC }
1631 #define T_V     &void_type_node
1632 #define T89_V   { STD_C89, NULL, T_V }
1633 #define T_W     &wchar_type_node
1634 #define T94_W   { STD_C94, "wchar_t", T_W }
1635 #define TEX_W   { STD_EXT, "wchar_t", T_W }
1636 #define T_WI    &wint_type_node
1637 #define T94_WI  { STD_C94, "wint_t", T_WI }
1638 #define TEX_WI  { STD_EXT, "wint_t", T_WI }
1639 #define T_ST    &c_size_type_node
1640 #define T99_ST  { STD_C99, "size_t", T_ST }
1641 #define T_SST   &signed_size_type_node
1642 #define T99_SST { STD_C99, "signed size_t", T_SST }
1643 #define T_PD    &ptrdiff_type_node
1644 #define T99_PD  { STD_C99, "ptrdiff_t", T_PD }
1645 #define T_UPD   &unsigned_ptrdiff_type_node
1646 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
1647 #define T_IM    &intmax_type_node
1648 #define T99_IM  { STD_C99, "intmax_t", T_IM }
1649 #define T_UIM   &uintmax_type_node
1650 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
1651
1652 static const format_char_info print_char_table[] =
1653 {
1654   /* C89 conversion specifiers.  */
1655   { "di",  0, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T99_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM  }, "-wp0 +'I", "i" },
1656   { "oxX", 0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T99_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "-wp0#",    "i" },
1657   { "u",   0, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T99_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "-wp0'I",   "i" },
1658   { "fgG", 0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'", ""  },
1659   { "eE",  0, STD_C89, { T89_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#",  ""  },
1660   { "c",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T94_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       ""  },
1661   { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",      "c" },
1662   { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       "c" },
1663   { "n",   1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T99_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",         "W" },
1664   /* C99 conversion specifiers.  */
1665   { "F",   0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#'", ""  },
1666   { "aA",  0, STD_C99, { T99_D,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "-wp0 +#",  ""  },
1667   /* X/Open conversion specifiers.  */
1668   { "C",   0, STD_EXT, { TEX_WI,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-w",       ""  },
1669   { "S",   1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",      ""  },
1670   /* GNU conversion specifiers.  */
1671   { "m",   0, STD_EXT, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "-wp",      ""  },
1672   { NULL,  0, 0, NOLENGTHS, NULL, NULL }
1673 };
1674
1675 static const format_char_info scan_char_table[] =
1676 {
1677   /* C89 conversion specifiers.  */
1678   { "di",    1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T99_LL,  TEX_LL,  T99_SST, T99_PD,  T99_IM  }, "*w'I", "W"   },
1679   { "u",     1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T99_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "*w'I", "W"   },
1680   { "oxX",   1, STD_C89, { T89_UI,  T99_UC,  T89_US,  T89_UL,  T99_ULL, TEX_ULL, T99_ST,  T99_UPD, T99_UIM }, "*w",   "W"   },
1681   { "efgEG", 1, STD_C89, { T89_F,   BADLEN,  BADLEN,  T89_D,   BADLEN,  T89_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W"   },
1682   { "c",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "cW"  },
1683   { "s",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW"  },
1684   { "[",     1, STD_C89, { T89_C,   BADLEN,  BADLEN,  T94_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "cW[" },
1685   { "p",     2, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W"   },
1686   { "n",     1, STD_C89, { T89_I,   T99_SC,  T89_S,   T89_L,   T99_LL,  BADLEN,  T99_SST, T99_PD,  T99_IM  }, "",     "W"   },
1687   /* C99 conversion specifiers.  */
1688   { "FaA",   1, STD_C99, { T99_F,   BADLEN,  BADLEN,  T99_D,   BADLEN,  T99_LD,  BADLEN,  BADLEN,  BADLEN  }, "*w'",  "W"   },
1689   /* X/Open conversion specifiers.  */
1690   { "C",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*w",   "W"   },
1691   { "S",     1, STD_EXT, { TEX_W,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "*aw",  "W"   },
1692   { NULL, 0, 0, NOLENGTHS, NULL, NULL }
1693 };
1694
1695 static format_char_info time_char_table[] =
1696 {
1697   /* C89 conversion specifiers.  */
1698   { "ABZab",            0, STD_C89, NOLENGTHS, "^#",     ""   },
1699   { "cx",               0, STD_C89, NOLENGTHS, "E",      "3"  },
1700   { "HIMSUWdmw",        0, STD_C89, NOLENGTHS, "-_0Ow",  ""   },
1701   { "j",                0, STD_C89, NOLENGTHS, "-_0Ow",  "o"  },
1702   { "p",                0, STD_C89, NOLENGTHS, "#",      ""   },
1703   { "X",                0, STD_C89, NOLENGTHS, "E",      ""   },
1704   { "y",                0, STD_C89, NOLENGTHS, "EO-_0w", "4"  },
1705   { "Y",                0, STD_C89, NOLENGTHS, "-_0EOw", "o"  },
1706   { "%",                0, STD_C89, NOLENGTHS, "",       ""   },
1707   /* C99 conversion specifiers.  */
1708   { "C",                0, STD_C99, NOLENGTHS, "-_0EOw", "o"  },
1709   { "D",                0, STD_C99, NOLENGTHS, "",       "2"  },
1710   { "eVu",              0, STD_C99, NOLENGTHS, "-_0Ow",  ""   },
1711   { "FRTnrt",           0, STD_C99, NOLENGTHS, "",       ""   },
1712   { "g",                0, STD_C99, NOLENGTHS, "O-_0w",  "2o" },
1713   { "G",                0, STD_C99, NOLENGTHS, "-_0Ow",  "o"  },
1714   { "h",                0, STD_C99, NOLENGTHS, "^#",     ""   },
1715   { "z",                0, STD_C99, NOLENGTHS, "O",      "o"  },
1716   /* GNU conversion specifiers.  */
1717   { "kls",              0, STD_EXT, NOLENGTHS, "-_0Ow",  ""   },
1718   { "P",                0, STD_EXT, NOLENGTHS, "",       ""   },
1719   { NULL,               0, 0, NOLENGTHS, NULL, NULL }
1720 };
1721
1722
1723 /* This must be in the same order as enum format_type.  */
1724 static const format_kind_info format_types[] =
1725 {
1726   { "printf",   printf_length_specs, print_char_table, " +#0-'I", NULL,
1727     printf_flag_specs, printf_flag_pairs,
1728     FMT_FLAG_ARG_CONVERT|FMT_FLAG_DOLLAR_MULTIPLE, 'w', 'p', 0, 'L',
1729     &integer_type_node, &integer_type_node
1730   },
1731   { "scanf",    scanf_length_specs,  scan_char_table,  "*'I", NULL,
1732     scanf_flag_specs, scanf_flag_pairs,
1733     FMT_FLAG_ARG_CONVERT|FMT_FLAG_SCANF_A_KLUDGE, 'w', 0, '*', 'L',
1734     NULL, NULL
1735   },
1736   { "strftime", NULL,                time_char_table,  "_-0^#", "EO",
1737     strftime_flag_specs, strftime_flag_pairs,
1738     FMT_FLAG_FANCY_PERCENT_OK, 'w', 0, 0, 0,
1739     NULL, NULL
1740   }
1741 };
1742
1743
1744 typedef struct function_format_info
1745 {
1746   struct function_format_info *next;  /* next structure on the list */
1747   tree name;                    /* identifier such as "printf" */
1748   tree assembler_name;          /* optional mangled identifier (for C++) */
1749   enum format_type format_type; /* type of format (printf, scanf, etc.) */
1750   int format_num;               /* number of format argument */
1751   int first_arg_num;            /* number of first arg (zero for varargs) */
1752 } function_format_info;
1753
1754 static function_format_info *function_format_list = NULL;
1755
1756 typedef struct international_format_info
1757 {
1758   struct international_format_info *next;  /* next structure on the list */
1759   tree name;                    /* identifier such as "gettext" */
1760   tree assembler_name;          /* optional mangled identifier (for C++) */
1761   int format_num;               /* number of format argument */
1762 } international_format_info;
1763
1764 static international_format_info *international_format_list = NULL;
1765
1766 /* Structure detailing the results of checking a format function call
1767    where the format expression may be a conditional expression with
1768    many leaves resulting from nested conditional expressions.  */
1769 typedef struct
1770 {
1771   /* Number of leaves of the format argument that could not be checked
1772      as they were not string literals.  */
1773   int number_non_literal;
1774   /* Number of leaves of the format argument that were null pointers or
1775      string literals, but had extra format arguments.  */
1776   int number_extra_args;
1777   /* Number of leaves of the format argument that were null pointers or
1778      string literals, but had extra format arguments and used $ operand
1779      numbers.  */
1780   int number_dollar_extra_args;
1781   /* Number of leaves of the format argument that were wide string
1782      literals.  */
1783   int number_wide;
1784   /* Number of leaves of the format argument that were empty strings.  */
1785   int number_empty;
1786   /* Number of leaves of the format argument that were unterminated
1787      strings.  */
1788   int number_unterminated;
1789   /* Number of leaves of the format argument that were not counted above.  */
1790   int number_other;
1791 } format_check_results;
1792
1793 static void check_format_info   PARAMS ((int *, function_format_info *, tree));
1794 static void check_format_info_recurse PARAMS ((int *, format_check_results *,
1795                                                function_format_info *, tree,
1796                                                tree, int));
1797 static void check_format_info_main PARAMS ((int *, format_check_results *,
1798                                             function_format_info *,
1799                                             const char *, int, tree, int));
1800 static void status_warning PARAMS ((int *, const char *, ...))
1801      ATTRIBUTE_PRINTF_2;
1802
1803 static void init_dollar_format_checking         PARAMS ((int, tree));
1804 static int maybe_read_dollar_number             PARAMS ((int *, const char **, int,
1805                                                          tree, tree *,
1806                                                          const format_kind_info *));
1807 static void finish_dollar_format_checking       PARAMS ((int *, format_check_results *));
1808
1809 static const format_flag_spec *get_flag_spec    PARAMS ((const format_flag_spec *,
1810                                                          int, const char *));
1811
1812 static void check_format_types  PARAMS ((int *, format_wanted_type *));
1813 static int is_valid_printf_arglist PARAMS ((tree));
1814 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
1815 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
1816                                             enum expand_modifier, int));
1817
1818 /* Initialize the table of functions to perform format checking on.
1819    The ISO C functions are always checked (whether <stdio.h> is
1820    included or not), since it is common to call printf without
1821    including <stdio.h>.  There shouldn't be a problem with this,
1822    since ISO C reserves these function names whether you include the
1823    header file or not.  In any case, the checking is harmless.  With
1824    -ffreestanding, these default attributes are disabled, and must be
1825    specified manually if desired.
1826
1827    Also initialize the name of function that modify the format string for
1828    internationalization purposes.  */
1829
1830 void
1831 init_function_format_info ()
1832 {
1833   if (flag_hosted)
1834     {
1835       /* Functions from ISO/IEC 9899:1990.  */
1836       record_function_format (get_identifier ("printf"), NULL_TREE,
1837                               printf_format_type, 1, 2);
1838       record_function_format (get_identifier ("__builtin_printf"), NULL_TREE,
1839                               printf_format_type, 1, 2);
1840       record_function_format (get_identifier ("fprintf"), NULL_TREE,
1841                               printf_format_type, 2, 3);
1842       record_function_format (get_identifier ("sprintf"), NULL_TREE,
1843                               printf_format_type, 2, 3);
1844       record_function_format (get_identifier ("scanf"), NULL_TREE,
1845                               scanf_format_type, 1, 2);
1846       record_function_format (get_identifier ("fscanf"), NULL_TREE,
1847                               scanf_format_type, 2, 3);
1848       record_function_format (get_identifier ("sscanf"), NULL_TREE,
1849                               scanf_format_type, 2, 3);
1850       record_function_format (get_identifier ("vprintf"), NULL_TREE,
1851                               printf_format_type, 1, 0);
1852       record_function_format (get_identifier ("vfprintf"), NULL_TREE,
1853                               printf_format_type, 2, 0);
1854       record_function_format (get_identifier ("vsprintf"), NULL_TREE,
1855                               printf_format_type, 2, 0);
1856       record_function_format (get_identifier ("strftime"), NULL_TREE,
1857                               strftime_format_type, 3, 0);
1858     }
1859
1860   if (flag_hosted && flag_isoc99)
1861     {
1862       /* ISO C99 adds the snprintf and vscanf family functions.  */
1863       record_function_format (get_identifier ("snprintf"), NULL_TREE,
1864                               printf_format_type, 3, 4);
1865       record_function_format (get_identifier ("vsnprintf"), NULL_TREE,
1866                               printf_format_type, 3, 0);
1867       record_function_format (get_identifier ("vscanf"), NULL_TREE,
1868                               scanf_format_type, 1, 0);
1869       record_function_format (get_identifier ("vfscanf"), NULL_TREE,
1870                               scanf_format_type, 2, 0);
1871       record_function_format (get_identifier ("vsscanf"), NULL_TREE,
1872                               scanf_format_type, 2, 0);
1873     }
1874
1875   if (flag_hosted && flag_noniso_default_format_attributes)
1876     {
1877       /* Uniforum/GNU gettext functions, not in ISO C.  */
1878       record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1879       record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1880       record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1881     }
1882 }
1883
1884 /* Record information for argument format checking.  FUNCTION_IDENT is
1885    the identifier node for the name of the function to check (its decl
1886    need not exist yet).
1887    FORMAT_TYPE specifies the type of format checking.  FORMAT_NUM is the number
1888    of the argument which is the format control string (starting from 1).
1889    FIRST_ARG_NUM is the number of the first actual argument to check
1890    against the format string, or zero if no checking is not be done
1891    (e.g. for varargs such as vfprintf).  */
1892
1893 static void
1894 record_function_format (name, assembler_name, format_type,
1895                         format_num, first_arg_num)
1896       tree name;
1897       tree assembler_name;
1898       enum format_type format_type;
1899       int format_num;
1900       int first_arg_num;
1901 {
1902   function_format_info *info;
1903
1904   /* Re-use existing structure if it's there.  */
1905
1906   for (info = function_format_list; info; info = info->next)
1907     {
1908       if (info->name == name && info->assembler_name == assembler_name)
1909         break;
1910     }
1911   if (! info)
1912     {
1913       info = (function_format_info *) xmalloc (sizeof (function_format_info));
1914       info->next = function_format_list;
1915       function_format_list = info;
1916
1917       info->name = name;
1918       info->assembler_name = assembler_name;
1919     }
1920
1921   info->format_type = format_type;
1922   info->format_num = format_num;
1923   info->first_arg_num = first_arg_num;
1924 }
1925
1926 /* Record information for the names of function that modify the format
1927    argument to format functions.  FUNCTION_IDENT is the identifier node for
1928    the name of the function (its decl need not exist yet) and FORMAT_NUM is
1929    the number of the argument which is the format control string (starting
1930    from 1).  */
1931
1932 static void
1933 record_international_format (name, assembler_name, format_num)
1934       tree name;
1935       tree assembler_name;
1936       int format_num;
1937 {
1938   international_format_info *info;
1939
1940   /* Re-use existing structure if it's there.  */
1941
1942   for (info = international_format_list; info; info = info->next)
1943     {
1944       if (info->name == name && info->assembler_name == assembler_name)
1945         break;
1946     }
1947
1948   if (! info)
1949     {
1950       info
1951         = (international_format_info *)
1952           xmalloc (sizeof (international_format_info));
1953       info->next = international_format_list;
1954       international_format_list = info;
1955
1956       info->name = name;
1957       info->assembler_name = assembler_name;
1958     }
1959
1960   info->format_num = format_num;
1961 }
1962 \f
1963 /* Check the argument list of a call to printf, scanf, etc.
1964    NAME is the function identifier.
1965    ASSEMBLER_NAME is the function's assembler identifier.
1966    (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1967    PARAMS is the list of argument values.  Also, if -Wmissing-format-attribute,
1968    warn for calls to vprintf or vscanf in functions with no such format
1969    attribute themselves.  */
1970
1971 void
1972 check_function_format (status, name, assembler_name, params)
1973      int *status;
1974      tree name;
1975      tree assembler_name;
1976      tree params;
1977 {
1978   function_format_info *info;
1979
1980   /* See if this function is a format function.  */
1981   for (info = function_format_list; info; info = info->next)
1982     {
1983       if (info->assembler_name
1984           ? (info->assembler_name == assembler_name)
1985           : (info->name == name))
1986         {
1987           /* Yup; check it.  */
1988           check_format_info (status, info, params);
1989           if (warn_missing_format_attribute && info->first_arg_num == 0
1990               && (format_types[info->format_type].flags & FMT_FLAG_ARG_CONVERT))
1991             {
1992               function_format_info *info2;
1993               for (info2 = function_format_list; info2; info2 = info2->next)
1994                 if ((info2->assembler_name
1995                      ? (info2->assembler_name == DECL_ASSEMBLER_NAME (current_function_decl))
1996                      : (info2->name == DECL_NAME (current_function_decl)))
1997                     && info2->format_type == info->format_type)
1998                   break;
1999               if (info2 == NULL)
2000                 warning ("function might be possible candidate for `%s' format attribute",
2001                          format_types[info->format_type].name);
2002             }
2003           break;
2004         }
2005     }
2006 }
2007
2008 /* This function replaces `warning' inside the printf format checking
2009    functions.  If the `status' parameter is non-NULL, then it is
2010    dereferenced and set to 1 whenever a warning is caught.  Otherwise
2011    it warns as usual by replicating the innards of the warning
2012    function from diagnostic.c.  */
2013 static void
2014 status_warning VPARAMS ((int *status, const char *msgid, ...))
2015 {
2016 #ifndef ANSI_PROTOTYPES
2017   int *status;
2018   const char *msgid;
2019 #endif
2020   va_list ap;
2021   diagnostic_context dc;
2022
2023   if (status)
2024     *status = 1;
2025   else
2026     {
2027       VA_START (ap, msgid);
2028
2029 #ifndef ANSI_PROTOTYPES
2030       status = va_arg (ap, int *);
2031       msgid = va_arg (ap, const char *);
2032 #endif
2033
2034       /* This duplicates the warning function behavior.  */
2035       set_diagnostic_context
2036         (&dc, msgid, &ap, input_filename, lineno, /* warn = */ 1);
2037       report_diagnostic (&dc);
2038
2039       va_end (ap);
2040     }
2041 }
2042
2043 /* Variables used by the checking of $ operand number formats.  */
2044 static char *dollar_arguments_used = NULL;
2045 static int dollar_arguments_alloc = 0;
2046 static int dollar_arguments_count;
2047 static int dollar_first_arg_num;
2048 static int dollar_max_arg_used;
2049 static int dollar_format_warned;
2050
2051 /* Initialize the checking for a format string that may contain $
2052    parameter number specifications; we will need to keep track of whether
2053    each parameter has been used.  FIRST_ARG_NUM is the number of the first
2054    argument that is a parameter to the format, or 0 for a vprintf-style
2055    function; PARAMS is the list of arguments starting at this argument.  */
2056
2057 static void
2058 init_dollar_format_checking (first_arg_num, params)
2059      int first_arg_num;
2060      tree params;
2061 {
2062   dollar_first_arg_num = first_arg_num;
2063   dollar_arguments_count = 0;
2064   dollar_max_arg_used = 0;
2065   dollar_format_warned = 0;
2066   if (first_arg_num > 0)
2067     {
2068       while (params)
2069         {
2070           dollar_arguments_count++;
2071           params = TREE_CHAIN (params);
2072         }
2073     }
2074   if (dollar_arguments_alloc < dollar_arguments_count)
2075     {
2076       if (dollar_arguments_used)
2077         free (dollar_arguments_used);
2078       dollar_arguments_alloc = dollar_arguments_count;
2079       dollar_arguments_used = xmalloc (dollar_arguments_alloc);
2080     }
2081   if (dollar_arguments_alloc)
2082     memset (dollar_arguments_used, 0, dollar_arguments_alloc);
2083 }
2084
2085
2086 /* Look for a decimal number followed by a $ in *FORMAT.  If DOLLAR_NEEDED
2087    is set, it is an error if one is not found; otherwise, it is OK.  If
2088    such a number is found, check whether it is within range and mark that
2089    numbered operand as being used for later checking.  Returns the operand
2090    number if found and within range, zero if no such number was found and
2091    this is OK, or -1 on error.  PARAMS points to the first operand of the
2092    format; PARAM_PTR is made to point to the parameter referred to.  If
2093    a $ format is found, *FORMAT is updated to point just after it.  */
2094
2095 static int
2096 maybe_read_dollar_number (status, format, dollar_needed, params, param_ptr,
2097                           fki)
2098      int *status;
2099      const char **format;
2100      int dollar_needed;
2101      tree params;
2102      tree *param_ptr;
2103      const format_kind_info *fki;
2104 {
2105   int argnum;
2106   int overflow_flag;
2107   const char *fcp = *format;
2108   if (*fcp < '0' || *fcp > '9')
2109     {
2110       if (dollar_needed)
2111         {
2112           status_warning (status, "missing $ operand number in format");
2113           return -1;
2114         }
2115       else
2116         return 0;
2117     }
2118   argnum = 0;
2119   overflow_flag = 0;
2120   while (*fcp >= '0' && *fcp <= '9')
2121     {
2122       int nargnum;
2123       nargnum = 10 * argnum + (*fcp - '0');
2124       if (nargnum < 0 || nargnum / 10 != argnum)
2125         overflow_flag = 1;
2126       argnum = nargnum;
2127       fcp++;
2128     }
2129   if (*fcp != '$')
2130     {
2131       if (dollar_needed)
2132         {
2133           status_warning (status, "missing $ operand number in format");
2134           return -1;
2135         }
2136       else
2137         return 0;
2138     }
2139   *format = fcp + 1;
2140   if (pedantic && !dollar_format_warned)
2141     {
2142       status_warning (status,
2143                       "%s does not support %%n$ operand number formats",
2144                       C_STD_NAME (STD_EXT));
2145       dollar_format_warned = 1;
2146     }
2147   if (overflow_flag || argnum == 0
2148       || (dollar_first_arg_num && argnum > dollar_arguments_count))
2149     {
2150       status_warning (status, "operand number out of range in format");
2151       return -1;
2152     }
2153   if (argnum > dollar_max_arg_used)
2154     dollar_max_arg_used = argnum;
2155   /* For vprintf-style functions we may need to allocate more memory to
2156      track which arguments are used.  */
2157   while (dollar_arguments_alloc < dollar_max_arg_used)
2158     {
2159       int nalloc;
2160       nalloc = 2 * dollar_arguments_alloc + 16;
2161       dollar_arguments_used = xrealloc (dollar_arguments_used, nalloc);
2162       memset (dollar_arguments_used + dollar_arguments_alloc, 0,
2163               nalloc - dollar_arguments_alloc);
2164       dollar_arguments_alloc = nalloc;
2165     }
2166   if (!(fki->flags & FMT_FLAG_DOLLAR_MULTIPLE)
2167       && dollar_arguments_used[argnum - 1] == 1)
2168     {
2169       dollar_arguments_used[argnum - 1] = 2;
2170       status_warning (status,
2171                       "format argument %d used more than once in %s format",
2172                       argnum, fki->name);
2173     }
2174   else
2175     dollar_arguments_used[argnum - 1] = 1;
2176   if (dollar_first_arg_num)
2177     {
2178       int i;
2179       *param_ptr = params;
2180       for (i = 1; i < argnum && *param_ptr != 0; i++)
2181         *param_ptr = TREE_CHAIN (*param_ptr);
2182
2183       if (*param_ptr == 0)
2184         {
2185           /* This case shouldn't be caught here.  */
2186           abort ();
2187         }
2188     }
2189   else
2190     *param_ptr = 0;
2191   return argnum;
2192 }
2193
2194
2195 /* Finish the checking for a format string that used $ operand number formats
2196    instead of non-$ formats.  We check for unused operands before used ones
2197    (a serious error, since the implementation of the format function
2198    can't know what types to pass to va_arg to find the later arguments).
2199    and for unused operands at the end of the format (if we know how many
2200    arguments the format had, so not for vprintf).  If there were operand
2201    numbers out of range on a non-vprintf-style format, we won't have reached
2202    here.  */
2203
2204 static void
2205 finish_dollar_format_checking (status, res)
2206      int *status;
2207      format_check_results *res;
2208 {
2209   int i;
2210   for (i = 0; i < dollar_max_arg_used; i++)
2211     {
2212       if (!dollar_arguments_used[i])
2213         status_warning (status, "format argument %d unused before used argument %d in $-style format",
2214                  i + 1, dollar_max_arg_used);
2215     }
2216   if (dollar_first_arg_num && dollar_max_arg_used < dollar_arguments_count)
2217     {
2218       res->number_other--;
2219       res->number_dollar_extra_args++;
2220     }
2221 }
2222
2223
2224 /* Retrieve the specification for a format flag.  SPEC contains the
2225    specifications for format flags for the applicable kind of format.
2226    FLAG is the flag in question.  If PREDICATES is NULL, the basic
2227    spec for that flag must be retrieved and this function aborts if
2228    it cannot be found.  If PREDICATES is not NULL, it is a string listing
2229    possible predicates for the spec entry; if an entry predicated on any
2230    of these is found, it is returned, otherwise NULL is returned.  */
2231
2232 static const format_flag_spec *
2233 get_flag_spec (spec, flag, predicates)
2234      const format_flag_spec *spec;
2235      int flag;
2236      const char *predicates;
2237 {
2238   int i;
2239   for (i = 0; spec[i].flag_char != 0; i++)
2240     {
2241       if (spec[i].flag_char != flag)
2242         continue;
2243       if (predicates != NULL)
2244         {
2245           if (spec[i].predicate != 0
2246               && index (predicates, spec[i].predicate) != 0)
2247             return &spec[i];
2248         }
2249       else if (spec[i].predicate == 0)
2250         return &spec[i];
2251     }
2252   if (predicates == NULL)
2253     abort ();
2254   else
2255     return NULL;
2256 }
2257
2258
2259 /* Check the argument list of a call to printf, scanf, etc.
2260    INFO points to the function_format_info structure.
2261    PARAMS is the list of argument values.  */
2262
2263 static void
2264 check_format_info (status, info, params)
2265      int *status;
2266      function_format_info *info;
2267      tree params;
2268 {
2269   int arg_num;
2270   tree format_tree;
2271   format_check_results res;
2272   /* Skip to format argument.  If the argument isn't available, there's
2273      no work for us to do; prototype checking will catch the problem.  */
2274   for (arg_num = 1; ; ++arg_num)
2275     {
2276       if (params == 0)
2277         return;
2278       if (arg_num == info->format_num)
2279         break;
2280       params = TREE_CHAIN (params);
2281     }
2282   format_tree = TREE_VALUE (params);
2283   params = TREE_CHAIN (params);
2284   if (format_tree == 0)
2285     return;
2286
2287   res.number_non_literal = 0;
2288   res.number_extra_args = 0;
2289   res.number_dollar_extra_args = 0;
2290   res.number_wide = 0;
2291   res.number_empty = 0;
2292   res.number_unterminated = 0;
2293   res.number_other = 0;
2294
2295   check_format_info_recurse (status, &res, info, format_tree, params, arg_num);
2296
2297   if (res.number_non_literal > 0)
2298     {
2299       /* Functions taking a va_list normally pass a non-literal format
2300          string.  These functions typically are declared with
2301          first_arg_num == 0, so avoid warning in those cases.  */
2302       if (info->first_arg_num != 0 && warn_format > 1)
2303         status_warning (status, "format not a string literal, argument types not checked");
2304     }
2305
2306   /* If there were extra arguments to the format, normally warn.  However,
2307      the standard does say extra arguments are ignored, so in the specific
2308      case where we have multiple leaves (conditional expressions or
2309      ngettext) allow extra arguments if at least one leaf didn't have extra
2310      arguments, but was otherwise OK (either non-literal or checked OK).
2311      If the format is an empty string, this should be counted similarly to the
2312      case of extra format arguments.  */
2313   if (res.number_extra_args > 0 && res.number_non_literal == 0
2314       && res.number_other == 0)
2315     status_warning (status, "too many arguments for format");
2316   if (res.number_dollar_extra_args > 0 && res.number_non_literal == 0
2317       && res.number_other == 0)
2318     status_warning (status, "unused arguments in $-style format");
2319   if (res.number_empty > 0 && res.number_non_literal == 0
2320       && res.number_other == 0)
2321     status_warning (status, "zero-length format string");
2322
2323   if (res.number_wide > 0)
2324     status_warning (status, "format is a wide character string");
2325
2326   if (res.number_unterminated > 0)
2327     status_warning (status, "unterminated format string");
2328 }
2329
2330
2331 /* Recursively check a call to a format function.  FORMAT_TREE is the
2332    format parameter, which may be a conditional expression in which
2333    both halves should be checked.  ARG_NUM is the number of the
2334    format argument; PARAMS points just after it in the argument list.  */
2335
2336 static void
2337 check_format_info_recurse (status, res, info, format_tree, params, arg_num)
2338      int *status;
2339      format_check_results *res;
2340      function_format_info *info;
2341      tree format_tree;
2342      tree params;
2343      int arg_num;
2344 {
2345   int format_length;
2346   const char *format_chars;
2347   tree array_size = 0;
2348   tree array_init;
2349
2350   if (TREE_CODE (format_tree) == NOP_EXPR)
2351     {
2352       /* Strip coercion.  */
2353       check_format_info_recurse (status, res, info,
2354                                  TREE_OPERAND (format_tree, 0), params,
2355                                  arg_num);
2356       return;
2357     }
2358
2359   if (TREE_CODE (format_tree) == CALL_EXPR
2360       && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
2361       && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
2362           == FUNCTION_DECL))
2363     {
2364       tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
2365
2366       /* See if this is a call to a known internationalization function
2367          that modifies the format arg.  */
2368       international_format_info *iinfo;
2369
2370       for (iinfo = international_format_list; iinfo; iinfo = iinfo->next)
2371         if (iinfo->assembler_name
2372             ? (iinfo->assembler_name == DECL_ASSEMBLER_NAME (function))
2373             : (iinfo->name == DECL_NAME (function)))
2374           {
2375             tree inner_args;
2376             int i;
2377
2378             for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
2379                  inner_args != 0;
2380                  inner_args = TREE_CHAIN (inner_args), i++)
2381               if (i == iinfo->format_num)
2382                 {
2383                   /* FIXME: with Marc Espie's __attribute__((nonnull))
2384                      patch in GCC, we will have chained attributes,
2385                      and be able to handle functions like ngettext
2386                      with multiple format_arg attributes properly.  */
2387                   check_format_info_recurse (status, res, info,
2388                                              TREE_VALUE (inner_args), params,
2389                                              arg_num);
2390                   return;
2391                 }
2392           }
2393     }
2394
2395   if (TREE_CODE (format_tree) == COND_EXPR)
2396     {
2397       /* Check both halves of the conditional expression.  */
2398       check_format_info_recurse (status, res, info,
2399                                  TREE_OPERAND (format_tree, 1), params,
2400                                  arg_num);
2401       check_format_info_recurse (status, res, info,
2402                                  TREE_OPERAND (format_tree, 2), params,
2403                                  arg_num);
2404       return;
2405     }
2406
2407   if (integer_zerop (format_tree))
2408     {
2409       /* FIXME: this warning should go away once Marc Espie's
2410          __attribute__((nonnull)) patch is in.  Instead, checking for
2411          nonnull attributes should probably change this function to act
2412          specially if info == NULL and add a res->number_null entry for
2413          that case, or maybe add a function pointer to be called at
2414          the end instead of hardcoding check_format_info_main.  */
2415       status_warning (status, "null format string");
2416
2417       /* Skip to first argument to check, so we can see if this format
2418          has any arguments (it shouldn't).  */
2419       while (arg_num + 1 < info->first_arg_num)
2420         {
2421           if (params == 0)
2422             return;
2423           params = TREE_CHAIN (params);
2424           ++arg_num;
2425         }
2426
2427       if (params == 0)
2428         res->number_other++;
2429       else
2430         res->number_extra_args++;
2431
2432       return;
2433     }
2434
2435   if (TREE_CODE (format_tree) != ADDR_EXPR)
2436     {
2437       res->number_non_literal++;
2438       return;
2439     }
2440   format_tree = TREE_OPERAND (format_tree, 0);
2441   if (TREE_CODE (format_tree) == VAR_DECL
2442       && TREE_CODE (TREE_TYPE (format_tree)) == ARRAY_TYPE
2443       && (array_init = decl_constant_value (format_tree)) != format_tree
2444       && TREE_CODE (array_init) == STRING_CST)
2445     {
2446       /* Extract the string constant initializer.  Note that this may include
2447          a trailing NUL character that is not in the array (e.g.
2448          const char a[3] = "foo";).  */
2449       array_size = DECL_SIZE_UNIT (format_tree);
2450       format_tree = array_init;
2451     }
2452   if (TREE_CODE (format_tree) != STRING_CST)
2453     {
2454       res->number_non_literal++;
2455       return;
2456     }
2457   if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree))) != char_type_node)
2458     {
2459       res->number_wide++;
2460       return;
2461     }
2462   format_chars = TREE_STRING_POINTER (format_tree);
2463   format_length = TREE_STRING_LENGTH (format_tree);
2464   if (array_size != 0)
2465     {
2466       /* Variable length arrays can't be initialized.  */
2467       if (TREE_CODE (array_size) != INTEGER_CST)
2468         abort ();
2469       if (host_integerp (array_size, 0))
2470         {
2471           HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
2472           if (array_size_value > 0
2473               && array_size_value == (int) array_size_value
2474               && format_length > array_size_value)
2475             format_length = array_size_value;
2476         }
2477     }
2478   if (format_length < 1)
2479     {
2480       res->number_unterminated++;
2481       return;
2482     }
2483   if (format_length == 1)
2484     {
2485       res->number_empty++;
2486       return;
2487     }
2488   if (format_chars[--format_length] != 0)
2489     {
2490       res->number_unterminated++;
2491       return;
2492     }
2493
2494   /* Skip to first argument to check.  */
2495   while (arg_num + 1 < info->first_arg_num)
2496     {
2497       if (params == 0)
2498         return;
2499       params = TREE_CHAIN (params);
2500       ++arg_num;
2501     }
2502   /* Provisionally increment res->number_other; check_format_info_main
2503      will decrement it if it finds there are extra arguments, but this way
2504      need not adjust it for every return.  */
2505   res->number_other++;
2506   check_format_info_main (status, res, info, format_chars, format_length,
2507                           params, arg_num);
2508 }
2509
2510
2511 /* Do the main part of checking a call to a format function.  FORMAT_CHARS
2512    is the NUL-terminated format string (which at this point may contain
2513    internal NUL characters); FORMAT_LENGTH is its length (excluding the
2514    terminating NUL character).  ARG_NUM is one less than the number of
2515    the first format argument to check; PARAMS points to that format
2516    argument in the list of arguments.  */
2517
2518 static void
2519 check_format_info_main (status, res, info, format_chars, format_length,
2520                         params, arg_num)
2521      int *status;
2522      format_check_results *res;
2523      function_format_info *info;
2524      const char *format_chars;
2525      int format_length;
2526      tree params;
2527      int arg_num;
2528 {
2529   const char *orig_format_chars = format_chars;
2530   tree first_fillin_param = params;
2531
2532   const format_kind_info *fki = &format_types[info->format_type];
2533   const format_flag_spec *flag_specs = fki->flag_specs;
2534   const format_flag_pair *bad_flag_pairs = fki->bad_flag_pairs;
2535
2536   /* -1 if no conversions taking an operand have been found; 0 if one has
2537      and it didn't use $; 1 if $ formats are in use.  */
2538   int has_operand_number = -1;
2539
2540   init_dollar_format_checking (info->first_arg_num, first_fillin_param);
2541
2542   while (1)
2543     {
2544       int i;
2545       int suppressed = FALSE;
2546       const char *length_chars = NULL;
2547       enum format_lengths length_chars_val = FMT_LEN_none;
2548       enum format_std_version length_chars_std = STD_C89;
2549       int format_char;
2550       tree cur_param;
2551       tree wanted_type;
2552       int main_arg_num = 0;
2553       tree main_arg_params = 0;
2554       enum format_std_version wanted_type_std;
2555       const char *wanted_type_name;
2556       format_wanted_type width_wanted_type;
2557       format_wanted_type precision_wanted_type;
2558       format_wanted_type main_wanted_type;
2559       format_wanted_type *first_wanted_type = NULL;
2560       format_wanted_type *last_wanted_type = NULL;
2561       const format_length_info *fli = NULL;
2562       const format_char_info *fci = NULL;
2563       char flag_chars[256];
2564       int aflag = 0;
2565       if (*format_chars == 0)
2566         {
2567           if (format_chars - orig_format_chars != format_length)
2568             status_warning (status, "embedded `\\0' in format");
2569           if (info->first_arg_num != 0 && params != 0
2570               && has_operand_number <= 0)
2571             {
2572               res->number_other--;
2573               res->number_extra_args++;
2574             }
2575           if (has_operand_number > 0)
2576             finish_dollar_format_checking (status, res);
2577           return;
2578         }
2579       if (*format_chars++ != '%')
2580         continue;
2581       if (*format_chars == 0)
2582         {
2583           status_warning (status, "spurious trailing `%%' in format");
2584           continue;
2585         }
2586       if (*format_chars == '%')
2587         {
2588           ++format_chars;
2589           continue;
2590         }
2591       flag_chars[0] = 0;
2592
2593       if ((fki->flags & FMT_FLAG_ARG_CONVERT) && has_operand_number != 0)
2594         {
2595           /* Possibly read a $ operand number at the start of the format.
2596              If one was previously used, one is required here.  If one
2597              is not used here, we can't immediately conclude this is a
2598              format without them, since it could be printf %m or scanf %*.  */
2599           int opnum;
2600           opnum = maybe_read_dollar_number (status, &format_chars, 0,
2601                                             first_fillin_param,
2602                                             &main_arg_params, fki);
2603           if (opnum == -1)
2604             return;
2605           else if (opnum > 0)
2606             {
2607               has_operand_number = 1;
2608               main_arg_num = opnum + info->first_arg_num - 1;
2609             }
2610         }
2611
2612       /* Read any format flags, but do not yet validate them beyond removing
2613          duplicates, since in general validation depends on the rest of
2614          the format.  */
2615       while (*format_chars != 0 && index (fki->flag_chars, *format_chars) != 0)
2616         {
2617           if (index (flag_chars, *format_chars) != 0)
2618             {
2619               const format_flag_spec *s = get_flag_spec (flag_specs,
2620                                                          *format_chars, NULL);
2621               status_warning (status, "repeated %s in format", _(s->name));
2622             }
2623           else
2624             {
2625               i = strlen (flag_chars);
2626               flag_chars[i++] = *format_chars;
2627               flag_chars[i] = 0;
2628             }
2629           ++format_chars;
2630         }
2631
2632       /* Read any format width, possibly * or *m$.  */
2633       if (fki->width_char != 0)
2634         {
2635           if (fki->width_type != NULL && *format_chars == '*')
2636             {
2637               i = strlen (flag_chars);
2638               flag_chars[i++] = fki->width_char;
2639               flag_chars[i] = 0;
2640               /* "...a field width...may be indicated by an asterisk.
2641                  In this case, an int argument supplies the field width..."  */
2642               ++format_chars;
2643               if (params == 0)
2644                 {
2645                   status_warning (status, "too few arguments for format");
2646                   return;
2647                 }
2648               if (has_operand_number != 0)
2649                 {
2650                   int opnum;
2651                   opnum = maybe_read_dollar_number (status, &format_chars,
2652                                                     has_operand_number == 1,
2653                                                     first_fillin_param,
2654                                                     &params, fki);
2655                   if (opnum == -1)
2656                     return;
2657                   else if (opnum > 0)
2658                     {
2659                       has_operand_number = 1;
2660                       arg_num = opnum + info->first_arg_num - 1;
2661                     }
2662                   else
2663                     has_operand_number = 0;
2664                 }
2665               if (info->first_arg_num != 0)
2666                 {
2667                   cur_param = TREE_VALUE (params);
2668                   if (has_operand_number <= 0)
2669                     {
2670                       params = TREE_CHAIN (params);
2671                       ++arg_num;
2672                     }
2673                   width_wanted_type.wanted_type = *fki->width_type;
2674                   width_wanted_type.wanted_type_name = NULL;
2675                   width_wanted_type.pointer_count = 0;
2676                   width_wanted_type.char_lenient_flag = 0;
2677                   width_wanted_type.writing_in_flag = 0;
2678                   width_wanted_type.name = _("field width");
2679                   width_wanted_type.param = cur_param;
2680                   width_wanted_type.arg_num = arg_num;
2681                   width_wanted_type.next = NULL;
2682                   if (last_wanted_type != 0)
2683                     last_wanted_type->next = &width_wanted_type;
2684                   if (first_wanted_type == 0)
2685                     first_wanted_type = &width_wanted_type;
2686                   last_wanted_type = &width_wanted_type;
2687                 }
2688             }
2689           else
2690             {
2691               /* Possibly read a numeric width.  If the width is zero,
2692                  we complain; for scanf this is bad according to the
2693                  standard, and for printf and strftime it cannot occur
2694                  because 0 is a flag.  */
2695               int non_zero_width_char = FALSE;
2696               int found_width = FALSE;
2697               while (ISDIGIT (*format_chars))
2698                 {
2699                   found_width = TRUE;
2700                   if (*format_chars != '0')
2701                     non_zero_width_char = TRUE;
2702                   ++format_chars;
2703                 }
2704               if (found_width && !non_zero_width_char)
2705                 status_warning (status, "zero width in %s format",
2706                                 fki->name);
2707               if (found_width)
2708                 {
2709                   i = strlen (flag_chars);
2710                   flag_chars[i++] = fki->width_char;
2711                   flag_chars[i] = 0;
2712                 }
2713             }
2714         }
2715
2716       /* Read any format precision, possibly * or *m$.  */
2717       if (fki->precision_char != 0 && *format_chars == '.')
2718         {
2719           ++format_chars;
2720           i = strlen (flag_chars);
2721           flag_chars[i++] = fki->precision_char;
2722           flag_chars[i] = 0;
2723           if (fki->precision_type != NULL && *format_chars == '*')
2724             {
2725               /* "...a...precision...may be indicated by an asterisk.
2726                  In this case, an int argument supplies the...precision."  */
2727               ++format_chars;
2728               if (has_operand_number != 0)
2729                 {
2730                   int opnum;
2731                   opnum = maybe_read_dollar_number (status, &format_chars,
2732                                                     has_operand_number == 1,
2733                                                     first_fillin_param,
2734                                                     &params, fki);
2735                   if (opnum == -1)
2736                     return;
2737                   else if (opnum > 0)
2738                     {
2739                       has_operand_number = 1;
2740                       arg_num = opnum + info->first_arg_num - 1;
2741                     }
2742                   else
2743                     has_operand_number = 0;
2744                 }
2745               if (info->first_arg_num != 0)
2746                 {
2747                   if (params == 0)
2748                     {
2749                       status_warning (status, "too few arguments for format");
2750                       return;
2751                     }
2752                   cur_param = TREE_VALUE (params);
2753                   if (has_operand_number <= 0)
2754                     {
2755                       params = TREE_CHAIN (params);
2756                       ++arg_num;
2757                     }
2758                   precision_wanted_type.wanted_type = *fki->precision_type;
2759                   precision_wanted_type.wanted_type_name = NULL;
2760                   precision_wanted_type.pointer_count = 0;
2761                   precision_wanted_type.char_lenient_flag = 0;
2762                   precision_wanted_type.writing_in_flag = 0;
2763                   precision_wanted_type.name = _("field precision");
2764                   precision_wanted_type.param = cur_param;
2765                   precision_wanted_type.arg_num = arg_num;
2766                   precision_wanted_type.next = NULL;
2767                   if (last_wanted_type != 0)
2768                     last_wanted_type->next = &precision_wanted_type;
2769                   if (first_wanted_type == 0)
2770                     first_wanted_type = &precision_wanted_type;
2771                   last_wanted_type = &precision_wanted_type;
2772                 }
2773             }
2774           else
2775             {
2776               while (ISDIGIT (*format_chars))
2777                 ++format_chars;
2778             }
2779         }
2780
2781       /* Read any length modifier, if this kind of format has them.  */
2782       fli = fki->length_char_specs;
2783       length_chars = NULL;
2784       length_chars_val = FMT_LEN_none;
2785       length_chars_std = STD_C89;
2786       if (fli)
2787         {
2788           while (fli->name != 0 && fli->name[0] != *format_chars)
2789             fli++;
2790           if (fli->name != 0)
2791             {
2792               format_chars++;
2793               if (fli->double_name != 0 && fli->name[0] == *format_chars)
2794                 {
2795                   format_chars++;
2796                   length_chars = fli->double_name;
2797                   length_chars_val = fli->double_index;
2798                   length_chars_std = fli->double_std;
2799                 }
2800               else
2801                 {
2802                   length_chars = fli->name;
2803                   length_chars_val = fli->index;
2804                   length_chars_std = fli->std;
2805                 }
2806               i = strlen (flag_chars);
2807               flag_chars[i++] = fki->length_code_char;
2808               flag_chars[i] = 0;
2809             }
2810           if (pedantic)
2811             {
2812               /* Warn if the length modifier is non-standard.  */
2813               if (length_chars_std > C_STD_VER)
2814                 status_warning (status, "%s does not support the `%s' %s length modifier",
2815                                 C_STD_NAME (length_chars_std), length_chars,
2816                                 fki->name);
2817             }
2818         }
2819
2820       /* Read any modifier (strftime E/O).  */
2821       if (fki->modifier_chars != NULL)
2822         {
2823           while (*format_chars != 0
2824                  && index (fki->modifier_chars, *format_chars) != 0)
2825             {
2826               if (index (flag_chars, *format_chars) != 0)
2827                 {
2828                   const format_flag_spec *s = get_flag_spec (flag_specs,
2829                                                              *format_chars, NULL);
2830                   status_warning (status, "repeated %s in format", _(s->name));
2831                 }
2832               else
2833                 {
2834                   i = strlen (flag_chars);
2835                   flag_chars[i++] = *format_chars;
2836                   flag_chars[i] = 0;
2837                 }
2838               ++format_chars;
2839             }
2840         }
2841
2842       /* Handle the scanf allocation kludge.  */
2843       if (fki->flags & FMT_FLAG_SCANF_A_KLUDGE)
2844         {
2845           if (*format_chars == 'a' && !flag_isoc99)
2846             {
2847               if (format_chars[1] == 's' || format_chars[1] == 'S'
2848                   || format_chars[1] == '[')
2849                 {
2850                   /* `a' is used as a flag.  */
2851                   i = strlen (flag_chars);
2852                   flag_chars[i++] = 'a';
2853                   flag_chars[i] = 0;
2854                   format_chars++;
2855                 }
2856             }
2857         }
2858
2859       format_char = *format_chars;
2860       if (format_char == 0
2861           || (!(fki->flags & FMT_FLAG_FANCY_PERCENT_OK) && format_char == '%'))
2862         {
2863           status_warning (status, "conversion lacks type at end of format");
2864           continue;
2865         }
2866       format_chars++;
2867       fci = fki->conversion_specs;
2868       while (fci->format_chars != 0
2869              && index (fci->format_chars, format_char) == 0)
2870           ++fci;
2871       if (fci->format_chars == 0)
2872         {
2873           if (ISGRAPH(format_char))
2874             status_warning (status, "unknown conversion type character `%c' in format",
2875                      format_char);
2876           else
2877             status_warning (status, "unknown conversion type character 0x%x in format",
2878                      format_char);
2879           continue;
2880         }
2881       if (pedantic)
2882         {
2883           if (fci->std > C_STD_VER)
2884             status_warning (status, "%s does not support the `%%%c' %s format",
2885                             C_STD_NAME (fci->std), format_char, fki->name);
2886         }
2887
2888       /* Validate the individual flags used, removing any that are invalid.  */
2889       {
2890         int d = 0;
2891         for (i = 0; flag_chars[i] != 0; i++)
2892           {
2893             const format_flag_spec *s = get_flag_spec (flag_specs,
2894                                                        flag_chars[i], NULL);
2895             flag_chars[i - d] = flag_chars[i];
2896             if (flag_chars[i] == fki->length_code_char)
2897               continue;
2898             if (index (fci->flag_chars, flag_chars[i]) == 0)
2899               {
2900                 status_warning (status, "%s used with `%%%c' %s format",
2901                                 _(s->name), format_char, fki->name);
2902                 d++;
2903                 continue;
2904               }
2905             if (pedantic)
2906               {
2907                 const format_flag_spec *t;
2908                 if (s->std > C_STD_VER)
2909                   status_warning (status, "%s does not support %s",
2910                                   C_STD_NAME (s->std), _(s->long_name));
2911                 t = get_flag_spec (flag_specs, flag_chars[i], fci->flags2);
2912                 if (t != NULL && t->std > s->std)
2913                   {
2914                     const char *long_name = (t->long_name != NULL
2915                                              ? t->long_name
2916                                              : s->long_name);
2917                     if (t->std > C_STD_VER)
2918                       status_warning (status, "%s does not support %s with the `%%%c' %s format",
2919                                       C_STD_NAME (t->std), _(long_name),
2920                                       format_char, fki->name);
2921                   }
2922               }
2923           }
2924         flag_chars[i - d] = 0;
2925       }
2926
2927       if ((fki->flags & FMT_FLAG_SCANF_A_KLUDGE)
2928           && index (flag_chars, 'a') != 0)
2929         aflag = 1;
2930
2931       if (fki->suppression_char
2932           && index (flag_chars, fki->suppression_char) != 0)
2933         suppressed = 1;
2934
2935       /* Validate the pairs of flags used.  */
2936       for (i = 0; bad_flag_pairs[i].flag_char1 != 0; i++)
2937         {
2938           const format_flag_spec *s, *t;
2939           if (index (flag_chars, bad_flag_pairs[i].flag_char1) == 0)
2940             continue;
2941           if (index (flag_chars, bad_flag_pairs[i].flag_char2) == 0)
2942             continue;
2943           if (bad_flag_pairs[i].predicate != 0
2944               && index (fci->flags2, bad_flag_pairs[i].predicate) == 0)
2945             continue;
2946           s = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char1, NULL);
2947           t = get_flag_spec (flag_specs, bad_flag_pairs[i].flag_char2, NULL);
2948           if (bad_flag_pairs[i].ignored)
2949             {
2950               if (bad_flag_pairs[i].predicate != 0)
2951                 status_warning (status, "%s ignored with %s and `%%%c' %s format",
2952                                 _(s->name), _(t->name), format_char,
2953                                 fki->name);
2954               else
2955                 status_warning (status, "%s ignored with %s in %s format",
2956                                 _(s->name), _(t->name), fki->name);
2957             }
2958           else
2959             {
2960               if (bad_flag_pairs[i].predicate != 0)
2961                 status_warning (status, "use of %s and %s together with `%%%c' %s format",
2962                                 _(s->name), _(t->name), format_char,
2963                                 fki->name);
2964               else
2965                 status_warning (status, "use of %s and %s together in %s format",
2966                                 _(s->name), _(t->name), fki->name);
2967             }
2968         }
2969
2970       /* Give Y2K warnings.  */
2971       {
2972         int y2k_level = 0;
2973         if (index (fci->flags2, '4') != 0)
2974           if (index (flag_chars, 'E') != 0)
2975             y2k_level = 3;
2976           else
2977             y2k_level = 2;
2978         else if (index (fci->flags2, '3') != 0)
2979           y2k_level = 3;
2980         else if (index (fci->flags2, '2') != 0)
2981           y2k_level = 2;
2982         if (y2k_level == 3)
2983           status_warning (status, "`%%%c' yields only last 2 digits of year in some locales",
2984                           format_char);
2985         else if (y2k_level == 2)
2986           status_warning (status, "`%%%c' yields only last 2 digits of year", format_char);
2987       }
2988
2989       if (index (fci->flags2, '[') != 0)
2990         {
2991           /* Skip over scan set, in case it happens to have '%' in it.  */
2992           if (*format_chars == '^')
2993             ++format_chars;
2994           /* Find closing bracket; if one is hit immediately, then
2995              it's part of the scan set rather than a terminator.  */
2996           if (*format_chars == ']')
2997             ++format_chars;
2998           while (*format_chars && *format_chars != ']')
2999             ++format_chars;
3000           if (*format_chars != ']')
3001             /* The end of the format string was reached.  */
3002             status_warning (status, "no closing `]' for `%%[' format");
3003         }
3004
3005       wanted_type = 0;
3006       wanted_type_name = 0;
3007       if (fki->flags & FMT_FLAG_ARG_CONVERT)
3008         {
3009           wanted_type = (fci->types[length_chars_val].type
3010                          ? *fci->types[length_chars_val].type : 0);
3011           wanted_type_name = fci->types[length_chars_val].name;
3012           wanted_type_std = fci->types[length_chars_val].std;
3013           if (wanted_type == 0)
3014             {
3015               status_warning (status, "use of `%s' length modifier with `%c' type character",
3016                               length_chars, format_char);
3017               /* Heuristic: skip one argument when an invalid length/type
3018                  combination is encountered.  */
3019               arg_num++;
3020               if (params == 0)
3021                 {
3022                   status_warning (status, "too few arguments for format");
3023                   return;
3024                 }
3025               params = TREE_CHAIN (params);
3026               continue;
3027             }
3028           else if (pedantic
3029                    /* Warn if non-standard, provided it is more non-standard
3030                       than the length and type characters that may already
3031                       have been warned for.  */
3032                    && wanted_type_std > length_chars_std
3033                    && wanted_type_std > fci->std)
3034             {
3035               if (wanted_type_std > C_STD_VER)
3036                 status_warning (status, "%s does not support the `%%%s%c' %s format",
3037                                 C_STD_NAME (wanted_type_std), length_chars,
3038                                 format_char, fki->name);
3039             }
3040         }
3041
3042       /* Finally. . .check type of argument against desired type!  */
3043       if (info->first_arg_num == 0)
3044         continue;
3045       if ((fci->pointer_count == 0 && wanted_type == void_type_node)
3046           || suppressed)
3047         {
3048           if (main_arg_num != 0)
3049             {
3050               if (suppressed)
3051                 status_warning (status, "operand number specified with suppressed assignment");
3052               else
3053                 status_warning (status, "operand number specified for format taking no argument");
3054             }
3055         }
3056       else
3057         {
3058           if (main_arg_num != 0)
3059             {
3060               arg_num = main_arg_num;
3061               params = main_arg_params;
3062             }
3063           else
3064             {
3065               ++arg_num;
3066               if (has_operand_number > 0)
3067                 {
3068                   status_warning (status, "missing $ operand number in format");
3069                   return;
3070                 }
3071               else
3072                 has_operand_number = 0;
3073               if (params == 0)
3074                 {
3075                   status_warning (status, "too few arguments for format");
3076                   return;
3077                 }
3078             }
3079           cur_param = TREE_VALUE (params);
3080           params = TREE_CHAIN (params);
3081           main_wanted_type.wanted_type = wanted_type;
3082           main_wanted_type.wanted_type_name = wanted_type_name;
3083           main_wanted_type.pointer_count = fci->pointer_count + aflag;
3084           main_wanted_type.char_lenient_flag = 0;
3085           if (index (fci->flags2, 'c') != 0)
3086             main_wanted_type.char_lenient_flag = 1;
3087           main_wanted_type.writing_in_flag = 0;
3088           if (index (fci->flags2, 'W') != 0)
3089             main_wanted_type.writing_in_flag = 1;
3090           main_wanted_type.name = NULL;
3091           main_wanted_type.param = cur_param;
3092           main_wanted_type.arg_num = arg_num;
3093           main_wanted_type.next = NULL;
3094           if (last_wanted_type != 0)
3095             last_wanted_type->next = &main_wanted_type;
3096           if (first_wanted_type == 0)
3097             first_wanted_type = &main_wanted_type;
3098           last_wanted_type = &main_wanted_type;
3099         }
3100
3101       if (first_wanted_type != 0)
3102         check_format_types (status, first_wanted_type);
3103
3104     }
3105 }
3106
3107
3108 /* Check the argument types from a single format conversion (possibly
3109    including width and precision arguments).  */
3110 static void
3111 check_format_types (status, types)
3112      int *status;
3113      format_wanted_type *types;
3114 {
3115   for (; types != 0; types = types->next)
3116     {
3117       tree cur_param;
3118       tree cur_type;
3119       tree orig_cur_type;
3120       tree wanted_type;
3121       tree promoted_type;
3122       int arg_num;
3123       int i;
3124       int char_type_flag;
3125       cur_param = types->param;
3126       cur_type = TREE_TYPE (cur_param);
3127       if (TREE_CODE (cur_type) == ERROR_MARK)
3128         continue;
3129       char_type_flag = 0;
3130       wanted_type = types->wanted_type;
3131       arg_num = types->arg_num;
3132
3133       /* The following should not occur here.  */
3134       if (wanted_type == 0)
3135         abort ();
3136       if (wanted_type == void_type_node && types->pointer_count == 0)
3137         abort ();
3138
3139       if (types->pointer_count == 0)
3140         {
3141           promoted_type = simple_type_promotes_to (wanted_type);
3142           if (promoted_type != NULL_TREE)
3143             wanted_type = promoted_type;
3144         }
3145
3146       STRIP_NOPS (cur_param);
3147
3148       /* Check the types of any additional pointer arguments
3149          that precede the "real" argument.  */
3150       for (i = 0; i < types->pointer_count; ++i)
3151         {
3152           if (TREE_CODE (cur_type) == POINTER_TYPE)
3153             {
3154               cur_type = TREE_TYPE (cur_type);
3155               if (TREE_CODE (cur_type) == ERROR_MARK)
3156                 break;
3157
3158               /* Check for writing through a NULL pointer.  */
3159               if (types->writing_in_flag
3160                   && i == 0
3161                   && cur_param != 0
3162                   && integer_zerop (cur_param))
3163                 status_warning (status,
3164                                 "writing through null pointer (arg %d)",
3165                                 arg_num);
3166
3167               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
3168                 cur_param = TREE_OPERAND (cur_param, 0);
3169               else
3170                 cur_param = 0;
3171
3172               /* See if this is an attempt to write into a const type with
3173                  scanf or with printf "%n".  Note: the writing in happens
3174                  at the first indirection only, if for example
3175                  void * const * is passed to scanf %p; passing
3176                  const void ** is simply passing an incompatible type.  */
3177               if (types->writing_in_flag
3178                   && i == 0
3179                   && (TYPE_READONLY (cur_type)
3180                       || (cur_param != 0
3181                           && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
3182                               || (DECL_P (cur_param)
3183                                   && TREE_READONLY (cur_param))))))
3184                 status_warning (status, "writing into constant object (arg %d)", arg_num);
3185
3186               /* If there are extra type qualifiers beyond the first
3187                  indirection, then this makes the types technically
3188                  incompatible.  */
3189               if (i > 0
3190                   && pedantic
3191                   && (TYPE_READONLY (cur_type)
3192                       || TYPE_VOLATILE (cur_type)
3193                       || TYPE_RESTRICT (cur_type)))
3194                 status_warning (status, "extra type qualifiers in format argument (arg %d)",
3195                          arg_num);
3196
3197             }
3198           else
3199             {
3200               if (types->pointer_count == 1)
3201                 status_warning (status, "format argument is not a pointer (arg %d)", arg_num);
3202               else
3203                 status_warning (status, "format argument is not a pointer to a pointer (arg %d)", arg_num);
3204               break;
3205             }
3206         }
3207
3208       if (i < types->pointer_count)
3209         continue;
3210
3211       orig_cur_type = cur_type;
3212       cur_type = TYPE_MAIN_VARIANT (cur_type);
3213
3214       /* Check whether the argument type is a character type.  This leniency
3215          only applies to certain formats, flagged with 'c'.
3216       */
3217       if (types->char_lenient_flag)
3218         char_type_flag = (cur_type == char_type_node
3219                           || cur_type == signed_char_type_node
3220                           || cur_type == unsigned_char_type_node);
3221
3222       /* Check the type of the "real" argument, if there's a type we want.  */
3223       if (wanted_type == cur_type)
3224         continue;
3225       /* If we want `void *', allow any pointer type.
3226          (Anything else would already have got a warning.)
3227          With -pedantic, only allow pointers to void and to character
3228          types.  */
3229       if (wanted_type == void_type_node
3230           && (!pedantic || (i == 1 && char_type_flag)))
3231         continue;
3232       /* Don't warn about differences merely in signedness, unless
3233          -pedantic.  With -pedantic, warn if the type is a pointer
3234          target and not a character type, and for character types at
3235          a second level of indirection.  */
3236       if (TREE_CODE (wanted_type) == INTEGER_TYPE
3237           && TREE_CODE (cur_type) == INTEGER_TYPE
3238           && (! pedantic || i == 0 || (i == 1 && char_type_flag))
3239           && (TREE_UNSIGNED (wanted_type)
3240               ? wanted_type == unsigned_type (cur_type)
3241               : wanted_type == signed_type (cur_type)))
3242         continue;
3243       /* Likewise, "signed char", "unsigned char" and "char" are
3244          equivalent but the above test won't consider them equivalent.  */
3245       if (wanted_type == char_type_node
3246           && (! pedantic || i < 2)
3247           && char_type_flag)
3248         continue;
3249       /* Now we have a type mismatch.  */
3250       {
3251         register const char *this;
3252         register const char *that;
3253
3254         this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
3255         that = 0;
3256         if (TYPE_NAME (orig_cur_type) != 0
3257             && TREE_CODE (orig_cur_type) != INTEGER_TYPE
3258             && !(TREE_CODE (orig_cur_type) == POINTER_TYPE
3259                  && TREE_CODE (TREE_TYPE (orig_cur_type)) == INTEGER_TYPE))
3260           {
3261             if (TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL
3262                 && DECL_NAME (TYPE_NAME (orig_cur_type)) != 0)
3263               that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
3264             else
3265               that = IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type));
3266           }
3267
3268         /* A nameless type can't possibly match what the format wants.
3269            So there will be a warning for it.
3270            Make up a string to describe vaguely what it is.  */
3271         if (that == 0)
3272           {
3273             if (TREE_CODE (orig_cur_type) == POINTER_TYPE)
3274               that = "pointer";
3275             else
3276               that = "different type";
3277           }
3278
3279         /* Make the warning better in case of mismatch of int vs long.  */
3280         if (TREE_CODE (orig_cur_type) == INTEGER_TYPE
3281             && TREE_CODE (wanted_type) == INTEGER_TYPE
3282             && TYPE_PRECISION (orig_cur_type) == TYPE_PRECISION (wanted_type)
3283             && TYPE_NAME (orig_cur_type) != 0
3284             && TREE_CODE (TYPE_NAME (orig_cur_type)) == TYPE_DECL)
3285           that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type)));
3286
3287         if (strcmp (this, that) != 0)
3288           {
3289             /* There may be a better name for the format, e.g. size_t,
3290                but we should allow for programs with a perverse typedef
3291                making size_t something other than what the compiler
3292                thinks.  */
3293             if (types->wanted_type_name != 0
3294                 && strcmp (types->wanted_type_name, that) != 0)
3295               this = types->wanted_type_name;
3296             if (types->name != 0)
3297               status_warning (status, "%s is not type %s (arg %d)", types->name, this,
3298                        arg_num);
3299             else
3300               status_warning (status, "%s format, %s arg (arg %d)", this, that, arg_num);
3301           }
3302       }
3303     }
3304 }
3305 \f
3306 /* Print a warning if a constant expression had overflow in folding.
3307    Invoke this function on every expression that the language
3308    requires to be a constant expression.
3309    Note the ANSI C standard says it is erroneous for a
3310    constant expression to overflow.  */
3311
3312 void
3313 constant_expression_warning (value)
3314      tree value;
3315 {
3316   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
3317        || TREE_CODE (value) == COMPLEX_CST)
3318       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
3319     pedwarn ("overflow in constant expression");
3320 }
3321
3322 /* Print a warning if an expression had overflow in folding.
3323    Invoke this function on every expression that
3324    (1) appears in the source code, and
3325    (2) might be a constant expression that overflowed, and
3326    (3) is not already checked by convert_and_check;
3327    however, do not invoke this function on operands of explicit casts.  */
3328
3329 void
3330 overflow_warning (value)
3331      tree value;
3332 {
3333   if ((TREE_CODE (value) == INTEGER_CST
3334        || (TREE_CODE (value) == COMPLEX_CST
3335            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
3336       && TREE_OVERFLOW (value))
3337     {
3338       TREE_OVERFLOW (value) = 0;
3339       if (skip_evaluation == 0)
3340         warning ("integer overflow in expression");
3341     }
3342   else if ((TREE_CODE (value) == REAL_CST
3343             || (TREE_CODE (value) == COMPLEX_CST
3344                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
3345            && TREE_OVERFLOW (value))
3346     {
3347       TREE_OVERFLOW (value) = 0;
3348       if (skip_evaluation == 0)
3349         warning ("floating point overflow in expression");
3350     }
3351 }
3352
3353 /* Print a warning if a large constant is truncated to unsigned,
3354    or if -Wconversion is used and a constant < 0 is converted to unsigned.
3355    Invoke this function on every expression that might be implicitly
3356    converted to an unsigned type.  */
3357
3358 void
3359 unsigned_conversion_warning (result, operand)
3360      tree result, operand;
3361 {
3362   if (TREE_CODE (operand) == INTEGER_CST
3363       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
3364       && TREE_UNSIGNED (TREE_TYPE (result))
3365       && skip_evaluation == 0
3366       && !int_fits_type_p (operand, TREE_TYPE (result)))
3367     {
3368       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
3369         /* This detects cases like converting -129 or 256 to unsigned char.  */
3370         warning ("large integer implicitly truncated to unsigned type");
3371       else if (warn_conversion)
3372         warning ("negative integer implicitly converted to unsigned type");
3373     }
3374 }
3375
3376 /* Convert EXPR to TYPE, warning about conversion problems with constants.
3377    Invoke this function on every expression that is converted implicitly,
3378    i.e. because of language rules and not because of an explicit cast.  */
3379
3380 tree
3381 convert_and_check (type, expr)
3382      tree type, expr;
3383 {
3384   tree t = convert (type, expr);
3385   if (TREE_CODE (t) == INTEGER_CST)
3386     {
3387       if (TREE_OVERFLOW (t))
3388         {
3389           TREE_OVERFLOW (t) = 0;
3390
3391           /* Do not diagnose overflow in a constant expression merely
3392              because a conversion overflowed.  */
3393           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
3394
3395           /* No warning for converting 0x80000000 to int.  */
3396           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
3397                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
3398                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
3399             /* If EXPR fits in the unsigned version of TYPE,
3400                don't warn unless pedantic.  */
3401             if ((pedantic
3402                  || TREE_UNSIGNED (type)
3403                  || ! int_fits_type_p (expr, unsigned_type (type)))
3404                 && skip_evaluation == 0)
3405               warning ("overflow in implicit constant conversion");
3406         }
3407       else
3408         unsigned_conversion_warning (t, expr);
3409     }
3410   return t;
3411 }
3412 \f
3413 /* Describe a reversed version of a normal tree, so that we can get to the
3414    parent of each node.  */
3415 struct reverse_tree
3416 {
3417   /* All reverse_tree structures for a given tree are chained through this
3418      field.  */
3419   struct reverse_tree *next;
3420   /* The parent of this node.  */
3421   struct reverse_tree *parent;
3422   /* The actual tree node.  */
3423   tree x;
3424   /* The operand number this node corresponds to in the parent.  */
3425   int operandno;
3426   /* Describe whether this expression is written to or read.  */
3427   char read, write;
3428 };
3429
3430 /* A list of all reverse_tree structures for a given expression, built by
3431    build_reverse_tree.  */
3432 static struct reverse_tree *reverse_list;
3433 /* The maximum depth of a tree, computed by build_reverse_tree.  */
3434 static int reverse_max_depth;
3435
3436 static void build_reverse_tree PARAMS ((tree, struct reverse_tree *, int, int,
3437                                         int, int));
3438 static struct reverse_tree *common_ancestor PARAMS ((struct reverse_tree *,
3439                                                      struct reverse_tree *,
3440                                                      struct reverse_tree **,
3441                                                      struct reverse_tree **));
3442 static int modify_ok PARAMS ((struct reverse_tree *, struct reverse_tree *));
3443 static void verify_sequence_points PARAMS ((tree));
3444
3445 /* Recursively process an expression, X, building a reverse tree while
3446    descending and recording OPERANDNO, READ, and WRITE in the created
3447    structures.  DEPTH is used to compute reverse_max_depth.
3448    FIXME: if walk_tree gets moved out of the C++ front end, this should
3449    probably use walk_tree.  */
3450
3451 static void
3452 build_reverse_tree (x, parent, operandno, read, write, depth)
3453      tree x;
3454      struct reverse_tree *parent;
3455      int operandno, read, write, depth;
3456 {
3457   struct reverse_tree *node;
3458
3459   if (x == 0 || x == error_mark_node)
3460     return;
3461
3462   node = (struct reverse_tree *) xmalloc (sizeof (struct reverse_tree));
3463
3464   node->parent = parent;
3465   node->x = x;
3466   node->read = read;
3467   node->write = write;
3468   node->operandno = operandno;
3469   node->next = reverse_list;
3470   reverse_list = node;
3471   if (depth > reverse_max_depth)
3472     reverse_max_depth = depth;
3473
3474   switch (TREE_CODE (x))
3475     {
3476     case PREDECREMENT_EXPR:
3477     case PREINCREMENT_EXPR:
3478     case POSTDECREMENT_EXPR:
3479     case POSTINCREMENT_EXPR:
3480       build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 1, 1, depth + 1);
3481       break;
3482
3483     case CALL_EXPR:
3484       build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 1, 0, depth + 1);
3485       x = TREE_OPERAND (x, 1);
3486       while (x)
3487         {
3488           build_reverse_tree (TREE_VALUE (x), node, 1, 1, 0, depth + 1);
3489           x = TREE_CHAIN (x);
3490         }
3491       break;
3492
3493     case TREE_LIST:
3494       /* Scan all the list, e.g. indices of multi dimensional array.  */
3495       while (x)
3496         {
3497           build_reverse_tree (TREE_VALUE (x), node, 0, 1, 0, depth + 1);
3498           x = TREE_CHAIN (x);
3499         }
3500       break;
3501
3502     case MODIFY_EXPR:
3503       build_reverse_tree (TREE_OPERAND (x, 0), node, 0, 0, 1, depth + 1);
3504       build_reverse_tree (TREE_OPERAND (x, 1), node, 1, 1, 0, depth + 1);
3505       break;
3506
3507     default:
3508       switch (TREE_CODE_CLASS (TREE_CODE (x)))
3509         {
3510         case 'r':
3511         case '<':
3512         case '2':
3513         case 'b':
3514         case '1':
3515         case 'e':
3516         case 's':
3517         case 'x':
3518           {
3519             int lp;
3520             int max = first_rtl_op (TREE_CODE (x));
3521             for (lp = 0; lp < max; lp++)
3522               build_reverse_tree (TREE_OPERAND (x, lp), node, lp, 1, 0,
3523                                   depth + 1);
3524             break;
3525           }
3526         default:
3527           break;
3528         }
3529       break;
3530     }
3531 }
3532
3533 /* Given nodes P1 and P2 as well as enough scratch space pointed to by TMP1
3534    and TMP2, find the common ancestor of P1 and P2.  */
3535
3536 static struct reverse_tree *
3537 common_ancestor (p1, p2, tmp1, tmp2)
3538      struct reverse_tree *p1, *p2;
3539      struct reverse_tree **tmp1, **tmp2;
3540 {
3541   struct reverse_tree *t1 = p1;
3542   struct reverse_tree *t2 = p2;
3543   int i, j;
3544
3545   /* First, check if we're actually looking at the same expression twice,
3546      which can happen if it's wrapped in a SAVE_EXPR - in this case there's
3547      no chance of conflict.  */
3548   while (t1 && t2 && t1->x == t2->x)
3549     {
3550       if (TREE_CODE (t1->x) == SAVE_EXPR)
3551         return 0;
3552       t1 = t1->parent;
3553       t2 = t2->parent;
3554     }
3555
3556   for (i = 0; p1; i++, p1 = p1->parent)
3557     tmp1[i] = p1;
3558   for (j = 0; p2; j++, p2 = p2->parent)
3559     tmp2[j] = p2;
3560   while (tmp1[i - 1] == tmp2[j - 1])
3561     i--, j--;
3562
3563   return tmp1[i];
3564 }
3565
3566 /* Subroutine of verify_sequence_points to check whether a node T corresponding
3567    to a MODIFY_EXPR invokes undefined behaviour.  OTHER occurs somewhere in the
3568    RHS, and an identical expression is the LHS of T.
3569    For MODIFY_EXPRs, some special cases apply when testing for undefined
3570    behaviour if one of the expressions we found is the LHS of the MODIFY_EXPR.
3571    If the other expression is just a use, then there's no undefined behaviour.
3572    Likewise, if the other expression is wrapped inside another expression that
3573    will force a sequence point, then there's no undefined behaviour either.  */
3574
3575 static int
3576 modify_ok (t, other)
3577      struct reverse_tree *t, *other;
3578 {
3579   struct reverse_tree *p;
3580
3581   if (! other->write)
3582     return 1;
3583
3584   /* See if there's an intervening sequence point.  */
3585   for (p = other; p->parent != t; p = p->parent)
3586     {
3587       if ((TREE_CODE (p->parent->x) == COMPOUND_EXPR
3588            || TREE_CODE (p->parent->x) == TRUTH_ANDIF_EXPR
3589            || TREE_CODE (p->parent->x) == TRUTH_ORIF_EXPR
3590            || TREE_CODE (p->parent->x) == COND_EXPR)
3591           && p->operandno == 0)
3592         return 1;
3593       if (TREE_CODE (p->parent->x) == SAVE_EXPR)
3594         return 1;
3595       if (TREE_CODE (p->parent->x) == CALL_EXPR
3596           && p->operandno != 0)
3597         return 1;
3598     }
3599   return 0;
3600 }
3601
3602 /* Try to warn for undefined behaviour in EXPR due to missing sequence
3603    points.  */
3604
3605 static void
3606 verify_sequence_points (expr)
3607      tree expr;
3608 {
3609   struct reverse_tree **tmp1, **tmp2;
3610   struct reverse_tree *p;
3611
3612   reverse_list = 0;
3613   reverse_max_depth = 0;
3614   build_reverse_tree (expr, NULL, 0, 1, 0, 1);
3615
3616   tmp1 = (struct reverse_tree **) xmalloc (sizeof (struct reverse_tree *)
3617                                            * reverse_max_depth);
3618   tmp2 = (struct reverse_tree **) xmalloc (sizeof (struct reverse_tree *)
3619                                            * reverse_max_depth);
3620
3621   /* Search for multiple occurrences of the same variable, where either both
3622      occurrences are writes, or one is a read and a write.  If we can't prove
3623      that these are ordered by a sequence point, warn that the expression is
3624      undefined.  */
3625   for (p = reverse_list; p; p = p->next)
3626     {
3627       struct reverse_tree *p2;
3628       if (TREE_CODE (p->x) != VAR_DECL && TREE_CODE (p->x) != PARM_DECL)
3629         continue;
3630       for (p2 = p->next; p2; p2 = p2->next)
3631         {
3632           if ((TREE_CODE (p2->x) == VAR_DECL || TREE_CODE (p2->x) == PARM_DECL)
3633               && DECL_NAME (p->x) == DECL_NAME (p2->x)
3634               && (p->write || p2->write))
3635             {
3636               struct reverse_tree *t = common_ancestor (p, p2, tmp1, tmp2);
3637
3638               if (t == 0
3639                   || TREE_CODE (t->x) == COMPOUND_EXPR
3640                   || TREE_CODE (t->x) == TRUTH_ANDIF_EXPR
3641                   || TREE_CODE (t->x) == TRUTH_ORIF_EXPR
3642                   || TREE_CODE (t->x) == COND_EXPR)
3643                 continue;
3644               if (TREE_CODE (t->x) == MODIFY_EXPR
3645                   && p->parent == t
3646                   && modify_ok (t, p2))
3647                 continue;
3648               if (TREE_CODE (t->x) == MODIFY_EXPR
3649                   && p2->parent == t
3650                   && modify_ok (t, p))
3651                 continue;
3652
3653               warning ("operation on `%s' may be undefined",
3654                        IDENTIFIER_POINTER (DECL_NAME (p->x)));
3655               break;
3656             }
3657         }
3658     }
3659
3660   while (reverse_list)
3661     {
3662       struct reverse_tree *p = reverse_list;
3663       reverse_list = p->next;
3664       free (p);
3665     }
3666   free (tmp1);
3667   free (tmp2);
3668 }
3669
3670 void
3671 c_expand_expr_stmt (expr)
3672      tree expr;
3673 {
3674   /* Do default conversion if safe and possibly important,
3675      in case within ({...}).  */
3676   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
3677       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
3678     expr = default_conversion (expr);
3679
3680   if (warn_sequence_point)
3681     verify_sequence_points (expr);
3682
3683   if (TREE_TYPE (expr) != error_mark_node
3684       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
3685       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
3686     error ("expression statement has incomplete type");
3687
3688   last_expr_type = TREE_TYPE (expr);
3689   add_stmt (build_stmt (EXPR_STMT, expr));
3690 }
3691 \f
3692 /* Validate the expression after `case' and apply default promotions.  */
3693
3694 tree
3695 check_case_value (value)
3696      tree value;
3697 {
3698   if (value == NULL_TREE)
3699     return value;
3700
3701   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
3702   STRIP_TYPE_NOPS (value);
3703   /* In C++, the following is allowed:
3704
3705        const int i = 3;
3706        switch (...) { case i: ... }
3707
3708      So, we try to reduce the VALUE to a constant that way.  */
3709   if (c_language == clk_cplusplus)
3710     {
3711       value = decl_constant_value (value);
3712       STRIP_TYPE_NOPS (value);
3713       value = fold (value);
3714     }
3715
3716   if (TREE_CODE (value) != INTEGER_CST
3717       && value != error_mark_node)
3718     {
3719       error ("case label does not reduce to an integer constant");
3720       value = error_mark_node;
3721     }
3722   else
3723     /* Promote char or short to int.  */
3724     value = default_conversion (value);
3725
3726   constant_expression_warning (value);
3727
3728   return value;
3729 }
3730 \f
3731 /* Return an integer type with BITS bits of precision,
3732    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
3733
3734 tree
3735 type_for_size (bits, unsignedp)
3736      unsigned bits;
3737      int unsignedp;
3738 {
3739   if (bits == TYPE_PRECISION (integer_type_node))
3740     return unsignedp ? unsigned_type_node : integer_type_node;
3741
3742   if (bits == TYPE_PRECISION (signed_char_type_node))
3743     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3744
3745   if (bits == TYPE_PRECISION (short_integer_type_node))
3746     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3747
3748   if (bits == TYPE_PRECISION (long_integer_type_node))
3749     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3750
3751   if (bits == TYPE_PRECISION (long_long_integer_type_node))
3752     return (unsignedp ? long_long_unsigned_type_node
3753             : long_long_integer_type_node);
3754
3755   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
3756     return (unsignedp ? widest_unsigned_literal_type_node
3757             : widest_integer_literal_type_node);
3758
3759   if (bits <= TYPE_PRECISION (intQI_type_node))
3760     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3761
3762   if (bits <= TYPE_PRECISION (intHI_type_node))
3763     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3764
3765   if (bits <= TYPE_PRECISION (intSI_type_node))
3766     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3767
3768   if (bits <= TYPE_PRECISION (intDI_type_node))
3769     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3770
3771   return 0;
3772 }
3773
3774 /* Return a data type that has machine mode MODE.
3775    If the mode is an integer,
3776    then UNSIGNEDP selects between signed and unsigned types.  */
3777
3778 tree
3779 type_for_mode (mode, unsignedp)
3780      enum machine_mode mode;
3781      int unsignedp;
3782 {
3783   if (mode == TYPE_MODE (integer_type_node))
3784     return unsignedp ? unsigned_type_node : integer_type_node;
3785
3786   if (mode == TYPE_MODE (signed_char_type_node))
3787     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3788
3789   if (mode == TYPE_MODE (short_integer_type_node))
3790     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3791
3792   if (mode == TYPE_MODE (long_integer_type_node))
3793     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3794
3795   if (mode == TYPE_MODE (long_long_integer_type_node))
3796     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3797
3798   if (mode == TYPE_MODE (widest_integer_literal_type_node))
3799     return unsignedp ? widest_unsigned_literal_type_node
3800                      : widest_integer_literal_type_node;
3801
3802   if (mode == TYPE_MODE (intQI_type_node))
3803     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3804
3805   if (mode == TYPE_MODE (intHI_type_node))
3806     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3807
3808   if (mode == TYPE_MODE (intSI_type_node))
3809     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3810
3811   if (mode == TYPE_MODE (intDI_type_node))
3812     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3813
3814 #if HOST_BITS_PER_WIDE_INT >= 64
3815   if (mode == TYPE_MODE (intTI_type_node))
3816     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3817 #endif
3818
3819   if (mode == TYPE_MODE (float_type_node))
3820     return float_type_node;
3821
3822   if (mode == TYPE_MODE (double_type_node))
3823     return double_type_node;
3824
3825   if (mode == TYPE_MODE (long_double_type_node))
3826     return long_double_type_node;
3827
3828   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
3829     return build_pointer_type (char_type_node);
3830
3831   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
3832     return build_pointer_type (integer_type_node);
3833
3834 #ifdef VECTOR_MODE_SUPPORTED_P
3835   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3836     return V4SF_type_node;
3837   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3838     return V4SI_type_node;
3839   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3840     return V2SI_type_node;
3841   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3842     return V4HI_type_node;
3843   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
3844     return V8QI_type_node;
3845 #endif
3846
3847   return 0;
3848 }
3849
3850 /* Return an unsigned type the same as TYPE in other respects. */
3851 tree
3852 unsigned_type (type)
3853      tree type;
3854 {
3855   tree type1 = TYPE_MAIN_VARIANT (type);
3856   if (type1 == signed_char_type_node || type1 == char_type_node)
3857     return unsigned_char_type_node;
3858   if (type1 == integer_type_node)
3859     return unsigned_type_node;
3860   if (type1 == short_integer_type_node)
3861     return short_unsigned_type_node;
3862   if (type1 == long_integer_type_node)
3863     return long_unsigned_type_node;
3864   if (type1 == long_long_integer_type_node)
3865     return long_long_unsigned_type_node;
3866   if (type1 == widest_integer_literal_type_node)
3867     return widest_unsigned_literal_type_node;
3868 #if HOST_BITS_PER_WIDE_INT >= 64
3869   if (type1 == intTI_type_node)
3870     return unsigned_intTI_type_node;
3871 #endif
3872   if (type1 == intDI_type_node)
3873     return unsigned_intDI_type_node;
3874   if (type1 == intSI_type_node)
3875     return unsigned_intSI_type_node;
3876   if (type1 == intHI_type_node)
3877     return unsigned_intHI_type_node;
3878   if (type1 == intQI_type_node)
3879     return unsigned_intQI_type_node;
3880
3881   return signed_or_unsigned_type (1, type);
3882 }
3883
3884 /* Return a signed type the same as TYPE in other respects.  */
3885
3886 tree
3887 signed_type (type)
3888      tree type;
3889 {
3890   tree type1 = TYPE_MAIN_VARIANT (type);
3891   if (type1 == unsigned_char_type_node || type1 == char_type_node)
3892     return signed_char_type_node;
3893   if (type1 == unsigned_type_node)
3894     return integer_type_node;
3895   if (type1 == short_unsigned_type_node)
3896     return short_integer_type_node;
3897   if (type1 == long_unsigned_type_node)
3898     return long_integer_type_node;
3899   if (type1 == long_long_unsigned_type_node)
3900     return long_long_integer_type_node;
3901   if (type1 == widest_unsigned_literal_type_node)
3902     return widest_integer_literal_type_node;
3903 #if HOST_BITS_PER_WIDE_INT >= 64
3904   if (type1 == unsigned_intTI_type_node)
3905     return intTI_type_node;
3906 #endif
3907   if (type1 == unsigned_intDI_type_node)
3908     return intDI_type_node;
3909   if (type1 == unsigned_intSI_type_node)
3910     return intSI_type_node;
3911   if (type1 == unsigned_intHI_type_node)
3912     return intHI_type_node;
3913   if (type1 == unsigned_intQI_type_node)
3914     return intQI_type_node;
3915
3916   return signed_or_unsigned_type (0, type);
3917 }
3918
3919 /* Return a type the same as TYPE except unsigned or
3920    signed according to UNSIGNEDP.  */
3921
3922 tree
3923 signed_or_unsigned_type (unsignedp, type)
3924      int unsignedp;
3925      tree type;
3926 {
3927   if (! INTEGRAL_TYPE_P (type)
3928       || TREE_UNSIGNED (type) == unsignedp)
3929     return type;
3930
3931   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
3932     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3933   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
3934     return unsignedp ? unsigned_type_node : integer_type_node;
3935   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
3936     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3937   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
3938     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3939   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
3940     return (unsignedp ? long_long_unsigned_type_node
3941             : long_long_integer_type_node);
3942   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
3943     return (unsignedp ? widest_unsigned_literal_type_node
3944             : widest_integer_literal_type_node);
3945   return type;
3946 }
3947 \f
3948 /* Return the minimum number of bits needed to represent VALUE in a
3949    signed or unsigned type, UNSIGNEDP says which.  */
3950
3951 unsigned int
3952 min_precision (value, unsignedp)
3953      tree value;
3954      int unsignedp;
3955 {
3956   int log;
3957
3958   /* If the value is negative, compute its negative minus 1.  The latter
3959      adjustment is because the absolute value of the largest negative value
3960      is one larger than the largest positive value.  This is equivalent to
3961      a bit-wise negation, so use that operation instead.  */
3962
3963   if (tree_int_cst_sgn (value) < 0)
3964     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
3965
3966   /* Return the number of bits needed, taking into account the fact
3967      that we need one more bit for a signed than unsigned type.  */
3968
3969   if (integer_zerop (value))
3970     log = 0;
3971   else
3972     log = tree_floor_log2 (value);
3973
3974   return log + 1 + ! unsignedp;
3975 }
3976 \f
3977 /* Print an error message for invalid operands to arith operation CODE.
3978    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
3979
3980 void
3981 binary_op_error (code)
3982      enum tree_code code;
3983 {
3984   register const char *opname;
3985
3986   switch (code)
3987     {
3988     case NOP_EXPR:
3989       error ("invalid truth-value expression");
3990       return;
3991
3992     case PLUS_EXPR:
3993       opname = "+"; break;
3994     case MINUS_EXPR:
3995       opname = "-"; break;
3996     case MULT_EXPR:
3997       opname = "*"; break;
3998     case MAX_EXPR:
3999       opname = "max"; break;
4000     case MIN_EXPR:
4001       opname = "min"; break;
4002     case EQ_EXPR:
4003       opname = "=="; break;
4004     case NE_EXPR:
4005       opname = "!="; break;
4006     case LE_EXPR:
4007       opname = "<="; break;
4008     case GE_EXPR:
4009       opname = ">="; break;
4010     case LT_EXPR:
4011       opname = "<"; break;
4012     case GT_EXPR:
4013       opname = ">"; break;
4014     case LSHIFT_EXPR:
4015       opname = "<<"; break;
4016     case RSHIFT_EXPR:
4017       opname = ">>"; break;
4018     case TRUNC_MOD_EXPR:
4019     case FLOOR_MOD_EXPR:
4020       opname = "%"; break;
4021     case TRUNC_DIV_EXPR:
4022     case FLOOR_DIV_EXPR:
4023       opname = "/"; break;
4024     case BIT_AND_EXPR:
4025       opname = "&"; break;
4026     case BIT_IOR_EXPR:
4027       opname = "|"; break;
4028     case TRUTH_ANDIF_EXPR:
4029       opname = "&&"; break;
4030     case TRUTH_ORIF_EXPR:
4031       opname = "||"; break;
4032     case BIT_XOR_EXPR:
4033       opname = "^"; break;
4034     case LROTATE_EXPR:
4035     case RROTATE_EXPR:
4036       opname = "rotate"; break;
4037     default:
4038       opname = "unknown"; break;
4039     }
4040   error ("invalid operands to binary %s", opname);
4041 }
4042 \f
4043 /* Subroutine of build_binary_op, used for comparison operations.
4044    See if the operands have both been converted from subword integer types
4045    and, if so, perhaps change them both back to their original type.
4046    This function is also responsible for converting the two operands
4047    to the proper common type for comparison.
4048
4049    The arguments of this function are all pointers to local variables
4050    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
4051    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
4052
4053    If this function returns nonzero, it means that the comparison has
4054    a constant value.  What this function returns is an expression for
4055    that value.  */
4056
4057 tree
4058 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
4059      tree *op0_ptr, *op1_ptr;
4060      tree *restype_ptr;
4061      enum tree_code *rescode_ptr;
4062 {
4063   register tree type;
4064   tree op0 = *op0_ptr;
4065   tree op1 = *op1_ptr;
4066   int unsignedp0, unsignedp1;
4067   int real1, real2;
4068   tree primop0, primop1;
4069   enum tree_code code = *rescode_ptr;
4070
4071   /* Throw away any conversions to wider types
4072      already present in the operands.  */
4073
4074   primop0 = get_narrower (op0, &unsignedp0);
4075   primop1 = get_narrower (op1, &unsignedp1);
4076
4077   /* Handle the case that OP0 does not *contain* a conversion
4078      but it *requires* conversion to FINAL_TYPE.  */
4079
4080   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
4081     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
4082   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
4083     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
4084
4085   /* If one of the operands must be floated, we cannot optimize.  */
4086   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
4087   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
4088
4089   /* If first arg is constant, swap the args (changing operation
4090      so value is preserved), for canonicalization.  Don't do this if
4091      the second arg is 0.  */
4092
4093   if (TREE_CONSTANT (primop0)
4094       && ! integer_zerop (primop1) && ! real_zerop (primop1))
4095     {
4096       register tree tem = primop0;
4097       register int temi = unsignedp0;
4098       primop0 = primop1;
4099       primop1 = tem;
4100       tem = op0;
4101       op0 = op1;
4102       op1 = tem;
4103       *op0_ptr = op0;
4104       *op1_ptr = op1;
4105       unsignedp0 = unsignedp1;
4106       unsignedp1 = temi;
4107       temi = real1;
4108       real1 = real2;
4109       real2 = temi;
4110
4111       switch (code)
4112         {
4113         case LT_EXPR:
4114           code = GT_EXPR;
4115           break;
4116         case GT_EXPR:
4117           code = LT_EXPR;
4118           break;
4119         case LE_EXPR:
4120           code = GE_EXPR;
4121           break;
4122         case GE_EXPR:
4123           code = LE_EXPR;
4124           break;
4125         default:
4126           break;
4127         }
4128       *rescode_ptr = code;
4129     }
4130
4131   /* If comparing an integer against a constant more bits wide,
4132      maybe we can deduce a value of 1 or 0 independent of the data.
4133      Or else truncate the constant now
4134      rather than extend the variable at run time.
4135
4136      This is only interesting if the constant is the wider arg.
4137      Also, it is not safe if the constant is unsigned and the
4138      variable arg is signed, since in this case the variable
4139      would be sign-extended and then regarded as unsigned.
4140      Our technique fails in this case because the lowest/highest
4141      possible unsigned results don't follow naturally from the
4142      lowest/highest possible values of the variable operand.
4143      For just EQ_EXPR and NE_EXPR there is another technique that
4144      could be used: see if the constant can be faithfully represented
4145      in the other operand's type, by truncating it and reextending it
4146      and see if that preserves the constant's value.  */
4147
4148   if (!real1 && !real2
4149       && TREE_CODE (primop1) == INTEGER_CST
4150       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
4151     {
4152       int min_gt, max_gt, min_lt, max_lt;
4153       tree maxval, minval;
4154       /* 1 if comparison is nominally unsigned.  */
4155       int unsignedp = TREE_UNSIGNED (*restype_ptr);
4156       tree val;
4157
4158       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
4159
4160       /* If TYPE is an enumeration, then we need to get its min/max
4161          values from it's underlying integral type, not the enumerated
4162          type itself.  */
4163       if (TREE_CODE (type) == ENUMERAL_TYPE)
4164         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
4165
4166       maxval = TYPE_MAX_VALUE (type);
4167       minval = TYPE_MIN_VALUE (type);
4168
4169       if (unsignedp && !unsignedp0)
4170         *restype_ptr = signed_type (*restype_ptr);
4171
4172       if (TREE_TYPE (primop1) != *restype_ptr)
4173         primop1 = convert (*restype_ptr, primop1);
4174       if (type != *restype_ptr)
4175         {
4176           minval = convert (*restype_ptr, minval);
4177           maxval = convert (*restype_ptr, maxval);
4178         }
4179
4180       if (unsignedp && unsignedp0)
4181         {
4182           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
4183           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
4184           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
4185           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
4186         }
4187       else
4188         {
4189           min_gt = INT_CST_LT (primop1, minval);
4190           max_gt = INT_CST_LT (primop1, maxval);
4191           min_lt = INT_CST_LT (minval, primop1);
4192           max_lt = INT_CST_LT (maxval, primop1);
4193         }
4194
4195       val = 0;
4196       /* This used to be a switch, but Genix compiler can't handle that.  */
4197       if (code == NE_EXPR)
4198         {
4199           if (max_lt || min_gt)
4200             val = boolean_true_node;
4201         }
4202       else if (code == EQ_EXPR)
4203         {
4204           if (max_lt || min_gt)
4205             val = boolean_false_node;
4206         }
4207       else if (code == LT_EXPR)
4208         {
4209           if (max_lt)
4210             val = boolean_true_node;
4211           if (!min_lt)
4212             val = boolean_false_node;
4213         }
4214       else if (code == GT_EXPR)
4215         {
4216           if (min_gt)
4217             val = boolean_true_node;
4218           if (!max_gt)
4219             val = boolean_false_node;
4220         }
4221       else if (code == LE_EXPR)
4222         {
4223           if (!max_gt)
4224             val = boolean_true_node;
4225           if (min_gt)
4226             val = boolean_false_node;
4227         }
4228       else if (code == GE_EXPR)
4229         {
4230           if (!min_lt)
4231             val = boolean_true_node;
4232           if (max_lt)
4233             val = boolean_false_node;
4234         }
4235
4236       /* If primop0 was sign-extended and unsigned comparison specd,
4237          we did a signed comparison above using the signed type bounds.
4238          But the comparison we output must be unsigned.
4239
4240          Also, for inequalities, VAL is no good; but if the signed
4241          comparison had *any* fixed result, it follows that the
4242          unsigned comparison just tests the sign in reverse
4243          (positive values are LE, negative ones GE).
4244          So we can generate an unsigned comparison
4245          against an extreme value of the signed type.  */
4246
4247       if (unsignedp && !unsignedp0)
4248         {
4249           if (val != 0)
4250             switch (code)
4251               {
4252               case LT_EXPR:
4253               case GE_EXPR:
4254                 primop1 = TYPE_MIN_VALUE (type);
4255                 val = 0;
4256                 break;
4257
4258               case LE_EXPR:
4259               case GT_EXPR:
4260                 primop1 = TYPE_MAX_VALUE (type);
4261                 val = 0;
4262                 break;
4263
4264               default:
4265                 break;
4266               }
4267           type = unsigned_type (type);
4268         }
4269
4270       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
4271         {
4272           /* This is the case of (char)x >?< 0x80, which people used to use
4273              expecting old C compilers to change the 0x80 into -0x80.  */
4274           if (val == boolean_false_node)
4275             warning ("comparison is always false due to limited range of data type");
4276           if (val == boolean_true_node)
4277             warning ("comparison is always true due to limited range of data type");
4278         }
4279
4280       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
4281         {
4282           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
4283           if (val == boolean_false_node)
4284             warning ("comparison is always false due to limited range of data type");
4285           if (val == boolean_true_node)
4286             warning ("comparison is always true due to limited range of data type");
4287         }
4288
4289       if (val != 0)
4290         {
4291           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
4292           if (TREE_SIDE_EFFECTS (primop0))
4293             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
4294           return val;
4295         }
4296
4297       /* Value is not predetermined, but do the comparison
4298          in the type of the operand that is not constant.
4299          TYPE is already properly set.  */
4300     }
4301   else if (real1 && real2
4302            && (TYPE_PRECISION (TREE_TYPE (primop0))
4303                == TYPE_PRECISION (TREE_TYPE (primop1))))
4304     type = TREE_TYPE (primop0);
4305
4306   /* If args' natural types are both narrower than nominal type
4307      and both extend in the same manner, compare them
4308      in the type of the wider arg.
4309      Otherwise must actually extend both to the nominal
4310      common type lest different ways of extending
4311      alter the result.
4312      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
4313
4314   else if (unsignedp0 == unsignedp1 && real1 == real2
4315            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
4316            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
4317     {
4318       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
4319       type = signed_or_unsigned_type (unsignedp0
4320                                       || TREE_UNSIGNED (*restype_ptr),
4321                                       type);
4322       /* Make sure shorter operand is extended the right way
4323          to match the longer operand.  */
4324       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
4325                          primop0);
4326       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
4327                          primop1);
4328     }
4329   else
4330     {
4331       /* Here we must do the comparison on the nominal type
4332          using the args exactly as we received them.  */
4333       type = *restype_ptr;
4334       primop0 = op0;
4335       primop1 = op1;
4336
4337       if (!real1 && !real2 && integer_zerop (primop1)
4338           && TREE_UNSIGNED (*restype_ptr))
4339         {
4340           tree value = 0;
4341           switch (code)
4342             {
4343             case GE_EXPR:
4344               /* All unsigned values are >= 0, so we warn if extra warnings
4345                  are requested.  However, if OP0 is a constant that is
4346                  >= 0, the signedness of the comparison isn't an issue,
4347                  so suppress the warning.  */
4348               if (extra_warnings && !in_system_header
4349                   && ! (TREE_CODE (primop0) == INTEGER_CST
4350                         && ! TREE_OVERFLOW (convert (signed_type (type),
4351                                                      primop0))))
4352                 warning ("comparison of unsigned expression >= 0 is always true");
4353               value = boolean_true_node;
4354               break;
4355
4356             case LT_EXPR:
4357               if (extra_warnings && !in_system_header
4358                   && ! (TREE_CODE (primop0) == INTEGER_CST
4359                         && ! TREE_OVERFLOW (convert (signed_type (type),
4360                                                      primop0))))
4361                 warning ("comparison of unsigned expression < 0 is always false");
4362               value = boolean_false_node;
4363               break;
4364
4365             default:
4366               break;
4367             }
4368
4369           if (value != 0)
4370             {
4371               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
4372               if (TREE_SIDE_EFFECTS (primop0))
4373                 return build (COMPOUND_EXPR, TREE_TYPE (value),
4374                               primop0, value);
4375               return value;
4376             }
4377         }
4378     }
4379
4380   *op0_ptr = convert (type, primop0);
4381   *op1_ptr = convert (type, primop1);
4382
4383   *restype_ptr = boolean_type_node;
4384
4385   return 0;
4386 }
4387 \f
4388 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
4389    or validate its data type for an `if' or `while' statement or ?..: exp.
4390
4391    This preparation consists of taking the ordinary
4392    representation of an expression expr and producing a valid tree
4393    boolean expression describing whether expr is nonzero.  We could
4394    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
4395    but we optimize comparisons, &&, ||, and !.
4396
4397    The resulting type should always be `boolean_type_node'.  */
4398
4399 tree
4400 truthvalue_conversion (expr)
4401      tree expr;
4402 {
4403   if (TREE_CODE (expr) == ERROR_MARK)
4404     return expr;
4405
4406 #if 0 /* This appears to be wrong for C++.  */
4407   /* These really should return error_mark_node after 2.4 is stable.
4408      But not all callers handle ERROR_MARK properly.  */
4409   switch (TREE_CODE (TREE_TYPE (expr)))
4410     {
4411     case RECORD_TYPE:
4412       error ("struct type value used where scalar is required");
4413       return boolean_false_node;
4414
4415     case UNION_TYPE:
4416       error ("union type value used where scalar is required");
4417       return boolean_false_node;
4418
4419     case ARRAY_TYPE:
4420       error ("array type value used where scalar is required");
4421       return boolean_false_node;
4422
4423     default:
4424       break;
4425     }
4426 #endif /* 0 */
4427
4428   switch (TREE_CODE (expr))
4429     {
4430     case EQ_EXPR:
4431     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
4432     case TRUTH_ANDIF_EXPR:
4433     case TRUTH_ORIF_EXPR:
4434     case TRUTH_AND_EXPR:
4435     case TRUTH_OR_EXPR:
4436     case TRUTH_XOR_EXPR:
4437     case TRUTH_NOT_EXPR:
4438       TREE_TYPE (expr) = boolean_type_node;
4439       return expr;
4440
4441     case ERROR_MARK:
4442       return expr;
4443
4444     case INTEGER_CST:
4445       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
4446
4447     case REAL_CST:
4448       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
4449
4450     case ADDR_EXPR:
4451       /* If we are taking the address of a external decl, it might be zero
4452          if it is weak, so we cannot optimize.  */
4453       if (DECL_P (TREE_OPERAND (expr, 0))
4454           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
4455         break;
4456
4457       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
4458         return build (COMPOUND_EXPR, boolean_type_node,
4459                       TREE_OPERAND (expr, 0), boolean_true_node);
4460       else
4461         return boolean_true_node;
4462
4463     case COMPLEX_EXPR:
4464       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4465                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4466                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
4467                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
4468                               0);
4469
4470     case NEGATE_EXPR:
4471     case ABS_EXPR:
4472     case FLOAT_EXPR:
4473     case FFS_EXPR:
4474       /* These don't change whether an object is non-zero or zero.  */
4475       return truthvalue_conversion (TREE_OPERAND (expr, 0));
4476
4477     case LROTATE_EXPR:
4478     case RROTATE_EXPR:
4479       /* These don't change whether an object is zero or non-zero, but
4480          we can't ignore them if their second arg has side-effects.  */
4481       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4482         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
4483                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
4484       else
4485         return truthvalue_conversion (TREE_OPERAND (expr, 0));
4486
4487     case COND_EXPR:
4488       /* Distribute the conversion into the arms of a COND_EXPR.  */
4489       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
4490                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
4491                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
4492
4493     case CONVERT_EXPR:
4494       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
4495          since that affects how `default_conversion' will behave.  */
4496       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
4497           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
4498         break;
4499       /* fall through...  */
4500     case NOP_EXPR:
4501       /* If this is widening the argument, we can ignore it.  */
4502       if (TYPE_PRECISION (TREE_TYPE (expr))
4503           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
4504         return truthvalue_conversion (TREE_OPERAND (expr, 0));
4505       break;
4506
4507     case MINUS_EXPR:
4508       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
4509          this case.  */
4510       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
4511           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
4512         break;
4513       /* fall through...  */
4514     case BIT_XOR_EXPR:
4515       /* This and MINUS_EXPR can be changed into a comparison of the
4516          two objects.  */
4517       if (TREE_TYPE (TREE_OPERAND (expr, 0))
4518           == TREE_TYPE (TREE_OPERAND (expr, 1)))
4519         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
4520                                 TREE_OPERAND (expr, 1), 1);
4521       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
4522                               fold (build1 (NOP_EXPR,
4523                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
4524                                             TREE_OPERAND (expr, 1))), 1);
4525
4526     case BIT_AND_EXPR:
4527       if (integer_onep (TREE_OPERAND (expr, 1))
4528           && TREE_TYPE (expr) != boolean_type_node)
4529         /* Using convert here would cause infinite recursion.  */
4530         return build1 (NOP_EXPR, boolean_type_node, expr);
4531       break;
4532
4533     case MODIFY_EXPR:
4534       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
4535         warning ("suggest parentheses around assignment used as truth value");
4536       break;
4537
4538     default:
4539       break;
4540     }
4541
4542   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
4543     {
4544       tree tem = save_expr (expr);
4545       return (build_binary_op
4546               ((TREE_SIDE_EFFECTS (expr)
4547                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4548                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
4549                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
4550                0));
4551     }
4552
4553   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
4554 }
4555 \f
4556 #if !USE_CPPLIB
4557 /* Read the rest of a #-directive from input stream FINPUT.
4558    In normal use, the directive name and the white space after it
4559    have already been read, so they won't be included in the result.
4560    We allow for the fact that the directive line may contain
4561    a newline embedded within a character or string literal which forms
4562    a part of the directive.
4563
4564    The value is a string in a reusable buffer.  It remains valid
4565    only until the next time this function is called.
4566
4567    The terminating character ('\n' or EOF) is left in FINPUT for the
4568    caller to re-read.  */
4569
4570 char *
4571 get_directive_line (finput)
4572      register FILE *finput;
4573 {
4574   static char *directive_buffer = NULL;
4575   static unsigned buffer_length = 0;
4576   register char *p;
4577   register char *buffer_limit;
4578   register int looking_for = 0;
4579   register int char_escaped = 0;
4580
4581   if (buffer_length == 0)
4582     {
4583       directive_buffer = (char *)xmalloc (128);
4584       buffer_length = 128;
4585     }
4586
4587   buffer_limit = &directive_buffer[buffer_length];
4588
4589   for (p = directive_buffer; ; )
4590     {
4591       int c;
4592
4593       /* Make buffer bigger if it is full.  */
4594       if (p >= buffer_limit)
4595         {
4596           register unsigned bytes_used = (p - directive_buffer);
4597
4598           buffer_length *= 2;
4599           directive_buffer
4600             = (char *)xrealloc (directive_buffer, buffer_length);
4601           p = &directive_buffer[bytes_used];
4602           buffer_limit = &directive_buffer[buffer_length];
4603         }
4604
4605       c = getc (finput);
4606
4607       /* Discard initial whitespace.  */
4608       if ((c == ' ' || c == '\t') && p == directive_buffer)
4609         continue;
4610
4611       /* Detect the end of the directive.  */
4612       if (looking_for == 0
4613           && (c == '\n' || c == EOF))
4614         {
4615           ungetc (c, finput);
4616           c = '\0';
4617         }
4618
4619       *p++ = c;
4620
4621       if (c == 0)
4622         return directive_buffer;
4623
4624       /* Handle string and character constant syntax.  */
4625       if (looking_for)
4626         {
4627           if (looking_for == c && !char_escaped)
4628             looking_for = 0;    /* Found terminator... stop looking.  */
4629         }
4630       else
4631         if (c == '\'' || c == '"')
4632           looking_for = c;      /* Don't stop buffering until we see another
4633                                    one of these (or an EOF).  */
4634
4635       /* Handle backslash.  */
4636       char_escaped = (c == '\\' && ! char_escaped);
4637     }
4638 }
4639 #endif /* USE_CPPLIB */
4640 \f
4641 /* Make a variant type in the proper way for C/C++, propagating qualifiers
4642    down to the element type of an array.  */
4643
4644 tree
4645 c_build_qualified_type (type, type_quals)
4646      tree type;
4647      int type_quals;
4648 {
4649   /* A restrict-qualified pointer type must be a pointer to object or
4650      incomplete type.  Note that the use of POINTER_TYPE_P also allows
4651      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
4652      the C++ front-end also use POINTER_TYPE for pointer-to-member
4653      values, so even though it should be illegal to use `restrict'
4654      with such an entity we don't flag that here.  Thus, special case
4655      code for that case is required in the C++ front-end.  */
4656   if ((type_quals & TYPE_QUAL_RESTRICT)
4657       && (!POINTER_TYPE_P (type)
4658           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
4659     {
4660       error ("invalid use of `restrict'");
4661       type_quals &= ~TYPE_QUAL_RESTRICT;
4662     }
4663
4664   if (TREE_CODE (type) == ARRAY_TYPE)
4665     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
4666                                                      type_quals),
4667                              TYPE_DOMAIN (type));
4668   return build_qualified_type (type, type_quals);
4669 }
4670
4671 /* Apply the TYPE_QUALS to the new DECL.  */
4672
4673 void
4674 c_apply_type_quals_to_decl (type_quals, decl)
4675      int type_quals;
4676      tree decl;
4677 {
4678   if ((type_quals & TYPE_QUAL_CONST)
4679       || (TREE_TYPE (decl)
4680           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
4681     TREE_READONLY (decl) = 1;
4682   if (type_quals & TYPE_QUAL_VOLATILE)
4683     {
4684       TREE_SIDE_EFFECTS (decl) = 1;
4685       TREE_THIS_VOLATILE (decl) = 1;
4686     }
4687   if (type_quals & TYPE_QUAL_RESTRICT)
4688     {
4689       if (!TREE_TYPE (decl)
4690           || !POINTER_TYPE_P (TREE_TYPE (decl))
4691           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
4692         error ("invalid use of `restrict'");
4693       else if (flag_strict_aliasing)
4694         {
4695           /* No two restricted pointers can point at the same thing.
4696              However, a restricted pointer can point at the same thing
4697              as an unrestricted pointer, if that unrestricted pointer
4698              is based on the restricted pointer.  So, we make the
4699              alias set for the restricted pointer a subset of the
4700              alias set for the type pointed to by the type of the
4701              decl.  */
4702
4703           HOST_WIDE_INT pointed_to_alias_set
4704             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
4705
4706           if (pointed_to_alias_set == 0)
4707             /* It's not legal to make a subset of alias set zero.  */
4708             ;
4709           else
4710             {
4711               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
4712               record_alias_subset  (pointed_to_alias_set,
4713                                     DECL_POINTER_ALIAS_SET (decl));
4714             }
4715         }
4716     }
4717 }
4718
4719
4720 /* Return the typed-based alias set for T, which may be an expression
4721    or a type.  Return -1 if we don't do anything special.  */
4722
4723 HOST_WIDE_INT
4724 lang_get_alias_set (t)
4725      tree t;
4726 {
4727   tree u;
4728
4729   /* Permit type-punning when accessing a union, provided the access
4730      is directly through the union.  For example, this code does not
4731      permit taking the address of a union member and then storing
4732      through it.  Even the type-punning allowed here is a GCC
4733      extension, albeit a common and useful one; the C standard says
4734      that such accesses have implementation-defined behavior.  */
4735   for (u = t;
4736        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
4737        u = TREE_OPERAND (u, 0))
4738     if (TREE_CODE (u) == COMPONENT_REF
4739         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
4740       return 0;
4741
4742   /* If this is a char *, the ANSI C standard says it can alias
4743      anything.  Note that all references need do this.  */
4744   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
4745       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
4746       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
4747     return 0;
4748
4749   /* That's all the expressions we handle specially.  */
4750   if (! TYPE_P (t))
4751     return -1;
4752
4753   /* The C standard specifically allows aliasing between signed and
4754      unsigned variants of the same type.  We treat the signed
4755      variant as canonical.  */
4756   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
4757     {
4758       tree t1 = signed_type (t);
4759
4760       /* t1 == t can happen for boolean nodes which are always unsigned.  */
4761       if (t1 != t)
4762         return get_alias_set (t1);
4763     }
4764   else if (POINTER_TYPE_P (t))
4765     {
4766       tree t1;
4767
4768       /* Unfortunately, there is no canonical form of a pointer type.
4769          In particular, if we have `typedef int I', then `int *', and
4770          `I *' are different types.  So, we have to pick a canonical
4771          representative.  We do this below.
4772
4773          Technically, this approach is actually more conservative that
4774          it needs to be.  In particular, `const int *' and `int *'
4775          chould be in different alias sets, according to the C and C++
4776          standard, since their types are not the same, and so,
4777          technically, an `int **' and `const int **' cannot point at
4778          the same thing.
4779
4780          But, the standard is wrong.  In particular, this code is
4781          legal C++:
4782
4783             int *ip;
4784             int **ipp = &ip;
4785             const int* const* cipp = &ip;
4786
4787          And, it doesn't make sense for that to be legal unless you
4788          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
4789          the pointed-to types.  This issue has been reported to the
4790          C++ committee.  */
4791       t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t));
4792       t1 = ((TREE_CODE (t) == POINTER_TYPE)
4793            ? build_pointer_type (t1) : build_reference_type (t1));
4794       if (t1 != t)
4795         return get_alias_set (t1);
4796     }
4797   /* It's not yet safe to use alias sets for classes in C++ because
4798      the TYPE_FIELDs list for a class doesn't mention base classes.  */
4799   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
4800     return 0;
4801
4802   return -1;
4803 }
4804
4805 /* Build tree nodes and builtin functions common to both C and C++ language
4806    frontends.  */
4807
4808 void
4809 c_common_nodes_and_builtins ()
4810 {
4811   tree temp;
4812   tree memcpy_ftype, memset_ftype, strlen_ftype;
4813   tree bzero_ftype, bcmp_ftype, puts_ftype, printf_ftype;
4814   tree endlink, int_endlink, double_endlink, unsigned_endlink;
4815   tree sizetype_endlink;
4816   tree ptr_ftype, ptr_ftype_unsigned;
4817   tree void_ftype_any, void_ftype_int, int_ftype_any, sizet_ftype_any;
4818   tree double_ftype_double, double_ftype_double_double;
4819   tree float_ftype_float, ldouble_ftype_ldouble;
4820   tree int_ftype_cptr_cptr_sizet;
4821   tree int_ftype_string_string, string_ftype_ptr_ptr;
4822   tree long_ftype_long;
4823   tree longlong_ftype_longlong;
4824   /* Either char* or void*.  */
4825   tree traditional_ptr_type_node;
4826   /* Either const char* or const void*.  */
4827   tree traditional_cptr_type_node;
4828   tree traditional_len_type_node;
4829   tree traditional_len_endlink;
4830   tree va_list_ref_type_node;
4831   tree va_list_arg_type_node;
4832
4833   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
4834                         va_list_type_node));
4835
4836   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
4837                         ptrdiff_type_node));
4838
4839   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
4840                         sizetype));
4841
4842   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
4843     {
4844       va_list_arg_type_node = va_list_ref_type_node =
4845         build_pointer_type (TREE_TYPE (va_list_type_node));
4846     }
4847   else
4848     {
4849       va_list_arg_type_node = va_list_type_node;
4850       va_list_ref_type_node = build_reference_type (va_list_type_node);
4851     }
4852
4853   endlink = void_list_node;
4854   int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
4855   double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
4856   unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
4857
4858   ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
4859   ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
4860   sizetype_endlink = tree_cons (NULL_TREE, TYPE_DOMAIN (sizetype), endlink);
4861   /* We realloc here because sizetype could be int or unsigned.  S'ok.  */
4862   ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
4863
4864   sizet_ftype_any = build_function_type (sizetype, NULL_TREE);
4865   int_ftype_any = build_function_type (integer_type_node, NULL_TREE);
4866   void_ftype_any = build_function_type (void_type_node, NULL_TREE);
4867   void_ftype = build_function_type (void_type_node, endlink);
4868   void_ftype_int = build_function_type (void_type_node, int_endlink);
4869   void_ftype_ptr
4870     = build_function_type (void_type_node,
4871                            tree_cons (NULL_TREE, ptr_type_node, endlink));
4872
4873   float_ftype_float
4874     = build_function_type (float_type_node,
4875                            tree_cons (NULL_TREE, float_type_node, endlink));
4876
4877   double_ftype_double
4878     = build_function_type (double_type_node, double_endlink);
4879
4880   ldouble_ftype_ldouble
4881     = build_function_type (long_double_type_node,
4882                            tree_cons (NULL_TREE, long_double_type_node,
4883                                       endlink));
4884
4885   double_ftype_double_double
4886     = build_function_type (double_type_node,
4887                            tree_cons (NULL_TREE, double_type_node,
4888                                       double_endlink));
4889
4890   int_ftype_int
4891     = build_function_type (integer_type_node, int_endlink);
4892
4893   long_ftype_long
4894     = build_function_type (long_integer_type_node,
4895                            tree_cons (NULL_TREE, long_integer_type_node,
4896                                       endlink));
4897
4898   longlong_ftype_longlong
4899     = build_function_type (long_long_integer_type_node,
4900                            tree_cons (NULL_TREE, long_long_integer_type_node,
4901                                       endlink));
4902
4903   int_ftype_cptr_cptr_sizet
4904     = build_function_type (integer_type_node,
4905                            tree_cons (NULL_TREE, const_ptr_type_node,
4906                                       tree_cons (NULL_TREE, const_ptr_type_node,
4907                                                  tree_cons (NULL_TREE,
4908                                                             sizetype,
4909                                                             endlink))));
4910
4911   void_zero_node = build_int_2 (0, 0);
4912   TREE_TYPE (void_zero_node) = void_type_node;
4913
4914   /* Prototype for strcpy.  */
4915   string_ftype_ptr_ptr
4916     = build_function_type (string_type_node,
4917                            tree_cons (NULL_TREE, string_type_node,
4918                                       tree_cons (NULL_TREE,
4919                                                  const_string_type_node,
4920                                                  endlink)));
4921
4922   traditional_len_type_node = ((flag_traditional &&
4923                                 c_language != clk_cplusplus)
4924                                ? integer_type_node : sizetype);
4925   traditional_len_endlink = tree_cons (NULL_TREE, traditional_len_type_node,
4926                                        endlink);
4927
4928   /* Prototype for strcmp.  */
4929   int_ftype_string_string
4930     = build_function_type (integer_type_node,
4931                            tree_cons (NULL_TREE, const_string_type_node,
4932                                       tree_cons (NULL_TREE,
4933                                                  const_string_type_node,
4934                                                  endlink)));
4935
4936   /* Prototype for strlen.  */
4937   strlen_ftype
4938     = build_function_type (traditional_len_type_node,
4939                            tree_cons (NULL_TREE, const_string_type_node,
4940                                       endlink));
4941
4942   traditional_ptr_type_node = ((flag_traditional &&
4943                                 c_language != clk_cplusplus)
4944                                ? string_type_node : ptr_type_node);
4945   traditional_cptr_type_node = ((flag_traditional &&
4946                                  c_language != clk_cplusplus)
4947                                ? const_string_type_node : const_ptr_type_node);
4948
4949   /* Prototype for memcpy.  */
4950   memcpy_ftype
4951     = build_function_type (traditional_ptr_type_node,
4952                            tree_cons (NULL_TREE, ptr_type_node,
4953                                       tree_cons (NULL_TREE, const_ptr_type_node,
4954                                                  sizetype_endlink)));
4955
4956   /* Prototype for memset.  */
4957   memset_ftype
4958     = build_function_type (traditional_ptr_type_node,
4959                            tree_cons (NULL_TREE, ptr_type_node,
4960                                       tree_cons (NULL_TREE, integer_type_node,
4961                                                  tree_cons (NULL_TREE,
4962                                                             sizetype,
4963                                                             endlink))));
4964
4965   /* Prototype for bzero.  */
4966   bzero_ftype
4967     = build_function_type (void_type_node,
4968                            tree_cons (NULL_TREE, traditional_ptr_type_node,
4969                                       traditional_len_endlink));
4970
4971   /* Prototype for bcmp.  */
4972   bcmp_ftype
4973     = build_function_type (integer_type_node,
4974                            tree_cons (NULL_TREE, traditional_cptr_type_node,
4975                                       tree_cons (NULL_TREE,
4976                                                  traditional_cptr_type_node,
4977                                                  traditional_len_endlink)));
4978
4979   /* Prototype for puts.  */
4980   puts_ftype
4981     = build_function_type (integer_type_node,
4982                            tree_cons (NULL_TREE, const_string_type_node,
4983                                       endlink));
4984
4985   /* Prototype for printf.  */
4986   printf_ftype
4987     = build_function_type (integer_type_node,
4988                            tree_cons (NULL_TREE, const_string_type_node,
4989                                       NULL_TREE));
4990
4991   builtin_function ("__builtin_constant_p", default_function_type,
4992                     BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL_PTR);
4993
4994   builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
4995                     BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
4996
4997   builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
4998                     BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
4999
5000   builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
5001                     BUILT_IN_ALLOCA, BUILT_IN_NORMAL, "alloca");
5002   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS,
5003                     BUILT_IN_NORMAL, NULL_PTR);
5004   /* Define alloca, ffs as builtins.
5005      Declare _exit just to mark it as volatile.  */
5006   if (! flag_no_builtin && ! flag_no_nonansi_builtin)
5007     {
5008 #ifndef SMALL_STACK
5009       temp = builtin_function ("alloca", ptr_ftype_sizetype,
5010                                BUILT_IN_ALLOCA, BUILT_IN_NORMAL, NULL_PTR);
5011       /* Suppress error if redefined as a non-function.  */
5012       DECL_BUILT_IN_NONANSI (temp) = 1;
5013 #endif
5014       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS,
5015                                BUILT_IN_NORMAL, NULL_PTR);
5016       /* Suppress error if redefined as a non-function.  */
5017       DECL_BUILT_IN_NONANSI (temp) = 1;
5018       temp = builtin_function ("_exit", void_ftype_int,
5019                                0, NOT_BUILT_IN, NULL_PTR);
5020       TREE_THIS_VOLATILE (temp) = 1;
5021       TREE_SIDE_EFFECTS (temp) = 1;
5022       /* Suppress error if redefined as a non-function.  */
5023       DECL_BUILT_IN_NONANSI (temp) = 1;
5024
5025       /* The system prototypes for these functions have many
5026          variations, so don't specify parameters to avoid conflicts.
5027          The expand_* functions check the argument types anyway.  */
5028       temp = builtin_function ("bzero", void_ftype_any,
5029                                BUILT_IN_BZERO, BUILT_IN_NORMAL, NULL_PTR);
5030       DECL_BUILT_IN_NONANSI (temp) = 1;
5031       temp = builtin_function ("bcmp", int_ftype_any,
5032                                BUILT_IN_BCMP, BUILT_IN_NORMAL, NULL_PTR);
5033       DECL_BUILT_IN_NONANSI (temp) = 1;
5034     }
5035
5036   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS,
5037                     BUILT_IN_NORMAL, NULL_PTR);
5038   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
5039                     BUILT_IN_NORMAL, NULL_PTR);
5040   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
5041                     BUILT_IN_NORMAL, NULL_PTR);
5042   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5043                     BUILT_IN_NORMAL, NULL_PTR);
5044   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
5045                     BUILT_IN_NORMAL, NULL_PTR);
5046   builtin_function ("__builtin_llabs", longlong_ftype_longlong, BUILT_IN_LLABS,
5047                     BUILT_IN_NORMAL, NULL_PTR);
5048   builtin_function ("__builtin_saveregs", ptr_ftype, BUILT_IN_SAVEREGS,
5049                     BUILT_IN_NORMAL, NULL_PTR);
5050   builtin_function ("__builtin_classify_type", default_function_type,
5051                     BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL_PTR);
5052   builtin_function ("__builtin_next_arg", ptr_ftype, BUILT_IN_NEXT_ARG,
5053                     BUILT_IN_NORMAL, NULL_PTR);
5054   builtin_function ("__builtin_args_info", int_ftype_int, BUILT_IN_ARGS_INFO,
5055                     BUILT_IN_NORMAL, NULL_PTR);
5056   builtin_function ("__builtin_setjmp",
5057                     build_function_type (integer_type_node,
5058                                          tree_cons (NULL_TREE, ptr_type_node,
5059                                                     endlink)),
5060                     BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL_PTR);
5061   builtin_function ("__builtin_longjmp",
5062                     build_function_type (void_type_node,
5063                                          tree_cons (NULL_TREE, ptr_type_node,
5064                                                     tree_cons (NULL_TREE,
5065                                                                integer_type_node,
5066                                                                endlink))),
5067                     BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL_PTR);
5068   builtin_function ("__builtin_trap", void_ftype, BUILT_IN_TRAP,
5069                     BUILT_IN_NORMAL, NULL_PTR);
5070
5071   /* ISO C99 IEEE Unordered compares.  */
5072   builtin_function ("__builtin_isgreater", default_function_type,
5073                     BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL_PTR);
5074   builtin_function ("__builtin_isgreaterequal", default_function_type,
5075                     BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL_PTR);
5076   builtin_function ("__builtin_isless", default_function_type,
5077                     BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL_PTR);
5078   builtin_function ("__builtin_islessequal", default_function_type,
5079                     BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL_PTR);
5080   builtin_function ("__builtin_islessgreater", default_function_type,
5081                     BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL_PTR);
5082   builtin_function ("__builtin_isunordered", default_function_type,
5083                     BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL_PTR);
5084
5085   /* Untyped call and return.  */
5086   builtin_function ("__builtin_apply_args", ptr_ftype,
5087                     BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL_PTR);
5088
5089   temp = tree_cons (NULL_TREE,
5090                     build_pointer_type (build_function_type (void_type_node,
5091                                                              NULL_TREE)),
5092                     tree_cons (NULL_TREE,
5093                                ptr_type_node,
5094                                tree_cons (NULL_TREE,
5095                                           sizetype,
5096                                           endlink)));
5097   builtin_function ("__builtin_apply",
5098                     build_function_type (ptr_type_node, temp),
5099                     BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL_PTR);
5100   builtin_function ("__builtin_return", void_ftype_ptr,
5101                     BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL_PTR);
5102
5103   /* Support for varargs.h and stdarg.h.  */
5104   builtin_function ("__builtin_varargs_start",
5105                     build_function_type (void_type_node,
5106                                          tree_cons (NULL_TREE,
5107                                                     va_list_ref_type_node,
5108                                                     endlink)),
5109                     BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL_PTR);
5110
5111   builtin_function ("__builtin_stdarg_start",
5112                     build_function_type (void_type_node,
5113                                          tree_cons (NULL_TREE,
5114                                                     va_list_ref_type_node,
5115                                                     NULL_TREE)),
5116                     BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL_PTR);
5117
5118   builtin_function ("__builtin_va_end",
5119                     build_function_type (void_type_node,
5120                                          tree_cons (NULL_TREE,
5121                                                     va_list_ref_type_node,
5122                                                     endlink)),
5123                     BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL_PTR);
5124
5125   builtin_function ("__builtin_va_copy",
5126                     build_function_type (void_type_node,
5127                                          tree_cons (NULL_TREE,
5128                                                     va_list_ref_type_node,
5129                                                     tree_cons (NULL_TREE,
5130                                                       va_list_arg_type_node,
5131                                                       endlink))),
5132                     BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL_PTR);
5133
5134   /* ??? Ought to be `T __builtin_expect(T, T)' for any type T.  */
5135   builtin_function ("__builtin_expect",
5136                     build_function_type (long_integer_type_node,
5137                                          tree_cons (NULL_TREE,
5138                                                     long_integer_type_node,
5139                                                     tree_cons (NULL_TREE,
5140                                                         long_integer_type_node,
5141                                                         endlink))),
5142                     BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL_PTR);
5143
5144   /* Currently under experimentation.  */
5145   builtin_function ("__builtin_memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
5146                     BUILT_IN_NORMAL, "memcpy");
5147   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
5148                     BUILT_IN_MEMCMP, BUILT_IN_NORMAL, "memcmp");
5149   builtin_function ("__builtin_memset", memset_ftype,
5150                     BUILT_IN_MEMSET, BUILT_IN_NORMAL, "memset");
5151   builtin_function ("__builtin_bzero", bzero_ftype,
5152                     BUILT_IN_BZERO, BUILT_IN_NORMAL, "bzero");
5153   builtin_function ("__builtin_bcmp", bcmp_ftype,
5154                     BUILT_IN_BCMP, BUILT_IN_NORMAL, "bcmp");
5155   builtin_function ("__builtin_strcmp", int_ftype_string_string,
5156                     BUILT_IN_STRCMP, BUILT_IN_NORMAL, "strcmp");
5157   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
5158                     BUILT_IN_STRCPY, BUILT_IN_NORMAL, "strcpy");
5159   builtin_function ("__builtin_strlen", strlen_ftype,
5160                     BUILT_IN_STRLEN, BUILT_IN_NORMAL, "strlen");
5161   builtin_function ("__builtin_sqrtf", float_ftype_float,
5162                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtf");
5163   builtin_function ("__builtin_fsqrt", double_ftype_double,
5164                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrt");
5165   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
5166                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtl");
5167   builtin_function ("__builtin_sinf", float_ftype_float,
5168                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinf");
5169   builtin_function ("__builtin_sin", double_ftype_double,
5170                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sin");
5171   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
5172                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinl");
5173   builtin_function ("__builtin_cosf", float_ftype_float,
5174                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosf");
5175   builtin_function ("__builtin_cos", double_ftype_double,
5176                     BUILT_IN_COS, BUILT_IN_NORMAL, "cos");
5177   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
5178                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosl");
5179   built_in_decls[BUILT_IN_PUTCHAR] =
5180     builtin_function ("__builtin_putchar", int_ftype_int,
5181                       BUILT_IN_PUTCHAR, BUILT_IN_NORMAL, "putchar");
5182   built_in_decls[BUILT_IN_PUTS] =
5183     builtin_function ("__builtin_puts", puts_ftype,
5184                       BUILT_IN_PUTS, BUILT_IN_NORMAL, "puts");
5185   builtin_function ("__builtin_printf", printf_ftype,
5186                     BUILT_IN_PRINTF, BUILT_IN_FRONTEND, "printf");
5187   /* We declare these without argument so that the initial declaration
5188      for these identifiers is a builtin.  That allows us to redeclare
5189      them later with argument without worrying about the explicit
5190      declarations in stdio.h being taken as the initial declaration.
5191      Also, save the _DECL for these so we can use them later.  */
5192   built_in_decls[BUILT_IN_FWRITE] =
5193     builtin_function ("__builtin_fwrite", sizet_ftype_any,
5194                       BUILT_IN_FWRITE, BUILT_IN_NORMAL, "fwrite");
5195   built_in_decls[BUILT_IN_FPUTC] =
5196     builtin_function ("__builtin_fputc", int_ftype_any,
5197                       BUILT_IN_FPUTC, BUILT_IN_NORMAL, "fputc");
5198   built_in_decls[BUILT_IN_FPUTS] =
5199     builtin_function ("__builtin_fputs", int_ftype_any,
5200                       BUILT_IN_FPUTS, BUILT_IN_NORMAL, "fputs");
5201
5202   if (! flag_no_builtin)
5203     {
5204       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS,
5205                         BUILT_IN_NORMAL, NULL_PTR);
5206       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS,
5207                         BUILT_IN_NORMAL, NULL_PTR);
5208       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS,
5209                         BUILT_IN_NORMAL, NULL_PTR);
5210       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
5211                         BUILT_IN_NORMAL, NULL_PTR);
5212       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS,
5213                         BUILT_IN_NORMAL, NULL_PTR);
5214       if (flag_isoc99 || ! flag_no_nonansi_builtin)
5215         builtin_function ("llabs", longlong_ftype_longlong, BUILT_IN_LLABS,
5216                           BUILT_IN_NORMAL, NULL_PTR);
5217       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
5218                         BUILT_IN_NORMAL, NULL_PTR);
5219       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
5220                         BUILT_IN_NORMAL, NULL_PTR);
5221       builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET,
5222                         BUILT_IN_NORMAL, NULL_PTR);
5223       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
5224                         BUILT_IN_NORMAL, NULL_PTR);
5225       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
5226                         BUILT_IN_NORMAL, NULL_PTR);
5227       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN,
5228                         BUILT_IN_NORMAL, NULL_PTR);
5229       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT,
5230                         BUILT_IN_NORMAL, NULL_PTR);
5231       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT,
5232                         BUILT_IN_NORMAL, NULL_PTR);
5233       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
5234                         BUILT_IN_NORMAL, NULL_PTR);
5235       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN,
5236                         BUILT_IN_NORMAL, NULL_PTR);
5237       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN,
5238                         BUILT_IN_NORMAL, NULL_PTR);
5239       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN,
5240                         BUILT_IN_NORMAL, NULL_PTR);
5241       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS,
5242                         BUILT_IN_NORMAL, NULL_PTR);
5243       builtin_function ("cos", double_ftype_double, BUILT_IN_COS,
5244                         BUILT_IN_NORMAL, NULL_PTR);
5245       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS,
5246                         BUILT_IN_NORMAL, NULL_PTR);
5247       builtin_function ("printf", printf_ftype, BUILT_IN_PRINTF,
5248                         BUILT_IN_FRONTEND, NULL_PTR);
5249       /* We declare these without argument so that the initial
5250          declaration for these identifiers is a builtin.  That allows
5251          us to redeclare them later with argument without worrying
5252          about the explicit declarations in stdio.h being taken as the
5253          initial declaration.  */
5254       builtin_function ("fputc", int_ftype_any, BUILT_IN_FPUTC,
5255                         BUILT_IN_NORMAL, NULL_PTR);
5256       builtin_function ("fputs", int_ftype_any, BUILT_IN_FPUTS,
5257                         BUILT_IN_NORMAL, NULL_PTR);
5258
5259       /* Declare these functions volatile
5260          to avoid spurious "control drops through" warnings.  */
5261       temp = builtin_function ("abort",
5262                                ((c_language == clk_cplusplus)
5263                                 ? void_ftype : void_ftype_any),
5264                                0, NOT_BUILT_IN, NULL_PTR);
5265       TREE_THIS_VOLATILE (temp) = 1;
5266       TREE_SIDE_EFFECTS (temp) = 1;
5267
5268       temp = builtin_function ("exit",
5269                                ((c_language == clk_cplusplus)
5270                                 ? void_ftype_int : void_ftype_any),
5271                                0, NOT_BUILT_IN, NULL_PTR);
5272       TREE_THIS_VOLATILE (temp) = 1;
5273       TREE_SIDE_EFFECTS (temp) = 1;
5274     }
5275
5276 #if 0
5277   /* Support for these has not been written in either expand_builtin
5278      or build_function_call.  */
5279   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV,
5280                     BUILT_IN_NORMAL, NULL_PTR);
5281   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV,
5282                     BUILT_IN_NORMAL, NULL_PTR);
5283   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
5284                     BUILT_IN_NORMAL, NULL_PTR);
5285   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
5286                     BUILT_IN_NORMAL, NULL_PTR);
5287   builtin_function ("__builtin_fmod", double_ftype_double_double,
5288                     BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL_PTR);
5289   builtin_function ("__builtin_frem", double_ftype_double_double,
5290                     BUILT_IN_FREM, BUILT_IN_NORMAL, NULL_PTR);
5291   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
5292                     BUILT_IN_NORMAL, NULL_PTR);
5293   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
5294                     BUILT_IN_NORMAL, NULL_PTR);
5295 #endif
5296
5297   main_identifier_node = get_identifier ("main");
5298
5299   /* ??? Perhaps there's a better place to do this.  But it is related
5300      to __builtin_va_arg, so it isn't that off-the-wall.  */
5301   lang_type_promotes_to = simple_type_promotes_to;
5302 }
5303
5304 tree
5305 build_va_arg (expr, type)
5306      tree expr, type;
5307 {
5308   return build1 (VA_ARG_EXPR, type, expr);
5309 }
5310 \f
5311 /* Given a type, apply default promotions wrt unnamed function arguments
5312    and return the new type.  Return NULL_TREE if no change.  */
5313 /* ??? There is a function of the same name in the C++ front end that
5314    does something similar, but is more thorough and does not return NULL
5315    if no change.  We could perhaps share code, but it would make the
5316    self_promoting_type property harder to identify.  */
5317
5318 tree
5319 simple_type_promotes_to (type)
5320      tree type;
5321 {
5322   if (TYPE_MAIN_VARIANT (type) == float_type_node)
5323     return double_type_node;
5324
5325   if (C_PROMOTING_INTEGER_TYPE_P (type))
5326     {
5327       /* Traditionally, unsignedness is preserved in default promotions.
5328          Also preserve unsignedness if not really getting any wider.  */
5329       if (TREE_UNSIGNED (type)
5330           && (flag_traditional
5331               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
5332         return unsigned_type_node;
5333       return integer_type_node;
5334     }
5335
5336   return NULL_TREE;
5337 }
5338
5339 /* Return 1 if PARMS specifies a fixed number of parameters
5340    and none of their types is affected by default promotions.  */
5341
5342 int
5343 self_promoting_args_p (parms)
5344      tree parms;
5345 {
5346   register tree t;
5347   for (t = parms; t; t = TREE_CHAIN (t))
5348     {
5349       register tree type = TREE_VALUE (t);
5350
5351       if (TREE_CHAIN (t) == 0 && type != void_type_node)
5352         return 0;
5353
5354       if (type == 0)
5355         return 0;
5356
5357       if (TYPE_MAIN_VARIANT (type) == float_type_node)
5358         return 0;
5359
5360       if (C_PROMOTING_INTEGER_TYPE_P (type))
5361         return 0;
5362     }
5363   return 1;
5364 }
5365
5366 /* Recognize certain built-in functions so we can make tree-codes
5367    other than CALL_EXPR.  We do this when it enables fold-const.c
5368    to do something useful.  */
5369 /* ??? By rights this should go in builtins.c, but only C and C++
5370    implement build_{binary,unary}_op.  Not exactly sure what bits
5371    of functionality are actually needed from those functions, or
5372    where the similar functionality exists in the other front ends.  */
5373
5374 tree
5375 expand_tree_builtin (function, params, coerced_params)
5376      tree function, params, coerced_params;
5377 {
5378   enum tree_code code;
5379
5380   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
5381     return NULL_TREE;
5382
5383   switch (DECL_FUNCTION_CODE (function))
5384     {
5385     case BUILT_IN_ABS:
5386     case BUILT_IN_LABS:
5387     case BUILT_IN_LLABS:
5388     case BUILT_IN_FABS:
5389       if (coerced_params == 0)
5390         return integer_zero_node;
5391       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
5392
5393     case BUILT_IN_ISGREATER:
5394       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5395         code = UNLE_EXPR;
5396       else
5397         code = LE_EXPR;
5398       goto unordered_cmp;
5399
5400     case BUILT_IN_ISGREATEREQUAL:
5401       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5402         code = UNLT_EXPR;
5403       else
5404         code = LT_EXPR;
5405       goto unordered_cmp;
5406
5407     case BUILT_IN_ISLESS:
5408       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5409         code = UNGE_EXPR;
5410       else
5411         code = GE_EXPR;
5412       goto unordered_cmp;
5413
5414     case BUILT_IN_ISLESSEQUAL:
5415       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5416         code = UNGT_EXPR;
5417       else
5418         code = GT_EXPR;
5419       goto unordered_cmp;
5420
5421     case BUILT_IN_ISLESSGREATER:
5422       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
5423         code = UNEQ_EXPR;
5424       else
5425         code = EQ_EXPR;
5426       goto unordered_cmp;
5427
5428     case BUILT_IN_ISUNORDERED:
5429       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
5430         return integer_zero_node;
5431       code = UNORDERED_EXPR;
5432       goto unordered_cmp;
5433
5434     unordered_cmp:
5435       {
5436         tree arg0, arg1;
5437
5438         if (params == 0
5439             || TREE_CHAIN (params) == 0)
5440           {
5441             error ("too few arguments to function `%s'",
5442                    IDENTIFIER_POINTER (DECL_NAME (function)));
5443             return error_mark_node;
5444           }
5445         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
5446           {
5447             error ("too many arguments to function `%s'",
5448                    IDENTIFIER_POINTER (DECL_NAME (function)));
5449             return error_mark_node;
5450           }
5451
5452         arg0 = TREE_VALUE (params);
5453         arg1 = TREE_VALUE (TREE_CHAIN (params));
5454         arg0 = build_binary_op (code, arg0, arg1, 0);
5455         if (code != UNORDERED_EXPR)
5456           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
5457         return arg0;
5458       }
5459       break;
5460
5461     default:
5462       break;
5463     }
5464
5465   return NULL_TREE;
5466 }
5467
5468 /* Returns non-zero if CODE is the code for a statement.  */
5469
5470 int
5471 statement_code_p (code)
5472      enum tree_code code;
5473 {
5474   switch (code)
5475     {
5476     case EXPR_STMT:
5477     case COMPOUND_STMT:
5478     case DECL_STMT:
5479     case IF_STMT:
5480     case FOR_STMT:
5481     case WHILE_STMT:
5482     case DO_STMT:
5483     case RETURN_STMT:
5484     case BREAK_STMT:
5485     case CONTINUE_STMT:
5486     case SCOPE_STMT:
5487     case SWITCH_STMT:
5488     case GOTO_STMT:
5489     case LABEL_STMT:
5490     case ASM_STMT:
5491     case CASE_LABEL:
5492       return 1;
5493
5494     default:
5495       if (lang_statement_code_p)
5496         return (*lang_statement_code_p) (code);
5497       return 0;
5498     }
5499 }
5500
5501 /* Walk the statemen tree, rooted at *tp.  Apply FUNC to all the
5502    sub-trees of *TP in a pre-order traversal.  FUNC is called with the
5503    DATA and the address of each sub-tree.  If FUNC returns a non-NULL
5504    value, the traversal is aborted, and the value returned by FUNC is
5505    returned.  If FUNC sets WALK_SUBTREES to zero, then the subtrees of
5506    the node being visited are not walked.
5507
5508    We don't need a without_duplicates variant of this one because the
5509    statement tree is a tree, not a graph.  */
5510
5511 tree
5512 walk_stmt_tree (tp, func, data)
5513      tree *tp;
5514      walk_tree_fn func;
5515      void *data;
5516 {
5517   enum tree_code code;
5518   int walk_subtrees;
5519   tree result;
5520   int i, len;
5521
5522 #define WALK_SUBTREE(NODE)                              \
5523   do                                                    \
5524     {                                                   \
5525       result = walk_stmt_tree (&(NODE), func, data);    \
5526       if (result)                                       \
5527         return result;                                  \
5528     }                                                   \
5529   while (0)
5530
5531   /* Skip empty subtrees.  */
5532   if (!*tp)
5533     return NULL_TREE;
5534
5535   /* Skip subtrees below non-statement nodes.  */
5536   if (!statement_code_p (TREE_CODE (*tp)))
5537     return NULL_TREE;
5538
5539   /* Call the function.  */
5540   walk_subtrees = 1;
5541   result = (*func) (tp, &walk_subtrees, data);
5542
5543   /* If we found something, return it.  */
5544   if (result)
5545     return result;
5546
5547   /* Even if we didn't, FUNC may have decided that there was nothing
5548      interesting below this point in the tree.  */
5549   if (!walk_subtrees)
5550     return NULL_TREE;
5551
5552   /* FUNC may have modified the tree, recheck that we're looking at a
5553      statement node.  */
5554   code = TREE_CODE (*tp);
5555   if (!statement_code_p (code))
5556     return NULL_TREE;
5557
5558   /* Walk over all the sub-trees of this operand.  Statement nodes never
5559      contain RTL, and we needn't worry about TARGET_EXPRs.  */
5560   len = TREE_CODE_LENGTH (code);
5561
5562   /* Go through the subtrees.  We need to do this in forward order so
5563      that the scope of a FOR_EXPR is handled properly.  */
5564   for (i = 0; i < len; ++i)
5565     WALK_SUBTREE (TREE_OPERAND (*tp, i));
5566
5567   /* Finally visit the chain.  This can be tail-recursion optimized if
5568      we write it this way.  */
5569   return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
5570
5571 #undef WALK_SUBTREE
5572 }
5573
5574 /* Used to compare case labels.  K1 and K2 are actually tree nodes
5575    representing case labels, or NULL_TREE for a `default' label.
5576    Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
5577    K2, and 0 if K1 and K2 are equal.  */
5578
5579 int
5580 case_compare (k1, k2)
5581      splay_tree_key k1;
5582      splay_tree_key k2;
5583 {
5584   /* Consider a NULL key (such as arises with a `default' label) to be
5585      smaller than anything else.  */
5586   if (!k1)
5587     return k2 ? -1 : 0;
5588   else if (!k2)
5589     return k1 ? 1 : 0;
5590
5591   return tree_int_cst_compare ((tree) k1, (tree) k2);
5592 }
5593
5594 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
5595    LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
5596    actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
5597    case label was declared using the usual C/C++ syntax, rather than
5598    the GNU case range extension.  CASES is a tree containing all the
5599    case ranges processed so far; COND is the condition for the
5600    switch-statement itself.  Returns the CASE_LABEL created, or
5601    ERROR_MARK_NODE if no CASE_LABEL is created.  */
5602
5603 tree
5604 c_add_case_label (cases, cond, low_value, high_value)
5605      splay_tree cases;
5606      tree cond;
5607      tree low_value;
5608      tree high_value;
5609 {
5610   tree type;
5611   tree label;
5612   tree case_label;
5613   splay_tree_node node;
5614
5615   /* Create the LABEL_DECL itself.  */
5616   label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5617   DECL_CONTEXT (label) = current_function_decl;
5618
5619   /* If there was an error processing the switch condition, bail now
5620      before we get more confused.  */
5621   if (!cond || cond == error_mark_node)
5622     {
5623       /* Add a label anyhow so that the back-end doesn't think that
5624          the beginning of the switch is unreachable.  */
5625       if (!cases->root)
5626         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5627       return error_mark_node;
5628     }
5629
5630   if ((low_value && TREE_TYPE (low_value)
5631        && POINTER_TYPE_P (TREE_TYPE (low_value)))
5632       || (high_value && TREE_TYPE (high_value)
5633           && POINTER_TYPE_P (TREE_TYPE (high_value))))
5634     error ("pointers are not permitted as case values");
5635
5636   /* Case ranges are a GNU extension.  */
5637   if (high_value && pedantic)
5638     {
5639       if (c_language == clk_cplusplus)
5640         pedwarn ("ISO C++ forbids range expressions in switch statements");
5641       else
5642         pedwarn ("ISO C forbids range expressions in switch statements");
5643     }
5644
5645   type = TREE_TYPE (cond);
5646   if (low_value)
5647     {
5648       low_value = check_case_value (low_value);
5649       low_value = convert_and_check (type, low_value);
5650     }
5651   if (high_value)
5652     {
5653       high_value = check_case_value (high_value);
5654       high_value = convert_and_check (type, high_value);
5655     }
5656
5657   /* If an error has occurred, bail out now.  */
5658   if (low_value == error_mark_node || high_value == error_mark_node)
5659     {
5660       if (!cases->root)
5661         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5662       return error_mark_node;
5663     }
5664
5665   /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
5666      really a case range, even though it was written that way.  Remove
5667      the HIGH_VALUE to simplify later processing.  */
5668   if (tree_int_cst_equal (low_value, high_value))
5669     high_value = NULL_TREE;
5670   if (low_value && high_value
5671       && !tree_int_cst_lt (low_value, high_value))
5672     warning ("empty range specified");
5673
5674   /* Look up the LOW_VALUE in the table of case labels we already
5675      have.  */
5676   node = splay_tree_lookup (cases, (splay_tree_key) low_value);
5677   /* If there was not an exact match, check for overlapping ranges.
5678      There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
5679      that's a `default' label and the only overlap is an exact match.  */
5680   if (!node && (low_value || high_value))
5681     {
5682       splay_tree_node low_bound;
5683       splay_tree_node high_bound;
5684
5685       /* Even though there wasn't an exact match, there might be an
5686          overlap between this case range and another case range.
5687          Since we've (inductively) not allowed any overlapping case
5688          ranges, we simply need to find the greatest low case label
5689          that is smaller that LOW_VALUE, and the smallest low case
5690          label that is greater than LOW_VALUE.  If there is an overlap
5691          it will occur in one of these two ranges.  */
5692       low_bound = splay_tree_predecessor (cases,
5693                                           (splay_tree_key) low_value);
5694       high_bound = splay_tree_successor (cases,
5695                                          (splay_tree_key) low_value);
5696
5697       /* Check to see if the LOW_BOUND overlaps.  It is smaller than
5698          the LOW_VALUE, so there is no need to check unless the
5699          LOW_BOUND is in fact itself a case range.  */
5700       if (low_bound
5701           && CASE_HIGH ((tree) low_bound->value)
5702           && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
5703                                     low_value) >= 0)
5704         node = low_bound;
5705       /* Check to see if the HIGH_BOUND overlaps.  The low end of that
5706          range is bigger than the low end of the current range, so we
5707          are only interested if the current range is a real range, and
5708          not an ordinary case label.  */
5709       else if (high_bound
5710                && high_value
5711                && (tree_int_cst_compare ((tree) high_bound->key,
5712                                          high_value)
5713                    <= 0))
5714         node = high_bound;
5715     }
5716   /* If there was an overlap, issue an error.  */
5717   if (node)
5718     {
5719       tree duplicate = CASE_LABEL_DECL ((tree) node->value);
5720
5721       if (high_value)
5722         {
5723           error ("duplicate (or overlapping) case value");
5724           error_with_decl (duplicate,
5725                            "this is the first entry overlapping that value");
5726         }
5727       else if (low_value)
5728         {
5729           error ("duplicate case value") ;
5730           error_with_decl (duplicate, "previously used here");
5731         }
5732       else
5733         {
5734           error ("multiple default labels in one switch");
5735           error_with_decl (duplicate, "this is the first default label");
5736         }
5737       if (!cases->root)
5738         add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
5739     }
5740
5741   /* Add a CASE_LABEL to the statement-tree.  */
5742   case_label = add_stmt (build_case_label (low_value, high_value, label));
5743   /* Register this case label in the splay tree.  */
5744   splay_tree_insert (cases,
5745                      (splay_tree_key) low_value,
5746                      (splay_tree_value) case_label);
5747
5748   return case_label;
5749 }
5750
5751 /* Mark P (a stmt_tree) for GC.  The use of a `void *' for the
5752    parameter allows this function to be used as a GC-marking
5753    function.  */
5754
5755 void
5756 mark_stmt_tree (p)
5757      void *p;
5758 {
5759   stmt_tree st = (stmt_tree) p;
5760
5761   ggc_mark_tree (st->x_last_stmt);
5762   ggc_mark_tree (st->x_last_expr_type);
5763 }
5764
5765 /* Mark LD for GC.  */
5766
5767 void
5768 c_mark_lang_decl (c)
5769      struct c_lang_decl *c;
5770 {
5771   ggc_mark_tree (c->saved_tree);
5772 }
5773
5774 /* Mark F for GC.  */
5775
5776 void
5777 mark_c_language_function (f)
5778      struct language_function *f;
5779 {
5780   if (!f)
5781     return;
5782
5783   mark_stmt_tree (&f->x_stmt_tree);
5784   ggc_mark_tree (f->x_scope_stmt_stack);
5785 }
5786
5787 /* Hook used by expand_expr to expand language-specific tree codes.  */
5788
5789 rtx
5790 c_expand_expr (exp, target, tmode, modifier)
5791      tree exp;
5792      rtx target;
5793      enum machine_mode tmode;
5794      enum expand_modifier modifier;
5795 {
5796   switch (TREE_CODE (exp))
5797     {
5798     case STMT_EXPR:
5799       {
5800         tree rtl_expr;
5801         rtx result;
5802
5803         /* Since expand_expr_stmt calls free_temp_slots after every
5804            expression statement, we must call push_temp_slots here.
5805            Otherwise, any temporaries in use now would be considered
5806            out-of-scope after the first EXPR_STMT from within the
5807            STMT_EXPR.  */
5808         push_temp_slots ();
5809         rtl_expr = expand_start_stmt_expr ();
5810         expand_stmt (STMT_EXPR_STMT (exp));
5811         expand_end_stmt_expr (rtl_expr);
5812         result = expand_expr (rtl_expr, target, tmode, modifier);
5813         pop_temp_slots ();
5814         return result;
5815       }
5816       break;
5817
5818     case CALL_EXPR:
5819       {
5820         if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
5821             && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5822                 == FUNCTION_DECL)
5823             && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5824             && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
5825                 == BUILT_IN_FRONTEND))
5826           return c_expand_builtin (exp, target, tmode, modifier);
5827         else
5828           abort();
5829       }
5830       break;
5831
5832     default:
5833       abort ();
5834     }
5835
5836   abort ();
5837   return NULL;
5838 }
5839
5840 /* Hook used by safe_from_p to handle language-specific tree codes.  */
5841
5842 int
5843 c_safe_from_p (target, exp)
5844      rtx target;
5845      tree exp;
5846 {
5847   /* We can see statements here when processing the body of a
5848      statement-expression.  For a declaration statement declaring a
5849      variable, look at the variable's initializer.  */
5850   if (TREE_CODE (exp) == DECL_STMT)
5851     {
5852       tree decl = DECL_STMT_DECL (exp);
5853
5854       if (TREE_CODE (decl) == VAR_DECL
5855           && DECL_INITIAL (decl)
5856           && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
5857         return 0;
5858     }
5859
5860   /* For any statement, we must follow the statement-chain.  */
5861   if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
5862     return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
5863
5864   /* Assume everything else is safe.  */
5865   return 1;
5866 }
5867
5868 /* Tree code classes. */
5869
5870 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
5871
5872 static char c_tree_code_type[] = {
5873   'x',
5874 #include "c-common.def"
5875 };
5876 #undef DEFTREECODE
5877
5878 /* Table indexed by tree code giving number of expression
5879    operands beyond the fixed part of the node structure.
5880    Not used for types or decls.  */
5881
5882 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
5883
5884 static int c_tree_code_length[] = {
5885   0,
5886 #include "c-common.def"
5887 };
5888 #undef DEFTREECODE
5889
5890 /* Names of tree components.
5891    Used for printing out the tree and error messages.  */
5892 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
5893
5894 static const char *c_tree_code_name[] = {
5895   "@@dummy",
5896 #include "c-common.def"
5897 };
5898 #undef DEFTREECODE
5899
5900 /* Adds the tree codes specific to the C front end to the list of all
5901    tree codes. */
5902
5903 void
5904 add_c_tree_codes ()
5905 {
5906   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
5907           c_tree_code_type,
5908           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
5909   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
5910           c_tree_code_length,
5911           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
5912   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
5913           c_tree_code_name,
5914           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
5915 }
5916
5917 #define CALLED_AS_BUILT_IN(NODE) \
5918    (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
5919
5920 static rtx
5921 c_expand_builtin (exp, target, tmode, modifier)
5922      tree exp;
5923      rtx target;
5924      enum machine_mode tmode;
5925      enum expand_modifier modifier;
5926 {
5927   tree type = TREE_TYPE (exp);
5928   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
5929   tree arglist = TREE_OPERAND (exp, 1);
5930   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5931   enum tree_code code = TREE_CODE (exp);
5932   const int ignore = (target == const0_rtx
5933                       || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
5934                            || code == CONVERT_EXPR || code == REFERENCE_EXPR
5935                            || code == COND_EXPR)
5936                           && TREE_CODE (type) == VOID_TYPE));
5937
5938   if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
5939     return expand_call (exp, target, ignore);
5940
5941   switch (fcode)
5942     {
5943     case BUILT_IN_PRINTF:
5944       target = c_expand_builtin_printf (arglist, target, tmode,
5945                                         modifier, ignore);
5946       if (target)
5947         return target;
5948       break;
5949
5950     default:                    /* just do library call, if unknown builtin */
5951       error ("built-in function `%s' not currently supported",
5952              IDENTIFIER_POINTER (DECL_NAME (fndecl)));
5953     }
5954
5955   /* The switch statement above can drop through to cause the function
5956      to be called normally.  */
5957   return expand_call (exp, target, ignore);
5958 }
5959
5960 /* Check an arglist to *printf for problems.  The arglist should start
5961    at the format specifier, with the remaining arguments immediately
5962    following it. */
5963 static int
5964 is_valid_printf_arglist (arglist)
5965   tree arglist;
5966 {
5967   /* Save this value so we can restore it later. */
5968   const int SAVE_pedantic = pedantic;
5969   int diagnostic_occurred = 0;
5970
5971   /* Set this to a known value so the user setting won't affect code
5972      generation.  */
5973   pedantic = 1;
5974   /* Check to make sure there are no format specifier errors. */
5975   check_function_format (&diagnostic_occurred,
5976                          maybe_get_identifier("printf"),
5977                          NULL_TREE, arglist);
5978
5979   /* Restore the value of `pedantic'. */
5980   pedantic = SAVE_pedantic;
5981
5982   /* If calling `check_function_format_ptr' produces a warning, we
5983      return false, otherwise we return true. */
5984   return ! diagnostic_occurred;
5985 }
5986
5987 /* If the arguments passed to printf are suitable for optimizations,
5988    we attempt to transform the call. */
5989 static rtx
5990 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
5991      tree arglist;
5992      rtx target;
5993      enum machine_mode tmode;
5994      enum expand_modifier modifier;
5995      int ignore;
5996 {
5997   tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
5998     fn_puts = built_in_decls[BUILT_IN_PUTS];
5999   tree fn, format_arg, stripped_string;
6000
6001   /* If the return value is used, or the replacement _DECL isn't
6002      initialized, don't do the transformation. */
6003   if (!ignore || !fn_putchar || !fn_puts)
6004     return 0;
6005
6006   /* Verify the required arguments in the original call. */
6007   if (arglist == 0
6008       || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
6009     return 0;
6010
6011   /* Check the specifier vs. the parameters. */
6012   if (!is_valid_printf_arglist (arglist))
6013     return 0;
6014
6015   format_arg = TREE_VALUE (arglist);
6016   stripped_string = format_arg;
6017   STRIP_NOPS (stripped_string);
6018   if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
6019     stripped_string = TREE_OPERAND (stripped_string, 0);
6020
6021   /* If the format specifier isn't a STRING_CST, punt.  */
6022   if (TREE_CODE (stripped_string) != STRING_CST)
6023     return 0;
6024
6025   /* OK!  We can attempt optimization.  */
6026
6027   /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
6028   if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
6029     {
6030       arglist = TREE_CHAIN (arglist);
6031       fn = fn_puts;
6032     }
6033   /* If the format specifier was "%c", call __builtin_putchar (arg2). */
6034   else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
6035     {
6036       arglist = TREE_CHAIN (arglist);
6037       fn = fn_putchar;
6038     }
6039   else
6040     {
6041      /* We can't handle anything else with % args or %% ... yet. */
6042       if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
6043         return 0;
6044
6045       /* If the resulting constant string has a length of 1, call
6046          putchar.  Note, TREE_STRING_LENGTH includes the terminating
6047          NULL in its count.  */
6048       if (TREE_STRING_LENGTH (stripped_string) == 2)
6049         {
6050           /* Given printf("c"), (where c is any one character,)
6051              convert "c"[0] to an int and pass that to the replacement
6052              function. */
6053           arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
6054           arglist = build_tree_list (NULL_TREE, arglist);
6055
6056           fn = fn_putchar;
6057         }
6058       /* If the resulting constant was "string\n", call
6059          __builtin_puts("string").  Ensure "string" has at least one
6060          character besides the trailing \n.  Note, TREE_STRING_LENGTH
6061          includes the terminating NULL in its count.  */
6062       else if (TREE_STRING_LENGTH (stripped_string) > 2
6063                && TREE_STRING_POINTER (stripped_string)
6064                [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
6065         {
6066           /* Create a NULL-terminated string that's one char shorter
6067              than the original, stripping off the trailing '\n'.  */
6068           const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
6069           char *newstr = (char *) alloca (newlen);
6070           memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
6071           newstr[newlen - 1] = 0;
6072
6073           arglist = combine_strings (build_string (newlen, newstr));
6074           arglist = build_tree_list (NULL_TREE, arglist);
6075           fn = fn_puts;
6076         }
6077       else
6078         /* We'd like to arrange to call fputs(string) here, but we
6079            need stdout and don't have a way to get it ... yet.  */
6080         return 0;
6081     }
6082
6083   return expand_expr (build_function_call (fn, arglist),
6084                       (ignore ? const0_rtx : target),
6085                       tmode, modifier);
6086 }