gcc/c-common.c

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