gcc/fold-const.c

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