gcc/c-common.c

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