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 "c-common.h"
  26 #include "flags.h"
  27 #include "toplev.h"
  28 #include "output.h"
  29 #include "c-pragma.h"
  30 #include "rtl.h"
  31 #include "ggc.h"
  32 #include "expr.h"
  33 #include "tm_p.h"
  34
  35 #if USE_CPPLIB
  36 #include "cpplib.h"
  37 cpp_reader  parse_in;
  38 cpp_options parse_options;
  39 enum cpp_token cpp_token;
  40 #endif
  41
  42 #undef WCHAR_TYPE_SIZE
  43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
  44
  45 /* The following symbols are subsumed in the c_global_trees array, and
  46    listed here individually for documentation purposes.
  47
  48    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
  49
  50         tree short_integer_type_node;
  51         tree long_integer_type_node;
  52         tree long_long_integer_type_node;
  53
  54         tree short_unsigned_type_node;
  55         tree long_unsigned_type_node;
  56         tree long_long_unsigned_type_node;
  57
  58         tree boolean_type_node;
  59         tree boolean_false_node;
  60         tree boolean_true_node;
  61
  62         tree ptrdiff_type_node;
  63
  64         tree unsigned_char_type_node;
  65         tree signed_char_type_node;
  66         tree wchar_type_node;
  67         tree signed_wchar_type_node;
  68         tree unsigned_wchar_type_node;
  69
  70         tree float_type_node;
  71         tree double_type_node;
  72         tree long_double_type_node;
  73
  74         tree complex_integer_type_node;
  75         tree complex_float_type_node;
  76         tree complex_double_type_node;
  77         tree complex_long_double_type_node;
  78
  79         tree intQI_type_node;
  80         tree intHI_type_node;
  81         tree intSI_type_node;
  82         tree intDI_type_node;
  83         tree intTI_type_node;
  84
  85         tree unsigned_intQI_type_node;
  86         tree unsigned_intHI_type_node;
  87         tree unsigned_intSI_type_node;
  88         tree unsigned_intDI_type_node;
  89         tree unsigned_intTI_type_node;
  90
  91         tree widest_integer_literal_type_node;
  92         tree widest_unsigned_literal_type_node;
  93
  94    Nodes for types `void *' and `const void *'.
  95
  96         tree ptr_type_node, const_ptr_type_node;
  97
  98    Nodes for types `char *' and `const char *'.
  99
 100         tree string_type_node, const_string_type_node;
 101
 102    Type `char[SOMENUMBER]'.
 103    Used when an array of char is needed and the size is irrelevant.
 104
 105         tree char_array_type_node;
 106
 107    Type `int[SOMENUMBER]' or something like it.
 108    Used when an array of int needed and the size is irrelevant.
 109
 110         tree int_array_type_node;
 111
 112    Type `wchar_t[SOMENUMBER]' or something like it.
 113    Used when a wide string literal is created.
 114
 115         tree wchar_array_type_node;
 116
 117    Type `int ()' -- used for implicit declaration of functions.
 118
 119         tree default_function_type;
 120
 121    Function types `int (int)', etc.
 122
 123         tree int_ftype_int;
 124         tree void_ftype;
 125         tree void_ftype_ptr;
 126         tree int_ftype_int;
 127         tree ptr_ftype_sizetype;
 128
 129    A VOID_TYPE node, packaged in a TREE_LIST.
 130
 131         tree void_list_node;
 132
 133 */
 134
 135 tree c_global_trees[CTI_MAX];
 136
 137 /* The elements of `ridpointers' are identifier nodes for the reserved
 138    type names and storage classes.  It is indexed by a RID_... value.  */
 139 tree *ridpointers;
 140
 141 tree (*make_fname_decl)                PARAMS ((tree, const char *, int));
 142
 143 /* Nonzero means the expression being parsed will never be evaluated.
 144    This is a count, since unevaluated expressions can nest.  */
 145 int skip_evaluation;
 146
 147 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
 148             A_NO_CHECK_MEMORY_USAGE, A_NO_INSTRUMENT_FUNCTION,
 149             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
 150             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS, A_MALLOC,
 151             A_NO_LIMIT_STACK, A_PURE};
 152
 153 enum format_type { printf_format_type, scanf_format_type,
 154                    strftime_format_type };
 155
 156 static void add_attribute               PARAMS ((enum attrs, const char *,
 157                                                  int, int, int));
 158 static void init_attributes             PARAMS ((void));
 159 static void record_function_format      PARAMS ((tree, tree, enum format_type,
 160                                                  int, int));
 161 static void record_international_format PARAMS ((tree, tree, int));
 162 static int default_valid_lang_attribute PARAMS ((tree, tree, tree, tree));
 163
 164 /* Keep a stack of if statements.  We record the number of compound
 165    statements seen up to the if keyword, as well as the line number
 166    and file of the if.  If a potentially ambiguous else is seen, that
 167    fact is recorded; the warning is issued when we can be sure that
 168    the enclosing if statement does not have an else branch.  */
 169 typedef struct
 170 {
 171   int compstmt_count;
 172   int line;
 173   const char *file;
 174   int needs_warning;
 175 } if_elt;
 176 static void tfaff                       PARAMS ((void));
 177
 178 static if_elt *if_stack;
 179
 180 /* Amount of space in the if statement stack.  */
 181 static int if_stack_space = 0;
 182
 183 /* Stack pointer.  */
 184 static int if_stack_pointer = 0;
 185
 186 /* Generate RTL for the start of an if-then, and record the start of it
 187    for ambiguous else detection.  */
 188
 189 void
 190 c_expand_start_cond (cond, exitflag, compstmt_count)
 191      tree cond;
 192      int exitflag;
 193      int compstmt_count;
 194 {
 195   /* Make sure there is enough space on the stack.  */
 196   if (if_stack_space == 0)
 197     {
 198       if_stack_space = 10;
 199       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 200     }
 201   else if (if_stack_space == if_stack_pointer)
 202     {
 203       if_stack_space += 10;
 204       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 205     }
 206
 207   /* Record this if statement.  */
 208   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 209   if_stack[if_stack_pointer].file = input_filename;
 210   if_stack[if_stack_pointer].line = lineno;
 211   if_stack[if_stack_pointer].needs_warning = 0;
 212   if_stack_pointer++;
 213
 214   expand_start_cond (cond, exitflag);
 215 }
 216
 217 /* Generate RTL for the end of an if-then.  Optionally warn if a nested
 218    if statement had an ambiguous else clause.  */
 219
 220 void
 221 c_expand_end_cond ()
 222 {
 223   if_stack_pointer--;
 224   if (if_stack[if_stack_pointer].needs_warning)
 225     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 226                                 if_stack[if_stack_pointer].line,
 227                                 "suggest explicit braces to avoid ambiguous `else'");
 228   expand_end_cond ();
 229 }
 230
 231 /* Generate RTL between the then-clause and the else-clause
 232    of an if-then-else.  */
 233
 234 void
 235 c_expand_start_else ()
 236 {
 237   /* An ambiguous else warning must be generated for the enclosing if
 238      statement, unless we see an else branch for that one, too.  */
 239   if (warn_parentheses
 240       && if_stack_pointer > 1
 241       && (if_stack[if_stack_pointer - 1].compstmt_count
 242           == if_stack[if_stack_pointer - 2].compstmt_count))
 243     if_stack[if_stack_pointer - 2].needs_warning = 1;
 244
 245   /* Even if a nested if statement had an else branch, it can't be
 246      ambiguous if this one also has an else.  So don't warn in that
 247      case.  Also don't warn for any if statements nested in this else.  */
 248   if_stack[if_stack_pointer - 1].needs_warning = 0;
 249   if_stack[if_stack_pointer - 1].compstmt_count--;
 250
 251   expand_start_else ();
 252 }
 253
 254 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__.  */
 255
 256 void
 257 declare_function_name ()
 258 {
 259   const char *name, *printable_name;
 260
 261   if (current_function_decl == NULL)
 262     {
 263       name = "";
 264       printable_name = "top level";
 265     }
 266   else
 267     {
 268       /* Allow functions to be nameless (such as artificial ones).  */
 269       if (DECL_NAME (current_function_decl))
 270         name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 271       else
 272         name = "";
 273       printable_name = (*decl_printable_name) (current_function_decl, 2);
 274     }
 275
 276   (*make_fname_decl) (get_identifier ("__FUNCTION__"), name, 0);
 277   (*make_fname_decl) (get_identifier ("__PRETTY_FUNCTION__"), printable_name, 1);
 278   /* The ISO C people "of course" couldn't use __FUNCTION__ in the
 279      ISO C 99 standard; instead a new variable is invented.  */
 280   (*make_fname_decl) (get_identifier ("__func__"), name, 0);
 281 }
 282
 283 /* Given a chain of STRING_CST nodes,
 284    concatenate them into one STRING_CST
 285    and give it a suitable array-of-chars data type.  */
 286
 287 tree
 288 combine_strings (strings)
 289      tree strings;
 290 {
 291   register tree value, t;
 292   register int length = 1;
 293   int wide_length = 0;
 294   int wide_flag = 0;
 295   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 296   int nchars;
 297   const int nchars_max = flag_isoc99 ? 4095 : 509;
 298
 299   if (TREE_CHAIN (strings))
 300     {
 301       /* More than one in the chain, so concatenate.  */
 302       register char *p, *q;
 303
 304       /* Don't include the \0 at the end of each substring,
 305          except for the last one.
 306          Count wide strings and ordinary strings separately.  */
 307       for (t = strings; t; t = TREE_CHAIN (t))
 308         {
 309           if (TREE_TYPE (t) == wchar_array_type_node)
 310             {
 311               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 312               wide_flag = 1;
 313             }
 314           else
 315             length += (TREE_STRING_LENGTH (t) - 1);
 316         }
 317
 318       /* If anything is wide, the non-wides will be converted,
 319          which makes them take more space.  */
 320       if (wide_flag)
 321         length = length * wchar_bytes + wide_length;
 322
 323       p = ggc_alloc_string (NULL, length);
 324
 325       /* Copy the individual strings into the new combined string.
 326          If the combined string is wide, convert the chars to ints
 327          for any individual strings that are not wide.  */
 328
 329       q = p;
 330       for (t = strings; t; t = TREE_CHAIN (t))
 331         {
 332           int len = (TREE_STRING_LENGTH (t)
 333                      - ((TREE_TYPE (t) == wchar_array_type_node)
 334                         ? wchar_bytes : 1));
 335           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 336             {
 337               memcpy (q, TREE_STRING_POINTER (t), len);
 338               q += len;
 339             }
 340           else
 341             {
 342               int i;
 343               for (i = 0; i < len; i++)
 344                 {
 345                   if (WCHAR_TYPE_SIZE == HOST_BITS_PER_SHORT)
 346                     ((short *) q)[i] = TREE_STRING_POINTER (t)[i];
 347                   else
 348                     ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
 349                 }
 350               q += len * wchar_bytes;
 351             }
 352         }
 353       if (wide_flag)
 354         {
 355           int i;
 356           for (i = 0; i < wchar_bytes; i++)
 357             *q++ = 0;
 358         }
 359       else
 360         *q = 0;
 361
 362       value = make_node (STRING_CST);
 363       TREE_STRING_POINTER (value) = p;
 364       TREE_STRING_LENGTH (value) = length;
 365     }
 366   else
 367     {
 368       value = strings;
 369       length = TREE_STRING_LENGTH (value);
 370       if (TREE_TYPE (value) == wchar_array_type_node)
 371         wide_flag = 1;
 372     }
 373
 374   /* Compute the number of elements, for the array type.  */
 375   nchars = wide_flag ? length / wchar_bytes : length;
 376
 377   if (pedantic && nchars > nchars_max)
 378     pedwarn ("string length `%d' is greater than the minimum length `%d' ANSI C is required to support",
 379              nchars, nchars_max);
 380
 381   /* Create the array type for the string constant.
 382      -Wwrite-strings says make the string constant an array of const char
 383      so that copying it to a non-const pointer will get a warning.
 384      For C++, this is the standard behavior.  */
 385   if (flag_const_strings
 386       && (! flag_traditional  && ! flag_writable_strings))
 387     {
 388       tree elements
 389         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 390                               1, 0);
 391       TREE_TYPE (value)
 392         = build_array_type (elements,
 393                             build_index_type (build_int_2 (nchars - 1, 0)));
 394     }
 395   else
 396     TREE_TYPE (value)
 397       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 398                           build_index_type (build_int_2 (nchars - 1, 0)));
 399
 400   TREE_CONSTANT (value) = 1;
 401   TREE_READONLY (value) = ! flag_writable_strings;
 402   TREE_STATIC (value) = 1;
 403   return value;
 404 }
 405 \f
 406 /* To speed up processing of attributes, we maintain an array of
 407    IDENTIFIER_NODES and the corresponding attribute types.  */
 408
 409 /* Array to hold attribute information.  */
 410
 411 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 412
 413 static int attrtab_idx = 0;
 414
 415 /* Add an entry to the attribute table above.  */
 416
 417 static void
 418 add_attribute (id, string, min_len, max_len, decl_req)
 419      enum attrs id;
 420      const char *string;
 421      int min_len, max_len;
 422      int decl_req;
 423 {
 424   char buf[100];
 425
 426   attrtab[attrtab_idx].id = id;
 427   attrtab[attrtab_idx].name = get_identifier (string);
 428   attrtab[attrtab_idx].min = min_len;
 429   attrtab[attrtab_idx].max = max_len;
 430   attrtab[attrtab_idx++].decl_req = decl_req;
 431
 432   sprintf (buf, "__%s__", string);
 433
 434   attrtab[attrtab_idx].id = id;
 435   attrtab[attrtab_idx].name = get_identifier (buf);
 436   attrtab[attrtab_idx].min = min_len;
 437   attrtab[attrtab_idx].max = max_len;
 438   attrtab[attrtab_idx++].decl_req = decl_req;
 439 }
 440
 441 /* Initialize attribute table.  */
 442
 443 static void
 444 init_attributes ()
 445 {
 446   add_attribute (A_PACKED, "packed", 0, 0, 0);
 447   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 448   add_attribute (A_COMMON, "common", 0, 0, 1);
 449   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 450   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 451   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 452   add_attribute (A_CONST, "const", 0, 0, 1);
 453   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 454   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 455   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 456   add_attribute (A_MODE, "mode", 1, 1, 1);
 457   add_attribute (A_SECTION, "section", 1, 1, 1);
 458   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 459   add_attribute (A_FORMAT, "format", 3, 3, 1);
 460   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 461   add_attribute (A_WEAK, "weak", 0, 0, 1);
 462   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 463   add_attribute (A_NO_INSTRUMENT_FUNCTION, "no_instrument_function", 0, 0, 1);
 464   add_attribute (A_NO_CHECK_MEMORY_USAGE, "no_check_memory_usage", 0, 0, 1);
 465   add_attribute (A_MALLOC, "malloc", 0, 0, 1);
 466   add_attribute (A_NO_LIMIT_STACK, "no_stack_limit", 0, 0, 1);
 467   add_attribute (A_PURE, "pure", 0, 0, 1);
 468 }
 469 \f
 470 /* Default implementation of valid_lang_attribute, below.  By default, there
 471    are no language-specific attributes.  */
 472
 473 static int
 474 default_valid_lang_attribute (attr_name, attr_args, decl, type)
 475   tree attr_name ATTRIBUTE_UNUSED;
 476   tree attr_args ATTRIBUTE_UNUSED;
 477   tree decl ATTRIBUTE_UNUSED;
 478   tree type ATTRIBUTE_UNUSED;
 479 {
 480   return 0;
 481 }
 482
 483 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
 484    attribute for either declaration DECL or type TYPE and 0 otherwise.  */
 485
 486 int (*valid_lang_attribute) PARAMS ((tree, tree, tree, tree))
 487      = default_valid_lang_attribute;
 488
 489 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
 490    and install them in NODE, which is either a DECL (including a TYPE_DECL)
 491    or a TYPE.  PREFIX_ATTRIBUTES can appear after the declaration specifiers
 492    and declaration modifiers but before the declaration proper.  */
 493
 494 void
 495 decl_attributes (node, attributes, prefix_attributes)
 496      tree node, attributes, prefix_attributes;
 497 {
 498   tree decl = 0, type = 0;
 499   int is_type = 0;
 500   tree a;
 501
 502   if (attrtab_idx == 0)
 503     init_attributes ();
 504
 505   if (DECL_P (node))
 506     {
 507       decl = node;
 508       type = TREE_TYPE (decl);
 509       is_type = TREE_CODE (node) == TYPE_DECL;
 510     }
 511   else if (TYPE_P (node))
 512     type = node, is_type = 1;
 513
 514 #ifdef PRAGMA_INSERT_ATTRIBUTES
 515   /* If the code in c-pragma.c wants to insert some attributes then
 516      allow it to do so.  Do this before allowing machine back ends to
 517      insert attributes, so that they have the opportunity to override
 518      anything done here.  */
 519   PRAGMA_INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 520 #endif
 521
 522 #ifdef INSERT_ATTRIBUTES
 523   INSERT_ATTRIBUTES (node, & attributes, & prefix_attributes);
 524 #endif
 525
 526   attributes = chainon (prefix_attributes, attributes);
 527
 528   for (a = attributes; a; a = TREE_CHAIN (a))
 529     {
 530       tree name = TREE_PURPOSE (a);
 531       tree args = TREE_VALUE (a);
 532       int i;
 533       enum attrs id;
 534
 535       for (i = 0; i < attrtab_idx; i++)
 536         if (attrtab[i].name == name)
 537           break;
 538
 539       if (i == attrtab_idx)
 540         {
 541           if (! valid_machine_attribute (name, args, decl, type)
 542               && ! (* valid_lang_attribute) (name, args, decl, type))
 543             warning ("`%s' attribute directive ignored",
 544                      IDENTIFIER_POINTER (name));
 545           else if (decl != 0)
 546             type = TREE_TYPE (decl);
 547           continue;
 548         }
 549       else if (attrtab[i].decl_req && decl == 0)
 550         {
 551           warning ("`%s' attribute does not apply to types",
 552                    IDENTIFIER_POINTER (name));
 553           continue;
 554         }
 555       else if (list_length (args) < attrtab[i].min
 556                || list_length (args) > attrtab[i].max)
 557         {
 558           error ("wrong number of arguments specified for `%s' attribute",
 559                  IDENTIFIER_POINTER (name));
 560           continue;
 561         }
 562
 563       id = attrtab[i].id;
 564       switch (id)
 565         {
 566         case A_PACKED:
 567           if (is_type)
 568             TYPE_PACKED (type) = 1;
 569           else if (TREE_CODE (decl) == FIELD_DECL)
 570             DECL_PACKED (decl) = 1;
 571           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 572              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 573           else
 574             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 575           break;
 576
 577         case A_NOCOMMON:
 578           if (TREE_CODE (decl) == VAR_DECL)
 579             DECL_COMMON (decl) = 0;
 580           else
 581             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 582           break;
 583
 584         case A_COMMON:
 585           if (TREE_CODE (decl) == VAR_DECL)
 586             DECL_COMMON (decl) = 1;
 587           else
 588             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 589           break;
 590
 591         case A_NORETURN:
 592           if (TREE_CODE (decl) == FUNCTION_DECL)
 593             TREE_THIS_VOLATILE (decl) = 1;
 594           else if (TREE_CODE (type) == POINTER_TYPE
 595                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 596             TREE_TYPE (decl) = type
 597               = build_pointer_type
 598                 (build_type_variant (TREE_TYPE (type),
 599                                      TREE_READONLY (TREE_TYPE (type)), 1));
 600           else
 601             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 602           break;
 603
 604         case A_MALLOC:
 605           if (TREE_CODE (decl) == FUNCTION_DECL)
 606             DECL_IS_MALLOC (decl) = 1;
 607           /* ??? TODO: Support types.  */
 608           else
 609             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 610           break;
 611
 612         case A_UNUSED:
 613           if (is_type)
 614             if (decl)
 615               TREE_USED (decl) = 1;
 616             else
 617               TREE_USED (type) = 1;
 618           else if (TREE_CODE (decl) == PARM_DECL
 619                    || TREE_CODE (decl) == VAR_DECL
 620                    || TREE_CODE (decl) == FUNCTION_DECL
 621                    || TREE_CODE (decl) == LABEL_DECL)
 622             TREE_USED (decl) = 1;
 623           else
 624             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 625           break;
 626
 627         case A_CONST:
 628           if (TREE_CODE (decl) == FUNCTION_DECL)
 629             TREE_READONLY (decl) = 1;
 630           else if (TREE_CODE (type) == POINTER_TYPE
 631                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 632             TREE_TYPE (decl) = type
 633               = build_pointer_type
 634                 (build_type_variant (TREE_TYPE (type), 1,
 635                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 636           else
 637             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 638           break;
 639
 640         case A_PURE:
 641           if (TREE_CODE (decl) == FUNCTION_DECL)
 642             DECL_IS_PURE (decl) = 1;
 643           /* ??? TODO: Support types.  */
 644           else
 645             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 646           break;
 647
 648
 649         case A_T_UNION:
 650           if (is_type
 651               && TREE_CODE (type) == UNION_TYPE
 652               && (decl == 0
 653                   || (TYPE_FIELDS (type) != 0
 654                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 655             TYPE_TRANSPARENT_UNION (type) = 1;
 656           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 657                    && TREE_CODE (type) == UNION_TYPE
 658                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 659             DECL_TRANSPARENT_UNION (decl) = 1;
 660           else
 661             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 662           break;
 663
 664         case A_CONSTRUCTOR:
 665           if (TREE_CODE (decl) == FUNCTION_DECL
 666               && TREE_CODE (type) == FUNCTION_TYPE
 667               && decl_function_context (decl) == 0)
 668             {
 669               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 670               TREE_USED (decl) = 1;
 671             }
 672           else
 673             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 674           break;
 675
 676         case A_DESTRUCTOR:
 677           if (TREE_CODE (decl) == FUNCTION_DECL
 678               && TREE_CODE (type) == FUNCTION_TYPE
 679               && decl_function_context (decl) == 0)
 680             {
 681               DECL_STATIC_DESTRUCTOR (decl) = 1;
 682               TREE_USED (decl) = 1;
 683             }
 684           else
 685             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 686           break;
 687
 688         case A_MODE:
 689           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 690             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 691           else
 692             {
 693               int j;
 694               const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 695               int len = strlen (p);
 696               enum machine_mode mode = VOIDmode;
 697               tree typefm;
 698
 699               if (len > 4 && p[0] == '_' && p[1] == '_'
 700                   && p[len - 1] == '_' && p[len - 2] == '_')
 701                 {
 702                   char *newp = (char *) alloca (len - 1);
 703
 704                   strcpy (newp, &p[2]);
 705                   newp[len - 4] = '\0';
 706                   p = newp;
 707                 }
 708
 709               /* Give this decl a type with the specified mode.
 710                  First check for the special modes.  */
 711               if (! strcmp (p, "byte"))
 712                 mode = byte_mode;
 713               else if (!strcmp (p, "word"))
 714                 mode = word_mode;
 715               else if (! strcmp (p, "pointer"))
 716                 mode = ptr_mode;
 717               else
 718                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 719                   if (!strcmp (p, GET_MODE_NAME (j)))
 720                     mode = (enum machine_mode) j;
 721
 722               if (mode == VOIDmode)
 723                 error ("unknown machine mode `%s'", p);
 724               else if (0 == (typefm = type_for_mode (mode,
 725                                                      TREE_UNSIGNED (type))))
 726                 error ("no data type for mode `%s'", p);
 727               else
 728                 {
 729                   TREE_TYPE (decl) = type = typefm;
 730                   DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
 731                   layout_decl (decl, 0);
 732                 }
 733             }
 734           break;
 735
 736         case A_SECTION:
 737 #ifdef ASM_OUTPUT_SECTION_NAME
 738           if ((TREE_CODE (decl) == FUNCTION_DECL
 739                || TREE_CODE (decl) == VAR_DECL)
 740               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 741             {
 742               if (TREE_CODE (decl) == VAR_DECL
 743                   && current_function_decl != NULL_TREE
 744                   && ! TREE_STATIC (decl))
 745                 error_with_decl (decl,
 746                   "section attribute cannot be specified for local variables");
 747               /* The decl may have already been given a section attribute from
 748                  a previous declaration.  Ensure they match.  */
 749               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 750                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 751                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 752                 error_with_decl (node,
 753                                  "section of `%s' conflicts with previous declaration");
 754               else
 755                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 756             }
 757           else
 758             error_with_decl (node,
 759                            "section attribute not allowed for `%s'");
 760 #else
 761           error_with_decl (node,
 762                   "section attributes are not supported for this target");
 763 #endif
 764           break;
 765
 766         case A_ALIGNED:
 767           {
 768             tree align_expr
 769               = (args ? TREE_VALUE (args)
 770                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 771             int i;
 772
 773             /* Strip any NOPs of any kind.  */
 774             while (TREE_CODE (align_expr) == NOP_EXPR
 775                    || TREE_CODE (align_expr) == CONVERT_EXPR
 776                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
 777               align_expr = TREE_OPERAND (align_expr, 0);
 778
 779             if (TREE_CODE (align_expr) != INTEGER_CST)
 780               {
 781                 error ("requested alignment is not a constant");
 782                 continue;
 783               }
 784
 785             if ((i = tree_log2 (align_expr)) == -1)
 786               error ("requested alignment is not a power of 2");
 787             else if (i > HOST_BITS_PER_INT - 2)
 788               error ("requested alignment is too large");
 789             else if (is_type)
 790               {
 791                 if (decl)
 792                   {
 793                     DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
 794                     DECL_USER_ALIGN (decl) = 1;
 795                   }
 796                 else
 797                   {
 798                     TYPE_ALIGN (type) = (1 << i) * BITS_PER_UNIT;
 799                     TYPE_USER_ALIGN (type) = 1;
 800                   }
 801               }
 802             else if (TREE_CODE (decl) != VAR_DECL
 803                      && TREE_CODE (decl) != FIELD_DECL)
 804               error_with_decl (decl,
 805                                "alignment may not be specified for `%s'");
 806             else
 807               {
 808                 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
 809                 DECL_USER_ALIGN (decl) = 1;
 810               }
 811           }
 812           break;
 813
 814         case A_FORMAT:
 815           {
 816             tree format_type_id = TREE_VALUE (args);
 817             tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 818             tree first_arg_num_expr
 819               = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 820             unsigned HOST_WIDE_INT format_num, first_arg_num;
 821             enum format_type format_type;
 822             tree argument;
 823             unsigned int arg_num;
 824
 825             if (TREE_CODE (decl) != FUNCTION_DECL)
 826               {
 827                 error_with_decl (decl,
 828                          "argument format specified for non-function `%s'");
 829                 continue;
 830               }
 831
 832             if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
 833               {
 834                 error ("unrecognized format specifier");
 835                 continue;
 836               }
 837             else
 838               {
 839                 const char *p = IDENTIFIER_POINTER (format_type_id);
 840
 841                 if (!strcmp (p, "printf") || !strcmp (p, "__printf__"))
 842                   format_type = printf_format_type;
 843                 else if (!strcmp (p, "scanf") || !strcmp (p, "__scanf__"))
 844                   format_type = scanf_format_type;
 845                 else if (!strcmp (p, "strftime")
 846                          || !strcmp (p, "__strftime__"))
 847                   format_type = strftime_format_type;
 848                 else
 849                   {
 850                     warning ("`%s' is an unrecognized format function type", p);
 851                     continue;
 852                   }
 853               }
 854
 855             /* Strip any conversions from the string index and first arg number
 856                and verify they are constants.  */
 857             while (TREE_CODE (format_num_expr) == NOP_EXPR
 858                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 859                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 860               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 861
 862             while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
 863                    || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
 864                    || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
 865               first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
 866
 867             if (TREE_CODE (format_num_expr) != INTEGER_CST
 868                 || TREE_INT_CST_HIGH (format_num_expr) != 0
 869                 || TREE_CODE (first_arg_num_expr) != INTEGER_CST
 870                 || TREE_INT_CST_HIGH (first_arg_num_expr) != 0)
 871               {
 872                 error ("format string has invalid operand number");
 873                 continue;
 874               }
 875
 876             format_num = TREE_INT_CST_LOW (format_num_expr);
 877             first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
 878             if (first_arg_num != 0 && first_arg_num <= format_num)
 879               {
 880                 error ("format string arg follows the args to be formatted");
 881                 continue;
 882               }
 883
 884             /* If a parameter list is specified, verify that the format_num
 885                argument is actually a string, in case the format attribute
 886                is in error.  */
 887             argument = TYPE_ARG_TYPES (type);
 888             if (argument)
 889               {
 890                 for (arg_num = 1; argument != 0 && arg_num != format_num;
 891                      ++arg_num, argument = TREE_CHAIN (argument))
 892                   ;
 893
 894                 if (! argument
 895                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 896                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 897                       != char_type_node))
 898                   {
 899                     error ("format string arg not a string type");
 900                     continue;
 901                   }
 902
 903                 else if (first_arg_num != 0)
 904                   {
 905                     /* Verify that first_arg_num points to the last arg,
 906                        the ...  */
 907                     while (argument)
 908                       arg_num++, argument = TREE_CHAIN (argument);
 909
 910                     if (arg_num != first_arg_num)
 911                       {
 912                         error ("args to be formatted is not '...'");
 913                         continue;
 914                       }
 915                   }
 916               }
 917
 918             record_function_format (DECL_NAME (decl),
 919                                     DECL_ASSEMBLER_NAME (decl),
 920                                     format_type, format_num, first_arg_num);
 921             break;
 922           }
 923
 924         case A_FORMAT_ARG:
 925           {
 926             tree format_num_expr = TREE_VALUE (args);
 927             unsigned HOST_WIDE_INT format_num;
 928             unsigned int arg_num;
 929             tree argument;
 930
 931             if (TREE_CODE (decl) != FUNCTION_DECL)
 932               {
 933                 error_with_decl (decl,
 934                          "argument format specified for non-function `%s'");
 935                 continue;
 936               }
 937
 938             /* Strip any conversions from the first arg number and verify it
 939                is a constant.  */
 940             while (TREE_CODE (format_num_expr) == NOP_EXPR
 941                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 942                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 943               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 944
 945             if (TREE_CODE (format_num_expr) != INTEGER_CST
 946                 || TREE_INT_CST_HIGH (format_num_expr) != 0)
 947               {
 948                 error ("format string has invalid operand number");
 949                 continue;
 950               }
 951
 952             format_num = TREE_INT_CST_LOW (format_num_expr);
 953
 954             /* If a parameter list is specified, verify that the format_num
 955                argument is actually a string, in case the format attribute
 956                is in error.  */
 957             argument = TYPE_ARG_TYPES (type);
 958             if (argument)
 959               {
 960                 for (arg_num = 1; argument != 0 && arg_num != format_num;
 961                      ++arg_num, argument = TREE_CHAIN (argument))
 962                   ;
 963
 964                 if (! argument
 965                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 966                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 967                       != char_type_node))
 968                   {
 969                     error ("format string arg not a string type");
 970                     continue;
 971                   }
 972               }
 973
 974             if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) != POINTER_TYPE
 975                 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl))))
 976                     != char_type_node))
 977               {
 978                 error ("function does not return string type");
 979                 continue;
 980               }
 981
 982             record_international_format (DECL_NAME (decl),
 983                                          DECL_ASSEMBLER_NAME (decl),
 984                                          format_num);
 985             break;
 986           }
 987
 988         case A_WEAK:
 989           declare_weak (decl);
 990           break;
 991
 992         case A_ALIAS:
 993           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
 994               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
 995             error_with_decl (decl,
 996                              "`%s' defined both normally and as an alias");
 997           else if (decl_function_context (decl) == 0)
 998             {
 999               tree id;
1000
1001               id = TREE_VALUE (args);
1002               if (TREE_CODE (id) != STRING_CST)
1003                 {
1004                   error ("alias arg not a string");
1005                   break;
1006                 }
1007               id = get_identifier (TREE_STRING_POINTER (id));
1008               /* This counts as a use of the object pointed to.  */
1009               TREE_USED (id) = 1;
1010
1011               if (TREE_CODE (decl) == FUNCTION_DECL)
1012                 DECL_INITIAL (decl) = error_mark_node;
1013               else
1014                 DECL_EXTERNAL (decl) = 0;
1015               assemble_alias (decl, id);
1016             }
1017           else
1018             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
1019           break;
1020
1021         case A_NO_CHECK_MEMORY_USAGE:
1022           if (TREE_CODE (decl) != FUNCTION_DECL)
1023             {
1024               error_with_decl (decl,
1025                                "`%s' attribute applies only to functions",
1026                                IDENTIFIER_POINTER (name));
1027             }
1028           else if (DECL_INITIAL (decl))
1029             {
1030               error_with_decl (decl,
1031                                "can't set `%s' attribute after definition",
1032                                IDENTIFIER_POINTER (name));
1033             }
1034           else
1035             DECL_NO_CHECK_MEMORY_USAGE (decl) = 1;
1036           break;
1037
1038         case A_NO_INSTRUMENT_FUNCTION:
1039           if (TREE_CODE (decl) != FUNCTION_DECL)
1040             {
1041               error_with_decl (decl,
1042                                "`%s' attribute applies only to functions",
1043                                IDENTIFIER_POINTER (name));
1044             }
1045           else if (DECL_INITIAL (decl))
1046             {
1047               error_with_decl (decl,
1048                                "can't set `%s' attribute after definition",
1049                                IDENTIFIER_POINTER (name));
1050             }
1051           else
1052             DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1053           break;
1054
1055         case A_NO_LIMIT_STACK:
1056           if (TREE_CODE (decl) != FUNCTION_DECL)
1057             {
1058               error_with_decl (decl,
1059                                "`%s' attribute applies only to functions",
1060                                IDENTIFIER_POINTER (name));
1061             }
1062           else if (DECL_INITIAL (decl))
1063             {
1064               error_with_decl (decl,
1065                                "can't set `%s' attribute after definition",
1066                                IDENTIFIER_POINTER (name));
1067             }
1068           else
1069             DECL_NO_LIMIT_STACK (decl) = 1;
1070           break;
1071         }
1072     }
1073 }
1074
1075 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1076    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1077
1078    The head of the declspec list is stored in DECLSPECS.
1079    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1080
1081    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1082    the list elements.  We drop the containing TREE_LIST nodes and link the
1083    resulting attributes together the way decl_attributes expects them.  */
1084
1085 void
1086 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
1087      tree specs_attrs;
1088      tree *declspecs, *prefix_attributes;
1089 {
1090   tree t, s, a, next, specs, attrs;
1091
1092   /* This can happen after an __extension__ in pedantic mode.  */
1093   if (specs_attrs != NULL_TREE
1094       && TREE_CODE (specs_attrs) == INTEGER_CST)
1095     {
1096       *declspecs = NULL_TREE;
1097       *prefix_attributes = NULL_TREE;
1098       return;
1099     }
1100
1101   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
1102   if (specs_attrs != NULL_TREE
1103       && TREE_CODE (specs_attrs) != TREE_LIST)
1104     {
1105       *declspecs = specs_attrs;
1106       *prefix_attributes = NULL_TREE;
1107       return;
1108     }
1109
1110   /* Remember to keep the lists in the same order, element-wise.  */
1111
1112   specs = s = NULL_TREE;
1113   attrs = a = NULL_TREE;
1114   for (t = specs_attrs; t; t = next)
1115     {
1116       next = TREE_CHAIN (t);
1117       /* Declspecs have a non-NULL TREE_VALUE.  */
1118       if (TREE_VALUE (t) != NULL_TREE)
1119         {
1120           if (specs == NULL_TREE)
1121             specs = s = t;
1122           else
1123             {
1124               TREE_CHAIN (s) = t;
1125               s = t;
1126             }
1127         }
1128       else
1129         {
1130           if (attrs == NULL_TREE)
1131             attrs = a = TREE_PURPOSE (t);
1132           else
1133             {
1134               TREE_CHAIN (a) = TREE_PURPOSE (t);
1135               a = TREE_PURPOSE (t);
1136             }
1137           /* More attrs can be linked here, move A to the end.  */
1138           while (TREE_CHAIN (a) != NULL_TREE)
1139             a = TREE_CHAIN (a);
1140         }
1141     }
1142
1143   /* Terminate the lists.  */
1144   if (s != NULL_TREE)
1145     TREE_CHAIN (s) = NULL_TREE;
1146   if (a != NULL_TREE)
1147     TREE_CHAIN (a) = NULL_TREE;
1148
1149   /* All done.  */
1150   *declspecs = specs;
1151   *prefix_attributes = attrs;
1152 }
1153
1154 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1155    This function is used by the parser when a rule will accept attributes
1156    in a particular position, but we don't want to support that just yet.
1157
1158    A warning is issued for every ignored attribute.  */
1159
1160 tree
1161 strip_attrs (specs_attrs)
1162      tree specs_attrs;
1163 {
1164   tree specs, attrs;
1165
1166   split_specs_attrs (specs_attrs, &specs, &attrs);
1167
1168   while (attrs)
1169     {
1170       warning ("`%s' attribute ignored",
1171                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
1172       attrs = TREE_CHAIN (attrs);
1173     }
1174
1175   return specs;
1176 }
1177 \f
1178 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
1179    a parameter list.  */
1180
1181 #define T_I     &integer_type_node
1182 #define T_L     &long_integer_type_node
1183 #define T_LL    &long_long_integer_type_node
1184 #define T_S     &short_integer_type_node
1185 #define T_UI    &unsigned_type_node
1186 #define T_UL    &long_unsigned_type_node
1187 #define T_ULL   &long_long_unsigned_type_node
1188 #define T_US    &short_unsigned_type_node
1189 #define T_F     &float_type_node
1190 #define T_D     &double_type_node
1191 #define T_LD    &long_double_type_node
1192 #define T_C     &char_type_node
1193 #define T_SC    &signed_char_type_node
1194 #define T_UC    &unsigned_char_type_node
1195 #define T_V     &void_type_node
1196 #define T_W     &wchar_type_node
1197 #define T_WI    &wint_type_node
1198 #define T_ST    &sizetype
1199 #define T_SST   &signed_size_type_node
1200 #define T_PD    &ptrdiff_type_node
1201 #define T_UPD   &unsigned_ptrdiff_type_node
1202 #define T_IM    NULL /* intmax_t not yet implemented.  */
1203 #define T_UIM   NULL /* uintmax_t not yet implemented.  */
1204
1205 typedef struct {
1206   const char *format_chars;
1207   int pointer_count;
1208   /* Type of argument if no length modifier is used.  */
1209   tree *nolen;
1210   /* Type of argument if length modifier for shortening to byte is used.
1211      If NULL, then this modifier is not allowed.  */
1212   tree *hhlen;
1213   /* Type of argument if length modifier for shortening is used.
1214      If NULL, then this modifier is not allowed.  */
1215   tree *hlen;
1216   /* Type of argument if length modifier `l' is used.
1217      If NULL, then this modifier is not allowed.  */
1218   tree *llen;
1219   /* Type of argument if length modifier `q' or `ll' is used.
1220      If NULL, then this modifier is not allowed.  */
1221   tree *qlen;
1222   /* Type of argument if length modifier `L' is used.
1223      If NULL, then this modifier is not allowed.  */
1224   tree *bigllen;
1225   /* Type of argument if length modifiers 'z' or `Z' is used.
1226      If NULL, then this modifier is not allowed.  */
1227   tree *zlen;
1228   /* Type of argument if length modifier 't' is used.
1229      If NULL, then this modifier is not allowed.  */
1230   tree *tlen;
1231   /* Type of argument if length modifier 'j' is used.
1232      If NULL, then this modifier is not allowed.  */
1233   tree *jlen;
1234   /* List of other modifier characters allowed with these options.  */
1235   const char *flag_chars;
1236 } format_char_info;
1237
1238 static format_char_info print_char_table[] = {
1239   { "di",       0,      T_I,    T_I,    T_I,    T_L,    T_LL,   T_LL,   T_SST,  T_PD,   T_IM,   "-wp0 +'"       },
1240   { "oxX",      0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   T_UPD,  T_UIM,  "-wp0#"         },
1241   { "u",        0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   T_UPD,  T_UIM,  "-wp0'"         },
1242 /* A GNU extension.  */
1243   { "m",        0,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1244   { "fFgG",     0,      T_D,    NULL,   NULL,   T_D,    NULL,   T_LD,   NULL,   NULL,   NULL,   "-wp0 +#'"      },
1245   { "eEaA",     0,      T_D,    NULL,   NULL,   T_D,    NULL,   T_LD,   NULL,   NULL,   NULL,   "-wp0 +#"       },
1246   { "c",        0,      T_I,    NULL,   NULL,   T_WI,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1247   { "C",        0,      T_WI,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1248   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   "-wpc"          },
1249   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1250   { "p",        1,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wc"           },
1251   { "n",        1,      T_I,    T_SC,   T_S,    T_L,    T_LL,   NULL,   T_SST,  T_PD,   T_IM,   ""              },
1252   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL            }
1253 };
1254
1255 static format_char_info scan_char_table[] = {
1256   { "di",       1,      T_I,    T_SC,   T_S,    T_L,    T_LL,   T_LL,   T_SST,  T_PD,   T_IM,   "*"     },
1257   { "ouxX",     1,      T_UI,   T_UC,   T_US,   T_UL,   T_ULL,  T_ULL,  T_ST,   T_UPD,  T_UIM,  "*"     },
1258   { "efFgEGaA", 1,      T_F,    NULL,   NULL,   T_D,    NULL,   T_LD,   NULL,   NULL,   NULL,   "*"     },
1259   { "c",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   "*c"    },
1260   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   "*ac"   },
1261   { "[",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   "*ac"   },
1262   { "C",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1263   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*a"    },
1264   { "p",        2,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1265   { "n",        1,      T_I,    T_SC,   T_S,    T_L,    T_LL,   NULL,   T_SST,  T_PD,   T_IM,   ""      },
1266   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL    }
1267 };
1268
1269 /* Handle format characters recognized by glibc's strftime.c.
1270    '2' - MUST do years as only two digits
1271    '3' - MAY do years as only two digits (depending on locale)
1272    'E' - E modifier is acceptable
1273    'O' - O modifier is acceptable to Standard C
1274    'o' - O modifier is acceptable as a GNU extension
1275    '9' - added to the C standard in C99
1276    'G' - other GNU extensions  */
1277
1278 static format_char_info time_char_table[] = {
1279   { "y",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2EO-_0w" },
1280   { "D",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "29" },
1281   { "g",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2Oo-_0w9" },
1282   { "cx",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "3E" },
1283   { "%",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "" },
1284   { "X",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "E" },
1285   { "RTnrt",            0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "9" },
1286   { "P",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "G" },
1287   { "HIMSUWdmw",        0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Ow" },
1288   { "e",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Ow9" },
1289   { "j",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Oow" },
1290   { "Vu",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Ow9" },
1291   { "Gz",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Oow9" },
1292   { "kls",              0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0OGw" },
1293   { "ABZa",             0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^#" },
1294   { "p",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "#" },
1295   { "b",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^" },
1296   { "h",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^9" },
1297   { "Y",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0EOow" },
1298   { "F",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "w9" },
1299   { "C",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0EOow9" },
1300   { NULL,               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
1301 };
1302
1303 typedef struct function_format_info
1304 {
1305   struct function_format_info *next;  /* next structure on the list */
1306   tree name;                    /* identifier such as "printf" */
1307   tree assembler_name;          /* optional mangled identifier (for C++) */
1308   enum format_type format_type; /* type of format (printf, scanf, etc.) */
1309   int format_num;               /* number of format argument */
1310   int first_arg_num;            /* number of first arg (zero for varargs) */
1311 } function_format_info;
1312
1313 static function_format_info *function_format_list = NULL;
1314
1315 typedef struct international_format_info
1316 {
1317   struct international_format_info *next;  /* next structure on the list */
1318   tree name;                    /* identifier such as "gettext" */
1319   tree assembler_name;          /* optional mangled identifier (for C++) */
1320   int format_num;               /* number of format argument */
1321 } international_format_info;
1322
1323 static international_format_info *international_format_list = NULL;
1324
1325 static void check_format_info   PARAMS ((function_format_info *, tree));
1326
1327 /* Initialize the table of functions to perform format checking on.
1328    The ANSI functions are always checked (whether <stdio.h> is
1329    included or not), since it is common to call printf without
1330    including <stdio.h>.  There shouldn't be a problem with this,
1331    since ANSI reserves these function names whether you include the
1332    header file or not.  In any case, the checking is harmless.
1333
1334    Also initialize the name of function that modify the format string for
1335    internationalization purposes.  */
1336
1337 void
1338 init_function_format_info ()
1339 {
1340   record_function_format (get_identifier ("printf"), NULL_TREE,
1341                           printf_format_type, 1, 2);
1342   record_function_format (get_identifier ("fprintf"), NULL_TREE,
1343                           printf_format_type, 2, 3);
1344   record_function_format (get_identifier ("sprintf"), NULL_TREE,
1345                           printf_format_type, 2, 3);
1346   record_function_format (get_identifier ("scanf"), NULL_TREE,
1347                           scanf_format_type, 1, 2);
1348   record_function_format (get_identifier ("fscanf"), NULL_TREE,
1349                           scanf_format_type, 2, 3);
1350   record_function_format (get_identifier ("sscanf"), NULL_TREE,
1351                           scanf_format_type, 2, 3);
1352   record_function_format (get_identifier ("vprintf"), NULL_TREE,
1353                           printf_format_type, 1, 0);
1354   record_function_format (get_identifier ("vfprintf"), NULL_TREE,
1355                           printf_format_type, 2, 0);
1356   record_function_format (get_identifier ("vsprintf"), NULL_TREE,
1357                           printf_format_type, 2, 0);
1358   record_function_format (get_identifier ("strftime"), NULL_TREE,
1359                           strftime_format_type, 3, 0);
1360
1361   if (flag_isoc99)
1362     {
1363       /* ISO C99 adds the snprintf and vscanf family functions.  */
1364       record_function_format (get_identifier ("snprintf"), NULL_TREE,
1365                               printf_format_type, 3, 4);
1366       record_function_format (get_identifier ("vsnprintf"), NULL_TREE,
1367                               printf_format_type, 3, 0);
1368       record_function_format (get_identifier ("vscanf"), NULL_TREE,
1369                               scanf_format_type, 1, 0);
1370       record_function_format (get_identifier ("vfscanf"), NULL_TREE,
1371                               scanf_format_type, 2, 0);
1372       record_function_format (get_identifier ("vsscanf"), NULL_TREE,
1373                               scanf_format_type, 2, 0);
1374     }
1375
1376   record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1377   record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1378   record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1379 }
1380
1381 /* Record information for argument format checking.  FUNCTION_IDENT is
1382    the identifier node for the name of the function to check (its decl
1383    need not exist yet).
1384    FORMAT_TYPE specifies the type of format checking.  FORMAT_NUM is the number
1385    of the argument which is the format control string (starting from 1).
1386    FIRST_ARG_NUM is the number of the first actual argument to check
1387    against the format string, or zero if no checking is not be done
1388    (e.g. for varargs such as vfprintf).  */
1389
1390 static void
1391 record_function_format (name, assembler_name, format_type,
1392                         format_num, first_arg_num)
1393       tree name;
1394       tree assembler_name;
1395       enum format_type format_type;
1396       int format_num;
1397       int first_arg_num;
1398 {
1399   function_format_info *info;
1400
1401   /* Re-use existing structure if it's there.  */
1402
1403   for (info = function_format_list; info; info = info->next)
1404     {
1405       if (info->name == name && info->assembler_name == assembler_name)
1406         break;
1407     }
1408   if (! info)
1409     {
1410       info = (function_format_info *) xmalloc (sizeof (function_format_info));
1411       info->next = function_format_list;
1412       function_format_list = info;
1413
1414       info->name = name;
1415       info->assembler_name = assembler_name;
1416     }
1417
1418   info->format_type = format_type;
1419   info->format_num = format_num;
1420   info->first_arg_num = first_arg_num;
1421 }
1422
1423 /* Record information for the names of function that modify the format
1424    argument to format functions.  FUNCTION_IDENT is the identifier node for
1425    the name of the function (its decl need not exist yet) and FORMAT_NUM is
1426    the number of the argument which is the format control string (starting
1427    from 1).  */
1428
1429 static void
1430 record_international_format (name, assembler_name, format_num)
1431       tree name;
1432       tree assembler_name;
1433       int format_num;
1434 {
1435   international_format_info *info;
1436
1437   /* Re-use existing structure if it's there.  */
1438
1439   for (info = international_format_list; info; info = info->next)
1440     {
1441       if (info->name == name && info->assembler_name == assembler_name)
1442         break;
1443     }
1444
1445   if (! info)
1446     {
1447       info
1448         = (international_format_info *)
1449           xmalloc (sizeof (international_format_info));
1450       info->next = international_format_list;
1451       international_format_list = info;
1452
1453       info->name = name;
1454       info->assembler_name = assembler_name;
1455     }
1456
1457   info->format_num = format_num;
1458 }
1459
1460 static void
1461 tfaff ()
1462 {
1463   warning ("too few arguments for format");
1464 }
1465 \f
1466 /* Check the argument list of a call to printf, scanf, etc.
1467    NAME is the function identifier.
1468    ASSEMBLER_NAME is the function's assembler identifier.
1469    (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1470    PARAMS is the list of argument values.  */
1471
1472 void
1473 check_function_format (name, assembler_name, params)
1474      tree name;
1475      tree assembler_name;
1476      tree params;
1477 {
1478   function_format_info *info;
1479
1480   /* See if this function is a format function.  */
1481   for (info = function_format_list; info; info = info->next)
1482     {
1483       if (info->assembler_name
1484           ? (info->assembler_name == assembler_name)
1485           : (info->name == name))
1486         {
1487           /* Yup; check it.  */
1488           check_format_info (info, params);
1489           break;
1490         }
1491     }
1492 }
1493
1494 /* Check the argument list of a call to printf, scanf, etc.
1495    INFO points to the function_format_info structure.
1496    PARAMS is the list of argument values.  */
1497
1498 static void
1499 check_format_info (info, params)
1500      function_format_info *info;
1501      tree params;
1502 {
1503   int i;
1504   int arg_num;
1505   int suppressed, wide, precise;
1506   int length_char = 0;
1507   int format_char;
1508   int format_length;
1509   tree format_tree;
1510   tree cur_param;
1511   tree cur_type;
1512   tree wanted_type;
1513   tree first_fillin_param;
1514   const char *format_chars;
1515   format_char_info *fci = NULL;
1516   char flag_chars[8];
1517   int has_operand_number = 0;
1518
1519   /* Skip to format argument.  If the argument isn't available, there's
1520      no work for us to do; prototype checking will catch the problem.  */
1521   for (arg_num = 1; ; ++arg_num)
1522     {
1523       if (params == 0)
1524         return;
1525       if (arg_num == info->format_num)
1526         break;
1527       params = TREE_CHAIN (params);
1528     }
1529   format_tree = TREE_VALUE (params);
1530   params = TREE_CHAIN (params);
1531   if (format_tree == 0)
1532     return;
1533
1534   /* We can only check the format if it's a string constant.  */
1535   while (TREE_CODE (format_tree) == NOP_EXPR)
1536     format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
1537
1538   if (TREE_CODE (format_tree) == CALL_EXPR
1539       && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
1540       && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
1541           == FUNCTION_DECL))
1542     {
1543       tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
1544
1545       /* See if this is a call to a known internationalization function
1546          that modifies the format arg.  */
1547       international_format_info *info;
1548
1549       for (info = international_format_list; info; info = info->next)
1550         if (info->assembler_name
1551             ? (info->assembler_name == DECL_ASSEMBLER_NAME (function))
1552             : (info->name == DECL_NAME (function)))
1553           {
1554             tree inner_args;
1555             int i;
1556
1557             for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
1558                  inner_args != 0;
1559                  inner_args = TREE_CHAIN (inner_args), i++)
1560               if (i == info->format_num)
1561                 {
1562                   format_tree = TREE_VALUE (inner_args);
1563
1564                   while (TREE_CODE (format_tree) == NOP_EXPR)
1565                     format_tree = TREE_OPERAND (format_tree, 0);
1566                 }
1567           }
1568     }
1569
1570   if (integer_zerop (format_tree))
1571     {
1572       warning ("null format string");
1573       return;
1574     }
1575   if (TREE_CODE (format_tree) != ADDR_EXPR)
1576     {
1577       /* The user may get multiple warnings if the supplied argument
1578          isn't even a string pointer.  */
1579       /* Functions taking a va_list normally pass a non-literal format
1580          string.  These functions typically are declared with
1581          first_arg_num == 0, so avoid warning in those cases.  */
1582       if (info->first_arg_num != 0 && warn_format > 1)
1583         warning ("format not a string literal, argument types not checked");
1584       return;
1585     }
1586   format_tree = TREE_OPERAND (format_tree, 0);
1587   if (TREE_CODE (format_tree) != STRING_CST)
1588     {
1589       /* The user may get multiple warnings if the supplied argument
1590          isn't even a string pointer.  */
1591       /* Functions taking a va_list normally pass a non-literal format
1592          string.  These functions typically are declared with
1593          first_arg_num == 0, so avoid warning in those cases.  */
1594       if (info->first_arg_num != 0 && warn_format > 1)
1595         warning ("format not a string literal, argument types not checked");
1596       return;
1597     }
1598   format_chars = TREE_STRING_POINTER (format_tree);
1599   format_length = TREE_STRING_LENGTH (format_tree);
1600   if (format_length <= 1)
1601     warning ("zero-length format string");
1602   if (format_chars[--format_length] != 0)
1603     {
1604       warning ("unterminated format string");
1605       return;
1606     }
1607   /* Skip to first argument to check.  */
1608   while (arg_num + 1 < info->first_arg_num)
1609     {
1610       if (params == 0)
1611         return;
1612       params = TREE_CHAIN (params);
1613       ++arg_num;
1614     }
1615
1616   first_fillin_param = params;
1617   while (1)
1618     {
1619       int aflag;
1620       int char_type_flag = 0;
1621       if (*format_chars == 0)
1622         {
1623           if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
1624             warning ("embedded `\\0' in format");
1625           if (info->first_arg_num != 0 && params != 0 && ! has_operand_number)
1626             warning ("too many arguments for format");
1627           return;
1628         }
1629       if (*format_chars++ != '%')
1630         continue;
1631       if (*format_chars == 0)
1632         {
1633           warning ("spurious trailing `%%' in format");
1634           continue;
1635         }
1636       if (*format_chars == '%')
1637         {
1638           ++format_chars;
1639           continue;
1640         }
1641       flag_chars[0] = 0;
1642       suppressed = wide = precise = FALSE;
1643       if (info->format_type == scanf_format_type)
1644         {
1645           suppressed = *format_chars == '*';
1646           if (suppressed)
1647             ++format_chars;
1648           while (ISDIGIT (*format_chars))
1649             ++format_chars;
1650         }
1651       else if (info->format_type == strftime_format_type)
1652         {
1653           while (*format_chars != 0 && index ("_-0^#", *format_chars) != 0)
1654             {
1655               if (pedantic)
1656                 warning ("ANSI C does not support the strftime `%c' flag",
1657                          *format_chars);
1658               if (index (flag_chars, *format_chars) != 0)
1659                 {
1660                   warning ("repeated `%c' flag in format",
1661                            *format_chars);
1662                   ++format_chars;
1663                 }
1664               else
1665                 {
1666                   i = strlen (flag_chars);
1667                   flag_chars[i++] = *format_chars++;
1668                   flag_chars[i] = 0;
1669                 }
1670             }
1671           while (ISDIGIT ((unsigned char) *format_chars))
1672             {
1673               wide = TRUE;
1674               ++format_chars;
1675             }
1676           if (wide && pedantic)
1677             warning ("ANSI C does not support strftime format width");
1678           if (*format_chars == 'E' || *format_chars == 'O')
1679             {
1680               i = strlen (flag_chars);
1681               flag_chars[i++] = *format_chars++;
1682               flag_chars[i] = 0;
1683               if (*format_chars == 'E' || *format_chars == 'O')
1684                 {
1685                   warning ("multiple E/O modifiers in format");
1686                   while (*format_chars == 'E' || *format_chars == 'O')
1687                     ++format_chars;
1688                 }
1689             }
1690         }
1691       else if (info->format_type == printf_format_type)
1692         {
1693           /* See if we have a number followed by a dollar sign.  If we do,
1694              it is an operand number, so set PARAMS to that operand.  */
1695           if (*format_chars >= '0' && *format_chars <= '9')
1696             {
1697               const char *p = format_chars;
1698
1699               while (*p >= '0' && *p++ <= '9')
1700                 ;
1701
1702               if (*p == '$')
1703                 {
1704                   int opnum = atoi (format_chars);
1705
1706                   if (pedantic)
1707                     warning ("ANSI C does not support printf %%n$");
1708
1709                   params = first_fillin_param;
1710                   format_chars = p + 1;
1711                   has_operand_number = 1;
1712
1713                   for (i = 1; i < opnum && params != 0; i++)
1714                     params = TREE_CHAIN (params);
1715
1716                   if (opnum == 0 || params == 0)
1717                     {
1718                       warning ("operand number out of range in format");
1719                       return;
1720                     }
1721                 }
1722             }
1723
1724           while (*format_chars != 0 && index (" +#0-'", *format_chars) != 0)
1725             {
1726               if (index (flag_chars, *format_chars) != 0)
1727                 warning ("repeated `%c' flag in format", *format_chars++);
1728               else
1729                 {
1730                   i = strlen (flag_chars);
1731                   flag_chars[i++] = *format_chars++;
1732                   flag_chars[i] = 0;
1733                 }
1734             }
1735           /* "If the space and + flags both appear,
1736              the space flag will be ignored."  */
1737           if (index (flag_chars, ' ') != 0
1738               && index (flag_chars, '+') != 0)
1739             warning ("use of both ` ' and `+' flags in format");
1740           /* "If the 0 and - flags both appear,
1741              the 0 flag will be ignored."  */
1742           if (index (flag_chars, '0') != 0
1743               && index (flag_chars, '-') != 0)
1744             warning ("use of both `0' and `-' flags in format");
1745           if (index (flag_chars, '\'') && pedantic)
1746             warning ("ANSI C does not support the `'' format flag");
1747           if (*format_chars == '*')
1748             {
1749               wide = TRUE;
1750               /* "...a field width...may be indicated by an asterisk.
1751                  In this case, an int argument supplies the field width..."  */
1752               ++format_chars;
1753               if (params == 0)
1754                 {
1755                   tfaff ();
1756                   return;
1757                 }
1758               if (info->first_arg_num != 0)
1759                 {
1760                   cur_param = TREE_VALUE (params);
1761                   params = TREE_CHAIN (params);
1762                   ++arg_num;
1763                   /* size_t is generally not valid here.
1764                      It will work on most machines, because size_t and int
1765                      have the same mode.  But might as well warn anyway,
1766                      since it will fail on other machines.  */
1767                   if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1768                        != integer_type_node)
1769                       &&
1770                       (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1771                        != unsigned_type_node))
1772                     warning ("field width is not type int (arg %d)", arg_num);
1773                 }
1774             }
1775           else
1776             {
1777               while (ISDIGIT (*format_chars))
1778                 {
1779                   wide = TRUE;
1780                   ++format_chars;
1781                 }
1782             }
1783           if (*format_chars == '.')
1784             {
1785               precise = TRUE;
1786               ++format_chars;
1787               /* "...a...precision...may be indicated by an asterisk.
1788                  In this case, an int argument supplies the...precision."  */
1789               if (*format_chars == '*')
1790                 {
1791                   if (info->first_arg_num != 0)
1792                     {
1793                       ++format_chars;
1794                       if (params == 0)
1795                         {
1796                           tfaff ();
1797                           return;
1798                         }
1799                       cur_param = TREE_VALUE (params);
1800                       params = TREE_CHAIN (params);
1801                       ++arg_num;
1802                       if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1803                            != integer_type_node)
1804                           &&
1805                           (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1806                            != unsigned_type_node))
1807                         warning ("field precision is not type int (arg %d)",
1808                                  arg_num);
1809                     }
1810                 }
1811               else
1812                 {
1813                   while (ISDIGIT (*format_chars))
1814                     ++format_chars;
1815                 }
1816             }
1817         }
1818
1819       aflag = 0;
1820
1821       if (info->format_type != strftime_format_type)
1822         {
1823           if (*format_chars == 'h' || *format_chars == 'l')
1824             length_char = *format_chars++;
1825           else if (*format_chars == 'q' || *format_chars == 'L')
1826             {
1827               length_char = *format_chars++;
1828               if (length_char == 'q' && pedantic)
1829                 warning ("ANSI C does not support the `%c' length modifier",
1830                          length_char);
1831             }
1832           else if (*format_chars == 'Z' || *format_chars == 'z')
1833             {
1834               length_char = *format_chars++;
1835               if (pedantic && (length_char == 'Z' || !flag_isoc99))
1836                 warning ("ANSI C does not support the `%c' length modifier",
1837                          length_char);
1838             }
1839           else if (*format_chars == 't' || *format_chars == 'j')
1840             {
1841               length_char = *format_chars++;
1842               if (pedantic && !flag_isoc99)
1843                 warning ("ANSI C does not support the `%c' length modifier",
1844                          length_char);
1845             }
1846           else
1847             length_char = 0;
1848           if (length_char == 'l' && *format_chars == 'l')
1849             {
1850               length_char = 'q', format_chars++;
1851               if (pedantic && !flag_isoc99)
1852                 warning ("ANSI C does not support the `ll' length modifier");
1853             }
1854           else if (length_char == 'h' && *format_chars == 'h')
1855             {
1856               length_char = 'H', format_chars++;
1857               if (pedantic && !flag_isoc99)
1858                 warning ("ANSI C does not support the `hh' length modifier");
1859             }
1860           if (*format_chars == 'a' && info->format_type == scanf_format_type)
1861             {
1862               if (format_chars[1] == 's' || format_chars[1] == 'S'
1863                   || format_chars[1] == '[')
1864                 {
1865                   /* `a' is used as a flag.  */
1866                   aflag = 1;
1867                   format_chars++;
1868                 }
1869             }
1870           if (suppressed && length_char != 0)
1871             warning ("use of `*' and `%c' together in format", length_char);
1872         }
1873       format_char = *format_chars;
1874       if (format_char == 0
1875           || (info->format_type != strftime_format_type && format_char == '%'))
1876         {
1877           warning ("conversion lacks type at end of format");
1878           continue;
1879         }
1880       /* The m, C, and S formats are GNU extensions.  */
1881       if (pedantic && info->format_type != strftime_format_type
1882           && (format_char == 'm' || format_char == 'C' || format_char == 'S'))
1883         warning ("ANSI C does not support the `%c' format", format_char);
1884       /* The a, A and F formats are C99 extensions.  */
1885       if (pedantic && info->format_type != strftime_format_type
1886           && (format_char == 'a' || format_char == 'A' || format_char == 'F')
1887           && !flag_isoc99)
1888         warning ("ANSI C does not support the `%c' format", format_char);
1889       format_chars++;
1890       switch (info->format_type)
1891         {
1892         case printf_format_type:
1893           fci = print_char_table;
1894           break;
1895         case scanf_format_type:
1896           fci = scan_char_table;
1897           break;
1898         case strftime_format_type:
1899           fci = time_char_table;
1900           break;
1901         default:
1902           abort ();
1903         }
1904       while (fci->format_chars != 0
1905              && index (fci->format_chars, format_char) == 0)
1906           ++fci;
1907       if (fci->format_chars == 0)
1908         {
1909           if (ISGRAPH(format_char))
1910             warning ("unknown conversion type character `%c' in format",
1911                      format_char);
1912           else
1913             warning ("unknown conversion type character 0x%x in format",
1914                      format_char);
1915           continue;
1916         }
1917       if (pedantic)
1918         {
1919           if (index (fci->flag_chars, 'G') != 0)
1920             warning ("ANSI C does not support `%%%c'", format_char);
1921           if (index (fci->flag_chars, '9') != 0 && !flag_isoc99)
1922             warning ("ANSI C does not support `%%%c'", format_char);
1923           if ((index (fci->flag_chars, 'o') != 0
1924                || (!flag_isoc99 && index (fci->flag_chars, 'O') != 0))
1925               && index (flag_chars, 'O') != 0)
1926             warning ("ANSI C does not support `%%O%c'", format_char);
1927           if (!flag_isoc99 && index (flag_chars, 'E'))
1928             warning ("ANSI C does not support `%%E%c'", format_char);
1929         }
1930       if (wide && index (fci->flag_chars, 'w') == 0)
1931         warning ("width used with `%c' format", format_char);
1932       if (index (fci->flag_chars, '2') != 0)
1933         warning ("`%%%c' yields only last 2 digits of year", format_char);
1934       else if (index (fci->flag_chars, '3') != 0)
1935         warning ("`%%%c' yields only last 2 digits of year in some locales",
1936                  format_char);
1937       if (precise && index (fci->flag_chars, 'p') == 0)
1938         warning ("precision used with `%c' format", format_char);
1939       if (aflag && index (fci->flag_chars, 'a') == 0)
1940         {
1941           warning ("`a' flag used with `%c' format", format_char);
1942           /* To simplify the following code.  */
1943           aflag = 0;
1944         }
1945       /* The a flag is a GNU extension.  */
1946       else if (pedantic && aflag)
1947         warning ("ANSI C does not support the `a' flag");
1948       if (info->format_type == scanf_format_type && format_char == '[')
1949         {
1950           /* Skip over scan set, in case it happens to have '%' in it.  */
1951           if (*format_chars == '^')
1952             ++format_chars;
1953           /* Find closing bracket; if one is hit immediately, then
1954              it's part of the scan set rather than a terminator.  */
1955           if (*format_chars == ']')
1956             ++format_chars;
1957           while (*format_chars && *format_chars != ']')
1958             ++format_chars;
1959           if (*format_chars != ']')
1960             /* The end of the format string was reached.  */
1961             warning ("no closing `]' for `%%[' format");
1962         }
1963       if (suppressed)
1964         {
1965           if (index (fci->flag_chars, '*') == 0)
1966             warning ("suppression of `%c' conversion in format", format_char);
1967           continue;
1968         }
1969       for (i = 0; flag_chars[i] != 0; ++i)
1970         {
1971           if (index (fci->flag_chars, flag_chars[i]) == 0)
1972             warning ("flag `%c' used with type `%c'",
1973                      flag_chars[i], format_char);
1974         }
1975       if (info->format_type == strftime_format_type)
1976         continue;
1977       if (precise && index (flag_chars, '0') != 0
1978           && (format_char == 'd' || format_char == 'i'
1979               || format_char == 'o' || format_char == 'u'
1980               || format_char == 'x' || format_char == 'X'))
1981         warning ("`0' flag ignored with precision specifier and `%c' format",
1982                  format_char);
1983       switch (length_char)
1984         {
1985         default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
1986         case 'H': wanted_type = fci->hhlen ? *(fci->hhlen) : 0; break;
1987         case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
1988         case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
1989         case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
1990         case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
1991         case 'z': case 'Z': wanted_type = (fci->zlen
1992                                            ? (TYPE_DOMAIN (*fci->zlen)
1993                                               ? TYPE_DOMAIN (*fci->zlen)
1994                                               : *fci->zlen)
1995                                            : 0); break;
1996         case 't': wanted_type = fci->tlen ? *(fci->tlen) : 0; break;
1997         case 'j': wanted_type = fci->jlen ? *(fci->jlen) : 0; break;
1998         }
1999       if (wanted_type == 0)
2000         warning ("use of `%c' length character with `%c' type character",
2001                  length_char, format_char);
2002       else if (length_char == 'L' && pedantic
2003                && !(format_char == 'a' || format_char == 'A'
2004                     || format_char == 'e' || format_char == 'E'
2005                     || format_char == 'f' || format_char == 'F'
2006                     || format_char == 'g' || format_char == 'G'))
2007         warning ("ANSI C does not support the `L' length modifier with the `%c' type character",
2008                  format_char);
2009       else if (length_char == 'l'
2010                && (format_char == 'c' || format_char == 's'
2011                    || format_char == '[')
2012                && pedantic && !flag_isoc94)
2013         warning ("ANSI C89 does not support the `l' length modifier with the `%c' type character",
2014                  format_char);
2015       else if (info->format_type == printf_format_type && pedantic
2016                && !flag_isoc99 && length_char == 'l'
2017                && (format_char == 'f' || format_char == 'e'
2018                    || format_char == 'E' || format_char == 'g'
2019                    || format_char == 'G'))
2020         warning ("ANSI C does not support the `l' length modifier with the `%c' type character",
2021                  format_char);
2022
2023       /* Finally. . .check type of argument against desired type!  */
2024       if (info->first_arg_num == 0)
2025         continue;
2026       if (fci->pointer_count == 0 && wanted_type == void_type_node)
2027         /* This specifier takes no argument.  */
2028         continue;
2029       if (params == 0)
2030         {
2031           tfaff ();
2032           return;
2033         }
2034       cur_param = TREE_VALUE (params);
2035       params = TREE_CHAIN (params);
2036       ++arg_num;
2037       cur_type = TREE_TYPE (cur_param);
2038
2039       STRIP_NOPS (cur_param);
2040
2041       /* Check the types of any additional pointer arguments
2042          that precede the "real" argument.  */
2043       for (i = 0; i < fci->pointer_count + aflag; ++i)
2044         {
2045           if (TREE_CODE (cur_type) == POINTER_TYPE)
2046             {
2047               cur_type = TREE_TYPE (cur_type);
2048
2049               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
2050                 cur_param = TREE_OPERAND (cur_param, 0);
2051               else
2052                 cur_param = 0;
2053
2054               continue;
2055             }
2056           if (TREE_CODE (cur_type) != ERROR_MARK)
2057             {
2058               if (fci->pointer_count + aflag == 1)
2059                 warning ("format argument is not a pointer (arg %d)", arg_num);
2060               else
2061                 warning ("format argument is not a pointer to a pointer (arg %d)", arg_num);
2062             }
2063           break;
2064         }
2065
2066       /* See if this is an attempt to write into a const type with
2067          scanf or with printf "%n".  */
2068       if ((info->format_type == scanf_format_type
2069            || (info->format_type == printf_format_type
2070                && format_char == 'n'))
2071           && i == fci->pointer_count + aflag
2072           && wanted_type != 0
2073           && TREE_CODE (cur_type) != ERROR_MARK
2074           && (TYPE_READONLY (cur_type)
2075               || (cur_param != 0
2076                   && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
2077                       || (DECL_P (cur_param) && TREE_READONLY (cur_param))))))
2078         warning ("writing into constant object (arg %d)", arg_num);
2079
2080       /* Check whether the argument type is a character type.  This leniency
2081          only applies to certain formats, flagged with 'c'.
2082       */
2083       if (TREE_CODE (cur_type) != ERROR_MARK && index (fci->flag_chars, 'c') != 0)
2084         char_type_flag = (TYPE_MAIN_VARIANT (cur_type) == char_type_node
2085                           || TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node
2086                           || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node);
2087
2088       /* Check the type of the "real" argument, if there's a type we want.  */
2089       if (i == fci->pointer_count + aflag && wanted_type != 0
2090           && TREE_CODE (cur_type) != ERROR_MARK
2091           && wanted_type != TYPE_MAIN_VARIANT (cur_type)
2092           /* If we want `void *', allow any pointer type.
2093              (Anything else would already have got a warning.)
2094              With -pedantic, only allow pointers to void and to character
2095              types.
2096           */
2097           && ! (wanted_type == void_type_node
2098                 && fci->pointer_count > 0
2099                 && (! pedantic
2100                     || TYPE_MAIN_VARIANT (cur_type) == void_type_node
2101                     || (i == 1 && char_type_flag)))
2102           /* Don't warn about differences merely in signedness, unless
2103              -pedantic.  With -pedantic, warn if the type is a pointer
2104              target and not a character type, and for character types at
2105              a second level of indirection.
2106           */
2107           && !(TREE_CODE (wanted_type) == INTEGER_TYPE
2108                && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE
2109                && (! pedantic || i == 0 || (i == 1 && char_type_flag))
2110                && (TREE_UNSIGNED (wanted_type)
2111                    ? wanted_type == (cur_type = unsigned_type (cur_type))
2112                    : wanted_type == (cur_type = signed_type (cur_type))))
2113           /* Likewise, "signed char", "unsigned char" and "char" are
2114              equivalent but the above test won't consider them equivalent.  */
2115           && ! (wanted_type == char_type_node
2116                 && (! pedantic || i < 2)
2117                 && char_type_flag))
2118         {
2119           register const char *this;
2120           register const char *that;
2121
2122           this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
2123           that = 0;
2124           if (TREE_CODE (cur_type) != ERROR_MARK
2125               && TYPE_NAME (cur_type) != 0
2126               && TREE_CODE (cur_type) != INTEGER_TYPE
2127               && !(TREE_CODE (cur_type) == POINTER_TYPE
2128                    && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
2129             {
2130               if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
2131                   && DECL_NAME (TYPE_NAME (cur_type)) != 0)
2132                 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
2133               else
2134                 that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
2135             }
2136
2137           /* A nameless type can't possibly match what the format wants.
2138              So there will be a warning for it.
2139              Make up a string to describe vaguely what it is.  */
2140           if (that == 0)
2141             {
2142               if (TREE_CODE (cur_type) == POINTER_TYPE)
2143                 that = "pointer";
2144               else
2145                 that = "different type";
2146             }
2147
2148           /* Make the warning better in case of mismatch of int vs long.  */
2149           if (TREE_CODE (cur_type) == INTEGER_TYPE
2150               && TREE_CODE (wanted_type) == INTEGER_TYPE
2151               && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type)
2152               && TYPE_NAME (cur_type) != 0
2153               && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL)
2154             that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
2155
2156           if (strcmp (this, that) != 0)
2157             warning ("%s format, %s arg (arg %d)", this, that, arg_num);
2158         }
2159     }
2160 }
2161 \f
2162 /* Print a warning if a constant expression had overflow in folding.
2163    Invoke this function on every expression that the language
2164    requires to be a constant expression.
2165    Note the ANSI C standard says it is erroneous for a
2166    constant expression to overflow.  */
2167
2168 void
2169 constant_expression_warning (value)
2170      tree value;
2171 {
2172   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
2173        || TREE_CODE (value) == COMPLEX_CST)
2174       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
2175     pedwarn ("overflow in constant expression");
2176 }
2177
2178 /* Print a warning if an expression had overflow in folding.
2179    Invoke this function on every expression that
2180    (1) appears in the source code, and
2181    (2) might be a constant expression that overflowed, and
2182    (3) is not already checked by convert_and_check;
2183    however, do not invoke this function on operands of explicit casts.  */
2184
2185 void
2186 overflow_warning (value)
2187      tree value;
2188 {
2189   if ((TREE_CODE (value) == INTEGER_CST
2190        || (TREE_CODE (value) == COMPLEX_CST
2191            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
2192       && TREE_OVERFLOW (value))
2193     {
2194       TREE_OVERFLOW (value) = 0;
2195       if (skip_evaluation == 0)
2196         warning ("integer overflow in expression");
2197     }
2198   else if ((TREE_CODE (value) == REAL_CST
2199             || (TREE_CODE (value) == COMPLEX_CST
2200                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
2201            && TREE_OVERFLOW (value))
2202     {
2203       TREE_OVERFLOW (value) = 0;
2204       if (skip_evaluation == 0)
2205         warning ("floating point overflow in expression");
2206     }
2207 }
2208
2209 /* Print a warning if a large constant is truncated to unsigned,
2210    or if -Wconversion is used and a constant < 0 is converted to unsigned.
2211    Invoke this function on every expression that might be implicitly
2212    converted to an unsigned type.  */
2213
2214 void
2215 unsigned_conversion_warning (result, operand)
2216      tree result, operand;
2217 {
2218   if (TREE_CODE (operand) == INTEGER_CST
2219       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
2220       && TREE_UNSIGNED (TREE_TYPE (result))
2221       && skip_evaluation == 0
2222       && !int_fits_type_p (operand, TREE_TYPE (result)))
2223     {
2224       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
2225         /* This detects cases like converting -129 or 256 to unsigned char.  */
2226         warning ("large integer implicitly truncated to unsigned type");
2227       else if (warn_conversion)
2228         warning ("negative integer implicitly converted to unsigned type");
2229     }
2230 }
2231
2232 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2233    Invoke this function on every expression that is converted implicitly,
2234    i.e. because of language rules and not because of an explicit cast.  */
2235
2236 tree
2237 convert_and_check (type, expr)
2238      tree type, expr;
2239 {
2240   tree t = convert (type, expr);
2241   if (TREE_CODE (t) == INTEGER_CST)
2242     {
2243       if (TREE_OVERFLOW (t))
2244         {
2245           TREE_OVERFLOW (t) = 0;
2246
2247           /* Do not diagnose overflow in a constant expression merely
2248              because a conversion overflowed.  */
2249           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
2250
2251           /* No warning for converting 0x80000000 to int.  */
2252           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
2253                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
2254                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
2255             /* If EXPR fits in the unsigned version of TYPE,
2256                don't warn unless pedantic.  */
2257             if ((pedantic
2258                  || TREE_UNSIGNED (type)
2259                  || ! int_fits_type_p (expr, unsigned_type (type)))
2260                 && skip_evaluation == 0)
2261               warning ("overflow in implicit constant conversion");
2262         }
2263       else
2264         unsigned_conversion_warning (t, expr);
2265     }
2266   return t;
2267 }
2268 \f
2269 void
2270 c_expand_expr_stmt (expr)
2271      tree expr;
2272 {
2273   /* Do default conversion if safe and possibly important,
2274      in case within ({...}).  */
2275   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
2276       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
2277     expr = default_conversion (expr);
2278
2279   if (TREE_TYPE (expr) != error_mark_node
2280       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
2281       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
2282     error ("expression statement has incomplete type");
2283
2284   expand_expr_stmt (expr);
2285 }
2286 \f
2287 /* Validate the expression after `case' and apply default promotions.  */
2288
2289 tree
2290 check_case_value (value)
2291      tree value;
2292 {
2293   if (value == NULL_TREE)
2294     return value;
2295
2296   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
2297   STRIP_TYPE_NOPS (value);
2298
2299   if (TREE_CODE (value) != INTEGER_CST
2300       && value != error_mark_node)
2301     {
2302       error ("case label does not reduce to an integer constant");
2303       value = error_mark_node;
2304     }
2305   else
2306     /* Promote char or short to int.  */
2307     value = default_conversion (value);
2308
2309   constant_expression_warning (value);
2310
2311   return value;
2312 }
2313 \f
2314 /* Return an integer type with BITS bits of precision,
2315    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2316
2317 tree
2318 type_for_size (bits, unsignedp)
2319      unsigned bits;
2320      int unsignedp;
2321 {
2322   if (bits == TYPE_PRECISION (integer_type_node))
2323     return unsignedp ? unsigned_type_node : integer_type_node;
2324
2325   if (bits == TYPE_PRECISION (signed_char_type_node))
2326     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2327
2328   if (bits == TYPE_PRECISION (short_integer_type_node))
2329     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2330
2331   if (bits == TYPE_PRECISION (long_integer_type_node))
2332     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2333
2334   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2335     return (unsignedp ? long_long_unsigned_type_node
2336             : long_long_integer_type_node);
2337
2338   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2339     return (unsignedp ? widest_unsigned_literal_type_node
2340             : widest_integer_literal_type_node);
2341
2342   if (bits <= TYPE_PRECISION (intQI_type_node))
2343     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2344
2345   if (bits <= TYPE_PRECISION (intHI_type_node))
2346     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2347
2348   if (bits <= TYPE_PRECISION (intSI_type_node))
2349     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2350
2351   if (bits <= TYPE_PRECISION (intDI_type_node))
2352     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2353
2354   return 0;
2355 }
2356
2357 /* Return a data type that has machine mode MODE.
2358    If the mode is an integer,
2359    then UNSIGNEDP selects between signed and unsigned types.  */
2360
2361 tree
2362 type_for_mode (mode, unsignedp)
2363      enum machine_mode mode;
2364      int unsignedp;
2365 {
2366   if (mode == TYPE_MODE (integer_type_node))
2367     return unsignedp ? unsigned_type_node : integer_type_node;
2368
2369   if (mode == TYPE_MODE (signed_char_type_node))
2370     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2371
2372   if (mode == TYPE_MODE (short_integer_type_node))
2373     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2374
2375   if (mode == TYPE_MODE (long_integer_type_node))
2376     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2377
2378   if (mode == TYPE_MODE (long_long_integer_type_node))
2379     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2380
2381   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2382     return unsignedp ? widest_unsigned_literal_type_node
2383                      : widest_integer_literal_type_node;
2384
2385   if (mode == TYPE_MODE (intQI_type_node))
2386     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2387
2388   if (mode == TYPE_MODE (intHI_type_node))
2389     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2390
2391   if (mode == TYPE_MODE (intSI_type_node))
2392     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2393
2394   if (mode == TYPE_MODE (intDI_type_node))
2395     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2396
2397 #if HOST_BITS_PER_WIDE_INT >= 64
2398   if (mode == TYPE_MODE (intTI_type_node))
2399     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2400 #endif
2401
2402   if (mode == TYPE_MODE (float_type_node))
2403     return float_type_node;
2404
2405   if (mode == TYPE_MODE (double_type_node))
2406     return double_type_node;
2407
2408   if (mode == TYPE_MODE (long_double_type_node))
2409     return long_double_type_node;
2410
2411   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2412     return build_pointer_type (char_type_node);
2413
2414   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2415     return build_pointer_type (integer_type_node);
2416
2417 #ifdef VECTOR_MODE_SUPPORTED_P
2418   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2419     return V4SF_type_node;
2420   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2421     return V4SI_type_node;
2422   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2423     return V2SI_type_node;
2424   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2425     return V4HI_type_node;
2426   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2427     return V8QI_type_node;
2428 #endif
2429
2430   return 0;
2431 }
2432
2433 /* Return an unsigned type the same as TYPE in other respects. */
2434 tree
2435 unsigned_type (type)
2436      tree type;
2437 {
2438   tree type1 = TYPE_MAIN_VARIANT (type);
2439   if (type1 == signed_char_type_node || type1 == char_type_node)
2440     return unsigned_char_type_node;
2441   if (type1 == integer_type_node)
2442     return unsigned_type_node;
2443   if (type1 == short_integer_type_node)
2444     return short_unsigned_type_node;
2445   if (type1 == long_integer_type_node)
2446     return long_unsigned_type_node;
2447   if (type1 == long_long_integer_type_node)
2448     return long_long_unsigned_type_node;
2449   if (type1 == widest_integer_literal_type_node)
2450     return widest_unsigned_literal_type_node;
2451 #if HOST_BITS_PER_WIDE_INT >= 64
2452   if (type1 == intTI_type_node)
2453     return unsigned_intTI_type_node;
2454 #endif
2455   if (type1 == intDI_type_node)
2456     return unsigned_intDI_type_node;
2457   if (type1 == intSI_type_node)
2458     return unsigned_intSI_type_node;
2459   if (type1 == intHI_type_node)
2460     return unsigned_intHI_type_node;
2461   if (type1 == intQI_type_node)
2462     return unsigned_intQI_type_node;
2463
2464   return signed_or_unsigned_type (1, type);
2465 }
2466
2467 /* Return a signed type the same as TYPE in other respects.  */
2468
2469 tree
2470 signed_type (type)
2471      tree type;
2472 {
2473   tree type1 = TYPE_MAIN_VARIANT (type);
2474   if (type1 == unsigned_char_type_node || type1 == char_type_node)
2475     return signed_char_type_node;
2476   if (type1 == unsigned_type_node)
2477     return integer_type_node;
2478   if (type1 == short_unsigned_type_node)
2479     return short_integer_type_node;
2480   if (type1 == long_unsigned_type_node)
2481     return long_integer_type_node;
2482   if (type1 == long_long_unsigned_type_node)
2483     return long_long_integer_type_node;
2484   if (type1 == widest_unsigned_literal_type_node)
2485     return widest_integer_literal_type_node;
2486 #if HOST_BITS_PER_WIDE_INT >= 64
2487   if (type1 == unsigned_intTI_type_node)
2488     return intTI_type_node;
2489 #endif
2490   if (type1 == unsigned_intDI_type_node)
2491     return intDI_type_node;
2492   if (type1 == unsigned_intSI_type_node)
2493     return intSI_type_node;
2494   if (type1 == unsigned_intHI_type_node)
2495     return intHI_type_node;
2496   if (type1 == unsigned_intQI_type_node)
2497     return intQI_type_node;
2498
2499   return signed_or_unsigned_type (0, type);
2500 }
2501
2502 /* Return a type the same as TYPE except unsigned or
2503    signed according to UNSIGNEDP.  */
2504
2505 tree
2506 signed_or_unsigned_type (unsignedp, type)
2507      int unsignedp;
2508      tree type;
2509 {
2510   if (! INTEGRAL_TYPE_P (type)
2511       || TREE_UNSIGNED (type) == unsignedp)
2512     return type;
2513
2514   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2515     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2516   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2517     return unsignedp ? unsigned_type_node : integer_type_node;
2518   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2519     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2520   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2521     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2522   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2523     return (unsignedp ? long_long_unsigned_type_node
2524             : long_long_integer_type_node);
2525   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2526     return (unsignedp ? widest_unsigned_literal_type_node
2527             : widest_integer_literal_type_node);
2528   return type;
2529 }
2530 \f
2531 /* Return the minimum number of bits needed to represent VALUE in a
2532    signed or unsigned type, UNSIGNEDP says which.  */
2533
2534 unsigned int
2535 min_precision (value, unsignedp)
2536      tree value;
2537      int unsignedp;
2538 {
2539   int log;
2540
2541   /* If the value is negative, compute its negative minus 1.  The latter
2542      adjustment is because the absolute value of the largest negative value
2543      is one larger than the largest positive value.  This is equivalent to
2544      a bit-wise negation, so use that operation instead.  */
2545
2546   if (tree_int_cst_sgn (value) < 0)
2547     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2548
2549   /* Return the number of bits needed, taking into account the fact
2550      that we need one more bit for a signed than unsigned type.  */
2551
2552   if (integer_zerop (value))
2553     log = 0;
2554   else
2555     log = tree_floor_log2 (value);
2556
2557   return log + 1 + ! unsignedp;
2558 }
2559 \f
2560 /* Print an error message for invalid operands to arith operation CODE.
2561    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2562
2563 void
2564 binary_op_error (code)
2565      enum tree_code code;
2566 {
2567   register const char *opname;
2568
2569   switch (code)
2570     {
2571     case NOP_EXPR:
2572       error ("invalid truth-value expression");
2573       return;
2574
2575     case PLUS_EXPR:
2576       opname = "+"; break;
2577     case MINUS_EXPR:
2578       opname = "-"; break;
2579     case MULT_EXPR:
2580       opname = "*"; break;
2581     case MAX_EXPR:
2582       opname = "max"; break;
2583     case MIN_EXPR:
2584       opname = "min"; break;
2585     case EQ_EXPR:
2586       opname = "=="; break;
2587     case NE_EXPR:
2588       opname = "!="; break;
2589     case LE_EXPR:
2590       opname = "<="; break;
2591     case GE_EXPR:
2592       opname = ">="; break;
2593     case LT_EXPR:
2594       opname = "<"; break;
2595     case GT_EXPR:
2596       opname = ">"; break;
2597     case LSHIFT_EXPR:
2598       opname = "<<"; break;
2599     case RSHIFT_EXPR:
2600       opname = ">>"; break;
2601     case TRUNC_MOD_EXPR:
2602     case FLOOR_MOD_EXPR:
2603       opname = "%"; break;
2604     case TRUNC_DIV_EXPR:
2605     case FLOOR_DIV_EXPR:
2606       opname = "/"; break;
2607     case BIT_AND_EXPR:
2608       opname = "&"; break;
2609     case BIT_IOR_EXPR:
2610       opname = "|"; break;
2611     case TRUTH_ANDIF_EXPR:
2612       opname = "&&"; break;
2613     case TRUTH_ORIF_EXPR:
2614       opname = "||"; break;
2615     case BIT_XOR_EXPR:
2616       opname = "^"; break;
2617     case LROTATE_EXPR:
2618     case RROTATE_EXPR:
2619       opname = "rotate"; break;
2620     default:
2621       opname = "unknown"; break;
2622     }
2623   error ("invalid operands to binary %s", opname);
2624 }
2625 \f
2626 /* Subroutine of build_binary_op, used for comparison operations.
2627    See if the operands have both been converted from subword integer types
2628    and, if so, perhaps change them both back to their original type.
2629    This function is also responsible for converting the two operands
2630    to the proper common type for comparison.
2631
2632    The arguments of this function are all pointers to local variables
2633    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2634    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2635
2636    If this function returns nonzero, it means that the comparison has
2637    a constant value.  What this function returns is an expression for
2638    that value.  */
2639
2640 tree
2641 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2642      tree *op0_ptr, *op1_ptr;
2643      tree *restype_ptr;
2644      enum tree_code *rescode_ptr;
2645 {
2646   register tree type;
2647   tree op0 = *op0_ptr;
2648   tree op1 = *op1_ptr;
2649   int unsignedp0, unsignedp1;
2650   int real1, real2;
2651   tree primop0, primop1;
2652   enum tree_code code = *rescode_ptr;
2653
2654   /* Throw away any conversions to wider types
2655      already present in the operands.  */
2656
2657   primop0 = get_narrower (op0, &unsignedp0);
2658   primop1 = get_narrower (op1, &unsignedp1);
2659
2660   /* Handle the case that OP0 does not *contain* a conversion
2661      but it *requires* conversion to FINAL_TYPE.  */
2662
2663   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2664     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2665   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2666     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2667
2668   /* If one of the operands must be floated, we cannot optimize.  */
2669   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2670   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2671
2672   /* If first arg is constant, swap the args (changing operation
2673      so value is preserved), for canonicalization.  Don't do this if
2674      the second arg is 0.  */
2675
2676   if (TREE_CONSTANT (primop0)
2677       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2678     {
2679       register tree tem = primop0;
2680       register int temi = unsignedp0;
2681       primop0 = primop1;
2682       primop1 = tem;
2683       tem = op0;
2684       op0 = op1;
2685       op1 = tem;
2686       *op0_ptr = op0;
2687       *op1_ptr = op1;
2688       unsignedp0 = unsignedp1;
2689       unsignedp1 = temi;
2690       temi = real1;
2691       real1 = real2;
2692       real2 = temi;
2693
2694       switch (code)
2695         {
2696         case LT_EXPR:
2697           code = GT_EXPR;
2698           break;
2699         case GT_EXPR:
2700           code = LT_EXPR;
2701           break;
2702         case LE_EXPR:
2703           code = GE_EXPR;
2704           break;
2705         case GE_EXPR:
2706           code = LE_EXPR;
2707           break;
2708         default:
2709           break;
2710         }
2711       *rescode_ptr = code;
2712     }
2713
2714   /* If comparing an integer against a constant more bits wide,
2715      maybe we can deduce a value of 1 or 0 independent of the data.
2716      Or else truncate the constant now
2717      rather than extend the variable at run time.
2718
2719      This is only interesting if the constant is the wider arg.
2720      Also, it is not safe if the constant is unsigned and the
2721      variable arg is signed, since in this case the variable
2722      would be sign-extended and then regarded as unsigned.
2723      Our technique fails in this case because the lowest/highest
2724      possible unsigned results don't follow naturally from the
2725      lowest/highest possible values of the variable operand.
2726      For just EQ_EXPR and NE_EXPR there is another technique that
2727      could be used: see if the constant can be faithfully represented
2728      in the other operand's type, by truncating it and reextending it
2729      and see if that preserves the constant's value.  */
2730
2731   if (!real1 && !real2
2732       && TREE_CODE (primop1) == INTEGER_CST
2733       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2734     {
2735       int min_gt, max_gt, min_lt, max_lt;
2736       tree maxval, minval;
2737       /* 1 if comparison is nominally unsigned.  */
2738       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2739       tree val;
2740
2741       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2742
2743       /* If TYPE is an enumeration, then we need to get its min/max
2744          values from it's underlying integral type, not the enumerated
2745          type itself.  */
2746       if (TREE_CODE (type) == ENUMERAL_TYPE)
2747         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
2748
2749       maxval = TYPE_MAX_VALUE (type);
2750       minval = TYPE_MIN_VALUE (type);
2751
2752       if (unsignedp && !unsignedp0)
2753         *restype_ptr = signed_type (*restype_ptr);
2754
2755       if (TREE_TYPE (primop1) != *restype_ptr)
2756         primop1 = convert (*restype_ptr, primop1);
2757       if (type != *restype_ptr)
2758         {
2759           minval = convert (*restype_ptr, minval);
2760           maxval = convert (*restype_ptr, maxval);
2761         }
2762
2763       if (unsignedp && unsignedp0)
2764         {
2765           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2766           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2767           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2768           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2769         }
2770       else
2771         {
2772           min_gt = INT_CST_LT (primop1, minval);
2773           max_gt = INT_CST_LT (primop1, maxval);
2774           min_lt = INT_CST_LT (minval, primop1);
2775           max_lt = INT_CST_LT (maxval, primop1);
2776         }
2777
2778       val = 0;
2779       /* This used to be a switch, but Genix compiler can't handle that.  */
2780       if (code == NE_EXPR)
2781         {
2782           if (max_lt || min_gt)
2783             val = boolean_true_node;
2784         }
2785       else if (code == EQ_EXPR)
2786         {
2787           if (max_lt || min_gt)
2788             val = boolean_false_node;
2789         }
2790       else if (code == LT_EXPR)
2791         {
2792           if (max_lt)
2793             val = boolean_true_node;
2794           if (!min_lt)
2795             val = boolean_false_node;
2796         }
2797       else if (code == GT_EXPR)
2798         {
2799           if (min_gt)
2800             val = boolean_true_node;
2801           if (!max_gt)
2802             val = boolean_false_node;
2803         }
2804       else if (code == LE_EXPR)
2805         {
2806           if (!max_gt)
2807             val = boolean_true_node;
2808           if (min_gt)
2809             val = boolean_false_node;
2810         }
2811       else if (code == GE_EXPR)
2812         {
2813           if (!min_lt)
2814             val = boolean_true_node;
2815           if (max_lt)
2816             val = boolean_false_node;
2817         }
2818
2819       /* If primop0 was sign-extended and unsigned comparison specd,
2820          we did a signed comparison above using the signed type bounds.
2821          But the comparison we output must be unsigned.
2822
2823          Also, for inequalities, VAL is no good; but if the signed
2824          comparison had *any* fixed result, it follows that the
2825          unsigned comparison just tests the sign in reverse
2826          (positive values are LE, negative ones GE).
2827          So we can generate an unsigned comparison
2828          against an extreme value of the signed type.  */
2829
2830       if (unsignedp && !unsignedp0)
2831         {
2832           if (val != 0)
2833             switch (code)
2834               {
2835               case LT_EXPR:
2836               case GE_EXPR:
2837                 primop1 = TYPE_MIN_VALUE (type);
2838                 val = 0;
2839                 break;
2840
2841               case LE_EXPR:
2842               case GT_EXPR:
2843                 primop1 = TYPE_MAX_VALUE (type);
2844                 val = 0;
2845                 break;
2846
2847               default:
2848                 break;
2849               }
2850           type = unsigned_type (type);
2851         }
2852
2853       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2854         {
2855           /* This is the case of (char)x >?< 0x80, which people used to use
2856              expecting old C compilers to change the 0x80 into -0x80.  */
2857           if (val == boolean_false_node)
2858             warning ("comparison is always false due to limited range of data type");
2859           if (val == boolean_true_node)
2860             warning ("comparison is always true due to limited range of data type");
2861         }
2862
2863       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2864         {
2865           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2866           if (val == boolean_false_node)
2867             warning ("comparison is always false due to limited range of data type");
2868           if (val == boolean_true_node)
2869             warning ("comparison is always true due to limited range of data type");
2870         }
2871
2872       if (val != 0)
2873         {
2874           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2875           if (TREE_SIDE_EFFECTS (primop0))
2876             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2877           return val;
2878         }
2879
2880       /* Value is not predetermined, but do the comparison
2881          in the type of the operand that is not constant.
2882          TYPE is already properly set.  */
2883     }
2884   else if (real1 && real2
2885            && (TYPE_PRECISION (TREE_TYPE (primop0))
2886                == TYPE_PRECISION (TREE_TYPE (primop1))))
2887     type = TREE_TYPE (primop0);
2888
2889   /* If args' natural types are both narrower than nominal type
2890      and both extend in the same manner, compare them
2891      in the type of the wider arg.
2892      Otherwise must actually extend both to the nominal
2893      common type lest different ways of extending
2894      alter the result.
2895      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2896
2897   else if (unsignedp0 == unsignedp1 && real1 == real2
2898            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2899            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2900     {
2901       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2902       type = signed_or_unsigned_type (unsignedp0
2903                                       || TREE_UNSIGNED (*restype_ptr),
2904                                       type);
2905       /* Make sure shorter operand is extended the right way
2906          to match the longer operand.  */
2907       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2908                          primop0);
2909       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2910                          primop1);
2911     }
2912   else
2913     {
2914       /* Here we must do the comparison on the nominal type
2915          using the args exactly as we received them.  */
2916       type = *restype_ptr;
2917       primop0 = op0;
2918       primop1 = op1;
2919
2920       if (!real1 && !real2 && integer_zerop (primop1)
2921           && TREE_UNSIGNED (*restype_ptr))
2922         {
2923           tree value = 0;
2924           switch (code)
2925             {
2926             case GE_EXPR:
2927               /* All unsigned values are >= 0, so we warn if extra warnings
2928                  are requested.  However, if OP0 is a constant that is
2929                  >= 0, the signedness of the comparison isn't an issue,
2930                  so suppress the warning.  */
2931               if (extra_warnings && !in_system_header
2932                   && ! (TREE_CODE (primop0) == INTEGER_CST
2933                         && ! TREE_OVERFLOW (convert (signed_type (type),
2934                                                      primop0))))
2935                 warning ("comparison of unsigned expression >= 0 is always true");
2936               value = boolean_true_node;
2937               break;
2938
2939             case LT_EXPR:
2940               if (extra_warnings && !in_system_header
2941                   && ! (TREE_CODE (primop0) == INTEGER_CST
2942                         && ! TREE_OVERFLOW (convert (signed_type (type),
2943                                                      primop0))))
2944                 warning ("comparison of unsigned expression < 0 is always false");
2945               value = boolean_false_node;
2946               break;
2947
2948             default:
2949               break;
2950             }
2951
2952           if (value != 0)
2953             {
2954               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2955               if (TREE_SIDE_EFFECTS (primop0))
2956                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2957                               primop0, value);
2958               return value;
2959             }
2960         }
2961     }
2962
2963   *op0_ptr = convert (type, primop0);
2964   *op1_ptr = convert (type, primop1);
2965
2966   *restype_ptr = boolean_type_node;
2967
2968   return 0;
2969 }
2970 \f
2971 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2972    or validate its data type for an `if' or `while' statement or ?..: exp.
2973
2974    This preparation consists of taking the ordinary
2975    representation of an expression expr and producing a valid tree
2976    boolean expression describing whether expr is nonzero.  We could
2977    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2978    but we optimize comparisons, &&, ||, and !.
2979
2980    The resulting type should always be `boolean_type_node'.  */
2981
2982 tree
2983 truthvalue_conversion (expr)
2984      tree expr;
2985 {
2986   if (TREE_CODE (expr) == ERROR_MARK)
2987     return expr;
2988
2989 #if 0 /* This appears to be wrong for C++.  */
2990   /* These really should return error_mark_node after 2.4 is stable.
2991      But not all callers handle ERROR_MARK properly.  */
2992   switch (TREE_CODE (TREE_TYPE (expr)))
2993     {
2994     case RECORD_TYPE:
2995       error ("struct type value used where scalar is required");
2996       return boolean_false_node;
2997
2998     case UNION_TYPE:
2999       error ("union type value used where scalar is required");
3000       return boolean_false_node;
3001
3002     case ARRAY_TYPE:
3003       error ("array type value used where scalar is required");
3004       return boolean_false_node;
3005
3006     default:
3007       break;
3008     }
3009 #endif /* 0 */
3010
3011   switch (TREE_CODE (expr))
3012     {
3013     case EQ_EXPR:
3014     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
3015     case TRUTH_ANDIF_EXPR:
3016     case TRUTH_ORIF_EXPR:
3017     case TRUTH_AND_EXPR:
3018     case TRUTH_OR_EXPR:
3019     case TRUTH_XOR_EXPR:
3020     case TRUTH_NOT_EXPR:
3021       TREE_TYPE (expr) = boolean_type_node;
3022       return expr;
3023
3024     case ERROR_MARK:
3025       return expr;
3026
3027     case INTEGER_CST:
3028       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
3029
3030     case REAL_CST:
3031       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
3032
3033     case ADDR_EXPR:
3034       /* If we are taking the address of a external decl, it might be zero
3035          if it is weak, so we cannot optimize.  */
3036       if (DECL_P (TREE_OPERAND (expr, 0))
3037           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
3038         break;
3039
3040       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
3041         return build (COMPOUND_EXPR, boolean_type_node,
3042                       TREE_OPERAND (expr, 0), boolean_true_node);
3043       else
3044         return boolean_true_node;
3045
3046     case COMPLEX_EXPR:
3047       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
3048                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3049                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
3050                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
3051                               0);
3052
3053     case NEGATE_EXPR:
3054     case ABS_EXPR:
3055     case FLOAT_EXPR:
3056     case FFS_EXPR:
3057       /* These don't change whether an object is non-zero or zero.  */
3058       return truthvalue_conversion (TREE_OPERAND (expr, 0));
3059
3060     case LROTATE_EXPR:
3061     case RROTATE_EXPR:
3062       /* These don't change whether an object is zero or non-zero, but
3063          we can't ignore them if their second arg has side-effects.  */
3064       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
3065         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
3066                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
3067       else
3068         return truthvalue_conversion (TREE_OPERAND (expr, 0));
3069
3070     case COND_EXPR:
3071       /* Distribute the conversion into the arms of a COND_EXPR.  */
3072       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
3073                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
3074                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
3075
3076     case CONVERT_EXPR:
3077       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3078          since that affects how `default_conversion' will behave.  */
3079       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3080           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3081         break;
3082       /* fall through...  */
3083     case NOP_EXPR:
3084       /* If this is widening the argument, we can ignore it.  */
3085       if (TYPE_PRECISION (TREE_TYPE (expr))
3086           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3087         return truthvalue_conversion (TREE_OPERAND (expr, 0));
3088       break;
3089
3090     case MINUS_EXPR:
3091       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
3092          this case.  */
3093       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3094           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
3095         break;
3096       /* fall through...  */
3097     case BIT_XOR_EXPR:
3098       /* This and MINUS_EXPR can be changed into a comparison of the
3099          two objects.  */
3100       if (TREE_TYPE (TREE_OPERAND (expr, 0))
3101           == TREE_TYPE (TREE_OPERAND (expr, 1)))
3102         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
3103                                 TREE_OPERAND (expr, 1), 1);
3104       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
3105                               fold (build1 (NOP_EXPR,
3106                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
3107                                             TREE_OPERAND (expr, 1))), 1);
3108
3109     case BIT_AND_EXPR:
3110       if (integer_onep (TREE_OPERAND (expr, 1))
3111           && TREE_TYPE (expr) != boolean_type_node)
3112         /* Using convert here would cause infinite recursion.  */
3113         return build1 (NOP_EXPR, boolean_type_node, expr);
3114       break;
3115
3116     case MODIFY_EXPR:
3117       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
3118         warning ("suggest parentheses around assignment used as truth value");
3119       break;
3120
3121     default:
3122       break;
3123     }
3124
3125   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3126     {
3127       tree tem = save_expr (expr);
3128       return (build_binary_op
3129               ((TREE_SIDE_EFFECTS (expr)
3130                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3131                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
3132                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
3133                0));
3134     }
3135
3136   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3137 }
3138 \f
3139 #if USE_CPPLIB
3140 /* Read the rest of a #-directive from input stream FINPUT.
3141    In normal use, the directive name and the white space after it
3142    have already been read, so they won't be included in the result.
3143    We allow for the fact that the directive line may contain
3144    a newline embedded within a character or string literal which forms
3145    a part of the directive.
3146
3147    The value is a string in a reusable buffer.  It remains valid
3148    only until the next time this function is called.  */
3149 unsigned char *yy_cur, *yy_lim;
3150
3151 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
3152 #define UNGETC(c) ((c) == EOF ? 0 : yy_cur--)
3153
3154 int
3155 yy_get_token ()
3156 {
3157   for (;;)
3158     {
3159       parse_in.limit = parse_in.token_buffer;
3160       cpp_token = cpp_get_token (&parse_in);
3161       if (cpp_token == CPP_EOF)
3162         return -1;
3163       yy_lim = CPP_PWRITTEN (&parse_in);
3164       yy_cur = parse_in.token_buffer;
3165       if (yy_cur < yy_lim)
3166         return *yy_cur++;
3167     }
3168 }
3169
3170 char *
3171 get_directive_line ()
3172 {
3173   static char *directive_buffer = NULL;
3174   static unsigned buffer_length = 0;
3175   register char *p;
3176   register char *buffer_limit;
3177   register int looking_for = 0;
3178   register int char_escaped = 0;
3179
3180   if (buffer_length == 0)
3181     {
3182       directive_buffer = (char *)xmalloc (128);
3183       buffer_length = 128;
3184     }
3185
3186   buffer_limit = &directive_buffer[buffer_length];
3187
3188   for (p = directive_buffer; ; )
3189     {
3190       int c;
3191
3192       /* Make buffer bigger if it is full.  */
3193       if (p >= buffer_limit)
3194         {
3195           register unsigned bytes_used = (p - directive_buffer);
3196
3197           buffer_length *= 2;
3198           directive_buffer
3199             = (char *)xrealloc (directive_buffer, buffer_length);
3200           p = &directive_buffer[bytes_used];
3201           buffer_limit = &directive_buffer[buffer_length];
3202         }
3203
3204       c = GETC ();
3205
3206       /* Discard initial whitespace.  */
3207       if ((c == ' ' || c == '\t') && p == directive_buffer)
3208         continue;
3209
3210       /* Detect the end of the directive.  */
3211       if (c == '\n' && looking_for == 0)
3212         {
3213           UNGETC (c);
3214           c = '\0';
3215         }
3216
3217       *p++ = c;
3218
3219       if (c == 0)
3220         return directive_buffer;
3221
3222       /* Handle string and character constant syntax.  */
3223       if (looking_for)
3224         {
3225           if (looking_for == c && !char_escaped)
3226             looking_for = 0;    /* Found terminator... stop looking.  */
3227         }
3228       else
3229         if (c == '\'' || c == '"')
3230           looking_for = c;      /* Don't stop buffering until we see another
3231                                    another one of these (or an EOF).  */
3232
3233       /* Handle backslash.  */
3234       char_escaped = (c == '\\' && ! char_escaped);
3235     }
3236 }
3237 #else
3238 /* Read the rest of a #-directive from input stream FINPUT.
3239    In normal use, the directive name and the white space after it
3240    have already been read, so they won't be included in the result.
3241    We allow for the fact that the directive line may contain
3242    a newline embedded within a character or string literal which forms
3243    a part of the directive.
3244
3245    The value is a string in a reusable buffer.  It remains valid
3246    only until the next time this function is called.
3247
3248    The terminating character ('\n' or EOF) is left in FINPUT for the
3249    caller to re-read.  */
3250
3251 char *
3252 get_directive_line (finput)
3253      register FILE *finput;
3254 {
3255   static char *directive_buffer = NULL;
3256   static unsigned buffer_length = 0;
3257   register char *p;
3258   register char *buffer_limit;
3259   register int looking_for = 0;
3260   register int char_escaped = 0;
3261
3262   if (buffer_length == 0)
3263     {
3264       directive_buffer = (char *)xmalloc (128);
3265       buffer_length = 128;
3266     }
3267
3268   buffer_limit = &directive_buffer[buffer_length];
3269
3270   for (p = directive_buffer; ; )
3271     {
3272       int c;
3273
3274       /* Make buffer bigger if it is full.  */
3275       if (p >= buffer_limit)
3276         {
3277           register unsigned bytes_used = (p - directive_buffer);
3278
3279           buffer_length *= 2;
3280           directive_buffer
3281             = (char *)xrealloc (directive_buffer, buffer_length);
3282           p = &directive_buffer[bytes_used];
3283           buffer_limit = &directive_buffer[buffer_length];
3284         }
3285
3286       c = getc (finput);
3287
3288       /* Discard initial whitespace.  */
3289       if ((c == ' ' || c == '\t') && p == directive_buffer)
3290         continue;
3291
3292       /* Detect the end of the directive.  */
3293       if (looking_for == 0
3294           && (c == '\n' || c == EOF))
3295         {
3296           ungetc (c, finput);
3297           c = '\0';
3298         }
3299
3300       *p++ = c;
3301
3302       if (c == 0)
3303         return directive_buffer;
3304
3305       /* Handle string and character constant syntax.  */
3306       if (looking_for)
3307         {
3308           if (looking_for == c && !char_escaped)
3309             looking_for = 0;    /* Found terminator... stop looking.  */
3310         }
3311       else
3312         if (c == '\'' || c == '"')
3313           looking_for = c;      /* Don't stop buffering until we see another
3314                                    one of these (or an EOF).  */
3315
3316       /* Handle backslash.  */
3317       char_escaped = (c == '\\' && ! char_escaped);
3318     }
3319 }
3320 #endif /* !USE_CPPLIB */
3321 \f
3322 /* Make a variant type in the proper way for C/C++, propagating qualifiers
3323    down to the element type of an array.  */
3324
3325 tree
3326 c_build_qualified_type (type, type_quals)
3327      tree type;
3328      int type_quals;
3329 {
3330   /* A restrict-qualified pointer type must be a pointer to object or
3331      incomplete type.  Note that the use of POINTER_TYPE_P also allows
3332      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
3333      the C++ front-end also use POINTER_TYPE for pointer-to-member
3334      values, so even though it should be illegal to use `restrict'
3335      with such an entity we don't flag that here.  Thus, special case
3336      code for that case is required in the C++ front-end.  */
3337   if ((type_quals & TYPE_QUAL_RESTRICT)
3338       && (!POINTER_TYPE_P (type)
3339           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
3340     {
3341       error ("invalid use of `restrict'");
3342       type_quals &= ~TYPE_QUAL_RESTRICT;
3343     }
3344
3345   if (TREE_CODE (type) == ARRAY_TYPE)
3346     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
3347                                                      type_quals),
3348                              TYPE_DOMAIN (type));
3349   return build_qualified_type (type, type_quals);
3350 }
3351
3352 /* Apply the TYPE_QUALS to the new DECL.  */
3353
3354 void
3355 c_apply_type_quals_to_decl (type_quals, decl)
3356      int type_quals;
3357      tree decl;
3358 {
3359   if ((type_quals & TYPE_QUAL_CONST)
3360       || (TREE_TYPE (decl)
3361           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
3362     TREE_READONLY (decl) = 1;
3363   if (type_quals & TYPE_QUAL_VOLATILE)
3364     {
3365       TREE_SIDE_EFFECTS (decl) = 1;
3366       TREE_THIS_VOLATILE (decl) = 1;
3367     }
3368   if (type_quals & TYPE_QUAL_RESTRICT)
3369     {
3370       if (!TREE_TYPE (decl)
3371           || !POINTER_TYPE_P (TREE_TYPE (decl))
3372           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
3373         error ("invalid use of `restrict'");
3374       else if (flag_strict_aliasing)
3375         {
3376           /* No two restricted pointers can point at the same thing.
3377              However, a restricted pointer can point at the same thing
3378              as an unrestricted pointer, if that unrestricted pointer
3379              is based on the restricted pointer.  So, we make the
3380              alias set for the restricted pointer a subset of the
3381              alias set for the type pointed to by the type of the
3382              decl.  */
3383
3384           HOST_WIDE_INT pointed_to_alias_set
3385             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
3386
3387           if (pointed_to_alias_set == 0)
3388             /* It's not legal to make a subset of alias set zero.  */
3389             ;
3390           else
3391             {
3392               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
3393               record_alias_subset  (pointed_to_alias_set,
3394                                     DECL_POINTER_ALIAS_SET (decl));
3395             }
3396         }
3397     }
3398 }
3399
3400
3401 /* Return the typed-based alias set for T, which may be an expression
3402    or a type.  Return -1 if we don't do anything special.  */
3403
3404 HOST_WIDE_INT
3405 lang_get_alias_set (t)
3406      tree t;
3407 {
3408   tree u;
3409
3410   /* Permit type-punning when accessing a union, provided the access
3411      is directly through the union.  For example, this code does not
3412      permit taking the address of a union member and then storing
3413      through it.  Even the type-punning allowed here is a GCC
3414      extension, albeit a common and useful one; the C standard says
3415      that such accesses have implementation-defined behavior.  */
3416   for (u = t;
3417        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3418        u = TREE_OPERAND (u, 0))
3419     if (TREE_CODE (u) == COMPONENT_REF
3420         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3421       return 0;
3422
3423   /* If this is a char *, the ANSI C standard says it can alias
3424      anything.  Note that all references need do this.  */
3425   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
3426       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
3427       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
3428     return 0;
3429
3430   /* That's all the expressions we handle specially.  */
3431   if (! TYPE_P (t))
3432     return -1;
3433
3434   /* The C standard specifically allows aliasing between signed and
3435      unsigned variants of the same type.  We treat the signed
3436      variant as canonical.  */
3437   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
3438     {
3439       tree t1 = signed_type (t);
3440
3441       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3442       if (t1 != t)
3443         return get_alias_set (t1);
3444     }
3445   else if (POINTER_TYPE_P (t))
3446     {
3447       tree t1;
3448
3449       /* Unfortunately, there is no canonical form of a pointer type.
3450          In particular, if we have `typedef int I', then `int *', and
3451          `I *' are different types.  So, we have to pick a canonical
3452          representative.  We do this below.
3453
3454          Technically, this approach is actually more conservative that
3455          it needs to be.  In particular, `const int *' and `int *'
3456          chould be in different alias sets, according to the C and C++
3457          standard, since their types are not the same, and so,
3458          technically, an `int **' and `const int **' cannot point at
3459          the same thing.
3460
3461          But, the standard is wrong.  In particular, this code is
3462          legal C++:
3463
3464             int *ip;
3465             int **ipp = &ip;
3466             const int* const* cipp = &ip;
3467
3468          And, it doesn't make sense for that to be legal unless you
3469          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3470          the pointed-to types.  This issue has been reported to the
3471          C++ committee.  */
3472       t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t));
3473       t1 = ((TREE_CODE (t) == POINTER_TYPE)
3474            ? build_pointer_type (t1) : build_reference_type (t1));
3475       if (t1 != t)
3476         return get_alias_set (t1);
3477     }
3478   /* It's not yet safe to use alias sets for classes in C++ because
3479      the TYPE_FIELDs list for a class doesn't mention base classes.  */
3480   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
3481     return 0;
3482
3483   return -1;
3484 }
3485
3486 /* Build tree nodes and builtin functions common to both C and C++ language
3487    frontends.
3488    CPLUS_MODE is nonzero if we are called from the C++ frontend, we generate
3489    some stricter prototypes in that case.
3490    NO_BUILTINS and NO_NONANSI_BUILTINS contain the respective values of
3491    the language frontend flags flag_no_builtin and
3492    flag_no_nonansi_builtin.  */
3493
3494 void
3495 c_common_nodes_and_builtins (cplus_mode, no_builtins, no_nonansi_builtins)
3496     int cplus_mode, no_builtins, no_nonansi_builtins;
3497 {
3498   tree temp;
3499   tree memcpy_ftype, memset_ftype, strlen_ftype;
3500   tree bzero_ftype, bcmp_ftype;
3501   tree endlink, int_endlink, double_endlink, unsigned_endlink;
3502   tree sizetype_endlink;
3503   tree ptr_ftype, ptr_ftype_unsigned;
3504   tree void_ftype_any, void_ftype_int, int_ftype_any;
3505   tree double_ftype_double, double_ftype_double_double;
3506   tree float_ftype_float, ldouble_ftype_ldouble;
3507   tree int_ftype_cptr_cptr_sizet;
3508   tree int_ftype_string_string, string_ftype_ptr_ptr;
3509   tree long_ftype_long;
3510   /* Either char* or void*.  */
3511   tree traditional_ptr_type_node;
3512   /* Either const char* or const void*.  */
3513   tree traditional_cptr_type_node;
3514   tree traditional_len_type_node;
3515   tree traditional_len_endlink;
3516   tree va_list_ref_type_node;
3517   tree va_list_arg_type_node;
3518
3519   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3520                         va_list_type_node));
3521
3522   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3523                         ptrdiff_type_node));
3524
3525   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3526                         sizetype));
3527
3528   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3529     {
3530       va_list_arg_type_node = va_list_ref_type_node =
3531         build_pointer_type (TREE_TYPE (va_list_type_node));
3532     }
3533   else
3534     {
3535       va_list_arg_type_node = va_list_type_node;
3536       va_list_ref_type_node = build_reference_type (va_list_type_node);
3537     }
3538
3539   endlink = void_list_node;
3540   int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
3541   double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
3542   unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
3543
3544   ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
3545   ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
3546   sizetype_endlink = tree_cons (NULL_TREE, TYPE_DOMAIN (sizetype), endlink);
3547   /* We realloc here because sizetype could be int or unsigned.  S'ok.  */
3548   ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
3549
3550   int_ftype_any = build_function_type (integer_type_node, NULL_TREE);
3551   void_ftype_any = build_function_type (void_type_node, NULL_TREE);
3552   void_ftype = build_function_type (void_type_node, endlink);
3553   void_ftype_int = build_function_type (void_type_node, int_endlink);
3554   void_ftype_ptr
3555     = build_function_type (void_type_node,
3556                            tree_cons (NULL_TREE, ptr_type_node, endlink));
3557
3558   float_ftype_float
3559     = build_function_type (float_type_node,
3560                            tree_cons (NULL_TREE, float_type_node, endlink));
3561
3562   double_ftype_double
3563     = build_function_type (double_type_node, double_endlink);
3564
3565   ldouble_ftype_ldouble
3566     = build_function_type (long_double_type_node,
3567                            tree_cons (NULL_TREE, long_double_type_node,
3568                                       endlink));
3569
3570   double_ftype_double_double
3571     = build_function_type (double_type_node,
3572                            tree_cons (NULL_TREE, double_type_node,
3573                                       double_endlink));
3574
3575   int_ftype_int
3576     = build_function_type (integer_type_node, int_endlink);
3577
3578   long_ftype_long
3579     = build_function_type (long_integer_type_node,
3580                            tree_cons (NULL_TREE, long_integer_type_node,
3581                                       endlink));
3582
3583   int_ftype_cptr_cptr_sizet
3584     = build_function_type (integer_type_node,
3585                            tree_cons (NULL_TREE, const_ptr_type_node,
3586                                       tree_cons (NULL_TREE, const_ptr_type_node,
3587                                                  tree_cons (NULL_TREE,
3588                                                             sizetype,
3589                                                             endlink))));
3590
3591   /* Prototype for strcpy.  */
3592   string_ftype_ptr_ptr
3593     = build_function_type (string_type_node,
3594                            tree_cons (NULL_TREE, string_type_node,
3595                                       tree_cons (NULL_TREE,
3596                                                  const_string_type_node,
3597                                                  endlink)));
3598
3599   traditional_len_type_node = (flag_traditional && ! cplus_mode
3600                                ? integer_type_node : sizetype);
3601   traditional_len_endlink = tree_cons (NULL_TREE, traditional_len_type_node,
3602                                        endlink);
3603
3604   /* Prototype for strcmp.  */
3605   int_ftype_string_string
3606     = build_function_type (integer_type_node,
3607                            tree_cons (NULL_TREE, const_string_type_node,
3608                                       tree_cons (NULL_TREE,
3609                                                  const_string_type_node,
3610                                                  endlink)));
3611
3612   /* Prototype for strlen.  */
3613   strlen_ftype
3614     = build_function_type (traditional_len_type_node,
3615                            tree_cons (NULL_TREE, const_string_type_node,
3616                                       endlink));
3617
3618   traditional_ptr_type_node = (flag_traditional && ! cplus_mode
3619                                ? string_type_node : ptr_type_node);
3620   traditional_cptr_type_node = (flag_traditional && ! cplus_mode
3621                                ? const_string_type_node : const_ptr_type_node);
3622
3623   /* Prototype for memcpy.  */
3624   memcpy_ftype
3625     = build_function_type (traditional_ptr_type_node,
3626                            tree_cons (NULL_TREE, ptr_type_node,
3627                                       tree_cons (NULL_TREE, const_ptr_type_node,
3628                                                  sizetype_endlink)));
3629
3630   /* Prototype for memset.  */
3631   memset_ftype
3632     = build_function_type (traditional_ptr_type_node,
3633                            tree_cons (NULL_TREE, ptr_type_node,
3634                                       tree_cons (NULL_TREE, integer_type_node,
3635                                                  tree_cons (NULL_TREE,
3636                                                             sizetype,
3637                                                             endlink))));
3638
3639   /* Prototype for bzero.  */
3640   bzero_ftype
3641     = build_function_type (void_type_node,
3642                            tree_cons (NULL_TREE, traditional_ptr_type_node,
3643                                       traditional_len_endlink));
3644
3645   /* Prototype for bcmp.  */
3646   bcmp_ftype
3647     = build_function_type (integer_type_node,
3648                            tree_cons (NULL_TREE, traditional_cptr_type_node,
3649                                       tree_cons (NULL_TREE,
3650                                                  traditional_cptr_type_node,
3651                                                  traditional_len_endlink)));
3652
3653   builtin_function ("__builtin_constant_p", default_function_type,
3654                     BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL_PTR);
3655
3656   builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
3657                     BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
3658
3659   builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
3660                     BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
3661
3662   builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
3663                     BUILT_IN_ALLOCA, BUILT_IN_NORMAL, "alloca");
3664   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS,
3665                     BUILT_IN_NORMAL, NULL_PTR);
3666   /* Define alloca, ffs as builtins.
3667      Declare _exit just to mark it as volatile.  */
3668   if (! no_builtins && ! no_nonansi_builtins)
3669     {
3670 #ifndef SMALL_STACK
3671       temp = builtin_function ("alloca", ptr_ftype_sizetype,
3672                                BUILT_IN_ALLOCA, BUILT_IN_NORMAL, NULL_PTR);
3673       /* Suppress error if redefined as a non-function.  */
3674       DECL_BUILT_IN_NONANSI (temp) = 1;
3675 #endif
3676       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS,
3677                                BUILT_IN_NORMAL, NULL_PTR);
3678       /* Suppress error if redefined as a non-function.  */
3679       DECL_BUILT_IN_NONANSI (temp) = 1;
3680       temp = builtin_function ("_exit", void_ftype_int,
3681                                0, NOT_BUILT_IN, NULL_PTR);
3682       TREE_THIS_VOLATILE (temp) = 1;
3683       TREE_SIDE_EFFECTS (temp) = 1;
3684       /* Suppress error if redefined as a non-function.  */
3685       DECL_BUILT_IN_NONANSI (temp) = 1;
3686
3687       /* The system prototypes for these functions have many
3688          variations, so don't specify parameters to avoid conflicts.
3689          The expand_* functions check the argument types anyway.  */
3690       temp = builtin_function ("bzero", void_ftype_any,
3691                                BUILT_IN_BZERO, BUILT_IN_NORMAL, NULL_PTR);
3692       DECL_BUILT_IN_NONANSI (temp) = 1;
3693       temp = builtin_function ("bcmp", int_ftype_any,
3694                                BUILT_IN_BCMP, BUILT_IN_NORMAL, NULL_PTR);
3695       DECL_BUILT_IN_NONANSI (temp) = 1;
3696     }
3697
3698   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS,
3699                     BUILT_IN_NORMAL, NULL_PTR);
3700   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
3701                     BUILT_IN_NORMAL, NULL_PTR);
3702   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
3703                     BUILT_IN_NORMAL, NULL_PTR);
3704   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3705                     BUILT_IN_NORMAL, NULL_PTR);
3706   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
3707                     BUILT_IN_NORMAL, NULL_PTR);
3708   builtin_function ("__builtin_saveregs", ptr_ftype, BUILT_IN_SAVEREGS,
3709                     BUILT_IN_NORMAL, NULL_PTR);
3710   builtin_function ("__builtin_classify_type", default_function_type,
3711                     BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL_PTR);
3712   builtin_function ("__builtin_next_arg", ptr_ftype, BUILT_IN_NEXT_ARG,
3713                     BUILT_IN_NORMAL, NULL_PTR);
3714   builtin_function ("__builtin_args_info", int_ftype_int, BUILT_IN_ARGS_INFO,
3715                     BUILT_IN_NORMAL, NULL_PTR);
3716   builtin_function ("__builtin_setjmp",
3717                     build_function_type (integer_type_node,
3718                                          tree_cons (NULL_TREE, ptr_type_node,
3719                                                     endlink)),
3720                     BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL_PTR);
3721   builtin_function ("__builtin_longjmp",
3722                     build_function_type (void_type_node,
3723                                          tree_cons (NULL_TREE, ptr_type_node,
3724                                                     tree_cons (NULL_TREE,
3725                                                                integer_type_node,
3726                                                                endlink))),
3727                     BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL_PTR);
3728   builtin_function ("__builtin_trap", void_ftype, BUILT_IN_TRAP,
3729                     BUILT_IN_NORMAL, NULL_PTR);
3730
3731   /* ISO C99 IEEE Unordered compares.  */
3732   builtin_function ("__builtin_isgreater", default_function_type,
3733                     BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL_PTR);
3734   builtin_function ("__builtin_isgreaterequal", default_function_type,
3735                     BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL_PTR);
3736   builtin_function ("__builtin_isless", default_function_type,
3737                     BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL_PTR);
3738   builtin_function ("__builtin_islessequal", default_function_type,
3739                     BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL_PTR);
3740   builtin_function ("__builtin_islessgreater", default_function_type,
3741                     BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL_PTR);
3742   builtin_function ("__builtin_isunordered", default_function_type,
3743                     BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL_PTR);
3744
3745   /* Untyped call and return.  */
3746   builtin_function ("__builtin_apply_args", ptr_ftype,
3747                     BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL_PTR);
3748
3749   temp = tree_cons (NULL_TREE,
3750                     build_pointer_type (build_function_type (void_type_node,
3751                                                              NULL_TREE)),
3752                     tree_cons (NULL_TREE,
3753                                ptr_type_node,
3754                                tree_cons (NULL_TREE,
3755                                           sizetype,
3756                                           endlink)));
3757   builtin_function ("__builtin_apply",
3758                     build_function_type (ptr_type_node, temp),
3759                     BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL_PTR);
3760   builtin_function ("__builtin_return", void_ftype_ptr,
3761                     BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL_PTR);
3762
3763   /* Support for varargs.h and stdarg.h.  */
3764   builtin_function ("__builtin_varargs_start",
3765                     build_function_type (void_type_node,
3766                                          tree_cons (NULL_TREE,
3767                                                     va_list_ref_type_node,
3768                                                     endlink)),
3769                     BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL_PTR);
3770
3771   builtin_function ("__builtin_stdarg_start",
3772                     build_function_type (void_type_node,
3773                                          tree_cons (NULL_TREE,
3774                                                     va_list_ref_type_node,
3775                                                     NULL_TREE)),
3776                     BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL_PTR);
3777
3778   builtin_function ("__builtin_va_end",
3779                     build_function_type (void_type_node,
3780                                          tree_cons (NULL_TREE,
3781                                                     va_list_ref_type_node,
3782                                                     endlink)),
3783                     BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL_PTR);
3784
3785   builtin_function ("__builtin_va_copy",
3786                     build_function_type (void_type_node,
3787                                          tree_cons (NULL_TREE,
3788                                                     va_list_ref_type_node,
3789                                                     tree_cons (NULL_TREE,
3790                                                       va_list_arg_type_node,
3791                                                       endlink))),
3792                     BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL_PTR);
3793
3794   /* ??? Ought to be `T __builtin_expect(T, T)' for any type T.  */
3795   builtin_function ("__builtin_expect",
3796                     build_function_type (long_integer_type_node,
3797                                          tree_cons (NULL_TREE,
3798                                                     long_integer_type_node,
3799                                                     tree_cons (NULL_TREE,
3800                                                         long_integer_type_node,
3801                                                         endlink))),
3802                     BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL_PTR);
3803
3804   /* Currently under experimentation.  */
3805   builtin_function ("__builtin_memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
3806                     BUILT_IN_NORMAL, "memcpy");
3807   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
3808                     BUILT_IN_MEMCMP, BUILT_IN_NORMAL, "memcmp");
3809   builtin_function ("__builtin_memset", memset_ftype,
3810                     BUILT_IN_MEMSET, BUILT_IN_NORMAL, "memset");
3811   builtin_function ("__builtin_bzero", bzero_ftype,
3812                     BUILT_IN_BZERO, BUILT_IN_NORMAL, "bzero");
3813   builtin_function ("__builtin_bcmp", bcmp_ftype,
3814                     BUILT_IN_BCMP, BUILT_IN_NORMAL, "bcmp");
3815   builtin_function ("__builtin_strcmp", int_ftype_string_string,
3816                     BUILT_IN_STRCMP, BUILT_IN_NORMAL, "strcmp");
3817   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
3818                     BUILT_IN_STRCPY, BUILT_IN_NORMAL, "strcpy");
3819   builtin_function ("__builtin_strlen", strlen_ftype,
3820                     BUILT_IN_STRLEN, BUILT_IN_NORMAL, "strlen");
3821   builtin_function ("__builtin_sqrtf", float_ftype_float,
3822                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtf");
3823   builtin_function ("__builtin_fsqrt", double_ftype_double,
3824                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrt");
3825   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
3826                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtl");
3827   builtin_function ("__builtin_sinf", float_ftype_float,
3828                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinf");
3829   builtin_function ("__builtin_sin", double_ftype_double,
3830                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sin");
3831   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
3832                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinl");
3833   builtin_function ("__builtin_cosf", float_ftype_float,
3834                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosf");
3835   builtin_function ("__builtin_cos", double_ftype_double,
3836                     BUILT_IN_COS, BUILT_IN_NORMAL, "cos");
3837   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
3838                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosl");
3839
3840   if (! no_builtins)
3841     {
3842       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS,
3843                         BUILT_IN_NORMAL, NULL_PTR);
3844       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS,
3845                         BUILT_IN_NORMAL, NULL_PTR);
3846       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS,
3847                         BUILT_IN_NORMAL, NULL_PTR);
3848       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3849                         BUILT_IN_NORMAL, NULL_PTR);
3850       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS,
3851                         BUILT_IN_NORMAL, NULL_PTR);
3852       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
3853                         BUILT_IN_NORMAL, NULL_PTR);
3854       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
3855                         BUILT_IN_NORMAL, NULL_PTR);
3856       builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET,
3857                         BUILT_IN_NORMAL, NULL_PTR);
3858       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
3859                         BUILT_IN_NORMAL, NULL_PTR);
3860       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
3861                         BUILT_IN_NORMAL, NULL_PTR);
3862       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN,
3863                         BUILT_IN_NORMAL, NULL_PTR);
3864       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT,
3865                         BUILT_IN_NORMAL, NULL_PTR);
3866       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT,
3867                         BUILT_IN_NORMAL, NULL_PTR);
3868       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
3869                         BUILT_IN_NORMAL, NULL_PTR);
3870       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN,
3871                         BUILT_IN_NORMAL, NULL_PTR);
3872       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN,
3873                         BUILT_IN_NORMAL, NULL_PTR);
3874       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN,
3875                         BUILT_IN_NORMAL, NULL_PTR);
3876       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS,
3877                         BUILT_IN_NORMAL, NULL_PTR);
3878       builtin_function ("cos", double_ftype_double, BUILT_IN_COS,
3879                         BUILT_IN_NORMAL, NULL_PTR);
3880       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS,
3881                         BUILT_IN_NORMAL, NULL_PTR);
3882
3883       /* Declare these functions volatile
3884          to avoid spurious "control drops through" warnings.  */
3885       temp = builtin_function ("abort", cplus_mode ? void_ftype : void_ftype_any,
3886                                0, NOT_BUILT_IN, NULL_PTR);
3887       TREE_THIS_VOLATILE (temp) = 1;
3888       TREE_SIDE_EFFECTS (temp) = 1;
3889
3890 #if 0 /* ??? The C++ frontend used to do this.  */
3891       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
3892          them...  */
3893       DECL_BUILT_IN_NONANSI (temp) = 1;
3894 #endif
3895       temp = builtin_function ("exit",
3896                                cplus_mode ? void_ftype_int : void_ftype_any,
3897                                0, NOT_BUILT_IN, NULL_PTR);
3898       TREE_THIS_VOLATILE (temp) = 1;
3899       TREE_SIDE_EFFECTS (temp) = 1;
3900
3901 #if 0 /* ??? The C++ frontend used to do this.  */
3902       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
3903          them...  */
3904       DECL_BUILT_IN_NONANSI (temp) = 1;
3905 #endif
3906     }
3907
3908 #if 0
3909   /* Support for these has not been written in either expand_builtin
3910      or build_function_call.  */
3911   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV,
3912                     BUILT_IN_NORMAL, NULL_PTR);
3913   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV,
3914                     BUILT_IN_NORMAL, NULL_PTR);
3915   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
3916                     BUILT_IN_NORMAL, NULL_PTR);
3917   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
3918                     BUILT_IN_NORMAL, NULL_PTR);
3919   builtin_function ("__builtin_fmod", double_ftype_double_double,
3920                     BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL_PTR);
3921   builtin_function ("__builtin_frem", double_ftype_double_double,
3922                     BUILT_IN_FREM, BUILT_IN_NORMAL, NULL_PTR);
3923   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
3924                     BUILT_IN_NORMAL, NULL_PTR);
3925   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
3926                     BUILT_IN_NORMAL, NULL_PTR);
3927 #endif
3928
3929   /* ??? Perhaps there's a better place to do this.  But it is related
3930      to __builtin_va_arg, so it isn't that off-the-wall.  */
3931   lang_type_promotes_to = simple_type_promotes_to;
3932 }
3933
3934 tree
3935 build_va_arg (expr, type)
3936      tree expr, type;
3937 {
3938   return build1 (VA_ARG_EXPR, type, expr);
3939 }
3940 \f
3941 /* Given a type, apply default promotions wrt unnamed function arguments
3942    and return the new type.  Return NULL_TREE if no change.  */
3943 /* ??? There is a function of the same name in the C++ front end that
3944    does something similar, but is more thorough and does not return NULL
3945    if no change.  We could perhaps share code, but it would make the
3946    self_promoting_type property harder to identify.  */
3947
3948 tree
3949 simple_type_promotes_to (type)
3950      tree type;
3951 {
3952   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3953     return double_type_node;
3954
3955   if (C_PROMOTING_INTEGER_TYPE_P (type))
3956     {
3957       /* Traditionally, unsignedness is preserved in default promotions.
3958          Also preserve unsignedness if not really getting any wider.  */
3959       if (TREE_UNSIGNED (type)
3960           && (flag_traditional
3961               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3962         return unsigned_type_node;
3963       return integer_type_node;
3964     }
3965
3966   return NULL_TREE;
3967 }
3968
3969 /* Return 1 if PARMS specifies a fixed number of parameters
3970    and none of their types is affected by default promotions.  */
3971
3972 int
3973 self_promoting_args_p (parms)
3974      tree parms;
3975 {
3976   register tree t;
3977   for (t = parms; t; t = TREE_CHAIN (t))
3978     {
3979       register tree type = TREE_VALUE (t);
3980
3981       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3982         return 0;
3983
3984       if (type == 0)
3985         return 0;
3986
3987       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3988         return 0;
3989
3990       if (C_PROMOTING_INTEGER_TYPE_P (type))
3991         return 0;
3992     }
3993   return 1;
3994 }
3995
3996 /* Recognize certain built-in functions so we can make tree-codes
3997    other than CALL_EXPR.  We do this when it enables fold-const.c
3998    to do something useful.  */
3999 /* ??? By rights this should go in builtins.c, but only C and C++
4000    implement build_{binary,unary}_op.  Not exactly sure what bits
4001    of functionality are actually needed from those functions, or
4002    where the similar functionality exists in the other front ends.  */
4003
4004 tree
4005 expand_tree_builtin (function, params, coerced_params)
4006      tree function, params, coerced_params;
4007 {
4008   enum tree_code code;
4009
4010   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
4011     return NULL_TREE;
4012
4013   switch (DECL_FUNCTION_CODE (function))
4014     {
4015     case BUILT_IN_ABS:
4016     case BUILT_IN_LABS:
4017     case BUILT_IN_FABS:
4018       if (coerced_params == 0)
4019         return integer_zero_node;
4020       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
4021
4022     case BUILT_IN_ISGREATER:
4023       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
4024         code = UNLE_EXPR;
4025       else
4026         code = LE_EXPR;
4027       goto unordered_cmp;
4028
4029     case BUILT_IN_ISGREATEREQUAL:
4030       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
4031         code = UNLT_EXPR;
4032       else
4033         code = LT_EXPR;
4034       goto unordered_cmp;
4035
4036     case BUILT_IN_ISLESS:
4037       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
4038         code = UNGE_EXPR;
4039       else
4040         code = GE_EXPR;
4041       goto unordered_cmp;
4042
4043     case BUILT_IN_ISLESSEQUAL:
4044       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
4045         code = UNGT_EXPR;
4046       else
4047         code = GT_EXPR;
4048       goto unordered_cmp;
4049
4050     case BUILT_IN_ISLESSGREATER:
4051       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
4052         code = UNEQ_EXPR;
4053       else
4054         code = EQ_EXPR;
4055       goto unordered_cmp;
4056
4057     case BUILT_IN_ISUNORDERED:
4058       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
4059         return integer_zero_node;
4060       code = UNORDERED_EXPR;
4061       goto unordered_cmp;
4062
4063     unordered_cmp:
4064       {
4065         tree arg0, arg1;
4066
4067         if (params == 0
4068             || TREE_CHAIN (params) == 0)
4069           {
4070             error ("too few arguments to function `%s'",
4071                    IDENTIFIER_POINTER (DECL_NAME (function)));
4072             return error_mark_node;
4073           }
4074         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
4075           {
4076             error ("too many arguments to function `%s'",
4077                    IDENTIFIER_POINTER (DECL_NAME (function)));
4078             return error_mark_node;
4079           }
4080
4081         arg0 = TREE_VALUE (params);
4082         arg1 = TREE_VALUE (TREE_CHAIN (params));
4083         arg0 = build_binary_op (code, arg0, arg1, 0);
4084         if (code != UNORDERED_EXPR)
4085           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
4086         return arg0;
4087       }
4088       break;
4089
4090     default:
4091       break;
4092     }
4093
4094   return NULL_TREE;
4095 }
4096
4097 /* Tree code classes. */
4098
4099 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
4100
4101 static char c_tree_code_type[] = {
4102   'x',
4103 #include "c-common.def"
4104 };
4105 #undef DEFTREECODE
4106
4107 /* Table indexed by tree code giving number of expression
4108    operands beyond the fixed part of the node structure.
4109    Not used for types or decls.  */
4110
4111 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
4112
4113 static int c_tree_code_length[] = {
4114   0,
4115 #include "c-common.def"
4116 };
4117 #undef DEFTREECODE
4118
4119 /* Names of tree components.
4120    Used for printing out the tree and error messages.  */
4121 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
4122
4123 static const char *c_tree_code_name[] = {
4124   "@@dummy",
4125 #include "c-common.def"
4126 };
4127 #undef DEFTREECODE
4128
4129 /* Adds the tree codes specific to the C front end to the list of all
4130    tree codes. */
4131
4132 void
4133 add_c_tree_codes ()
4134 {
4135   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
4136           c_tree_code_type,
4137           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
4138   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
4139           c_tree_code_length,
4140           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
4141   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
4142           c_tree_code_name,
4143           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
4144 }