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_UC    &unsigned_char_type_node
1194 #define T_V     &void_type_node
1195 #define T_W     &wchar_type_node
1196 #define T_ST    &sizetype
1197
1198 typedef struct {
1199   const char *format_chars;
1200   int pointer_count;
1201   /* Type of argument if no length modifier is used.  */
1202   tree *nolen;
1203   /* Type of argument if length modifier for shortening to byte is used.
1204      If NULL, then this modifier is not allowed.  */
1205   tree *hhlen;
1206   /* Type of argument if length modifier for shortening is used.
1207      If NULL, then this modifier is not allowed.  */
1208   tree *hlen;
1209   /* Type of argument if length modifier `l' is used.
1210      If NULL, then this modifier is not allowed.  */
1211   tree *llen;
1212   /* Type of argument if length modifier `q' or `ll' is used.
1213      If NULL, then this modifier is not allowed.  */
1214   tree *qlen;
1215   /* Type of argument if length modifier `L' is used.
1216      If NULL, then this modifier is not allowed.  */
1217   tree *bigllen;
1218   /* Type of argument if length modifiers 'z' or `Z' is used.
1219      If NULL, then this modifier is not allowed.  */
1220   tree *zlen;
1221   /* List of other modifier characters allowed with these options.  */
1222   const char *flag_chars;
1223 } format_char_info;
1224
1225 static format_char_info print_char_table[] = {
1226   { "di",       0,      T_I,    T_I,    T_I,    T_L,    T_LL,   T_LL,   T_ST,   "-wp0 +"        },
1227   { "oxX",      0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   "-wp0#"         },
1228   { "u",        0,      T_UI,   T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  T_ST,   "-wp0"          },
1229 /* A GNU extension.  */
1230   { "m",        0,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1231   { "feEgGaA",  0,      T_D,    NULL,   NULL,   NULL,   NULL,   T_LD,   NULL,   "-wp0 +#"       },
1232   { "c",        0,      T_I,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "-w"            },
1233   { "C",        0,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1234   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "-wp"           },
1235   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-wp"           },
1236   { "p",        1,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "-w"            },
1237   { "n",        1,      T_I,    NULL,   T_S,    T_L,    T_LL,   NULL,   NULL,   ""              },
1238   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL            }
1239 };
1240
1241 static format_char_info scan_char_table[] = {
1242   { "di",       1,      T_I,    T_C,    T_S,    T_L,    T_LL,   T_LL,   T_ST,   "*"     },
1243   { "ouxX",     1,      T_UI,   T_UC,   T_US,   T_UL,   T_ULL,  T_ULL,  T_ST,   "*"     },
1244   { "efgEGaA",  1,      T_F,    NULL,   NULL,   T_D,    NULL,   T_LD,   NULL,   "*"     },
1245   { "c",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "*"     },
1246   { "s",        1,      T_C,    NULL,   NULL,   T_W,    NULL,   NULL,   NULL,   "*a"    },
1247   { "[",        1,      T_C,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*a"    },
1248   { "C",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1249   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*a"    },
1250   { "p",        2,      T_V,    NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   "*"     },
1251   { "n",        1,      T_I,    T_C,    T_S,    T_L,    T_LL,   NULL,   T_ST,   ""      },
1252   { NULL,       0,      NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL,   NULL    }
1253 };
1254
1255 /* Handle format characters recognized by glibc's strftime.c.
1256    '2' - MUST do years as only two digits
1257    '3' - MAY do years as only two digits (depending on locale)
1258    'E' - E modifier is acceptable
1259    'O' - O modifier is acceptable to Standard C
1260    'o' - O modifier is acceptable as a GNU extension
1261    'G' - other GNU extensions  */
1262
1263 static format_char_info time_char_table[] = {
1264   { "y",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2EO-_0w" },
1265   { "D",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2" },
1266   { "g",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "2O-_0w" },
1267   { "cx",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "3E" },
1268   { "%RTXnrt",          0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "" },
1269   { "P",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "G" },
1270   { "HIMSUWdemw",       0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Ow" },
1271   { "Vju",              0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0Oow" },
1272   { "Gklsz",            0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0OGw" },
1273   { "ABZa",             0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^#" },
1274   { "p",                0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "#" },
1275   { "bh",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "^" },
1276   { "CY",               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "-_0EOw" },
1277   { NULL,               0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
1278 };
1279
1280 typedef struct function_format_info
1281 {
1282   struct function_format_info *next;  /* next structure on the list */
1283   tree name;                    /* identifier such as "printf" */
1284   tree assembler_name;          /* optional mangled identifier (for C++) */
1285   enum format_type format_type; /* type of format (printf, scanf, etc.) */
1286   int format_num;               /* number of format argument */
1287   int first_arg_num;            /* number of first arg (zero for varargs) */
1288 } function_format_info;
1289
1290 static function_format_info *function_format_list = NULL;
1291
1292 typedef struct international_format_info
1293 {
1294   struct international_format_info *next;  /* next structure on the list */
1295   tree name;                    /* identifier such as "gettext" */
1296   tree assembler_name;          /* optional mangled identifier (for C++) */
1297   int format_num;               /* number of format argument */
1298 } international_format_info;
1299
1300 static international_format_info *international_format_list = NULL;
1301
1302 static void check_format_info   PARAMS ((function_format_info *, tree));
1303
1304 /* Initialize the table of functions to perform format checking on.
1305    The ANSI functions are always checked (whether <stdio.h> is
1306    included or not), since it is common to call printf without
1307    including <stdio.h>.  There shouldn't be a problem with this,
1308    since ANSI reserves these function names whether you include the
1309    header file or not.  In any case, the checking is harmless.
1310
1311    Also initialize the name of function that modify the format string for
1312    internationalization purposes.  */
1313
1314 void
1315 init_function_format_info ()
1316 {
1317   record_function_format (get_identifier ("printf"), NULL_TREE,
1318                           printf_format_type, 1, 2);
1319   record_function_format (get_identifier ("fprintf"), NULL_TREE,
1320                           printf_format_type, 2, 3);
1321   record_function_format (get_identifier ("sprintf"), NULL_TREE,
1322                           printf_format_type, 2, 3);
1323   record_function_format (get_identifier ("scanf"), NULL_TREE,
1324                           scanf_format_type, 1, 2);
1325   record_function_format (get_identifier ("fscanf"), NULL_TREE,
1326                           scanf_format_type, 2, 3);
1327   record_function_format (get_identifier ("sscanf"), NULL_TREE,
1328                           scanf_format_type, 2, 3);
1329   record_function_format (get_identifier ("vprintf"), NULL_TREE,
1330                           printf_format_type, 1, 0);
1331   record_function_format (get_identifier ("vfprintf"), NULL_TREE,
1332                           printf_format_type, 2, 0);
1333   record_function_format (get_identifier ("vsprintf"), NULL_TREE,
1334                           printf_format_type, 2, 0);
1335   record_function_format (get_identifier ("strftime"), NULL_TREE,
1336                           strftime_format_type, 3, 0);
1337
1338   if (flag_isoc99)
1339     {
1340       /* ISO C99 adds the snprintf and vscanf family functions.  */
1341       record_function_format (get_identifier ("snprintf"), NULL_TREE,
1342                               printf_format_type, 3, 4);
1343       record_function_format (get_identifier ("vsnprintf"), NULL_TREE,
1344                               printf_format_type, 3, 0);
1345       record_function_format (get_identifier ("vscanf"), NULL_TREE,
1346                               scanf_format_type, 1, 0);
1347       record_function_format (get_identifier ("vfscanf"), NULL_TREE,
1348                               scanf_format_type, 2, 0);
1349       record_function_format (get_identifier ("vsscanf"), NULL_TREE,
1350                               scanf_format_type, 2, 0);
1351     }
1352
1353   record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1354   record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1355   record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1356 }
1357
1358 /* Record information for argument format checking.  FUNCTION_IDENT is
1359    the identifier node for the name of the function to check (its decl
1360    need not exist yet).
1361    FORMAT_TYPE specifies the type of format checking.  FORMAT_NUM is the number
1362    of the argument which is the format control string (starting from 1).
1363    FIRST_ARG_NUM is the number of the first actual argument to check
1364    against the format string, or zero if no checking is not be done
1365    (e.g. for varargs such as vfprintf).  */
1366
1367 static void
1368 record_function_format (name, assembler_name, format_type,
1369                         format_num, first_arg_num)
1370       tree name;
1371       tree assembler_name;
1372       enum format_type format_type;
1373       int format_num;
1374       int first_arg_num;
1375 {
1376   function_format_info *info;
1377
1378   /* Re-use existing structure if it's there.  */
1379
1380   for (info = function_format_list; info; info = info->next)
1381     {
1382       if (info->name == name && info->assembler_name == assembler_name)
1383         break;
1384     }
1385   if (! info)
1386     {
1387       info = (function_format_info *) xmalloc (sizeof (function_format_info));
1388       info->next = function_format_list;
1389       function_format_list = info;
1390
1391       info->name = name;
1392       info->assembler_name = assembler_name;
1393     }
1394
1395   info->format_type = format_type;
1396   info->format_num = format_num;
1397   info->first_arg_num = first_arg_num;
1398 }
1399
1400 /* Record information for the names of function that modify the format
1401    argument to format functions.  FUNCTION_IDENT is the identifier node for
1402    the name of the function (its decl need not exist yet) and FORMAT_NUM is
1403    the number of the argument which is the format control string (starting
1404    from 1).  */
1405
1406 static void
1407 record_international_format (name, assembler_name, format_num)
1408       tree name;
1409       tree assembler_name;
1410       int format_num;
1411 {
1412   international_format_info *info;
1413
1414   /* Re-use existing structure if it's there.  */
1415
1416   for (info = international_format_list; info; info = info->next)
1417     {
1418       if (info->name == name && info->assembler_name == assembler_name)
1419         break;
1420     }
1421
1422   if (! info)
1423     {
1424       info
1425         = (international_format_info *)
1426           xmalloc (sizeof (international_format_info));
1427       info->next = international_format_list;
1428       international_format_list = info;
1429
1430       info->name = name;
1431       info->assembler_name = assembler_name;
1432     }
1433
1434   info->format_num = format_num;
1435 }
1436
1437 static void
1438 tfaff ()
1439 {
1440   warning ("too few arguments for format");
1441 }
1442 \f
1443 /* Check the argument list of a call to printf, scanf, etc.
1444    NAME is the function identifier.
1445    ASSEMBLER_NAME is the function's assembler identifier.
1446    (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1447    PARAMS is the list of argument values.  */
1448
1449 void
1450 check_function_format (name, assembler_name, params)
1451      tree name;
1452      tree assembler_name;
1453      tree params;
1454 {
1455   function_format_info *info;
1456
1457   /* See if this function is a format function.  */
1458   for (info = function_format_list; info; info = info->next)
1459     {
1460       if (info->assembler_name
1461           ? (info->assembler_name == assembler_name)
1462           : (info->name == name))
1463         {
1464           /* Yup; check it.  */
1465           check_format_info (info, params);
1466           break;
1467         }
1468     }
1469 }
1470
1471 /* Check the argument list of a call to printf, scanf, etc.
1472    INFO points to the function_format_info structure.
1473    PARAMS is the list of argument values.  */
1474
1475 static void
1476 check_format_info (info, params)
1477      function_format_info *info;
1478      tree params;
1479 {
1480   int i;
1481   int arg_num;
1482   int suppressed, wide, precise;
1483   int length_char = 0;
1484   int format_char;
1485   int format_length;
1486   tree format_tree;
1487   tree cur_param;
1488   tree cur_type;
1489   tree wanted_type;
1490   tree first_fillin_param;
1491   const char *format_chars;
1492   format_char_info *fci = NULL;
1493   char flag_chars[8];
1494   int has_operand_number = 0;
1495
1496   /* Skip to format argument.  If the argument isn't available, there's
1497      no work for us to do; prototype checking will catch the problem.  */
1498   for (arg_num = 1; ; ++arg_num)
1499     {
1500       if (params == 0)
1501         return;
1502       if (arg_num == info->format_num)
1503         break;
1504       params = TREE_CHAIN (params);
1505     }
1506   format_tree = TREE_VALUE (params);
1507   params = TREE_CHAIN (params);
1508   if (format_tree == 0)
1509     return;
1510
1511   /* We can only check the format if it's a string constant.  */
1512   while (TREE_CODE (format_tree) == NOP_EXPR)
1513     format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
1514
1515   if (TREE_CODE (format_tree) == CALL_EXPR
1516       && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
1517       && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
1518           == FUNCTION_DECL))
1519     {
1520       tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
1521
1522       /* See if this is a call to a known internationalization function
1523          that modifies the format arg.  */
1524       international_format_info *info;
1525
1526       for (info = international_format_list; info; info = info->next)
1527         if (info->assembler_name
1528             ? (info->assembler_name == DECL_ASSEMBLER_NAME (function))
1529             : (info->name == DECL_NAME (function)))
1530           {
1531             tree inner_args;
1532             int i;
1533
1534             for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
1535                  inner_args != 0;
1536                  inner_args = TREE_CHAIN (inner_args), i++)
1537               if (i == info->format_num)
1538                 {
1539                   format_tree = TREE_VALUE (inner_args);
1540
1541                   while (TREE_CODE (format_tree) == NOP_EXPR)
1542                     format_tree = TREE_OPERAND (format_tree, 0);
1543                 }
1544           }
1545     }
1546
1547   if (integer_zerop (format_tree))
1548     {
1549       warning ("null format string");
1550       return;
1551     }
1552   if (TREE_CODE (format_tree) != ADDR_EXPR)
1553     {
1554       /* The user may get multiple warnings if the supplied argument
1555          isn't even a string pointer.  */
1556       /* Functions taking a va_list normally pass a non-literal format
1557          string.  These functions typically are declared with
1558          first_arg_num == 0, so avoid warning in those cases.  */
1559       if (info->first_arg_num != 0 && warn_format > 1)
1560         warning ("format not a string literal, argument types not checked");
1561       return;
1562     }
1563   format_tree = TREE_OPERAND (format_tree, 0);
1564   if (TREE_CODE (format_tree) != STRING_CST)
1565     {
1566       /* The user may get multiple warnings if the supplied argument
1567          isn't even a string pointer.  */
1568       /* Functions taking a va_list normally pass a non-literal format
1569          string.  These functions typically are declared with
1570          first_arg_num == 0, so avoid warning in those cases.  */
1571       if (info->first_arg_num != 0 && warn_format > 1)
1572         warning ("format not a string literal, argument types not checked");
1573       return;
1574     }
1575   format_chars = TREE_STRING_POINTER (format_tree);
1576   format_length = TREE_STRING_LENGTH (format_tree);
1577   if (format_length <= 1)
1578     warning ("zero-length format string");
1579   if (format_chars[--format_length] != 0)
1580     {
1581       warning ("unterminated format string");
1582       return;
1583     }
1584   /* Skip to first argument to check.  */
1585   while (arg_num + 1 < info->first_arg_num)
1586     {
1587       if (params == 0)
1588         return;
1589       params = TREE_CHAIN (params);
1590       ++arg_num;
1591     }
1592
1593   first_fillin_param = params;
1594   while (1)
1595     {
1596       int aflag;
1597       if (*format_chars == 0)
1598         {
1599           if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
1600             warning ("embedded `\\0' in format");
1601           if (info->first_arg_num != 0 && params != 0 && ! has_operand_number)
1602             warning ("too many arguments for format");
1603           return;
1604         }
1605       if (*format_chars++ != '%')
1606         continue;
1607       if (*format_chars == 0)
1608         {
1609           warning ("spurious trailing `%%' in format");
1610           continue;
1611         }
1612       if (*format_chars == '%')
1613         {
1614           ++format_chars;
1615           continue;
1616         }
1617       flag_chars[0] = 0;
1618       suppressed = wide = precise = FALSE;
1619       if (info->format_type == scanf_format_type)
1620         {
1621           suppressed = *format_chars == '*';
1622           if (suppressed)
1623             ++format_chars;
1624           while (ISDIGIT (*format_chars))
1625             ++format_chars;
1626         }
1627       else if (info->format_type == strftime_format_type)
1628         {
1629           while (*format_chars != 0 && index ("_-0^#", *format_chars) != 0)
1630             {
1631               if (pedantic)
1632                 warning ("ANSI C does not support the strftime `%c' flag",
1633                          *format_chars);
1634               if (index (flag_chars, *format_chars) != 0)
1635                 {
1636                   warning ("repeated `%c' flag in format",
1637                            *format_chars);
1638                   ++format_chars;
1639                 }
1640               else
1641                 {
1642                   i = strlen (flag_chars);
1643                   flag_chars[i++] = *format_chars++;
1644                   flag_chars[i] = 0;
1645                 }
1646             }
1647           while (ISDIGIT ((unsigned char) *format_chars))
1648             {
1649               wide = TRUE;
1650               ++format_chars;
1651             }
1652           if (wide && pedantic)
1653             warning ("ANSI C does not support strftime format width");
1654           if (*format_chars == 'E' || *format_chars == 'O')
1655             {
1656               i = strlen (flag_chars);
1657               flag_chars[i++] = *format_chars++;
1658               flag_chars[i] = 0;
1659               if (*format_chars == 'E' || *format_chars == 'O')
1660                 {
1661                   warning ("multiple E/O modifiers in format");
1662                   while (*format_chars == 'E' || *format_chars == 'O')
1663                     ++format_chars;
1664                 }
1665             }
1666         }
1667       else if (info->format_type == printf_format_type)
1668         {
1669           /* See if we have a number followed by a dollar sign.  If we do,
1670              it is an operand number, so set PARAMS to that operand.  */
1671           if (*format_chars >= '0' && *format_chars <= '9')
1672             {
1673               const char *p = format_chars;
1674
1675               while (*p >= '0' && *p++ <= '9')
1676                 ;
1677
1678               if (*p == '$')
1679                 {
1680                   int opnum = atoi (format_chars);
1681
1682                   params = first_fillin_param;
1683                   format_chars = p + 1;
1684                   has_operand_number = 1;
1685
1686                   for (i = 1; i < opnum && params != 0; i++)
1687                     params = TREE_CHAIN (params);
1688
1689                   if (opnum == 0 || params == 0)
1690                     {
1691                       warning ("operand number out of range in format");
1692                       return;
1693                     }
1694                 }
1695             }
1696
1697           while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
1698             {
1699               if (index (flag_chars, *format_chars) != 0)
1700                 warning ("repeated `%c' flag in format", *format_chars++);
1701               else
1702                 {
1703                   i = strlen (flag_chars);
1704                   flag_chars[i++] = *format_chars++;
1705                   flag_chars[i] = 0;
1706                 }
1707             }
1708           /* "If the space and + flags both appear,
1709              the space flag will be ignored."  */
1710           if (index (flag_chars, ' ') != 0
1711               && index (flag_chars, '+') != 0)
1712             warning ("use of both ` ' and `+' flags in format");
1713           /* "If the 0 and - flags both appear,
1714              the 0 flag will be ignored."  */
1715           if (index (flag_chars, '0') != 0
1716               && index (flag_chars, '-') != 0)
1717             warning ("use of both `0' and `-' flags in format");
1718           if (*format_chars == '*')
1719             {
1720               wide = TRUE;
1721               /* "...a field width...may be indicated by an asterisk.
1722                  In this case, an int argument supplies the field width..."  */
1723               ++format_chars;
1724               if (params == 0)
1725                 {
1726                   tfaff ();
1727                   return;
1728                 }
1729               if (info->first_arg_num != 0)
1730                 {
1731                   cur_param = TREE_VALUE (params);
1732                   params = TREE_CHAIN (params);
1733                   ++arg_num;
1734                   /* size_t is generally not valid here.
1735                      It will work on most machines, because size_t and int
1736                      have the same mode.  But might as well warn anyway,
1737                      since it will fail on other machines.  */
1738                   if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1739                        != integer_type_node)
1740                       &&
1741                       (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1742                        != unsigned_type_node))
1743                     warning ("field width is not type int (arg %d)", arg_num);
1744                 }
1745             }
1746           else
1747             {
1748               while (ISDIGIT (*format_chars))
1749                 {
1750                   wide = TRUE;
1751                   ++format_chars;
1752                 }
1753             }
1754           if (*format_chars == '.')
1755             {
1756               precise = TRUE;
1757               ++format_chars;
1758               if (*format_chars != '*' && !ISDIGIT (*format_chars))
1759                 warning ("`.' not followed by `*' or digit in format");
1760               /* "...a...precision...may be indicated by an asterisk.
1761                  In this case, an int argument supplies the...precision."  */
1762               if (*format_chars == '*')
1763                 {
1764                   if (info->first_arg_num != 0)
1765                     {
1766                       ++format_chars;
1767                       if (params == 0)
1768                         {
1769                           tfaff ();
1770                           return;
1771                         }
1772                       cur_param = TREE_VALUE (params);
1773                       params = TREE_CHAIN (params);
1774                       ++arg_num;
1775                       if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1776                           != integer_type_node)
1777                         warning ("field width is not type int (arg %d)",
1778                                  arg_num);
1779                     }
1780                 }
1781               else
1782                 {
1783                   while (ISDIGIT (*format_chars))
1784                     ++format_chars;
1785                 }
1786             }
1787         }
1788
1789       aflag = 0;
1790
1791       if (info->format_type != strftime_format_type)
1792         {
1793           if (*format_chars == 'h' || *format_chars == 'l')
1794             length_char = *format_chars++;
1795           else if (*format_chars == 'q' || *format_chars == 'L')
1796             {
1797               length_char = *format_chars++;
1798               if (length_char == 'q' && pedantic)
1799                 warning ("ANSI C does not support the `%c' length modifier",
1800                          length_char);
1801             }
1802           else if (*format_chars == 'Z' || *format_chars == 'z')
1803             {
1804               length_char = *format_chars++;
1805               if (pedantic && (length_char == 'Z' || !flag_isoc99))
1806                 warning ("ANSI C does not support the `%c' length modifier",
1807                          length_char);
1808             }
1809           else
1810             length_char = 0;
1811           if (length_char == 'l' && *format_chars == 'l')
1812             {
1813               length_char = 'q', format_chars++;
1814               if (pedantic && !flag_isoc99)
1815                 warning ("ANSI C does not support the `ll' length modifier");
1816             }
1817           else if (length_char == 'h' && *format_chars == 'h')
1818             {
1819               length_char = 'H', format_chars++;
1820               if (pedantic && !flag_isoc99)
1821                 warning ("ANSI C does not support the `hh' length modifier");
1822             }
1823           if (*format_chars == 'a' && info->format_type == scanf_format_type)
1824             {
1825               if (format_chars[1] == 's' || format_chars[1] == 'S'
1826                   || format_chars[1] == '[')
1827                 {
1828                   /* `a' is used as a flag.  */
1829                   aflag = 1;
1830                   format_chars++;
1831                 }
1832             }
1833           if (suppressed && length_char != 0)
1834             warning ("use of `*' and `%c' together in format", length_char);
1835         }
1836       format_char = *format_chars;
1837       if (format_char == 0
1838           || (info->format_type != strftime_format_type && format_char == '%'))
1839         {
1840           warning ("conversion lacks type at end of format");
1841           continue;
1842         }
1843       /* The m, C, and S formats are GNU extensions.  */
1844       if (pedantic && info->format_type != strftime_format_type
1845           && (format_char == 'm' || format_char == 'C' || format_char == 'S'))
1846         warning ("ANSI C does not support the `%c' format", format_char);
1847       /* The a and A formats are C99 extensions.  */
1848       if (pedantic && info->format_type != strftime_format_type
1849           && (format_char == 'a' || format_char == 'A')
1850           && !flag_isoc99)
1851         warning ("ANSI C does not support the `%c' format", format_char);
1852       format_chars++;
1853       switch (info->format_type)
1854         {
1855         case printf_format_type:
1856           fci = print_char_table;
1857           break;
1858         case scanf_format_type:
1859           fci = scan_char_table;
1860           break;
1861         case strftime_format_type:
1862           fci = time_char_table;
1863           break;
1864         default:
1865           abort ();
1866         }
1867       while (fci->format_chars != 0
1868              && index (fci->format_chars, format_char) == 0)
1869           ++fci;
1870       if (fci->format_chars == 0)
1871         {
1872           if (ISGRAPH(format_char))
1873             warning ("unknown conversion type character `%c' in format",
1874                      format_char);
1875           else
1876             warning ("unknown conversion type character 0x%x in format",
1877                      format_char);
1878           continue;
1879         }
1880       if (pedantic)
1881         {
1882           if (index (fci->flag_chars, 'G') != 0)
1883             warning ("ANSI C does not support `%%%c'", format_char);
1884           if (index (fci->flag_chars, 'o') != 0
1885               && index (flag_chars, 'O') != 0)
1886             warning ("ANSI C does not support `%%O%c'", format_char);
1887         }
1888       if (wide && index (fci->flag_chars, 'w') == 0)
1889         warning ("width used with `%c' format", format_char);
1890       if (index (fci->flag_chars, '2') != 0)
1891         warning ("`%%%c' yields only last 2 digits of year", format_char);
1892       else if (index (fci->flag_chars, '3') != 0)
1893         warning ("`%%%c' yields only last 2 digits of year in some locales",
1894                  format_char);
1895       if (precise && index (fci->flag_chars, 'p') == 0)
1896         warning ("precision used with `%c' format", format_char);
1897       if (aflag && index (fci->flag_chars, 'a') == 0)
1898         {
1899           warning ("`a' flag used with `%c' format", format_char);
1900           /* To simplify the following code.  */
1901           aflag = 0;
1902         }
1903       /* The a flag is a GNU extension.  */
1904       else if (pedantic && aflag)
1905         warning ("ANSI C does not support the `a' flag");
1906       if (info->format_type == scanf_format_type && format_char == '[')
1907         {
1908           /* Skip over scan set, in case it happens to have '%' in it.  */
1909           if (*format_chars == '^')
1910             ++format_chars;
1911           /* Find closing bracket; if one is hit immediately, then
1912              it's part of the scan set rather than a terminator.  */
1913           if (*format_chars == ']')
1914             ++format_chars;
1915           while (*format_chars && *format_chars != ']')
1916             ++format_chars;
1917           if (*format_chars != ']')
1918             /* The end of the format string was reached.  */
1919             warning ("no closing `]' for `%%[' format");
1920         }
1921       if (suppressed)
1922         {
1923           if (index (fci->flag_chars, '*') == 0)
1924             warning ("suppression of `%c' conversion in format", format_char);
1925           continue;
1926         }
1927       for (i = 0; flag_chars[i] != 0; ++i)
1928         {
1929           if (index (fci->flag_chars, flag_chars[i]) == 0)
1930             warning ("flag `%c' used with type `%c'",
1931                      flag_chars[i], format_char);
1932         }
1933       if (info->format_type == strftime_format_type)
1934         continue;
1935       if (precise && index (flag_chars, '0') != 0
1936           && (format_char == 'd' || format_char == 'i'
1937               || format_char == 'o' || format_char == 'u'
1938               || format_char == 'x' || format_char == 'X'))
1939         warning ("`0' flag ignored with precision specifier and `%c' format",
1940                  format_char);
1941       switch (length_char)
1942         {
1943         default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
1944         case 'H': wanted_type = fci->hhlen ? *(fci->hhlen) : 0; break;
1945         case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
1946         case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
1947         case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
1948         case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
1949         case 'z': case 'Z': wanted_type = (fci->zlen
1950                                            ? (TYPE_DOMAIN (*fci->zlen)
1951                                               ? TYPE_DOMAIN (*fci->zlen)
1952                                               : *fci->zlen)
1953                                            : 0); break;
1954         }
1955       if (wanted_type == 0)
1956         warning ("use of `%c' length character with `%c' type character",
1957                  length_char, format_char);
1958       else if (length_char == 'L' && pedantic
1959                && !(format_char == 'a' || format_char == 'A'
1960                     || format_char == 'e' || format_char == 'E'
1961                     || format_char == 'f' || format_char == 'F'
1962                     || format_char == 'g' || format_char == 'G'))
1963         warning ("ANSI C does not support the `L' length modifier with the `%c' type character",
1964                  format_char);
1965
1966       /* Finally. . .check type of argument against desired type!  */
1967       if (info->first_arg_num == 0)
1968         continue;
1969       if (fci->pointer_count == 0 && wanted_type == void_type_node)
1970         /* This specifier takes no argument.  */
1971         continue;
1972       if (params == 0)
1973         {
1974           tfaff ();
1975           return;
1976         }
1977       cur_param = TREE_VALUE (params);
1978       params = TREE_CHAIN (params);
1979       ++arg_num;
1980       cur_type = TREE_TYPE (cur_param);
1981
1982       STRIP_NOPS (cur_param);
1983
1984       /* Check the types of any additional pointer arguments
1985          that precede the "real" argument.  */
1986       for (i = 0; i < fci->pointer_count + aflag; ++i)
1987         {
1988           if (TREE_CODE (cur_type) == POINTER_TYPE)
1989             {
1990               cur_type = TREE_TYPE (cur_type);
1991
1992               if (cur_param != 0 && TREE_CODE (cur_param) == ADDR_EXPR)
1993                 cur_param = TREE_OPERAND (cur_param, 0);
1994               else
1995                 cur_param = 0;
1996
1997               continue;
1998             }
1999           if (TREE_CODE (cur_type) != ERROR_MARK)
2000             {
2001               if (fci->pointer_count + aflag == 1)
2002                 warning ("format argument is not a pointer (arg %d)", arg_num);
2003               else
2004                 warning ("format argument is not a pointer to a pointer (arg %d)", arg_num);
2005             }
2006           break;
2007         }
2008
2009       /* See if this is an attempt to write into a const type with
2010          scanf or with printf "%n".  */
2011       if ((info->format_type == scanf_format_type
2012            || (info->format_type == printf_format_type
2013                && format_char == 'n'))
2014           && i == fci->pointer_count + aflag
2015           && wanted_type != 0
2016           && TREE_CODE (cur_type) != ERROR_MARK
2017           && (TYPE_READONLY (cur_type)
2018               || (cur_param != 0
2019                   && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
2020                       || (DECL_P (cur_param) && TREE_READONLY (cur_param))))))
2021         warning ("writing into constant object (arg %d)", arg_num);
2022
2023       /* Check the type of the "real" argument, if there's a type we want.  */
2024       if (i == fci->pointer_count + aflag && wanted_type != 0
2025           && TREE_CODE (cur_type) != ERROR_MARK
2026           && wanted_type != TYPE_MAIN_VARIANT (cur_type)
2027           /* If we want `void *', allow any pointer type.
2028              (Anything else would already have got a warning.)  */
2029           && ! (wanted_type == void_type_node
2030                 && fci->pointer_count > 0)
2031           /* Don't warn about differences merely in signedness.  */
2032           && !(TREE_CODE (wanted_type) == INTEGER_TYPE
2033                && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE
2034                && (TREE_UNSIGNED (wanted_type)
2035                    ? wanted_type == (cur_type = unsigned_type (cur_type))
2036                    : wanted_type == (cur_type = signed_type (cur_type))))
2037           /* Likewise, "signed char", "unsigned char" and "char" are
2038              equivalent but the above test won't consider them equivalent.  */
2039           && ! (wanted_type == char_type_node
2040                 && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node
2041                     || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node)))
2042         {
2043           register const char *this;
2044           register const char *that;
2045
2046           this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
2047           that = 0;
2048           if (TREE_CODE (cur_type) != ERROR_MARK
2049               && TYPE_NAME (cur_type) != 0
2050               && TREE_CODE (cur_type) != INTEGER_TYPE
2051               && !(TREE_CODE (cur_type) == POINTER_TYPE
2052                    && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
2053             {
2054               if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
2055                   && DECL_NAME (TYPE_NAME (cur_type)) != 0)
2056                 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
2057               else
2058                 that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
2059             }
2060
2061           /* A nameless type can't possibly match what the format wants.
2062              So there will be a warning for it.
2063              Make up a string to describe vaguely what it is.  */
2064           if (that == 0)
2065             {
2066               if (TREE_CODE (cur_type) == POINTER_TYPE)
2067                 that = "pointer";
2068               else
2069                 that = "different type";
2070             }
2071
2072           /* Make the warning better in case of mismatch of int vs long.  */
2073           if (TREE_CODE (cur_type) == INTEGER_TYPE
2074               && TREE_CODE (wanted_type) == INTEGER_TYPE
2075               && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type)
2076               && TYPE_NAME (cur_type) != 0
2077               && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL)
2078             that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
2079
2080           if (strcmp (this, that) != 0)
2081             warning ("%s format, %s arg (arg %d)", this, that, arg_num);
2082         }
2083     }
2084 }
2085 \f
2086 /* Print a warning if a constant expression had overflow in folding.
2087    Invoke this function on every expression that the language
2088    requires to be a constant expression.
2089    Note the ANSI C standard says it is erroneous for a
2090    constant expression to overflow.  */
2091
2092 void
2093 constant_expression_warning (value)
2094      tree value;
2095 {
2096   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
2097        || TREE_CODE (value) == COMPLEX_CST)
2098       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
2099     pedwarn ("overflow in constant expression");
2100 }
2101
2102 /* Print a warning if an expression had overflow in folding.
2103    Invoke this function on every expression that
2104    (1) appears in the source code, and
2105    (2) might be a constant expression that overflowed, and
2106    (3) is not already checked by convert_and_check;
2107    however, do not invoke this function on operands of explicit casts.  */
2108
2109 void
2110 overflow_warning (value)
2111      tree value;
2112 {
2113   if ((TREE_CODE (value) == INTEGER_CST
2114        || (TREE_CODE (value) == COMPLEX_CST
2115            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
2116       && TREE_OVERFLOW (value))
2117     {
2118       TREE_OVERFLOW (value) = 0;
2119       if (skip_evaluation == 0)
2120         warning ("integer overflow in expression");
2121     }
2122   else if ((TREE_CODE (value) == REAL_CST
2123             || (TREE_CODE (value) == COMPLEX_CST
2124                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
2125            && TREE_OVERFLOW (value))
2126     {
2127       TREE_OVERFLOW (value) = 0;
2128       if (skip_evaluation == 0)
2129         warning ("floating point overflow in expression");
2130     }
2131 }
2132
2133 /* Print a warning if a large constant is truncated to unsigned,
2134    or if -Wconversion is used and a constant < 0 is converted to unsigned.
2135    Invoke this function on every expression that might be implicitly
2136    converted to an unsigned type.  */
2137
2138 void
2139 unsigned_conversion_warning (result, operand)
2140      tree result, operand;
2141 {
2142   if (TREE_CODE (operand) == INTEGER_CST
2143       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
2144       && TREE_UNSIGNED (TREE_TYPE (result))
2145       && skip_evaluation == 0
2146       && !int_fits_type_p (operand, TREE_TYPE (result)))
2147     {
2148       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
2149         /* This detects cases like converting -129 or 256 to unsigned char.  */
2150         warning ("large integer implicitly truncated to unsigned type");
2151       else if (warn_conversion)
2152         warning ("negative integer implicitly converted to unsigned type");
2153     }
2154 }
2155
2156 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2157    Invoke this function on every expression that is converted implicitly,
2158    i.e. because of language rules and not because of an explicit cast.  */
2159
2160 tree
2161 convert_and_check (type, expr)
2162      tree type, expr;
2163 {
2164   tree t = convert (type, expr);
2165   if (TREE_CODE (t) == INTEGER_CST)
2166     {
2167       if (TREE_OVERFLOW (t))
2168         {
2169           TREE_OVERFLOW (t) = 0;
2170
2171           /* Do not diagnose overflow in a constant expression merely
2172              because a conversion overflowed.  */
2173           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
2174
2175           /* No warning for converting 0x80000000 to int.  */
2176           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
2177                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
2178                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
2179             /* If EXPR fits in the unsigned version of TYPE,
2180                don't warn unless pedantic.  */
2181             if ((pedantic
2182                  || TREE_UNSIGNED (type)
2183                  || ! int_fits_type_p (expr, unsigned_type (type)))
2184                 && skip_evaluation == 0)
2185               warning ("overflow in implicit constant conversion");
2186         }
2187       else
2188         unsigned_conversion_warning (t, expr);
2189     }
2190   return t;
2191 }
2192 \f
2193 void
2194 c_expand_expr_stmt (expr)
2195      tree expr;
2196 {
2197   /* Do default conversion if safe and possibly important,
2198      in case within ({...}).  */
2199   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
2200       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
2201     expr = default_conversion (expr);
2202
2203   if (TREE_TYPE (expr) != error_mark_node
2204       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
2205       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
2206     error ("expression statement has incomplete type");
2207
2208   expand_expr_stmt (expr);
2209 }
2210 \f
2211 /* Validate the expression after `case' and apply default promotions.  */
2212
2213 tree
2214 check_case_value (value)
2215      tree value;
2216 {
2217   if (value == NULL_TREE)
2218     return value;
2219
2220   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
2221   STRIP_TYPE_NOPS (value);
2222
2223   if (TREE_CODE (value) != INTEGER_CST
2224       && value != error_mark_node)
2225     {
2226       error ("case label does not reduce to an integer constant");
2227       value = error_mark_node;
2228     }
2229   else
2230     /* Promote char or short to int.  */
2231     value = default_conversion (value);
2232
2233   constant_expression_warning (value);
2234
2235   return value;
2236 }
2237 \f
2238 /* Return an integer type with BITS bits of precision,
2239    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2240
2241 tree
2242 type_for_size (bits, unsignedp)
2243      unsigned bits;
2244      int unsignedp;
2245 {
2246   if (bits == TYPE_PRECISION (integer_type_node))
2247     return unsignedp ? unsigned_type_node : integer_type_node;
2248
2249   if (bits == TYPE_PRECISION (signed_char_type_node))
2250     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2251
2252   if (bits == TYPE_PRECISION (short_integer_type_node))
2253     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2254
2255   if (bits == TYPE_PRECISION (long_integer_type_node))
2256     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2257
2258   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2259     return (unsignedp ? long_long_unsigned_type_node
2260             : long_long_integer_type_node);
2261
2262   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2263     return (unsignedp ? widest_unsigned_literal_type_node
2264             : widest_integer_literal_type_node);
2265
2266   if (bits <= TYPE_PRECISION (intQI_type_node))
2267     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2268
2269   if (bits <= TYPE_PRECISION (intHI_type_node))
2270     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2271
2272   if (bits <= TYPE_PRECISION (intSI_type_node))
2273     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2274
2275   if (bits <= TYPE_PRECISION (intDI_type_node))
2276     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2277
2278   return 0;
2279 }
2280
2281 /* Return a data type that has machine mode MODE.
2282    If the mode is an integer,
2283    then UNSIGNEDP selects between signed and unsigned types.  */
2284
2285 tree
2286 type_for_mode (mode, unsignedp)
2287      enum machine_mode mode;
2288      int unsignedp;
2289 {
2290   if (mode == TYPE_MODE (integer_type_node))
2291     return unsignedp ? unsigned_type_node : integer_type_node;
2292
2293   if (mode == TYPE_MODE (signed_char_type_node))
2294     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2295
2296   if (mode == TYPE_MODE (short_integer_type_node))
2297     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2298
2299   if (mode == TYPE_MODE (long_integer_type_node))
2300     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2301
2302   if (mode == TYPE_MODE (long_long_integer_type_node))
2303     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2304
2305   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2306     return unsignedp ? widest_unsigned_literal_type_node
2307                      : widest_integer_literal_type_node;
2308
2309   if (mode == TYPE_MODE (intQI_type_node))
2310     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2311
2312   if (mode == TYPE_MODE (intHI_type_node))
2313     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2314
2315   if (mode == TYPE_MODE (intSI_type_node))
2316     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2317
2318   if (mode == TYPE_MODE (intDI_type_node))
2319     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2320
2321 #if HOST_BITS_PER_WIDE_INT >= 64
2322   if (mode == TYPE_MODE (intTI_type_node))
2323     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2324 #endif
2325
2326   if (mode == TYPE_MODE (float_type_node))
2327     return float_type_node;
2328
2329   if (mode == TYPE_MODE (double_type_node))
2330     return double_type_node;
2331
2332   if (mode == TYPE_MODE (long_double_type_node))
2333     return long_double_type_node;
2334
2335   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2336     return build_pointer_type (char_type_node);
2337
2338   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2339     return build_pointer_type (integer_type_node);
2340
2341 #ifdef VECTOR_MODE_SUPPORTED_P
2342   if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2343     return V4SF_type_node;
2344   if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2345     return V4SI_type_node;
2346   if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2347     return V2SI_type_node;
2348   if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2349     return V4HI_type_node;
2350   if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
2351     return V8QI_type_node;
2352 #endif
2353
2354   return 0;
2355 }
2356
2357 /* Return an unsigned type the same as TYPE in other respects. */
2358 tree
2359 unsigned_type (type)
2360      tree type;
2361 {
2362   tree type1 = TYPE_MAIN_VARIANT (type);
2363   if (type1 == signed_char_type_node || type1 == char_type_node)
2364     return unsigned_char_type_node;
2365   if (type1 == integer_type_node)
2366     return unsigned_type_node;
2367   if (type1 == short_integer_type_node)
2368     return short_unsigned_type_node;
2369   if (type1 == long_integer_type_node)
2370     return long_unsigned_type_node;
2371   if (type1 == long_long_integer_type_node)
2372     return long_long_unsigned_type_node;
2373   if (type1 == widest_integer_literal_type_node)
2374     return widest_unsigned_literal_type_node;
2375 #if HOST_BITS_PER_WIDE_INT >= 64
2376   if (type1 == intTI_type_node)
2377     return unsigned_intTI_type_node;
2378 #endif
2379   if (type1 == intDI_type_node)
2380     return unsigned_intDI_type_node;
2381   if (type1 == intSI_type_node)
2382     return unsigned_intSI_type_node;
2383   if (type1 == intHI_type_node)
2384     return unsigned_intHI_type_node;
2385   if (type1 == intQI_type_node)
2386     return unsigned_intQI_type_node;
2387
2388   return signed_or_unsigned_type (1, type);
2389 }
2390
2391 /* Return a signed type the same as TYPE in other respects.  */
2392
2393 tree
2394 signed_type (type)
2395      tree type;
2396 {
2397   tree type1 = TYPE_MAIN_VARIANT (type);
2398   if (type1 == unsigned_char_type_node || type1 == char_type_node)
2399     return signed_char_type_node;
2400   if (type1 == unsigned_type_node)
2401     return integer_type_node;
2402   if (type1 == short_unsigned_type_node)
2403     return short_integer_type_node;
2404   if (type1 == long_unsigned_type_node)
2405     return long_integer_type_node;
2406   if (type1 == long_long_unsigned_type_node)
2407     return long_long_integer_type_node;
2408   if (type1 == widest_unsigned_literal_type_node)
2409     return widest_integer_literal_type_node;
2410 #if HOST_BITS_PER_WIDE_INT >= 64
2411   if (type1 == unsigned_intTI_type_node)
2412     return intTI_type_node;
2413 #endif
2414   if (type1 == unsigned_intDI_type_node)
2415     return intDI_type_node;
2416   if (type1 == unsigned_intSI_type_node)
2417     return intSI_type_node;
2418   if (type1 == unsigned_intHI_type_node)
2419     return intHI_type_node;
2420   if (type1 == unsigned_intQI_type_node)
2421     return intQI_type_node;
2422
2423   return signed_or_unsigned_type (0, type);
2424 }
2425
2426 /* Return a type the same as TYPE except unsigned or
2427    signed according to UNSIGNEDP.  */
2428
2429 tree
2430 signed_or_unsigned_type (unsignedp, type)
2431      int unsignedp;
2432      tree type;
2433 {
2434   if (! INTEGRAL_TYPE_P (type)
2435       || TREE_UNSIGNED (type) == unsignedp)
2436     return type;
2437
2438   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
2439     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2440   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2441     return unsignedp ? unsigned_type_node : integer_type_node;
2442   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
2443     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2444   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
2445     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2446   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
2447     return (unsignedp ? long_long_unsigned_type_node
2448             : long_long_integer_type_node);
2449   if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
2450     return (unsignedp ? widest_unsigned_literal_type_node
2451             : widest_integer_literal_type_node);
2452   return type;
2453 }
2454 \f
2455 /* Return the minimum number of bits needed to represent VALUE in a
2456    signed or unsigned type, UNSIGNEDP says which.  */
2457
2458 unsigned int
2459 min_precision (value, unsignedp)
2460      tree value;
2461      int unsignedp;
2462 {
2463   int log;
2464
2465   /* If the value is negative, compute its negative minus 1.  The latter
2466      adjustment is because the absolute value of the largest negative value
2467      is one larger than the largest positive value.  This is equivalent to
2468      a bit-wise negation, so use that operation instead.  */
2469
2470   if (tree_int_cst_sgn (value) < 0)
2471     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
2472
2473   /* Return the number of bits needed, taking into account the fact
2474      that we need one more bit for a signed than unsigned type.  */
2475
2476   if (integer_zerop (value))
2477     log = 0;
2478   else
2479     log = tree_floor_log2 (value);
2480
2481   return log + 1 + ! unsignedp;
2482 }
2483 \f
2484 /* Print an error message for invalid operands to arith operation CODE.
2485    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2486
2487 void
2488 binary_op_error (code)
2489      enum tree_code code;
2490 {
2491   register const char *opname;
2492
2493   switch (code)
2494     {
2495     case NOP_EXPR:
2496       error ("invalid truth-value expression");
2497       return;
2498
2499     case PLUS_EXPR:
2500       opname = "+"; break;
2501     case MINUS_EXPR:
2502       opname = "-"; break;
2503     case MULT_EXPR:
2504       opname = "*"; break;
2505     case MAX_EXPR:
2506       opname = "max"; break;
2507     case MIN_EXPR:
2508       opname = "min"; break;
2509     case EQ_EXPR:
2510       opname = "=="; break;
2511     case NE_EXPR:
2512       opname = "!="; break;
2513     case LE_EXPR:
2514       opname = "<="; break;
2515     case GE_EXPR:
2516       opname = ">="; break;
2517     case LT_EXPR:
2518       opname = "<"; break;
2519     case GT_EXPR:
2520       opname = ">"; break;
2521     case LSHIFT_EXPR:
2522       opname = "<<"; break;
2523     case RSHIFT_EXPR:
2524       opname = ">>"; break;
2525     case TRUNC_MOD_EXPR:
2526     case FLOOR_MOD_EXPR:
2527       opname = "%"; break;
2528     case TRUNC_DIV_EXPR:
2529     case FLOOR_DIV_EXPR:
2530       opname = "/"; break;
2531     case BIT_AND_EXPR:
2532       opname = "&"; break;
2533     case BIT_IOR_EXPR:
2534       opname = "|"; break;
2535     case TRUTH_ANDIF_EXPR:
2536       opname = "&&"; break;
2537     case TRUTH_ORIF_EXPR:
2538       opname = "||"; break;
2539     case BIT_XOR_EXPR:
2540       opname = "^"; break;
2541     case LROTATE_EXPR:
2542     case RROTATE_EXPR:
2543       opname = "rotate"; break;
2544     default:
2545       opname = "unknown"; break;
2546     }
2547   error ("invalid operands to binary %s", opname);
2548 }
2549 \f
2550 /* Subroutine of build_binary_op, used for comparison operations.
2551    See if the operands have both been converted from subword integer types
2552    and, if so, perhaps change them both back to their original type.
2553    This function is also responsible for converting the two operands
2554    to the proper common type for comparison.
2555
2556    The arguments of this function are all pointers to local variables
2557    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2558    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2559
2560    If this function returns nonzero, it means that the comparison has
2561    a constant value.  What this function returns is an expression for
2562    that value.  */
2563
2564 tree
2565 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2566      tree *op0_ptr, *op1_ptr;
2567      tree *restype_ptr;
2568      enum tree_code *rescode_ptr;
2569 {
2570   register tree type;
2571   tree op0 = *op0_ptr;
2572   tree op1 = *op1_ptr;
2573   int unsignedp0, unsignedp1;
2574   int real1, real2;
2575   tree primop0, primop1;
2576   enum tree_code code = *rescode_ptr;
2577
2578   /* Throw away any conversions to wider types
2579      already present in the operands.  */
2580
2581   primop0 = get_narrower (op0, &unsignedp0);
2582   primop1 = get_narrower (op1, &unsignedp1);
2583
2584   /* Handle the case that OP0 does not *contain* a conversion
2585      but it *requires* conversion to FINAL_TYPE.  */
2586
2587   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2588     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2589   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2590     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2591
2592   /* If one of the operands must be floated, we cannot optimize.  */
2593   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2594   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2595
2596   /* If first arg is constant, swap the args (changing operation
2597      so value is preserved), for canonicalization.  Don't do this if
2598      the second arg is 0.  */
2599
2600   if (TREE_CONSTANT (primop0)
2601       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2602     {
2603       register tree tem = primop0;
2604       register int temi = unsignedp0;
2605       primop0 = primop1;
2606       primop1 = tem;
2607       tem = op0;
2608       op0 = op1;
2609       op1 = tem;
2610       *op0_ptr = op0;
2611       *op1_ptr = op1;
2612       unsignedp0 = unsignedp1;
2613       unsignedp1 = temi;
2614       temi = real1;
2615       real1 = real2;
2616       real2 = temi;
2617
2618       switch (code)
2619         {
2620         case LT_EXPR:
2621           code = GT_EXPR;
2622           break;
2623         case GT_EXPR:
2624           code = LT_EXPR;
2625           break;
2626         case LE_EXPR:
2627           code = GE_EXPR;
2628           break;
2629         case GE_EXPR:
2630           code = LE_EXPR;
2631           break;
2632         default:
2633           break;
2634         }
2635       *rescode_ptr = code;
2636     }
2637
2638   /* If comparing an integer against a constant more bits wide,
2639      maybe we can deduce a value of 1 or 0 independent of the data.
2640      Or else truncate the constant now
2641      rather than extend the variable at run time.
2642
2643      This is only interesting if the constant is the wider arg.
2644      Also, it is not safe if the constant is unsigned and the
2645      variable arg is signed, since in this case the variable
2646      would be sign-extended and then regarded as unsigned.
2647      Our technique fails in this case because the lowest/highest
2648      possible unsigned results don't follow naturally from the
2649      lowest/highest possible values of the variable operand.
2650      For just EQ_EXPR and NE_EXPR there is another technique that
2651      could be used: see if the constant can be faithfully represented
2652      in the other operand's type, by truncating it and reextending it
2653      and see if that preserves the constant's value.  */
2654
2655   if (!real1 && !real2
2656       && TREE_CODE (primop1) == INTEGER_CST
2657       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2658     {
2659       int min_gt, max_gt, min_lt, max_lt;
2660       tree maxval, minval;
2661       /* 1 if comparison is nominally unsigned.  */
2662       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2663       tree val;
2664
2665       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2666
2667       /* If TYPE is an enumeration, then we need to get its min/max
2668          values from it's underlying integral type, not the enumerated
2669          type itself.  */
2670       if (TREE_CODE (type) == ENUMERAL_TYPE)
2671         type = type_for_size (TYPE_PRECISION (type), unsignedp0);
2672
2673       maxval = TYPE_MAX_VALUE (type);
2674       minval = TYPE_MIN_VALUE (type);
2675
2676       if (unsignedp && !unsignedp0)
2677         *restype_ptr = signed_type (*restype_ptr);
2678
2679       if (TREE_TYPE (primop1) != *restype_ptr)
2680         primop1 = convert (*restype_ptr, primop1);
2681       if (type != *restype_ptr)
2682         {
2683           minval = convert (*restype_ptr, minval);
2684           maxval = convert (*restype_ptr, maxval);
2685         }
2686
2687       if (unsignedp && unsignedp0)
2688         {
2689           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2690           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2691           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2692           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2693         }
2694       else
2695         {
2696           min_gt = INT_CST_LT (primop1, minval);
2697           max_gt = INT_CST_LT (primop1, maxval);
2698           min_lt = INT_CST_LT (minval, primop1);
2699           max_lt = INT_CST_LT (maxval, primop1);
2700         }
2701
2702       val = 0;
2703       /* This used to be a switch, but Genix compiler can't handle that.  */
2704       if (code == NE_EXPR)
2705         {
2706           if (max_lt || min_gt)
2707             val = boolean_true_node;
2708         }
2709       else if (code == EQ_EXPR)
2710         {
2711           if (max_lt || min_gt)
2712             val = boolean_false_node;
2713         }
2714       else if (code == LT_EXPR)
2715         {
2716           if (max_lt)
2717             val = boolean_true_node;
2718           if (!min_lt)
2719             val = boolean_false_node;
2720         }
2721       else if (code == GT_EXPR)
2722         {
2723           if (min_gt)
2724             val = boolean_true_node;
2725           if (!max_gt)
2726             val = boolean_false_node;
2727         }
2728       else if (code == LE_EXPR)
2729         {
2730           if (!max_gt)
2731             val = boolean_true_node;
2732           if (min_gt)
2733             val = boolean_false_node;
2734         }
2735       else if (code == GE_EXPR)
2736         {
2737           if (!min_lt)
2738             val = boolean_true_node;
2739           if (max_lt)
2740             val = boolean_false_node;
2741         }
2742
2743       /* If primop0 was sign-extended and unsigned comparison specd,
2744          we did a signed comparison above using the signed type bounds.
2745          But the comparison we output must be unsigned.
2746
2747          Also, for inequalities, VAL is no good; but if the signed
2748          comparison had *any* fixed result, it follows that the
2749          unsigned comparison just tests the sign in reverse
2750          (positive values are LE, negative ones GE).
2751          So we can generate an unsigned comparison
2752          against an extreme value of the signed type.  */
2753
2754       if (unsignedp && !unsignedp0)
2755         {
2756           if (val != 0)
2757             switch (code)
2758               {
2759               case LT_EXPR:
2760               case GE_EXPR:
2761                 primop1 = TYPE_MIN_VALUE (type);
2762                 val = 0;
2763                 break;
2764
2765               case LE_EXPR:
2766               case GT_EXPR:
2767                 primop1 = TYPE_MAX_VALUE (type);
2768                 val = 0;
2769                 break;
2770
2771               default:
2772                 break;
2773               }
2774           type = unsigned_type (type);
2775         }
2776
2777       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2778         {
2779           /* This is the case of (char)x >?< 0x80, which people used to use
2780              expecting old C compilers to change the 0x80 into -0x80.  */
2781           if (val == boolean_false_node)
2782             warning ("comparison is always false due to limited range of data type");
2783           if (val == boolean_true_node)
2784             warning ("comparison is always true due to limited range of data type");
2785         }
2786
2787       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2788         {
2789           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2790           if (val == boolean_false_node)
2791             warning ("comparison is always false due to limited range of data type");
2792           if (val == boolean_true_node)
2793             warning ("comparison is always true due to limited range of data type");
2794         }
2795
2796       if (val != 0)
2797         {
2798           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2799           if (TREE_SIDE_EFFECTS (primop0))
2800             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2801           return val;
2802         }
2803
2804       /* Value is not predetermined, but do the comparison
2805          in the type of the operand that is not constant.
2806          TYPE is already properly set.  */
2807     }
2808   else if (real1 && real2
2809            && (TYPE_PRECISION (TREE_TYPE (primop0))
2810                == TYPE_PRECISION (TREE_TYPE (primop1))))
2811     type = TREE_TYPE (primop0);
2812
2813   /* If args' natural types are both narrower than nominal type
2814      and both extend in the same manner, compare them
2815      in the type of the wider arg.
2816      Otherwise must actually extend both to the nominal
2817      common type lest different ways of extending
2818      alter the result.
2819      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2820
2821   else if (unsignedp0 == unsignedp1 && real1 == real2
2822            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2823            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2824     {
2825       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2826       type = signed_or_unsigned_type (unsignedp0
2827                                       || TREE_UNSIGNED (*restype_ptr),
2828                                       type);
2829       /* Make sure shorter operand is extended the right way
2830          to match the longer operand.  */
2831       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2832                          primop0);
2833       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2834                          primop1);
2835     }
2836   else
2837     {
2838       /* Here we must do the comparison on the nominal type
2839          using the args exactly as we received them.  */
2840       type = *restype_ptr;
2841       primop0 = op0;
2842       primop1 = op1;
2843
2844       if (!real1 && !real2 && integer_zerop (primop1)
2845           && TREE_UNSIGNED (*restype_ptr))
2846         {
2847           tree value = 0;
2848           switch (code)
2849             {
2850             case GE_EXPR:
2851               /* All unsigned values are >= 0, so we warn if extra warnings
2852                  are requested.  However, if OP0 is a constant that is
2853                  >= 0, the signedness of the comparison isn't an issue,
2854                  so suppress the warning.  */
2855               if (extra_warnings && !in_system_header
2856                   && ! (TREE_CODE (primop0) == INTEGER_CST
2857                         && ! TREE_OVERFLOW (convert (signed_type (type),
2858                                                      primop0))))
2859                 warning ("comparison of unsigned expression >= 0 is always true");
2860               value = boolean_true_node;
2861               break;
2862
2863             case LT_EXPR:
2864               if (extra_warnings && !in_system_header
2865                   && ! (TREE_CODE (primop0) == INTEGER_CST
2866                         && ! TREE_OVERFLOW (convert (signed_type (type),
2867                                                      primop0))))
2868                 warning ("comparison of unsigned expression < 0 is always false");
2869               value = boolean_false_node;
2870               break;
2871
2872             default:
2873               break;
2874             }
2875
2876           if (value != 0)
2877             {
2878               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2879               if (TREE_SIDE_EFFECTS (primop0))
2880                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2881                               primop0, value);
2882               return value;
2883             }
2884         }
2885     }
2886
2887   *op0_ptr = convert (type, primop0);
2888   *op1_ptr = convert (type, primop1);
2889
2890   *restype_ptr = boolean_type_node;
2891
2892   return 0;
2893 }
2894 \f
2895 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2896    or validate its data type for an `if' or `while' statement or ?..: exp.
2897
2898    This preparation consists of taking the ordinary
2899    representation of an expression expr and producing a valid tree
2900    boolean expression describing whether expr is nonzero.  We could
2901    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2902    but we optimize comparisons, &&, ||, and !.
2903
2904    The resulting type should always be `boolean_type_node'.  */
2905
2906 tree
2907 truthvalue_conversion (expr)
2908      tree expr;
2909 {
2910   if (TREE_CODE (expr) == ERROR_MARK)
2911     return expr;
2912
2913 #if 0 /* This appears to be wrong for C++.  */
2914   /* These really should return error_mark_node after 2.4 is stable.
2915      But not all callers handle ERROR_MARK properly.  */
2916   switch (TREE_CODE (TREE_TYPE (expr)))
2917     {
2918     case RECORD_TYPE:
2919       error ("struct type value used where scalar is required");
2920       return boolean_false_node;
2921
2922     case UNION_TYPE:
2923       error ("union type value used where scalar is required");
2924       return boolean_false_node;
2925
2926     case ARRAY_TYPE:
2927       error ("array type value used where scalar is required");
2928       return boolean_false_node;
2929
2930     default:
2931       break;
2932     }
2933 #endif /* 0 */
2934
2935   switch (TREE_CODE (expr))
2936     {
2937     case EQ_EXPR:
2938     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2939     case TRUTH_ANDIF_EXPR:
2940     case TRUTH_ORIF_EXPR:
2941     case TRUTH_AND_EXPR:
2942     case TRUTH_OR_EXPR:
2943     case TRUTH_XOR_EXPR:
2944     case TRUTH_NOT_EXPR:
2945       TREE_TYPE (expr) = boolean_type_node;
2946       return expr;
2947
2948     case ERROR_MARK:
2949       return expr;
2950
2951     case INTEGER_CST:
2952       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2953
2954     case REAL_CST:
2955       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2956
2957     case ADDR_EXPR:
2958       /* If we are taking the address of a external decl, it might be zero
2959          if it is weak, so we cannot optimize.  */
2960       if (DECL_P (TREE_OPERAND (expr, 0))
2961           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2962         break;
2963
2964       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2965         return build (COMPOUND_EXPR, boolean_type_node,
2966                       TREE_OPERAND (expr, 0), boolean_true_node);
2967       else
2968         return boolean_true_node;
2969
2970     case COMPLEX_EXPR:
2971       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2972                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2973                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2974                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2975                               0);
2976
2977     case NEGATE_EXPR:
2978     case ABS_EXPR:
2979     case FLOAT_EXPR:
2980     case FFS_EXPR:
2981       /* These don't change whether an object is non-zero or zero.  */
2982       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2983
2984     case LROTATE_EXPR:
2985     case RROTATE_EXPR:
2986       /* These don't change whether an object is zero or non-zero, but
2987          we can't ignore them if their second arg has side-effects.  */
2988       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2989         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2990                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2991       else
2992         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2993
2994     case COND_EXPR:
2995       /* Distribute the conversion into the arms of a COND_EXPR.  */
2996       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2997                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2998                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2999
3000     case CONVERT_EXPR:
3001       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3002          since that affects how `default_conversion' will behave.  */
3003       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
3004           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
3005         break;
3006       /* fall through...  */
3007     case NOP_EXPR:
3008       /* If this is widening the argument, we can ignore it.  */
3009       if (TYPE_PRECISION (TREE_TYPE (expr))
3010           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
3011         return truthvalue_conversion (TREE_OPERAND (expr, 0));
3012       break;
3013
3014     case MINUS_EXPR:
3015       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
3016          this case.  */
3017       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
3018           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
3019         break;
3020       /* fall through...  */
3021     case BIT_XOR_EXPR:
3022       /* This and MINUS_EXPR can be changed into a comparison of the
3023          two objects.  */
3024       if (TREE_TYPE (TREE_OPERAND (expr, 0))
3025           == TREE_TYPE (TREE_OPERAND (expr, 1)))
3026         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
3027                                 TREE_OPERAND (expr, 1), 1);
3028       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
3029                               fold (build1 (NOP_EXPR,
3030                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
3031                                             TREE_OPERAND (expr, 1))), 1);
3032
3033     case BIT_AND_EXPR:
3034       if (integer_onep (TREE_OPERAND (expr, 1))
3035           && TREE_TYPE (expr) != boolean_type_node)
3036         /* Using convert here would cause infinite recursion.  */
3037         return build1 (NOP_EXPR, boolean_type_node, expr);
3038       break;
3039
3040     case MODIFY_EXPR:
3041       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
3042         warning ("suggest parentheses around assignment used as truth value");
3043       break;
3044
3045     default:
3046       break;
3047     }
3048
3049   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
3050     {
3051       tree tem = save_expr (expr);
3052       return (build_binary_op
3053               ((TREE_SIDE_EFFECTS (expr)
3054                 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
3055                truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
3056                truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
3057                0));
3058     }
3059
3060   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
3061 }
3062 \f
3063 #if USE_CPPLIB
3064 /* Read the rest of a #-directive from input stream FINPUT.
3065    In normal use, the directive name and the white space after it
3066    have already been read, so they won't be included in the result.
3067    We allow for the fact that the directive line may contain
3068    a newline embedded within a character or string literal which forms
3069    a part of the directive.
3070
3071    The value is a string in a reusable buffer.  It remains valid
3072    only until the next time this function is called.  */
3073 unsigned char *yy_cur, *yy_lim;
3074
3075 #define GETC() (yy_cur < yy_lim ? *yy_cur++ : yy_get_token ())
3076 #define UNGETC(c) ((c) == EOF ? 0 : yy_cur--)
3077
3078 int
3079 yy_get_token ()
3080 {
3081   for (;;)
3082     {
3083       parse_in.limit = parse_in.token_buffer;
3084       cpp_token = cpp_get_token (&parse_in);
3085       if (cpp_token == CPP_EOF)
3086         return -1;
3087       yy_lim = CPP_PWRITTEN (&parse_in);
3088       yy_cur = parse_in.token_buffer;
3089       if (yy_cur < yy_lim)
3090         return *yy_cur++;
3091     }
3092 }
3093
3094 char *
3095 get_directive_line ()
3096 {
3097   static char *directive_buffer = NULL;
3098   static unsigned buffer_length = 0;
3099   register char *p;
3100   register char *buffer_limit;
3101   register int looking_for = 0;
3102   register int char_escaped = 0;
3103
3104   if (buffer_length == 0)
3105     {
3106       directive_buffer = (char *)xmalloc (128);
3107       buffer_length = 128;
3108     }
3109
3110   buffer_limit = &directive_buffer[buffer_length];
3111
3112   for (p = directive_buffer; ; )
3113     {
3114       int c;
3115
3116       /* Make buffer bigger if it is full.  */
3117       if (p >= buffer_limit)
3118         {
3119           register unsigned bytes_used = (p - directive_buffer);
3120
3121           buffer_length *= 2;
3122           directive_buffer
3123             = (char *)xrealloc (directive_buffer, buffer_length);
3124           p = &directive_buffer[bytes_used];
3125           buffer_limit = &directive_buffer[buffer_length];
3126         }
3127
3128       c = GETC ();
3129
3130       /* Discard initial whitespace.  */
3131       if ((c == ' ' || c == '\t') && p == directive_buffer)
3132         continue;
3133
3134       /* Detect the end of the directive.  */
3135       if (c == '\n' && looking_for == 0)
3136         {
3137           UNGETC (c);
3138           c = '\0';
3139         }
3140
3141       *p++ = c;
3142
3143       if (c == 0)
3144         return directive_buffer;
3145
3146       /* Handle string and character constant syntax.  */
3147       if (looking_for)
3148         {
3149           if (looking_for == c && !char_escaped)
3150             looking_for = 0;    /* Found terminator... stop looking.  */
3151         }
3152       else
3153         if (c == '\'' || c == '"')
3154           looking_for = c;      /* Don't stop buffering until we see another
3155                                    another one of these (or an EOF).  */
3156
3157       /* Handle backslash.  */
3158       char_escaped = (c == '\\' && ! char_escaped);
3159     }
3160 }
3161 #else
3162 /* Read the rest of a #-directive from input stream FINPUT.
3163    In normal use, the directive name and the white space after it
3164    have already been read, so they won't be included in the result.
3165    We allow for the fact that the directive line may contain
3166    a newline embedded within a character or string literal which forms
3167    a part of the directive.
3168
3169    The value is a string in a reusable buffer.  It remains valid
3170    only until the next time this function is called.
3171
3172    The terminating character ('\n' or EOF) is left in FINPUT for the
3173    caller to re-read.  */
3174
3175 char *
3176 get_directive_line (finput)
3177      register FILE *finput;
3178 {
3179   static char *directive_buffer = NULL;
3180   static unsigned buffer_length = 0;
3181   register char *p;
3182   register char *buffer_limit;
3183   register int looking_for = 0;
3184   register int char_escaped = 0;
3185
3186   if (buffer_length == 0)
3187     {
3188       directive_buffer = (char *)xmalloc (128);
3189       buffer_length = 128;
3190     }
3191
3192   buffer_limit = &directive_buffer[buffer_length];
3193
3194   for (p = directive_buffer; ; )
3195     {
3196       int c;
3197
3198       /* Make buffer bigger if it is full.  */
3199       if (p >= buffer_limit)
3200         {
3201           register unsigned bytes_used = (p - directive_buffer);
3202
3203           buffer_length *= 2;
3204           directive_buffer
3205             = (char *)xrealloc (directive_buffer, buffer_length);
3206           p = &directive_buffer[bytes_used];
3207           buffer_limit = &directive_buffer[buffer_length];
3208         }
3209
3210       c = getc (finput);
3211
3212       /* Discard initial whitespace.  */
3213       if ((c == ' ' || c == '\t') && p == directive_buffer)
3214         continue;
3215
3216       /* Detect the end of the directive.  */
3217       if (looking_for == 0
3218           && (c == '\n' || c == EOF))
3219         {
3220           ungetc (c, finput);
3221           c = '\0';
3222         }
3223
3224       *p++ = c;
3225
3226       if (c == 0)
3227         return directive_buffer;
3228
3229       /* Handle string and character constant syntax.  */
3230       if (looking_for)
3231         {
3232           if (looking_for == c && !char_escaped)
3233             looking_for = 0;    /* Found terminator... stop looking.  */
3234         }
3235       else
3236         if (c == '\'' || c == '"')
3237           looking_for = c;      /* Don't stop buffering until we see another
3238                                    one of these (or an EOF).  */
3239
3240       /* Handle backslash.  */
3241       char_escaped = (c == '\\' && ! char_escaped);
3242     }
3243 }
3244 #endif /* !USE_CPPLIB */
3245 \f
3246 /* Make a variant type in the proper way for C/C++, propagating qualifiers
3247    down to the element type of an array.  */
3248
3249 tree
3250 c_build_qualified_type (type, type_quals)
3251      tree type;
3252      int type_quals;
3253 {
3254   /* A restrict-qualified pointer type must be a pointer to object or
3255      incomplete type.  Note that the use of POINTER_TYPE_P also allows
3256      REFERENCE_TYPEs, which is appropriate for C++.  Unfortunately,
3257      the C++ front-end also use POINTER_TYPE for pointer-to-member
3258      values, so even though it should be illegal to use `restrict'
3259      with such an entity we don't flag that here.  Thus, special case
3260      code for that case is required in the C++ front-end.  */
3261   if ((type_quals & TYPE_QUAL_RESTRICT)
3262       && (!POINTER_TYPE_P (type)
3263           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
3264     {
3265       error ("invalid use of `restrict'");
3266       type_quals &= ~TYPE_QUAL_RESTRICT;
3267     }
3268
3269   if (TREE_CODE (type) == ARRAY_TYPE)
3270     return build_array_type (c_build_qualified_type (TREE_TYPE (type),
3271                                                      type_quals),
3272                              TYPE_DOMAIN (type));
3273   return build_qualified_type (type, type_quals);
3274 }
3275
3276 /* Apply the TYPE_QUALS to the new DECL.  */
3277
3278 void
3279 c_apply_type_quals_to_decl (type_quals, decl)
3280      int type_quals;
3281      tree decl;
3282 {
3283   if ((type_quals & TYPE_QUAL_CONST)
3284       || (TREE_TYPE (decl)
3285           && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
3286     TREE_READONLY (decl) = 1;
3287   if (type_quals & TYPE_QUAL_VOLATILE)
3288     {
3289       TREE_SIDE_EFFECTS (decl) = 1;
3290       TREE_THIS_VOLATILE (decl) = 1;
3291     }
3292   if (type_quals & TYPE_QUAL_RESTRICT)
3293     {
3294       if (!TREE_TYPE (decl)
3295           || !POINTER_TYPE_P (TREE_TYPE (decl))
3296           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
3297         error ("invalid use of `restrict'");
3298       else if (flag_strict_aliasing)
3299         {
3300           /* No two restricted pointers can point at the same thing.
3301              However, a restricted pointer can point at the same thing
3302              as an unrestricted pointer, if that unrestricted pointer
3303              is based on the restricted pointer.  So, we make the
3304              alias set for the restricted pointer a subset of the
3305              alias set for the type pointed to by the type of the
3306              decl.  */
3307
3308           HOST_WIDE_INT pointed_to_alias_set
3309             = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
3310
3311           if (pointed_to_alias_set == 0)
3312             /* It's not legal to make a subset of alias set zero.  */
3313             ;
3314           else
3315             {
3316               DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
3317               record_alias_subset  (pointed_to_alias_set,
3318                                     DECL_POINTER_ALIAS_SET (decl));
3319             }
3320         }
3321     }
3322 }
3323
3324
3325 /* Return the typed-based alias set for T, which may be an expression
3326    or a type.  Return -1 if we don't do anything special.  */
3327
3328 HOST_WIDE_INT
3329 lang_get_alias_set (t)
3330      tree t;
3331 {
3332   tree u;
3333
3334   /* Permit type-punning when accessing a union, provided the access
3335      is directly through the union.  For example, this code does not
3336      permit taking the address of a union member and then storing
3337      through it.  Even the type-punning allowed here is a GCC
3338      extension, albeit a common and useful one; the C standard says
3339      that such accesses have implementation-defined behavior.  */
3340   for (u = t;
3341        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
3342        u = TREE_OPERAND (u, 0))
3343     if (TREE_CODE (u) == COMPONENT_REF
3344         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
3345       return 0;
3346
3347   /* If this is a char *, the ANSI C standard says it can alias
3348      anything.  Note that all references need do this.  */
3349   if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
3350       && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
3351       && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
3352     return 0;
3353
3354   /* That's all the expressions we handle specially.  */
3355   if (! TYPE_P (t))
3356     return -1;
3357
3358   /* The C standard specifically allows aliasing between signed and
3359      unsigned variants of the same type.  We treat the signed
3360      variant as canonical.  */
3361   if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
3362     {
3363       tree t1 = signed_type (t);
3364
3365       /* t1 == t can happen for boolean nodes which are always unsigned.  */
3366       if (t1 != t)
3367         return get_alias_set (t1);
3368     }
3369   else if (POINTER_TYPE_P (t))
3370     {
3371       tree t1;
3372
3373       /* Unfortunately, there is no canonical form of a pointer type.
3374          In particular, if we have `typedef int I', then `int *', and
3375          `I *' are different types.  So, we have to pick a canonical
3376          representative.  We do this below.
3377
3378          Technically, this approach is actually more conservative that
3379          it needs to be.  In particular, `const int *' and `int *'
3380          chould be in different alias sets, according to the C and C++
3381          standard, since their types are not the same, and so,
3382          technically, an `int **' and `const int **' cannot point at
3383          the same thing.
3384
3385          But, the standard is wrong.  In particular, this code is
3386          legal C++:
3387
3388             int *ip;
3389             int **ipp = &ip;
3390             const int* const* cipp = &ip;
3391
3392          And, it doesn't make sense for that to be legal unless you
3393          can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
3394          the pointed-to types.  This issue has been reported to the
3395          C++ committee.  */
3396       t1 = TYPE_MAIN_VARIANT (TREE_TYPE (t));
3397       t1 = ((TREE_CODE (t) == POINTER_TYPE)
3398            ? build_pointer_type (t1) : build_reference_type (t1));
3399       if (t1 != t)
3400         return get_alias_set (t1);
3401     }
3402   /* It's not yet safe to use alias sets for classes in C++ because
3403      the TYPE_FIELDs list for a class doesn't mention base classes.  */
3404   else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
3405     return 0;
3406
3407   return -1;
3408 }
3409
3410 /* Build tree nodes and builtin functions common to both C and C++ language
3411    frontends.
3412    CPLUS_MODE is nonzero if we are called from the C++ frontend, we generate
3413    some stricter prototypes in that case.
3414    NO_BUILTINS and NO_NONANSI_BUILTINS contain the respective values of
3415    the language frontend flags flag_no_builtin and
3416    flag_no_nonansi_builtin.  */
3417
3418 void
3419 c_common_nodes_and_builtins (cplus_mode, no_builtins, no_nonansi_builtins)
3420     int cplus_mode, no_builtins, no_nonansi_builtins;
3421 {
3422   tree temp;
3423   tree memcpy_ftype, memset_ftype, strlen_ftype;
3424   tree bzero_ftype, bcmp_ftype;
3425   tree endlink, int_endlink, double_endlink, unsigned_endlink;
3426   tree sizetype_endlink;
3427   tree ptr_ftype, ptr_ftype_unsigned;
3428   tree void_ftype_any, void_ftype_int, int_ftype_any;
3429   tree double_ftype_double, double_ftype_double_double;
3430   tree float_ftype_float, ldouble_ftype_ldouble;
3431   tree int_ftype_cptr_cptr_sizet;
3432   tree int_ftype_string_string, string_ftype_ptr_ptr;
3433   tree long_ftype_long;
3434   /* Either char* or void*.  */
3435   tree traditional_ptr_type_node;
3436   /* Either const char* or const void*.  */
3437   tree traditional_cptr_type_node;
3438   tree traditional_len_type_node;
3439   tree traditional_len_endlink;
3440   tree va_list_ref_type_node;
3441   tree va_list_arg_type_node;
3442
3443   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3444                         va_list_type_node));
3445
3446   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3447                         ptrdiff_type_node));
3448
3449   pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3450                         sizetype));
3451
3452   if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3453     {
3454       va_list_arg_type_node = va_list_ref_type_node =
3455         build_pointer_type (TREE_TYPE (va_list_type_node));
3456     }
3457   else
3458     {
3459       va_list_arg_type_node = va_list_type_node;
3460       va_list_ref_type_node = build_reference_type (va_list_type_node);
3461     }
3462
3463   endlink = void_list_node;
3464   int_endlink = tree_cons (NULL_TREE, integer_type_node, endlink);
3465   double_endlink = tree_cons (NULL_TREE, double_type_node, endlink);
3466   unsigned_endlink = tree_cons (NULL_TREE, unsigned_type_node, endlink);
3467
3468   ptr_ftype = build_function_type (ptr_type_node, NULL_TREE);
3469   ptr_ftype_unsigned = build_function_type (ptr_type_node, unsigned_endlink);
3470   sizetype_endlink = tree_cons (NULL_TREE, TYPE_DOMAIN (sizetype), endlink);
3471   /* We realloc here because sizetype could be int or unsigned.  S'ok.  */
3472   ptr_ftype_sizetype = build_function_type (ptr_type_node, sizetype_endlink);
3473
3474   int_ftype_any = build_function_type (integer_type_node, NULL_TREE);
3475   void_ftype_any = build_function_type (void_type_node, NULL_TREE);
3476   void_ftype = build_function_type (void_type_node, endlink);
3477   void_ftype_int = build_function_type (void_type_node, int_endlink);
3478   void_ftype_ptr
3479     = build_function_type (void_type_node,
3480                            tree_cons (NULL_TREE, ptr_type_node, endlink));
3481
3482   float_ftype_float
3483     = build_function_type (float_type_node,
3484                            tree_cons (NULL_TREE, float_type_node, endlink));
3485
3486   double_ftype_double
3487     = build_function_type (double_type_node, double_endlink);
3488
3489   ldouble_ftype_ldouble
3490     = build_function_type (long_double_type_node,
3491                            tree_cons (NULL_TREE, long_double_type_node,
3492                                       endlink));
3493
3494   double_ftype_double_double
3495     = build_function_type (double_type_node,
3496                            tree_cons (NULL_TREE, double_type_node,
3497                                       double_endlink));
3498
3499   int_ftype_int
3500     = build_function_type (integer_type_node, int_endlink);
3501
3502   long_ftype_long
3503     = build_function_type (long_integer_type_node,
3504                            tree_cons (NULL_TREE, long_integer_type_node,
3505                                       endlink));
3506
3507   int_ftype_cptr_cptr_sizet
3508     = build_function_type (integer_type_node,
3509                            tree_cons (NULL_TREE, const_ptr_type_node,
3510                                       tree_cons (NULL_TREE, const_ptr_type_node,
3511                                                  tree_cons (NULL_TREE,
3512                                                             sizetype,
3513                                                             endlink))));
3514
3515   /* Prototype for strcpy.  */
3516   string_ftype_ptr_ptr
3517     = build_function_type (string_type_node,
3518                            tree_cons (NULL_TREE, string_type_node,
3519                                       tree_cons (NULL_TREE,
3520                                                  const_string_type_node,
3521                                                  endlink)));
3522
3523   traditional_len_type_node = (flag_traditional && ! cplus_mode
3524                                ? integer_type_node : sizetype);
3525   traditional_len_endlink = tree_cons (NULL_TREE, traditional_len_type_node,
3526                                        endlink);
3527
3528   /* Prototype for strcmp.  */
3529   int_ftype_string_string
3530     = build_function_type (integer_type_node,
3531                            tree_cons (NULL_TREE, const_string_type_node,
3532                                       tree_cons (NULL_TREE,
3533                                                  const_string_type_node,
3534                                                  endlink)));
3535
3536   /* Prototype for strlen.  */
3537   strlen_ftype
3538     = build_function_type (traditional_len_type_node,
3539                            tree_cons (NULL_TREE, const_string_type_node,
3540                                       endlink));
3541
3542   traditional_ptr_type_node = (flag_traditional && ! cplus_mode
3543                                ? string_type_node : ptr_type_node);
3544   traditional_cptr_type_node = (flag_traditional && ! cplus_mode
3545                                ? const_string_type_node : const_ptr_type_node);
3546
3547   /* Prototype for memcpy.  */
3548   memcpy_ftype
3549     = build_function_type (traditional_ptr_type_node,
3550                            tree_cons (NULL_TREE, ptr_type_node,
3551                                       tree_cons (NULL_TREE, const_ptr_type_node,
3552                                                  sizetype_endlink)));
3553
3554   /* Prototype for memset.  */
3555   memset_ftype
3556     = build_function_type (traditional_ptr_type_node,
3557                            tree_cons (NULL_TREE, ptr_type_node,
3558                                       tree_cons (NULL_TREE, integer_type_node,
3559                                                  tree_cons (NULL_TREE,
3560                                                             sizetype,
3561                                                             endlink))));
3562
3563   /* Prototype for bzero.  */
3564   bzero_ftype
3565     = build_function_type (void_type_node,
3566                            tree_cons (NULL_TREE, traditional_ptr_type_node,
3567                                       traditional_len_endlink));
3568
3569   /* Prototype for bcmp.  */
3570   bcmp_ftype
3571     = build_function_type (integer_type_node,
3572                            tree_cons (NULL_TREE, traditional_cptr_type_node,
3573                                       tree_cons (NULL_TREE,
3574                                                  traditional_cptr_type_node,
3575                                                  traditional_len_endlink)));
3576
3577   builtin_function ("__builtin_constant_p", default_function_type,
3578                     BUILT_IN_CONSTANT_P, BUILT_IN_NORMAL, NULL_PTR);
3579
3580   builtin_function ("__builtin_return_address", ptr_ftype_unsigned,
3581                     BUILT_IN_RETURN_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
3582
3583   builtin_function ("__builtin_frame_address", ptr_ftype_unsigned,
3584                     BUILT_IN_FRAME_ADDRESS, BUILT_IN_NORMAL, NULL_PTR);
3585
3586   builtin_function ("__builtin_alloca", ptr_ftype_sizetype,
3587                     BUILT_IN_ALLOCA, BUILT_IN_NORMAL, "alloca");
3588   builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS,
3589                     BUILT_IN_NORMAL, NULL_PTR);
3590   /* Define alloca, ffs as builtins.
3591      Declare _exit just to mark it as volatile.  */
3592   if (! no_builtins && ! no_nonansi_builtins)
3593     {
3594 #ifndef SMALL_STACK
3595       temp = builtin_function ("alloca", ptr_ftype_sizetype,
3596                                BUILT_IN_ALLOCA, BUILT_IN_NORMAL, NULL_PTR);
3597       /* Suppress error if redefined as a non-function.  */
3598       DECL_BUILT_IN_NONANSI (temp) = 1;
3599 #endif
3600       temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS,
3601                                BUILT_IN_NORMAL, NULL_PTR);
3602       /* Suppress error if redefined as a non-function.  */
3603       DECL_BUILT_IN_NONANSI (temp) = 1;
3604       temp = builtin_function ("_exit", void_ftype_int,
3605                                0, NOT_BUILT_IN, NULL_PTR);
3606       TREE_THIS_VOLATILE (temp) = 1;
3607       TREE_SIDE_EFFECTS (temp) = 1;
3608       /* Suppress error if redefined as a non-function.  */
3609       DECL_BUILT_IN_NONANSI (temp) = 1;
3610
3611       /* The system prototypes for these functions have many
3612          variations, so don't specify parameters to avoid conflicts.
3613          The expand_* functions check the argument types anyway.  */
3614       temp = builtin_function ("bzero", void_ftype_any,
3615                                BUILT_IN_BZERO, BUILT_IN_NORMAL, NULL_PTR);
3616       DECL_BUILT_IN_NONANSI (temp) = 1;
3617       temp = builtin_function ("bcmp", int_ftype_any,
3618                                BUILT_IN_BCMP, BUILT_IN_NORMAL, NULL_PTR);
3619       DECL_BUILT_IN_NONANSI (temp) = 1;
3620     }
3621
3622   builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS,
3623                     BUILT_IN_NORMAL, NULL_PTR);
3624   builtin_function ("__builtin_fabsf", float_ftype_float, BUILT_IN_FABS,
3625                     BUILT_IN_NORMAL, NULL_PTR);
3626   builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS,
3627                     BUILT_IN_NORMAL, NULL_PTR);
3628   builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3629                     BUILT_IN_NORMAL, NULL_PTR);
3630   builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS,
3631                     BUILT_IN_NORMAL, NULL_PTR);
3632   builtin_function ("__builtin_saveregs", ptr_ftype, BUILT_IN_SAVEREGS,
3633                     BUILT_IN_NORMAL, NULL_PTR);
3634   builtin_function ("__builtin_classify_type", default_function_type,
3635                     BUILT_IN_CLASSIFY_TYPE, BUILT_IN_NORMAL, NULL_PTR);
3636   builtin_function ("__builtin_next_arg", ptr_ftype, BUILT_IN_NEXT_ARG,
3637                     BUILT_IN_NORMAL, NULL_PTR);
3638   builtin_function ("__builtin_args_info", int_ftype_int, BUILT_IN_ARGS_INFO,
3639                     BUILT_IN_NORMAL, NULL_PTR);
3640   builtin_function ("__builtin_setjmp",
3641                     build_function_type (integer_type_node,
3642                                          tree_cons (NULL_TREE, ptr_type_node,
3643                                                     endlink)),
3644                     BUILT_IN_SETJMP, BUILT_IN_NORMAL, NULL_PTR);
3645   builtin_function ("__builtin_longjmp",
3646                     build_function_type (void_type_node,
3647                                          tree_cons (NULL_TREE, ptr_type_node,
3648                                                     tree_cons (NULL_TREE,
3649                                                                integer_type_node,
3650                                                                endlink))),
3651                     BUILT_IN_LONGJMP, BUILT_IN_NORMAL, NULL_PTR);
3652   builtin_function ("__builtin_trap", void_ftype, BUILT_IN_TRAP,
3653                     BUILT_IN_NORMAL, NULL_PTR);
3654
3655   /* ISO C99 IEEE Unordered compares.  */
3656   builtin_function ("__builtin_isgreater", default_function_type,
3657                     BUILT_IN_ISGREATER, BUILT_IN_NORMAL, NULL_PTR);
3658   builtin_function ("__builtin_isgreaterequal", default_function_type,
3659                     BUILT_IN_ISGREATEREQUAL, BUILT_IN_NORMAL, NULL_PTR);
3660   builtin_function ("__builtin_isless", default_function_type,
3661                     BUILT_IN_ISLESS, BUILT_IN_NORMAL, NULL_PTR);
3662   builtin_function ("__builtin_islessequal", default_function_type,
3663                     BUILT_IN_ISLESSEQUAL, BUILT_IN_NORMAL, NULL_PTR);
3664   builtin_function ("__builtin_islessgreater", default_function_type,
3665                     BUILT_IN_ISLESSGREATER, BUILT_IN_NORMAL, NULL_PTR);
3666   builtin_function ("__builtin_isunordered", default_function_type,
3667                     BUILT_IN_ISUNORDERED, BUILT_IN_NORMAL, NULL_PTR);
3668
3669   /* Untyped call and return.  */
3670   builtin_function ("__builtin_apply_args", ptr_ftype,
3671                     BUILT_IN_APPLY_ARGS, BUILT_IN_NORMAL, NULL_PTR);
3672
3673   temp = tree_cons (NULL_TREE,
3674                     build_pointer_type (build_function_type (void_type_node,
3675                                                              NULL_TREE)),
3676                     tree_cons (NULL_TREE,
3677                                ptr_type_node,
3678                                tree_cons (NULL_TREE,
3679                                           sizetype,
3680                                           endlink)));
3681   builtin_function ("__builtin_apply",
3682                     build_function_type (ptr_type_node, temp),
3683                     BUILT_IN_APPLY, BUILT_IN_NORMAL, NULL_PTR);
3684   builtin_function ("__builtin_return", void_ftype_ptr,
3685                     BUILT_IN_RETURN, BUILT_IN_NORMAL, NULL_PTR);
3686
3687   /* Support for varargs.h and stdarg.h.  */
3688   builtin_function ("__builtin_varargs_start",
3689                     build_function_type (void_type_node,
3690                                          tree_cons (NULL_TREE,
3691                                                     va_list_ref_type_node,
3692                                                     endlink)),
3693                     BUILT_IN_VARARGS_START, BUILT_IN_NORMAL, NULL_PTR);
3694
3695   builtin_function ("__builtin_stdarg_start",
3696                     build_function_type (void_type_node,
3697                                          tree_cons (NULL_TREE,
3698                                                     va_list_ref_type_node,
3699                                                     NULL_TREE)),
3700                     BUILT_IN_STDARG_START, BUILT_IN_NORMAL, NULL_PTR);
3701
3702   builtin_function ("__builtin_va_end",
3703                     build_function_type (void_type_node,
3704                                          tree_cons (NULL_TREE,
3705                                                     va_list_ref_type_node,
3706                                                     endlink)),
3707                     BUILT_IN_VA_END, BUILT_IN_NORMAL, NULL_PTR);
3708
3709   builtin_function ("__builtin_va_copy",
3710                     build_function_type (void_type_node,
3711                                          tree_cons (NULL_TREE,
3712                                                     va_list_ref_type_node,
3713                                                     tree_cons (NULL_TREE,
3714                                                       va_list_arg_type_node,
3715                                                       endlink))),
3716                     BUILT_IN_VA_COPY, BUILT_IN_NORMAL, NULL_PTR);
3717
3718   /* ??? Ought to be `T __builtin_expect(T, T)' for any type T.  */
3719   builtin_function ("__builtin_expect",
3720                     build_function_type (long_integer_type_node,
3721                                          tree_cons (NULL_TREE,
3722                                                     long_integer_type_node,
3723                                                     tree_cons (NULL_TREE,
3724                                                         long_integer_type_node,
3725                                                         endlink))),
3726                     BUILT_IN_EXPECT, BUILT_IN_NORMAL, NULL_PTR);
3727
3728   /* Currently under experimentation.  */
3729   builtin_function ("__builtin_memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
3730                     BUILT_IN_NORMAL, "memcpy");
3731   builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet,
3732                     BUILT_IN_MEMCMP, BUILT_IN_NORMAL, "memcmp");
3733   builtin_function ("__builtin_memset", memset_ftype,
3734                     BUILT_IN_MEMSET, BUILT_IN_NORMAL, "memset");
3735   builtin_function ("__builtin_bzero", bzero_ftype,
3736                     BUILT_IN_BZERO, BUILT_IN_NORMAL, "bzero");
3737   builtin_function ("__builtin_bcmp", bcmp_ftype,
3738                     BUILT_IN_BCMP, BUILT_IN_NORMAL, "bcmp");
3739   builtin_function ("__builtin_strcmp", int_ftype_string_string,
3740                     BUILT_IN_STRCMP, BUILT_IN_NORMAL, "strcmp");
3741   builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr,
3742                     BUILT_IN_STRCPY, BUILT_IN_NORMAL, "strcpy");
3743   builtin_function ("__builtin_strlen", strlen_ftype,
3744                     BUILT_IN_STRLEN, BUILT_IN_NORMAL, "strlen");
3745   builtin_function ("__builtin_sqrtf", float_ftype_float,
3746                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtf");
3747   builtin_function ("__builtin_fsqrt", double_ftype_double,
3748                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrt");
3749   builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,
3750                     BUILT_IN_FSQRT, BUILT_IN_NORMAL, "sqrtl");
3751   builtin_function ("__builtin_sinf", float_ftype_float,
3752                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinf");
3753   builtin_function ("__builtin_sin", double_ftype_double,
3754                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sin");
3755   builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,
3756                     BUILT_IN_SIN, BUILT_IN_NORMAL, "sinl");
3757   builtin_function ("__builtin_cosf", float_ftype_float,
3758                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosf");
3759   builtin_function ("__builtin_cos", double_ftype_double,
3760                     BUILT_IN_COS, BUILT_IN_NORMAL, "cos");
3761   builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,
3762                     BUILT_IN_COS, BUILT_IN_NORMAL, "cosl");
3763
3764   if (! no_builtins)
3765     {
3766       builtin_function ("abs", int_ftype_int, BUILT_IN_ABS,
3767                         BUILT_IN_NORMAL, NULL_PTR);
3768       builtin_function ("fabsf", float_ftype_float, BUILT_IN_FABS,
3769                         BUILT_IN_NORMAL, NULL_PTR);
3770       builtin_function ("fabs", double_ftype_double, BUILT_IN_FABS,
3771                         BUILT_IN_NORMAL, NULL_PTR);
3772       builtin_function ("fabsl", ldouble_ftype_ldouble, BUILT_IN_FABS,
3773                         BUILT_IN_NORMAL, NULL_PTR);
3774       builtin_function ("labs", long_ftype_long, BUILT_IN_LABS,
3775                         BUILT_IN_NORMAL, NULL_PTR);
3776       builtin_function ("memcpy", memcpy_ftype, BUILT_IN_MEMCPY,
3777                         BUILT_IN_NORMAL, NULL_PTR);
3778       builtin_function ("memcmp", int_ftype_cptr_cptr_sizet, BUILT_IN_MEMCMP,
3779                         BUILT_IN_NORMAL, NULL_PTR);
3780       builtin_function ("memset", memset_ftype, BUILT_IN_MEMSET,
3781                         BUILT_IN_NORMAL, NULL_PTR);
3782       builtin_function ("strcmp", int_ftype_string_string, BUILT_IN_STRCMP,
3783                         BUILT_IN_NORMAL, NULL_PTR);
3784       builtin_function ("strcpy", string_ftype_ptr_ptr, BUILT_IN_STRCPY,
3785                         BUILT_IN_NORMAL, NULL_PTR);
3786       builtin_function ("strlen", strlen_ftype, BUILT_IN_STRLEN,
3787                         BUILT_IN_NORMAL, NULL_PTR);
3788       builtin_function ("sqrtf", float_ftype_float, BUILT_IN_FSQRT,
3789                         BUILT_IN_NORMAL, NULL_PTR);
3790       builtin_function ("sqrt", double_ftype_double, BUILT_IN_FSQRT,
3791                         BUILT_IN_NORMAL, NULL_PTR);
3792       builtin_function ("sqrtl", ldouble_ftype_ldouble, BUILT_IN_FSQRT,
3793                         BUILT_IN_NORMAL, NULL_PTR);
3794       builtin_function ("sinf", float_ftype_float, BUILT_IN_SIN,
3795                         BUILT_IN_NORMAL, NULL_PTR);
3796       builtin_function ("sin", double_ftype_double, BUILT_IN_SIN,
3797                         BUILT_IN_NORMAL, NULL_PTR);
3798       builtin_function ("sinl", ldouble_ftype_ldouble, BUILT_IN_SIN,
3799                         BUILT_IN_NORMAL, NULL_PTR);
3800       builtin_function ("cosf", float_ftype_float, BUILT_IN_COS,
3801                         BUILT_IN_NORMAL, NULL_PTR);
3802       builtin_function ("cos", double_ftype_double, BUILT_IN_COS,
3803                         BUILT_IN_NORMAL, NULL_PTR);
3804       builtin_function ("cosl", ldouble_ftype_ldouble, BUILT_IN_COS,
3805                         BUILT_IN_NORMAL, NULL_PTR);
3806
3807       /* Declare these functions volatile
3808          to avoid spurious "control drops through" warnings.  */
3809       temp = builtin_function ("abort", cplus_mode ? void_ftype : void_ftype_any,
3810                                0, NOT_BUILT_IN, NULL_PTR);
3811       TREE_THIS_VOLATILE (temp) = 1;
3812       TREE_SIDE_EFFECTS (temp) = 1;
3813
3814 #if 0 /* ??? The C++ frontend used to do this.  */
3815       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
3816          them...  */
3817       DECL_BUILT_IN_NONANSI (temp) = 1;
3818 #endif
3819       temp = builtin_function ("exit",
3820                                cplus_mode ? void_ftype_int : void_ftype_any,
3821                                0, NOT_BUILT_IN, NULL_PTR);
3822       TREE_THIS_VOLATILE (temp) = 1;
3823       TREE_SIDE_EFFECTS (temp) = 1;
3824
3825 #if 0 /* ??? The C++ frontend used to do this.  */
3826       /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
3827          them...  */
3828       DECL_BUILT_IN_NONANSI (temp) = 1;
3829 #endif
3830     }
3831
3832 #if 0
3833   /* Support for these has not been written in either expand_builtin
3834      or build_function_call.  */
3835   builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV,
3836                     BUILT_IN_NORMAL, NULL_PTR);
3837   builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV,
3838                     BUILT_IN_NORMAL, NULL_PTR);
3839   builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR,
3840                     BUILT_IN_NORMAL, NULL_PTR);
3841   builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL,
3842                     BUILT_IN_NORMAL, NULL_PTR);
3843   builtin_function ("__builtin_fmod", double_ftype_double_double,
3844                     BUILT_IN_FMOD, BUILT_IN_NORMAL, NULL_PTR);
3845   builtin_function ("__builtin_frem", double_ftype_double_double,
3846                     BUILT_IN_FREM, BUILT_IN_NORMAL, NULL_PTR);
3847   builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP,
3848                     BUILT_IN_NORMAL, NULL_PTR);
3849   builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN,
3850                     BUILT_IN_NORMAL, NULL_PTR);
3851 #endif
3852
3853   /* ??? Perhaps there's a better place to do this.  But it is related
3854      to __builtin_va_arg, so it isn't that off-the-wall.  */
3855   lang_type_promotes_to = simple_type_promotes_to;
3856 }
3857
3858 tree
3859 build_va_arg (expr, type)
3860      tree expr, type;
3861 {
3862   return build1 (VA_ARG_EXPR, type, expr);
3863 }
3864 \f
3865 /* Given a type, apply default promotions wrt unnamed function arguments
3866    and return the new type.  Return NULL_TREE if no change.  */
3867 /* ??? There is a function of the same name in the C++ front end that
3868    does something similar, but is more thorough and does not return NULL
3869    if no change.  We could perhaps share code, but it would make the
3870    self_promoting_type property harder to identify.  */
3871
3872 tree
3873 simple_type_promotes_to (type)
3874      tree type;
3875 {
3876   if (TYPE_MAIN_VARIANT (type) == float_type_node)
3877     return double_type_node;
3878
3879   if (C_PROMOTING_INTEGER_TYPE_P (type))
3880     {
3881       /* Traditionally, unsignedness is preserved in default promotions.
3882          Also preserve unsignedness if not really getting any wider.  */
3883       if (TREE_UNSIGNED (type)
3884           && (flag_traditional
3885               || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3886         return unsigned_type_node;
3887       return integer_type_node;
3888     }
3889
3890   return NULL_TREE;
3891 }
3892
3893 /* Return 1 if PARMS specifies a fixed number of parameters
3894    and none of their types is affected by default promotions.  */
3895
3896 int
3897 self_promoting_args_p (parms)
3898      tree parms;
3899 {
3900   register tree t;
3901   for (t = parms; t; t = TREE_CHAIN (t))
3902     {
3903       register tree type = TREE_VALUE (t);
3904
3905       if (TREE_CHAIN (t) == 0 && type != void_type_node)
3906         return 0;
3907
3908       if (type == 0)
3909         return 0;
3910
3911       if (TYPE_MAIN_VARIANT (type) == float_type_node)
3912         return 0;
3913
3914       if (C_PROMOTING_INTEGER_TYPE_P (type))
3915         return 0;
3916     }
3917   return 1;
3918 }
3919
3920 /* Recognize certain built-in functions so we can make tree-codes
3921    other than CALL_EXPR.  We do this when it enables fold-const.c
3922    to do something useful.  */
3923 /* ??? By rights this should go in builtins.c, but only C and C++
3924    implement build_{binary,unary}_op.  Not exactly sure what bits
3925    of functionality are actually needed from those functions, or
3926    where the similar functionality exists in the other front ends.  */
3927
3928 tree
3929 expand_tree_builtin (function, params, coerced_params)
3930      tree function, params, coerced_params;
3931 {
3932   enum tree_code code;
3933
3934   if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3935     return NULL_TREE;
3936
3937   switch (DECL_FUNCTION_CODE (function))
3938     {
3939     case BUILT_IN_ABS:
3940     case BUILT_IN_LABS:
3941     case BUILT_IN_FABS:
3942       if (coerced_params == 0)
3943         return integer_zero_node;
3944       return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3945
3946     case BUILT_IN_ISGREATER:
3947       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3948         code = UNLE_EXPR;
3949       else
3950         code = LE_EXPR;
3951       goto unordered_cmp;
3952
3953     case BUILT_IN_ISGREATEREQUAL:
3954       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3955         code = UNLT_EXPR;
3956       else
3957         code = LT_EXPR;
3958       goto unordered_cmp;
3959
3960     case BUILT_IN_ISLESS:
3961       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3962         code = UNGE_EXPR;
3963       else
3964         code = GE_EXPR;
3965       goto unordered_cmp;
3966
3967     case BUILT_IN_ISLESSEQUAL:
3968       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3969         code = UNGT_EXPR;
3970       else
3971         code = GT_EXPR;
3972       goto unordered_cmp;
3973
3974     case BUILT_IN_ISLESSGREATER:
3975       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3976         code = UNEQ_EXPR;
3977       else
3978         code = EQ_EXPR;
3979       goto unordered_cmp;
3980
3981     case BUILT_IN_ISUNORDERED:
3982       if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3983         return integer_zero_node;
3984       code = UNORDERED_EXPR;
3985       goto unordered_cmp;
3986
3987     unordered_cmp:
3988       {
3989         tree arg0, arg1;
3990
3991         if (params == 0
3992             || TREE_CHAIN (params) == 0)
3993           {
3994             error ("too few arguments to function `%s'",
3995                    IDENTIFIER_POINTER (DECL_NAME (function)));
3996             return error_mark_node;
3997           }
3998         else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3999           {
4000             error ("too many arguments to function `%s'",
4001                    IDENTIFIER_POINTER (DECL_NAME (function)));
4002             return error_mark_node;
4003           }
4004
4005         arg0 = TREE_VALUE (params);
4006         arg1 = TREE_VALUE (TREE_CHAIN (params));
4007         arg0 = build_binary_op (code, arg0, arg1, 0);
4008         if (code != UNORDERED_EXPR)
4009           arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
4010         return arg0;
4011       }
4012       break;
4013
4014     default:
4015       break;
4016     }
4017
4018   return NULL_TREE;
4019 }
4020
4021 /* Tree code classes. */
4022
4023 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
4024
4025 static char c_tree_code_type[] = {
4026   'x',
4027 #include "c-common.def"
4028 };
4029 #undef DEFTREECODE
4030
4031 /* Table indexed by tree code giving number of expression
4032    operands beyond the fixed part of the node structure.
4033    Not used for types or decls.  */
4034
4035 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
4036
4037 static int c_tree_code_length[] = {
4038   0,
4039 #include "c-common.def"
4040 };
4041 #undef DEFTREECODE
4042
4043 /* Names of tree components.
4044    Used for printing out the tree and error messages.  */
4045 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
4046
4047 static const char *c_tree_code_name[] = {
4048   "@@dummy",
4049 #include "c-common.def"
4050 };
4051 #undef DEFTREECODE
4052
4053 /* Adds the tree codes specific to the C front end to the list of all
4054    tree codes. */
4055
4056 void
4057 add_c_tree_codes ()
4058 {
4059   memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
4060           c_tree_code_type,
4061           (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
4062   memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
4063           c_tree_code_length,
4064           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
4065   memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
4066           c_tree_code_name,
4067           (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
4068 }