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