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