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