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