gcc/c-common.c

   1 /* Subroutines shared by all languages that are variants of C.
   2    Copyright (C) 1992 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 <stdio.h>
  26
  27 #undef NULL
  28 #define NULL 0
  29
  30 /* Given a chain of STRING_CST nodes,
  31    concatenate them into one STRING_CST
  32    and give it a suitable array-of-chars data type.  */
  33
  34 tree
  35 combine_strings (strings)
  36      tree strings;
  37 {
  38   register tree value, t;
  39   register int length = 1;
  40   int wide_length = 0;
  41   int wide_flag = 0;
  42   int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
  43   int nchars;
  44
  45   if (TREE_CHAIN (strings))
  46     {
  47       /* More than one in the chain, so concatenate.  */
  48       register char *p, *q;
  49
  50       /* Don't include the \0 at the end of each substring,
  51          except for the last one.
  52          Count wide strings and ordinary strings separately.  */
  53       for (t = strings; t; t = TREE_CHAIN (t))
  54         {
  55           if (TREE_TYPE (t) == wchar_array_type_node)
  56             {
  57               wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
  58               wide_flag = 1;
  59             }
  60           else
  61             length += (TREE_STRING_LENGTH (t) - 1);
  62         }
  63
  64       /* If anything is wide, the non-wides will be converted,
  65          which makes them take more space.  */
  66       if (wide_flag)
  67         length = length * wchar_bytes + wide_length;
  68
  69       p = savealloc (length);
  70
  71       /* Copy the individual strings into the new combined string.
  72          If the combined string is wide, convert the chars to ints
  73          for any individual strings that are not wide.  */
  74
  75       q = p;
  76       for (t = strings; t; t = TREE_CHAIN (t))
  77         {
  78           int len = (TREE_STRING_LENGTH (t)
  79                      - ((TREE_TYPE (t) == wchar_array_type_node)
  80                         ? wchar_bytes : 1));
  81           if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
  82             {
  83               bcopy (TREE_STRING_POINTER (t), q, len);
  84               q += len;
  85             }
  86           else
  87             {
  88               int i;
  89               for (i = 0; i < len; i++)
  90                 ((int *) q)[i] = TREE_STRING_POINTER (t)[i];
  91               q += len * wchar_bytes;
  92             }
  93         }
  94       if (wide_flag)
  95         {
  96           int i;
  97           for (i = 0; i < wchar_bytes; i++)
  98             *q++ = 0;
  99         }
 100       else
 101         *q = 0;
 102
 103       value = make_node (STRING_CST);
 104       TREE_STRING_POINTER (value) = p;
 105       TREE_STRING_LENGTH (value) = length;
 106       TREE_CONSTANT (value) = 1;
 107     }
 108   else
 109     {
 110       value = strings;
 111       length = TREE_STRING_LENGTH (value);
 112       if (TREE_TYPE (value) == wchar_array_type_node)
 113         wide_flag = 1;
 114     }
 115
 116   /* Compute the number of elements, for the array type.  */
 117   nchars = wide_flag ? length / wchar_bytes : length;
 118
 119   /* Create the array type for the string constant.
 120      -Wwrite-strings says make the string constant an array of const char
 121      so that copying it to a non-const pointer will get a warning.  */
 122   if (warn_write_strings
 123       && (! flag_traditional  && ! flag_writable_strings))
 124     {
 125       tree elements
 126         = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
 127                               1, 0);
 128       TREE_TYPE (value)
 129         = build_array_type (elements,
 130                             build_index_type (build_int_2 (nchars - 1, 0)));
 131     }
 132   else
 133     TREE_TYPE (value)
 134       = build_array_type (wide_flag ? wchar_type_node : char_type_node,
 135                           build_index_type (build_int_2 (nchars - 1, 0)));
 136   TREE_CONSTANT (value) = 1;
 137   TREE_STATIC (value) = 1;
 138   return value;
 139 }
 140 \f
 141 /* Process the attributes listed in ATTRIBUTES
 142    and install them in DECL.  */
 143
 144 void
 145 decl_attributes (decl, attributes)
 146      tree decl, attributes;
 147 {
 148   tree a;
 149   for (a = attributes; a; a = TREE_CHAIN (a))
 150     if (TREE_VALUE (a) != 0
 151         && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 152         && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned"))
 153       {
 154         int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a)))
 155                     * BITS_PER_UNIT;
 156
 157         if (exact_log2 (align) == -1)
 158           warning_with_decl (decl,
 159                         "requested alignment of `%s' is not a power of 2");
 160         else if (TREE_CODE (decl) != VAR_DECL
 161                  && TREE_CODE (decl) != FIELD_DECL)
 162           warning_with_decl (decl,
 163                 "alignment specified for `%s' which is not a variable");
 164
 165         /* ??? The maximum alignment gcc can currently handle is 16 bytes!
 166            We should change the representation to be the log of the
 167            actual alignment since we only handle powers of 2 anyway.  */
 168         else if (align > 255)
 169           warning_with_decl (decl,
 170                 "requested alignment of `%s' exceeds compiler limits");
 171         else
 172           DECL_ALIGN (decl) = align;
 173       }
 174     else if (TREE_VALUE (a) != 0
 175              && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 176              && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("packed"))
 177       {
 178         if (TREE_CODE (decl) == FIELD_DECL)
 179           DECL_PACKED (decl) = 1;
 180       }
 181     else if (TREE_VALUE (a) != 0
 182         && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
 183         && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format"))
 184       {
 185         tree list = TREE_VALUE (TREE_VALUE (a));
 186         tree format_type = TREE_PURPOSE (list);
 187         int format_num = TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list)));
 188         int first_arg_num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
 189         int is_scan;
 190
 191         if (TREE_CODE (decl) != FUNCTION_DECL)
 192           {
 193             warning_with_decl (decl,
 194                 "argument format specified for non-function `%s'");
 195             return;
 196           }
 197
 198         if (format_type == get_identifier ("printf"))
 199           is_scan = 0;
 200         else if (format_type == get_identifier ("scanf"))
 201           is_scan = 1;
 202         else
 203           {
 204             warning_with_decl (decl,"unrecognized format specifier for `%s'");
 205             return;
 206           }
 207
 208         if (first_arg_num != 0 && first_arg_num <= format_num)
 209           {
 210             warning_with_decl (decl,
 211                 "format string arg follows the args to be formatted, for `%s'");
 212             return;
 213           }
 214
 215         record_format_info (DECL_NAME (decl), is_scan, format_num,
 216                             first_arg_num);
 217       }
 218 }
 219 \f
 220 void
 221 c_expand_expr_stmt (expr)
 222      tree expr;
 223 {
 224   /* Do default conversion if safe and possibly important,
 225      in case within ({...}).  */
 226   if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
 227       || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
 228     expr = default_conversion (expr);
 229
 230   if (TREE_TYPE (expr) != error_mark_node
 231       && TYPE_SIZE (TREE_TYPE (expr)) == 0
 232       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
 233     error ("expression statement has incomplete type");
 234
 235   expand_expr_stmt (expr);
 236 }
 237 \f
 238 /* Validate the expression after `case' and apply default promotions.  */
 239
 240 tree
 241 check_case_value (value)
 242      tree value;
 243 {
 244   if (value == NULL_TREE)
 245     return value;
 246
 247   /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue.  */
 248   if (TREE_CODE (value) == NON_LVALUE_EXPR)
 249     value = TREE_OPERAND (value, 0);
 250
 251   if (TREE_CODE (value) != INTEGER_CST
 252       && value != error_mark_node)
 253     {
 254       error ("case label does not reduce to an integer constant");
 255       value = error_mark_node;
 256     }
 257   else
 258     /* Promote char or short to int.  */
 259     value = default_conversion (value);
 260
 261   return value;
 262 }
 263 \f
 264 /* Return an integer type with BITS bits of precision,
 265    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 266
 267 tree
 268 type_for_size (bits, unsignedp)
 269      unsigned bits;
 270      int unsignedp;
 271 {
 272   if (bits <= TYPE_PRECISION (signed_char_type_node))
 273     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 274
 275   if (bits <= TYPE_PRECISION (short_integer_type_node))
 276     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 277
 278   if (bits <= TYPE_PRECISION (integer_type_node))
 279     return unsignedp ? unsigned_type_node : integer_type_node;
 280
 281   if (bits <= TYPE_PRECISION (long_integer_type_node))
 282     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 283
 284   if (bits <= TYPE_PRECISION (long_long_integer_type_node))
 285     return (unsignedp ? long_long_unsigned_type_node
 286             : long_long_integer_type_node);
 287
 288   return 0;
 289 }
 290
 291 /* Return a data type that has machine mode MODE.
 292    If the mode is an integer,
 293    then UNSIGNEDP selects between signed and unsigned types.  */
 294
 295 tree
 296 type_for_mode (mode, unsignedp)
 297      enum machine_mode mode;
 298      int unsignedp;
 299 {
 300   if (mode == TYPE_MODE (signed_char_type_node))
 301     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 302
 303   if (mode == TYPE_MODE (short_integer_type_node))
 304     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 305
 306   if (mode == TYPE_MODE (integer_type_node))
 307     return unsignedp ? unsigned_type_node : integer_type_node;
 308
 309   if (mode == TYPE_MODE (long_integer_type_node))
 310     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 311
 312   if (mode == TYPE_MODE (long_long_integer_type_node))
 313     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
 314
 315   if (mode == TYPE_MODE (float_type_node))
 316     return float_type_node;
 317
 318   if (mode == TYPE_MODE (double_type_node))
 319     return double_type_node;
 320
 321   if (mode == TYPE_MODE (long_double_type_node))
 322     return long_double_type_node;
 323
 324   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
 325     return build_pointer_type (char_type_node);
 326
 327   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
 328     return build_pointer_type (integer_type_node);
 329
 330   return 0;
 331 }
 332 \f
 333 /* Print an error message for invalid operands to arith operation CODE.
 334    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
 335
 336 void
 337 binary_op_error (code)
 338      enum tree_code code;
 339 {
 340   register char *opname;
 341   switch (code)
 342     {
 343     case NOP_EXPR:
 344       error ("invalid truth-value expression");
 345       return;
 346
 347     case PLUS_EXPR:
 348       opname = "+"; break;
 349     case MINUS_EXPR:
 350       opname = "-"; break;
 351     case MULT_EXPR:
 352       opname = "*"; break;
 353     case MAX_EXPR:
 354       opname = "max"; break;
 355     case MIN_EXPR:
 356       opname = "min"; break;
 357     case EQ_EXPR:
 358       opname = "=="; break;
 359     case NE_EXPR:
 360       opname = "!="; break;
 361     case LE_EXPR:
 362       opname = "<="; break;
 363     case GE_EXPR:
 364       opname = ">="; break;
 365     case LT_EXPR:
 366       opname = "<"; break;
 367     case GT_EXPR:
 368       opname = ">"; break;
 369     case LSHIFT_EXPR:
 370       opname = "<<"; break;
 371     case RSHIFT_EXPR:
 372       opname = ">>"; break;
 373     case TRUNC_MOD_EXPR:
 374       opname = "%"; break;
 375     case TRUNC_DIV_EXPR:
 376       opname = "/"; break;
 377     case BIT_AND_EXPR:
 378       opname = "&"; break;
 379     case BIT_IOR_EXPR:
 380       opname = "|"; break;
 381     case TRUTH_ANDIF_EXPR:
 382       opname = "&&"; break;
 383     case TRUTH_ORIF_EXPR:
 384       opname = "||"; break;
 385     case BIT_XOR_EXPR:
 386       opname = "^"; break;
 387     }
 388   error ("invalid operands to binary %s", opname);
 389 }
 390 \f
 391 /* Subroutine of build_binary_op, used for comparison operations.
 392    See if the operands have both been converted from subword integer types
 393    and, if so, perhaps change them both back to their original type.
 394
 395    The arguments of this function are all pointers to local variables
 396    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
 397    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
 398
 399    If this function returns nonzero, it means that the comparison has
 400    a constant value.  What this function returns is an expression for
 401    that value.  */
 402
 403 tree
 404 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
 405      tree *op0_ptr, *op1_ptr;
 406      tree *restype_ptr;
 407      enum tree_code *rescode_ptr;
 408 {
 409   register tree type;
 410   tree op0 = *op0_ptr;
 411   tree op1 = *op1_ptr;
 412   int unsignedp0, unsignedp1;
 413   int real1, real2;
 414   tree primop0, primop1;
 415   enum tree_code code = *rescode_ptr;
 416
 417   /* Throw away any conversions to wider types
 418      already present in the operands.  */
 419
 420   primop0 = get_narrower (op0, &unsignedp0);
 421   primop1 = get_narrower (op1, &unsignedp1);
 422
 423   /* Handle the case that OP0 does not *contain* a conversion
 424      but it *requires* conversion to FINAL_TYPE.  */
 425
 426   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
 427     unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
 428   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
 429     unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
 430
 431   /* If one of the operands must be floated, we cannot optimize.  */
 432   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
 433   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
 434
 435   /* If first arg is constant, swap the args (changing operation
 436      so value is preserved), for canonicalization.  */
 437
 438   if (TREE_CONSTANT (primop0))
 439     {
 440       register tree tem = primop0;
 441       register int temi = unsignedp0;
 442       primop0 = primop1;
 443       primop1 = tem;
 444       tem = op0;
 445       op0 = op1;
 446       op1 = tem;
 447       *op0_ptr = op0;
 448       *op1_ptr = op1;
 449       unsignedp0 = unsignedp1;
 450       unsignedp1 = temi;
 451       temi = real1;
 452       real1 = real2;
 453       real2 = temi;
 454
 455       switch (code)
 456         {
 457         case LT_EXPR:
 458           code = GT_EXPR;
 459           break;
 460         case GT_EXPR:
 461           code = LT_EXPR;
 462           break;
 463         case LE_EXPR:
 464           code = GE_EXPR;
 465           break;
 466         case GE_EXPR:
 467           code = LE_EXPR;
 468           break;
 469         }
 470       *rescode_ptr = code;
 471     }
 472
 473   /* If comparing an integer against a constant more bits wide,
 474      maybe we can deduce a value of 1 or 0 independent of the data.
 475      Or else truncate the constant now
 476      rather than extend the variable at run time.
 477
 478      This is only interesting if the constant is the wider arg.
 479      Also, it is not safe if the constant is unsigned and the
 480      variable arg is signed, since in this case the variable
 481      would be sign-extended and then regarded as unsigned.
 482      Our technique fails in this case because the lowest/highest
 483      possible unsigned results don't follow naturally from the
 484      lowest/highest possible values of the variable operand.
 485      For just EQ_EXPR and NE_EXPR there is another technique that
 486      could be used: see if the constant can be faithfully represented
 487      in the other operand's type, by truncating it and reextending it
 488      and see if that preserves the constant's value.  */
 489
 490   if (!real1 && !real2
 491       && TREE_CODE (primop1) == INTEGER_CST
 492       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
 493     {
 494       int min_gt, max_gt, min_lt, max_lt;
 495       tree maxval, minval;
 496       /* 1 if comparison is nominally unsigned.  */
 497       int unsignedp = TREE_UNSIGNED (*restype_ptr);
 498       tree val;
 499
 500       type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
 501
 502       maxval = TYPE_MAX_VALUE (type);
 503       minval = TYPE_MIN_VALUE (type);
 504
 505       if (unsignedp && !unsignedp0)
 506         *restype_ptr = signed_type (*restype_ptr);
 507
 508       if (TREE_TYPE (primop1) != *restype_ptr)
 509         primop1 = convert (*restype_ptr, primop1);
 510       if (type != *restype_ptr)
 511         {
 512           minval = convert (*restype_ptr, minval);
 513           maxval = convert (*restype_ptr, maxval);
 514         }
 515
 516       if (unsignedp && unsignedp0)
 517         {
 518           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
 519           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
 520           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
 521           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
 522         }
 523       else
 524         {
 525           min_gt = INT_CST_LT (primop1, minval);
 526           max_gt = INT_CST_LT (primop1, maxval);
 527           min_lt = INT_CST_LT (minval, primop1);
 528           max_lt = INT_CST_LT (maxval, primop1);
 529         }
 530
 531       val = 0;
 532       /* This used to be a switch, but Genix compiler can't handle that.  */
 533       if (code == NE_EXPR)
 534         {
 535           if (max_lt || min_gt)
 536             val = integer_one_node;
 537         }
 538       else if (code == EQ_EXPR)
 539         {
 540           if (max_lt || min_gt)
 541             val = integer_zero_node;
 542         }
 543       else if (code == LT_EXPR)
 544         {
 545           if (max_lt)
 546             val = integer_one_node;
 547           if (!min_lt)
 548             val = integer_zero_node;
 549         }
 550       else if (code == GT_EXPR)
 551         {
 552           if (min_gt)
 553             val = integer_one_node;
 554           if (!max_gt)
 555             val = integer_zero_node;
 556         }
 557       else if (code == LE_EXPR)
 558         {
 559           if (!max_gt)
 560             val = integer_one_node;
 561           if (min_gt)
 562             val = integer_zero_node;
 563         }
 564       else if (code == GE_EXPR)
 565         {
 566           if (!min_lt)
 567             val = integer_one_node;
 568           if (max_lt)
 569             val = integer_zero_node;
 570         }
 571
 572       /* If primop0 was sign-extended and unsigned comparison specd,
 573          we did a signed comparison above using the signed type bounds.
 574          But the comparison we output must be unsigned.
 575
 576          Also, for inequalities, VAL is no good; but if the signed
 577          comparison had *any* fixed result, it follows that the
 578          unsigned comparison just tests the sign in reverse
 579          (positive values are LE, negative ones GE).
 580          So we can generate an unsigned comparison
 581          against an extreme value of the signed type.  */
 582
 583       if (unsignedp && !unsignedp0)
 584         {
 585           if (val != 0)
 586             switch (code)
 587               {
 588               case LT_EXPR:
 589               case GE_EXPR:
 590                 primop1 = TYPE_MIN_VALUE (type);
 591                 val = 0;
 592                 break;
 593
 594               case LE_EXPR:
 595               case GT_EXPR:
 596                 primop1 = TYPE_MAX_VALUE (type);
 597                 val = 0;
 598                 break;
 599               }
 600           type = unsigned_type (type);
 601         }
 602
 603       if (max_lt && !unsignedp0)
 604         {
 605           /* This is the case of (char)x >?< 0x80, which people used to use
 606              expecting old C compilers to change the 0x80 into -0x80.  */
 607           if (val == integer_zero_node)
 608             warning ("comparison is always 0 due to limited range of data type");
 609           if (val == integer_one_node)
 610             warning ("comparison is always 1 due to limited range of data type");
 611         }
 612
 613       if (min_gt && unsignedp0)
 614         {
 615           /* This is the case of (unsigned char)x >?< -1.  */
 616           if (val == integer_zero_node)
 617             warning ("comparison is always 0 due to limited range of data type");
 618           if (val == integer_one_node)
 619             warning ("comparison is always 1 due to limited range of data type");
 620         }
 621
 622       if (val != 0)
 623         {
 624           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
 625           if (TREE_SIDE_EFFECTS (primop0))
 626             return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
 627           return val;
 628         }
 629
 630       /* Value is not predetermined, but do the comparison
 631          in the type of the operand that is not constant.
 632          TYPE is already properly set.  */
 633     }
 634   else if (real1 && real2
 635            && TYPE_PRECISION (TREE_TYPE (primop0)) == TYPE_PRECISION (TREE_TYPE (primop1)))
 636     type = TREE_TYPE (primop0);
 637
 638   /* If args' natural types are both narrower than nominal type
 639      and both extend in the same manner, compare them
 640      in the type of the wider arg.
 641      Otherwise must actually extend both to the nominal
 642      common type lest different ways of extending
 643      alter the result.
 644      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
 645
 646   else if (unsignedp0 == unsignedp1 && real1 == real2
 647            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
 648            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
 649     {
 650       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
 651       type = signed_or_unsigned_type (unsignedp0
 652                                       || TREE_UNSIGNED (*restype_ptr),
 653                                       type);
 654       /* Make sure shorter operand is extended the right way
 655          to match the longer operand.  */
 656       primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
 657                          primop0);
 658       primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
 659                          primop1);
 660     }
 661   else
 662     {
 663       /* Here we must do the comparison on the nominal type
 664          using the args exactly as we received them.  */
 665       type = *restype_ptr;
 666       primop0 = op0;
 667       primop1 = op1;
 668
 669       if (!real1 && !real2 && integer_zerop (primop1)
 670           && TREE_UNSIGNED (TREE_TYPE (primop0)))
 671         {
 672           tree value = 0;
 673           switch (code)
 674             {
 675             case GE_EXPR:
 676               if (extra_warnings)
 677                 warning ("unsigned value >= 0 is always 1");
 678               value = integer_one_node;
 679               break;
 680
 681             case LT_EXPR:
 682               if (extra_warnings)
 683                 warning ("unsigned value < 0 is always 0");
 684               value = integer_zero_node;
 685             }
 686
 687           if (value != 0)
 688             {
 689               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
 690               if (TREE_SIDE_EFFECTS (primop0))
 691                 return build (COMPOUND_EXPR, TREE_TYPE (value),
 692                               primop0, value);
 693               return value;
 694             }
 695         }
 696     }
 697
 698   *op0_ptr = convert (type, primop0);
 699   *op1_ptr = convert (type, primop1);
 700
 701   *restype_ptr = integer_type_node;
 702
 703   return 0;
 704 }
 705 \f
 706 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
 707    or validate its data type for an `if' or `while' statement or ?..: exp.
 708
 709    This preparation consists of taking the ordinary
 710    representation of an expression expr and producing a valid tree
 711    boolean expression describing whether expr is nonzero.  We could
 712    simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
 713    but we optimize comparisons, &&, ||, and !.
 714
 715    The resulting type should always be `integer_type_node'.  */
 716
 717 tree
 718 truthvalue_conversion (expr)
 719      tree expr;
 720 {
 721   register enum tree_code code;
 722
 723   switch (TREE_CODE (expr))
 724     {
 725       /* It is simpler and generates better code to have only TRUTH_*_EXPR
 726          or comparison expressions as truth values at this level.  */
 727 #if 0
 728     case COMPONENT_REF:
 729       /* A one-bit unsigned bit-field is already acceptable.  */
 730       if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1)))
 731           && TREE_UNSIGNED (TREE_OPERAND (expr, 1)))
 732         return expr;
 733       break;
 734 #endif
 735
 736     case EQ_EXPR:
 737       /* It is simpler and generates better code to have only TRUTH_*_EXPR
 738          or comparison expressions as truth values at this level.  */
 739 #if 0
 740       if (integer_zerop (TREE_OPERAND (expr, 1)))
 741         return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0);
 742 #endif
 743     case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
 744     case TRUTH_ANDIF_EXPR:
 745     case TRUTH_ORIF_EXPR:
 746     case TRUTH_AND_EXPR:
 747     case TRUTH_OR_EXPR:
 748     case ERROR_MARK:
 749       return expr;
 750
 751     case INTEGER_CST:
 752       return integer_zerop (expr) ? integer_zero_node : integer_one_node;
 753
 754     case REAL_CST:
 755       return real_zerop (expr) ? integer_zero_node : integer_one_node;
 756
 757     case ADDR_EXPR:
 758       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
 759         return build (COMPOUND_EXPR, integer_type_node,
 760                       TREE_OPERAND (expr, 0), integer_one_node);
 761       else
 762         return integer_one_node;
 763
 764     case NEGATE_EXPR:
 765     case ABS_EXPR:
 766     case FLOAT_EXPR:
 767     case FFS_EXPR:
 768       /* These don't change whether an object is non-zero or zero.  */
 769       return truthvalue_conversion (TREE_OPERAND (expr, 0));
 770
 771     case LROTATE_EXPR:
 772     case RROTATE_EXPR:
 773       /* These don't change whether an object is zero or non-zero, but
 774          we can't ignore them if their second arg has side-effects.  */
 775       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
 776         return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1),
 777                       truthvalue_conversion (TREE_OPERAND (expr, 0)));
 778       else
 779         return truthvalue_conversion (TREE_OPERAND (expr, 0));
 780
 781     case COND_EXPR:
 782       /* Distribute the conversion into the arms of a COND_EXPR.  */
 783       return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0),
 784                           truthvalue_conversion (TREE_OPERAND (expr, 1)),
 785                           truthvalue_conversion (TREE_OPERAND (expr, 2))));
 786
 787     case CONVERT_EXPR:
 788       /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
 789          since that affects how `default_conversion' will behave.  */
 790       if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
 791           || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
 792         break;
 793       /* fall through... */
 794     case NOP_EXPR:
 795       /* If this is widening the argument, we can ignore it.  */
 796       if (TYPE_PRECISION (TREE_TYPE (expr))
 797           >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
 798         return truthvalue_conversion (TREE_OPERAND (expr, 0));
 799       break;
 800
 801     case BIT_XOR_EXPR:
 802     case MINUS_EXPR:
 803       /* These can be changed into a comparison of the two objects.  */
 804       if (TREE_TYPE (TREE_OPERAND (expr, 0))
 805           == TREE_TYPE (TREE_OPERAND (expr, 1)))
 806         return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
 807                                 TREE_OPERAND (expr, 1), 1);
 808       return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
 809                               fold (build1 (NOP_EXPR,
 810                                             TREE_TYPE (TREE_OPERAND (expr, 0)),
 811                                             TREE_OPERAND (expr, 1))), 1);
 812     }
 813
 814   return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
 815 }
 816 \f
 817 /* Read the rest of a #-directive from input stream FINPUT.
 818    In normal use, the directive name and the white space after it
 819    have already been read, so they won't be included in the result.
 820    We allow for the fact that the directive line may contain
 821    a newline embedded within a character or string literal which forms
 822    a part of the directive.
 823
 824    The value is a string in a reusable buffer.  It remains valid
 825    only until the next time this function is called.  */
 826
 827 char *
 828 get_directive_line (finput)
 829      register FILE *finput;
 830 {
 831   static char *directive_buffer = NULL;
 832   static unsigned buffer_length = 0;
 833   register char *p;
 834   register char *buffer_limit;
 835   register int looking_for = 0;
 836   register int char_escaped = 0;
 837
 838   if (buffer_length == 0)
 839     {
 840       directive_buffer = (char *)xmalloc (128);
 841       buffer_length = 128;
 842     }
 843
 844   buffer_limit = &directive_buffer[buffer_length];
 845
 846   for (p = directive_buffer; ; )
 847     {
 848       int c;
 849
 850       /* Make buffer bigger if it is full.  */
 851       if (p >= buffer_limit)
 852         {
 853           register unsigned bytes_used = (p - directive_buffer);
 854
 855           buffer_length *= 2;
 856           directive_buffer
 857             = (char *)xrealloc (directive_buffer, buffer_length);
 858           p = &directive_buffer[bytes_used];
 859           buffer_limit = &directive_buffer[buffer_length];
 860         }
 861
 862       c = getc (finput);
 863
 864       /* Discard initial whitespace.  */
 865       if ((c == ' ' || c == '\t') && p == directive_buffer)
 866         continue;
 867
 868       /* Detect the end of the directive.  */
 869       if (c == '\n' && looking_for == 0)
 870         {
 871           ungetc (c, finput);
 872           c = '\0';
 873         }
 874
 875       *p++ = c;
 876
 877       if (c == 0)
 878         return directive_buffer;
 879
 880       /* Handle string and character constant syntax.  */
 881       if (looking_for)
 882         {
 883           if (looking_for == c && !char_escaped)
 884             looking_for = 0;    /* Found terminator... stop looking.  */
 885         }
 886       else
 887         if (c == '\'' || c == '"')
 888           looking_for = c;      /* Don't stop buffering until we see another
 889                                    another one of these (or an EOF).  */
 890
 891       /* Handle backslash.  */
 892       char_escaped = (c == '\\' && ! char_escaped);
 893     }
 894 }