gcc/fold-const.c

   1 /* Fold a constant sub-tree into a single node for C-compiler
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /*@@ This file should be rewritten to use an arbitrary precision
  23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  25   @@ The routines that translate from the ap rep should
  26   @@ warn if precision et. al. is lost.
  27   @@ This would also make life easier when this technology is used
  28   @@ for cross-compilers.  */
  29
  30 /* The entry points in this file are fold, size_int_wide, size_binop
  31    and force_fit_type.
  32
  33    fold takes a tree as argument and returns a simplified tree.
  34
  35    size_binop takes a tree code for an arithmetic operation
  36    and two operands that are trees, and produces a tree for the
  37    result, assuming the type comes from `sizetype'.
  38
  39    size_int takes an integer value, and creates a tree constant
  40    with type from `sizetype'.
  41
  42    force_fit_type takes a constant and prior overflow indicator, and
  43    forces the value to fit the type.  It returns an overflow indicator.  */
  44
  45 #include "config.h"
  46 #include "system.h"
  47 #include <setjmp.h>
  48 #include "flags.h"
  49 #include "tree.h"
  50 #include "rtl.h"
  51 #include "tm_p.h"
  52 #include "toplev.h"
  53 #include "ggc.h"
  54
  55 static void encode              PARAMS ((HOST_WIDE_INT *,
  56                                          unsigned HOST_WIDE_INT,
  57                                          HOST_WIDE_INT));
  58 static void decode              PARAMS ((HOST_WIDE_INT *,
  59                                          unsigned HOST_WIDE_INT *,
  60                                          HOST_WIDE_INT *));
  61 static tree negate_expr         PARAMS ((tree));
  62 static tree split_tree          PARAMS ((tree, enum tree_code, tree *, tree *,
  63                                          int));
  64 static tree associate_trees     PARAMS ((tree, tree, enum tree_code, tree));
  65 static tree int_const_binop     PARAMS ((enum tree_code, tree, tree, int, int));
  66 static void const_binop_1       PARAMS ((PTR));
  67 static tree const_binop         PARAMS ((enum tree_code, tree, tree, int));
  68 static void fold_convert_1      PARAMS ((PTR));
  69 static tree fold_convert        PARAMS ((tree, tree));
  70 static enum tree_code invert_tree_comparison PARAMS ((enum tree_code));
  71 static enum tree_code swap_tree_comparison PARAMS ((enum tree_code));
  72 static int truth_value_p        PARAMS ((enum tree_code));
  73 static int operand_equal_for_comparison_p PARAMS ((tree, tree, tree));
  74 static int twoval_comparison_p  PARAMS ((tree, tree *, tree *, int *));
  75 static tree eval_subst          PARAMS ((tree, tree, tree, tree, tree));
  76 static tree omit_one_operand    PARAMS ((tree, tree, tree));
  77 static tree pedantic_omit_one_operand PARAMS ((tree, tree, tree));
  78 static tree distribute_bit_expr PARAMS ((enum tree_code, tree, tree, tree));
  79 static tree make_bit_field_ref  PARAMS ((tree, tree, int, int, int));
  80 static tree optimize_bit_field_compare PARAMS ((enum tree_code, tree,
  81                                                 tree, tree));
  82 static tree decode_field_reference PARAMS ((tree, HOST_WIDE_INT *,
  83                                             HOST_WIDE_INT *,
  84                                             enum machine_mode *, int *,
  85                                             int *, tree *, tree *));
  86 static int all_ones_mask_p      PARAMS ((tree, int));
  87 static int simple_operand_p     PARAMS ((tree));
  88 static tree range_binop         PARAMS ((enum tree_code, tree, tree, int,
  89                                          tree, int));
  90 static tree make_range          PARAMS ((tree, int *, tree *, tree *));
  91 static tree build_range_check   PARAMS ((tree, tree, int, tree, tree));
  92 static int merge_ranges         PARAMS ((int *, tree *, tree *, int, tree, tree,
  93                                        int, tree, tree));
  94 static tree fold_range_test     PARAMS ((tree));
  95 static tree unextend            PARAMS ((tree, int, int, tree));
  96 static tree fold_truthop        PARAMS ((enum tree_code, tree, tree, tree));
  97 static tree optimize_minmax_comparison PARAMS ((tree));
  98 static tree extract_muldiv      PARAMS ((tree, tree, enum tree_code, tree));
  99 static tree strip_compound_expr PARAMS ((tree, tree));
 100 static int multiple_of_p        PARAMS ((tree, tree, tree));
 101 static tree constant_boolean_node PARAMS ((int, tree));
 102 static int count_cond           PARAMS ((tree, int));
 103
 104 #ifndef BRANCH_COST
 105 #define BRANCH_COST 1
 106 #endif
 107
 108 #if defined(HOST_EBCDIC)
 109 /* bit 8 is significant in EBCDIC */
 110 #define CHARMASK 0xff
 111 #else
 112 #define CHARMASK 0x7f
 113 #endif
 114
 115 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 116    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 117    and SUM1.  Then this yields nonzero if overflow occurred during the
 118    addition.
 119
 120    Overflow occurs if A and B have the same sign, but A and SUM differ in
 121    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 122    sign.  */
 123 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 124 \f
 125 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
 126    We do that by representing the two-word integer in 4 words, with only
 127    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
 128    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
 129
 130 #define LOWPART(x) \
 131   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
 132 #define HIGHPART(x) \
 133   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
 134 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
 135
 136 /* Unpack a two-word integer into 4 words.
 137    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
 138    WORDS points to the array of HOST_WIDE_INTs.  */
 139
 140 static void
 141 encode (words, low, hi)
 142      HOST_WIDE_INT *words;
 143      unsigned HOST_WIDE_INT low;
 144      HOST_WIDE_INT hi;
 145 {
 146   words[0] = LOWPART (low);
 147   words[1] = HIGHPART (low);
 148   words[2] = LOWPART (hi);
 149   words[3] = HIGHPART (hi);
 150 }
 151
 152 /* Pack an array of 4 words into a two-word integer.
 153    WORDS points to the array of words.
 154    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
 155
 156 static void
 157 decode (words, low, hi)
 158      HOST_WIDE_INT *words;
 159      unsigned HOST_WIDE_INT *low;
 160      HOST_WIDE_INT *hi;
 161 {
 162   *low = words[0] + words[1] * BASE;
 163   *hi = words[2] + words[3] * BASE;
 164 }
 165 \f
 166 /* Make the integer constant T valid for its type by setting to 0 or 1 all
 167    the bits in the constant that don't belong in the type.
 168
 169    Return 1 if a signed overflow occurs, 0 otherwise.  If OVERFLOW is
 170    nonzero, a signed overflow has already occurred in calculating T, so
 171    propagate it.
 172
 173    Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
 174    if it exists.  */
 175
 176 int
 177 force_fit_type (t, overflow)
 178      tree t;
 179      int overflow;
 180 {
 181   unsigned HOST_WIDE_INT low;
 182   HOST_WIDE_INT high;
 183   unsigned int prec;
 184
 185   if (TREE_CODE (t) == REAL_CST)
 186     {
 187 #ifdef CHECK_FLOAT_VALUE
 188       CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t)), TREE_REAL_CST (t),
 189                          overflow);
 190 #endif
 191       return overflow;
 192     }
 193
 194   else if (TREE_CODE (t) != INTEGER_CST)
 195     return overflow;
 196
 197   low = TREE_INT_CST_LOW (t);
 198   high = TREE_INT_CST_HIGH (t);
 199
 200   if (POINTER_TYPE_P (TREE_TYPE (t)))
 201     prec = POINTER_SIZE;
 202   else
 203     prec = TYPE_PRECISION (TREE_TYPE (t));
 204
 205   /* First clear all bits that are beyond the type's precision.  */
 206
 207   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 208     ;
 209   else if (prec > HOST_BITS_PER_WIDE_INT)
 210     TREE_INT_CST_HIGH (t)
 211       &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 212   else
 213     {
 214       TREE_INT_CST_HIGH (t) = 0;
 215       if (prec < HOST_BITS_PER_WIDE_INT)
 216         TREE_INT_CST_LOW (t) &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
 217     }
 218
 219   /* Unsigned types do not suffer sign extension or overflow.  */
 220   if (TREE_UNSIGNED (TREE_TYPE (t)))
 221     return overflow;
 222
 223   /* If the value's sign bit is set, extend the sign.  */
 224   if (prec != 2 * HOST_BITS_PER_WIDE_INT
 225       && (prec > HOST_BITS_PER_WIDE_INT
 226           ? 0 != (TREE_INT_CST_HIGH (t)
 227                   & ((HOST_WIDE_INT) 1
 228                      << (prec - HOST_BITS_PER_WIDE_INT - 1)))
 229           : 0 != (TREE_INT_CST_LOW (t)
 230                   & ((unsigned HOST_WIDE_INT) 1 << (prec - 1)))))
 231     {
 232       /* Value is negative:
 233          set to 1 all the bits that are outside this type's precision.  */
 234       if (prec > HOST_BITS_PER_WIDE_INT)
 235         TREE_INT_CST_HIGH (t)
 236           |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 237       else
 238         {
 239           TREE_INT_CST_HIGH (t) = -1;
 240           if (prec < HOST_BITS_PER_WIDE_INT)
 241             TREE_INT_CST_LOW (t) |= ((unsigned HOST_WIDE_INT) (-1) << prec);
 242         }
 243     }
 244
 245   /* Return nonzero if signed overflow occurred.  */
 246   return
 247     ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
 248      != 0);
 249 }
 250 \f
 251 /* Add two doubleword integers with doubleword result.
 252    Each argument is given as two `HOST_WIDE_INT' pieces.
 253    One argument is L1 and H1; the other, L2 and H2.
 254    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 255
 256 int
 257 add_double (l1, h1, l2, h2, lv, hv)
 258      unsigned HOST_WIDE_INT l1, l2;
 259      HOST_WIDE_INT h1, h2;
 260      unsigned HOST_WIDE_INT *lv;
 261      HOST_WIDE_INT *hv;
 262 {
 263   unsigned HOST_WIDE_INT l;
 264   HOST_WIDE_INT h;
 265
 266   l = l1 + l2;
 267   h = h1 + h2 + (l < l1);
 268
 269   *lv = l;
 270   *hv = h;
 271   return OVERFLOW_SUM_SIGN (h1, h2, h);
 272 }
 273
 274 /* Negate a doubleword integer with doubleword result.
 275    Return nonzero if the operation overflows, assuming it's signed.
 276    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
 277    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 278
 279 int
 280 neg_double (l1, h1, lv, hv)
 281      unsigned HOST_WIDE_INT l1;
 282      HOST_WIDE_INT h1;
 283      unsigned HOST_WIDE_INT *lv;
 284      HOST_WIDE_INT *hv;
 285 {
 286   if (l1 == 0)
 287     {
 288       *lv = 0;
 289       *hv = - h1;
 290       return (*hv & h1) < 0;
 291     }
 292   else
 293     {
 294       *lv = -l1;
 295       *hv = ~h1;
 296       return 0;
 297     }
 298 }
 299 \f
 300 /* Multiply two doubleword integers with doubleword result.
 301    Return nonzero if the operation overflows, assuming it's signed.
 302    Each argument is given as two `HOST_WIDE_INT' pieces.
 303    One argument is L1 and H1; the other, L2 and H2.
 304    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 305
 306 int
 307 mul_double (l1, h1, l2, h2, lv, hv)
 308      unsigned HOST_WIDE_INT l1, l2;
 309      HOST_WIDE_INT h1, h2;
 310      unsigned HOST_WIDE_INT *lv;
 311      HOST_WIDE_INT *hv;
 312 {
 313   HOST_WIDE_INT arg1[4];
 314   HOST_WIDE_INT arg2[4];
 315   HOST_WIDE_INT prod[4 * 2];
 316   register unsigned HOST_WIDE_INT carry;
 317   register int i, j, k;
 318   unsigned HOST_WIDE_INT toplow, neglow;
 319   HOST_WIDE_INT tophigh, neghigh;
 320
 321   encode (arg1, l1, h1);
 322   encode (arg2, l2, h2);
 323
 324   bzero ((char *) prod, sizeof prod);
 325
 326   for (i = 0; i < 4; i++)
 327     {
 328       carry = 0;
 329       for (j = 0; j < 4; j++)
 330         {
 331           k = i + j;
 332           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
 333           carry += arg1[i] * arg2[j];
 334           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
 335           carry += prod[k];
 336           prod[k] = LOWPART (carry);
 337           carry = HIGHPART (carry);
 338         }
 339       prod[i + 4] = carry;
 340     }
 341
 342   decode (prod, lv, hv);        /* This ignores prod[4] through prod[4*2-1] */
 343
 344   /* Check for overflow by calculating the top half of the answer in full;
 345      it should agree with the low half's sign bit.  */
 346   decode (prod + 4, &toplow, &tophigh);
 347   if (h1 < 0)
 348     {
 349       neg_double (l2, h2, &neglow, &neghigh);
 350       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 351     }
 352   if (h2 < 0)
 353     {
 354       neg_double (l1, h1, &neglow, &neghigh);
 355       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 356     }
 357   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
 358 }
 359 \f
 360 /* Shift the doubleword integer in L1, H1 left by COUNT places
 361    keeping only PREC bits of result.
 362    Shift right if COUNT is negative.
 363    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 364    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 365
 366 void
 367 lshift_double (l1, h1, count, prec, lv, hv, arith)
 368      unsigned HOST_WIDE_INT l1;
 369      HOST_WIDE_INT h1, count;
 370      unsigned int prec;
 371      unsigned HOST_WIDE_INT *lv;
 372      HOST_WIDE_INT *hv;
 373      int arith;
 374 {
 375   if (count < 0)
 376     {
 377       rshift_double (l1, h1, -count, prec, lv, hv, arith);
 378       return;
 379     }
 380
 381 #ifdef SHIFT_COUNT_TRUNCATED
 382   if (SHIFT_COUNT_TRUNCATED)
 383     count %= prec;
 384 #endif
 385
 386   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 387     {
 388       /* Shifting by the host word size is undefined according to the
 389          ANSI standard, so we must handle this as a special case.  */
 390       *hv = 0;
 391       *lv = 0;
 392     }
 393   else if (count >= HOST_BITS_PER_WIDE_INT)
 394     {
 395       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
 396       *lv = 0;
 397     }
 398   else
 399     {
 400       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
 401              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
 402       *lv = l1 << count;
 403     }
 404 }
 405
 406 /* Shift the doubleword integer in L1, H1 right by COUNT places
 407    keeping only PREC bits of result.  COUNT must be positive.
 408    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 409    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 410
 411 void
 412 rshift_double (l1, h1, count, prec, lv, hv, arith)
 413      unsigned HOST_WIDE_INT l1;
 414      HOST_WIDE_INT h1, count;
 415      unsigned int prec ATTRIBUTE_UNUSED;
 416      unsigned HOST_WIDE_INT *lv;
 417      HOST_WIDE_INT *hv;
 418      int arith;
 419 {
 420   unsigned HOST_WIDE_INT signmask;
 421
 422   signmask = (arith
 423               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
 424               : 0);
 425
 426 #ifdef SHIFT_COUNT_TRUNCATED
 427   if (SHIFT_COUNT_TRUNCATED)
 428     count %= prec;
 429 #endif
 430
 431   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 432     {
 433       /* Shifting by the host word size is undefined according to the
 434          ANSI standard, so we must handle this as a special case.  */
 435       *hv = signmask;
 436       *lv = signmask;
 437     }
 438   else if (count >= HOST_BITS_PER_WIDE_INT)
 439     {
 440       *hv = signmask;
 441       *lv = ((signmask << (2 * HOST_BITS_PER_WIDE_INT - count - 1) << 1)
 442              | ((unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT)));
 443     }
 444   else
 445     {
 446       *lv = ((l1 >> count)
 447              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
 448       *hv = ((signmask << (HOST_BITS_PER_WIDE_INT - count))
 449              | ((unsigned HOST_WIDE_INT) h1 >> count));
 450     }
 451 }
 452 \f
 453 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 454    keeping only PREC bits of result.
 455    Rotate right if COUNT is negative.
 456    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 457
 458 void
 459 lrotate_double (l1, h1, count, prec, lv, hv)
 460      unsigned HOST_WIDE_INT l1;
 461      HOST_WIDE_INT h1, count;
 462      unsigned int prec;
 463      unsigned HOST_WIDE_INT *lv;
 464      HOST_WIDE_INT *hv;
 465 {
 466   unsigned HOST_WIDE_INT s1l, s2l;
 467   HOST_WIDE_INT s1h, s2h;
 468
 469   count %= prec;
 470   if (count < 0)
 471     count += prec;
 472
 473   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 474   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 475   *lv = s1l | s2l;
 476   *hv = s1h | s2h;
 477 }
 478
 479 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 480    keeping only PREC bits of result.  COUNT must be positive.
 481    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 482
 483 void
 484 rrotate_double (l1, h1, count, prec, lv, hv)
 485      unsigned HOST_WIDE_INT l1;
 486      HOST_WIDE_INT h1, count;
 487      unsigned int prec;
 488      unsigned HOST_WIDE_INT *lv;
 489      HOST_WIDE_INT *hv;
 490 {
 491   unsigned HOST_WIDE_INT s1l, s2l;
 492   HOST_WIDE_INT s1h, s2h;
 493
 494   count %= prec;
 495   if (count < 0)
 496     count += prec;
 497
 498   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 499   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 500   *lv = s1l | s2l;
 501   *hv = s1h | s2h;
 502 }
 503 \f
 504 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
 505    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
 506    CODE is a tree code for a kind of division, one of
 507    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
 508    or EXACT_DIV_EXPR
 509    It controls how the quotient is rounded to a integer.
 510    Return nonzero if the operation overflows.
 511    UNS nonzero says do unsigned division.  */
 512
 513 int
 514 div_and_round_double (code, uns,
 515                       lnum_orig, hnum_orig, lden_orig, hden_orig,
 516                       lquo, hquo, lrem, hrem)
 517      enum tree_code code;
 518      int uns;
 519      unsigned HOST_WIDE_INT lnum_orig; /* num == numerator == dividend */
 520      HOST_WIDE_INT hnum_orig;
 521      unsigned HOST_WIDE_INT lden_orig; /* den == denominator == divisor */
 522      HOST_WIDE_INT hden_orig;
 523      unsigned HOST_WIDE_INT *lquo, *lrem;
 524      HOST_WIDE_INT *hquo, *hrem;
 525 {
 526   int quo_neg = 0;
 527   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
 528   HOST_WIDE_INT den[4], quo[4];
 529   register int i, j;
 530   unsigned HOST_WIDE_INT work;
 531   unsigned HOST_WIDE_INT carry = 0;
 532   unsigned HOST_WIDE_INT lnum = lnum_orig;
 533   HOST_WIDE_INT hnum = hnum_orig;
 534   unsigned HOST_WIDE_INT lden = lden_orig;
 535   HOST_WIDE_INT hden = hden_orig;
 536   int overflow = 0;
 537
 538   if (hden == 0 && lden == 0)
 539     overflow = 1, lden = 1;
 540
 541   /* calculate quotient sign and convert operands to unsigned.  */
 542   if (!uns)
 543     {
 544       if (hnum < 0)
 545         {
 546           quo_neg = ~ quo_neg;
 547           /* (minimum integer) / (-1) is the only overflow case.  */
 548           if (neg_double (lnum, hnum, &lnum, &hnum)
 549               && ((HOST_WIDE_INT) lden & hden) == -1)
 550             overflow = 1;
 551         }
 552       if (hden < 0)
 553         {
 554           quo_neg = ~ quo_neg;
 555           neg_double (lden, hden, &lden, &hden);
 556         }
 557     }
 558
 559   if (hnum == 0 && hden == 0)
 560     {                           /* single precision */
 561       *hquo = *hrem = 0;
 562       /* This unsigned division rounds toward zero.  */
 563       *lquo = lnum / lden;
 564       goto finish_up;
 565     }
 566
 567   if (hnum == 0)
 568     {                           /* trivial case: dividend < divisor */
 569       /* hden != 0 already checked.  */
 570       *hquo = *lquo = 0;
 571       *hrem = hnum;
 572       *lrem = lnum;
 573       goto finish_up;
 574     }
 575
 576   bzero ((char *) quo, sizeof quo);
 577
 578   bzero ((char *) num, sizeof num);     /* to zero 9th element */
 579   bzero ((char *) den, sizeof den);
 580
 581   encode (num, lnum, hnum);
 582   encode (den, lden, hden);
 583
 584   /* Special code for when the divisor < BASE.  */
 585   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
 586     {
 587       /* hnum != 0 already checked.  */
 588       for (i = 4 - 1; i >= 0; i--)
 589         {
 590           work = num[i] + carry * BASE;
 591           quo[i] = work / lden;
 592           carry = work % lden;
 593         }
 594     }
 595   else
 596     {
 597       /* Full double precision division,
 598          with thanks to Don Knuth's "Seminumerical Algorithms".  */
 599       int num_hi_sig, den_hi_sig;
 600       unsigned HOST_WIDE_INT quo_est, scale;
 601
 602       /* Find the highest non-zero divisor digit.  */
 603       for (i = 4 - 1;; i--)
 604         if (den[i] != 0)
 605           {
 606             den_hi_sig = i;
 607             break;
 608           }
 609
 610       /* Insure that the first digit of the divisor is at least BASE/2.
 611          This is required by the quotient digit estimation algorithm.  */
 612
 613       scale = BASE / (den[den_hi_sig] + 1);
 614       if (scale > 1)
 615         {               /* scale divisor and dividend */
 616           carry = 0;
 617           for (i = 0; i <= 4 - 1; i++)
 618             {
 619               work = (num[i] * scale) + carry;
 620               num[i] = LOWPART (work);
 621               carry = HIGHPART (work);
 622             }
 623
 624           num[4] = carry;
 625           carry = 0;
 626           for (i = 0; i <= 4 - 1; i++)
 627             {
 628               work = (den[i] * scale) + carry;
 629               den[i] = LOWPART (work);
 630               carry = HIGHPART (work);
 631               if (den[i] != 0) den_hi_sig = i;
 632             }
 633         }
 634
 635       num_hi_sig = 4;
 636
 637       /* Main loop */
 638       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
 639         {
 640           /* Guess the next quotient digit, quo_est, by dividing the first
 641              two remaining dividend digits by the high order quotient digit.
 642              quo_est is never low and is at most 2 high.  */
 643           unsigned HOST_WIDE_INT tmp;
 644
 645           num_hi_sig = i + den_hi_sig + 1;
 646           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
 647           if (num[num_hi_sig] != den[den_hi_sig])
 648             quo_est = work / den[den_hi_sig];
 649           else
 650             quo_est = BASE - 1;
 651
 652           /* Refine quo_est so it's usually correct, and at most one high.   */
 653           tmp = work - quo_est * den[den_hi_sig];
 654           if (tmp < BASE
 655               && (den[den_hi_sig - 1] * quo_est
 656                   > (tmp * BASE + num[num_hi_sig - 2])))
 657             quo_est--;
 658
 659           /* Try QUO_EST as the quotient digit, by multiplying the
 660              divisor by QUO_EST and subtracting from the remaining dividend.
 661              Keep in mind that QUO_EST is the I - 1st digit.  */
 662
 663           carry = 0;
 664           for (j = 0; j <= den_hi_sig; j++)
 665             {
 666               work = quo_est * den[j] + carry;
 667               carry = HIGHPART (work);
 668               work = num[i + j] - LOWPART (work);
 669               num[i + j] = LOWPART (work);
 670               carry += HIGHPART (work) != 0;
 671             }
 672
 673           /* If quo_est was high by one, then num[i] went negative and
 674              we need to correct things.  */
 675           if (num[num_hi_sig] < carry)
 676             {
 677               quo_est--;
 678               carry = 0;                /* add divisor back in */
 679               for (j = 0; j <= den_hi_sig; j++)
 680                 {
 681                   work = num[i + j] + den[j] + carry;
 682                   carry = HIGHPART (work);
 683                   num[i + j] = LOWPART (work);
 684                 }
 685
 686               num [num_hi_sig] += carry;
 687             }
 688
 689           /* Store the quotient digit.  */
 690           quo[i] = quo_est;
 691         }
 692     }
 693
 694   decode (quo, lquo, hquo);
 695
 696  finish_up:
 697   /* if result is negative, make it so.  */
 698   if (quo_neg)
 699     neg_double (*lquo, *hquo, lquo, hquo);
 700
 701   /* compute trial remainder:  rem = num - (quo * den)  */
 702   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 703   neg_double (*lrem, *hrem, lrem, hrem);
 704   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 705
 706   switch (code)
 707     {
 708     case TRUNC_DIV_EXPR:
 709     case TRUNC_MOD_EXPR:        /* round toward zero */
 710     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
 711       return overflow;
 712
 713     case FLOOR_DIV_EXPR:
 714     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
 715       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
 716         {
 717           /* quo = quo - 1;  */
 718           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
 719                       lquo, hquo);
 720         }
 721       else
 722         return overflow;
 723       break;
 724
 725     case CEIL_DIV_EXPR:
 726     case CEIL_MOD_EXPR:         /* round toward positive infinity */
 727       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
 728         {
 729           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 730                       lquo, hquo);
 731         }
 732       else
 733         return overflow;
 734       break;
 735
 736     case ROUND_DIV_EXPR:
 737     case ROUND_MOD_EXPR:        /* round to closest integer */
 738       {
 739         unsigned HOST_WIDE_INT labs_rem = *lrem;
 740         HOST_WIDE_INT habs_rem = *hrem;
 741         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
 742         HOST_WIDE_INT habs_den = hden, htwice;
 743
 744         /* Get absolute values */
 745         if (*hrem < 0)
 746           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
 747         if (hden < 0)
 748           neg_double (lden, hden, &labs_den, &habs_den);
 749
 750         /* If (2 * abs (lrem) >= abs (lden)) */
 751         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
 752                     labs_rem, habs_rem, &ltwice, &htwice);
 753
 754         if (((unsigned HOST_WIDE_INT) habs_den
 755              < (unsigned HOST_WIDE_INT) htwice)
 756             || (((unsigned HOST_WIDE_INT) habs_den
 757                  == (unsigned HOST_WIDE_INT) htwice)
 758                 && (labs_den < ltwice)))
 759           {
 760             if (*hquo < 0)
 761               /* quo = quo - 1;  */
 762               add_double (*lquo, *hquo,
 763                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
 764             else
 765               /* quo = quo + 1; */
 766               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 767                           lquo, hquo);
 768           }
 769         else
 770           return overflow;
 771       }
 772       break;
 773
 774     default:
 775       abort ();
 776     }
 777
 778   /* compute true remainder:  rem = num - (quo * den)  */
 779   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 780   neg_double (*lrem, *hrem, lrem, hrem);
 781   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 782   return overflow;
 783 }
 784 \f
 785 #ifndef REAL_ARITHMETIC
 786 /* Effectively truncate a real value to represent the nearest possible value
 787    in a narrower mode.  The result is actually represented in the same data
 788    type as the argument, but its value is usually different.
 789
 790    A trap may occur during the FP operations and it is the responsibility
 791    of the calling function to have a handler established.  */
 792
 793 REAL_VALUE_TYPE
 794 real_value_truncate (mode, arg)
 795      enum machine_mode mode;
 796      REAL_VALUE_TYPE arg;
 797 {
 798   return REAL_VALUE_TRUNCATE (mode, arg);
 799 }
 800
 801 #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
 802
 803 /* Check for infinity in an IEEE double precision number.  */
 804
 805 int
 806 target_isinf (x)
 807      REAL_VALUE_TYPE x;
 808 {
 809   /* The IEEE 64-bit double format.  */
 810   union {
 811     REAL_VALUE_TYPE d;
 812     struct {
 813       unsigned sign      :  1;
 814       unsigned exponent  : 11;
 815       unsigned mantissa1 : 20;
 816       unsigned mantissa2;
 817     } little_endian;
 818     struct {
 819       unsigned mantissa2;
 820       unsigned mantissa1 : 20;
 821       unsigned exponent  : 11;
 822       unsigned sign      :  1;
 823     } big_endian;
 824   } u;
 825
 826   u.d = dconstm1;
 827   if (u.big_endian.sign == 1)
 828     {
 829       u.d = x;
 830       return (u.big_endian.exponent == 2047
 831               && u.big_endian.mantissa1 == 0
 832               && u.big_endian.mantissa2 == 0);
 833     }
 834   else
 835     {
 836       u.d = x;
 837       return (u.little_endian.exponent == 2047
 838               && u.little_endian.mantissa1 == 0
 839               && u.little_endian.mantissa2 == 0);
 840     }
 841 }
 842
 843 /* Check whether an IEEE double precision number is a NaN.  */
 844
 845 int
 846 target_isnan (x)
 847      REAL_VALUE_TYPE x;
 848 {
 849   /* The IEEE 64-bit double format.  */
 850   union {
 851     REAL_VALUE_TYPE d;
 852     struct {
 853       unsigned sign      :  1;
 854       unsigned exponent  : 11;
 855       unsigned mantissa1 : 20;
 856       unsigned mantissa2;
 857     } little_endian;
 858     struct {
 859       unsigned mantissa2;
 860       unsigned mantissa1 : 20;
 861       unsigned exponent  : 11;
 862       unsigned sign      :  1;
 863     } big_endian;
 864   } u;
 865
 866   u.d = dconstm1;
 867   if (u.big_endian.sign == 1)
 868     {
 869       u.d = x;
 870       return (u.big_endian.exponent == 2047
 871               && (u.big_endian.mantissa1 != 0
 872                   || u.big_endian.mantissa2 != 0));
 873     }
 874   else
 875     {
 876       u.d = x;
 877       return (u.little_endian.exponent == 2047
 878               && (u.little_endian.mantissa1 != 0
 879                   || u.little_endian.mantissa2 != 0));
 880     }
 881 }
 882
 883 /* Check for a negative IEEE double precision number.  */
 884
 885 int
 886 target_negative (x)
 887      REAL_VALUE_TYPE x;
 888 {
 889   /* The IEEE 64-bit double format.  */
 890   union {
 891     REAL_VALUE_TYPE d;
 892     struct {
 893       unsigned sign      :  1;
 894       unsigned exponent  : 11;
 895       unsigned mantissa1 : 20;
 896       unsigned mantissa2;
 897     } little_endian;
 898     struct {
 899       unsigned mantissa2;
 900       unsigned mantissa1 : 20;
 901       unsigned exponent  : 11;
 902       unsigned sign      :  1;
 903     } big_endian;
 904   } u;
 905
 906   u.d = dconstm1;
 907   if (u.big_endian.sign == 1)
 908     {
 909       u.d = x;
 910       return u.big_endian.sign;
 911     }
 912   else
 913     {
 914       u.d = x;
 915       return u.little_endian.sign;
 916     }
 917 }
 918 #else /* Target not IEEE */
 919
 920 /* Let's assume other float formats don't have infinity.
 921    (This can be overridden by redefining REAL_VALUE_ISINF.)  */
 922
 923 int
 924 target_isinf (x)
 925      REAL_VALUE_TYPE x ATTRIBUTE_UNUSED;
 926 {
 927   return 0;
 928 }
 929
 930 /* Let's assume other float formats don't have NaNs.
 931    (This can be overridden by redefining REAL_VALUE_ISNAN.)  */
 932
 933 int
 934 target_isnan (x)
 935      REAL_VALUE_TYPE x ATTRIBUTE_UNUSED;
 936 {
 937   return 0;
 938 }
 939
 940 /* Let's assume other float formats don't have minus zero.
 941    (This can be overridden by redefining REAL_VALUE_NEGATIVE.)  */
 942
 943 int
 944 target_negative (x)
 945      REAL_VALUE_TYPE x;
 946 {
 947   return x < 0;
 948 }
 949 #endif /* Target not IEEE */
 950
 951 /* Try to change R into its exact multiplicative inverse in machine mode
 952    MODE.  Return nonzero function value if successful.  */
 953
 954 int
 955 exact_real_inverse (mode, r)
 956      enum machine_mode mode;
 957      REAL_VALUE_TYPE *r;
 958 {
 959   jmp_buf float_error;
 960   union
 961     {
 962       double d;
 963       unsigned short i[4];
 964     }x, t, y;
 965 #ifdef CHECK_FLOAT_VALUE
 966   int i;
 967 #endif
 968
 969   /* Usually disable if bounds checks are not reliable.  */
 970   if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT) && !flag_pretend_float)
 971     return 0;
 972
 973   /* Set array index to the less significant bits in the unions, depending
 974      on the endian-ness of the host doubles.
 975      Disable if insufficient information on the data structure.  */
 976 #if HOST_FLOAT_FORMAT == UNKNOWN_FLOAT_FORMAT
 977   return 0;
 978 #else
 979 #if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
 980 #define K 2
 981 #else
 982 #if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
 983 #define K 2
 984 #else
 985 #define K (2 * HOST_FLOAT_WORDS_BIG_ENDIAN)
 986 #endif
 987 #endif
 988 #endif
 989
 990   if (setjmp (float_error))
 991     {
 992       /* Don't do the optimization if there was an arithmetic error.  */
 993 fail:
 994       set_float_handler (NULL_PTR);
 995       return 0;
 996     }
 997   set_float_handler (float_error);
 998
 999   /* Domain check the argument.  */
1000   x.d = *r;
1001   if (x.d == 0.0)
1002     goto fail;
1003
1004 #ifdef REAL_INFINITY
1005   if (REAL_VALUE_ISINF (x.d) || REAL_VALUE_ISNAN (x.d))
1006     goto fail;
1007 #endif
1008
1009   /* Compute the reciprocal and check for numerical exactness.
1010      It is unnecessary to check all the significand bits to determine
1011      whether X is a power of 2.  If X is not, then it is impossible for
1012      the bottom half significand of both X and 1/X to be all zero bits.
1013      Hence we ignore the data structure of the top half and examine only
1014      the low order bits of the two significands.  */
1015   t.d = 1.0 / x.d;
1016   if (x.i[K] != 0 || x.i[K + 1] != 0 || t.i[K] != 0 || t.i[K + 1] != 0)
1017     goto fail;
1018
1019   /* Truncate to the required mode and range-check the result.  */
1020   y.d = REAL_VALUE_TRUNCATE (mode, t.d);
1021 #ifdef CHECK_FLOAT_VALUE
1022   i = 0;
1023   if (CHECK_FLOAT_VALUE (mode, y.d, i))
1024     goto fail;
1025 #endif
1026
1027   /* Fail if truncation changed the value.  */
1028   if (y.d != t.d || y.d == 0.0)
1029     goto fail;
1030
1031 #ifdef REAL_INFINITY
1032   if (REAL_VALUE_ISINF (y.d) || REAL_VALUE_ISNAN (y.d))
1033     goto fail;
1034 #endif
1035
1036   /* Output the reciprocal and return success flag.  */
1037   set_float_handler (NULL_PTR);
1038   *r = y.d;
1039   return 1;
1040 }
1041
1042 /* Convert C9X hexadecimal floating point string constant S.  Return
1043    real value type in mode MODE.  This function uses the host computer's
1044    floating point arithmetic when there is no REAL_ARITHMETIC.  */
1045
1046 REAL_VALUE_TYPE
1047 real_hex_to_f (s, mode)
1048    char *s;
1049    enum machine_mode mode;
1050 {
1051   REAL_VALUE_TYPE ip;
1052   char *p = s;
1053   unsigned HOST_WIDE_INT low, high;
1054   int shcount, nrmcount, k;
1055   int sign, expsign, isfloat;
1056   int lost = 0;/* Nonzero low order bits shifted out and discarded.  */
1057   int frexpon = 0;  /* Bits after the decimal point.  */
1058   int expon = 0;  /* Value of exponent.  */
1059   int decpt = 0;  /* How many decimal points.  */
1060   int gotp = 0;  /* How many P's.  */
1061   char c;
1062
1063   isfloat = 0;
1064   expsign = 1;
1065   ip = 0.0;
1066
1067   while (*p == ' ' || *p == '\t')
1068     ++p;
1069
1070   /* Sign, if any, comes first.  */
1071   sign = 1;
1072   if (*p == '-')
1073     {
1074       sign = -1;
1075       ++p;
1076     }
1077
1078   /* The string is supposed to start with 0x or 0X .  */
1079   if (*p == '0')
1080     {
1081       ++p;
1082       if (*p == 'x' || *p == 'X')
1083         ++p;
1084       else
1085         abort ();
1086     }
1087   else
1088     abort ();
1089
1090   while (*p == '0')
1091     ++p;
1092
1093   high = 0;
1094   low = 0;
1095   shcount = 0;
1096   while ((c = *p) != '\0')
1097     {
1098       if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
1099           || (c >= 'a' && c <= 'f'))
1100         {
1101           k = c & CHARMASK;
1102           if (k >= 'a' && k <= 'f')
1103             k = k - 'a' + 10;
1104           else if (k >= 'A')
1105             k = k - 'A' + 10;
1106           else
1107             k = k - '0';
1108
1109           if ((high & 0xf0000000) == 0)
1110             {
1111               high = (high << 4) + ((low >> 28) & 15);
1112               low = (low << 4) + k;
1113               shcount += 4;
1114               if (decpt)
1115                 frexpon += 4;
1116             }
1117           else
1118             {
1119               /* Record nonzero lost bits.  */
1120               lost |= k;
1121               if (! decpt)
1122                 frexpon -= 4;
1123             }
1124           ++p;
1125         }
1126       else if (c == '.')
1127         {
1128           ++decpt;
1129           ++p;
1130         }
1131
1132       else if (c == 'p' || c == 'P')
1133         {
1134           ++gotp;
1135           ++p;
1136           /* Sign of exponent.  */
1137           if (*p == '-')
1138             {
1139               expsign = -1;
1140               ++p;
1141             }
1142
1143           /* Value of exponent.
1144              The exponent field is a decimal integer.  */
1145           while (ISDIGIT (*p))
1146             {
1147               k = (*p++ & CHARMASK) - '0';
1148               expon = 10 * expon + k;
1149             }
1150
1151           expon *= expsign;
1152           /* F suffix is ambiguous in the significand part
1153              so it must appear after the decimal exponent field.  */
1154           if (*p == 'f' || *p == 'F')
1155             {
1156               isfloat = 1;
1157               ++p;
1158               break;
1159             }
1160         }
1161
1162       else if (c == 'l' || c == 'L')
1163         {
1164           ++p;
1165           break;
1166         }
1167       else
1168         break;
1169     }
1170
1171   /* Abort if last character read was not legitimate.  */
1172   c = *p;
1173   if ((c != '\0' && c != ' ' && c != '\n' && c != '\r') || (decpt > 1))
1174     abort ();
1175
1176   /* There must be either one decimal point or one p.  */
1177   if (decpt == 0 && gotp == 0)
1178     abort ();
1179
1180   shcount -= 4;
1181   if (high == 0 && low == 0)
1182     return dconst0;
1183
1184   /* Normalize.  */
1185   nrmcount = 0;
1186   if (high == 0)
1187     {
1188       high = low;
1189       low = 0;
1190       nrmcount += 32;
1191     }
1192
1193   /* Leave a high guard bit for carry-out.  */
1194   if ((high & 0x80000000) != 0)
1195     {
1196       lost |= low & 1;
1197       low = (low >> 1) | (high << 31);
1198       high = high >> 1;
1199       nrmcount -= 1;
1200     }
1201
1202   if ((high & 0xffff8000) == 0)
1203     {
1204       high = (high << 16) + ((low >> 16) & 0xffff);
1205       low = low << 16;
1206       nrmcount += 16;
1207     }
1208
1209   while ((high & 0xc0000000) == 0)
1210     {
1211       high = (high << 1) + ((low >> 31) & 1);
1212       low = low << 1;
1213       nrmcount += 1;
1214     }
1215
1216   if (isfloat || GET_MODE_SIZE (mode) == UNITS_PER_WORD)
1217     {
1218       /* Keep 24 bits precision, bits 0x7fffff80.
1219          Rounding bit is 0x40.  */
1220       lost = lost | low | (high & 0x3f);
1221       low = 0;
1222       if (high & 0x40)
1223         {
1224           if ((high & 0x80) || lost)
1225             high += 0x40;
1226         }
1227       high &= 0xffffff80;
1228     }
1229   else
1230     {
1231       /* We need real.c to do long double formats, so here default
1232          to double precision.  */
1233 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1234       /* IEEE double.
1235          Keep 53 bits precision, bits 0x7fffffff fffffc00.
1236          Rounding bit is low word 0x200.  */
1237       lost = lost | (low & 0x1ff);
1238       if (low & 0x200)
1239         {
1240           if ((low & 0x400) || lost)
1241             {
1242               low = (low + 0x200) & 0xfffffc00;
1243               if (low == 0)
1244                 high += 1;
1245             }
1246         }
1247       low &= 0xfffffc00;
1248 #else
1249       /* Assume it's a VAX with 56-bit significand,
1250          bits 0x7fffffff ffffff80.  */
1251       lost = lost | (low & 0x7f);
1252       if (low & 0x40)
1253         {
1254           if ((low & 0x80) || lost)
1255             {
1256               low = (low + 0x40) & 0xffffff80;
1257               if (low == 0)
1258                 high += 1;
1259             }
1260         }
1261       low &= 0xffffff80;
1262 #endif
1263     }
1264
1265   ip = (double) high;
1266   ip = REAL_VALUE_LDEXP (ip, 32) + (double) low;
1267   /* Apply shifts and exponent value as power of 2.  */
1268   ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
1269
1270   if (sign < 0)
1271     ip = -ip;
1272   return ip;
1273 }
1274
1275 #endif /* no REAL_ARITHMETIC */
1276 \f
1277 /* Given T, an expression, return the negation of T.  Allow for T to be
1278    null, in which case return null.  */
1279
1280 static tree
1281 negate_expr (t)
1282      tree t;
1283 {
1284   tree type;
1285   tree tem;
1286
1287   if (t == 0)
1288     return 0;
1289
1290   type = TREE_TYPE (t);
1291   STRIP_SIGN_NOPS (t);
1292
1293   switch (TREE_CODE (t))
1294     {
1295     case INTEGER_CST:
1296     case REAL_CST:
1297       if (! TREE_UNSIGNED (type)
1298           && 0 != (tem = fold (build1 (NEGATE_EXPR, type, t)))
1299           && ! TREE_OVERFLOW (tem))
1300         return tem;
1301       break;
1302
1303     case NEGATE_EXPR:
1304       return convert (type, TREE_OPERAND (t, 0));
1305
1306     case MINUS_EXPR:
1307       /* - (A - B) -> B - A  */
1308       if (! FLOAT_TYPE_P (type) || flag_fast_math)
1309         return convert (type,
1310                         fold (build (MINUS_EXPR, TREE_TYPE (t),
1311                                      TREE_OPERAND (t, 1),
1312                                      TREE_OPERAND (t, 0))));
1313       break;
1314
1315     default:
1316       break;
1317     }
1318
1319   return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (t), t));
1320 }
1321 \f
1322 /* Split a tree IN into a constant, literal and variable parts that could be
1323    combined with CODE to make IN.  "constant" means an expression with
1324    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1325    commutative arithmetic operation.  Store the constant part into *CONP,
1326    the literal in &LITP and return the variable part.  If a part isn't
1327    present, set it to null.  If the tree does not decompose in this way,
1328    return the entire tree as the variable part and the other parts as null.
1329
1330    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1331    case, we negate an operand that was subtracted.  If NEGATE_P is true, we
1332    are negating all of IN.
1333
1334    If IN is itself a literal or constant, return it as appropriate.
1335
1336    Note that we do not guarantee that any of the three values will be the
1337    same type as IN, but they will have the same signedness and mode.  */
1338
1339 static tree
1340 split_tree (in, code, conp, litp, negate_p)
1341      tree in;
1342      enum tree_code code;
1343      tree *conp, *litp;
1344      int negate_p;
1345 {
1346   tree var = 0;
1347
1348   *conp = 0;
1349   *litp = 0;
1350
1351   /* Strip any conversions that don't change the machine mode or signedness. */
1352   STRIP_SIGN_NOPS (in);
1353
1354   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
1355     *litp = in;
1356   else if (TREE_CONSTANT (in))
1357     *conp = in;
1358
1359   else if (TREE_CODE (in) == code
1360            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1361                /* We can associate addition and subtraction together (even
1362                   though the C standard doesn't say so) for integers because
1363                   the value is not affected.  For reals, the value might be
1364                   affected, so we can't.  */
1365                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1366                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1367     {
1368       tree op0 = TREE_OPERAND (in, 0);
1369       tree op1 = TREE_OPERAND (in, 1);
1370       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1371       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1372
1373       /* First see if either of the operands is a literal, then a constant.  */
1374       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
1375         *litp = op0, op0 = 0;
1376       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1377         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1378
1379       if (op0 != 0 && TREE_CONSTANT (op0))
1380         *conp = op0, op0 = 0;
1381       else if (op1 != 0 && TREE_CONSTANT (op1))
1382         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1383
1384       /* If we haven't dealt with either operand, this is not a case we can
1385          decompose.  Otherwise, VAR is either of the ones remaining, if any. */
1386       if (op0 != 0 && op1 != 0)
1387         var = in;
1388       else if (op0 != 0)
1389         var = op0;
1390       else
1391         var = op1, neg_var_p = neg1_p;
1392
1393       /* Now do any needed negations.  */
1394       if (neg_litp_p) *litp = negate_expr (*litp);
1395       if (neg_conp_p) *conp = negate_expr (*conp);
1396       if (neg_var_p) var = negate_expr (var);
1397     }
1398   else
1399     var = in;
1400
1401   if (negate_p)
1402     {
1403       var = negate_expr (var);
1404       *conp = negate_expr (*conp);
1405       *litp = negate_expr (*litp);
1406     }
1407
1408   return var;
1409 }
1410
1411 /* Re-associate trees split by the above function.  T1 and T2 are either
1412    expressions to associate or null.  Return the new expression, if any.  If
1413    we build an operation, do it in TYPE and with CODE, except if CODE is a
1414    MINUS_EXPR, in which case we use PLUS_EXPR since split_tree will already
1415    have taken care of the negations.  */
1416
1417 static tree
1418 associate_trees (t1, t2, code, type)
1419      tree t1, t2;
1420      enum tree_code code;
1421      tree type;
1422 {
1423   if (t1 == 0)
1424     return t2;
1425   else if (t2 == 0)
1426     return t1;
1427
1428   if (code == MINUS_EXPR)
1429     code = PLUS_EXPR;
1430
1431   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1432      try to fold this since we will have infinite recursion.  But do
1433      deal with any NEGATE_EXPRs.  */
1434   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1435       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1436     {
1437       if (TREE_CODE (t1) == NEGATE_EXPR)
1438         return build (MINUS_EXPR, type, convert (type, t2),
1439                       convert (type, TREE_OPERAND (t1, 0)));
1440       else if (TREE_CODE (t2) == NEGATE_EXPR)
1441         return build (MINUS_EXPR, type, convert (type, t1),
1442                       convert (type, TREE_OPERAND (t2, 0)));
1443       else
1444         return build (code, type, convert (type, t1), convert (type, t2));
1445     }
1446
1447   return fold (build (code, type, convert (type, t1), convert (type, t2)));
1448 }
1449 \f
1450 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1451    to produce a new constant.
1452
1453    If NOTRUNC is nonzero, do not truncate the result to fit the data type.
1454    If FORSIZE is nonzero, compute overflow for unsigned types.  */
1455
1456 static tree
1457 int_const_binop (code, arg1, arg2, notrunc, forsize)
1458      enum tree_code code;
1459      register tree arg1, arg2;
1460      int notrunc, forsize;
1461 {
1462   unsigned HOST_WIDE_INT int1l, int2l;
1463   HOST_WIDE_INT int1h, int2h;
1464   unsigned HOST_WIDE_INT low;
1465   HOST_WIDE_INT hi;
1466   unsigned HOST_WIDE_INT garbagel;
1467   HOST_WIDE_INT garbageh;
1468   register tree t;
1469   int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1470   int overflow = 0;
1471   int no_overflow = 0;
1472
1473   int1l = TREE_INT_CST_LOW (arg1);
1474   int1h = TREE_INT_CST_HIGH (arg1);
1475   int2l = TREE_INT_CST_LOW (arg2);
1476   int2h = TREE_INT_CST_HIGH (arg2);
1477
1478   switch (code)
1479     {
1480     case BIT_IOR_EXPR:
1481       low = int1l | int2l, hi = int1h | int2h;
1482       break;
1483
1484     case BIT_XOR_EXPR:
1485       low = int1l ^ int2l, hi = int1h ^ int2h;
1486       break;
1487
1488     case BIT_AND_EXPR:
1489       low = int1l & int2l, hi = int1h & int2h;
1490       break;
1491
1492     case BIT_ANDTC_EXPR:
1493       low = int1l & ~int2l, hi = int1h & ~int2h;
1494       break;
1495
1496     case RSHIFT_EXPR:
1497       int2l = -int2l;
1498     case LSHIFT_EXPR:
1499       /* It's unclear from the C standard whether shifts can overflow.
1500          The following code ignores overflow; perhaps a C standard
1501          interpretation ruling is needed.  */
1502       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (TREE_TYPE (arg1)),
1503                      &low, &hi, !uns);
1504       no_overflow = 1;
1505       break;
1506
1507     case RROTATE_EXPR:
1508       int2l = - int2l;
1509     case LROTATE_EXPR:
1510       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (TREE_TYPE (arg1)),
1511                       &low, &hi);
1512       break;
1513
1514     case PLUS_EXPR:
1515       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1516       break;
1517
1518     case MINUS_EXPR:
1519       neg_double (int2l, int2h, &low, &hi);
1520       add_double (int1l, int1h, low, hi, &low, &hi);
1521       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1522       break;
1523
1524     case MULT_EXPR:
1525       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1526       break;
1527
1528     case TRUNC_DIV_EXPR:
1529     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1530     case EXACT_DIV_EXPR:
1531       /* This is a shortcut for a common special case.  */
1532       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1533           && ! TREE_CONSTANT_OVERFLOW (arg1)
1534           && ! TREE_CONSTANT_OVERFLOW (arg2)
1535           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1536         {
1537           if (code == CEIL_DIV_EXPR)
1538             int1l += int2l - 1;
1539
1540           low = int1l / int2l, hi = 0;
1541           break;
1542         }
1543
1544       /* ... fall through ... */
1545
1546     case ROUND_DIV_EXPR:
1547       if (int2h == 0 && int2l == 1)
1548         {
1549           low = int1l, hi = int1h;
1550           break;
1551         }
1552       if (int1l == int2l && int1h == int2h
1553           && ! (int1l == 0 && int1h == 0))
1554         {
1555           low = 1, hi = 0;
1556           break;
1557         }
1558       overflow = div_and_round_double (code, uns,
1559                                        int1l, int1h, int2l, int2h,
1560                                        &low, &hi, &garbagel, &garbageh);
1561       break;
1562
1563     case TRUNC_MOD_EXPR:
1564     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1565       /* This is a shortcut for a common special case.  */
1566       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1567           && ! TREE_CONSTANT_OVERFLOW (arg1)
1568           && ! TREE_CONSTANT_OVERFLOW (arg2)
1569           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1570         {
1571           if (code == CEIL_MOD_EXPR)
1572             int1l += int2l - 1;
1573           low = int1l % int2l, hi = 0;
1574           break;
1575         }
1576
1577       /* ... fall through ... */
1578
1579     case ROUND_MOD_EXPR:
1580       overflow = div_and_round_double (code, uns,
1581                                        int1l, int1h, int2l, int2h,
1582                                        &garbagel, &garbageh, &low, &hi);
1583       break;
1584
1585     case MIN_EXPR:
1586     case MAX_EXPR:
1587       if (uns)
1588         low = (((unsigned HOST_WIDE_INT) int1h
1589                 < (unsigned HOST_WIDE_INT) int2h)
1590                || (((unsigned HOST_WIDE_INT) int1h
1591                     == (unsigned HOST_WIDE_INT) int2h)
1592                    && int1l < int2l));
1593       else
1594         low = (int1h < int2h
1595                || (int1h == int2h && int1l < int2l));
1596
1597       if (low == (code == MIN_EXPR))
1598         low = int1l, hi = int1h;
1599       else
1600         low = int2l, hi = int2h;
1601       break;
1602
1603     default:
1604       abort ();
1605     }
1606
1607   if (forsize && hi == 0 && low < 10000)
1608     return size_int_type_wide (low, TREE_TYPE (arg1));
1609   else
1610     {
1611       t = build_int_2 (low, hi);
1612       TREE_TYPE (t) = TREE_TYPE (arg1);
1613     }
1614
1615   TREE_OVERFLOW (t)
1616     = ((notrunc ? (!uns || forsize) && overflow
1617         : force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
1618        | TREE_OVERFLOW (arg1)
1619        | TREE_OVERFLOW (arg2));
1620
1621   /* If we're doing a size calculation, unsigned arithmetic does overflow.
1622      So check if force_fit_type truncated the value.  */
1623   if (forsize
1624       && ! TREE_OVERFLOW (t)
1625       && (TREE_INT_CST_HIGH (t) != hi
1626           || TREE_INT_CST_LOW (t) != low))
1627     TREE_OVERFLOW (t) = 1;
1628
1629   TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1630                                 | TREE_CONSTANT_OVERFLOW (arg1)
1631                                 | TREE_CONSTANT_OVERFLOW (arg2));
1632   return t;
1633 }
1634
1635 /* Define input and output argument for const_binop_1.  */
1636 struct cb_args
1637 {
1638   enum tree_code code;          /* Input: tree code for operation.  */
1639   tree type;                    /* Input: tree type for operation.  */
1640   REAL_VALUE_TYPE d1, d2;       /* Input: floating point operands.  */
1641   tree t;                       /* Output: constant for result.  */
1642 };
1643
1644 /* Do the real arithmetic for const_binop while protected by a
1645    float overflow handler.  */
1646
1647 static void
1648 const_binop_1 (data)
1649      PTR data;
1650 {
1651   struct cb_args *args = (struct cb_args *) data;
1652   REAL_VALUE_TYPE value;
1653
1654 #ifdef REAL_ARITHMETIC
1655   REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
1656 #else
1657   switch (args->code)
1658     {
1659     case PLUS_EXPR:
1660       value = args->d1 + args->d2;
1661       break;
1662
1663     case MINUS_EXPR:
1664       value = args->d1 - args->d2;
1665       break;
1666
1667     case MULT_EXPR:
1668       value = args->d1 * args->d2;
1669       break;
1670
1671     case RDIV_EXPR:
1672 #ifndef REAL_INFINITY
1673       if (args->d2 == 0)
1674         abort ();
1675 #endif
1676
1677       value = args->d1 / args->d2;
1678       break;
1679
1680     case MIN_EXPR:
1681       value = MIN (args->d1, args->d2);
1682       break;
1683
1684     case MAX_EXPR:
1685       value = MAX (args->d1, args->d2);
1686       break;
1687
1688     default:
1689       abort ();
1690     }
1691 #endif /* no REAL_ARITHMETIC */
1692
1693   args->t
1694     = build_real (args->type,
1695                   real_value_truncate (TYPE_MODE (args->type), value));
1696 }
1697
1698 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1699    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1700    are the same kind of constant and the same machine mode.
1701
1702    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1703
1704 static tree
1705 const_binop (code, arg1, arg2, notrunc)
1706      enum tree_code code;
1707      register tree arg1, arg2;
1708      int notrunc;
1709 {
1710   STRIP_NOPS (arg1);
1711   STRIP_NOPS (arg2);
1712
1713   if (TREE_CODE (arg1) == INTEGER_CST)
1714     return int_const_binop (code, arg1, arg2, notrunc, 0);
1715
1716 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1717   if (TREE_CODE (arg1) == REAL_CST)
1718     {
1719       REAL_VALUE_TYPE d1;
1720       REAL_VALUE_TYPE d2;
1721       int overflow = 0;
1722       tree t;
1723       struct cb_args args;
1724
1725       d1 = TREE_REAL_CST (arg1);
1726       d2 = TREE_REAL_CST (arg2);
1727
1728       /* If either operand is a NaN, just return it.  Otherwise, set up
1729          for floating-point trap; we return an overflow.  */
1730       if (REAL_VALUE_ISNAN (d1))
1731         return arg1;
1732       else if (REAL_VALUE_ISNAN (d2))
1733         return arg2;
1734
1735       /* Setup input for const_binop_1() */
1736       args.type = TREE_TYPE (arg1);
1737       args.d1 = d1;
1738       args.d2 = d2;
1739       args.code = code;
1740
1741       if (do_float_handler (const_binop_1, (PTR) &args))
1742         /* Receive output from const_binop_1. */
1743         t = args.t;
1744       else
1745         {
1746           /* We got an exception from const_binop_1. */
1747           t = copy_node (arg1);
1748           overflow = 1;
1749         }
1750
1751       TREE_OVERFLOW (t)
1752         = (force_fit_type (t, overflow)
1753            | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1754       TREE_CONSTANT_OVERFLOW (t)
1755         = TREE_OVERFLOW (t)
1756           | TREE_CONSTANT_OVERFLOW (arg1)
1757           | TREE_CONSTANT_OVERFLOW (arg2);
1758       return t;
1759     }
1760 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1761   if (TREE_CODE (arg1) == COMPLEX_CST)
1762     {
1763       register tree type = TREE_TYPE (arg1);
1764       register tree r1 = TREE_REALPART (arg1);
1765       register tree i1 = TREE_IMAGPART (arg1);
1766       register tree r2 = TREE_REALPART (arg2);
1767       register tree i2 = TREE_IMAGPART (arg2);
1768       register tree t;
1769
1770       switch (code)
1771         {
1772         case PLUS_EXPR:
1773           t = build_complex (type,
1774                              const_binop (PLUS_EXPR, r1, r2, notrunc),
1775                              const_binop (PLUS_EXPR, i1, i2, notrunc));
1776           break;
1777
1778         case MINUS_EXPR:
1779           t = build_complex (type,
1780                              const_binop (MINUS_EXPR, r1, r2, notrunc),
1781                              const_binop (MINUS_EXPR, i1, i2, notrunc));
1782           break;
1783
1784         case MULT_EXPR:
1785           t = build_complex (type,
1786                              const_binop (MINUS_EXPR,
1787                                           const_binop (MULT_EXPR,
1788                                                        r1, r2, notrunc),
1789                                           const_binop (MULT_EXPR,
1790                                                        i1, i2, notrunc),
1791                                           notrunc),
1792                              const_binop (PLUS_EXPR,
1793                                           const_binop (MULT_EXPR,
1794                                                        r1, i2, notrunc),
1795                                           const_binop (MULT_EXPR,
1796                                                        i1, r2, notrunc),
1797                                           notrunc));
1798           break;
1799
1800         case RDIV_EXPR:
1801           {
1802             register tree magsquared
1803               = const_binop (PLUS_EXPR,
1804                              const_binop (MULT_EXPR, r2, r2, notrunc),
1805                              const_binop (MULT_EXPR, i2, i2, notrunc),
1806                              notrunc);
1807
1808             t = build_complex (type,
1809                                const_binop
1810                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1811                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1812                                 const_binop (PLUS_EXPR,
1813                                              const_binop (MULT_EXPR, r1, r2,
1814                                                           notrunc),
1815                                              const_binop (MULT_EXPR, i1, i2,
1816                                                           notrunc),
1817                                              notrunc),
1818                                 magsquared, notrunc),
1819                                const_binop
1820                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1821                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1822                                 const_binop (MINUS_EXPR,
1823                                              const_binop (MULT_EXPR, i1, r2,
1824                                                           notrunc),
1825                                              const_binop (MULT_EXPR, r1, i2,
1826                                                           notrunc),
1827                                              notrunc),
1828                                 magsquared, notrunc));
1829           }
1830           break;
1831
1832         default:
1833           abort ();
1834         }
1835       return t;
1836     }
1837   return 0;
1838 }
1839 \f
1840 /* Return an INTEGER_CST with value whose low-order HOST_BITS_PER_WIDE_INT
1841    bits are given by NUMBER and of the sizetype represented by KIND.  */
1842
1843 tree
1844 size_int_wide (number, kind)
1845      HOST_WIDE_INT number;
1846      enum size_type_kind kind;
1847 {
1848   return size_int_type_wide (number, sizetype_tab[(int) kind]);
1849 }
1850
1851 /* Likewise, but the desired type is specified explicitly.  */
1852
1853 tree
1854 size_int_type_wide (number, type)
1855      HOST_WIDE_INT number;
1856      tree type;
1857 {
1858   /* Type-size nodes already made for small sizes.  */
1859   static tree size_table[2048 + 1];
1860   static int init_p = 0;
1861   tree t;
1862
1863   if (! init_p)
1864     {
1865       ggc_add_tree_root ((tree *) size_table,
1866                          sizeof size_table / sizeof (tree));
1867       init_p = 1;
1868     }
1869
1870   /* If this is a positive number that fits in the table we use to hold
1871      cached entries, see if it is already in the table and put it there
1872      if not.  */
1873   if (number >= 0 && number < (int) ARRAY_SIZE (size_table))
1874     {
1875       if (size_table[number] != 0)
1876         for (t = size_table[number]; t != 0; t = TREE_CHAIN (t))
1877           if (TREE_TYPE (t) == type)
1878             return t;
1879
1880       t = build_int_2 (number, 0);
1881       TREE_TYPE (t) = type;
1882       TREE_CHAIN (t) = size_table[number];
1883       size_table[number] = t;
1884
1885       return t;
1886     }
1887
1888   t = build_int_2 (number, number < 0 ? -1 : 0);
1889   TREE_TYPE (t) = type;
1890   TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
1891   return t;
1892 }
1893
1894 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1895    is a tree code.  The type of the result is taken from the operands.
1896    Both must be the same type integer type and it must be a size type.
1897    If the operands are constant, so is the result.  */
1898
1899 tree
1900 size_binop (code, arg0, arg1)
1901      enum tree_code code;
1902      tree arg0, arg1;
1903 {
1904   tree type = TREE_TYPE (arg0);
1905
1906   if (TREE_CODE (type) != INTEGER_TYPE || ! TYPE_IS_SIZETYPE (type)
1907       || type != TREE_TYPE (arg1))
1908     abort ();
1909
1910   /* Handle the special case of two integer constants faster.  */
1911   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1912     {
1913       /* And some specific cases even faster than that.  */
1914       if (code == PLUS_EXPR && integer_zerop (arg0))
1915         return arg1;
1916       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1917                && integer_zerop (arg1))
1918         return arg0;
1919       else if (code == MULT_EXPR && integer_onep (arg0))
1920         return arg1;
1921
1922       /* Handle general case of two integer constants.  */
1923       return int_const_binop (code, arg0, arg1, 0, 1);
1924     }
1925
1926   if (arg0 == error_mark_node || arg1 == error_mark_node)
1927     return error_mark_node;
1928
1929   return fold (build (code, type, arg0, arg1));
1930 }
1931
1932 /* Given two values, either both of sizetype or both of bitsizetype,
1933    compute the difference between the two values.  Return the value
1934    in signed type corresponding to the type of the operands.  */
1935
1936 tree
1937 size_diffop (arg0, arg1)
1938      tree arg0, arg1;
1939 {
1940   tree type = TREE_TYPE (arg0);
1941   tree ctype;
1942
1943   if (TREE_CODE (type) != INTEGER_TYPE || ! TYPE_IS_SIZETYPE (type)
1944       || type != TREE_TYPE (arg1))
1945     abort ();
1946
1947   /* If the type is already signed, just do the simple thing.  */
1948   if (! TREE_UNSIGNED (type))
1949     return size_binop (MINUS_EXPR, arg0, arg1);
1950
1951   ctype = (type == bitsizetype || type == ubitsizetype
1952            ? sbitsizetype : ssizetype);
1953
1954   /* If either operand is not a constant, do the conversions to the signed
1955      type and subtract.  The hardware will do the right thing with any
1956      overflow in the subtraction.  */
1957   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1958     return size_binop (MINUS_EXPR, convert (ctype, arg0),
1959                        convert (ctype, arg1));
1960
1961   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1962      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1963      overflow) and negate (which can't either).  Special-case a result
1964      of zero while we're here.  */
1965   if (tree_int_cst_equal (arg0, arg1))
1966     return convert (ctype, integer_zero_node);
1967   else if (tree_int_cst_lt (arg1, arg0))
1968     return convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
1969   else
1970     return size_binop (MINUS_EXPR, convert (ctype, integer_zero_node),
1971                        convert (ctype, size_binop (MINUS_EXPR, arg1, arg0)));
1972 }
1973 \f
1974 /* This structure is used to communicate arguments to fold_convert_1.  */
1975 struct fc_args
1976 {
1977   tree arg1;                    /* Input: value to convert. */
1978   tree type;                    /* Input: type to convert value to. */
1979   tree t;                       /* Ouput: result of conversion. */
1980 };
1981
1982 /* Function to convert floating-point constants, protected by floating
1983    point exception handler.  */
1984
1985 static void
1986 fold_convert_1 (data)
1987      PTR data;
1988 {
1989   struct fc_args *args = (struct fc_args *) data;
1990
1991   args->t = build_real (args->type,
1992                         real_value_truncate (TYPE_MODE (args->type),
1993                                              TREE_REAL_CST (args->arg1)));
1994 }
1995
1996 /* Given T, a tree representing type conversion of ARG1, a constant,
1997    return a constant tree representing the result of conversion.  */
1998
1999 static tree
2000 fold_convert (t, arg1)
2001      register tree t;
2002      register tree arg1;
2003 {
2004   register tree type = TREE_TYPE (t);
2005   int overflow = 0;
2006
2007   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
2008     {
2009       if (TREE_CODE (arg1) == INTEGER_CST)
2010         {
2011           /* If we would build a constant wider than GCC supports,
2012              leave the conversion unfolded.  */
2013           if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
2014             return t;
2015
2016           /* If we are trying to make a sizetype for a small integer, use
2017              size_int to pick up cached types to reduce duplicate nodes.  */
2018           if (TREE_CODE (type) == INTEGER_CST && TYPE_IS_SIZETYPE (type)
2019               && compare_tree_int (arg1, 10000) < 0)
2020             return size_int_type_wide (TREE_INT_CST_LOW (arg1), type);
2021
2022           /* Given an integer constant, make new constant with new type,
2023              appropriately sign-extended or truncated.  */
2024           t = build_int_2 (TREE_INT_CST_LOW (arg1),
2025                            TREE_INT_CST_HIGH (arg1));
2026           TREE_TYPE (t) = type;
2027           /* Indicate an overflow if (1) ARG1 already overflowed,
2028              or (2) force_fit_type indicates an overflow.
2029              Tell force_fit_type that an overflow has already occurred
2030              if ARG1 is a too-large unsigned value and T is signed.
2031              But don't indicate an overflow if converting a pointer.  */
2032           TREE_OVERFLOW (t)
2033             = ((force_fit_type (t,
2034                                 (TREE_INT_CST_HIGH (arg1) < 0
2035                                  && (TREE_UNSIGNED (type)
2036                                     < TREE_UNSIGNED (TREE_TYPE (arg1)))))
2037                 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
2038                || TREE_OVERFLOW (arg1));
2039           TREE_CONSTANT_OVERFLOW (t)
2040             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2041         }
2042 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2043       else if (TREE_CODE (arg1) == REAL_CST)
2044         {
2045           /* Don't initialize these, use assignments.
2046              Initialized local aggregates don't work on old compilers.  */
2047           REAL_VALUE_TYPE x;
2048           REAL_VALUE_TYPE l;
2049           REAL_VALUE_TYPE u;
2050           tree type1 = TREE_TYPE (arg1);
2051           int no_upper_bound;
2052
2053           x = TREE_REAL_CST (arg1);
2054           l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
2055
2056           no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
2057           if (!no_upper_bound)
2058             u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
2059
2060           /* See if X will be in range after truncation towards 0.
2061              To compensate for truncation, move the bounds away from 0,
2062              but reject if X exactly equals the adjusted bounds.  */
2063 #ifdef REAL_ARITHMETIC
2064           REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
2065           if (!no_upper_bound)
2066             REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
2067 #else
2068           l--;
2069           if (!no_upper_bound)
2070             u++;
2071 #endif
2072           /* If X is a NaN, use zero instead and show we have an overflow.
2073              Otherwise, range check.  */
2074           if (REAL_VALUE_ISNAN (x))
2075             overflow = 1, x = dconst0;
2076           else if (! (REAL_VALUES_LESS (l, x)
2077                       && !no_upper_bound
2078                       && REAL_VALUES_LESS (x, u)))
2079             overflow = 1;
2080
2081 #ifndef REAL_ARITHMETIC
2082           {
2083             HOST_WIDE_INT low, high;
2084             HOST_WIDE_INT half_word
2085               = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
2086
2087             if (x < 0)
2088               x = -x;
2089
2090             high = (HOST_WIDE_INT) (x / half_word / half_word);
2091             x -= (REAL_VALUE_TYPE) high * half_word * half_word;
2092             if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
2093               {
2094                 low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
2095                 low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
2096               }
2097             else
2098               low = (HOST_WIDE_INT) x;
2099             if (TREE_REAL_CST (arg1) < 0)
2100               neg_double (low, high, &low, &high);
2101             t = build_int_2 (low, high);
2102           }
2103 #else
2104           {
2105             HOST_WIDE_INT low, high;
2106             REAL_VALUE_TO_INT (&low, &high, x);
2107             t = build_int_2 (low, high);
2108           }
2109 #endif
2110           TREE_TYPE (t) = type;
2111           TREE_OVERFLOW (t)
2112             = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
2113           TREE_CONSTANT_OVERFLOW (t)
2114             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2115         }
2116 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2117       TREE_TYPE (t) = type;
2118     }
2119   else if (TREE_CODE (type) == REAL_TYPE)
2120     {
2121 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2122       if (TREE_CODE (arg1) == INTEGER_CST)
2123         return build_real_from_int_cst (type, arg1);
2124 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2125       if (TREE_CODE (arg1) == REAL_CST)
2126         {
2127           struct fc_args args;
2128
2129           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
2130             {
2131               t = arg1;
2132               TREE_TYPE (arg1) = type;
2133               return t;
2134             }
2135
2136           /* Setup input for fold_convert_1() */
2137           args.arg1 = arg1;
2138           args.type = type;
2139
2140           if (do_float_handler (fold_convert_1, (PTR) &args))
2141             {
2142               /* Receive output from fold_convert_1() */
2143               t = args.t;
2144             }
2145           else
2146             {
2147               /* We got an exception from fold_convert_1() */
2148               overflow = 1;
2149               t = copy_node (arg1);
2150             }
2151
2152           TREE_OVERFLOW (t)
2153             = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
2154           TREE_CONSTANT_OVERFLOW (t)
2155             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2156           return t;
2157         }
2158     }
2159   TREE_CONSTANT (t) = 1;
2160   return t;
2161 }
2162 \f
2163 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2164
2165 tree
2166 non_lvalue (x)
2167      tree x;
2168 {
2169   tree result;
2170
2171   /* These things are certainly not lvalues.  */
2172   if (TREE_CODE (x) == NON_LVALUE_EXPR
2173       || TREE_CODE (x) == INTEGER_CST
2174       || TREE_CODE (x) == REAL_CST
2175       || TREE_CODE (x) == STRING_CST
2176       || TREE_CODE (x) == ADDR_EXPR)
2177     return x;
2178
2179   result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2180   TREE_CONSTANT (result) = TREE_CONSTANT (x);
2181   return result;
2182 }
2183
2184 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2185    Zero means allow extended lvalues.  */
2186
2187 int pedantic_lvalues;
2188
2189 /* When pedantic, return an expr equal to X but certainly not valid as a
2190    pedantic lvalue.  Otherwise, return X.  */
2191
2192 tree
2193 pedantic_non_lvalue (x)
2194      tree x;
2195 {
2196   if (pedantic_lvalues)
2197     return non_lvalue (x);
2198   else
2199     return x;
2200 }
2201 \f
2202 /* Given a tree comparison code, return the code that is the logical inverse
2203    of the given code.  It is not safe to do this for floating-point
2204    comparisons, except for NE_EXPR and EQ_EXPR.  */
2205
2206 static enum tree_code
2207 invert_tree_comparison (code)
2208      enum tree_code code;
2209 {
2210   switch (code)
2211     {
2212     case EQ_EXPR:
2213       return NE_EXPR;
2214     case NE_EXPR:
2215       return EQ_EXPR;
2216     case GT_EXPR:
2217       return LE_EXPR;
2218     case GE_EXPR:
2219       return LT_EXPR;
2220     case LT_EXPR:
2221       return GE_EXPR;
2222     case LE_EXPR:
2223       return GT_EXPR;
2224     default:
2225       abort ();
2226     }
2227 }
2228
2229 /* Similar, but return the comparison that results if the operands are
2230    swapped.  This is safe for floating-point.  */
2231
2232 static enum tree_code
2233 swap_tree_comparison (code)
2234      enum tree_code code;
2235 {
2236   switch (code)
2237     {
2238     case EQ_EXPR:
2239     case NE_EXPR:
2240       return code;
2241     case GT_EXPR:
2242       return LT_EXPR;
2243     case GE_EXPR:
2244       return LE_EXPR;
2245     case LT_EXPR:
2246       return GT_EXPR;
2247     case LE_EXPR:
2248       return GE_EXPR;
2249     default:
2250       abort ();
2251     }
2252 }
2253
2254 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2255
2256 static int
2257 truth_value_p (code)
2258      enum tree_code code;
2259 {
2260   return (TREE_CODE_CLASS (code) == '<'
2261           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2262           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2263           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2264 }
2265 \f
2266 /* Return nonzero if two operands are necessarily equal.
2267    If ONLY_CONST is non-zero, only return non-zero for constants.
2268    This function tests whether the operands are indistinguishable;
2269    it does not test whether they are equal using C's == operation.
2270    The distinction is important for IEEE floating point, because
2271    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2272    (2) two NaNs may be indistinguishable, but NaN!=NaN.  */
2273
2274 int
2275 operand_equal_p (arg0, arg1, only_const)
2276      tree arg0, arg1;
2277      int only_const;
2278 {
2279   /* If both types don't have the same signedness, then we can't consider
2280      them equal.  We must check this before the STRIP_NOPS calls
2281      because they may change the signedness of the arguments.  */
2282   if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
2283     return 0;
2284
2285   STRIP_NOPS (arg0);
2286   STRIP_NOPS (arg1);
2287
2288   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2289       /* This is needed for conversions and for COMPONENT_REF.
2290          Might as well play it safe and always test this.  */
2291       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2292       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2293       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2294     return 0;
2295
2296   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2297      We don't care about side effects in that case because the SAVE_EXPR
2298      takes care of that for us. In all other cases, two expressions are
2299      equal if they have no side effects.  If we have two identical
2300      expressions with side effects that should be treated the same due
2301      to the only side effects being identical SAVE_EXPR's, that will
2302      be detected in the recursive calls below.  */
2303   if (arg0 == arg1 && ! only_const
2304       && (TREE_CODE (arg0) == SAVE_EXPR
2305           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2306     return 1;
2307
2308   /* Next handle constant cases, those for which we can return 1 even
2309      if ONLY_CONST is set.  */
2310   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2311     switch (TREE_CODE (arg0))
2312       {
2313       case INTEGER_CST:
2314         return (! TREE_CONSTANT_OVERFLOW (arg0)
2315                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2316                 && tree_int_cst_equal (arg0, arg1));
2317
2318       case REAL_CST:
2319         return (! TREE_CONSTANT_OVERFLOW (arg0)
2320                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2321                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2322                                           TREE_REAL_CST (arg1)));
2323
2324       case COMPLEX_CST:
2325         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2326                                  only_const)
2327                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2328                                     only_const));
2329
2330       case STRING_CST:
2331         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2332                 && ! memcmp (TREE_STRING_POINTER (arg0),
2333                               TREE_STRING_POINTER (arg1),
2334                               TREE_STRING_LENGTH (arg0)));
2335
2336       case ADDR_EXPR:
2337         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2338                                 0);
2339       default:
2340         break;
2341       }
2342
2343   if (only_const)
2344     return 0;
2345
2346   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2347     {
2348     case '1':
2349       /* Two conversions are equal only if signedness and modes match.  */
2350       if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
2351           && (TREE_UNSIGNED (TREE_TYPE (arg0))
2352               != TREE_UNSIGNED (TREE_TYPE (arg1))))
2353         return 0;
2354
2355       return operand_equal_p (TREE_OPERAND (arg0, 0),
2356                               TREE_OPERAND (arg1, 0), 0);
2357
2358     case '<':
2359     case '2':
2360       if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
2361           && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
2362                               0))
2363         return 1;
2364
2365       /* For commutative ops, allow the other order.  */
2366       return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
2367                || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
2368                || TREE_CODE (arg0) == BIT_IOR_EXPR
2369                || TREE_CODE (arg0) == BIT_XOR_EXPR
2370                || TREE_CODE (arg0) == BIT_AND_EXPR
2371                || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
2372               && operand_equal_p (TREE_OPERAND (arg0, 0),
2373                                   TREE_OPERAND (arg1, 1), 0)
2374               && operand_equal_p (TREE_OPERAND (arg0, 1),
2375                                   TREE_OPERAND (arg1, 0), 0));
2376
2377     case 'r':
2378       /* If either of the pointer (or reference) expressions we are dereferencing
2379          contain a side effect, these cannot be equal. */
2380       if (TREE_SIDE_EFFECTS (arg0)
2381           || TREE_SIDE_EFFECTS (arg1))
2382         return 0;
2383
2384       switch (TREE_CODE (arg0))
2385         {
2386         case INDIRECT_REF:
2387           return operand_equal_p (TREE_OPERAND (arg0, 0),
2388                                   TREE_OPERAND (arg1, 0), 0);
2389
2390         case COMPONENT_REF:
2391         case ARRAY_REF:
2392           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2393                                    TREE_OPERAND (arg1, 0), 0)
2394                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2395                                       TREE_OPERAND (arg1, 1), 0));
2396
2397         case BIT_FIELD_REF:
2398           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2399                                    TREE_OPERAND (arg1, 0), 0)
2400                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2401                                       TREE_OPERAND (arg1, 1), 0)
2402                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2403                                       TREE_OPERAND (arg1, 2), 0));
2404         default:
2405           return 0;
2406         }
2407
2408     case 'e':
2409       if (TREE_CODE (arg0) == RTL_EXPR)
2410         return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
2411       return 0;
2412
2413     default:
2414       return 0;
2415     }
2416 }
2417 \f
2418 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2419    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2420
2421    When in doubt, return 0.  */
2422
2423 static int
2424 operand_equal_for_comparison_p (arg0, arg1, other)
2425      tree arg0, arg1;
2426      tree other;
2427 {
2428   int unsignedp1, unsignedpo;
2429   tree primarg0, primarg1, primother;
2430   unsigned int correct_width;
2431
2432   if (operand_equal_p (arg0, arg1, 0))
2433     return 1;
2434
2435   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2436       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2437     return 0;
2438
2439   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2440      and see if the inner values are the same.  This removes any
2441      signedness comparison, which doesn't matter here.  */
2442   primarg0 = arg0, primarg1 = arg1;
2443   STRIP_NOPS (primarg0);
2444   STRIP_NOPS (primarg1);
2445   if (operand_equal_p (primarg0, primarg1, 0))
2446     return 1;
2447
2448   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2449      actual comparison operand, ARG0.
2450
2451      First throw away any conversions to wider types
2452      already present in the operands.  */
2453
2454   primarg1 = get_narrower (arg1, &unsignedp1);
2455   primother = get_narrower (other, &unsignedpo);
2456
2457   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2458   if (unsignedp1 == unsignedpo
2459       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2460       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2461     {
2462       tree type = TREE_TYPE (arg0);
2463
2464       /* Make sure shorter operand is extended the right way
2465          to match the longer operand.  */
2466       primarg1 = convert (signed_or_unsigned_type (unsignedp1,
2467                                                    TREE_TYPE (primarg1)),
2468                           primarg1);
2469
2470       if (operand_equal_p (arg0, convert (type, primarg1), 0))
2471         return 1;
2472     }
2473
2474   return 0;
2475 }
2476 \f
2477 /* See if ARG is an expression that is either a comparison or is performing
2478    arithmetic on comparisons.  The comparisons must only be comparing
2479    two different values, which will be stored in *CVAL1 and *CVAL2; if
2480    they are non-zero it means that some operands have already been found.
2481    No variables may be used anywhere else in the expression except in the
2482    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2483    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2484
2485    If this is true, return 1.  Otherwise, return zero.  */
2486
2487 static int
2488 twoval_comparison_p (arg, cval1, cval2, save_p)
2489      tree arg;
2490      tree *cval1, *cval2;
2491      int *save_p;
2492 {
2493   enum tree_code code = TREE_CODE (arg);
2494   char class = TREE_CODE_CLASS (code);
2495
2496   /* We can handle some of the 'e' cases here.  */
2497   if (class == 'e' && code == TRUTH_NOT_EXPR)
2498     class = '1';
2499   else if (class == 'e'
2500            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2501                || code == COMPOUND_EXPR))
2502     class = '2';
2503
2504   else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0
2505            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2506     {
2507       /* If we've already found a CVAL1 or CVAL2, this expression is
2508          two complex to handle.  */
2509       if (*cval1 || *cval2)
2510         return 0;
2511
2512       class = '1';
2513       *save_p = 1;
2514     }
2515
2516   switch (class)
2517     {
2518     case '1':
2519       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2520
2521     case '2':
2522       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2523               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2524                                       cval1, cval2, save_p));
2525
2526     case 'c':
2527       return 1;
2528
2529     case 'e':
2530       if (code == COND_EXPR)
2531         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2532                                      cval1, cval2, save_p)
2533                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2534                                         cval1, cval2, save_p)
2535                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2536                                         cval1, cval2, save_p));
2537       return 0;
2538
2539     case '<':
2540       /* First see if we can handle the first operand, then the second.  For
2541          the second operand, we know *CVAL1 can't be zero.  It must be that
2542          one side of the comparison is each of the values; test for the
2543          case where this isn't true by failing if the two operands
2544          are the same.  */
2545
2546       if (operand_equal_p (TREE_OPERAND (arg, 0),
2547                            TREE_OPERAND (arg, 1), 0))
2548         return 0;
2549
2550       if (*cval1 == 0)
2551         *cval1 = TREE_OPERAND (arg, 0);
2552       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2553         ;
2554       else if (*cval2 == 0)
2555         *cval2 = TREE_OPERAND (arg, 0);
2556       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2557         ;
2558       else
2559         return 0;
2560
2561       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2562         ;
2563       else if (*cval2 == 0)
2564         *cval2 = TREE_OPERAND (arg, 1);
2565       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2566         ;
2567       else
2568         return 0;
2569
2570       return 1;
2571
2572     default:
2573       return 0;
2574     }
2575 }
2576 \f
2577 /* ARG is a tree that is known to contain just arithmetic operations and
2578    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2579    any occurrence of OLD0 as an operand of a comparison and likewise for
2580    NEW1 and OLD1.  */
2581
2582 static tree
2583 eval_subst (arg, old0, new0, old1, new1)
2584      tree arg;
2585      tree old0, new0, old1, new1;
2586 {
2587   tree type = TREE_TYPE (arg);
2588   enum tree_code code = TREE_CODE (arg);
2589   char class = TREE_CODE_CLASS (code);
2590
2591   /* We can handle some of the 'e' cases here.  */
2592   if (class == 'e' && code == TRUTH_NOT_EXPR)
2593     class = '1';
2594   else if (class == 'e'
2595            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2596     class = '2';
2597
2598   switch (class)
2599     {
2600     case '1':
2601       return fold (build1 (code, type,
2602                            eval_subst (TREE_OPERAND (arg, 0),
2603                                        old0, new0, old1, new1)));
2604
2605     case '2':
2606       return fold (build (code, type,
2607                           eval_subst (TREE_OPERAND (arg, 0),
2608                                       old0, new0, old1, new1),
2609                           eval_subst (TREE_OPERAND (arg, 1),
2610                                       old0, new0, old1, new1)));
2611
2612     case 'e':
2613       switch (code)
2614         {
2615         case SAVE_EXPR:
2616           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2617
2618         case COMPOUND_EXPR:
2619           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2620
2621         case COND_EXPR:
2622           return fold (build (code, type,
2623                               eval_subst (TREE_OPERAND (arg, 0),
2624                                           old0, new0, old1, new1),
2625                               eval_subst (TREE_OPERAND (arg, 1),
2626                                           old0, new0, old1, new1),
2627                               eval_subst (TREE_OPERAND (arg, 2),
2628                                           old0, new0, old1, new1)));
2629         default:
2630           break;
2631         }
2632       /* fall through - ??? */
2633
2634     case '<':
2635       {
2636         tree arg0 = TREE_OPERAND (arg, 0);
2637         tree arg1 = TREE_OPERAND (arg, 1);
2638
2639         /* We need to check both for exact equality and tree equality.  The
2640            former will be true if the operand has a side-effect.  In that
2641            case, we know the operand occurred exactly once.  */
2642
2643         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2644           arg0 = new0;
2645         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2646           arg0 = new1;
2647
2648         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2649           arg1 = new0;
2650         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2651           arg1 = new1;
2652
2653         return fold (build (code, type, arg0, arg1));
2654       }
2655
2656     default:
2657       return arg;
2658     }
2659 }
2660 \f
2661 /* Return a tree for the case when the result of an expression is RESULT
2662    converted to TYPE and OMITTED was previously an operand of the expression
2663    but is now not needed (e.g., we folded OMITTED * 0).
2664
2665    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2666    the conversion of RESULT to TYPE.  */
2667
2668 static tree
2669 omit_one_operand (type, result, omitted)
2670      tree type, result, omitted;
2671 {
2672   tree t = convert (type, result);
2673
2674   if (TREE_SIDE_EFFECTS (omitted))
2675     return build (COMPOUND_EXPR, type, omitted, t);
2676
2677   return non_lvalue (t);
2678 }
2679
2680 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2681
2682 static tree
2683 pedantic_omit_one_operand (type, result, omitted)
2684      tree type, result, omitted;
2685 {
2686   tree t = convert (type, result);
2687
2688   if (TREE_SIDE_EFFECTS (omitted))
2689     return build (COMPOUND_EXPR, type, omitted, t);
2690
2691   return pedantic_non_lvalue (t);
2692 }
2693 \f
2694 /* Return a simplified tree node for the truth-negation of ARG.  This
2695    never alters ARG itself.  We assume that ARG is an operation that
2696    returns a truth value (0 or 1).  */
2697
2698 tree
2699 invert_truthvalue (arg)
2700      tree arg;
2701 {
2702   tree type = TREE_TYPE (arg);
2703   enum tree_code code = TREE_CODE (arg);
2704
2705   if (code == ERROR_MARK)
2706     return arg;
2707
2708   /* If this is a comparison, we can simply invert it, except for
2709      floating-point non-equality comparisons, in which case we just
2710      enclose a TRUTH_NOT_EXPR around what we have.  */
2711
2712   if (TREE_CODE_CLASS (code) == '<')
2713     {
2714       if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
2715           && !flag_fast_math && code != NE_EXPR && code != EQ_EXPR)
2716         return build1 (TRUTH_NOT_EXPR, type, arg);
2717       else
2718         return build (invert_tree_comparison (code), type,
2719                       TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2720     }
2721
2722   switch (code)
2723     {
2724     case INTEGER_CST:
2725       return convert (type, build_int_2 (integer_zerop (arg), 0));
2726
2727     case TRUTH_AND_EXPR:
2728       return build (TRUTH_OR_EXPR, type,
2729                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2730                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2731
2732     case TRUTH_OR_EXPR:
2733       return build (TRUTH_AND_EXPR, type,
2734                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2735                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2736
2737     case TRUTH_XOR_EXPR:
2738       /* Here we can invert either operand.  We invert the first operand
2739          unless the second operand is a TRUTH_NOT_EXPR in which case our
2740          result is the XOR of the first operand with the inside of the
2741          negation of the second operand.  */
2742
2743       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2744         return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2745                       TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2746       else
2747         return build (TRUTH_XOR_EXPR, type,
2748                       invert_truthvalue (TREE_OPERAND (arg, 0)),
2749                       TREE_OPERAND (arg, 1));
2750
2751     case TRUTH_ANDIF_EXPR:
2752       return build (TRUTH_ORIF_EXPR, type,
2753                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2754                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2755
2756     case TRUTH_ORIF_EXPR:
2757       return build (TRUTH_ANDIF_EXPR, type,
2758                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2759                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2760
2761     case TRUTH_NOT_EXPR:
2762       return TREE_OPERAND (arg, 0);
2763
2764     case COND_EXPR:
2765       return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2766                     invert_truthvalue (TREE_OPERAND (arg, 1)),
2767                     invert_truthvalue (TREE_OPERAND (arg, 2)));
2768
2769     case COMPOUND_EXPR:
2770       return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2771                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2772
2773     case WITH_RECORD_EXPR:
2774       return build (WITH_RECORD_EXPR, type,
2775                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2776                     TREE_OPERAND (arg, 1));
2777
2778     case NON_LVALUE_EXPR:
2779       return invert_truthvalue (TREE_OPERAND (arg, 0));
2780
2781     case NOP_EXPR:
2782     case CONVERT_EXPR:
2783     case FLOAT_EXPR:
2784       return build1 (TREE_CODE (arg), type,
2785                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2786
2787     case BIT_AND_EXPR:
2788       if (!integer_onep (TREE_OPERAND (arg, 1)))
2789         break;
2790       return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2791
2792     case SAVE_EXPR:
2793       return build1 (TRUTH_NOT_EXPR, type, arg);
2794
2795     case CLEANUP_POINT_EXPR:
2796       return build1 (CLEANUP_POINT_EXPR, type,
2797                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2798
2799     default:
2800       break;
2801     }
2802   if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2803     abort ();
2804   return build1 (TRUTH_NOT_EXPR, type, arg);
2805 }
2806
2807 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2808    operands are another bit-wise operation with a common input.  If so,
2809    distribute the bit operations to save an operation and possibly two if
2810    constants are involved.  For example, convert
2811         (A | B) & (A | C) into A | (B & C)
2812    Further simplification will occur if B and C are constants.
2813
2814    If this optimization cannot be done, 0 will be returned.  */
2815
2816 static tree
2817 distribute_bit_expr (code, type, arg0, arg1)
2818      enum tree_code code;
2819      tree type;
2820      tree arg0, arg1;
2821 {
2822   tree common;
2823   tree left, right;
2824
2825   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2826       || TREE_CODE (arg0) == code
2827       || (TREE_CODE (arg0) != BIT_AND_EXPR
2828           && TREE_CODE (arg0) != BIT_IOR_EXPR))
2829     return 0;
2830
2831   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2832     {
2833       common = TREE_OPERAND (arg0, 0);
2834       left = TREE_OPERAND (arg0, 1);
2835       right = TREE_OPERAND (arg1, 1);
2836     }
2837   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2838     {
2839       common = TREE_OPERAND (arg0, 0);
2840       left = TREE_OPERAND (arg0, 1);
2841       right = TREE_OPERAND (arg1, 0);
2842     }
2843   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2844     {
2845       common = TREE_OPERAND (arg0, 1);
2846       left = TREE_OPERAND (arg0, 0);
2847       right = TREE_OPERAND (arg1, 1);
2848     }
2849   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2850     {
2851       common = TREE_OPERAND (arg0, 1);
2852       left = TREE_OPERAND (arg0, 0);
2853       right = TREE_OPERAND (arg1, 0);
2854     }
2855   else
2856     return 0;
2857
2858   return fold (build (TREE_CODE (arg0), type, common,
2859                       fold (build (code, type, left, right))));
2860 }
2861 \f
2862 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2863    starting at BITPOS.  The field is unsigned if UNSIGNEDP is non-zero.  */
2864
2865 static tree
2866 make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2867      tree inner;
2868      tree type;
2869      int bitsize, bitpos;
2870      int unsignedp;
2871 {
2872   tree result = build (BIT_FIELD_REF, type, inner,
2873                        size_int (bitsize), bitsize_int (bitpos));
2874
2875   TREE_UNSIGNED (result) = unsignedp;
2876
2877   return result;
2878 }
2879
2880 /* Optimize a bit-field compare.
2881
2882    There are two cases:  First is a compare against a constant and the
2883    second is a comparison of two items where the fields are at the same
2884    bit position relative to the start of a chunk (byte, halfword, word)
2885    large enough to contain it.  In these cases we can avoid the shift
2886    implicit in bitfield extractions.
2887
2888    For constants, we emit a compare of the shifted constant with the
2889    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2890    compared.  For two fields at the same position, we do the ANDs with the
2891    similar mask and compare the result of the ANDs.
2892
2893    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2894    COMPARE_TYPE is the type of the comparison, and LHS and RHS
2895    are the left and right operands of the comparison, respectively.
2896
2897    If the optimization described above can be done, we return the resulting
2898    tree.  Otherwise we return zero.  */
2899
2900 static tree
2901 optimize_bit_field_compare (code, compare_type, lhs, rhs)
2902      enum tree_code code;
2903      tree compare_type;
2904      tree lhs, rhs;
2905 {
2906   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
2907   tree type = TREE_TYPE (lhs);
2908   tree signed_type, unsigned_type;
2909   int const_p = TREE_CODE (rhs) == INTEGER_CST;
2910   enum machine_mode lmode, rmode, nmode;
2911   int lunsignedp, runsignedp;
2912   int lvolatilep = 0, rvolatilep = 0;
2913   unsigned int alignment;
2914   tree linner, rinner = NULL_TREE;
2915   tree mask;
2916   tree offset;
2917
2918   /* Get all the information about the extractions being done.  If the bit size
2919      if the same as the size of the underlying object, we aren't doing an
2920      extraction at all and so can do nothing.  We also don't want to
2921      do anything if the inner expression is a PLACEHOLDER_EXPR since we
2922      then will no longer be able to replace it.  */
2923   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2924                                 &lunsignedp, &lvolatilep, &alignment);
2925   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2926       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
2927     return 0;
2928
2929  if (!const_p)
2930    {
2931      /* If this is not a constant, we can only do something if bit positions,
2932         sizes, and signedness are the same.   */
2933      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2934                                    &runsignedp, &rvolatilep, &alignment);
2935
2936      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2937          || lunsignedp != runsignedp || offset != 0
2938          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
2939        return 0;
2940    }
2941
2942   /* See if we can find a mode to refer to this field.  We should be able to,
2943      but fail if we can't.  */
2944   nmode = get_best_mode (lbitsize, lbitpos,
2945                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
2946                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
2947                                 TYPE_ALIGN (TREE_TYPE (rinner))),
2948                          word_mode, lvolatilep || rvolatilep);
2949   if (nmode == VOIDmode)
2950     return 0;
2951
2952   /* Set signed and unsigned types of the precision of this mode for the
2953      shifts below.  */
2954   signed_type = type_for_mode (nmode, 0);
2955   unsigned_type = type_for_mode (nmode, 1);
2956
2957   /* Compute the bit position and size for the new reference and our offset
2958      within it. If the new reference is the same size as the original, we
2959      won't optimize anything, so return zero.  */
2960   nbitsize = GET_MODE_BITSIZE (nmode);
2961   nbitpos = lbitpos & ~ (nbitsize - 1);
2962   lbitpos -= nbitpos;
2963   if (nbitsize == lbitsize)
2964     return 0;
2965
2966   if (BYTES_BIG_ENDIAN)
2967     lbitpos = nbitsize - lbitsize - lbitpos;
2968
2969   /* Make the mask to be used against the extracted field.  */
2970   mask = build_int_2 (~0, ~0);
2971   TREE_TYPE (mask) = unsigned_type;
2972   force_fit_type (mask, 0);
2973   mask = convert (unsigned_type, mask);
2974   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
2975   mask = const_binop (RSHIFT_EXPR, mask,
2976                       size_int (nbitsize - lbitsize - lbitpos), 0);
2977
2978   if (! const_p)
2979     /* If not comparing with constant, just rework the comparison
2980        and return.  */
2981     return build (code, compare_type,
2982                   build (BIT_AND_EXPR, unsigned_type,
2983                          make_bit_field_ref (linner, unsigned_type,
2984                                              nbitsize, nbitpos, 1),
2985                          mask),
2986                   build (BIT_AND_EXPR, unsigned_type,
2987                          make_bit_field_ref (rinner, unsigned_type,
2988                                              nbitsize, nbitpos, 1),
2989                          mask));
2990
2991   /* Otherwise, we are handling the constant case. See if the constant is too
2992      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
2993      this not only for its own sake, but to avoid having to test for this
2994      error case below.  If we didn't, we might generate wrong code.
2995
2996      For unsigned fields, the constant shifted right by the field length should
2997      be all zero.  For signed fields, the high-order bits should agree with
2998      the sign bit.  */
2999
3000   if (lunsignedp)
3001     {
3002       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3003                                         convert (unsigned_type, rhs),
3004                                         size_int (lbitsize), 0)))
3005         {
3006           warning ("comparison is always %d due to width of bitfield",
3007                    code == NE_EXPR);
3008           return convert (compare_type,
3009                           (code == NE_EXPR
3010                            ? integer_one_node : integer_zero_node));
3011         }
3012     }
3013   else
3014     {
3015       tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
3016                               size_int (lbitsize - 1), 0);
3017       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3018         {
3019           warning ("comparison is always %d due to width of bitfield",
3020                    code == NE_EXPR);
3021           return convert (compare_type,
3022                           (code == NE_EXPR
3023                            ? integer_one_node : integer_zero_node));
3024         }
3025     }
3026
3027   /* Single-bit compares should always be against zero.  */
3028   if (lbitsize == 1 && ! integer_zerop (rhs))
3029     {
3030       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3031       rhs = convert (type, integer_zero_node);
3032     }
3033
3034   /* Make a new bitfield reference, shift the constant over the
3035      appropriate number of bits and mask it with the computed mask
3036      (in case this was a signed field).  If we changed it, make a new one.  */
3037   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3038   if (lvolatilep)
3039     {
3040       TREE_SIDE_EFFECTS (lhs) = 1;
3041       TREE_THIS_VOLATILE (lhs) = 1;
3042     }
3043
3044   rhs = fold (const_binop (BIT_AND_EXPR,
3045                            const_binop (LSHIFT_EXPR,
3046                                         convert (unsigned_type, rhs),
3047                                         size_int (lbitpos), 0),
3048                            mask, 0));
3049
3050   return build (code, compare_type,
3051                 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
3052                 rhs);
3053 }
3054 \f
3055 /* Subroutine for fold_truthop: decode a field reference.
3056
3057    If EXP is a comparison reference, we return the innermost reference.
3058
3059    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3060    set to the starting bit number.
3061
3062    If the innermost field can be completely contained in a mode-sized
3063    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3064
3065    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3066    otherwise it is not changed.
3067
3068    *PUNSIGNEDP is set to the signedness of the field.
3069
3070    *PMASK is set to the mask used.  This is either contained in a
3071    BIT_AND_EXPR or derived from the width of the field.
3072
3073    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3074
3075    Return 0 if this is not a component reference or is one that we can't
3076    do anything with.  */
3077
3078 static tree
3079 decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
3080                         pvolatilep, pmask, pand_mask)
3081      tree exp;
3082      HOST_WIDE_INT *pbitsize, *pbitpos;
3083      enum machine_mode *pmode;
3084      int *punsignedp, *pvolatilep;
3085      tree *pmask;
3086      tree *pand_mask;
3087 {
3088   tree and_mask = 0;
3089   tree mask, inner, offset;
3090   tree unsigned_type;
3091   unsigned int precision;
3092   unsigned int alignment;
3093
3094   /* All the optimizations using this function assume integer fields.
3095      There are problems with FP fields since the type_for_size call
3096      below can fail for, e.g., XFmode.  */
3097   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3098     return 0;
3099
3100   STRIP_NOPS (exp);
3101
3102   if (TREE_CODE (exp) == BIT_AND_EXPR)
3103     {
3104       and_mask = TREE_OPERAND (exp, 1);
3105       exp = TREE_OPERAND (exp, 0);
3106       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3107       if (TREE_CODE (and_mask) != INTEGER_CST)
3108         return 0;
3109     }
3110
3111   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3112                                punsignedp, pvolatilep, &alignment);
3113   if ((inner == exp && and_mask == 0)
3114       || *pbitsize < 0 || offset != 0
3115       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3116     return 0;
3117
3118   /* Compute the mask to access the bitfield.  */
3119   unsigned_type = type_for_size (*pbitsize, 1);
3120   precision = TYPE_PRECISION (unsigned_type);
3121
3122   mask = build_int_2 (~0, ~0);
3123   TREE_TYPE (mask) = unsigned_type;
3124   force_fit_type (mask, 0);
3125   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3126   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3127
3128   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3129   if (and_mask != 0)
3130     mask = fold (build (BIT_AND_EXPR, unsigned_type,
3131                         convert (unsigned_type, and_mask), mask));
3132
3133   *pmask = mask;
3134   *pand_mask = and_mask;
3135   return inner;
3136 }
3137
3138 /* Return non-zero if MASK represents a mask of SIZE ones in the low-order
3139    bit positions.  */
3140
3141 static int
3142 all_ones_mask_p (mask, size)
3143      tree mask;
3144      int size;
3145 {
3146   tree type = TREE_TYPE (mask);
3147   unsigned int precision = TYPE_PRECISION (type);
3148   tree tmask;
3149
3150   tmask = build_int_2 (~0, ~0);
3151   TREE_TYPE (tmask) = signed_type (type);
3152   force_fit_type (tmask, 0);
3153   return
3154     tree_int_cst_equal (mask,
3155                         const_binop (RSHIFT_EXPR,
3156                                      const_binop (LSHIFT_EXPR, tmask,
3157                                                   size_int (precision - size),
3158                                                   0),
3159                                      size_int (precision - size), 0));
3160 }
3161
3162 /* Subroutine for fold_truthop: determine if an operand is simple enough
3163    to be evaluated unconditionally.  */
3164
3165 static int
3166 simple_operand_p (exp)
3167      tree exp;
3168 {
3169   /* Strip any conversions that don't change the machine mode.  */
3170   while ((TREE_CODE (exp) == NOP_EXPR
3171           || TREE_CODE (exp) == CONVERT_EXPR)
3172          && (TYPE_MODE (TREE_TYPE (exp))
3173              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
3174     exp = TREE_OPERAND (exp, 0);
3175
3176   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
3177           || (DECL_P (exp)
3178               && ! TREE_ADDRESSABLE (exp)
3179               && ! TREE_THIS_VOLATILE (exp)
3180               && ! DECL_NONLOCAL (exp)
3181               /* Don't regard global variables as simple.  They may be
3182                  allocated in ways unknown to the compiler (shared memory,
3183                  #pragma weak, etc).  */
3184               && ! TREE_PUBLIC (exp)
3185               && ! DECL_EXTERNAL (exp)
3186               /* Loading a static variable is unduly expensive, but global
3187                  registers aren't expensive.  */
3188               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3189 }
3190 \f
3191 /* The following functions are subroutines to fold_range_test and allow it to
3192    try to change a logical combination of comparisons into a range test.
3193
3194    For example, both
3195         X == 2 || X == 3 || X == 4 || X == 5
3196    and
3197         X >= 2 && X <= 5
3198    are converted to
3199         (unsigned) (X - 2) <= 3
3200
3201    We describe each set of comparisons as being either inside or outside
3202    a range, using a variable named like IN_P, and then describe the
3203    range with a lower and upper bound.  If one of the bounds is omitted,
3204    it represents either the highest or lowest value of the type.
3205
3206    In the comments below, we represent a range by two numbers in brackets
3207    preceded by a "+" to designate being inside that range, or a "-" to
3208    designate being outside that range, so the condition can be inverted by
3209    flipping the prefix.  An omitted bound is represented by a "-".  For
3210    example, "- [-, 10]" means being outside the range starting at the lowest
3211    possible value and ending at 10, in other words, being greater than 10.
3212    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3213    always false.
3214
3215    We set up things so that the missing bounds are handled in a consistent
3216    manner so neither a missing bound nor "true" and "false" need to be
3217    handled using a special case.  */
3218
3219 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3220    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3221    and UPPER1_P are nonzero if the respective argument is an upper bound
3222    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3223    must be specified for a comparison.  ARG1 will be converted to ARG0's
3224    type if both are specified.  */
3225
3226 static tree
3227 range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
3228      enum tree_code code;
3229      tree type;
3230      tree arg0, arg1;
3231      int upper0_p, upper1_p;
3232 {
3233   tree tem;
3234   int result;
3235   int sgn0, sgn1;
3236
3237   /* If neither arg represents infinity, do the normal operation.
3238      Else, if not a comparison, return infinity.  Else handle the special
3239      comparison rules. Note that most of the cases below won't occur, but
3240      are handled for consistency.  */
3241
3242   if (arg0 != 0 && arg1 != 0)
3243     {
3244       tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
3245                          arg0, convert (TREE_TYPE (arg0), arg1)));
3246       STRIP_NOPS (tem);
3247       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3248     }
3249
3250   if (TREE_CODE_CLASS (code) != '<')
3251     return 0;
3252
3253   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3254      for neither.  In real maths, we cannot assume open ended ranges are
3255      the same. But, this is computer arithmetic, where numbers are finite.
3256      We can therefore make the transformation of any unbounded range with
3257      the value Z, Z being greater than any representable number. This permits
3258      us to treat unbounded ranges as equal. */
3259   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3260   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3261   switch (code)
3262     {
3263     case EQ_EXPR:
3264       result = sgn0 == sgn1;
3265       break;
3266     case NE_EXPR:
3267       result = sgn0 != sgn1;
3268       break;
3269     case LT_EXPR:
3270       result = sgn0 < sgn1;
3271       break;
3272     case LE_EXPR:
3273       result = sgn0 <= sgn1;
3274       break;
3275     case GT_EXPR:
3276       result = sgn0 > sgn1;
3277       break;
3278     case GE_EXPR:
3279       result = sgn0 >= sgn1;
3280       break;
3281     default:
3282       abort ();
3283     }
3284
3285   return convert (type, result ? integer_one_node : integer_zero_node);
3286 }
3287 \f
3288 /* Given EXP, a logical expression, set the range it is testing into
3289    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3290    actually being tested.  *PLOW and *PHIGH will be made of the same type
3291    as the returned expression.  If EXP is not a comparison, we will most
3292    likely not be returning a useful value and range.  */
3293
3294 static tree
3295 make_range (exp, pin_p, plow, phigh)
3296      tree exp;
3297      int *pin_p;
3298      tree *plow, *phigh;
3299 {
3300   enum tree_code code;
3301   tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
3302   tree orig_type = NULL_TREE;
3303   int in_p, n_in_p;
3304   tree low, high, n_low, n_high;
3305
3306   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3307      and see if we can refine the range.  Some of the cases below may not
3308      happen, but it doesn't seem worth worrying about this.  We "continue"
3309      the outer loop when we've changed something; otherwise we "break"
3310      the switch, which will "break" the while.  */
3311
3312   in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
3313
3314   while (1)
3315     {
3316       code = TREE_CODE (exp);
3317
3318       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3319         {
3320           arg0 = TREE_OPERAND (exp, 0);
3321           if (TREE_CODE_CLASS (code) == '<'
3322               || TREE_CODE_CLASS (code) == '1'
3323               || TREE_CODE_CLASS (code) == '2')
3324             type = TREE_TYPE (arg0);
3325           if (TREE_CODE_CLASS (code) == '2'
3326               || TREE_CODE_CLASS (code) == '<'
3327               || (TREE_CODE_CLASS (code) == 'e'
3328                   && TREE_CODE_LENGTH (code) > 1))
3329             arg1 = TREE_OPERAND (exp, 1);
3330         }
3331
3332       /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
3333          lose a cast by accident.  */
3334       if (type != NULL_TREE && orig_type == NULL_TREE)
3335         orig_type = type;
3336
3337       switch (code)
3338         {
3339         case TRUTH_NOT_EXPR:
3340           in_p = ! in_p, exp = arg0;
3341           continue;
3342
3343         case EQ_EXPR: case NE_EXPR:
3344         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3345           /* We can only do something if the range is testing for zero
3346              and if the second operand is an integer constant.  Note that
3347              saying something is "in" the range we make is done by
3348              complementing IN_P since it will set in the initial case of
3349              being not equal to zero; "out" is leaving it alone.  */
3350           if (low == 0 || high == 0
3351               || ! integer_zerop (low) || ! integer_zerop (high)
3352               || TREE_CODE (arg1) != INTEGER_CST)
3353             break;
3354
3355           switch (code)
3356             {
3357             case NE_EXPR:  /* - [c, c]  */
3358               low = high = arg1;
3359               break;
3360             case EQ_EXPR:  /* + [c, c]  */
3361               in_p = ! in_p, low = high = arg1;
3362               break;
3363             case GT_EXPR:  /* - [-, c] */
3364               low = 0, high = arg1;
3365               break;
3366             case GE_EXPR:  /* + [c, -] */
3367               in_p = ! in_p, low = arg1, high = 0;
3368               break;
3369             case LT_EXPR:  /* - [c, -] */
3370               low = arg1, high = 0;
3371               break;
3372             case LE_EXPR:  /* + [-, c] */
3373               in_p = ! in_p, low = 0, high = arg1;
3374               break;
3375             default:
3376               abort ();
3377             }
3378
3379           exp = arg0;
3380
3381           /* If this is an unsigned comparison, we also know that EXP is
3382              greater than or equal to zero.  We base the range tests we make
3383              on that fact, so we record it here so we can parse existing
3384              range tests.  */
3385           if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
3386             {
3387               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3388                                   1, convert (type, integer_zero_node),
3389                                   NULL_TREE))
3390                 break;
3391
3392               in_p = n_in_p, low = n_low, high = n_high;
3393
3394               /* If the high bound is missing, but we
3395                  have a low bound, reverse the range so
3396                  it goes from zero to the low bound minus 1.  */
3397               if (high == 0 && low)
3398                 {
3399                   in_p = ! in_p;
3400                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3401                                       integer_one_node, 0);
3402                   low = convert (type, integer_zero_node);
3403                 }
3404             }
3405           continue;
3406
3407         case NEGATE_EXPR:
3408           /* (-x) IN [a,b] -> x in [-b, -a]  */
3409           n_low = range_binop (MINUS_EXPR, type,
3410                                convert (type, integer_zero_node), 0, high, 1);
3411           n_high = range_binop (MINUS_EXPR, type,
3412                                 convert (type, integer_zero_node), 0, low, 0);
3413           low = n_low, high = n_high;
3414           exp = arg0;
3415           continue;
3416
3417         case BIT_NOT_EXPR:
3418           /* ~ X -> -X - 1  */
3419           exp = build (MINUS_EXPR, type, negate_expr (arg0),
3420                        convert (type, integer_one_node));
3421           continue;
3422
3423         case PLUS_EXPR:  case MINUS_EXPR:
3424           if (TREE_CODE (arg1) != INTEGER_CST)
3425             break;
3426
3427           /* If EXP is signed, any overflow in the computation is undefined,
3428              so we don't worry about it so long as our computations on
3429              the bounds don't overflow.  For unsigned, overflow is defined
3430              and this is exactly the right thing.  */
3431           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3432                                type, low, 0, arg1, 0);
3433           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3434                                 type, high, 1, arg1, 0);
3435           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3436               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3437             break;
3438
3439           /* Check for an unsigned range which has wrapped around the maximum
3440              value thus making n_high < n_low, and normalize it.  */
3441           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3442             {
3443               low = range_binop (PLUS_EXPR, type, n_high, 0,
3444                                  integer_one_node, 0);
3445               high = range_binop (MINUS_EXPR, type, n_low, 0,
3446                                   integer_one_node, 0);
3447
3448               /* If the range is of the form +/- [ x+1, x ], we won't
3449                  be able to normalize it.  But then, it represents the
3450                  whole range or the empty set, so make it
3451                  +/- [ -, - ].  */
3452               if (tree_int_cst_equal (n_low, low)
3453                   && tree_int_cst_equal (n_high, high))
3454                 low = high = 0;
3455               else
3456                 in_p = ! in_p;
3457             }
3458           else
3459             low = n_low, high = n_high;
3460
3461           exp = arg0;
3462           continue;
3463
3464         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3465           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3466             break;
3467
3468           if (! INTEGRAL_TYPE_P (type)
3469               || (low != 0 && ! int_fits_type_p (low, type))
3470               || (high != 0 && ! int_fits_type_p (high, type)))
3471             break;
3472
3473           n_low = low, n_high = high;
3474
3475           if (n_low != 0)
3476             n_low = convert (type, n_low);
3477
3478           if (n_high != 0)
3479             n_high = convert (type, n_high);
3480
3481           /* If we're converting from an unsigned to a signed type,
3482              we will be doing the comparison as unsigned.  The tests above
3483              have already verified that LOW and HIGH are both positive.
3484
3485              So we have to make sure that the original unsigned value will
3486              be interpreted as positive.  */
3487           if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3488             {
3489               tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
3490               tree high_positive;
3491
3492               /* A range without an upper bound is, naturally, unbounded.
3493                  Since convert would have cropped a very large value, use
3494                  the max value for the destination type.  */
3495               high_positive
3496                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3497                   : TYPE_MAX_VALUE (type);
3498
3499               high_positive = fold (build (RSHIFT_EXPR, type,
3500                                            convert (type, high_positive),
3501                                            convert (type, integer_one_node)));
3502
3503               /* If the low bound is specified, "and" the range with the
3504                  range for which the original unsigned value will be
3505                  positive.  */
3506               if (low != 0)
3507                 {
3508                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3509                                       1, n_low, n_high,
3510                                       1, convert (type, integer_zero_node),
3511                                       high_positive))
3512                     break;
3513
3514                   in_p = (n_in_p == in_p);
3515                 }
3516               else
3517                 {
3518                   /* Otherwise, "or" the range with the range of the input
3519                      that will be interpreted as negative.  */
3520                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3521                                       0, n_low, n_high,
3522                                       1, convert (type, integer_zero_node),
3523                                       high_positive))
3524                     break;
3525
3526                   in_p = (in_p != n_in_p);
3527                 }
3528             }
3529
3530           exp = arg0;
3531           low = n_low, high = n_high;
3532           continue;
3533
3534         default:
3535           break;
3536         }
3537
3538       break;
3539     }
3540
3541   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3542   if (TREE_CODE (exp) == INTEGER_CST)
3543     {
3544       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3545                                                  exp, 0, low, 0))
3546                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3547                                                     exp, 1, high, 1)));
3548       low = high = 0;
3549       exp = 0;
3550     }
3551
3552   *pin_p = in_p, *plow = low, *phigh = high;
3553   return exp;
3554 }
3555 \f
3556 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3557    type, TYPE, return an expression to test if EXP is in (or out of, depending
3558    on IN_P) the range.  */
3559
3560 static tree
3561 build_range_check (type, exp, in_p, low, high)
3562      tree type;
3563      tree exp;
3564      int in_p;
3565      tree low, high;
3566 {
3567   tree etype = TREE_TYPE (exp);
3568   tree utype, value;
3569
3570   if (! in_p
3571       && (0 != (value = build_range_check (type, exp, 1, low, high))))
3572     return invert_truthvalue (value);
3573
3574   else if (low == 0 && high == 0)
3575     return convert (type, integer_one_node);
3576
3577   else if (low == 0)
3578     return fold (build (LE_EXPR, type, exp, high));
3579
3580   else if (high == 0)
3581     return fold (build (GE_EXPR, type, exp, low));
3582
3583   else if (operand_equal_p (low, high, 0))
3584     return fold (build (EQ_EXPR, type, exp, low));
3585
3586   else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3587     return build_range_check (type, exp, 1, 0, high);
3588
3589   else if (integer_zerop (low))
3590     {
3591       utype = unsigned_type (etype);
3592       return build_range_check (type, convert (utype, exp), 1, 0,
3593                                 convert (utype, high));
3594     }
3595
3596   else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3597            && ! TREE_OVERFLOW (value))
3598     return build_range_check (type,
3599                               fold (build (MINUS_EXPR, etype, exp, low)),
3600                               1, convert (etype, integer_zero_node), value);
3601   else
3602     return 0;
3603 }
3604 \f
3605 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3606    can, 0 if we can't.  Set the output range into the specified parameters.  */
3607
3608 static int
3609 merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3610      int *pin_p;
3611      tree *plow, *phigh;
3612      int in0_p, in1_p;
3613      tree low0, high0, low1, high1;
3614 {
3615   int no_overlap;
3616   int subset;
3617   int temp;
3618   tree tem;
3619   int in_p;
3620   tree low, high;
3621   int lowequal = ((low0 == 0 && low1 == 0)
3622                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3623                                                 low0, 0, low1, 0)));
3624   int highequal = ((high0 == 0 && high1 == 0)
3625                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3626                                                  high0, 1, high1, 1)));
3627
3628   /* Make range 0 be the range that starts first, or ends last if they
3629      start at the same value.  Swap them if it isn't.  */
3630   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3631                                  low0, 0, low1, 0))
3632       || (lowequal
3633           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3634                                         high1, 1, high0, 1))))
3635     {
3636       temp = in0_p, in0_p = in1_p, in1_p = temp;
3637       tem = low0, low0 = low1, low1 = tem;
3638       tem = high0, high0 = high1, high1 = tem;
3639     }
3640
3641   /* Now flag two cases, whether the ranges are disjoint or whether the
3642      second range is totally subsumed in the first.  Note that the tests
3643      below are simplified by the ones above.  */
3644   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3645                                           high0, 1, low1, 0));
3646   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3647                                       high1, 1, high0, 1));
3648
3649   /* We now have four cases, depending on whether we are including or
3650      excluding the two ranges.  */
3651   if (in0_p && in1_p)
3652     {
3653       /* If they don't overlap, the result is false.  If the second range
3654          is a subset it is the result.  Otherwise, the range is from the start
3655          of the second to the end of the first.  */
3656       if (no_overlap)
3657         in_p = 0, low = high = 0;
3658       else if (subset)
3659         in_p = 1, low = low1, high = high1;
3660       else
3661         in_p = 1, low = low1, high = high0;
3662     }
3663
3664   else if (in0_p && ! in1_p)
3665     {
3666       /* If they don't overlap, the result is the first range.  If they are
3667          equal, the result is false.  If the second range is a subset of the
3668          first, and the ranges begin at the same place, we go from just after
3669          the end of the first range to the end of the second.  If the second
3670          range is not a subset of the first, or if it is a subset and both
3671          ranges end at the same place, the range starts at the start of the
3672          first range and ends just before the second range.
3673          Otherwise, we can't describe this as a single range.  */
3674       if (no_overlap)
3675         in_p = 1, low = low0, high = high0;
3676       else if (lowequal && highequal)
3677         in_p = 0, low = high = 0;
3678       else if (subset && lowequal)
3679         {
3680           in_p = 1, high = high0;
3681           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3682                              integer_one_node, 0);
3683         }
3684       else if (! subset || highequal)
3685         {
3686           in_p = 1, low = low0;
3687           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3688                               integer_one_node, 0);
3689         }
3690       else
3691         return 0;
3692     }
3693
3694   else if (! in0_p && in1_p)
3695     {
3696       /* If they don't overlap, the result is the second range.  If the second
3697          is a subset of the first, the result is false.  Otherwise,
3698          the range starts just after the first range and ends at the
3699          end of the second.  */
3700       if (no_overlap)
3701         in_p = 1, low = low1, high = high1;
3702       else if (subset || highequal)
3703         in_p = 0, low = high = 0;
3704       else
3705         {
3706           in_p = 1, high = high1;
3707           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3708                              integer_one_node, 0);
3709         }
3710     }
3711
3712   else
3713     {
3714       /* The case where we are excluding both ranges.  Here the complex case
3715          is if they don't overlap.  In that case, the only time we have a
3716          range is if they are adjacent.  If the second is a subset of the
3717          first, the result is the first.  Otherwise, the range to exclude
3718          starts at the beginning of the first range and ends at the end of the
3719          second.  */
3720       if (no_overlap)
3721         {
3722           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3723                                          range_binop (PLUS_EXPR, NULL_TREE,
3724                                                       high0, 1,
3725                                                       integer_one_node, 1),
3726                                          1, low1, 0)))
3727             in_p = 0, low = low0, high = high1;
3728           else
3729             return 0;
3730         }
3731       else if (subset)
3732         in_p = 0, low = low0, high = high0;
3733       else
3734         in_p = 0, low = low0, high = high1;
3735     }
3736
3737   *pin_p = in_p, *plow = low, *phigh = high;
3738   return 1;
3739 }
3740 \f
3741 /* EXP is some logical combination of boolean tests.  See if we can
3742    merge it into some range test.  Return the new tree if so.  */
3743
3744 static tree
3745 fold_range_test (exp)
3746      tree exp;
3747 {
3748   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3749                || TREE_CODE (exp) == TRUTH_OR_EXPR);
3750   int in0_p, in1_p, in_p;
3751   tree low0, low1, low, high0, high1, high;
3752   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3753   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3754   tree tem;
3755
3756   /* If this is an OR operation, invert both sides; we will invert
3757      again at the end.  */
3758   if (or_op)
3759     in0_p = ! in0_p, in1_p = ! in1_p;
3760
3761   /* If both expressions are the same, if we can merge the ranges, and we
3762      can build the range test, return it or it inverted.  If one of the
3763      ranges is always true or always false, consider it to be the same
3764      expression as the other.  */
3765   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3766       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3767                        in1_p, low1, high1)
3768       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3769                                          lhs != 0 ? lhs
3770                                          : rhs != 0 ? rhs : integer_zero_node,
3771                                          in_p, low, high))))
3772     return or_op ? invert_truthvalue (tem) : tem;
3773
3774   /* On machines where the branch cost is expensive, if this is a
3775      short-circuited branch and the underlying object on both sides
3776      is the same, make a non-short-circuit operation.  */
3777   else if (BRANCH_COST >= 2
3778            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3779                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3780            && operand_equal_p (lhs, rhs, 0))
3781     {
3782       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
3783          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3784          which cases we can't do this.  */
3785       if (simple_operand_p (lhs))
3786         return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3787                       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3788                       TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3789                       TREE_OPERAND (exp, 1));
3790
3791       else if (global_bindings_p () == 0
3792                && ! contains_placeholder_p (lhs))
3793         {
3794           tree common = save_expr (lhs);
3795
3796           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3797                                              or_op ? ! in0_p : in0_p,
3798                                              low0, high0))
3799               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3800                                                  or_op ? ! in1_p : in1_p,
3801                                                  low1, high1))))
3802             return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3803                           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3804                           TREE_TYPE (exp), lhs, rhs);
3805         }
3806     }
3807
3808   return 0;
3809 }
3810 \f
3811 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3812    bit value.  Arrange things so the extra bits will be set to zero if and
3813    only if C is signed-extended to its full width.  If MASK is nonzero,
3814    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
3815
3816 static tree
3817 unextend (c, p, unsignedp, mask)
3818      tree c;
3819      int p;
3820      int unsignedp;
3821      tree mask;
3822 {
3823   tree type = TREE_TYPE (c);
3824   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3825   tree temp;
3826
3827   if (p == modesize || unsignedp)
3828     return c;
3829
3830   /* We work by getting just the sign bit into the low-order bit, then
3831      into the high-order bit, then sign-extend.  We then XOR that value
3832      with C.  */
3833   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3834   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3835
3836   /* We must use a signed type in order to get an arithmetic right shift.
3837      However, we must also avoid introducing accidental overflows, so that
3838      a subsequent call to integer_zerop will work.  Hence we must
3839      do the type conversion here.  At this point, the constant is either
3840      zero or one, and the conversion to a signed type can never overflow.
3841      We could get an overflow if this conversion is done anywhere else.  */
3842   if (TREE_UNSIGNED (type))
3843     temp = convert (signed_type (type), temp);
3844
3845   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3846   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3847   if (mask != 0)
3848     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3849   /* If necessary, convert the type back to match the type of C.  */
3850   if (TREE_UNSIGNED (type))
3851     temp = convert (type, temp);
3852
3853   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3854 }
3855 \f
3856 /* Find ways of folding logical expressions of LHS and RHS:
3857    Try to merge two comparisons to the same innermost item.
3858    Look for range tests like "ch >= '0' && ch <= '9'".
3859    Look for combinations of simple terms on machines with expensive branches
3860    and evaluate the RHS unconditionally.
3861
3862    For example, if we have p->a == 2 && p->b == 4 and we can make an
3863    object large enough to span both A and B, we can do this with a comparison
3864    against the object ANDed with the a mask.
3865
3866    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3867    operations to do this with one comparison.
3868
3869    We check for both normal comparisons and the BIT_AND_EXPRs made this by
3870    function and the one above.
3871
3872    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
3873    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3874
3875    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3876    two operands.
3877
3878    We return the simplified tree or 0 if no optimization is possible.  */
3879
3880 static tree
3881 fold_truthop (code, truth_type, lhs, rhs)
3882      enum tree_code code;
3883      tree truth_type, lhs, rhs;
3884 {
3885   /* If this is the "or" of two comparisons, we can do something if
3886      the comparisons are NE_EXPR.  If this is the "and", we can do something
3887      if the comparisons are EQ_EXPR.  I.e.,
3888         (a->b == 2 && a->c == 4) can become (a->new == NEW).
3889
3890      WANTED_CODE is this operation code.  For single bit fields, we can
3891      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3892      comparison for one-bit fields.  */
3893
3894   enum tree_code wanted_code;
3895   enum tree_code lcode, rcode;
3896   tree ll_arg, lr_arg, rl_arg, rr_arg;
3897   tree ll_inner, lr_inner, rl_inner, rr_inner;
3898   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3899   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3900   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3901   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3902   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3903   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3904   enum machine_mode lnmode, rnmode;
3905   tree ll_mask, lr_mask, rl_mask, rr_mask;
3906   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3907   tree l_const, r_const;
3908   tree lntype, rntype, result;
3909   int first_bit, end_bit;
3910   int volatilep;
3911
3912   /* Start by getting the comparison codes.  Fail if anything is volatile.
3913      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3914      it were surrounded with a NE_EXPR.  */
3915
3916   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3917     return 0;
3918
3919   lcode = TREE_CODE (lhs);
3920   rcode = TREE_CODE (rhs);
3921
3922   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3923     lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3924
3925   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3926     rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3927
3928   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3929     return 0;
3930
3931   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3932           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3933
3934   ll_arg = TREE_OPERAND (lhs, 0);
3935   lr_arg = TREE_OPERAND (lhs, 1);
3936   rl_arg = TREE_OPERAND (rhs, 0);
3937   rr_arg = TREE_OPERAND (rhs, 1);
3938
3939   /* If the RHS can be evaluated unconditionally and its operands are
3940      simple, it wins to evaluate the RHS unconditionally on machines
3941      with expensive branches.  In this case, this isn't a comparison
3942      that can be merged.  Avoid doing this if the RHS is a floating-point
3943      comparison since those can trap.  */
3944
3945   if (BRANCH_COST >= 2
3946       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
3947       && simple_operand_p (rl_arg)
3948       && simple_operand_p (rr_arg))
3949     return build (code, truth_type, lhs, rhs);
3950
3951   /* See if the comparisons can be merged.  Then get all the parameters for
3952      each side.  */
3953
3954   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3955       || (rcode != EQ_EXPR && rcode != NE_EXPR))
3956     return 0;
3957
3958   volatilep = 0;
3959   ll_inner = decode_field_reference (ll_arg,
3960                                      &ll_bitsize, &ll_bitpos, &ll_mode,
3961                                      &ll_unsignedp, &volatilep, &ll_mask,
3962                                      &ll_and_mask);
3963   lr_inner = decode_field_reference (lr_arg,
3964                                      &lr_bitsize, &lr_bitpos, &lr_mode,
3965                                      &lr_unsignedp, &volatilep, &lr_mask,
3966                                      &lr_and_mask);
3967   rl_inner = decode_field_reference (rl_arg,
3968                                      &rl_bitsize, &rl_bitpos, &rl_mode,
3969                                      &rl_unsignedp, &volatilep, &rl_mask,
3970                                      &rl_and_mask);
3971   rr_inner = decode_field_reference (rr_arg,
3972                                      &rr_bitsize, &rr_bitpos, &rr_mode,
3973                                      &rr_unsignedp, &volatilep, &rr_mask,
3974                                      &rr_and_mask);
3975
3976   /* It must be true that the inner operation on the lhs of each
3977      comparison must be the same if we are to be able to do anything.
3978      Then see if we have constants.  If not, the same must be true for
3979      the rhs's.  */
3980   if (volatilep || ll_inner == 0 || rl_inner == 0
3981       || ! operand_equal_p (ll_inner, rl_inner, 0))
3982     return 0;
3983
3984   if (TREE_CODE (lr_arg) == INTEGER_CST
3985       && TREE_CODE (rr_arg) == INTEGER_CST)
3986     l_const = lr_arg, r_const = rr_arg;
3987   else if (lr_inner == 0 || rr_inner == 0
3988            || ! operand_equal_p (lr_inner, rr_inner, 0))
3989     return 0;
3990   else
3991     l_const = r_const = 0;
3992
3993   /* If either comparison code is not correct for our logical operation,
3994      fail.  However, we can convert a one-bit comparison against zero into
3995      the opposite comparison against that bit being set in the field.  */
3996
3997   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3998   if (lcode != wanted_code)
3999     {
4000       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
4001         {
4002           /* Make the left operand unsigned, since we are only interested
4003              in the value of one bit.  Otherwise we are doing the wrong
4004              thing below.  */
4005           ll_unsignedp = 1;
4006           l_const = ll_mask;
4007         }
4008       else
4009         return 0;
4010     }
4011
4012   /* This is analogous to the code for l_const above.  */
4013   if (rcode != wanted_code)
4014     {
4015       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
4016         {
4017           rl_unsignedp = 1;
4018           r_const = rl_mask;
4019         }
4020       else
4021         return 0;
4022     }
4023
4024   /* See if we can find a mode that contains both fields being compared on
4025      the left.  If we can't, fail.  Otherwise, update all constants and masks
4026      to be relative to a field of that size.  */
4027   first_bit = MIN (ll_bitpos, rl_bitpos);
4028   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
4029   lnmode = get_best_mode (end_bit - first_bit, first_bit,
4030                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
4031                           volatilep);
4032   if (lnmode == VOIDmode)
4033     return 0;
4034
4035   lnbitsize = GET_MODE_BITSIZE (lnmode);
4036   lnbitpos = first_bit & ~ (lnbitsize - 1);
4037   lntype = type_for_size (lnbitsize, 1);
4038   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
4039
4040   if (BYTES_BIG_ENDIAN)
4041     {
4042       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
4043       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
4044     }
4045
4046   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
4047                          size_int (xll_bitpos), 0);
4048   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
4049                          size_int (xrl_bitpos), 0);
4050
4051   if (l_const)
4052     {
4053       l_const = convert (lntype, l_const);
4054       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
4055       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
4056       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
4057                                         fold (build1 (BIT_NOT_EXPR,
4058                                                       lntype, ll_mask)),
4059                                         0)))
4060         {
4061           warning ("comparison is always %d", wanted_code == NE_EXPR);
4062
4063           return convert (truth_type,
4064                           wanted_code == NE_EXPR
4065                           ? integer_one_node : integer_zero_node);
4066         }
4067     }
4068   if (r_const)
4069     {
4070       r_const = convert (lntype, r_const);
4071       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
4072       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
4073       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
4074                                         fold (build1 (BIT_NOT_EXPR,
4075                                                       lntype, rl_mask)),
4076                                         0)))
4077         {
4078           warning ("comparison is always %d", wanted_code == NE_EXPR);
4079
4080           return convert (truth_type,
4081                           wanted_code == NE_EXPR
4082                           ? integer_one_node : integer_zero_node);
4083         }
4084     }
4085
4086   /* If the right sides are not constant, do the same for it.  Also,
4087      disallow this optimization if a size or signedness mismatch occurs
4088      between the left and right sides.  */
4089   if (l_const == 0)
4090     {
4091       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4092           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4093           /* Make sure the two fields on the right
4094              correspond to the left without being swapped.  */
4095           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4096         return 0;
4097
4098       first_bit = MIN (lr_bitpos, rr_bitpos);
4099       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4100       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4101                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4102                               volatilep);
4103       if (rnmode == VOIDmode)
4104         return 0;
4105
4106       rnbitsize = GET_MODE_BITSIZE (rnmode);
4107       rnbitpos = first_bit & ~ (rnbitsize - 1);
4108       rntype = type_for_size (rnbitsize, 1);
4109       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4110
4111       if (BYTES_BIG_ENDIAN)
4112         {
4113           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4114           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4115         }
4116
4117       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
4118                              size_int (xlr_bitpos), 0);
4119       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
4120                              size_int (xrr_bitpos), 0);
4121
4122       /* Make a mask that corresponds to both fields being compared.
4123          Do this for both items being compared.  If the operands are the
4124          same size and the bits being compared are in the same position
4125          then we can do this by masking both and comparing the masked
4126          results.  */
4127       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4128       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4129       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4130         {
4131           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4132                                     ll_unsignedp || rl_unsignedp);
4133           if (! all_ones_mask_p (ll_mask, lnbitsize))
4134             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
4135
4136           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4137                                     lr_unsignedp || rr_unsignedp);
4138           if (! all_ones_mask_p (lr_mask, rnbitsize))
4139             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
4140
4141           return build (wanted_code, truth_type, lhs, rhs);
4142         }
4143
4144       /* There is still another way we can do something:  If both pairs of
4145          fields being compared are adjacent, we may be able to make a wider
4146          field containing them both.
4147
4148          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4149          the mask must be shifted to account for the shift done by
4150          make_bit_field_ref.  */
4151       if ((ll_bitsize + ll_bitpos == rl_bitpos
4152            && lr_bitsize + lr_bitpos == rr_bitpos)
4153           || (ll_bitpos == rl_bitpos + rl_bitsize
4154               && lr_bitpos == rr_bitpos + rr_bitsize))
4155         {
4156           tree type;
4157
4158           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4159                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4160           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4161                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4162
4163           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4164                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4165           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4166                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4167
4168           /* Convert to the smaller type before masking out unwanted bits.  */
4169           type = lntype;
4170           if (lntype != rntype)
4171             {
4172               if (lnbitsize > rnbitsize)
4173                 {
4174                   lhs = convert (rntype, lhs);
4175                   ll_mask = convert (rntype, ll_mask);
4176                   type = rntype;
4177                 }
4178               else if (lnbitsize < rnbitsize)
4179                 {
4180                   rhs = convert (lntype, rhs);
4181                   lr_mask = convert (lntype, lr_mask);
4182                   type = lntype;
4183                 }
4184             }
4185
4186           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4187             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
4188
4189           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4190             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
4191
4192           return build (wanted_code, truth_type, lhs, rhs);
4193         }
4194
4195       return 0;
4196     }
4197
4198   /* Handle the case of comparisons with constants.  If there is something in
4199      common between the masks, those bits of the constants must be the same.
4200      If not, the condition is always false.  Test for this to avoid generating
4201      incorrect code below.  */
4202   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4203   if (! integer_zerop (result)
4204       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4205                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4206     {
4207       if (wanted_code == NE_EXPR)
4208         {
4209           warning ("`or' of unmatched not-equal tests is always 1");
4210           return convert (truth_type, integer_one_node);
4211         }
4212       else
4213         {
4214           warning ("`and' of mutually exclusive equal-tests is always 0");
4215           return convert (truth_type, integer_zero_node);
4216         }
4217     }
4218
4219   /* Construct the expression we will return.  First get the component
4220      reference we will make.  Unless the mask is all ones the width of
4221      that field, perform the mask operation.  Then compare with the
4222      merged constant.  */
4223   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4224                                ll_unsignedp || rl_unsignedp);
4225
4226   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4227   if (! all_ones_mask_p (ll_mask, lnbitsize))
4228     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
4229
4230   return build (wanted_code, truth_type, result,
4231                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4232 }
4233 \f
4234 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4235    constant.  */
4236
4237 static tree
4238 optimize_minmax_comparison (t)
4239      tree t;
4240 {
4241   tree type = TREE_TYPE (t);
4242   tree arg0 = TREE_OPERAND (t, 0);
4243   enum tree_code op_code;
4244   tree comp_const = TREE_OPERAND (t, 1);
4245   tree minmax_const;
4246   int consts_equal, consts_lt;
4247   tree inner;
4248
4249   STRIP_SIGN_NOPS (arg0);
4250
4251   op_code = TREE_CODE (arg0);
4252   minmax_const = TREE_OPERAND (arg0, 1);
4253   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4254   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4255   inner = TREE_OPERAND (arg0, 0);
4256
4257   /* If something does not permit us to optimize, return the original tree.  */
4258   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4259       || TREE_CODE (comp_const) != INTEGER_CST
4260       || TREE_CONSTANT_OVERFLOW (comp_const)
4261       || TREE_CODE (minmax_const) != INTEGER_CST
4262       || TREE_CONSTANT_OVERFLOW (minmax_const))
4263     return t;
4264
4265   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4266      and GT_EXPR, doing the rest with recursive calls using logical
4267      simplifications.  */
4268   switch (TREE_CODE (t))
4269     {
4270     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4271       return
4272         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4273
4274     case GE_EXPR:
4275       return
4276         fold (build (TRUTH_ORIF_EXPR, type,
4277                      optimize_minmax_comparison
4278                      (build (EQ_EXPR, type, arg0, comp_const)),
4279                      optimize_minmax_comparison
4280                      (build (GT_EXPR, type, arg0, comp_const))));
4281
4282     case EQ_EXPR:
4283       if (op_code == MAX_EXPR && consts_equal)
4284         /* MAX (X, 0) == 0  ->  X <= 0  */
4285         return fold (build (LE_EXPR, type, inner, comp_const));
4286
4287       else if (op_code == MAX_EXPR && consts_lt)
4288         /* MAX (X, 0) == 5  ->  X == 5   */
4289         return fold (build (EQ_EXPR, type, inner, comp_const));
4290
4291       else if (op_code == MAX_EXPR)
4292         /* MAX (X, 0) == -1  ->  false  */
4293         return omit_one_operand (type, integer_zero_node, inner);
4294
4295       else if (consts_equal)
4296         /* MIN (X, 0) == 0  ->  X >= 0  */
4297         return fold (build (GE_EXPR, type, inner, comp_const));
4298
4299       else if (consts_lt)
4300         /* MIN (X, 0) == 5  ->  false  */
4301         return omit_one_operand (type, integer_zero_node, inner);
4302
4303       else
4304         /* MIN (X, 0) == -1  ->  X == -1  */
4305         return fold (build (EQ_EXPR, type, inner, comp_const));
4306
4307     case GT_EXPR:
4308       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4309         /* MAX (X, 0) > 0  ->  X > 0
4310            MAX (X, 0) > 5  ->  X > 5  */
4311         return fold (build (GT_EXPR, type, inner, comp_const));
4312
4313       else if (op_code == MAX_EXPR)
4314         /* MAX (X, 0) > -1  ->  true  */
4315         return omit_one_operand (type, integer_one_node, inner);
4316
4317       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4318         /* MIN (X, 0) > 0  ->  false
4319            MIN (X, 0) > 5  ->  false  */
4320         return omit_one_operand (type, integer_zero_node, inner);
4321
4322       else
4323         /* MIN (X, 0) > -1  ->  X > -1  */
4324         return fold (build (GT_EXPR, type, inner, comp_const));
4325
4326     default:
4327       return t;
4328     }
4329 }
4330 \f
4331 /* T is an integer expression that is being multiplied, divided, or taken a
4332    modulus (CODE says which and what kind of divide or modulus) by a
4333    constant C.  See if we can eliminate that operation by folding it with
4334    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4335    should be used for the computation if wider than our type.
4336
4337    For example, if we are dividing (X * 8) + (Y + 16) by 4, we can return
4338    (X * 2) + (Y + 4).  We must, however, be assured that either the original
4339    expression would not overflow or that overflow is undefined for the type
4340    in the language in question.
4341
4342    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4343    the machine has a multiply-accumulate insn or that this is part of an
4344    addressing calculation.
4345
4346    If we return a non-null expression, it is an equivalent form of the
4347    original computation, but need not be in the original type.  */
4348
4349 static tree
4350 extract_muldiv (t, c, code, wide_type)
4351      tree t;
4352      tree c;
4353      enum tree_code code;
4354      tree wide_type;
4355 {
4356   tree type = TREE_TYPE (t);
4357   enum tree_code tcode = TREE_CODE (t);
4358   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4359                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4360                 ? wide_type : type);
4361   tree t1, t2;
4362   int same_p = tcode == code;
4363   tree op0 = NULL_TREE, op1 = NULL_TREE;
4364
4365   /* Don't deal with constants of zero here; they confuse the code below.  */
4366   if (integer_zerop (c))
4367     return NULL_TREE;
4368
4369   if (TREE_CODE_CLASS (tcode) == '1')
4370     op0 = TREE_OPERAND (t, 0);
4371
4372   if (TREE_CODE_CLASS (tcode) == '2')
4373     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4374
4375   /* Note that we need not handle conditional operations here since fold
4376      already handles those cases.  So just do arithmetic here.  */
4377   switch (tcode)
4378     {
4379     case INTEGER_CST:
4380       /* For a constant, we can always simplify if we are a multiply
4381          or (for divide and modulus) if it is a multiple of our constant.  */
4382       if (code == MULT_EXPR
4383           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4384         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4385       break;
4386
4387     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4388       /* If op0 is an expression, and is unsigned, and the type is
4389          smaller than ctype, then we cannot widen the expression.  */
4390       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
4391            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
4392            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
4393            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
4394           && TREE_UNSIGNED (TREE_TYPE (op0))
4395           && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
4396                 && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
4397           && (GET_MODE_SIZE (TYPE_MODE (ctype))
4398               > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
4399         break;
4400
4401       /* Pass the constant down and see if we can make a simplification.  If
4402          we can, replace this expression with the inner simplification for
4403          possible later conversion to our or some other type.  */
4404       if (0 != (t1 = extract_muldiv (op0, convert (TREE_TYPE (op0), c), code,
4405                                      code == MULT_EXPR ? ctype : NULL_TREE)))
4406         return t1;
4407       break;
4408
4409     case NEGATE_EXPR:  case ABS_EXPR:
4410       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4411         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4412       break;
4413
4414     case MIN_EXPR:  case MAX_EXPR:
4415       /* If widening the type changes the signedness, then we can't perform
4416          this optimization as that changes the result.  */
4417       if (TREE_UNSIGNED (ctype) != TREE_UNSIGNED (type))
4418         break;
4419
4420       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4421       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4422           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4423         {
4424           if (tree_int_cst_sgn (c) < 0)
4425             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4426
4427           return fold (build (tcode, ctype, convert (ctype, t1),
4428                               convert (ctype, t2)));
4429         }
4430       break;
4431
4432     case WITH_RECORD_EXPR:
4433       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4434         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4435                       TREE_OPERAND (t, 1));
4436       break;
4437
4438     case SAVE_EXPR:
4439       /* If this has not been evaluated and the operand has no side effects,
4440          we can see if we can do something inside it and make a new one.
4441          Note that this test is overly conservative since we can do this
4442          if the only reason it had side effects is that it was another
4443          similar SAVE_EXPR, but that isn't worth bothering with.  */
4444       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4445           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4446                                         wide_type)))
4447         return save_expr (t1);
4448       break;
4449
4450     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4451       /* If the second operand is constant, this is a multiplication
4452          or floor division, by a power of two, so we can treat it that
4453          way unless the multiplier or divisor overflows.  */
4454       if (TREE_CODE (op1) == INTEGER_CST
4455           /* const_binop may not detect overflow correctly,
4456              so check for it explicitly here.  */
4457           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
4458           && TREE_INT_CST_HIGH (op1) == 0
4459           && 0 != (t1 = convert (ctype,
4460                                  const_binop (LSHIFT_EXPR, size_one_node,
4461                                               op1, 0)))
4462           && ! TREE_OVERFLOW (t1))
4463         return extract_muldiv (build (tcode == LSHIFT_EXPR
4464                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4465                                       ctype, convert (ctype, op0), t1),
4466                                c, code, wide_type);
4467       break;
4468
4469     case PLUS_EXPR:  case MINUS_EXPR:
4470       /* See if we can eliminate the operation on both sides.  If we can, we
4471          can return a new PLUS or MINUS.  If we can't, the only remaining
4472          cases where we can do anything are if the second operand is a
4473          constant.  */
4474       t1 = extract_muldiv (op0, c, code, wide_type);
4475       t2 = extract_muldiv (op1, c, code, wide_type);
4476       if (t1 != 0 && t2 != 0)
4477         return fold (build (tcode, ctype, convert (ctype, t1),
4478                             convert (ctype, t2)));
4479
4480       /* If this was a subtraction, negate OP1 and set it to be an addition.
4481          This simplifies the logic below.  */
4482       if (tcode == MINUS_EXPR)
4483         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4484
4485       if (TREE_CODE (op1) != INTEGER_CST)
4486         break;
4487
4488       /* If either OP1 or C are negative, this optimization is not safe for
4489          some of the division and remainder types while for others we need
4490          to change the code.  */
4491       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4492         {
4493           if (code == CEIL_DIV_EXPR)
4494             code = FLOOR_DIV_EXPR;
4495           else if (code == CEIL_MOD_EXPR)
4496             code = FLOOR_MOD_EXPR;
4497           else if (code == FLOOR_DIV_EXPR)
4498             code = CEIL_DIV_EXPR;
4499           else if (code == FLOOR_MOD_EXPR)
4500             code = CEIL_MOD_EXPR;
4501           else if (code != MULT_EXPR)
4502             break;
4503         }
4504
4505       /* If it's a multiply or a division/modulus operation of a multiple
4506          of our constant, do the operation and verify it doesn't overflow.  */
4507       if (code == MULT_EXPR
4508           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4509         {
4510           op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4511           if (op1 == 0 || TREE_OVERFLOW (op1))
4512             break;
4513         }
4514       else
4515         break;
4516
4517       /* If we have an unsigned type is not a sizetype, we cannot widen
4518          the operation since it will change the result if the original
4519          computation overflowed.  */
4520       if (TREE_UNSIGNED (ctype)
4521           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
4522           && ctype != type)
4523         break;
4524
4525       /* If we were able to eliminate our operation from the first side,
4526          apply our operation to the second side and reform the PLUS.  */
4527       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4528         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4529
4530       /* The last case is if we are a multiply.  In that case, we can
4531          apply the distributive law to commute the multiply and addition
4532          if the multiplication of the constants doesn't overflow. */
4533       if (code == MULT_EXPR)
4534         return fold (build (tcode, ctype, fold (build (code, ctype,
4535                                                        convert (ctype, op0),
4536                                                        convert (ctype, c))),
4537                             op1));
4538
4539       break;
4540
4541     case MULT_EXPR:
4542       /* We have a special case here if we are doing something like
4543          (C * 8) % 4 since we know that's zero.  */
4544       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4545            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4546           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4547           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4548         return omit_one_operand (type, integer_zero_node, op0);
4549
4550       /* ... fall through ... */
4551
4552     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4553     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4554       /* If we can extract our operation from the LHS, do so and return a
4555          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4556          do something only if the second operand is a constant.  */
4557       if (same_p
4558           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4559         return fold (build (tcode, ctype, convert (ctype, t1),
4560                             convert (ctype, op1)));
4561       else if (tcode == MULT_EXPR && code == MULT_EXPR
4562                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4563         return fold (build (tcode, ctype, convert (ctype, op0),
4564                             convert (ctype, t1)));
4565       else if (TREE_CODE (op1) != INTEGER_CST)
4566         return 0;
4567
4568       /* If these are the same operation types, we can associate them
4569          assuming no overflow.  */
4570       if (tcode == code
4571           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4572                                      convert (ctype, c), 0))
4573           && ! TREE_OVERFLOW (t1))
4574         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4575
4576       /* If these operations "cancel" each other, we have the main
4577          optimizations of this pass, which occur when either constant is a
4578          multiple of the other, in which case we replace this with either an
4579          operation or CODE or TCODE.
4580
4581          If we have an unsigned type that is not a sizetype, we canot do
4582          this since it will change the result if the original computation
4583          overflowed.  */
4584       if ((! TREE_UNSIGNED (ctype)
4585            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
4586           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4587               || (tcode == MULT_EXPR
4588                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4589                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
4590         {
4591           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4592             return fold (build (tcode, ctype, convert (ctype, op0),
4593                                 convert (ctype,
4594                                          const_binop (TRUNC_DIV_EXPR,
4595                                                       op1, c, 0))));
4596           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4597             return fold (build (code, ctype, convert (ctype, op0),
4598                                 convert (ctype,
4599                                          const_binop (TRUNC_DIV_EXPR,
4600                                                       c, op1, 0))));
4601         }
4602       break;
4603
4604     default:
4605       break;
4606     }
4607
4608   return 0;
4609 }
4610 \f
4611 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4612    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4613    that we may sometimes modify the tree.  */
4614
4615 static tree
4616 strip_compound_expr (t, s)
4617      tree t;
4618      tree s;
4619 {
4620   enum tree_code code = TREE_CODE (t);
4621
4622   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4623   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4624       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4625     return TREE_OPERAND (t, 1);
4626
4627   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4628      don't bother handling any other types.  */
4629   else if (code == COND_EXPR)
4630     {
4631       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4632       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4633       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4634     }
4635   else if (TREE_CODE_CLASS (code) == '1')
4636     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4637   else if (TREE_CODE_CLASS (code) == '<'
4638            || TREE_CODE_CLASS (code) == '2')
4639     {
4640       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4641       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4642     }
4643
4644   return t;
4645 }
4646 \f
4647 /* Return a node which has the indicated constant VALUE (either 0 or
4648    1), and is of the indicated TYPE.  */
4649
4650 static tree
4651 constant_boolean_node (value, type)
4652      int value;
4653      tree type;
4654 {
4655   if (type == integer_type_node)
4656     return value ? integer_one_node : integer_zero_node;
4657   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4658     return truthvalue_conversion (value ? integer_one_node :
4659                                   integer_zero_node);
4660   else
4661     {
4662       tree t = build_int_2 (value, 0);
4663
4664       TREE_TYPE (t) = type;
4665       return t;
4666     }
4667 }
4668
4669 /* Utility function for the following routine, to see how complex a nesting of
4670    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4671    we don't care (to avoid spending too much time on complex expressions.).  */
4672
4673 static int
4674 count_cond (expr, lim)
4675      tree expr;
4676      int lim;
4677 {
4678   int true, false;
4679
4680   if (TREE_CODE (expr) != COND_EXPR)
4681     return 0;
4682   else if (lim <= 0)
4683     return 0;
4684
4685   true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4686   false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
4687   return MIN (lim, 1 + true + false);
4688 }
4689 \f
4690 /* Perform constant folding and related simplification of EXPR.
4691    The related simplifications include x*1 => x, x*0 => 0, etc.,
4692    and application of the associative law.
4693    NOP_EXPR conversions may be removed freely (as long as we
4694    are careful not to change the C type of the overall expression)
4695    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4696    but we can constant-fold them if they have constant operands.  */
4697
4698 tree
4699 fold (expr)
4700      tree expr;
4701 {
4702   register tree t = expr;
4703   tree t1 = NULL_TREE;
4704   tree tem;
4705   tree type = TREE_TYPE (expr);
4706   register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4707   register enum tree_code code = TREE_CODE (t);
4708   register int kind;
4709   int invert;
4710   /* WINS will be nonzero when the switch is done
4711      if all operands are constant.  */
4712   int wins = 1;
4713
4714   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4715      Likewise for a SAVE_EXPR that's already been evaluated.  */
4716   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
4717     return t;
4718
4719   /* Return right away if already constant.  */
4720   if (TREE_CONSTANT (t))
4721     {
4722       if (code == CONST_DECL)
4723         return DECL_INITIAL (t);
4724       return t;
4725     }
4726
4727 #ifdef MAX_INTEGER_COMPUTATION_MODE
4728   check_max_integer_computation_mode (expr);
4729 #endif
4730
4731   kind = TREE_CODE_CLASS (code);
4732   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4733     {
4734       tree subop;
4735
4736       /* Special case for conversion ops that can have fixed point args.  */
4737       arg0 = TREE_OPERAND (t, 0);
4738
4739       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4740       if (arg0 != 0)
4741         STRIP_SIGN_NOPS (arg0);
4742
4743       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4744         subop = TREE_REALPART (arg0);
4745       else
4746         subop = arg0;
4747
4748       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4749 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4750           && TREE_CODE (subop) != REAL_CST
4751 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4752           )
4753         /* Note that TREE_CONSTANT isn't enough:
4754            static var addresses are constant but we can't
4755            do arithmetic on them.  */
4756         wins = 0;
4757     }
4758   else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
4759     {
4760       register int len = TREE_CODE_LENGTH (code);
4761       register int i;
4762       for (i = 0; i < len; i++)
4763         {
4764           tree op = TREE_OPERAND (t, i);
4765           tree subop;
4766
4767           if (op == 0)
4768             continue;           /* Valid for CALL_EXPR, at least.  */
4769
4770           if (kind == '<' || code == RSHIFT_EXPR)
4771             {
4772               /* Signedness matters here.  Perhaps we can refine this
4773                  later.  */
4774               STRIP_SIGN_NOPS (op);
4775             }
4776           else
4777             /* Strip any conversions that don't change the mode.  */
4778             STRIP_NOPS (op);
4779
4780           if (TREE_CODE (op) == COMPLEX_CST)
4781             subop = TREE_REALPART (op);
4782           else
4783             subop = op;
4784
4785           if (TREE_CODE (subop) != INTEGER_CST
4786 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4787               && TREE_CODE (subop) != REAL_CST
4788 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4789               )
4790             /* Note that TREE_CONSTANT isn't enough:
4791                static var addresses are constant but we can't
4792                do arithmetic on them.  */
4793             wins = 0;
4794
4795           if (i == 0)
4796             arg0 = op;
4797           else if (i == 1)
4798             arg1 = op;
4799         }
4800     }
4801
4802   /* If this is a commutative operation, and ARG0 is a constant, move it
4803      to ARG1 to reduce the number of tests below.  */
4804   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4805        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4806        || code == BIT_AND_EXPR)
4807       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4808     {
4809       tem = arg0; arg0 = arg1; arg1 = tem;
4810
4811       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4812       TREE_OPERAND (t, 1) = tem;
4813     }
4814
4815   /* Now WINS is set as described above,
4816      ARG0 is the first operand of EXPR,
4817      and ARG1 is the second operand (if it has more than one operand).
4818
4819      First check for cases where an arithmetic operation is applied to a
4820      compound, conditional, or comparison operation.  Push the arithmetic
4821      operation inside the compound or conditional to see if any folding
4822      can then be done.  Convert comparison to conditional for this purpose.
4823      The also optimizes non-constant cases that used to be done in
4824      expand_expr.
4825
4826      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
4827      one of the operands is a comparison and the other is a comparison, a
4828      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
4829      code below would make the expression more complex.  Change it to a
4830      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
4831      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
4832
4833   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4834        || code == EQ_EXPR || code == NE_EXPR)
4835       && ((truth_value_p (TREE_CODE (arg0))
4836            && (truth_value_p (TREE_CODE (arg1))
4837                || (TREE_CODE (arg1) == BIT_AND_EXPR
4838                    && integer_onep (TREE_OPERAND (arg1, 1)))))
4839           || (truth_value_p (TREE_CODE (arg1))
4840               && (truth_value_p (TREE_CODE (arg0))
4841                   || (TREE_CODE (arg0) == BIT_AND_EXPR
4842                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
4843     {
4844       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4845                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4846                        : TRUTH_XOR_EXPR,
4847                        type, arg0, arg1));
4848
4849       if (code == EQ_EXPR)
4850         t = invert_truthvalue (t);
4851
4852       return t;
4853     }
4854
4855   if (TREE_CODE_CLASS (code) == '1')
4856     {
4857       if (TREE_CODE (arg0) == COMPOUND_EXPR)
4858         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4859                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4860       else if (TREE_CODE (arg0) == COND_EXPR)
4861         {
4862           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4863                            fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
4864                            fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
4865
4866           /* If this was a conversion, and all we did was to move into
4867              inside the COND_EXPR, bring it back out.  But leave it if
4868              it is a conversion from integer to integer and the
4869              result precision is no wider than a word since such a
4870              conversion is cheap and may be optimized away by combine,
4871              while it couldn't if it were outside the COND_EXPR.  Then return
4872              so we don't get into an infinite recursion loop taking the
4873              conversion out and then back in.  */
4874
4875           if ((code == NOP_EXPR || code == CONVERT_EXPR
4876                || code == NON_LVALUE_EXPR)
4877               && TREE_CODE (t) == COND_EXPR
4878               && TREE_CODE (TREE_OPERAND (t, 1)) == code
4879               && TREE_CODE (TREE_OPERAND (t, 2)) == code
4880               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4881                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4882               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4883                     && (INTEGRAL_TYPE_P
4884                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
4885                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4886             t = build1 (code, type,
4887                         build (COND_EXPR,
4888                                TREE_TYPE (TREE_OPERAND
4889                                           (TREE_OPERAND (t, 1), 0)),
4890                                TREE_OPERAND (t, 0),
4891                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4892                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4893           return t;
4894         }
4895       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4896         return fold (build (COND_EXPR, type, arg0,
4897                             fold (build1 (code, type, integer_one_node)),
4898                             fold (build1 (code, type, integer_zero_node))));
4899    }
4900   else if (TREE_CODE_CLASS (code) == '2'
4901            || TREE_CODE_CLASS (code) == '<')
4902     {
4903       if (TREE_CODE (arg1) == COMPOUND_EXPR)
4904         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4905                       fold (build (code, type,
4906                                    arg0, TREE_OPERAND (arg1, 1))));
4907       else if ((TREE_CODE (arg1) == COND_EXPR
4908                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4909                     && TREE_CODE_CLASS (code) != '<'))
4910                && (TREE_CODE (arg0) != COND_EXPR
4911                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4912                && (! TREE_SIDE_EFFECTS (arg0)
4913                    || (global_bindings_p () == 0
4914                        && ! contains_placeholder_p (arg0))))
4915         {
4916           tree test, true_value, false_value;
4917           tree lhs = 0, rhs = 0;
4918
4919           if (TREE_CODE (arg1) == COND_EXPR)
4920             {
4921               test = TREE_OPERAND (arg1, 0);
4922               true_value = TREE_OPERAND (arg1, 1);
4923               false_value = TREE_OPERAND (arg1, 2);
4924             }
4925           else
4926             {
4927               tree testtype = TREE_TYPE (arg1);
4928               test = arg1;
4929               true_value = convert (testtype, integer_one_node);
4930               false_value = convert (testtype, integer_zero_node);
4931             }
4932
4933           /* If ARG0 is complex we want to make sure we only evaluate
4934              it once.  Though this is only required if it is volatile, it
4935              might be more efficient even if it is not.  However, if we
4936              succeed in folding one part to a constant, we do not need
4937              to make this SAVE_EXPR.  Since we do this optimization
4938              primarily to see if we do end up with constant and this
4939              SAVE_EXPR interferes with later optimizations, suppressing
4940              it when we can is important.
4941
4942              If we are not in a function, we can't make a SAVE_EXPR, so don't
4943              try to do so.  Don't try to see if the result is a constant
4944              if an arm is a COND_EXPR since we get exponential behavior
4945              in that case.  */
4946
4947           if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4948               && global_bindings_p () == 0
4949               && ((TREE_CODE (arg0) != VAR_DECL
4950                    && TREE_CODE (arg0) != PARM_DECL)
4951                   || TREE_SIDE_EFFECTS (arg0)))
4952             {
4953               if (TREE_CODE (true_value) != COND_EXPR)
4954                 lhs = fold (build (code, type, arg0, true_value));
4955
4956               if (TREE_CODE (false_value) != COND_EXPR)
4957                 rhs = fold (build (code, type, arg0, false_value));
4958
4959               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4960                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
4961                 arg0 = save_expr (arg0), lhs = rhs = 0;
4962             }
4963
4964           if (lhs == 0)
4965             lhs = fold (build (code, type, arg0, true_value));
4966           if (rhs == 0)
4967             rhs = fold (build (code, type, arg0, false_value));
4968
4969           test = fold (build (COND_EXPR, type, test, lhs, rhs));
4970
4971           if (TREE_CODE (arg0) == SAVE_EXPR)
4972             return build (COMPOUND_EXPR, type,
4973                           convert (void_type_node, arg0),
4974                           strip_compound_expr (test, arg0));
4975           else
4976             return convert (type, test);
4977         }
4978
4979       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4980         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4981                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4982       else if ((TREE_CODE (arg0) == COND_EXPR
4983                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4984                     && TREE_CODE_CLASS (code) != '<'))
4985                && (TREE_CODE (arg1) != COND_EXPR
4986                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4987                && (! TREE_SIDE_EFFECTS (arg1)
4988                    || (global_bindings_p () == 0
4989                        && ! contains_placeholder_p (arg1))))
4990         {
4991           tree test, true_value, false_value;
4992           tree lhs = 0, rhs = 0;
4993
4994           if (TREE_CODE (arg0) == COND_EXPR)
4995             {
4996               test = TREE_OPERAND (arg0, 0);
4997               true_value = TREE_OPERAND (arg0, 1);
4998               false_value = TREE_OPERAND (arg0, 2);
4999             }
5000           else
5001             {
5002               tree testtype = TREE_TYPE (arg0);
5003               test = arg0;
5004               true_value = convert (testtype, integer_one_node);
5005               false_value = convert (testtype, integer_zero_node);
5006             }
5007
5008           if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
5009               && global_bindings_p () == 0
5010               && ((TREE_CODE (arg1) != VAR_DECL
5011                    && TREE_CODE (arg1) != PARM_DECL)
5012                   || TREE_SIDE_EFFECTS (arg1)))
5013             {
5014               if (TREE_CODE (true_value) != COND_EXPR)
5015                 lhs = fold (build (code, type, true_value, arg1));
5016
5017               if (TREE_CODE (false_value) != COND_EXPR)
5018                 rhs = fold (build (code, type, false_value, arg1));
5019
5020               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
5021                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
5022                 arg1 = save_expr (arg1), lhs = rhs = 0;
5023             }
5024
5025           if (lhs == 0)
5026             lhs = fold (build (code, type, true_value, arg1));
5027
5028           if (rhs == 0)
5029             rhs = fold (build (code, type, false_value, arg1));
5030
5031           test = fold (build (COND_EXPR, type, test, lhs, rhs));
5032           if (TREE_CODE (arg1) == SAVE_EXPR)
5033             return build (COMPOUND_EXPR, type,
5034                           convert (void_type_node, arg1),
5035                           strip_compound_expr (test, arg1));
5036           else
5037             return convert (type, test);
5038         }
5039     }
5040   else if (TREE_CODE_CLASS (code) == '<'
5041            && TREE_CODE (arg0) == COMPOUND_EXPR)
5042     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5043                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
5044   else if (TREE_CODE_CLASS (code) == '<'
5045            && TREE_CODE (arg1) == COMPOUND_EXPR)
5046     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
5047                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
5048
5049   switch (code)
5050     {
5051     case INTEGER_CST:
5052     case REAL_CST:
5053     case STRING_CST:
5054     case COMPLEX_CST:
5055     case CONSTRUCTOR:
5056       return t;
5057
5058     case CONST_DECL:
5059       return fold (DECL_INITIAL (t));
5060
5061     case NOP_EXPR:
5062     case FLOAT_EXPR:
5063     case CONVERT_EXPR:
5064     case FIX_TRUNC_EXPR:
5065       /* Other kinds of FIX are not handled properly by fold_convert.  */
5066
5067       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
5068         return TREE_OPERAND (t, 0);
5069
5070       /* Handle cases of two conversions in a row.  */
5071       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
5072           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
5073         {
5074           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5075           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
5076           tree final_type = TREE_TYPE (t);
5077           int inside_int = INTEGRAL_TYPE_P (inside_type);
5078           int inside_ptr = POINTER_TYPE_P (inside_type);
5079           int inside_float = FLOAT_TYPE_P (inside_type);
5080           unsigned int inside_prec = TYPE_PRECISION (inside_type);
5081           int inside_unsignedp = TREE_UNSIGNED (inside_type);
5082           int inter_int = INTEGRAL_TYPE_P (inter_type);
5083           int inter_ptr = POINTER_TYPE_P (inter_type);
5084           int inter_float = FLOAT_TYPE_P (inter_type);
5085           unsigned int inter_prec = TYPE_PRECISION (inter_type);
5086           int inter_unsignedp = TREE_UNSIGNED (inter_type);
5087           int final_int = INTEGRAL_TYPE_P (final_type);
5088           int final_ptr = POINTER_TYPE_P (final_type);
5089           int final_float = FLOAT_TYPE_P (final_type);
5090           unsigned int final_prec = TYPE_PRECISION (final_type);
5091           int final_unsignedp = TREE_UNSIGNED (final_type);
5092
5093           /* In addition to the cases of two conversions in a row
5094              handled below, if we are converting something to its own
5095              type via an object of identical or wider precision, neither
5096              conversion is needed.  */
5097           if (inside_type == final_type
5098               && ((inter_int && final_int) || (inter_float && final_float))
5099               && inter_prec >= final_prec)
5100             return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
5101
5102           /* Likewise, if the intermediate and final types are either both
5103              float or both integer, we don't need the middle conversion if
5104              it is wider than the final type and doesn't change the signedness
5105              (for integers).  Avoid this if the final type is a pointer
5106              since then we sometimes need the inner conversion.  Likewise if
5107              the outer has a precision not equal to the size of its mode.  */
5108           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
5109                || (inter_float && inside_float))
5110               && inter_prec >= inside_prec
5111               && (inter_float || inter_unsignedp == inside_unsignedp)
5112               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5113                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5114               && ! final_ptr)
5115             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5116
5117           /* If we have a sign-extension of a zero-extended value, we can
5118              replace that by a single zero-extension.  */
5119           if (inside_int && inter_int && final_int
5120               && inside_prec < inter_prec && inter_prec < final_prec
5121               && inside_unsignedp && !inter_unsignedp)
5122             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5123
5124           /* Two conversions in a row are not needed unless:
5125              - some conversion is floating-point (overstrict for now), or
5126              - the intermediate type is narrower than both initial and
5127                final, or
5128              - the intermediate type and innermost type differ in signedness,
5129                and the outermost type is wider than the intermediate, or
5130              - the initial type is a pointer type and the precisions of the
5131                intermediate and final types differ, or
5132              - the final type is a pointer type and the precisions of the
5133                initial and intermediate types differ.  */
5134           if (! inside_float && ! inter_float && ! final_float
5135               && (inter_prec > inside_prec || inter_prec > final_prec)
5136               && ! (inside_int && inter_int
5137                     && inter_unsignedp != inside_unsignedp
5138                     && inter_prec < final_prec)
5139               && ((inter_unsignedp && inter_prec > inside_prec)
5140                   == (final_unsignedp && final_prec > inter_prec))
5141               && ! (inside_ptr && inter_prec != final_prec)
5142               && ! (final_ptr && inside_prec != inter_prec)
5143               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5144                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5145               && ! final_ptr)
5146             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5147         }
5148
5149       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5150           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5151           /* Detect assigning a bitfield.  */
5152           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5153                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5154         {
5155           /* Don't leave an assignment inside a conversion
5156              unless assigning a bitfield.  */
5157           tree prev = TREE_OPERAND (t, 0);
5158           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5159           /* First do the assignment, then return converted constant.  */
5160           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5161           TREE_USED (t) = 1;
5162           return t;
5163         }
5164       if (!wins)
5165         {
5166           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5167           return t;
5168         }
5169       return fold_convert (t, arg0);
5170
5171 #if 0  /* This loses on &"foo"[0].  */
5172     case ARRAY_REF:
5173         {
5174           int i;
5175
5176           /* Fold an expression like: "foo"[2] */
5177           if (TREE_CODE (arg0) == STRING_CST
5178               && TREE_CODE (arg1) == INTEGER_CST
5179               && compare_tree_int (arg1, TREE_STRING_LENGTH (arg0)) < 0)
5180             {
5181               t = build_int_2 (TREE_STRING_POINTER (arg0)[TREE_INT_CST_LOW (arg))], 0);
5182               TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
5183               force_fit_type (t, 0);
5184             }
5185         }
5186       return t;
5187 #endif /* 0 */
5188
5189     case COMPONENT_REF:
5190       if (TREE_CODE (arg0) == CONSTRUCTOR)
5191         {
5192           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5193           if (m)
5194             t = TREE_VALUE (m);
5195         }
5196       return t;
5197
5198     case RANGE_EXPR:
5199       TREE_CONSTANT (t) = wins;
5200       return t;
5201
5202     case NEGATE_EXPR:
5203       if (wins)
5204         {
5205           if (TREE_CODE (arg0) == INTEGER_CST)
5206             {
5207               unsigned HOST_WIDE_INT low;
5208               HOST_WIDE_INT high;
5209               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5210                                          TREE_INT_CST_HIGH (arg0),
5211                                          &low, &high);
5212               t = build_int_2 (low, high);
5213               TREE_TYPE (t) = type;
5214               TREE_OVERFLOW (t)
5215                 = (TREE_OVERFLOW (arg0)
5216                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5217               TREE_CONSTANT_OVERFLOW (t)
5218                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5219             }
5220           else if (TREE_CODE (arg0) == REAL_CST)
5221             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5222         }
5223       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5224         return TREE_OPERAND (arg0, 0);
5225
5226       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5227       else if (TREE_CODE (arg0) == MINUS_EXPR
5228                && (! FLOAT_TYPE_P (type) || flag_fast_math))
5229         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5230                       TREE_OPERAND (arg0, 0));
5231
5232       return t;
5233
5234     case ABS_EXPR:
5235       if (wins)
5236         {
5237           if (TREE_CODE (arg0) == INTEGER_CST)
5238             {
5239               if (! TREE_UNSIGNED (type)
5240                   && TREE_INT_CST_HIGH (arg0) < 0)
5241                 {
5242                   unsigned HOST_WIDE_INT low;
5243                   HOST_WIDE_INT high;
5244                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5245                                              TREE_INT_CST_HIGH (arg0),
5246                                              &low, &high);
5247                   t = build_int_2 (low, high);
5248                   TREE_TYPE (t) = type;
5249                   TREE_OVERFLOW (t)
5250                     = (TREE_OVERFLOW (arg0)
5251                        | force_fit_type (t, overflow));
5252                   TREE_CONSTANT_OVERFLOW (t)
5253                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5254                 }
5255             }
5256           else if (TREE_CODE (arg0) == REAL_CST)
5257             {
5258               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5259                 t = build_real (type,
5260                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5261             }
5262         }
5263       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5264         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5265       return t;
5266
5267     case CONJ_EXPR:
5268       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5269         return convert (type, arg0);
5270       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5271         return build (COMPLEX_EXPR, type,
5272                       TREE_OPERAND (arg0, 0),
5273                       negate_expr (TREE_OPERAND (arg0, 1)));
5274       else if (TREE_CODE (arg0) == COMPLEX_CST)
5275         return build_complex (type, TREE_OPERAND (arg0, 0),
5276                               negate_expr (TREE_OPERAND (arg0, 1)));
5277       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5278         return fold (build (TREE_CODE (arg0), type,
5279                             fold (build1 (CONJ_EXPR, type,
5280                                           TREE_OPERAND (arg0, 0))),
5281                             fold (build1 (CONJ_EXPR,
5282                                           type, TREE_OPERAND (arg0, 1)))));
5283       else if (TREE_CODE (arg0) == CONJ_EXPR)
5284         return TREE_OPERAND (arg0, 0);
5285       return t;
5286
5287     case BIT_NOT_EXPR:
5288       if (wins)
5289         {
5290           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5291                            ~ TREE_INT_CST_HIGH (arg0));
5292           TREE_TYPE (t) = type;
5293           force_fit_type (t, 0);
5294           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5295           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5296         }
5297       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5298         return TREE_OPERAND (arg0, 0);
5299       return t;
5300
5301     case PLUS_EXPR:
5302       /* A + (-B) -> A - B */
5303       if (TREE_CODE (arg1) == NEGATE_EXPR)
5304         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5305       /* (-A) + B -> B - A */
5306       if (TREE_CODE (arg0) == NEGATE_EXPR)
5307         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5308       else if (! FLOAT_TYPE_P (type))
5309         {
5310           if (integer_zerop (arg1))
5311             return non_lvalue (convert (type, arg0));
5312
5313           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5314              with a constant, and the two constants have no bits in common,
5315              we should treat this as a BIT_IOR_EXPR since this may produce more
5316              simplifications.  */
5317           if (TREE_CODE (arg0) == BIT_AND_EXPR
5318               && TREE_CODE (arg1) == BIT_AND_EXPR
5319               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5320               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5321               && integer_zerop (const_binop (BIT_AND_EXPR,
5322                                              TREE_OPERAND (arg0, 1),
5323                                              TREE_OPERAND (arg1, 1), 0)))
5324             {
5325               code = BIT_IOR_EXPR;
5326               goto bit_ior;
5327             }
5328
5329           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5330              (plus (plus (mult) (mult)) (foo)) so that we can
5331              take advantage of the factoring cases below.  */
5332           if ((TREE_CODE (arg0) == PLUS_EXPR
5333                && TREE_CODE (arg1) == MULT_EXPR)
5334               || (TREE_CODE (arg1) == PLUS_EXPR
5335                   && TREE_CODE (arg0) == MULT_EXPR))
5336             {
5337               tree parg0, parg1, parg, marg;
5338
5339               if (TREE_CODE (arg0) == PLUS_EXPR)
5340                 parg = arg0, marg = arg1;
5341               else
5342                 parg = arg1, marg = arg0;
5343               parg0 = TREE_OPERAND (parg, 0);
5344               parg1 = TREE_OPERAND (parg, 1);
5345               STRIP_NOPS (parg0);
5346               STRIP_NOPS (parg1);
5347
5348               if (TREE_CODE (parg0) == MULT_EXPR
5349                   && TREE_CODE (parg1) != MULT_EXPR)
5350                 return fold (build (PLUS_EXPR, type,
5351                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5352                                     parg1));
5353               if (TREE_CODE (parg0) != MULT_EXPR
5354                   && TREE_CODE (parg1) == MULT_EXPR)
5355                 return fold (build (PLUS_EXPR, type,
5356                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5357                                     parg0));
5358             }
5359
5360           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5361             {
5362               tree arg00, arg01, arg10, arg11;
5363               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5364
5365               /* (A * C) + (B * C) -> (A+B) * C.
5366                  We are most concerned about the case where C is a constant,
5367                  but other combinations show up during loop reduction.  Since
5368                  it is not difficult, try all four possibilities.  */
5369
5370               arg00 = TREE_OPERAND (arg0, 0);
5371               arg01 = TREE_OPERAND (arg0, 1);
5372               arg10 = TREE_OPERAND (arg1, 0);
5373               arg11 = TREE_OPERAND (arg1, 1);
5374               same = NULL_TREE;
5375
5376               if (operand_equal_p (arg01, arg11, 0))
5377                 same = arg01, alt0 = arg00, alt1 = arg10;
5378               else if (operand_equal_p (arg00, arg10, 0))
5379                 same = arg00, alt0 = arg01, alt1 = arg11;
5380               else if (operand_equal_p (arg00, arg11, 0))
5381                 same = arg00, alt0 = arg01, alt1 = arg10;
5382               else if (operand_equal_p (arg01, arg10, 0))
5383                 same = arg01, alt0 = arg00, alt1 = arg11;
5384
5385               /* No identical multiplicands; see if we can find a common
5386                  power-of-two factor in non-power-of-two multiplies.  This
5387                  can help in multi-dimensional array access.  */
5388               else if (TREE_CODE (arg01) == INTEGER_CST
5389                        && TREE_CODE (arg11) == INTEGER_CST
5390                        && TREE_INT_CST_HIGH (arg01) == 0
5391                        && TREE_INT_CST_HIGH (arg11) == 0)
5392                 {
5393                   HOST_WIDE_INT int01, int11, tmp;
5394                   int01 = TREE_INT_CST_LOW (arg01);
5395                   int11 = TREE_INT_CST_LOW (arg11);
5396
5397                   /* Move min of absolute values to int11.  */
5398                   if ((int01 >= 0 ? int01 : -int01)
5399                       < (int11 >= 0 ? int11 : -int11))
5400                     {
5401                       tmp = int01, int01 = int11, int11 = tmp;
5402                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5403                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5404                     }
5405
5406                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5407                     {
5408                       alt0 = fold (build (MULT_EXPR, type, arg00,
5409                                           build_int_2 (int01 / int11, 0)));
5410                       alt1 = arg10;
5411                       same = arg11;
5412                     }
5413                 }
5414
5415               if (same)
5416                 return fold (build (MULT_EXPR, type,
5417                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5418                                     same));
5419             }
5420         }
5421       /* In IEEE floating point, x+0 may not equal x.  */
5422       else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5423                 || flag_fast_math)
5424                && real_zerop (arg1))
5425         return non_lvalue (convert (type, arg0));
5426       /* x+(-0) equals x, even for IEEE.  */
5427       else if (TREE_CODE (arg1) == REAL_CST
5428                && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5429         return non_lvalue (convert (type, arg0));
5430
5431      bit_rotate:
5432       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5433          is a rotate of A by C1 bits.  */
5434       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5435          is a rotate of A by B bits.  */
5436       {
5437         register enum tree_code code0, code1;
5438         code0 = TREE_CODE (arg0);
5439         code1 = TREE_CODE (arg1);
5440         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5441              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5442             && operand_equal_p (TREE_OPERAND (arg0, 0),
5443                                 TREE_OPERAND (arg1, 0), 0)
5444             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5445           {
5446             register tree tree01, tree11;
5447             register enum tree_code code01, code11;
5448
5449             tree01 = TREE_OPERAND (arg0, 1);
5450             tree11 = TREE_OPERAND (arg1, 1);
5451             STRIP_NOPS (tree01);
5452             STRIP_NOPS (tree11);
5453             code01 = TREE_CODE (tree01);
5454             code11 = TREE_CODE (tree11);
5455             if (code01 == INTEGER_CST
5456                 && code11 == INTEGER_CST
5457                 && TREE_INT_CST_HIGH (tree01) == 0
5458                 && TREE_INT_CST_HIGH (tree11) == 0
5459                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5460                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5461               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5462                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5463             else if (code11 == MINUS_EXPR)
5464               {
5465                 tree tree110, tree111;
5466                 tree110 = TREE_OPERAND (tree11, 0);
5467                 tree111 = TREE_OPERAND (tree11, 1);
5468                 STRIP_NOPS (tree110);
5469                 STRIP_NOPS (tree111);
5470                 if (TREE_CODE (tree110) == INTEGER_CST
5471                     && 0 == compare_tree_int (tree110,
5472                                               TYPE_PRECISION
5473                                               (TREE_TYPE (TREE_OPERAND
5474                                                           (arg0, 0))))
5475                     && operand_equal_p (tree01, tree111, 0))
5476                   return build ((code0 == LSHIFT_EXPR
5477                                  ? LROTATE_EXPR
5478                                  : RROTATE_EXPR),
5479                                 type, TREE_OPERAND (arg0, 0), tree01);
5480               }
5481             else if (code01 == MINUS_EXPR)
5482               {
5483                 tree tree010, tree011;
5484                 tree010 = TREE_OPERAND (tree01, 0);
5485                 tree011 = TREE_OPERAND (tree01, 1);
5486                 STRIP_NOPS (tree010);
5487                 STRIP_NOPS (tree011);
5488                 if (TREE_CODE (tree010) == INTEGER_CST
5489                     && 0 == compare_tree_int (tree010,
5490                                               TYPE_PRECISION
5491                                               (TREE_TYPE (TREE_OPERAND
5492                                                           (arg0, 0))))
5493                     && operand_equal_p (tree11, tree011, 0))
5494                   return build ((code0 != LSHIFT_EXPR
5495                                  ? LROTATE_EXPR
5496                                  : RROTATE_EXPR),
5497                                 type, TREE_OPERAND (arg0, 0), tree11);
5498               }
5499           }
5500       }
5501
5502     associate:
5503       /* In most languages, can't associate operations on floats through
5504          parentheses.  Rather than remember where the parentheses were, we
5505          don't associate floats at all.  It shouldn't matter much.  However,
5506          associating multiplications is only very slightly inaccurate, so do
5507          that if -ffast-math is specified.  */
5508
5509       if (! wins
5510           && (! FLOAT_TYPE_P (type)
5511               || (flag_fast_math && code != MULT_EXPR)))
5512         {
5513           tree var0, con0, lit0, var1, con1, lit1;
5514
5515           /* Split both trees into variables, constants, and literals.  Then
5516              associate each group together, the constants with literals,
5517              then the result with variables.  This increases the chances of
5518              literals being recombined later and of generating relocatable
5519              expressions for the sum of a constant and literal. */
5520           var0 = split_tree (arg0, code, &con0, &lit0, 0);
5521           var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
5522
5523           /* Only do something if we found more than two objects.  Otherwise,
5524              nothing has changed and we risk infinite recursion.  */
5525           if (2 < ((var0 != 0) + (var1 != 0) + (con0 != 0) + (con1 != 0)
5526                    + (lit0 != 0) + (lit1 != 0)))
5527             {
5528               var0 = associate_trees (var0, var1, code, type);
5529               con0 = associate_trees (con0, con1, code, type);
5530               lit0 = associate_trees (lit0, lit1, code, type);
5531               con0 = associate_trees (con0, lit0, code, type);
5532               return convert (type, associate_trees (var0, con0, code, type));
5533             }
5534         }
5535
5536     binary:
5537 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
5538       if (TREE_CODE (arg1) == REAL_CST)
5539         return t;
5540 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
5541       if (wins)
5542         t1 = const_binop (code, arg0, arg1, 0);
5543       if (t1 != NULL_TREE)
5544         {
5545           /* The return value should always have
5546              the same type as the original expression.  */
5547           if (TREE_TYPE (t1) != TREE_TYPE (t))
5548             t1 = convert (TREE_TYPE (t), t1);
5549
5550           return t1;
5551         }
5552       return t;
5553
5554     case MINUS_EXPR:
5555       /* A - (-B) -> A + B */
5556       if (TREE_CODE (arg1) == NEGATE_EXPR)
5557         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5558       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5559       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5560         return
5561           fold (build (MINUS_EXPR, type,
5562                        build_real (TREE_TYPE (arg1),
5563                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5564                        TREE_OPERAND (arg0, 0)));
5565
5566       if (! FLOAT_TYPE_P (type))
5567         {
5568           if (! wins && integer_zerop (arg0))
5569             return negate_expr (convert (type, arg1));
5570           if (integer_zerop (arg1))
5571             return non_lvalue (convert (type, arg0));
5572
5573           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5574              about the case where C is a constant, just try one of the
5575              four possibilities.  */
5576
5577           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5578               && operand_equal_p (TREE_OPERAND (arg0, 1),
5579                                   TREE_OPERAND (arg1, 1), 0))
5580             return fold (build (MULT_EXPR, type,
5581                                 fold (build (MINUS_EXPR, type,
5582                                              TREE_OPERAND (arg0, 0),
5583                                              TREE_OPERAND (arg1, 0))),
5584                                 TREE_OPERAND (arg0, 1)));
5585         }
5586
5587       else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5588                || flag_fast_math)
5589         {
5590           /* Except with IEEE floating point, 0-x equals -x.  */
5591           if (! wins && real_zerop (arg0))
5592             return negate_expr (convert (type, arg1));
5593           /* Except with IEEE floating point, x-0 equals x.  */
5594           if (real_zerop (arg1))
5595             return non_lvalue (convert (type, arg0));
5596         }
5597
5598       /* Fold &x - &x.  This can happen from &x.foo - &x.
5599          This is unsafe for certain floats even in non-IEEE formats.
5600          In IEEE, it is unsafe because it does wrong for NaNs.
5601          Also note that operand_equal_p is always false if an operand
5602          is volatile.  */
5603
5604       if ((! FLOAT_TYPE_P (type) || flag_fast_math)
5605           && operand_equal_p (arg0, arg1, 0))
5606         return convert (type, integer_zero_node);
5607
5608       goto associate;
5609
5610     case MULT_EXPR:
5611       /* (-A) * (-B) -> A * B  */
5612       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5613         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5614                             TREE_OPERAND (arg1, 0)));
5615
5616       if (! FLOAT_TYPE_P (type))
5617         {
5618           if (integer_zerop (arg1))
5619             return omit_one_operand (type, arg1, arg0);
5620           if (integer_onep (arg1))
5621             return non_lvalue (convert (type, arg0));
5622
5623           /* (a * (1 << b)) is (a << b)  */
5624           if (TREE_CODE (arg1) == LSHIFT_EXPR
5625               && integer_onep (TREE_OPERAND (arg1, 0)))
5626             return fold (build (LSHIFT_EXPR, type, arg0,
5627                                 TREE_OPERAND (arg1, 1)));
5628           if (TREE_CODE (arg0) == LSHIFT_EXPR
5629               && integer_onep (TREE_OPERAND (arg0, 0)))
5630             return fold (build (LSHIFT_EXPR, type, arg1,
5631                                 TREE_OPERAND (arg0, 1)));
5632
5633           if (TREE_CODE (arg1) == INTEGER_CST
5634               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5635                                              code, NULL_TREE)))
5636             return convert (type, tem);
5637
5638         }
5639       else
5640         {
5641           /* x*0 is 0, except for IEEE floating point.  */
5642           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5643                || flag_fast_math)
5644               && real_zerop (arg1))
5645             return omit_one_operand (type, arg1, arg0);
5646           /* In IEEE floating point, x*1 is not equivalent to x for snans.
5647              However, ANSI says we can drop signals,
5648              so we can do this anyway.  */
5649           if (real_onep (arg1))
5650             return non_lvalue (convert (type, arg0));
5651           /* x*2 is x+x */
5652           if (! wins && real_twop (arg1) && global_bindings_p () == 0
5653               && ! contains_placeholder_p (arg0))
5654             {
5655               tree arg = save_expr (arg0);
5656               return build (PLUS_EXPR, type, arg, arg);
5657             }
5658         }
5659       goto associate;
5660
5661     case BIT_IOR_EXPR:
5662     bit_ior:
5663       if (integer_all_onesp (arg1))
5664         return omit_one_operand (type, arg1, arg0);
5665       if (integer_zerop (arg1))
5666         return non_lvalue (convert (type, arg0));
5667       t1 = distribute_bit_expr (code, type, arg0, arg1);
5668       if (t1 != NULL_TREE)
5669         return t1;
5670
5671       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5672
5673          This results in more efficient code for machines without a NAND
5674          instruction.  Combine will canonicalize to the first form
5675          which will allow use of NAND instructions provided by the
5676          backend if they exist.  */
5677       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5678           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5679         {
5680           return fold (build1 (BIT_NOT_EXPR, type,
5681                                build (BIT_AND_EXPR, type,
5682                                       TREE_OPERAND (arg0, 0),
5683                                       TREE_OPERAND (arg1, 0))));
5684         }
5685
5686       /* See if this can be simplified into a rotate first.  If that
5687          is unsuccessful continue in the association code.  */
5688       goto bit_rotate;
5689
5690     case BIT_XOR_EXPR:
5691       if (integer_zerop (arg1))
5692         return non_lvalue (convert (type, arg0));
5693       if (integer_all_onesp (arg1))
5694         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5695
5696       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5697          with a constant, and the two constants have no bits in common,
5698          we should treat this as a BIT_IOR_EXPR since this may produce more
5699          simplifications.  */
5700       if (TREE_CODE (arg0) == BIT_AND_EXPR
5701           && TREE_CODE (arg1) == BIT_AND_EXPR
5702           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5703           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5704           && integer_zerop (const_binop (BIT_AND_EXPR,
5705                                          TREE_OPERAND (arg0, 1),
5706                                          TREE_OPERAND (arg1, 1), 0)))
5707         {
5708           code = BIT_IOR_EXPR;
5709           goto bit_ior;
5710         }
5711
5712       /* See if this can be simplified into a rotate first.  If that
5713          is unsuccessful continue in the association code.  */
5714       goto bit_rotate;
5715
5716     case BIT_AND_EXPR:
5717     bit_and:
5718       if (integer_all_onesp (arg1))
5719         return non_lvalue (convert (type, arg0));
5720       if (integer_zerop (arg1))
5721         return omit_one_operand (type, arg1, arg0);
5722       t1 = distribute_bit_expr (code, type, arg0, arg1);
5723       if (t1 != NULL_TREE)
5724         return t1;
5725       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5726       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5727           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5728         {
5729           unsigned int prec
5730             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5731
5732           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5733               && (~TREE_INT_CST_LOW (arg0)
5734                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5735             return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5736         }
5737       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5738           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5739         {
5740           unsigned int prec
5741             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5742
5743           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5744               && (~TREE_INT_CST_LOW (arg1)
5745                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5746             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5747         }
5748
5749       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5750
5751          This results in more efficient code for machines without a NOR
5752          instruction.  Combine will canonicalize to the first form
5753          which will allow use of NOR instructions provided by the
5754          backend if they exist.  */
5755       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5756           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5757         {
5758           return fold (build1 (BIT_NOT_EXPR, type,
5759                                build (BIT_IOR_EXPR, type,
5760                                       TREE_OPERAND (arg0, 0),
5761                                       TREE_OPERAND (arg1, 0))));
5762         }
5763
5764       goto associate;
5765
5766     case BIT_ANDTC_EXPR:
5767       if (integer_all_onesp (arg0))
5768         return non_lvalue (convert (type, arg1));
5769       if (integer_zerop (arg0))
5770         return omit_one_operand (type, arg0, arg1);
5771       if (TREE_CODE (arg1) == INTEGER_CST)
5772         {
5773           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5774           code = BIT_AND_EXPR;
5775           goto bit_and;
5776         }
5777       goto binary;
5778
5779     case RDIV_EXPR:
5780       /* In most cases, do nothing with a divide by zero.  */
5781 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5782 #ifndef REAL_INFINITY
5783       if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5784         return t;
5785 #endif
5786 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5787
5788       /* (-A) / (-B) -> A / B  */
5789       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5790         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5791                             TREE_OPERAND (arg1, 0)));
5792
5793       /* In IEEE floating point, x/1 is not equivalent to x for snans.
5794          However, ANSI says we can drop signals, so we can do this anyway.  */
5795       if (real_onep (arg1))
5796         return non_lvalue (convert (type, arg0));
5797
5798       /* If ARG1 is a constant, we can convert this to a multiply by the
5799          reciprocal.  This does not have the same rounding properties,
5800          so only do this if -ffast-math.  We can actually always safely
5801          do it if ARG1 is a power of two, but it's hard to tell if it is
5802          or not in a portable manner.  */
5803       if (TREE_CODE (arg1) == REAL_CST)
5804         {
5805           if (flag_fast_math
5806               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5807                                           arg1, 0)))
5808             return fold (build (MULT_EXPR, type, arg0, tem));
5809           /* Find the reciprocal if optimizing and the result is exact. */
5810           else if (optimize)
5811             {
5812               REAL_VALUE_TYPE r;
5813               r = TREE_REAL_CST (arg1);
5814               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5815                 {
5816                   tem = build_real (type, r);
5817                   return fold (build (MULT_EXPR, type, arg0, tem));
5818                 }
5819             }
5820         }
5821       goto binary;
5822
5823     case TRUNC_DIV_EXPR:
5824     case ROUND_DIV_EXPR:
5825     case FLOOR_DIV_EXPR:
5826     case CEIL_DIV_EXPR:
5827     case EXACT_DIV_EXPR:
5828       if (integer_onep (arg1))
5829         return non_lvalue (convert (type, arg0));
5830       if (integer_zerop (arg1))
5831         return t;
5832
5833       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5834          operation, EXACT_DIV_EXPR.
5835
5836          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5837          At one time others generated faster code, it's not clear if they do
5838          after the last round to changes to the DIV code in expmed.c.  */
5839       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5840           && multiple_of_p (type, arg0, arg1))
5841         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5842
5843       if (TREE_CODE (arg1) == INTEGER_CST
5844           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5845                                          code, NULL_TREE)))
5846         return convert (type, tem);
5847
5848       goto binary;
5849
5850     case CEIL_MOD_EXPR:
5851     case FLOOR_MOD_EXPR:
5852     case ROUND_MOD_EXPR:
5853     case TRUNC_MOD_EXPR:
5854       if (integer_onep (arg1))
5855         return omit_one_operand (type, integer_zero_node, arg0);
5856       if (integer_zerop (arg1))
5857         return t;
5858
5859       if (TREE_CODE (arg1) == INTEGER_CST
5860           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5861                                          code, NULL_TREE)))
5862         return convert (type, tem);
5863
5864       goto binary;
5865
5866     case LSHIFT_EXPR:
5867     case RSHIFT_EXPR:
5868     case LROTATE_EXPR:
5869     case RROTATE_EXPR:
5870       if (integer_zerop (arg1))
5871         return non_lvalue (convert (type, arg0));
5872       /* Since negative shift count is not well-defined,
5873          don't try to compute it in the compiler.  */
5874       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5875         return t;
5876       /* Rewrite an LROTATE_EXPR by a constant into an
5877          RROTATE_EXPR by a new constant.  */
5878       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5879         {
5880           TREE_SET_CODE (t, RROTATE_EXPR);
5881           code = RROTATE_EXPR;
5882           TREE_OPERAND (t, 1) = arg1
5883             = const_binop
5884               (MINUS_EXPR,
5885                convert (TREE_TYPE (arg1),
5886                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5887                arg1, 0);
5888           if (tree_int_cst_sgn (arg1) < 0)
5889             return t;
5890         }
5891
5892       /* If we have a rotate of a bit operation with the rotate count and
5893          the second operand of the bit operation both constant,
5894          permute the two operations.  */
5895       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5896           && (TREE_CODE (arg0) == BIT_AND_EXPR
5897               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5898               || TREE_CODE (arg0) == BIT_IOR_EXPR
5899               || TREE_CODE (arg0) == BIT_XOR_EXPR)
5900           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5901         return fold (build (TREE_CODE (arg0), type,
5902                             fold (build (code, type,
5903                                          TREE_OPERAND (arg0, 0), arg1)),
5904                             fold (build (code, type,
5905                                          TREE_OPERAND (arg0, 1), arg1))));
5906
5907       /* Two consecutive rotates adding up to the width of the mode can
5908          be ignored.  */
5909       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5910           && TREE_CODE (arg0) == RROTATE_EXPR
5911           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5912           && TREE_INT_CST_HIGH (arg1) == 0
5913           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5914           && ((TREE_INT_CST_LOW (arg1)
5915                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5916               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
5917         return TREE_OPERAND (arg0, 0);
5918
5919       goto binary;
5920
5921     case MIN_EXPR:
5922       if (operand_equal_p (arg0, arg1, 0))
5923         return omit_one_operand (type, arg0, arg1);
5924       if (INTEGRAL_TYPE_P (type)
5925           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5926         return omit_one_operand (type, arg1, arg0);
5927       goto associate;
5928
5929     case MAX_EXPR:
5930       if (operand_equal_p (arg0, arg1, 0))
5931         return omit_one_operand (type, arg0, arg1);
5932       if (INTEGRAL_TYPE_P (type)
5933           && TYPE_MAX_VALUE (type)
5934           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5935         return omit_one_operand (type, arg1, arg0);
5936       goto associate;
5937
5938     case TRUTH_NOT_EXPR:
5939       /* Note that the operand of this must be an int
5940          and its values must be 0 or 1.
5941          ("true" is a fixed value perhaps depending on the language,
5942          but we don't handle values other than 1 correctly yet.)  */
5943       tem = invert_truthvalue (arg0);
5944       /* Avoid infinite recursion.  */
5945       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5946         return t;
5947       return convert (type, tem);
5948
5949     case TRUTH_ANDIF_EXPR:
5950       /* Note that the operands of this must be ints
5951          and their values must be 0 or 1.
5952          ("true" is a fixed value perhaps depending on the language.)  */
5953       /* If first arg is constant zero, return it.  */
5954       if (integer_zerop (arg0))
5955         return convert (type, arg0);
5956     case TRUTH_AND_EXPR:
5957       /* If either arg is constant true, drop it.  */
5958       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5959         return non_lvalue (convert (type, arg1));
5960       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5961         return non_lvalue (convert (type, arg0));
5962       /* If second arg is constant zero, result is zero, but first arg
5963          must be evaluated.  */
5964       if (integer_zerop (arg1))
5965         return omit_one_operand (type, arg1, arg0);
5966       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5967          case will be handled here.  */
5968       if (integer_zerop (arg0))
5969         return omit_one_operand (type, arg0, arg1);
5970
5971     truth_andor:
5972       /* We only do these simplifications if we are optimizing.  */
5973       if (!optimize)
5974         return t;
5975
5976       /* Check for things like (A || B) && (A || C).  We can convert this
5977          to A || (B && C).  Note that either operator can be any of the four
5978          truth and/or operations and the transformation will still be
5979          valid.   Also note that we only care about order for the
5980          ANDIF and ORIF operators.  If B contains side effects, this
5981          might change the truth-value of A. */
5982       if (TREE_CODE (arg0) == TREE_CODE (arg1)
5983           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5984               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5985               || TREE_CODE (arg0) == TRUTH_AND_EXPR
5986               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5987           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5988         {
5989           tree a00 = TREE_OPERAND (arg0, 0);
5990           tree a01 = TREE_OPERAND (arg0, 1);
5991           tree a10 = TREE_OPERAND (arg1, 0);
5992           tree a11 = TREE_OPERAND (arg1, 1);
5993           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5994                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5995                              && (code == TRUTH_AND_EXPR
5996                                  || code == TRUTH_OR_EXPR));
5997
5998           if (operand_equal_p (a00, a10, 0))
5999             return fold (build (TREE_CODE (arg0), type, a00,
6000                                 fold (build (code, type, a01, a11))));
6001           else if (commutative && operand_equal_p (a00, a11, 0))
6002             return fold (build (TREE_CODE (arg0), type, a00,
6003                                 fold (build (code, type, a01, a10))));
6004           else if (commutative && operand_equal_p (a01, a10, 0))
6005             return fold (build (TREE_CODE (arg0), type, a01,
6006                                 fold (build (code, type, a00, a11))));
6007
6008           /* This case if tricky because we must either have commutative
6009              operators or else A10 must not have side-effects.  */
6010
6011           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
6012                    && operand_equal_p (a01, a11, 0))
6013             return fold (build (TREE_CODE (arg0), type,
6014                                 fold (build (code, type, a00, a10)),
6015                                 a01));
6016         }
6017
6018       /* See if we can build a range comparison.  */
6019       if (0 != (tem = fold_range_test (t)))
6020         return tem;
6021
6022       /* Check for the possibility of merging component references.  If our
6023          lhs is another similar operation, try to merge its rhs with our
6024          rhs.  Then try to merge our lhs and rhs.  */
6025       if (TREE_CODE (arg0) == code
6026           && 0 != (tem = fold_truthop (code, type,
6027                                        TREE_OPERAND (arg0, 1), arg1)))
6028         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6029
6030       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
6031         return tem;
6032
6033       return t;
6034
6035     case TRUTH_ORIF_EXPR:
6036       /* Note that the operands of this must be ints
6037          and their values must be 0 or true.
6038          ("true" is a fixed value perhaps depending on the language.)  */
6039       /* If first arg is constant true, return it.  */
6040       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6041         return convert (type, arg0);
6042     case TRUTH_OR_EXPR:
6043       /* If either arg is constant zero, drop it.  */
6044       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
6045         return non_lvalue (convert (type, arg1));
6046       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
6047         return non_lvalue (convert (type, arg0));
6048       /* If second arg is constant true, result is true, but we must
6049          evaluate first arg.  */
6050       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
6051         return omit_one_operand (type, arg1, arg0);
6052       /* Likewise for first arg, but note this only occurs here for
6053          TRUTH_OR_EXPR.  */
6054       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6055         return omit_one_operand (type, arg0, arg1);
6056       goto truth_andor;
6057
6058     case TRUTH_XOR_EXPR:
6059       /* If either arg is constant zero, drop it.  */
6060       if (integer_zerop (arg0))
6061         return non_lvalue (convert (type, arg1));
6062       if (integer_zerop (arg1))
6063         return non_lvalue (convert (type, arg0));
6064       /* If either arg is constant true, this is a logical inversion.  */
6065       if (integer_onep (arg0))
6066         return non_lvalue (convert (type, invert_truthvalue (arg1)));
6067       if (integer_onep (arg1))
6068         return non_lvalue (convert (type, invert_truthvalue (arg0)));
6069       return t;
6070
6071     case EQ_EXPR:
6072     case NE_EXPR:
6073     case LT_EXPR:
6074     case GT_EXPR:
6075     case LE_EXPR:
6076     case GE_EXPR:
6077       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6078         {
6079           /* (-a) CMP (-b) -> b CMP a  */
6080           if (TREE_CODE (arg0) == NEGATE_EXPR
6081               && TREE_CODE (arg1) == NEGATE_EXPR)
6082             return fold (build (code, type, TREE_OPERAND (arg1, 0),
6083                                 TREE_OPERAND (arg0, 0)));
6084           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
6085           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
6086             return
6087               fold (build
6088                     (swap_tree_comparison (code), type,
6089                      TREE_OPERAND (arg0, 0),
6090                      build_real (TREE_TYPE (arg1),
6091                                  REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
6092           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
6093           /* a CMP (-0) -> a CMP 0  */
6094           if (TREE_CODE (arg1) == REAL_CST
6095               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
6096             return fold (build (code, type, arg0,
6097                                 build_real (TREE_TYPE (arg1), dconst0)));
6098         }
6099
6100       /* If one arg is a constant integer, put it last.  */
6101       if (TREE_CODE (arg0) == INTEGER_CST
6102           && TREE_CODE (arg1) != INTEGER_CST)
6103         {
6104           TREE_OPERAND (t, 0) = arg1;
6105           TREE_OPERAND (t, 1) = arg0;
6106           arg0 = TREE_OPERAND (t, 0);
6107           arg1 = TREE_OPERAND (t, 1);
6108           code = swap_tree_comparison (code);
6109           TREE_SET_CODE (t, code);
6110         }
6111
6112       /* Convert foo++ == CONST into ++foo == CONST + INCR.
6113          First, see if one arg is constant; find the constant arg
6114          and the other one.  */
6115       {
6116         tree constop = 0, varop = NULL_TREE;
6117         int constopnum = -1;
6118
6119         if (TREE_CONSTANT (arg1))
6120           constopnum = 1, constop = arg1, varop = arg0;
6121         if (TREE_CONSTANT (arg0))
6122           constopnum = 0, constop = arg0, varop = arg1;
6123
6124         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
6125           {
6126             /* This optimization is invalid for ordered comparisons
6127                if CONST+INCR overflows or if foo+incr might overflow.
6128                This optimization is invalid for floating point due to rounding.
6129                For pointer types we assume overflow doesn't happen.  */
6130             if (POINTER_TYPE_P (TREE_TYPE (varop))
6131                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6132                     && (code == EQ_EXPR || code == NE_EXPR)))
6133               {
6134                 tree newconst
6135                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6136                                  constop, TREE_OPERAND (varop, 1)));
6137
6138                 /* Do not overwrite the current varop to be a preincrement,
6139                    create a new node so that we won't confuse our caller who
6140                    might create trees and throw them away, reusing the
6141                    arguments that they passed to build.  This shows up in
6142                    the THEN or ELSE parts of ?: being postincrements.  */
6143                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6144                                TREE_OPERAND (varop, 0),
6145                                TREE_OPERAND (varop, 1));
6146
6147                 /* If VAROP is a reference to a bitfield, we must mask
6148                    the constant by the width of the field.  */
6149                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6150                     && DECL_BIT_FIELD(TREE_OPERAND
6151                                       (TREE_OPERAND (varop, 0), 1)))
6152                   {
6153                     int size
6154                       = TREE_INT_CST_LOW (DECL_SIZE
6155                                           (TREE_OPERAND
6156                                            (TREE_OPERAND (varop, 0), 1)));
6157                     tree mask, unsigned_type;
6158                     unsigned int precision;
6159                     tree folded_compare;
6160
6161                     /* First check whether the comparison would come out
6162                        always the same.  If we don't do that we would
6163                        change the meaning with the masking.  */
6164                     if (constopnum == 0)
6165                       folded_compare = fold (build (code, type, constop,
6166                                                     TREE_OPERAND (varop, 0)));
6167                     else
6168                       folded_compare = fold (build (code, type,
6169                                                     TREE_OPERAND (varop, 0),
6170                                                     constop));
6171                     if (integer_zerop (folded_compare)
6172                         || integer_onep (folded_compare))
6173                       return omit_one_operand (type, folded_compare, varop);
6174
6175                     unsigned_type = type_for_size (size, 1);
6176                     precision = TYPE_PRECISION (unsigned_type);
6177                     mask = build_int_2 (~0, ~0);
6178                     TREE_TYPE (mask) = unsigned_type;
6179                     force_fit_type (mask, 0);
6180                     mask = const_binop (RSHIFT_EXPR, mask,
6181                                         size_int (precision - size), 0);
6182                     newconst = fold (build (BIT_AND_EXPR,
6183                                             TREE_TYPE (varop), newconst,
6184                                             convert (TREE_TYPE (varop),
6185                                                      mask)));
6186                   }
6187
6188                 t = build (code, type,
6189                            (constopnum == 0) ? newconst : varop,
6190                            (constopnum == 1) ? newconst : varop);
6191                 return t;
6192               }
6193           }
6194         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6195           {
6196             if (POINTER_TYPE_P (TREE_TYPE (varop))
6197                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6198                     && (code == EQ_EXPR || code == NE_EXPR)))
6199               {
6200                 tree newconst
6201                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6202                                  constop, TREE_OPERAND (varop, 1)));
6203
6204                 /* Do not overwrite the current varop to be a predecrement,
6205                    create a new node so that we won't confuse our caller who
6206                    might create trees and throw them away, reusing the
6207                    arguments that they passed to build.  This shows up in
6208                    the THEN or ELSE parts of ?: being postdecrements.  */
6209                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6210                                TREE_OPERAND (varop, 0),
6211                                TREE_OPERAND (varop, 1));
6212
6213                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6214                     && DECL_BIT_FIELD(TREE_OPERAND
6215                                       (TREE_OPERAND (varop, 0), 1)))
6216                   {
6217                     int size
6218                       = TREE_INT_CST_LOW (DECL_SIZE
6219                                           (TREE_OPERAND
6220                                            (TREE_OPERAND (varop, 0), 1)));
6221                     tree mask, unsigned_type;
6222                     unsigned int precision;
6223                     tree folded_compare;
6224
6225                     if (constopnum == 0)
6226                       folded_compare = fold (build (code, type, constop,
6227                                                     TREE_OPERAND (varop, 0)));
6228                     else
6229                       folded_compare = fold (build (code, type,
6230                                                     TREE_OPERAND (varop, 0),
6231                                                     constop));
6232                     if (integer_zerop (folded_compare)
6233                         || integer_onep (folded_compare))
6234                       return omit_one_operand (type, folded_compare, varop);
6235
6236                     unsigned_type = type_for_size (size, 1);
6237                     precision = TYPE_PRECISION (unsigned_type);
6238                     mask = build_int_2 (~0, ~0);
6239                     TREE_TYPE (mask) = TREE_TYPE (varop);
6240                     force_fit_type (mask, 0);
6241                     mask = const_binop (RSHIFT_EXPR, mask,
6242                                         size_int (precision - size), 0);
6243                     newconst = fold (build (BIT_AND_EXPR,
6244                                             TREE_TYPE (varop), newconst,
6245                                             convert (TREE_TYPE (varop),
6246                                                      mask)));
6247                   }
6248
6249                 t = build (code, type,
6250                            (constopnum == 0) ? newconst : varop,
6251                            (constopnum == 1) ? newconst : varop);
6252                 return t;
6253               }
6254           }
6255       }
6256
6257       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
6258       if (TREE_CODE (arg1) == INTEGER_CST
6259           && TREE_CODE (arg0) != INTEGER_CST
6260           && tree_int_cst_sgn (arg1) > 0)
6261         {
6262           switch (TREE_CODE (t))
6263             {
6264             case GE_EXPR:
6265               code = GT_EXPR;
6266               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6267               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6268               break;
6269
6270             case LT_EXPR:
6271               code = LE_EXPR;
6272               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6273               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6274               break;
6275
6276             default:
6277               break;
6278             }
6279         }
6280
6281       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6282          a MINUS_EXPR of a constant, we can convert it into a comparison with
6283          a revised constant as long as no overflow occurs.  */
6284       if ((code == EQ_EXPR || code == NE_EXPR)
6285           && TREE_CODE (arg1) == INTEGER_CST
6286           && (TREE_CODE (arg0) == PLUS_EXPR
6287               || TREE_CODE (arg0) == MINUS_EXPR)
6288           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6289           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6290                                       ? MINUS_EXPR : PLUS_EXPR,
6291                                       arg1, TREE_OPERAND (arg0, 1), 0))
6292           && ! TREE_CONSTANT_OVERFLOW (tem))
6293         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6294
6295       /* Similarly for a NEGATE_EXPR.  */
6296       else if ((code == EQ_EXPR || code == NE_EXPR)
6297                && TREE_CODE (arg0) == NEGATE_EXPR
6298                && TREE_CODE (arg1) == INTEGER_CST
6299                && 0 != (tem = negate_expr (arg1))
6300                && TREE_CODE (tem) == INTEGER_CST
6301                && ! TREE_CONSTANT_OVERFLOW (tem))
6302         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6303
6304       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6305          for !=.  Don't do this for ordered comparisons due to overflow.  */
6306       else if ((code == NE_EXPR || code == EQ_EXPR)
6307                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6308         return fold (build (code, type,
6309                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6310
6311       /* If we are widening one operand of an integer comparison,
6312          see if the other operand is similarly being widened.  Perhaps we
6313          can do the comparison in the narrower type.  */
6314       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6315                && TREE_CODE (arg0) == NOP_EXPR
6316                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6317                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6318                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6319                    || (TREE_CODE (t1) == INTEGER_CST
6320                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6321         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6322
6323       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6324          constant, we can simplify it.  */
6325       else if (TREE_CODE (arg1) == INTEGER_CST
6326                && (TREE_CODE (arg0) == MIN_EXPR
6327                    || TREE_CODE (arg0) == MAX_EXPR)
6328                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6329         return optimize_minmax_comparison (t);
6330
6331       /* If we are comparing an ABS_EXPR with a constant, we can
6332          convert all the cases into explicit comparisons, but they may
6333          well not be faster than doing the ABS and one comparison.
6334          But ABS (X) <= C is a range comparison, which becomes a subtraction
6335          and a comparison, and is probably faster.  */
6336       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6337                && TREE_CODE (arg0) == ABS_EXPR
6338                && ! TREE_SIDE_EFFECTS (arg0)
6339                && (0 != (tem = negate_expr (arg1)))
6340                && TREE_CODE (tem) == INTEGER_CST
6341                && ! TREE_CONSTANT_OVERFLOW (tem))
6342         return fold (build (TRUTH_ANDIF_EXPR, type,
6343                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6344                             build (LE_EXPR, type,
6345                                    TREE_OPERAND (arg0, 0), arg1)));
6346
6347       /* If this is an EQ or NE comparison with zero and ARG0 is
6348          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6349          two operations, but the latter can be done in one less insn
6350          on machines that have only two-operand insns or on which a
6351          constant cannot be the first operand.  */
6352       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6353           && TREE_CODE (arg0) == BIT_AND_EXPR)
6354         {
6355           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6356               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6357             return
6358               fold (build (code, type,
6359                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6360                                   build (RSHIFT_EXPR,
6361                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6362                                          TREE_OPERAND (arg0, 1),
6363                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6364                                   convert (TREE_TYPE (arg0),
6365                                            integer_one_node)),
6366                            arg1));
6367           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6368                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6369             return
6370               fold (build (code, type,
6371                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6372                                   build (RSHIFT_EXPR,
6373                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6374                                          TREE_OPERAND (arg0, 0),
6375                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6376                                   convert (TREE_TYPE (arg0),
6377                                            integer_one_node)),
6378                            arg1));
6379         }
6380
6381       /* If this is an NE or EQ comparison of zero against the result of a
6382          signed MOD operation whose second operand is a power of 2, make
6383          the MOD operation unsigned since it is simpler and equivalent.  */
6384       if ((code == NE_EXPR || code == EQ_EXPR)
6385           && integer_zerop (arg1)
6386           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6387           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6388               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6389               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6390               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6391           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6392         {
6393           tree newtype = unsigned_type (TREE_TYPE (arg0));
6394           tree newmod = build (TREE_CODE (arg0), newtype,
6395                                convert (newtype, TREE_OPERAND (arg0, 0)),
6396                                convert (newtype, TREE_OPERAND (arg0, 1)));
6397
6398           return build (code, type, newmod, convert (newtype, arg1));
6399         }
6400
6401       /* If this is an NE comparison of zero with an AND of one, remove the
6402          comparison since the AND will give the correct value.  */
6403       if (code == NE_EXPR && integer_zerop (arg1)
6404           && TREE_CODE (arg0) == BIT_AND_EXPR
6405           && integer_onep (TREE_OPERAND (arg0, 1)))
6406         return convert (type, arg0);
6407
6408       /* If we have (A & C) == C where C is a power of 2, convert this into
6409          (A & C) != 0.  Similarly for NE_EXPR.  */
6410       if ((code == EQ_EXPR || code == NE_EXPR)
6411           && TREE_CODE (arg0) == BIT_AND_EXPR
6412           && integer_pow2p (TREE_OPERAND (arg0, 1))
6413           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6414         return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6415                       arg0, integer_zero_node);
6416
6417       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6418          and similarly for >= into !=.  */
6419       if ((code == LT_EXPR || code == GE_EXPR)
6420           && TREE_UNSIGNED (TREE_TYPE (arg0))
6421           && TREE_CODE (arg1) == LSHIFT_EXPR
6422           && integer_onep (TREE_OPERAND (arg1, 0)))
6423         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6424                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6425                              TREE_OPERAND (arg1, 1)),
6426                       convert (TREE_TYPE (arg0), integer_zero_node));
6427
6428       else if ((code == LT_EXPR || code == GE_EXPR)
6429                && TREE_UNSIGNED (TREE_TYPE (arg0))
6430                && (TREE_CODE (arg1) == NOP_EXPR
6431                    || TREE_CODE (arg1) == CONVERT_EXPR)
6432                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6433                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6434         return
6435           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6436                  convert (TREE_TYPE (arg0),
6437                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6438                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6439                  convert (TREE_TYPE (arg0), integer_zero_node));
6440
6441       /* Simplify comparison of something with itself.  (For IEEE
6442          floating-point, we can only do some of these simplifications.)  */
6443       if (operand_equal_p (arg0, arg1, 0))
6444         {
6445           switch (code)
6446             {
6447             case EQ_EXPR:
6448             case GE_EXPR:
6449             case LE_EXPR:
6450               if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6451                 return constant_boolean_node (1, type);
6452               code = EQ_EXPR;
6453               TREE_SET_CODE (t, code);
6454               break;
6455
6456             case NE_EXPR:
6457               /* For NE, we can only do this simplification if integer.  */
6458               if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6459                 break;
6460               /* ... fall through ...  */
6461             case GT_EXPR:
6462             case LT_EXPR:
6463               return constant_boolean_node (0, type);
6464             default:
6465               abort ();
6466             }
6467         }
6468
6469       /* An unsigned comparison against 0 can be simplified.  */
6470       if (integer_zerop (arg1)
6471           && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6472               || POINTER_TYPE_P (TREE_TYPE (arg1)))
6473           && TREE_UNSIGNED (TREE_TYPE (arg1)))
6474         {
6475           switch (TREE_CODE (t))
6476             {
6477             case GT_EXPR:
6478               code = NE_EXPR;
6479               TREE_SET_CODE (t, NE_EXPR);
6480               break;
6481             case LE_EXPR:
6482               code = EQ_EXPR;
6483               TREE_SET_CODE (t, EQ_EXPR);
6484               break;
6485             case GE_EXPR:
6486               return omit_one_operand (type,
6487                                        convert (type, integer_one_node),
6488                                        arg0);
6489             case LT_EXPR:
6490               return omit_one_operand (type,
6491                                        convert (type, integer_zero_node),
6492                                        arg0);
6493             default:
6494               break;
6495             }
6496         }
6497
6498       /* Comparisons with the highest or lowest possible integer of
6499          the specified size will have known values and an unsigned
6500          <= 0x7fffffff can be simplified.  */
6501       {
6502         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6503
6504         if (TREE_CODE (arg1) == INTEGER_CST
6505             && ! TREE_CONSTANT_OVERFLOW (arg1)
6506             && width <= HOST_BITS_PER_WIDE_INT
6507             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6508                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6509           {
6510             if (TREE_INT_CST_HIGH (arg1) == 0
6511                 && (TREE_INT_CST_LOW (arg1)
6512                     == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6513                 && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6514               switch (TREE_CODE (t))
6515                 {
6516                 case GT_EXPR:
6517                   return omit_one_operand (type,
6518                                            convert (type, integer_zero_node),
6519                                            arg0);
6520                 case GE_EXPR:
6521                   TREE_SET_CODE (t, EQ_EXPR);
6522                   break;
6523
6524                 case LE_EXPR:
6525                   return omit_one_operand (type,
6526                                            convert (type, integer_one_node),
6527                                            arg0);
6528                 case LT_EXPR:
6529                   TREE_SET_CODE (t, NE_EXPR);
6530                   break;
6531
6532                 default:
6533                   break;
6534                 }
6535
6536             else if (TREE_INT_CST_HIGH (arg1) == -1
6537                      && (- TREE_INT_CST_LOW (arg1)
6538                          == ((unsigned HOST_WIDE_INT) 1 << (width - 1)))
6539                      && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6540               switch (TREE_CODE (t))
6541                 {
6542                 case LT_EXPR:
6543                   return omit_one_operand (type,
6544                                            convert (type, integer_zero_node),
6545                                            arg0);
6546                 case LE_EXPR:
6547                   TREE_SET_CODE (t, EQ_EXPR);
6548                   break;
6549
6550                 case GE_EXPR:
6551                   return omit_one_operand (type,
6552                                            convert (type, integer_one_node),
6553                                            arg0);
6554                 case GT_EXPR:
6555                   TREE_SET_CODE (t, NE_EXPR);
6556                   break;
6557
6558                 default:
6559                   break;
6560                 }
6561
6562             else if (TREE_INT_CST_HIGH (arg1) == 0
6563                       && (TREE_INT_CST_LOW (arg1)
6564                           == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6565                       && TREE_UNSIGNED (TREE_TYPE (arg1)))
6566
6567               switch (TREE_CODE (t))
6568                 {
6569                 case LE_EXPR:
6570                   return fold (build (GE_EXPR, type,
6571                                       convert (signed_type (TREE_TYPE (arg0)),
6572                                                arg0),
6573                                       convert (signed_type (TREE_TYPE (arg1)),
6574                                                integer_zero_node)));
6575                 case GT_EXPR:
6576                   return fold (build (LT_EXPR, type,
6577                                       convert (signed_type (TREE_TYPE (arg0)),
6578                                                arg0),
6579                                       convert (signed_type (TREE_TYPE (arg1)),
6580                                                integer_zero_node)));
6581
6582                 default:
6583                   break;
6584                 }
6585           }
6586       }
6587
6588       /* If we are comparing an expression that just has comparisons
6589          of two integer values, arithmetic expressions of those comparisons,
6590          and constants, we can simplify it.  There are only three cases
6591          to check: the two values can either be equal, the first can be
6592          greater, or the second can be greater.  Fold the expression for
6593          those three values.  Since each value must be 0 or 1, we have
6594          eight possibilities, each of which corresponds to the constant 0
6595          or 1 or one of the six possible comparisons.
6596
6597          This handles common cases like (a > b) == 0 but also handles
6598          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6599          occur in macroized code.  */
6600
6601       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6602         {
6603           tree cval1 = 0, cval2 = 0;
6604           int save_p = 0;
6605
6606           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6607               /* Don't handle degenerate cases here; they should already
6608                  have been handled anyway.  */
6609               && cval1 != 0 && cval2 != 0
6610               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6611               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6612               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6613               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6614               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6615               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6616                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6617             {
6618               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6619               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6620
6621               /* We can't just pass T to eval_subst in case cval1 or cval2
6622                  was the same as ARG1.  */
6623
6624               tree high_result
6625                 = fold (build (code, type,
6626                                eval_subst (arg0, cval1, maxval, cval2, minval),
6627                                arg1));
6628               tree equal_result
6629                 = fold (build (code, type,
6630                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6631                                arg1));
6632               tree low_result
6633                 = fold (build (code, type,
6634                                eval_subst (arg0, cval1, minval, cval2, maxval),
6635                                arg1));
6636
6637               /* All three of these results should be 0 or 1.  Confirm they
6638                  are.  Then use those values to select the proper code
6639                  to use.  */
6640
6641               if ((integer_zerop (high_result)
6642                    || integer_onep (high_result))
6643                   && (integer_zerop (equal_result)
6644                       || integer_onep (equal_result))
6645                   && (integer_zerop (low_result)
6646                       || integer_onep (low_result)))
6647                 {
6648                   /* Make a 3-bit mask with the high-order bit being the
6649                      value for `>', the next for '=', and the low for '<'.  */
6650                   switch ((integer_onep (high_result) * 4)
6651                           + (integer_onep (equal_result) * 2)
6652                           + integer_onep (low_result))
6653                     {
6654                     case 0:
6655                       /* Always false.  */
6656                       return omit_one_operand (type, integer_zero_node, arg0);
6657                     case 1:
6658                       code = LT_EXPR;
6659                       break;
6660                     case 2:
6661                       code = EQ_EXPR;
6662                       break;
6663                     case 3:
6664                       code = LE_EXPR;
6665                       break;
6666                     case 4:
6667                       code = GT_EXPR;
6668                       break;
6669                     case 5:
6670                       code = NE_EXPR;
6671                       break;
6672                     case 6:
6673                       code = GE_EXPR;
6674                       break;
6675                     case 7:
6676                       /* Always true.  */
6677                       return omit_one_operand (type, integer_one_node, arg0);
6678                     }
6679
6680                   t = build (code, type, cval1, cval2);
6681                   if (save_p)
6682                     return save_expr (t);
6683                   else
6684                     return fold (t);
6685                 }
6686             }
6687         }
6688
6689       /* If this is a comparison of a field, we may be able to simplify it.  */
6690       if ((TREE_CODE (arg0) == COMPONENT_REF
6691            || TREE_CODE (arg0) == BIT_FIELD_REF)
6692           && (code == EQ_EXPR || code == NE_EXPR)
6693           /* Handle the constant case even without -O
6694              to make sure the warnings are given.  */
6695           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6696         {
6697           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6698           return t1 ? t1 : t;
6699         }
6700
6701       /* If this is a comparison of complex values and either or both sides
6702          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6703          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6704          This may prevent needless evaluations.  */
6705       if ((code == EQ_EXPR || code == NE_EXPR)
6706           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6707           && (TREE_CODE (arg0) == COMPLEX_EXPR
6708               || TREE_CODE (arg1) == COMPLEX_EXPR
6709               || TREE_CODE (arg0) == COMPLEX_CST
6710               || TREE_CODE (arg1) == COMPLEX_CST))
6711         {
6712           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6713           tree real0, imag0, real1, imag1;
6714
6715           arg0 = save_expr (arg0);
6716           arg1 = save_expr (arg1);
6717           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6718           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6719           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6720           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6721
6722           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6723                                : TRUTH_ORIF_EXPR),
6724                               type,
6725                               fold (build (code, type, real0, real1)),
6726                               fold (build (code, type, imag0, imag1))));
6727         }
6728
6729       /* From here on, the only cases we handle are when the result is
6730          known to be a constant.
6731
6732          To compute GT, swap the arguments and do LT.
6733          To compute GE, do LT and invert the result.
6734          To compute LE, swap the arguments, do LT and invert the result.
6735          To compute NE, do EQ and invert the result.
6736
6737          Therefore, the code below must handle only EQ and LT.  */
6738
6739       if (code == LE_EXPR || code == GT_EXPR)
6740         {
6741           tem = arg0, arg0 = arg1, arg1 = tem;
6742           code = swap_tree_comparison (code);
6743         }
6744
6745       /* Note that it is safe to invert for real values here because we
6746          will check below in the one case that it matters.  */
6747
6748       t1 = NULL_TREE;
6749       invert = 0;
6750       if (code == NE_EXPR || code == GE_EXPR)
6751         {
6752           invert = 1;
6753           code = invert_tree_comparison (code);
6754         }
6755
6756       /* Compute a result for LT or EQ if args permit;
6757          otherwise return T.  */
6758       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6759         {
6760           if (code == EQ_EXPR)
6761             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
6762           else
6763             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6764                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6765                                : INT_CST_LT (arg0, arg1)),
6766                               0);
6767         }
6768
6769 #if 0 /* This is no longer useful, but breaks some real code.  */
6770       /* Assume a nonexplicit constant cannot equal an explicit one,
6771          since such code would be undefined anyway.
6772          Exception: on sysvr4, using #pragma weak,
6773          a label can come out as 0.  */
6774       else if (TREE_CODE (arg1) == INTEGER_CST
6775                && !integer_zerop (arg1)
6776                && TREE_CONSTANT (arg0)
6777                && TREE_CODE (arg0) == ADDR_EXPR
6778                && code == EQ_EXPR)
6779         t1 = build_int_2 (0, 0);
6780 #endif
6781       /* Two real constants can be compared explicitly.  */
6782       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6783         {
6784           /* If either operand is a NaN, the result is false with two
6785              exceptions: First, an NE_EXPR is true on NaNs, but that case
6786              is already handled correctly since we will be inverting the
6787              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6788              or a GE_EXPR into a LT_EXPR, we must return true so that it
6789              will be inverted into false.  */
6790
6791           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6792               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6793             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6794
6795           else if (code == EQ_EXPR)
6796             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6797                                                  TREE_REAL_CST (arg1)),
6798                               0);
6799           else
6800             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6801                                                 TREE_REAL_CST (arg1)),
6802                               0);
6803         }
6804
6805       if (t1 == NULL_TREE)
6806         return t;
6807
6808       if (invert)
6809         TREE_INT_CST_LOW (t1) ^= 1;
6810
6811       TREE_TYPE (t1) = type;
6812       if (TREE_CODE (type) == BOOLEAN_TYPE)
6813         return truthvalue_conversion (t1);
6814       return t1;
6815
6816     case COND_EXPR:
6817       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6818          so all simple results must be passed through pedantic_non_lvalue.  */
6819       if (TREE_CODE (arg0) == INTEGER_CST)
6820         return pedantic_non_lvalue
6821           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6822       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6823         return pedantic_omit_one_operand (type, arg1, arg0);
6824
6825       /* If the second operand is zero, invert the comparison and swap
6826          the second and third operands.  Likewise if the second operand
6827          is constant and the third is not or if the third operand is
6828          equivalent to the first operand of the comparison.  */
6829
6830       if (integer_zerop (arg1)
6831           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6832           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6833               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6834                                                  TREE_OPERAND (t, 2),
6835                                                  TREE_OPERAND (arg0, 1))))
6836         {
6837           /* See if this can be inverted.  If it can't, possibly because
6838              it was a floating-point inequality comparison, don't do
6839              anything.  */
6840           tem = invert_truthvalue (arg0);
6841
6842           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6843             {
6844               t = build (code, type, tem,
6845                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6846               arg0 = tem;
6847               /* arg1 should be the first argument of the new T.  */
6848               arg1 = TREE_OPERAND (t, 1);
6849               STRIP_NOPS (arg1);
6850             }
6851         }
6852
6853       /* If we have A op B ? A : C, we may be able to convert this to a
6854          simpler expression, depending on the operation and the values
6855          of B and C.  IEEE floating point prevents this though,
6856          because A or B might be -0.0 or a NaN.  */
6857
6858       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6859           && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
6860               || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
6861               || flag_fast_math)
6862           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6863                                              arg1, TREE_OPERAND (arg0, 1)))
6864         {
6865           tree arg2 = TREE_OPERAND (t, 2);
6866           enum tree_code comp_code = TREE_CODE (arg0);
6867
6868           STRIP_NOPS (arg2);
6869
6870           /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
6871              depending on the comparison operation.  */
6872           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
6873                ? real_zerop (TREE_OPERAND (arg0, 1))
6874                : integer_zerop (TREE_OPERAND (arg0, 1)))
6875               && TREE_CODE (arg2) == NEGATE_EXPR
6876               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
6877             switch (comp_code)
6878               {
6879               case EQ_EXPR:
6880                 return
6881                   pedantic_non_lvalue
6882                     (convert (type,
6883                               negate_expr
6884                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
6885                                         arg1))));
6886
6887               case NE_EXPR:
6888                 return pedantic_non_lvalue (convert (type, arg1));
6889               case GE_EXPR:
6890               case GT_EXPR:
6891                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6892                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6893                 return pedantic_non_lvalue
6894                   (convert (type, fold (build1 (ABS_EXPR,
6895                                                 TREE_TYPE (arg1), arg1))));
6896               case LE_EXPR:
6897               case LT_EXPR:
6898                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6899                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6900                 return pedantic_non_lvalue
6901                   (negate_expr (convert (type,
6902                                          fold (build1 (ABS_EXPR,
6903                                                        TREE_TYPE (arg1),
6904                                                        arg1)))));
6905               default:
6906                 abort ();
6907               }
6908
6909           /* If this is A != 0 ? A : 0, this is simply A.  For ==, it is
6910              always zero.  */
6911
6912           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
6913             {
6914               if (comp_code == NE_EXPR)
6915                 return pedantic_non_lvalue (convert (type, arg1));
6916               else if (comp_code == EQ_EXPR)
6917                 return pedantic_non_lvalue (convert (type, integer_zero_node));
6918             }
6919
6920           /* If this is A op B ? A : B, this is either A, B, min (A, B),
6921              or max (A, B), depending on the operation.  */
6922
6923           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
6924                                               arg2, TREE_OPERAND (arg0, 0)))
6925             {
6926               tree comp_op0 = TREE_OPERAND (arg0, 0);
6927               tree comp_op1 = TREE_OPERAND (arg0, 1);
6928               tree comp_type = TREE_TYPE (comp_op0);
6929
6930               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
6931               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
6932                 comp_type = type;
6933
6934               switch (comp_code)
6935                 {
6936                 case EQ_EXPR:
6937                   return pedantic_non_lvalue (convert (type, arg2));
6938                 case NE_EXPR:
6939                   return pedantic_non_lvalue (convert (type, arg1));
6940                 case LE_EXPR:
6941                 case LT_EXPR:
6942                   /* In C++ a ?: expression can be an lvalue, so put the
6943                      operand which will be used if they are equal first
6944                      so that we can convert this back to the
6945                      corresponding COND_EXPR.  */
6946                   return pedantic_non_lvalue
6947                     (convert (type, fold (build (MIN_EXPR, comp_type,
6948                                                  (comp_code == LE_EXPR
6949                                                   ? comp_op0 : comp_op1),
6950                                                  (comp_code == LE_EXPR
6951                                                   ? comp_op1 : comp_op0)))));
6952                   break;
6953                 case GE_EXPR:
6954                 case GT_EXPR:
6955                   return pedantic_non_lvalue
6956                     (convert (type, fold (build (MAX_EXPR, comp_type,
6957                                                  (comp_code == GE_EXPR
6958                                                   ? comp_op0 : comp_op1),
6959                                                  (comp_code == GE_EXPR
6960                                                   ? comp_op1 : comp_op0)))));
6961                   break;
6962                 default:
6963                   abort ();
6964                 }
6965             }
6966
6967           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6968              we might still be able to simplify this.  For example,
6969              if C1 is one less or one more than C2, this might have started
6970              out as a MIN or MAX and been transformed by this function.
6971              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
6972
6973           if (INTEGRAL_TYPE_P (type)
6974               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6975               && TREE_CODE (arg2) == INTEGER_CST)
6976             switch (comp_code)
6977               {
6978               case EQ_EXPR:
6979                 /* We can replace A with C1 in this case.  */
6980                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
6981                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
6982                            TREE_OPERAND (t, 2));
6983                 break;
6984
6985               case LT_EXPR:
6986                 /* If C1 is C2 + 1, this is min(A, C2).  */
6987                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6988                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6989                                         const_binop (PLUS_EXPR, arg2,
6990                                                      integer_one_node, 0), 1))
6991                   return pedantic_non_lvalue
6992                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6993                 break;
6994
6995               case LE_EXPR:
6996                 /* If C1 is C2 - 1, this is min(A, C2).  */
6997                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6998                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6999                                         const_binop (MINUS_EXPR, arg2,
7000                                                      integer_one_node, 0), 1))
7001                   return pedantic_non_lvalue
7002                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7003                 break;
7004
7005               case GT_EXPR:
7006                 /* If C1 is C2 - 1, this is max(A, C2).  */
7007                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7008                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7009                                         const_binop (MINUS_EXPR, arg2,
7010                                                      integer_one_node, 0), 1))
7011                   return pedantic_non_lvalue
7012                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7013                 break;
7014
7015               case GE_EXPR:
7016                 /* If C1 is C2 + 1, this is max(A, C2).  */
7017                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7018                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7019                                         const_binop (PLUS_EXPR, arg2,
7020                                                      integer_one_node, 0), 1))
7021                   return pedantic_non_lvalue
7022                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7023                 break;
7024               case NE_EXPR:
7025                 break;
7026               default:
7027                 abort ();
7028               }
7029         }
7030
7031       /* If the second operand is simpler than the third, swap them
7032          since that produces better jump optimization results.  */
7033       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7034            || TREE_CODE (arg1) == SAVE_EXPR)
7035           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7036                 || DECL_P (TREE_OPERAND (t, 2))
7037                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7038         {
7039           /* See if this can be inverted.  If it can't, possibly because
7040              it was a floating-point inequality comparison, don't do
7041              anything.  */
7042           tem = invert_truthvalue (arg0);
7043
7044           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7045             {
7046               t = build (code, type, tem,
7047                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7048               arg0 = tem;
7049               /* arg1 should be the first argument of the new T.  */
7050               arg1 = TREE_OPERAND (t, 1);
7051               STRIP_NOPS (arg1);
7052             }
7053         }
7054
7055       /* Convert A ? 1 : 0 to simply A.  */
7056       if (integer_onep (TREE_OPERAND (t, 1))
7057           && integer_zerop (TREE_OPERAND (t, 2))
7058           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7059              call to fold will try to move the conversion inside
7060              a COND, which will recurse.  In that case, the COND_EXPR
7061              is probably the best choice, so leave it alone.  */
7062           && type == TREE_TYPE (arg0))
7063         return pedantic_non_lvalue (arg0);
7064
7065       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7066          operation is simply A & 2.  */
7067
7068       if (integer_zerop (TREE_OPERAND (t, 2))
7069           && TREE_CODE (arg0) == NE_EXPR
7070           && integer_zerop (TREE_OPERAND (arg0, 1))
7071           && integer_pow2p (arg1)
7072           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7073           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7074                               arg1, 1))
7075         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7076
7077       return t;
7078
7079     case COMPOUND_EXPR:
7080       /* When pedantic, a compound expression can be neither an lvalue
7081          nor an integer constant expression.  */
7082       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7083         return t;
7084       /* Don't let (0, 0) be null pointer constant.  */
7085       if (integer_zerop (arg1))
7086         return build1 (NOP_EXPR, type, arg1);
7087       return convert (type, arg1);
7088
7089     case COMPLEX_EXPR:
7090       if (wins)
7091         return build_complex (type, arg0, arg1);
7092       return t;
7093
7094     case REALPART_EXPR:
7095       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7096         return t;
7097       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7098         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7099                                  TREE_OPERAND (arg0, 1));
7100       else if (TREE_CODE (arg0) == COMPLEX_CST)
7101         return TREE_REALPART (arg0);
7102       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7103         return fold (build (TREE_CODE (arg0), type,
7104                             fold (build1 (REALPART_EXPR, type,
7105                                           TREE_OPERAND (arg0, 0))),
7106                             fold (build1 (REALPART_EXPR,
7107                                           type, TREE_OPERAND (arg0, 1)))));
7108       return t;
7109
7110     case IMAGPART_EXPR:
7111       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7112         return convert (type, integer_zero_node);
7113       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7114         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7115                                  TREE_OPERAND (arg0, 0));
7116       else if (TREE_CODE (arg0) == COMPLEX_CST)
7117         return TREE_IMAGPART (arg0);
7118       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7119         return fold (build (TREE_CODE (arg0), type,
7120                             fold (build1 (IMAGPART_EXPR, type,
7121                                           TREE_OPERAND (arg0, 0))),
7122                             fold (build1 (IMAGPART_EXPR, type,
7123                                           TREE_OPERAND (arg0, 1)))));
7124       return t;
7125
7126       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7127          appropriate.  */
7128     case CLEANUP_POINT_EXPR:
7129       if (! has_cleanups (arg0))
7130         return TREE_OPERAND (t, 0);
7131
7132       {
7133         enum tree_code code0 = TREE_CODE (arg0);
7134         int kind0 = TREE_CODE_CLASS (code0);
7135         tree arg00 = TREE_OPERAND (arg0, 0);
7136         tree arg01;
7137
7138         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7139           return fold (build1 (code0, type,
7140                                fold (build1 (CLEANUP_POINT_EXPR,
7141                                              TREE_TYPE (arg00), arg00))));
7142
7143         if (kind0 == '<' || kind0 == '2'
7144             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7145             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7146             || code0 == TRUTH_XOR_EXPR)
7147           {
7148             arg01 = TREE_OPERAND (arg0, 1);
7149
7150             if (TREE_CONSTANT (arg00)
7151                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7152                     && ! has_cleanups (arg00)))
7153               return fold (build (code0, type, arg00,
7154                                   fold (build1 (CLEANUP_POINT_EXPR,
7155                                                 TREE_TYPE (arg01), arg01))));
7156
7157             if (TREE_CONSTANT (arg01))
7158               return fold (build (code0, type,
7159                                   fold (build1 (CLEANUP_POINT_EXPR,
7160                                                 TREE_TYPE (arg00), arg00)),
7161                                   arg01));
7162           }
7163
7164         return t;
7165       }
7166
7167     default:
7168       return t;
7169     } /* switch (code) */
7170 }
7171
7172 /* Determine if first argument is a multiple of second argument.  Return 0 if
7173    it is not, or we cannot easily determined it to be.
7174
7175    An example of the sort of thing we care about (at this point; this routine
7176    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7177    fold cases do now) is discovering that
7178
7179      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7180
7181    is a multiple of
7182
7183      SAVE_EXPR (J * 8)
7184
7185    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7186
7187    This code also handles discovering that
7188
7189      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7190
7191    is a multiple of 8 so we don't have to worry about dealing with a
7192    possible remainder.
7193
7194    Note that we *look* inside a SAVE_EXPR only to determine how it was
7195    calculated; it is not safe for fold to do much of anything else with the
7196    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7197    at run time.  For example, the latter example above *cannot* be implemented
7198    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7199    evaluation time of the original SAVE_EXPR is not necessarily the same at
7200    the time the new expression is evaluated.  The only optimization of this
7201    sort that would be valid is changing
7202
7203      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7204
7205    divided by 8 to
7206
7207      SAVE_EXPR (I) * SAVE_EXPR (J)
7208
7209    (where the same SAVE_EXPR (J) is used in the original and the
7210    transformed version).  */
7211
7212 static int
7213 multiple_of_p (type, top, bottom)
7214      tree type;
7215      tree top;
7216      tree bottom;
7217 {
7218   if (operand_equal_p (top, bottom, 0))
7219     return 1;
7220
7221   if (TREE_CODE (type) != INTEGER_TYPE)
7222     return 0;
7223
7224   switch (TREE_CODE (top))
7225     {
7226     case MULT_EXPR:
7227       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7228               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7229
7230     case PLUS_EXPR:
7231     case MINUS_EXPR:
7232       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7233               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7234
7235     case NOP_EXPR:
7236       /* Can't handle conversions from non-integral or wider integral type.  */
7237       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7238           || (TYPE_PRECISION (type)
7239               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7240         return 0;
7241
7242       /* .. fall through ... */
7243
7244     case SAVE_EXPR:
7245       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7246
7247     case INTEGER_CST:
7248       if ((TREE_CODE (bottom) != INTEGER_CST)
7249           || (tree_int_cst_sgn (top) < 0)
7250           || (tree_int_cst_sgn (bottom) < 0))
7251         return 0;
7252       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7253                                          top, bottom, 0));
7254
7255     default:
7256       return 0;
7257     }
7258 }
7259
7260 /* Return true if `t' is known to be non-negative.  */
7261
7262 int
7263 tree_expr_nonnegative_p (t)
7264      tree t;
7265 {
7266   switch (TREE_CODE (t))
7267     {
7268     case INTEGER_CST:
7269       return tree_int_cst_sgn (t) >= 0;
7270     case COND_EXPR:
7271       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
7272         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
7273     case BIND_EXPR:
7274       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7275     case RTL_EXPR:
7276       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
7277
7278     default:
7279       /* We don't know sign of `t', so be safe and return false.  */
7280       return 0;
7281     }
7282 }
7283
7284 /* Return true if `r' is known to be non-negative.
7285    Only handles constants at the moment.  */
7286
7287 int
7288 rtl_expr_nonnegative_p (r)
7289      rtx r;
7290 {
7291   switch (GET_CODE (r))
7292     {
7293     case CONST_INT:
7294       return INTVAL (r) >= 0;
7295
7296     case CONST_DOUBLE:
7297       if (GET_MODE (r) == VOIDmode)
7298         return CONST_DOUBLE_HIGH (r) >= 0;
7299       return 0;
7300
7301     case SYMBOL_REF:
7302     case LABEL_REF:
7303       /* These are always nonnegative.  */
7304       return 1;
7305
7306     default:
7307       return 0;
7308     }
7309 }