gcc/c-common.c

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