gcc/c-common.c

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