gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include <stdio.h>
  23 #include "tree.h"
  24 #include "c-lex.h"
  25 #include "c-tree.h"
  26 #include "flags.h"
  27 #include "obstack.h"
  28 #include <ctype.h>
  29
  30 #ifdef HAVE_STRING_H
  31 #include <string.h>
  32 #else
  33 #ifdef HAVE_STRINGS_H
  34 #include <strings.h>
  35 #endif
  36 #endif
  37
  38 #ifdef HAVE_STDLIB_H
  39 #include <stdlib.h>
  40 #endif
  41
  42
  43 #ifndef WCHAR_TYPE_SIZE
  44 #ifdef INT_TYPE_SIZE
  45 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  46 #else
  47 #define WCHAR_TYPE_SIZE BITS_PER_WORD
  48 #endif
  49 #endif
  50
  51 extern struct obstack permanent_obstack;
  52
  53 /* Nonzero means the expression being parsed will never be evaluated.
  54    This is a count, since unevaluated expressions can nest.  */
  55 int skip_evaluation;
  56
  57 enum attrs {A_PACKED, A_NOCOMMON, A_COMMON, A_NORETURN, A_CONST, A_T_UNION,
  58             A_CONSTRUCTOR, A_DESTRUCTOR, A_MODE, A_SECTION, A_ALIGNED,
  59             A_UNUSED, A_FORMAT, A_FORMAT_ARG, A_WEAK, A_ALIAS};
  60
  61 static void declare_hidden_char_array   PROTO((char *, char *));
  62 static void add_attribute               PROTO((enum attrs, char *,
  63                                                int, int, int));
  64 static void init_attributes             PROTO((void));
  65 static void record_international_format PROTO((tree, tree, int));
  66
  67 /* Keep a stack of if statements.  We record the number of compound
  68    statements seen up to the if keyword, as well as the line number
  69    and file of the if.  If a potentially ambiguous else is seen, that
  70    fact is recorded; the warning is issued when we can be sure that
  71    the enclosing if statement does not have an else branch.  */
  72 typedef struct
  73 {
  74   int compstmt_count;
  75   int line;
  76   char *file;
  77   int needs_warning;
  78 } if_elt;
  79
  80 static if_elt *if_stack;
  81
  82 /* Amount of space in the if statement stack.  */
  83 static int if_stack_space = 0;
  84
  85 /* Stack pointer.  */
  86 static int if_stack_pointer = 0;
  87
  88 /* Generate RTL for the start of an if-then, and record the start of it
  89    for ambiguous else detection.  */
  90
  91 void
  92 c_expand_start_cond (cond, exitflag, compstmt_count)
  93      tree cond;
  94      int exitflag;
  95      int compstmt_count;
  96 {
  97   /* Make sure there is enough space on the stack.  */
  98   if (if_stack_space == 0)
  99     {
 100       if_stack_space = 10;
 101       if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
 102     }
 103   else if (if_stack_space == if_stack_pointer)
 104     {
 105       if_stack_space += 10;
 106       if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
 107     }
 108
 109   /* Record this if statement.  */
 110   if_stack[if_stack_pointer].compstmt_count = compstmt_count;
 111   if_stack[if_stack_pointer].file = input_filename;
 112   if_stack[if_stack_pointer].line = lineno;
 113   if_stack[if_stack_pointer].needs_warning = 0;
 114   if_stack_pointer++;
 115
 116   expand_start_cond (cond, exitflag);
 117 }
 118
 119 /* Generate RTL for the end of an if-then.  Optionally warn if a nested
 120    if statement had an ambiguous else clause.  */
 121
 122 void
 123 c_expand_end_cond ()
 124 {
 125   if_stack_pointer--;
 126   if (if_stack[if_stack_pointer].needs_warning)
 127     warning_with_file_and_line (if_stack[if_stack_pointer].file,
 128                                 if_stack[if_stack_pointer].line,
 129                                 "suggest explicit braces to avoid ambiguous `else'");
 130   expand_end_cond ();
 131 }
 132
 133 /* Generate RTL between the then-clause and the else-clause
 134    of an if-then-else.  */
 135
 136 void
 137 c_expand_start_else ()
 138 {
 139   /* An ambiguous else warning must be generated for the enclosing if
 140      statement, unless we see an else branch for that one, too.  */
 141   if (warn_parentheses
 142       && if_stack_pointer > 1
 143       && (if_stack[if_stack_pointer - 1].compstmt_count
 144           == if_stack[if_stack_pointer - 2].compstmt_count))
 145     if_stack[if_stack_pointer - 2].needs_warning = 1;
 146
 147   /* Even if a nested if statement had an else branch, it can't be
 148      ambiguous if this one also has an else.  So don't warn in that
 149      case.  Also don't warn for any if statements nested in this else.  */
 150   if_stack[if_stack_pointer - 1].needs_warning = 0;
 151   if_stack[if_stack_pointer - 1].compstmt_count--;
 152
 153   expand_start_else ();
 154 }
 155
 156 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
 157
 158 void
 159 declare_function_name ()
 160 {
 161   char *name, *printable_name;
 162
 163   if (current_function_decl == NULL)
 164     {
 165       name = "";
 166       printable_name = "top level";
 167     }
 168   else
 169     {
 170       /* Allow functions to be nameless (such as artificial ones).  */
 171       if (DECL_NAME (current_function_decl))
 172         name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
 173       else
 174         name = "";
 175       printable_name = (*decl_printable_name) (current_function_decl, 2);
 176     }
 177
 178   declare_hidden_char_array ("__FUNCTION__", name);
 179   declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name);
 180 }
 181
 182 static void
 183 declare_hidden_char_array (name, value)
 184      char *name, *value;
 185 {
 186   tree decl, type, init;
 187   int vlen;
 188
 189   /* If the default size of char arrays isn't big enough for the name,
 190      or if we want to give warnings for large objects, make a bigger one.  */
 191   vlen = strlen (value) + 1;
 192   type = char_array_type_node;
 193   if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type))) < vlen
 194       || warn_larger_than)
 195     type = build_array_type (char_type_node,
 196                              build_index_type (build_int_2 (vlen, 0)));
 197   push_obstacks_nochange ();
 198   decl = build_decl (VAR_DECL, get_identifier (name), type);
 199   TREE_STATIC (decl) = 1;
 200   TREE_READONLY (decl) = 1;
 201   TREE_ASM_WRITTEN (decl) = 1;
 202   DECL_SOURCE_LINE (decl) = 0;
 203   DECL_ARTIFICIAL (decl) = 1;
 204   DECL_IN_SYSTEM_HEADER (decl) = 1;
 205   DECL_IGNORED_P (decl) = 1;
 206   init = build_string (vlen, value);
 207   TREE_TYPE (init) = type;
 208   DECL_INITIAL (decl) = init;
 209   finish_decl (pushdecl (decl), init, NULL_TREE);
 210 }
 211
 212 /* Given a chain of STRING_CST nodes,
 213    concatenate them into one STRING_CST
 214    and give it a suitable array-of-chars data type.  */
 215
 216 tree
 217 combine_strings (strings)
 218      tree strings;
 219 {
 220   register tree value, t;
 221   register int length = 1;
 222   int wide_length = 0;
 223   int wide_flag = 0;
 224   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
 225   int nchars;
 226
 227   if (TREE_CHAIN (strings))
 228     {
 229       /* More than one in the chain, so concatenate.  */
 230       register char *p, *q;
 231
 232       /* Don't include the \0 at the end of each substring,
 233          except for the last one.
 234          Count wide strings and ordinary strings separately.  */
 235       for (t = strings; t; t = TREE_CHAIN (t))
 236         {
 237           if (TREE_TYPE (t) == wchar_array_type_node)
 238             {
 239               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
 240               wide_flag = 1;
 241             }
 242           else
 243             length += (TREE_STRING_LENGTH (t) - 1);
 244         }
 245
 246       /* If anything is wide, the non-wides will be converted,
 247          which makes them take more space.  */
 248       if (wide_flag)
 249         length = length * wchar_bytes + wide_length;
 250
 251       p = savealloc (length);
 252
 253       /* Copy the individual strings into the new combined string.
 254          If the combined string is wide, convert the chars to ints
 255          for any individual strings that are not wide.  */
 256
 257       q = p;
 258       for (t = strings; t; t = TREE_CHAIN (t))
 259         {
 260           int len = (TREE_STRING_LENGTH (t)
 261                      - ((TREE_TYPE (t) == wchar_array_type_node)
 262                         ? wchar_bytes : 1));
 263           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
 264             {
 265               bcopy (TREE_STRING_POINTER (t), q, len);
 266               q += len;
 267             }
 268           else
 269             {
 270               int i;
 271               for (i = 0; i < len; i++)
 272                 {
 273                   if (WCHAR_TYPE_SIZE == HOST_BITS_PER_SHORT)
 274                     ((short *) q)[i] = TREE_STRING_POINTER (t)[i];
 275                   else
 276                     ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
 277                 }
 278               q += len * wchar_bytes;
 279             }
 280         }
 281       if (wide_flag)
 282         {
 283           int i;
 284           for (i = 0; i < wchar_bytes; i++)
 285             *q++ = 0;
 286         }
 287       else
 288         *q = 0;
 289
 290       value = make_node (STRING_CST);
 291       TREE_STRING_POINTER (value) = p;
 292       TREE_STRING_LENGTH (value) = length;
 293       TREE_CONSTANT (value) = 1;
 294     }
 295   else
 296     {
 297       value = strings;
 298       length = TREE_STRING_LENGTH (value);
 299       if (TREE_TYPE (value) == wchar_array_type_node)
 300         wide_flag = 1;
 301     }
 302
 303   /* Compute the number of elements, for the array type.  */
 304   nchars = wide_flag ? length / wchar_bytes : length;
 305
 306   /* Create the array type for the string constant.
 307      -Wwrite-strings says make the string constant an array of const char
 308      so that copying it to a non-const pointer will get a warning.  */
 309   if (warn_write_strings
 310       && (! flag_traditional  && ! flag_writable_strings))
 311     {
 312       tree elements
 313         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 314                               1, 0);
 315       TREE_TYPE (value)
 316         = build_array_type (elements,
 317                             build_index_type (build_int_2 (nchars - 1, 0)));
 318     }
 319   else
 320     TREE_TYPE (value)
 321       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 322                           build_index_type (build_int_2 (nchars - 1, 0)));
 323   TREE_CONSTANT (value) = 1;
 324   TREE_STATIC (value) = 1;
 325   return value;
 326 }
 327 \f
 328 /* To speed up processing of attributes, we maintain an array of
 329    IDENTIFIER_NODES and the corresponding attribute types.  */
 330
 331 /* Array to hold attribute information.  */
 332
 333 static struct {enum attrs id; tree name; int min, max, decl_req;} attrtab[50];
 334
 335 static int attrtab_idx = 0;
 336
 337 /* Add an entry to the attribute table above.  */
 338
 339 static void
 340 add_attribute (id, string, min_len, max_len, decl_req)
 341      enum attrs id;
 342      char *string;
 343      int min_len, max_len;
 344      int decl_req;
 345 {
 346   char buf[100];
 347
 348   attrtab[attrtab_idx].id = id;
 349   attrtab[attrtab_idx].name = get_identifier (string);
 350   attrtab[attrtab_idx].min = min_len;
 351   attrtab[attrtab_idx].max = max_len;
 352   attrtab[attrtab_idx++].decl_req = decl_req;
 353
 354   sprintf (buf, "__%s__", string);
 355
 356   attrtab[attrtab_idx].id = id;
 357   attrtab[attrtab_idx].name = get_identifier (buf);
 358   attrtab[attrtab_idx].min = min_len;
 359   attrtab[attrtab_idx].max = max_len;
 360   attrtab[attrtab_idx++].decl_req = decl_req;
 361 }
 362
 363 /* Initialize attribute table.  */
 364
 365 static void
 366 init_attributes ()
 367 {
 368   add_attribute (A_PACKED, "packed", 0, 0, 0);
 369   add_attribute (A_NOCOMMON, "nocommon", 0, 0, 1);
 370   add_attribute (A_COMMON, "common", 0, 0, 1);
 371   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
 372   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
 373   add_attribute (A_UNUSED, "unused", 0, 0, 0);
 374   add_attribute (A_CONST, "const", 0, 0, 1);
 375   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
 376   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
 377   add_attribute (A_DESTRUCTOR, "destructor", 0, 0, 1);
 378   add_attribute (A_MODE, "mode", 1, 1, 1);
 379   add_attribute (A_SECTION, "section", 1, 1, 1);
 380   add_attribute (A_ALIGNED, "aligned", 0, 1, 0);
 381   add_attribute (A_FORMAT, "format", 3, 3, 1);
 382   add_attribute (A_FORMAT_ARG, "format_arg", 1, 1, 1);
 383   add_attribute (A_WEAK, "weak", 0, 0, 1);
 384   add_attribute (A_ALIAS, "alias", 1, 1, 1);
 385 }
 386 \f
 387 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
 388    and install them in NODE, which is either a DECL (including a TYPE_DECL)
 389    or a TYPE.  PREFIX_ATTRIBUTES can appear after the declaration specifiers
 390    and declaration modifiers but before the declaration proper.  */
 391
 392 void
 393 decl_attributes (node, attributes, prefix_attributes)
 394      tree node, attributes, prefix_attributes;
 395 {
 396   tree decl = 0, type;
 397   int is_type;
 398   tree a;
 399
 400   if (attrtab_idx == 0)
 401     init_attributes ();
 402
 403   if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd')
 404     {
 405       decl = node;
 406       type = TREE_TYPE (decl);
 407       is_type = TREE_CODE (node) == TYPE_DECL;
 408     }
 409   else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't')
 410     type = node, is_type = 1;
 411
 412   attributes = chainon (prefix_attributes, attributes);
 413
 414   for (a = attributes; a; a = TREE_CHAIN (a))
 415     {
 416       tree name = TREE_PURPOSE (a);
 417       tree args = TREE_VALUE (a);
 418       int i;
 419       enum attrs id;
 420
 421       for (i = 0; i < attrtab_idx; i++)
 422         if (attrtab[i].name == name)
 423           break;
 424
 425       if (i == attrtab_idx)
 426         {
 427           if (! valid_machine_attribute (name, args, decl, type))
 428             warning ("`%s' attribute directive ignored",
 429                      IDENTIFIER_POINTER (name));
 430           else if (decl != 0)
 431             type = TREE_TYPE (decl);
 432           continue;
 433         }
 434       else if (attrtab[i].decl_req && decl == 0)
 435         {
 436           warning ("`%s' attribute does not apply to types",
 437                    IDENTIFIER_POINTER (name));
 438           continue;
 439         }
 440       else if (list_length (args) < attrtab[i].min
 441                || list_length (args) > attrtab[i].max)
 442         {
 443           error ("wrong number of arguments specified for `%s' attribute",
 444                  IDENTIFIER_POINTER (name));
 445           continue;
 446         }
 447
 448       id = attrtab[i].id;
 449       switch (id)
 450         {
 451         case A_PACKED:
 452           if (is_type)
 453             TYPE_PACKED (type) = 1;
 454           else if (TREE_CODE (decl) == FIELD_DECL)
 455             DECL_PACKED (decl) = 1;
 456           /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
 457              used for DECL_REGISTER.  It wouldn't mean anything anyway.  */
 458           else
 459             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 460           break;
 461
 462         case A_NOCOMMON:
 463           if (TREE_CODE (decl) == VAR_DECL)
 464             DECL_COMMON (decl) = 0;
 465           else
 466             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 467           break;
 468
 469         case A_COMMON:
 470           if (TREE_CODE (decl) == VAR_DECL)
 471             DECL_COMMON (decl) = 1;
 472           else
 473             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 474           break;
 475
 476         case A_NORETURN:
 477           if (TREE_CODE (decl) == FUNCTION_DECL)
 478             TREE_THIS_VOLATILE (decl) = 1;
 479           else if (TREE_CODE (type) == POINTER_TYPE
 480                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 481             TREE_TYPE (decl) = type
 482               = build_pointer_type
 483                 (build_type_variant (TREE_TYPE (type),
 484                                      TREE_READONLY (TREE_TYPE (type)), 1));
 485           else
 486             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 487           break;
 488
 489         case A_UNUSED:
 490           if (is_type)
 491             TREE_USED (type) = 1;
 492           else if (TREE_CODE (decl) == PARM_DECL
 493                    || TREE_CODE (decl) == VAR_DECL
 494                    || TREE_CODE (decl) == FUNCTION_DECL)
 495             TREE_USED (decl) = 1;
 496           else
 497             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 498           break;
 499
 500         case A_CONST:
 501           if (TREE_CODE (decl) == FUNCTION_DECL)
 502             TREE_READONLY (decl) = 1;
 503           else if (TREE_CODE (type) == POINTER_TYPE
 504                    && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
 505             TREE_TYPE (decl) = type
 506               = build_pointer_type
 507                 (build_type_variant (TREE_TYPE (type), 1,
 508                                      TREE_THIS_VOLATILE (TREE_TYPE (type))));
 509           else
 510             warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name));
 511           break;
 512
 513         case A_T_UNION:
 514           if (is_type
 515               && TREE_CODE (type) == UNION_TYPE
 516               && (decl == 0
 517                   || (TYPE_FIELDS (type) != 0
 518                       && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))))
 519             TYPE_TRANSPARENT_UNION (type) = 1;
 520           else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
 521                    && TREE_CODE (type) == UNION_TYPE
 522                    && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type)))
 523             DECL_TRANSPARENT_UNION (decl) = 1;
 524           else
 525             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 526           break;
 527
 528         case A_CONSTRUCTOR:
 529           if (TREE_CODE (decl) == FUNCTION_DECL
 530               && TREE_CODE (type) == FUNCTION_TYPE
 531               && decl_function_context (decl) == 0)
 532             {
 533               DECL_STATIC_CONSTRUCTOR (decl) = 1;
 534               TREE_USED (decl) = 1;
 535             }
 536           else
 537             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 538           break;
 539
 540         case A_DESTRUCTOR:
 541           if (TREE_CODE (decl) == FUNCTION_DECL
 542               && TREE_CODE (type) == FUNCTION_TYPE
 543               && decl_function_context (decl) == 0)
 544             {
 545               DECL_STATIC_DESTRUCTOR (decl) = 1;
 546               TREE_USED (decl) = 1;
 547             }
 548           else
 549             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 550           break;
 551
 552         case A_MODE:
 553           if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
 554             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 555           else
 556             {
 557               int j;
 558               char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
 559               int len = strlen (p);
 560               enum machine_mode mode = VOIDmode;
 561               tree typefm;
 562
 563               if (len > 4 && p[0] == '_' && p[1] == '_'
 564                   && p[len - 1] == '_' && p[len - 2] == '_')
 565                 {
 566                   char *newp = (char *) alloca (len - 1);
 567
 568                   strcpy (newp, &p[2]);
 569                   newp[len - 4] = '\0';
 570                   p = newp;
 571                 }
 572
 573               /* Give this decl a type with the specified mode.
 574                  First check for the special modes.  */
 575               if (! strcmp (p, "byte"))
 576                 mode = byte_mode;
 577               else if (!strcmp (p, "word"))
 578                 mode = word_mode;
 579               else if (! strcmp (p, "pointer"))
 580                 mode = ptr_mode;
 581               else
 582                 for (j = 0; j < NUM_MACHINE_MODES; j++)
 583                   if (!strcmp (p, GET_MODE_NAME (j)))
 584                     mode = (enum machine_mode) j;
 585
 586               if (mode == VOIDmode)
 587                 error ("unknown machine mode `%s'", p);
 588               else if (0 == (typefm = type_for_mode (mode,
 589                                                      TREE_UNSIGNED (type))))
 590                 error ("no data type for mode `%s'", p);
 591               else
 592                 {
 593                   TREE_TYPE (decl) = type = typefm;
 594                   DECL_SIZE (decl) = 0;
 595                   layout_decl (decl, 0);
 596                 }
 597             }
 598           break;
 599
 600         case A_SECTION:
 601 #ifdef ASM_OUTPUT_SECTION_NAME
 602           if ((TREE_CODE (decl) == FUNCTION_DECL
 603                || TREE_CODE (decl) == VAR_DECL)
 604               && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
 605             {
 606               if (TREE_CODE (decl) == VAR_DECL
 607                   && current_function_decl != NULL_TREE
 608                   && ! TREE_STATIC (decl))
 609                 error_with_decl (decl,
 610                   "section attribute cannot be specified for local variables");
 611               /* The decl may have already been given a section attribute from
 612                  a previous declaration.  Ensure they match.  */
 613               else if (DECL_SECTION_NAME (decl) != NULL_TREE
 614                        && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
 615                                   TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
 616                 error_with_decl (node,
 617                                  "section of `%s' conflicts with previous declaration");
 618               else
 619                 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
 620             }
 621           else
 622             error_with_decl (node,
 623                            "section attribute not allowed for `%s'");
 624 #else
 625           error_with_decl (node,
 626                   "section attributes are not supported for this target");
 627 #endif
 628           break;
 629
 630         case A_ALIGNED:
 631           {
 632             tree align_expr
 633               = (args ? TREE_VALUE (args)
 634                  : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 635             int align;
 636
 637             /* Strip any NOPs of any kind.  */
 638             while (TREE_CODE (align_expr) == NOP_EXPR
 639                    || TREE_CODE (align_expr) == CONVERT_EXPR
 640                    || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
 641               align_expr = TREE_OPERAND (align_expr, 0);
 642
 643             if (TREE_CODE (align_expr) != INTEGER_CST)
 644               {
 645                 error ("requested alignment is not a constant");
 646                 continue;
 647               }
 648
 649             align = TREE_INT_CST_LOW (align_expr) * BITS_PER_UNIT;
 650
 651             if (exact_log2 (align) == -1)
 652               error ("requested alignment is not a power of 2");
 653             else if (is_type)
 654               TYPE_ALIGN (type) = align;
 655             else if (TREE_CODE (decl) != VAR_DECL
 656                      && TREE_CODE (decl) != FIELD_DECL)
 657               error_with_decl (decl,
 658                                "alignment may not be specified for `%s'");
 659             else
 660               DECL_ALIGN (decl) = align;
 661           }
 662           break;
 663
 664         case A_FORMAT:
 665           {
 666             tree format_type = TREE_VALUE (args);
 667             tree format_num_expr = TREE_VALUE (TREE_CHAIN (args));
 668             tree first_arg_num_expr
 669               = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
 670             int format_num;
 671             int first_arg_num;
 672             int is_scan;
 673             tree argument;
 674             int arg_num;
 675
 676             if (TREE_CODE (decl) != FUNCTION_DECL)
 677               {
 678                 error_with_decl (decl,
 679                          "argument format specified for non-function `%s'");
 680                 continue;
 681               }
 682
 683             if (TREE_CODE (format_type) == IDENTIFIER_NODE
 684                 && (!strcmp (IDENTIFIER_POINTER (format_type), "printf")
 685                     || !strcmp (IDENTIFIER_POINTER (format_type),
 686                                 "__printf__")))
 687               is_scan = 0;
 688             else if (TREE_CODE (format_type) == IDENTIFIER_NODE
 689                      && (!strcmp (IDENTIFIER_POINTER (format_type), "scanf")
 690                          || !strcmp (IDENTIFIER_POINTER (format_type),
 691                                      "__scanf__")))
 692               is_scan = 1;
 693             else if (TREE_CODE (format_type) == IDENTIFIER_NODE)
 694               {
 695                 warning ("`%s' is an unrecognized format function type",
 696                          IDENTIFIER_POINTER (format_type));
 697                 continue;
 698               }
 699             else
 700               {
 701                 error ("unrecognized format specifier");
 702                 continue;
 703               }
 704
 705             /* Strip any conversions from the string index and first arg number
 706                and verify they are constants.  */
 707             while (TREE_CODE (format_num_expr) == NOP_EXPR
 708                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 709                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 710               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 711
 712             while (TREE_CODE (first_arg_num_expr) == NOP_EXPR
 713                    || TREE_CODE (first_arg_num_expr) == CONVERT_EXPR
 714                    || TREE_CODE (first_arg_num_expr) == NON_LVALUE_EXPR)
 715               first_arg_num_expr = TREE_OPERAND (first_arg_num_expr, 0);
 716
 717             if (TREE_CODE (format_num_expr) != INTEGER_CST
 718                 || TREE_CODE (first_arg_num_expr) != INTEGER_CST)
 719               {
 720                 error ("format string has non-constant operand number");
 721                 continue;
 722               }
 723
 724             format_num = TREE_INT_CST_LOW (format_num_expr);
 725             first_arg_num = TREE_INT_CST_LOW (first_arg_num_expr);
 726             if (first_arg_num != 0 && first_arg_num <= format_num)
 727               {
 728                 error ("format string arg follows the args to be formatted");
 729                 continue;
 730               }
 731
 732             /* If a parameter list is specified, verify that the format_num
 733                argument is actually a string, in case the format attribute
 734                is in error.  */
 735             argument = TYPE_ARG_TYPES (type);
 736             if (argument)
 737               {
 738                 for (arg_num = 1; ; ++arg_num)
 739                   {
 740                     if (argument == 0 || arg_num == format_num)
 741                       break;
 742                     argument = TREE_CHAIN (argument);
 743                   }
 744                 if (! argument
 745                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 746                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 747                       != char_type_node))
 748                   {
 749                     error ("format string arg not a string type");
 750                     continue;
 751                   }
 752                 if (first_arg_num != 0)
 753                   {
 754                     /* Verify that first_arg_num points to the last arg,
 755                        the ...  */
 756                     while (argument)
 757                       arg_num++, argument = TREE_CHAIN (argument);
 758                   if (arg_num != first_arg_num)
 759                     {
 760                       error ("args to be formatted is not ...");
 761                       continue;
 762                     }
 763                   }
 764               }
 765
 766             record_function_format (DECL_NAME (decl),
 767                                     DECL_ASSEMBLER_NAME (decl),
 768                                     is_scan, format_num, first_arg_num);
 769             break;
 770           }
 771
 772         case A_FORMAT_ARG:
 773           {
 774             tree format_num_expr = TREE_VALUE (args);
 775             int format_num, arg_num;
 776             tree argument;
 777
 778             if (TREE_CODE (decl) != FUNCTION_DECL)
 779               {
 780                 error_with_decl (decl,
 781                          "argument format specified for non-function `%s'");
 782                 continue;
 783               }
 784
 785             /* Strip any conversions from the first arg number and verify it
 786                is a constant.  */
 787             while (TREE_CODE (format_num_expr) == NOP_EXPR
 788                    || TREE_CODE (format_num_expr) == CONVERT_EXPR
 789                    || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 790               format_num_expr = TREE_OPERAND (format_num_expr, 0);
 791
 792             if (TREE_CODE (format_num_expr) != INTEGER_CST)
 793               {
 794                 error ("format string has non-constant operand number");
 795                 continue;
 796               }
 797
 798             format_num = TREE_INT_CST_LOW (format_num_expr);
 799
 800             /* If a parameter list is specified, verify that the format_num
 801                argument is actually a string, in case the format attribute
 802                is in error.  */
 803             argument = TYPE_ARG_TYPES (type);
 804             if (argument)
 805               {
 806                 for (arg_num = 1; ; ++arg_num)
 807                   {
 808                     if (argument == 0 || arg_num == format_num)
 809                       break;
 810                     argument = TREE_CHAIN (argument);
 811                   }
 812                 if (! argument
 813                     || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE
 814                   || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument)))
 815                       != char_type_node))
 816                   {
 817                     error ("format string arg not a string type");
 818                     continue;
 819                   }
 820               }
 821
 822             if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) != POINTER_TYPE
 823                 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl))))
 824                     != char_type_node))
 825               {
 826                 error ("function does not return string type");
 827                 continue;
 828               }
 829
 830             record_international_format (DECL_NAME (decl),
 831                                          DECL_ASSEMBLER_NAME (decl),
 832                                          format_num);
 833             break;
 834           }
 835
 836         case A_WEAK:
 837           declare_weak (decl);
 838           break;
 839
 840         case A_ALIAS:
 841           if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
 842               || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
 843             error_with_decl (decl,
 844                              "`%s' defined both normally and as an alias");
 845           else if (decl_function_context (decl) == 0)
 846             {
 847               tree id = get_identifier (TREE_STRING_POINTER
 848                                         (TREE_VALUE (args)));
 849               if (TREE_CODE (decl) == FUNCTION_DECL)
 850                 DECL_INITIAL (decl) = error_mark_node;
 851               else
 852                 DECL_EXTERNAL (decl) = 0;
 853               assemble_alias (decl, id);
 854             }
 855           else
 856             warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
 857           break;
 858         }
 859     }
 860 }
 861
 862 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
 863    lists.  SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
 864
 865    The head of the declspec list is stored in DECLSPECS.
 866    The head of the attribute list is stored in PREFIX_ATTRIBUTES.
 867
 868    Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
 869    the list elements.  We drop the containing TREE_LIST nodes and link the
 870    resulting attributes together the way decl_attributes expects them.  */
 871
 872 void
 873 split_specs_attrs (specs_attrs, declspecs, prefix_attributes)
 874      tree specs_attrs;
 875      tree *declspecs, *prefix_attributes;
 876 {
 877   tree t, s, a, next, specs, attrs;
 878
 879   /* This can happen in c++ (eg: decl: typespec initdecls ';').  */
 880   if (specs_attrs != NULL_TREE
 881       && TREE_CODE (specs_attrs) != TREE_LIST)
 882     {
 883       *declspecs = specs_attrs;
 884       *prefix_attributes = NULL_TREE;
 885       return;
 886     }
 887
 888   /* Remember to keep the lists in the same order, element-wise.  */
 889
 890   specs = s = NULL_TREE;
 891   attrs = a = NULL_TREE;
 892   for (t = specs_attrs; t; t = next)
 893     {
 894       next = TREE_CHAIN (t);
 895       /* Declspecs have a non-NULL TREE_VALUE.  */
 896       if (TREE_VALUE (t) != NULL_TREE)
 897         {
 898           if (specs == NULL_TREE)
 899             specs = s = t;
 900           else
 901             {
 902               TREE_CHAIN (s) = t;
 903               s = t;
 904             }
 905         }
 906       else
 907         {
 908           if (attrs == NULL_TREE)
 909             attrs = a = TREE_PURPOSE (t);
 910           else
 911             {
 912               TREE_CHAIN (a) = TREE_PURPOSE (t);
 913               a = TREE_PURPOSE (t);
 914             }
 915           /* More attrs can be linked here, move A to the end.  */
 916           while (TREE_CHAIN (a) != NULL_TREE)
 917             a = TREE_CHAIN (a);
 918         }
 919     }
 920
 921   /* Terminate the lists.  */
 922   if (s != NULL_TREE)
 923     TREE_CHAIN (s) = NULL_TREE;
 924   if (a != NULL_TREE)
 925     TREE_CHAIN (a) = NULL_TREE;
 926
 927   /* All done.  */
 928   *declspecs = specs;
 929   *prefix_attributes = attrs;
 930 }
 931
 932 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
 933    This function is used by the parser when a rule will accept attributes
 934    in a particular position, but we don't want to support that just yet.
 935
 936    A warning is issued for every ignored attribute.  */
 937
 938 tree
 939 strip_attrs (specs_attrs)
 940      tree specs_attrs;
 941 {
 942   tree specs, attrs;
 943
 944   split_specs_attrs (specs_attrs, &specs, &attrs);
 945
 946   while (attrs)
 947     {
 948       warning ("`%s' attribute ignored",
 949                IDENTIFIER_POINTER (TREE_PURPOSE (attrs)));
 950       attrs = TREE_CHAIN (attrs);
 951     }
 952
 953   return specs;
 954 }
 955 \f
 956 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
 957    a parameter list.  */
 958
 959 #define T_I     &integer_type_node
 960 #define T_L     &long_integer_type_node
 961 #define T_LL    &long_long_integer_type_node
 962 #define T_S     &short_integer_type_node
 963 #define T_UI    &unsigned_type_node
 964 #define T_UL    &long_unsigned_type_node
 965 #define T_ULL   &long_long_unsigned_type_node
 966 #define T_US    &short_unsigned_type_node
 967 #define T_F     &float_type_node
 968 #define T_D     &double_type_node
 969 #define T_LD    &long_double_type_node
 970 #define T_C     &char_type_node
 971 #define T_V     &void_type_node
 972 #define T_W     &wchar_type_node
 973 #define T_ST    &sizetype
 974
 975 typedef struct {
 976   char *format_chars;
 977   int pointer_count;
 978   /* Type of argument if no length modifier is used.  */
 979   tree *nolen;
 980   /* Type of argument if length modifier for shortening is used.
 981      If NULL, then this modifier is not allowed.  */
 982   tree *hlen;
 983   /* Type of argument if length modifier `l' is used.
 984      If NULL, then this modifier is not allowed.  */
 985   tree *llen;
 986   /* Type of argument if length modifier `q' or `ll' is used.
 987      If NULL, then this modifier is not allowed.  */
 988   tree *qlen;
 989   /* Type of argument if length modifier `L' is used.
 990      If NULL, then this modifier is not allowed.  */
 991   tree *bigllen;
 992   /* List of other modifier characters allowed with these options.  */
 993   char *flag_chars;
 994 } format_char_info;
 995
 996 static format_char_info print_char_table[] = {
 997   { "di",       0,      T_I,    T_I,    T_L,    T_LL,   T_LL,   "-wp0 +"        },
 998   { "oxX",      0,      T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  "-wp0#"         },
 999   { "u",        0,      T_UI,   T_UI,   T_UL,   T_ULL,  T_ULL,  "-wp0"          },
1000 /* Two GNU extensions.  */
1001   { "Z",        0,      T_ST,   NULL,   NULL,   NULL,   NULL,   "-wp0"          },
1002   { "m",        0,      T_V,    NULL,   NULL,   NULL,   NULL,   "-wp"           },
1003   { "feEgGaA",  0,      T_D,    NULL,   NULL,   NULL,   T_LD,   "-wp0 +#"       },
1004   { "c",        0,      T_I,    NULL,   T_W,    NULL,   NULL,   "-w"            },
1005   { "C",        0,      T_W,    NULL,   NULL,   NULL,   NULL,   "-w"            },
1006   { "s",        1,      T_C,    NULL,   T_W,    NULL,   NULL,   "-wp"           },
1007   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   "-wp"           },
1008   { "p",        1,      T_V,    NULL,   NULL,   NULL,   NULL,   "-w"            },
1009   { "n",        1,      T_I,    T_S,    T_L,    T_LL,   NULL,   ""              },
1010   { NULL }
1011 };
1012
1013 static format_char_info scan_char_table[] = {
1014   { "di",       1,      T_I,    T_S,    T_L,    T_LL,   T_LL,   "*"     },
1015   { "ouxX",     1,      T_UI,   T_US,   T_UL,   T_ULL,  T_ULL,  "*"     },
1016   { "efgEGaA",  1,      T_F,    NULL,   T_D,    NULL,   T_LD,   "*"     },
1017   { "sc",       1,      T_C,    NULL,   T_W,    NULL,   NULL,   "*a"    },
1018   { "[",        1,      T_C,    NULL,   NULL,   NULL,   NULL,   "*a"    },
1019   { "C",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   "*"     },
1020   { "S",        1,      T_W,    NULL,   NULL,   NULL,   NULL,   "*"     },
1021   { "p",        2,      T_V,    NULL,   NULL,   NULL,   NULL,   "*"     },
1022   { "n",        1,      T_I,    T_S,    T_L,    T_LL,   NULL,   ""      },
1023   { NULL }
1024 };
1025
1026 typedef struct function_format_info
1027 {
1028   struct function_format_info *next;  /* next structure on the list */
1029   tree name;                    /* identifier such as "printf" */
1030   tree assembler_name;          /* optional mangled identifier (for C++) */
1031   int is_scan;                  /* TRUE if *scanf */
1032   int format_num;               /* number of format argument */
1033   int first_arg_num;            /* number of first arg (zero for varargs) */
1034 } function_format_info;
1035
1036 static function_format_info *function_format_list = NULL;
1037
1038 typedef struct international_format_info
1039 {
1040   struct international_format_info *next;  /* next structure on the list */
1041   tree name;                    /* identifier such as "gettext" */
1042   tree assembler_name;          /* optional mangled identifier (for C++) */
1043   int format_num;               /* number of format argument */
1044 } international_format_info;
1045
1046 static international_format_info *international_format_list = NULL;
1047
1048 static void check_format_info           PROTO((function_format_info *, tree));
1049
1050 /* Initialize the table of functions to perform format checking on.
1051    The ANSI functions are always checked (whether <stdio.h> is
1052    included or not), since it is common to call printf without
1053    including <stdio.h>.  There shouldn't be a problem with this,
1054    since ANSI reserves these function names whether you include the
1055    header file or not.  In any case, the checking is harmless.
1056
1057    Also initialize the name of function that modify the format string for
1058    internationalization purposes.  */
1059
1060 void
1061 init_function_format_info ()
1062 {
1063   record_function_format (get_identifier ("printf"), NULL_TREE, 0, 1, 2);
1064   record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 2, 3);
1065   record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 2, 3);
1066   record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 1, 2);
1067   record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 2, 3);
1068   record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 2, 3);
1069   record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 1, 0);
1070   record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 2, 0);
1071   record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 2, 0);
1072
1073   record_international_format (get_identifier ("gettext"), NULL_TREE, 1);
1074   record_international_format (get_identifier ("dgettext"), NULL_TREE, 2);
1075   record_international_format (get_identifier ("dcgettext"), NULL_TREE, 2);
1076 }
1077
1078 /* Record information for argument format checking.  FUNCTION_IDENT is
1079    the identifier node for the name of the function to check (its decl
1080    need not exist yet).  IS_SCAN is true for scanf-type format checking;
1081    false indicates printf-style format checking.  FORMAT_NUM is the number
1082    of the argument which is the format control string (starting from 1).
1083    FIRST_ARG_NUM is the number of the first actual argument to check
1084    against the format string, or zero if no checking is not be done
1085    (e.g. for varargs such as vfprintf).  */
1086
1087 void
1088 record_function_format (name, assembler_name, is_scan,
1089                         format_num, first_arg_num)
1090       tree name;
1091       tree assembler_name;
1092       int is_scan;
1093       int format_num;
1094       int first_arg_num;
1095 {
1096   function_format_info *info;
1097
1098   /* Re-use existing structure if it's there.  */
1099
1100   for (info = function_format_list; info; info = info->next)
1101     {
1102       if (info->name == name && info->assembler_name == assembler_name)
1103         break;
1104     }
1105   if (! info)
1106     {
1107       info = (function_format_info *) xmalloc (sizeof (function_format_info));
1108       info->next = function_format_list;
1109       function_format_list = info;
1110
1111       info->name = name;
1112       info->assembler_name = assembler_name;
1113     }
1114
1115   info->is_scan = is_scan;
1116   info->format_num = format_num;
1117   info->first_arg_num = first_arg_num;
1118 }
1119
1120 /* Record information for the names of function that modify the format
1121    argument to format functions.  FUNCTION_IDENT is the identifier node for
1122    the name of the function (its decl need not exist yet) and FORMAT_NUM is
1123    the number of the argument which is the format control string (starting
1124    from 1).  */
1125
1126 static void
1127 record_international_format (name, assembler_name, format_num)
1128       tree name;
1129       tree assembler_name;
1130       int format_num;
1131 {
1132   international_format_info *info;
1133
1134   /* Re-use existing structure if it's there.  */
1135
1136   for (info = international_format_list; info; info = info->next)
1137     {
1138       if (info->name == name && info->assembler_name == assembler_name)
1139         break;
1140     }
1141
1142   if (! info)
1143     {
1144       info
1145         = (international_format_info *)
1146           xmalloc (sizeof (international_format_info));
1147       info->next = international_format_list;
1148       international_format_list = info;
1149
1150       info->name = name;
1151       info->assembler_name = assembler_name;
1152     }
1153
1154   info->format_num = format_num;
1155 }
1156
1157 static char     tfaff[] = "too few arguments for format";
1158 \f
1159 /* Check the argument list of a call to printf, scanf, etc.
1160    NAME is the function identifier.
1161    ASSEMBLER_NAME is the function's assembler identifier.
1162    (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1163    PARAMS is the list of argument values.  */
1164
1165 void
1166 check_function_format (name, assembler_name, params)
1167      tree name;
1168      tree assembler_name;
1169      tree params;
1170 {
1171   function_format_info *info;
1172
1173   /* See if this function is a format function.  */
1174   for (info = function_format_list; info; info = info->next)
1175     {
1176       if (info->assembler_name
1177           ? (info->assembler_name == assembler_name)
1178           : (info->name == name))
1179         {
1180           /* Yup; check it.  */
1181           check_format_info (info, params);
1182           break;
1183         }
1184     }
1185 }
1186
1187 /* Check the argument list of a call to printf, scanf, etc.
1188    INFO points to the function_format_info structure.
1189    PARAMS is the list of argument values.  */
1190
1191 static void
1192 check_format_info (info, params)
1193      function_format_info *info;
1194      tree params;
1195 {
1196   int i;
1197   int arg_num;
1198   int suppressed, wide, precise;
1199   int length_char;
1200   int format_char;
1201   int format_length;
1202   tree format_tree;
1203   tree cur_param;
1204   tree cur_type;
1205   tree wanted_type;
1206   tree first_fillin_param;
1207   char *format_chars;
1208   format_char_info *fci;
1209   static char message[132];
1210   char flag_chars[8];
1211   int has_operand_number = 0;
1212
1213   /* Skip to format argument.  If the argument isn't available, there's
1214      no work for us to do; prototype checking will catch the problem.  */
1215   for (arg_num = 1; ; ++arg_num)
1216     {
1217       if (params == 0)
1218         return;
1219       if (arg_num == info->format_num)
1220         break;
1221       params = TREE_CHAIN (params);
1222     }
1223   format_tree = TREE_VALUE (params);
1224   params = TREE_CHAIN (params);
1225   if (format_tree == 0)
1226     return;
1227
1228   /* We can only check the format if it's a string constant.  */
1229   while (TREE_CODE (format_tree) == NOP_EXPR)
1230     format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */
1231
1232   if (TREE_CODE (format_tree) == CALL_EXPR
1233       && TREE_CODE (TREE_OPERAND (format_tree, 0)) == ADDR_EXPR
1234       && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0))
1235           == FUNCTION_DECL))
1236     {
1237       tree function = TREE_OPERAND (TREE_OPERAND (format_tree, 0), 0);
1238
1239       /* See if this is a call to a known internationalization function
1240          that modifies the format arg.  */
1241       international_format_info *info;
1242
1243       for (info = international_format_list; info; info = info->next)
1244         if (info->assembler_name
1245             ? (info->assembler_name == DECL_ASSEMBLER_NAME (function))
1246             : (info->name == DECL_NAME (function)))
1247           {
1248             tree inner_args;
1249             int i;
1250
1251             for (inner_args = TREE_OPERAND (format_tree, 1), i = 1;
1252                  inner_args != 0;
1253                  inner_args = TREE_CHAIN (inner_args), i++)
1254               if (i == info->format_num)
1255                 {
1256                   format_tree = TREE_VALUE (inner_args);
1257
1258                   while (TREE_CODE (format_tree) == NOP_EXPR)
1259                     format_tree = TREE_OPERAND (format_tree, 0);
1260                 }
1261           }
1262     }
1263
1264   if (integer_zerop (format_tree))
1265     {
1266       warning ("null format string");
1267       return;
1268     }
1269   if (TREE_CODE (format_tree) != ADDR_EXPR)
1270     return;
1271   format_tree = TREE_OPERAND (format_tree, 0);
1272   if (TREE_CODE (format_tree) != STRING_CST)
1273     return;
1274   format_chars = TREE_STRING_POINTER (format_tree);
1275   format_length = TREE_STRING_LENGTH (format_tree);
1276   if (format_length <= 1)
1277     warning ("zero-length format string");
1278   if (format_chars[--format_length] != 0)
1279     {
1280       warning ("unterminated format string");
1281       return;
1282     }
1283   /* Skip to first argument to check.  */
1284   while (arg_num + 1 < info->first_arg_num)
1285     {
1286       if (params == 0)
1287         return;
1288       params = TREE_CHAIN (params);
1289       ++arg_num;
1290     }
1291
1292   first_fillin_param = params;
1293   while (1)
1294     {
1295       int aflag;
1296       if (*format_chars == 0)
1297         {
1298           if (format_chars - TREE_STRING_POINTER (format_tree) != format_length)
1299             warning ("embedded `\\0' in format");
1300           if (info->first_arg_num != 0 && params != 0 && ! has_operand_number)
1301             warning ("too many arguments for format");
1302           return;
1303         }
1304       if (*format_chars++ != '%')
1305         continue;
1306       if (*format_chars == 0)
1307         {
1308           warning ("spurious trailing `%%' in format");
1309           continue;
1310         }
1311       if (*format_chars == '%')
1312         {
1313           ++format_chars;
1314           continue;
1315         }
1316       flag_chars[0] = 0;
1317       suppressed = wide = precise = FALSE;
1318       if (info->is_scan)
1319         {
1320           suppressed = *format_chars == '*';
1321           if (suppressed)
1322             ++format_chars;
1323           while (isdigit (*format_chars))
1324             ++format_chars;
1325         }
1326       else
1327         {
1328           /* See if we have a number followed by a dollar sign.  If we do,
1329              it is an operand number, so set PARAMS to that operand.  */
1330           if (*format_chars >= '0' && *format_chars <= '9')
1331             {
1332               char *p = format_chars;
1333
1334               while (*p >= '0' && *p++ <= '9')
1335                 ;
1336
1337               if (*p == '$')
1338                 {
1339                   int opnum = atoi (format_chars);
1340
1341                   params = first_fillin_param;
1342                   format_chars = p + 1;
1343                   has_operand_number = 1;
1344
1345                   for (i = 1; i < opnum && params != 0; i++)
1346                     params = TREE_CHAIN (params);
1347
1348                   if (opnum == 0 || params == 0)
1349                     {
1350                       warning ("operand number out of range in format");
1351                       return;
1352                     }
1353                 }
1354             }
1355
1356           while (*format_chars != 0 && index (" +#0-", *format_chars) != 0)
1357             {
1358               if (index (flag_chars, *format_chars) != 0)
1359                 {
1360                   sprintf (message, "repeated `%c' flag in format",
1361                            *format_chars);
1362                   warning (message);
1363                 }
1364               else
1365                 {
1366                   i = strlen (flag_chars);
1367                   flag_chars[i++] = *format_chars++;
1368                   flag_chars[i] = 0;
1369                 }
1370             }
1371           /* "If the space and + flags both appear,
1372              the space flag will be ignored."  */
1373           if (index (flag_chars, ' ') != 0
1374               && index (flag_chars, '+') != 0)
1375             warning ("use of both ` ' and `+' flags in format");
1376           /* "If the 0 and - flags both appear,
1377              the 0 flag will be ignored."  */
1378           if (index (flag_chars, '0') != 0
1379               && index (flag_chars, '-') != 0)
1380             warning ("use of both `0' and `-' flags in format");
1381           if (*format_chars == '*')
1382             {
1383               wide = TRUE;
1384               /* "...a field width...may be indicated by an asterisk.
1385                  In this case, an int argument supplies the field width..."  */
1386               ++format_chars;
1387               if (params == 0)
1388                 {
1389                   warning (tfaff);
1390                   return;
1391                 }
1392               if (info->first_arg_num != 0)
1393                 {
1394                   cur_param = TREE_VALUE (params);
1395                   params = TREE_CHAIN (params);
1396                   ++arg_num;
1397                   /* size_t is generally not valid here.
1398                      It will work on most machines, because size_t and int
1399                      have the same mode.  But might as well warn anyway,
1400                      since it will fail on other machines.  */
1401                   if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1402                        != integer_type_node)
1403                       &&
1404                       (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1405                        != unsigned_type_node))
1406                     {
1407                       sprintf (message,
1408                                "field width is not type int (arg %d)",
1409                                arg_num);
1410                       warning (message);
1411                     }
1412                 }
1413             }
1414           else
1415             {
1416               while (isdigit (*format_chars))
1417                 {
1418                   wide = TRUE;
1419                   ++format_chars;
1420                 }
1421             }
1422           if (*format_chars == '.')
1423             {
1424               precise = TRUE;
1425               ++format_chars;
1426               if (*format_chars != '*' && !isdigit (*format_chars))
1427                 warning ("`.' not followed by `*' or digit in format");
1428               /* "...a...precision...may be indicated by an asterisk.
1429                  In this case, an int argument supplies the...precision."  */
1430               if (*format_chars == '*')
1431                 {
1432                   if (info->first_arg_num != 0)
1433                     {
1434                       ++format_chars;
1435                       if (params == 0)
1436                         {
1437                           warning (tfaff);
1438                           return;
1439                         }
1440                       cur_param = TREE_VALUE (params);
1441                       params = TREE_CHAIN (params);
1442                       ++arg_num;
1443                       if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param))
1444                           != integer_type_node)
1445                         {
1446                           sprintf (message,
1447                                    "field width is not type int (arg %d)",
1448                                    arg_num);
1449                           warning (message);
1450                         }
1451                     }
1452                 }
1453               else
1454                 {
1455                   while (isdigit (*format_chars))
1456                     ++format_chars;
1457                 }
1458             }
1459         }
1460       if (*format_chars == 'h' || *format_chars == 'l')
1461         length_char = *format_chars++;
1462       else if (*format_chars == 'q' || *format_chars == 'L')
1463         {
1464           length_char = *format_chars++;
1465           if (pedantic)
1466             pedwarn ("ANSI C does not support the `%c' length modifier",
1467                      length_char);
1468         }
1469       else
1470         length_char = 0;
1471       if (length_char == 'l' && *format_chars == 'l')
1472         {
1473           length_char = 'q', format_chars++;
1474           if (pedantic)
1475             pedwarn ("ANSI C does not support the `ll' length modifier");
1476         }
1477       aflag = 0;
1478       if (*format_chars == 'a' && info->is_scan)
1479         {
1480           if (format_chars[1] == 's' || format_chars[1] == 'S'
1481               || format_chars[1] == '[')
1482             {
1483               /* `a' is used as a flag.  */
1484               aflag = 1;
1485               format_chars++;
1486             }
1487         }
1488       if (suppressed && length_char != 0)
1489         {
1490           sprintf (message,
1491                    "use of `*' and `%c' together in format",
1492                    length_char);
1493           warning (message);
1494         }
1495       format_char = *format_chars;
1496       if (format_char == 0 || format_char == '%')
1497         {
1498           warning ("conversion lacks type at end of format");
1499           continue;
1500         }
1501       format_chars++;
1502       fci = info->is_scan ? scan_char_table : print_char_table;
1503       while (fci->format_chars != 0
1504              && index (fci->format_chars, format_char) == 0)
1505           ++fci;
1506       if (fci->format_chars == 0)
1507         {
1508           if (format_char >= 040 && format_char < 0177)
1509             sprintf (message,
1510                      "unknown conversion type character `%c' in format",
1511                      format_char);
1512           else
1513             sprintf (message,
1514                      "unknown conversion type character 0x%x in format",
1515                      format_char);
1516           warning (message);
1517           continue;
1518         }
1519       if (wide && index (fci->flag_chars, 'w') == 0)
1520         {
1521           sprintf (message, "width used with `%c' format",
1522                    format_char);
1523           warning (message);
1524         }
1525       if (precise && index (fci->flag_chars, 'p') == 0)
1526         {
1527           sprintf (message, "precision used with `%c' format",
1528                    format_char);
1529           warning (message);
1530         }
1531       if (aflag && index (fci->flag_chars, 'a') == 0)
1532         {
1533           sprintf (message, "`a' flag used with `%c' format",
1534                    format_char);
1535           warning (message);
1536           /* To simplify the following code.  */
1537           aflag = 0;
1538         }
1539       if (info->is_scan && format_char == '[')
1540         {
1541           /* Skip over scan set, in case it happens to have '%' in it.  */
1542           if (*format_chars == '^')
1543             ++format_chars;
1544           /* Find closing bracket; if one is hit immediately, then
1545              it's part of the scan set rather than a terminator.  */
1546           if (*format_chars == ']')
1547             ++format_chars;
1548           while (*format_chars && *format_chars != ']')
1549             ++format_chars;
1550           if (*format_chars != ']')
1551               /* The end of the format string was reached.  */
1552               warning ("no closing `]' for `%%[' format");
1553         }
1554       if (suppressed)
1555         {
1556           if (index (fci->flag_chars, '*') == 0)
1557             {
1558               sprintf (message,
1559                        "suppression of `%c' conversion in format",
1560                        format_char);
1561               warning (message);
1562             }
1563           continue;
1564         }
1565       for (i = 0; flag_chars[i] != 0; ++i)
1566         {
1567           if (index (fci->flag_chars, flag_chars[i]) == 0)
1568             {
1569               sprintf (message, "flag `%c' used with type `%c'",
1570                        flag_chars[i], format_char);
1571               warning (message);
1572             }
1573         }
1574       if (precise && index (flag_chars, '0') != 0
1575           && (format_char == 'd' || format_char == 'i'
1576               || format_char == 'o' || format_char == 'u'
1577               || format_char == 'x' || format_char == 'x'))
1578         {
1579           sprintf (message,
1580                    "`0' flag ignored with precision specifier and `%c' format",
1581                    format_char);
1582           warning (message);
1583         }
1584       switch (length_char)
1585         {
1586         default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break;
1587         case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break;
1588         case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
1589         case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
1590         case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
1591         }
1592       if (wanted_type == 0)
1593         {
1594           sprintf (message,
1595                    "use of `%c' length character with `%c' type character",
1596                    length_char, format_char);
1597           warning (message);
1598         }
1599
1600       /*
1601        ** XXX -- should kvetch about stuff such as
1602        **       {
1603        **               const int       i;
1604        **
1605        **               scanf ("%d", &i);
1606        **       }
1607        */
1608
1609       /* Finally. . .check type of argument against desired type!  */
1610       if (info->first_arg_num == 0)
1611         continue;
1612       if (fci->pointer_count == 0 && wanted_type == void_type_node)
1613         /* This specifier takes no argument.  */
1614         continue;
1615       if (params == 0)
1616         {
1617           warning (tfaff);
1618           return;
1619         }
1620       cur_param = TREE_VALUE (params);
1621       params = TREE_CHAIN (params);
1622       ++arg_num;
1623       cur_type = TREE_TYPE (cur_param);
1624
1625       STRIP_NOPS (cur_param);
1626
1627       /* Check the types of any additional pointer arguments
1628          that precede the "real" argument.  */
1629       for (i = 0; i < fci->pointer_count + aflag; ++i)
1630         {
1631           if (TREE_CODE (cur_type) == POINTER_TYPE)
1632             {
1633               cur_type = TREE_TYPE (cur_type);
1634
1635               if (TREE_CODE (cur_param) == ADDR_EXPR)
1636                 cur_param = TREE_OPERAND (cur_param, 0);
1637               else
1638                 cur_param = 0;
1639
1640               continue;
1641             }
1642           if (TREE_CODE (cur_type) != ERROR_MARK)
1643             {
1644               sprintf (message,
1645                        "format argument is not a %s (arg %d)",
1646                        ((fci->pointer_count + aflag == 1)
1647                         ? "pointer" : "pointer to a pointer"),
1648                        arg_num);
1649               warning (message);
1650             }
1651           break;
1652         }
1653
1654       /* See if this is an attempt to write into a const type with
1655          scanf.  */
1656       if (info->is_scan && i == fci->pointer_count + aflag
1657           && wanted_type != 0
1658           && TREE_CODE (cur_type) != ERROR_MARK
1659           && (TYPE_READONLY (cur_type)
1660               || (cur_param != 0
1661                   && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
1662                       || (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'd'
1663                           && TREE_READONLY (cur_param))))))
1664         {
1665           sprintf (message, "writing into constant object (arg %d)", arg_num);
1666           warning (message);
1667         }
1668
1669       /* Check the type of the "real" argument, if there's a type we want.  */
1670       if (i == fci->pointer_count + aflag && wanted_type != 0
1671           && TREE_CODE (cur_type) != ERROR_MARK
1672           && wanted_type != TYPE_MAIN_VARIANT (cur_type)
1673           /* If we want `void *', allow any pointer type.
1674              (Anything else would already have got a warning.)  */
1675           && ! (wanted_type == void_type_node
1676                 && fci->pointer_count > 0)
1677           /* Don't warn about differences merely in signedness.  */
1678           && !(TREE_CODE (wanted_type) == INTEGER_TYPE
1679                && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE
1680                && (TREE_UNSIGNED (wanted_type)
1681                    ? wanted_type == (cur_type = unsigned_type (cur_type))
1682                    : wanted_type == (cur_type = signed_type (cur_type))))
1683           /* Likewise, "signed char", "unsigned char" and "char" are
1684              equivalent but the above test won't consider them equivalent.  */
1685           && ! (wanted_type == char_type_node
1686                 && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node
1687                     || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node)))
1688         {
1689           register char *this;
1690           register char *that;
1691
1692           this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type)));
1693           that = 0;
1694           if (TREE_CODE (cur_type) != ERROR_MARK
1695               && TYPE_NAME (cur_type) != 0
1696               && TREE_CODE (cur_type) != INTEGER_TYPE
1697               && !(TREE_CODE (cur_type) == POINTER_TYPE
1698                    && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE))
1699             {
1700               if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL
1701                   && DECL_NAME (TYPE_NAME (cur_type)) != 0)
1702                 that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1703               else
1704                 that = IDENTIFIER_POINTER (TYPE_NAME (cur_type));
1705             }
1706
1707           /* A nameless type can't possibly match what the format wants.
1708              So there will be a warning for it.
1709              Make up a string to describe vaguely what it is.  */
1710           if (that == 0)
1711             {
1712               if (TREE_CODE (cur_type) == POINTER_TYPE)
1713                 that = "pointer";
1714               else
1715                 that = "different type";
1716             }
1717
1718           /* Make the warning better in case of mismatch of int vs long.  */
1719           if (TREE_CODE (cur_type) == INTEGER_TYPE
1720               && TREE_CODE (wanted_type) == INTEGER_TYPE
1721               && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type)
1722               && TYPE_NAME (cur_type) != 0
1723               && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL)
1724             that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type)));
1725
1726           if (strcmp (this, that) != 0)
1727             {
1728               sprintf (message, "%s format, %s arg (arg %d)",
1729                         this, that, arg_num);
1730               warning (message);
1731             }
1732         }
1733     }
1734 }
1735 \f
1736 /* Print a warning if a constant expression had overflow in folding.
1737    Invoke this function on every expression that the language
1738    requires to be a constant expression.
1739    Note the ANSI C standard says it is erroneous for a
1740    constant expression to overflow.  */
1741
1742 void
1743 constant_expression_warning (value)
1744      tree value;
1745 {
1746   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1747        || TREE_CODE (value) == COMPLEX_CST)
1748       && TREE_CONSTANT_OVERFLOW (value) && pedantic)
1749     pedwarn ("overflow in constant expression");
1750 }
1751
1752 /* Print a warning if an expression had overflow in folding.
1753    Invoke this function on every expression that
1754    (1) appears in the source code, and
1755    (2) might be a constant expression that overflowed, and
1756    (3) is not already checked by convert_and_check;
1757    however, do not invoke this function on operands of explicit casts.  */
1758
1759 void
1760 overflow_warning (value)
1761      tree value;
1762 {
1763   if ((TREE_CODE (value) == INTEGER_CST
1764        || (TREE_CODE (value) == COMPLEX_CST
1765            && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1766       && TREE_OVERFLOW (value))
1767     {
1768       TREE_OVERFLOW (value) = 0;
1769       if (skip_evaluation == 0)
1770         warning ("integer overflow in expression");
1771     }
1772   else if ((TREE_CODE (value) == REAL_CST
1773             || (TREE_CODE (value) == COMPLEX_CST
1774                 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1775            && TREE_OVERFLOW (value))
1776     {
1777       TREE_OVERFLOW (value) = 0;
1778       if (skip_evaluation == 0)
1779         warning ("floating point overflow in expression");
1780     }
1781 }
1782
1783 /* Print a warning if a large constant is truncated to unsigned,
1784    or if -Wconversion is used and a constant < 0 is converted to unsigned.
1785    Invoke this function on every expression that might be implicitly
1786    converted to an unsigned type.  */
1787
1788 void
1789 unsigned_conversion_warning (result, operand)
1790      tree result, operand;
1791 {
1792   if (TREE_CODE (operand) == INTEGER_CST
1793       && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
1794       && TREE_UNSIGNED (TREE_TYPE (result))
1795       && skip_evaluation == 0
1796       && !int_fits_type_p (operand, TREE_TYPE (result)))
1797     {
1798       if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
1799         /* This detects cases like converting -129 or 256 to unsigned char.  */
1800         warning ("large integer implicitly truncated to unsigned type");
1801       else if (warn_conversion)
1802         warning ("negative integer implicitly converted to unsigned type");
1803     }
1804 }
1805
1806 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1807    Invoke this function on every expression that is converted implicitly,
1808    i.e. because of language rules and not because of an explicit cast.  */
1809
1810 tree
1811 convert_and_check (type, expr)
1812      tree type, expr;
1813 {
1814   tree t = convert (type, expr);
1815   if (TREE_CODE (t) == INTEGER_CST)
1816     {
1817       if (TREE_OVERFLOW (t))
1818         {
1819           TREE_OVERFLOW (t) = 0;
1820
1821           /* Do not diagnose overflow in a constant expression merely
1822              because a conversion overflowed.  */
1823           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1824
1825           /* No warning for converting 0x80000000 to int.  */
1826           if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1827                 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1828                 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1829             /* If EXPR fits in the unsigned version of TYPE,
1830                don't warn unless pedantic.  */
1831             if ((pedantic
1832                  || TREE_UNSIGNED (type)
1833                  || ! int_fits_type_p (expr, unsigned_type (type)))
1834                 && skip_evaluation == 0)
1835                 warning ("overflow in implicit constant conversion");
1836         }
1837       else
1838         unsigned_conversion_warning (t, expr);
1839     }
1840   return t;
1841 }
1842 \f
1843 void
1844 c_expand_expr_stmt (expr)
1845      tree expr;
1846 {
1847   /* Do default conversion if safe and possibly important,
1848      in case within ({...}).  */
1849   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1850       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1851     expr = default_conversion (expr);
1852
1853   if (TREE_TYPE (expr) != error_mark_node
1854       && TYPE_SIZE (TREE_TYPE (expr)) == 0
1855       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1856     error ("expression statement has incomplete type");
1857
1858   expand_expr_stmt (expr);
1859 }
1860 \f
1861 /* Validate the expression after `case' and apply default promotions.  */
1862
1863 tree
1864 check_case_value (value)
1865      tree value;
1866 {
1867   if (value == NULL_TREE)
1868     return value;
1869
1870   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
1871   STRIP_TYPE_NOPS (value);
1872
1873   if (TREE_CODE (value) != INTEGER_CST
1874       && value != error_mark_node)
1875     {
1876       error ("case label does not reduce to an integer constant");
1877       value = error_mark_node;
1878     }
1879   else
1880     /* Promote char or short to int.  */
1881     value = default_conversion (value);
1882
1883   constant_expression_warning (value);
1884
1885   return value;
1886 }
1887 \f
1888 /* Return an integer type with BITS bits of precision,
1889    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1890
1891 tree
1892 type_for_size (bits, unsignedp)
1893      unsigned bits;
1894      int unsignedp;
1895 {
1896   if (bits == TYPE_PRECISION (integer_type_node))
1897     return unsignedp ? unsigned_type_node : integer_type_node;
1898
1899   if (bits == TYPE_PRECISION (signed_char_type_node))
1900     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1901
1902   if (bits == TYPE_PRECISION (short_integer_type_node))
1903     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1904
1905   if (bits == TYPE_PRECISION (long_integer_type_node))
1906     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1907
1908   if (bits == TYPE_PRECISION (long_long_integer_type_node))
1909     return (unsignedp ? long_long_unsigned_type_node
1910             : long_long_integer_type_node);
1911
1912   if (bits <= TYPE_PRECISION (intQI_type_node))
1913     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1914
1915   if (bits <= TYPE_PRECISION (intHI_type_node))
1916     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1917
1918   if (bits <= TYPE_PRECISION (intSI_type_node))
1919     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1920
1921   if (bits <= TYPE_PRECISION (intDI_type_node))
1922     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1923
1924   return 0;
1925 }
1926
1927 /* Return a data type that has machine mode MODE.
1928    If the mode is an integer,
1929    then UNSIGNEDP selects between signed and unsigned types.  */
1930
1931 tree
1932 type_for_mode (mode, unsignedp)
1933      enum machine_mode mode;
1934      int unsignedp;
1935 {
1936   if (mode == TYPE_MODE (integer_type_node))
1937     return unsignedp ? unsigned_type_node : integer_type_node;
1938
1939   if (mode == TYPE_MODE (signed_char_type_node))
1940     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1941
1942   if (mode == TYPE_MODE (short_integer_type_node))
1943     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1944
1945   if (mode == TYPE_MODE (long_integer_type_node))
1946     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1947
1948   if (mode == TYPE_MODE (long_long_integer_type_node))
1949     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1950
1951   if (mode == TYPE_MODE (intQI_type_node))
1952     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1953
1954   if (mode == TYPE_MODE (intHI_type_node))
1955     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1956
1957   if (mode == TYPE_MODE (intSI_type_node))
1958     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1959
1960   if (mode == TYPE_MODE (intDI_type_node))
1961     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1962
1963   if (mode == TYPE_MODE (float_type_node))
1964     return float_type_node;
1965
1966   if (mode == TYPE_MODE (double_type_node))
1967     return double_type_node;
1968
1969   if (mode == TYPE_MODE (long_double_type_node))
1970     return long_double_type_node;
1971
1972   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1973     return build_pointer_type (char_type_node);
1974
1975   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1976     return build_pointer_type (integer_type_node);
1977
1978   return 0;
1979 }
1980 \f
1981 /* Return the minimum number of bits needed to represent VALUE in a
1982    signed or unsigned type, UNSIGNEDP says which.  */
1983
1984 int
1985 min_precision (value, unsignedp)
1986      tree value;
1987      int unsignedp;
1988 {
1989   int log;
1990
1991   /* If the value is negative, compute its negative minus 1.  The latter
1992      adjustment is because the absolute value of the largest negative value
1993      is one larger than the largest positive value.  This is equivalent to
1994      a bit-wise negation, so use that operation instead.  */
1995
1996   if (tree_int_cst_sgn (value) < 0)
1997     value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1998
1999   /* Return the number of bits needed, taking into account the fact
2000      that we need one more bit for a signed than unsigned type.  */
2001
2002   if (integer_zerop (value))
2003     log = 0;
2004   else if (TREE_INT_CST_HIGH (value) != 0)
2005     log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value));
2006   else
2007     log = floor_log2 (TREE_INT_CST_LOW (value));
2008
2009   return log + 1 + ! unsignedp;
2010 }
2011 \f
2012 /* Print an error message for invalid operands to arith operation CODE.
2013    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
2014
2015 void
2016 binary_op_error (code)
2017      enum tree_code code;
2018 {
2019   register char *opname;
2020
2021   switch (code)
2022     {
2023     case NOP_EXPR:
2024       error ("invalid truth-value expression");
2025       return;
2026
2027     case PLUS_EXPR:
2028       opname = "+"; break;
2029     case MINUS_EXPR:
2030       opname = "-"; break;
2031     case MULT_EXPR:
2032       opname = "*"; break;
2033     case MAX_EXPR:
2034       opname = "max"; break;
2035     case MIN_EXPR:
2036       opname = "min"; break;
2037     case EQ_EXPR:
2038       opname = "=="; break;
2039     case NE_EXPR:
2040       opname = "!="; break;
2041     case LE_EXPR:
2042       opname = "<="; break;
2043     case GE_EXPR:
2044       opname = ">="; break;
2045     case LT_EXPR:
2046       opname = "<"; break;
2047     case GT_EXPR:
2048       opname = ">"; break;
2049     case LSHIFT_EXPR:
2050       opname = "<<"; break;
2051     case RSHIFT_EXPR:
2052       opname = ">>"; break;
2053     case TRUNC_MOD_EXPR:
2054     case FLOOR_MOD_EXPR:
2055       opname = "%"; break;
2056     case TRUNC_DIV_EXPR:
2057     case FLOOR_DIV_EXPR:
2058       opname = "/"; break;
2059     case BIT_AND_EXPR:
2060       opname = "&"; break;
2061     case BIT_IOR_EXPR:
2062       opname = "|"; break;
2063     case TRUTH_ANDIF_EXPR:
2064       opname = "&&"; break;
2065     case TRUTH_ORIF_EXPR:
2066       opname = "||"; break;
2067     case BIT_XOR_EXPR:
2068       opname = "^"; break;
2069     case LROTATE_EXPR:
2070     case RROTATE_EXPR:
2071       opname = "rotate"; break;
2072     default:
2073       opname = "unknown"; break;
2074     }
2075   error ("invalid operands to binary %s", opname);
2076 }
2077 \f
2078 /* Subroutine of build_binary_op, used for comparison operations.
2079    See if the operands have both been converted from subword integer types
2080    and, if so, perhaps change them both back to their original type.
2081    This function is also responsible for converting the two operands
2082    to the proper common type for comparison.
2083
2084    The arguments of this function are all pointers to local variables
2085    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2086    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2087
2088    If this function returns nonzero, it means that the comparison has
2089    a constant value.  What this function returns is an expression for
2090    that value.  */
2091
2092 tree
2093 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
2094      tree *op0_ptr, *op1_ptr;
2095      tree *restype_ptr;
2096      enum tree_code *rescode_ptr;
2097 {
2098   register tree type;
2099   tree op0 = *op0_ptr;
2100   tree op1 = *op1_ptr;
2101   int unsignedp0, unsignedp1;
2102   int real1, real2;
2103   tree primop0, primop1;
2104   enum tree_code code = *rescode_ptr;
2105
2106   /* Throw away any conversions to wider types
2107      already present in the operands.  */
2108
2109   primop0 = get_narrower (op0, &unsignedp0);
2110   primop1 = get_narrower (op1, &unsignedp1);
2111
2112   /* Handle the case that OP0 does not *contain* a conversion
2113      but it *requires* conversion to FINAL_TYPE.  */
2114
2115   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2116     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2117   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2118     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2119
2120   /* If one of the operands must be floated, we cannot optimize.  */
2121   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2122   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2123
2124   /* If first arg is constant, swap the args (changing operation
2125      so value is preserved), for canonicalization.  Don't do this if
2126      the second arg is 0.  */
2127
2128   if (TREE_CONSTANT (primop0)
2129       && ! integer_zerop (primop1) && ! real_zerop (primop1))
2130     {
2131       register tree tem = primop0;
2132       register int temi = unsignedp0;
2133       primop0 = primop1;
2134       primop1 = tem;
2135       tem = op0;
2136       op0 = op1;
2137       op1 = tem;
2138       *op0_ptr = op0;
2139       *op1_ptr = op1;
2140       unsignedp0 = unsignedp1;
2141       unsignedp1 = temi;
2142       temi = real1;
2143       real1 = real2;
2144       real2 = temi;
2145
2146       switch (code)
2147         {
2148         case LT_EXPR:
2149           code = GT_EXPR;
2150           break;
2151         case GT_EXPR:
2152           code = LT_EXPR;
2153           break;
2154         case LE_EXPR:
2155           code = GE_EXPR;
2156           break;
2157         case GE_EXPR:
2158           code = LE_EXPR;
2159           break;
2160         default:
2161           break;
2162         }
2163       *rescode_ptr = code;
2164     }
2165
2166   /* If comparing an integer against a constant more bits wide,
2167      maybe we can deduce a value of 1 or 0 independent of the data.
2168      Or else truncate the constant now
2169      rather than extend the variable at run time.
2170
2171      This is only interesting if the constant is the wider arg.
2172      Also, it is not safe if the constant is unsigned and the
2173      variable arg is signed, since in this case the variable
2174      would be sign-extended and then regarded as unsigned.
2175      Our technique fails in this case because the lowest/highest
2176      possible unsigned results don't follow naturally from the
2177      lowest/highest possible values of the variable operand.
2178      For just EQ_EXPR and NE_EXPR there is another technique that
2179      could be used: see if the constant can be faithfully represented
2180      in the other operand's type, by truncating it and reextending it
2181      and see if that preserves the constant's value.  */
2182
2183   if (!real1 && !real2
2184       && TREE_CODE (primop1) == INTEGER_CST
2185       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2186     {
2187       int min_gt, max_gt, min_lt, max_lt;
2188       tree maxval, minval;
2189       /* 1 if comparison is nominally unsigned.  */
2190       int unsignedp = TREE_UNSIGNED (*restype_ptr);
2191       tree val;
2192
2193       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
2194
2195       maxval = TYPE_MAX_VALUE (type);
2196       minval = TYPE_MIN_VALUE (type);
2197
2198       if (unsignedp && !unsignedp0)
2199         *restype_ptr = signed_type (*restype_ptr);
2200
2201       if (TREE_TYPE (primop1) != *restype_ptr)
2202         primop1 = convert (*restype_ptr, primop1);
2203       if (type != *restype_ptr)
2204         {
2205           minval = convert (*restype_ptr, minval);
2206           maxval = convert (*restype_ptr, maxval);
2207         }
2208
2209       if (unsignedp && unsignedp0)
2210         {
2211           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2212           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2213           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2214           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2215         }
2216       else
2217         {
2218           min_gt = INT_CST_LT (primop1, minval);
2219           max_gt = INT_CST_LT (primop1, maxval);
2220           min_lt = INT_CST_LT (minval, primop1);
2221           max_lt = INT_CST_LT (maxval, primop1);
2222         }
2223
2224       val = 0;
2225       /* This used to be a switch, but Genix compiler can't handle that.  */
2226       if (code == NE_EXPR)
2227         {
2228           if (max_lt || min_gt)
2229             val = boolean_true_node;
2230         }
2231       else if (code == EQ_EXPR)
2232         {
2233           if (max_lt || min_gt)
2234             val = boolean_false_node;
2235         }
2236       else if (code == LT_EXPR)
2237         {
2238           if (max_lt)
2239             val = boolean_true_node;
2240           if (!min_lt)
2241             val = boolean_false_node;
2242         }
2243       else if (code == GT_EXPR)
2244         {
2245           if (min_gt)
2246             val = boolean_true_node;
2247           if (!max_gt)
2248             val = boolean_false_node;
2249         }
2250       else if (code == LE_EXPR)
2251         {
2252           if (!max_gt)
2253             val = boolean_true_node;
2254           if (min_gt)
2255             val = boolean_false_node;
2256         }
2257       else if (code == GE_EXPR)
2258         {
2259           if (!min_lt)
2260             val = boolean_true_node;
2261           if (max_lt)
2262             val = boolean_false_node;
2263         }
2264
2265       /* If primop0 was sign-extended and unsigned comparison specd,
2266          we did a signed comparison above using the signed type bounds.
2267          But the comparison we output must be unsigned.
2268
2269          Also, for inequalities, VAL is no good; but if the signed
2270          comparison had *any* fixed result, it follows that the
2271          unsigned comparison just tests the sign in reverse
2272          (positive values are LE, negative ones GE).
2273          So we can generate an unsigned comparison
2274          against an extreme value of the signed type.  */
2275
2276       if (unsignedp && !unsignedp0)
2277         {
2278           if (val != 0)
2279             switch (code)
2280               {
2281               case LT_EXPR:
2282               case GE_EXPR:
2283                 primop1 = TYPE_MIN_VALUE (type);
2284                 val = 0;
2285                 break;
2286
2287               case LE_EXPR:
2288               case GT_EXPR:
2289                 primop1 = TYPE_MAX_VALUE (type);
2290                 val = 0;
2291                 break;
2292
2293               default:
2294                 break;
2295               }
2296           type = unsigned_type (type);
2297         }
2298
2299       if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2300         {
2301           /* This is the case of (char)x >?< 0x80, which people used to use
2302              expecting old C compilers to change the 0x80 into -0x80.  */
2303           if (val == boolean_false_node)
2304             warning ("comparison is always 0 due to limited range of data type");
2305           if (val == boolean_true_node)
2306             warning ("comparison is always 1 due to limited range of data type");
2307         }
2308
2309       if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
2310         {
2311           /* This is the case of (unsigned char)x >?< -1 or < 0.  */
2312           if (val == boolean_false_node)
2313             warning ("comparison is always 0 due to limited range of data type");
2314           if (val == boolean_true_node)
2315             warning ("comparison is always 1 due to limited range of data type");
2316         }
2317
2318       if (val != 0)
2319         {
2320           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2321           if (TREE_SIDE_EFFECTS (primop0))
2322             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2323           return val;
2324         }
2325
2326       /* Value is not predetermined, but do the comparison
2327          in the type of the operand that is not constant.
2328          TYPE is already properly set.  */
2329     }
2330   else if (real1 && real2
2331            && (TYPE_PRECISION (TREE_TYPE (primop0))
2332                == TYPE_PRECISION (TREE_TYPE (primop1))))
2333     type = TREE_TYPE (primop0);
2334
2335   /* If args' natural types are both narrower than nominal type
2336      and both extend in the same manner, compare them
2337      in the type of the wider arg.
2338      Otherwise must actually extend both to the nominal
2339      common type lest different ways of extending
2340      alter the result.
2341      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2342
2343   else if (unsignedp0 == unsignedp1 && real1 == real2
2344            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2345            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2346     {
2347       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2348       type = signed_or_unsigned_type (unsignedp0
2349                                       || TREE_UNSIGNED (*restype_ptr),
2350                                       type);
2351       /* Make sure shorter operand is extended the right way
2352          to match the longer operand.  */
2353       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
2354                          primop0);
2355       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
2356                          primop1);
2357     }
2358   else
2359     {
2360       /* Here we must do the comparison on the nominal type
2361          using the args exactly as we received them.  */
2362       type = *restype_ptr;
2363       primop0 = op0;
2364       primop1 = op1;
2365
2366       if (!real1 && !real2 && integer_zerop (primop1)
2367           && TREE_UNSIGNED (*restype_ptr))
2368         {
2369           tree value = 0;
2370           switch (code)
2371             {
2372             case GE_EXPR:
2373               /* All unsigned values are >= 0, so we warn if extra warnings
2374                  are requested.  However, if OP0 is a constant that is
2375                  >= 0, the signedness of the comparison isn't an issue,
2376                  so suppress the warning.  */
2377               if (extra_warnings
2378                   && ! (TREE_CODE (primop0) == INTEGER_CST
2379                         && ! TREE_OVERFLOW (convert (signed_type (type),
2380                                                      primop0))))
2381                 warning ("unsigned value >= 0 is always 1");
2382               value = boolean_true_node;
2383               break;
2384
2385             case LT_EXPR:
2386               if (extra_warnings
2387                   && ! (TREE_CODE (primop0) == INTEGER_CST
2388                         && ! TREE_OVERFLOW (convert (signed_type (type),
2389                                                      primop0))))
2390                 warning ("unsigned value < 0 is always 0");
2391               value = boolean_false_node;
2392               break;
2393
2394             default:
2395               break;
2396             }
2397
2398           if (value != 0)
2399             {
2400               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2401               if (TREE_SIDE_EFFECTS (primop0))
2402                 return build (COMPOUND_EXPR, TREE_TYPE (value),
2403                               primop0, value);
2404               return value;
2405             }
2406         }
2407     }
2408
2409   *op0_ptr = convert (type, primop0);
2410   *op1_ptr = convert (type, primop1);
2411
2412   *restype_ptr = boolean_type_node;
2413
2414   return 0;
2415 }
2416 \f
2417 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2418    or validate its data type for an `if' or `while' statement or ?..: exp.
2419
2420    This preparation consists of taking the ordinary
2421    representation of an expression expr and producing a valid tree
2422    boolean expression describing whether expr is nonzero.  We could
2423    simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2424    but we optimize comparisons, &&, ||, and !.
2425
2426    The resulting type should always be `boolean_type_node'.  */
2427
2428 tree
2429 truthvalue_conversion (expr)
2430      tree expr;
2431 {
2432   if (TREE_CODE (expr) == ERROR_MARK)
2433     return expr;
2434
2435 #if 0 /* This appears to be wrong for C++.  */
2436   /* These really should return error_mark_node after 2.4 is stable.
2437      But not all callers handle ERROR_MARK properly.  */
2438   switch (TREE_CODE (TREE_TYPE (expr)))
2439     {
2440     case RECORD_TYPE:
2441       error ("struct type value used where scalar is required");
2442       return boolean_false_node;
2443
2444     case UNION_TYPE:
2445       error ("union type value used where scalar is required");
2446       return boolean_false_node;
2447
2448     case ARRAY_TYPE:
2449       error ("array type value used where scalar is required");
2450       return boolean_false_node;
2451
2452     default:
2453       break;
2454     }
2455 #endif /* 0 */
2456
2457   switch (TREE_CODE (expr))
2458     {
2459       /* It is simpler and generates better code to have only TRUTH_*_EXPR
2460          or comparison expressions as truth values at this level.  */
2461 #if 0
2462     case COMPONENT_REF:
2463       /* A one-bit unsigned bit-field is already acceptable.  */
2464       if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
2465           && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
2466         return expr;
2467       break;
2468 #endif
2469
2470     case EQ_EXPR:
2471       /* It is simpler and generates better code to have only TRUTH_*_EXPR
2472          or comparison expressions as truth values at this level.  */
2473 #if 0
2474       if (integer_zerop (TREE_OPERAND (expr, 1)))
2475         return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
2476 #endif
2477     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2478     case TRUTH_ANDIF_EXPR:
2479     case TRUTH_ORIF_EXPR:
2480     case TRUTH_AND_EXPR:
2481     case TRUTH_OR_EXPR:
2482     case TRUTH_XOR_EXPR:
2483     case TRUTH_NOT_EXPR:
2484       TREE_TYPE (expr) = boolean_type_node;
2485       return expr;
2486
2487     case ERROR_MARK:
2488       return expr;
2489
2490     case INTEGER_CST:
2491       return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2492
2493     case REAL_CST:
2494       return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2495
2496     case ADDR_EXPR:
2497       /* If we are taking the address of a external decl, it might be zero
2498          if it is weak, so we cannot optimize.  */
2499       if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (expr, 0))) == 'd'
2500           && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2501         break;
2502
2503       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2504         return build (COMPOUND_EXPR, boolean_type_node,
2505                       TREE_OPERAND (expr, 0), boolean_true_node);
2506       else
2507         return boolean_true_node;
2508
2509     case COMPLEX_EXPR:
2510       return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2511                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2512                               truthvalue_conversion (TREE_OPERAND (expr, 0)),
2513                               truthvalue_conversion (TREE_OPERAND (expr, 1)),
2514                               0);
2515
2516     case NEGATE_EXPR:
2517     case ABS_EXPR:
2518     case FLOAT_EXPR:
2519     case FFS_EXPR:
2520       /* These don't change whether an object is non-zero or zero.  */
2521       return truthvalue_conversion (TREE_OPERAND (expr, 0));
2522
2523     case LROTATE_EXPR:
2524     case RROTATE_EXPR:
2525       /* These don't change whether an object is zero or non-zero, but
2526          we can't ignore them if their second arg has side-effects.  */
2527       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2528         return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2529                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
2530       else
2531         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2532
2533     case COND_EXPR:
2534       /* Distribute the conversion into the arms of a COND_EXPR.  */
2535       return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2536                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
2537                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
2538
2539     case CONVERT_EXPR:
2540       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2541          since that affects how `default_conversion' will behave.  */
2542       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2543           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2544         break;
2545       /* fall through...  */
2546     case NOP_EXPR:
2547       /* If this is widening the argument, we can ignore it.  */
2548       if (TYPE_PRECISION (TREE_TYPE (expr))
2549           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2550         return truthvalue_conversion (TREE_OPERAND (expr, 0));
2551       break;
2552
2553     case MINUS_EXPR:
2554       /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2555          this case.  */
2556       if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2557           && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2558         break;
2559       /* fall through...  */
2560     case BIT_XOR_EXPR:
2561       /* This and MINUS_EXPR can be changed into a comparison of the
2562          two objects.  */
2563       if (TREE_TYPE (TREE_OPERAND (expr, 0))
2564           == TREE_TYPE (TREE_OPERAND (expr, 1)))
2565         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2566                                 TREE_OPERAND (expr, 1), 1);
2567       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2568                               fold (build1 (NOP_EXPR,
2569                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
2570                                             TREE_OPERAND (expr, 1))), 1);
2571
2572     case BIT_AND_EXPR:
2573       if (integer_onep (TREE_OPERAND (expr, 1))
2574           && TREE_TYPE (expr) != boolean_type_node)
2575         /* Using convert here would cause infinite recursion.  */
2576         return build1 (NOP_EXPR, boolean_type_node, expr);
2577       break;
2578
2579     case MODIFY_EXPR:
2580       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2581         warning ("suggest parentheses around assignment used as truth value");
2582       break;
2583
2584     default:
2585       break;
2586     }
2587
2588   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2589     return (build_binary_op
2590             ((TREE_SIDE_EFFECTS (expr)
2591               ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2592              truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)),
2593              truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)),
2594              0));
2595
2596   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2597 }
2598 \f
2599 /* Read the rest of a #-directive from input stream FINPUT.
2600    In normal use, the directive name and the white space after it
2601    have already been read, so they won't be included in the result.
2602    We allow for the fact that the directive line may contain
2603    a newline embedded within a character or string literal which forms
2604    a part of the directive.
2605
2606    The value is a string in a reusable buffer.  It remains valid
2607    only until the next time this function is called.
2608
2609    The terminating character ('\n' or EOF) is left in FINPUT for the
2610    caller to re-read.  */
2611
2612 char *
2613 get_directive_line (finput)
2614      register FILE *finput;
2615 {
2616   static char *directive_buffer = NULL;
2617   static unsigned buffer_length = 0;
2618   register char *p;
2619   register char *buffer_limit;
2620   register int looking_for = 0;
2621   register int char_escaped = 0;
2622
2623   if (buffer_length == 0)
2624     {
2625       directive_buffer = (char *)xmalloc (128);
2626       buffer_length = 128;
2627     }
2628
2629   buffer_limit = &directive_buffer[buffer_length];
2630
2631   for (p = directive_buffer; ; )
2632     {
2633       int c;
2634
2635       /* Make buffer bigger if it is full.  */
2636       if (p >= buffer_limit)
2637         {
2638           register unsigned bytes_used = (p - directive_buffer);
2639
2640           buffer_length *= 2;
2641           directive_buffer
2642             = (char *)xrealloc (directive_buffer, buffer_length);
2643           p = &directive_buffer[bytes_used];
2644           buffer_limit = &directive_buffer[buffer_length];
2645         }
2646
2647       c = getc (finput);
2648
2649       /* Discard initial whitespace.  */
2650       if ((c == ' ' || c == '\t') && p == directive_buffer)
2651         continue;
2652
2653       /* Detect the end of the directive.  */
2654       if (looking_for == 0
2655           && (c == '\n' || c == EOF))
2656         {
2657           ungetc (c, finput);
2658           c = '\0';
2659         }
2660
2661       *p++ = c;
2662
2663       if (c == 0)
2664         return directive_buffer;
2665
2666       /* Handle string and character constant syntax.  */
2667       if (looking_for)
2668         {
2669           if (looking_for == c && !char_escaped)
2670             looking_for = 0;    /* Found terminator... stop looking.  */
2671         }
2672       else
2673         if (c == '\'' || c == '"')
2674           looking_for = c;      /* Don't stop buffering until we see another
2675                                    another one of these (or an EOF).  */
2676
2677       /* Handle backslash.  */
2678       char_escaped = (c == '\\' && ! char_escaped);
2679     }
2680 }
2681 \f
2682 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2683    down to the element type of an array.  */
2684
2685 tree
2686 c_build_type_variant (type, constp, volatilep)
2687      tree type;
2688      int constp, volatilep;
2689 {
2690   if (TREE_CODE (type) == ARRAY_TYPE)
2691     return build_array_type (c_build_type_variant (TREE_TYPE (type),
2692                                                    constp, volatilep),
2693                              TYPE_DOMAIN (type));
2694   return build_type_variant (type, constp, volatilep);
2695 }