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