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