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 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, reverse the range so it
3319                  goes from zero to the low bound minus 1.  */
3320               if (high == 0)
3321                 {
3322                   in_p = ! in_p;
3323                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3324                                       integer_one_node, 0);
3325                   low = convert (type, integer_zero_node);
3326                 }
3327             }
3328           continue;
3329
3330         case NEGATE_EXPR:
3331           /* (-x) IN [a,b] -> x in [-b, -a]  */
3332           n_low = range_binop (MINUS_EXPR, type,
3333                                convert (type, integer_zero_node), 0, high, 1);
3334           n_high = range_binop (MINUS_EXPR, type,
3335                                 convert (type, integer_zero_node), 0, low, 0);
3336           low = n_low, high = n_high;
3337           exp = arg0;
3338           continue;
3339
3340         case BIT_NOT_EXPR:
3341           /* ~ X -> -X - 1  */
3342           exp = build (MINUS_EXPR, type, negate_expr (arg0),
3343                        convert (type, integer_one_node));
3344           continue;
3345
3346         case PLUS_EXPR:  case MINUS_EXPR:
3347           if (TREE_CODE (arg1) != INTEGER_CST)
3348             break;
3349
3350           /* If EXP is signed, any overflow in the computation is undefined,
3351              so we don't worry about it so long as our computations on
3352              the bounds don't overflow.  For unsigned, overflow is defined
3353              and this is exactly the right thing.  */
3354           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3355                                type, low, 0, arg1, 0);
3356           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3357                                 type, high, 1, arg1, 0);
3358           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3359               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3360             break;
3361
3362           /* Check for an unsigned range which has wrapped around the maximum
3363              value thus making n_high < n_low, and normalize it.  */
3364           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3365             {
3366               low = range_binop (PLUS_EXPR, type, n_high, 0,
3367                                  integer_one_node, 0);
3368               high = range_binop (MINUS_EXPR, type, n_low, 0,
3369                                  integer_one_node, 0);
3370               in_p = ! in_p;
3371             }
3372           else
3373             low = n_low, high = n_high;
3374
3375           exp = arg0;
3376           continue;
3377
3378         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3379           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3380             break;
3381
3382           if (! INTEGRAL_TYPE_P (type)
3383               || (low != 0 && ! int_fits_type_p (low, type))
3384               || (high != 0 && ! int_fits_type_p (high, type)))
3385             break;
3386
3387           n_low = low, n_high = high;
3388
3389           if (n_low != 0)
3390             n_low = convert (type, n_low);
3391
3392           if (n_high != 0)
3393             n_high = convert (type, n_high);
3394
3395           /* If we're converting from an unsigned to a signed type,
3396              we will be doing the comparison as unsigned.  The tests above
3397              have already verified that LOW and HIGH are both positive.
3398
3399              So we have to make sure that the original unsigned value will
3400              be interpreted as positive.  */
3401           if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3402             {
3403               tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
3404               tree high_positive;
3405
3406               /* A range without an upper bound is, naturally, unbounded.
3407                  Since convert would have cropped a very large value, use
3408                  the max value for the destination type.  */
3409               high_positive
3410                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3411                   : TYPE_MAX_VALUE (type);
3412
3413               high_positive = fold (build (RSHIFT_EXPR, type,
3414                                            convert (type, high_positive),
3415                                            convert (type, integer_one_node)));
3416
3417               /* If the low bound is specified, "and" the range with the
3418                  range for which the original unsigned value will be
3419                  positive.  */
3420               if (low != 0)
3421                 {
3422                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3423                                       1, n_low, n_high,
3424                                       1, convert (type, integer_zero_node),
3425                                       high_positive))
3426                     break;
3427
3428                   in_p = (n_in_p == in_p);
3429                 }
3430               else
3431                 {
3432                   /* Otherwise, "or" the range with the range of the input
3433                      that will be interpreted as negative.  */
3434                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3435                                       0, n_low, n_high,
3436                                       1, convert (type, integer_zero_node),
3437                                       high_positive))
3438                     break;
3439
3440                   in_p = (in_p != n_in_p);
3441                 }
3442             }
3443
3444           exp = arg0;
3445           low = n_low, high = n_high;
3446           continue;
3447
3448         default:
3449           break;
3450         }
3451
3452       break;
3453     }
3454
3455   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3456   if (TREE_CODE (exp) == INTEGER_CST)
3457     {
3458       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3459                                                  exp, 0, low, 0))
3460                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3461                                                     exp, 1, high, 1)));
3462       low = high = 0;
3463       exp = 0;
3464     }
3465
3466   *pin_p = in_p, *plow = low, *phigh = high;
3467   return exp;
3468 }
3469 \f
3470 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3471    type, TYPE, return an expression to test if EXP is in (or out of, depending
3472    on IN_P) the range.  */
3473
3474 static tree
3475 build_range_check (type, exp, in_p, low, high)
3476      tree type;
3477      tree exp;
3478      int in_p;
3479      tree low, high;
3480 {
3481   tree etype = TREE_TYPE (exp);
3482   tree utype, value;
3483
3484   if (! in_p
3485       && (0 != (value = build_range_check (type, exp, 1, low, high))))
3486     return invert_truthvalue (value);
3487
3488   else if (low == 0 && high == 0)
3489     return convert (type, integer_one_node);
3490
3491   else if (low == 0)
3492     return fold (build (LE_EXPR, type, exp, high));
3493
3494   else if (high == 0)
3495     return fold (build (GE_EXPR, type, exp, low));
3496
3497   else if (operand_equal_p (low, high, 0))
3498     return fold (build (EQ_EXPR, type, exp, low));
3499
3500   else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3501     return build_range_check (type, exp, 1, 0, high);
3502
3503   else if (integer_zerop (low))
3504     {
3505       utype = unsigned_type (etype);
3506       return build_range_check (type, convert (utype, exp), 1, 0,
3507                                 convert (utype, high));
3508     }
3509
3510   else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3511            && ! TREE_OVERFLOW (value))
3512     return build_range_check (type,
3513                               fold (build (MINUS_EXPR, etype, exp, low)),
3514                               1, convert (etype, integer_zero_node), value);
3515   else
3516     return 0;
3517 }
3518 \f
3519 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3520    can, 0 if we can't.  Set the output range into the specified parameters.  */
3521
3522 static int
3523 merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3524      int *pin_p;
3525      tree *plow, *phigh;
3526      int in0_p, in1_p;
3527      tree low0, high0, low1, high1;
3528 {
3529   int no_overlap;
3530   int subset;
3531   int temp;
3532   tree tem;
3533   int in_p;
3534   tree low, high;
3535   int lowequal = ((low0 == 0 && low1 == 0)
3536                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3537                                                 low0, 0, low1, 0)));
3538   int highequal = ((high0 == 0 && high1 == 0)
3539                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3540                                                  high0, 1, high1, 1)));
3541
3542   /* Make range 0 be the range that starts first, or ends last if they
3543      start at the same value.  Swap them if it isn't.  */
3544   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3545                                  low0, 0, low1, 0))
3546       || (lowequal
3547           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3548                                         high1, 1, high0, 1))))
3549     {
3550       temp = in0_p, in0_p = in1_p, in1_p = temp;
3551       tem = low0, low0 = low1, low1 = tem;
3552       tem = high0, high0 = high1, high1 = tem;
3553     }
3554
3555   /* Now flag two cases, whether the ranges are disjoint or whether the
3556      second range is totally subsumed in the first.  Note that the tests
3557      below are simplified by the ones above.  */
3558   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3559                                           high0, 1, low1, 0));
3560   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3561                                       high1, 1, high0, 1));
3562
3563   /* We now have four cases, depending on whether we are including or
3564      excluding the two ranges.  */
3565   if (in0_p && in1_p)
3566     {
3567       /* If they don't overlap, the result is false.  If the second range
3568          is a subset it is the result.  Otherwise, the range is from the start
3569          of the second to the end of the first.  */
3570       if (no_overlap)
3571         in_p = 0, low = high = 0;
3572       else if (subset)
3573         in_p = 1, low = low1, high = high1;
3574       else
3575         in_p = 1, low = low1, high = high0;
3576     }
3577
3578   else if (in0_p && ! in1_p)
3579     {
3580       /* If they don't overlap, the result is the first range.  If they are
3581          equal, the result is false.  If the second range is a subset of the
3582          first, and the ranges begin at the same place, we go from just after
3583          the end of the first range to the end of the second.  If the second
3584          range is not a subset of the first, or if it is a subset and both
3585          ranges end at the same place, the range starts at the start of the
3586          first range and ends just before the second range.
3587          Otherwise, we can't describe this as a single range.  */
3588       if (no_overlap)
3589         in_p = 1, low = low0, high = high0;
3590       else if (lowequal && highequal)
3591         in_p = 0, low = high = 0;
3592       else if (subset && lowequal)
3593         {
3594           in_p = 1, high = high0;
3595           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3596                              integer_one_node, 0);
3597         }
3598       else if (! subset || highequal)
3599         {
3600           in_p = 1, low = low0;
3601           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3602                               integer_one_node, 0);
3603         }
3604       else
3605         return 0;
3606     }
3607
3608   else if (! in0_p && in1_p)
3609     {
3610       /* If they don't overlap, the result is the second range.  If the second
3611          is a subset of the first, the result is false.  Otherwise,
3612          the range starts just after the first range and ends at the
3613          end of the second.  */
3614       if (no_overlap)
3615         in_p = 1, low = low1, high = high1;
3616       else if (subset || highequal)
3617         in_p = 0, low = high = 0;
3618       else
3619         {
3620           in_p = 1, high = high1;
3621           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3622                              integer_one_node, 0);
3623         }
3624     }
3625
3626   else
3627     {
3628       /* The case where we are excluding both ranges.  Here the complex case
3629          is if they don't overlap.  In that case, the only time we have a
3630          range is if they are adjacent.  If the second is a subset of the
3631          first, the result is the first.  Otherwise, the range to exclude
3632          starts at the beginning of the first range and ends at the end of the
3633          second.  */
3634       if (no_overlap)
3635         {
3636           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3637                                          range_binop (PLUS_EXPR, NULL_TREE,
3638                                                       high0, 1,
3639                                                       integer_one_node, 1),
3640                                          1, low1, 0)))
3641             in_p = 0, low = low0, high = high1;
3642           else
3643             return 0;
3644         }
3645       else if (subset)
3646         in_p = 0, low = low0, high = high0;
3647       else
3648         in_p = 0, low = low0, high = high1;
3649     }
3650
3651   *pin_p = in_p, *plow = low, *phigh = high;
3652   return 1;
3653 }
3654 \f
3655 /* EXP is some logical combination of boolean tests.  See if we can
3656    merge it into some range test.  Return the new tree if so.  */
3657
3658 static tree
3659 fold_range_test (exp)
3660      tree exp;
3661 {
3662   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3663                || TREE_CODE (exp) == TRUTH_OR_EXPR);
3664   int in0_p, in1_p, in_p;
3665   tree low0, low1, low, high0, high1, high;
3666   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3667   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3668   tree tem;
3669
3670   /* If this is an OR operation, invert both sides; we will invert
3671      again at the end.  */
3672   if (or_op)
3673     in0_p = ! in0_p, in1_p = ! in1_p;
3674
3675   /* If both expressions are the same, if we can merge the ranges, and we
3676      can build the range test, return it or it inverted.  If one of the
3677      ranges is always true or always false, consider it to be the same
3678      expression as the other.  */
3679   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3680       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3681                        in1_p, low1, high1)
3682       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3683                                          lhs != 0 ? lhs
3684                                          : rhs != 0 ? rhs : integer_zero_node,
3685                                          in_p, low, high))))
3686     return or_op ? invert_truthvalue (tem) : tem;
3687
3688   /* On machines where the branch cost is expensive, if this is a
3689      short-circuited branch and the underlying object on both sides
3690      is the same, make a non-short-circuit operation.  */
3691   else if (BRANCH_COST >= 2
3692            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3693                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3694            && operand_equal_p (lhs, rhs, 0))
3695     {
3696       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
3697          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3698          which cases we can't do this.  */
3699       if (simple_operand_p (lhs))
3700         return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3701                       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3702                       TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3703                       TREE_OPERAND (exp, 1));
3704
3705       else if (global_bindings_p () == 0
3706                && ! contains_placeholder_p (lhs))
3707         {
3708           tree common = save_expr (lhs);
3709
3710           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3711                                              or_op ? ! in0_p : in0_p,
3712                                              low0, high0))
3713               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3714                                                  or_op ? ! in1_p : in1_p,
3715                                                  low1, high1))))
3716             return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3717                           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3718                           TREE_TYPE (exp), lhs, rhs);
3719         }
3720     }
3721
3722   return 0;
3723 }
3724 \f
3725 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3726    bit value.  Arrange things so the extra bits will be set to zero if and
3727    only if C is signed-extended to its full width.  If MASK is nonzero,
3728    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
3729
3730 static tree
3731 unextend (c, p, unsignedp, mask)
3732      tree c;
3733      int p;
3734      int unsignedp;
3735      tree mask;
3736 {
3737   tree type = TREE_TYPE (c);
3738   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3739   tree temp;
3740
3741   if (p == modesize || unsignedp)
3742     return c;
3743
3744   /* We work by getting just the sign bit into the low-order bit, then
3745      into the high-order bit, then sign-extend.  We then XOR that value
3746      with C.  */
3747   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3748   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3749
3750   /* We must use a signed type in order to get an arithmetic right shift.
3751      However, we must also avoid introducing accidental overflows, so that
3752      a subsequent call to integer_zerop will work.  Hence we must
3753      do the type conversion here.  At this point, the constant is either
3754      zero or one, and the conversion to a signed type can never overflow.
3755      We could get an overflow if this conversion is done anywhere else.  */
3756   if (TREE_UNSIGNED (type))
3757     temp = convert (signed_type (type), temp);
3758
3759   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3760   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3761   if (mask != 0)
3762     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3763   /* If necessary, convert the type back to match the type of C.  */
3764   if (TREE_UNSIGNED (type))
3765     temp = convert (type, temp);
3766
3767   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3768 }
3769 \f
3770 /* Find ways of folding logical expressions of LHS and RHS:
3771    Try to merge two comparisons to the same innermost item.
3772    Look for range tests like "ch >= '0' && ch <= '9'".
3773    Look for combinations of simple terms on machines with expensive branches
3774    and evaluate the RHS unconditionally.
3775
3776    For example, if we have p->a == 2 && p->b == 4 and we can make an
3777    object large enough to span both A and B, we can do this with a comparison
3778    against the object ANDed with the a mask.
3779
3780    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3781    operations to do this with one comparison.
3782
3783    We check for both normal comparisons and the BIT_AND_EXPRs made this by
3784    function and the one above.
3785
3786    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
3787    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3788
3789    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3790    two operands.
3791
3792    We return the simplified tree or 0 if no optimization is possible.  */
3793
3794 static tree
3795 fold_truthop (code, truth_type, lhs, rhs)
3796      enum tree_code code;
3797      tree truth_type, lhs, rhs;
3798 {
3799   /* If this is the "or" of two comparisons, we can do something if we
3800      the comparisons are NE_EXPR.  If this is the "and", we can do something
3801      if the comparisons are EQ_EXPR.  I.e.,
3802         (a->b == 2 && a->c == 4) can become (a->new == NEW).
3803
3804      WANTED_CODE is this operation code.  For single bit fields, we can
3805      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3806      comparison for one-bit fields.  */
3807
3808   enum tree_code wanted_code;
3809   enum tree_code lcode, rcode;
3810   tree ll_arg, lr_arg, rl_arg, rr_arg;
3811   tree ll_inner, lr_inner, rl_inner, rr_inner;
3812   int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3813   int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3814   int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3815   int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3816   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3817   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3818   enum machine_mode lnmode, rnmode;
3819   tree ll_mask, lr_mask, rl_mask, rr_mask;
3820   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3821   tree l_const, r_const;
3822   tree lntype, rntype, result;
3823   int first_bit, end_bit;
3824   int volatilep;
3825
3826   /* Start by getting the comparison codes.  Fail if anything is volatile.
3827      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3828      it were surrounded with a NE_EXPR.  */
3829
3830   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3831     return 0;
3832
3833   lcode = TREE_CODE (lhs);
3834   rcode = TREE_CODE (rhs);
3835
3836   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3837     lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3838
3839   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3840     rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3841
3842   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3843     return 0;
3844
3845   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3846           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3847
3848   ll_arg = TREE_OPERAND (lhs, 0);
3849   lr_arg = TREE_OPERAND (lhs, 1);
3850   rl_arg = TREE_OPERAND (rhs, 0);
3851   rr_arg = TREE_OPERAND (rhs, 1);
3852
3853   /* If the RHS can be evaluated unconditionally and its operands are
3854      simple, it wins to evaluate the RHS unconditionally on machines
3855      with expensive branches.  In this case, this isn't a comparison
3856      that can be merged.  Avoid doing this if the RHS is a floating-point
3857      comparison since those can trap.  */
3858
3859   if (BRANCH_COST >= 2
3860       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
3861       && simple_operand_p (rl_arg)
3862       && simple_operand_p (rr_arg))
3863     return build (code, truth_type, lhs, rhs);
3864
3865   /* See if the comparisons can be merged.  Then get all the parameters for
3866      each side.  */
3867
3868   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3869       || (rcode != EQ_EXPR && rcode != NE_EXPR))
3870     return 0;
3871
3872   volatilep = 0;
3873   ll_inner = decode_field_reference (ll_arg,
3874                                      &ll_bitsize, &ll_bitpos, &ll_mode,
3875                                      &ll_unsignedp, &volatilep, &ll_mask,
3876                                      &ll_and_mask);
3877   lr_inner = decode_field_reference (lr_arg,
3878                                      &lr_bitsize, &lr_bitpos, &lr_mode,
3879                                      &lr_unsignedp, &volatilep, &lr_mask,
3880                                      &lr_and_mask);
3881   rl_inner = decode_field_reference (rl_arg,
3882                                      &rl_bitsize, &rl_bitpos, &rl_mode,
3883                                      &rl_unsignedp, &volatilep, &rl_mask,
3884                                      &rl_and_mask);
3885   rr_inner = decode_field_reference (rr_arg,
3886                                      &rr_bitsize, &rr_bitpos, &rr_mode,
3887                                      &rr_unsignedp, &volatilep, &rr_mask,
3888                                      &rr_and_mask);
3889
3890   /* It must be true that the inner operation on the lhs of each
3891      comparison must be the same if we are to be able to do anything.
3892      Then see if we have constants.  If not, the same must be true for
3893      the rhs's.  */
3894   if (volatilep || ll_inner == 0 || rl_inner == 0
3895       || ! operand_equal_p (ll_inner, rl_inner, 0))
3896     return 0;
3897
3898   if (TREE_CODE (lr_arg) == INTEGER_CST
3899       && TREE_CODE (rr_arg) == INTEGER_CST)
3900     l_const = lr_arg, r_const = rr_arg;
3901   else if (lr_inner == 0 || rr_inner == 0
3902            || ! operand_equal_p (lr_inner, rr_inner, 0))
3903     return 0;
3904   else
3905     l_const = r_const = 0;
3906
3907   /* If either comparison code is not correct for our logical operation,
3908      fail.  However, we can convert a one-bit comparison against zero into
3909      the opposite comparison against that bit being set in the field.  */
3910
3911   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3912   if (lcode != wanted_code)
3913     {
3914       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3915         {
3916           /* Make the left operand unsigned, since we are only interested
3917              in the value of one bit.  Otherwise we are doing the wrong
3918              thing below.  */
3919           ll_unsignedp = 1;
3920           l_const = ll_mask;
3921         }
3922       else
3923         return 0;
3924     }
3925
3926   /* This is analogous to the code for l_const above.  */
3927   if (rcode != wanted_code)
3928     {
3929       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3930         {
3931           rl_unsignedp = 1;
3932           r_const = rl_mask;
3933         }
3934       else
3935         return 0;
3936     }
3937
3938   /* See if we can find a mode that contains both fields being compared on
3939      the left.  If we can't, fail.  Otherwise, update all constants and masks
3940      to be relative to a field of that size.  */
3941   first_bit = MIN (ll_bitpos, rl_bitpos);
3942   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3943   lnmode = get_best_mode (end_bit - first_bit, first_bit,
3944                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3945                           volatilep);
3946   if (lnmode == VOIDmode)
3947     return 0;
3948
3949   lnbitsize = GET_MODE_BITSIZE (lnmode);
3950   lnbitpos = first_bit & ~ (lnbitsize - 1);
3951   lntype = type_for_size (lnbitsize, 1);
3952   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3953
3954   if (BYTES_BIG_ENDIAN)
3955     {
3956       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3957       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3958     }
3959
3960   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3961                          size_int (xll_bitpos), 0);
3962   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3963                          size_int (xrl_bitpos), 0);
3964
3965   if (l_const)
3966     {
3967       l_const = convert (lntype, l_const);
3968       l_const = unextend (l_const,  ll_bitsize, ll_unsignedp, ll_and_mask);
3969       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3970       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3971                                         fold (build1 (BIT_NOT_EXPR,
3972                                                       lntype, ll_mask)),
3973                                         0)))
3974         {
3975           warning ("comparison is always %d", wanted_code == NE_EXPR);
3976
3977           return convert (truth_type,
3978                           wanted_code == NE_EXPR
3979                           ? integer_one_node : integer_zero_node);
3980         }
3981     }
3982   if (r_const)
3983     {
3984       r_const = convert (lntype, r_const);
3985       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3986       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3987       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3988                                         fold (build1 (BIT_NOT_EXPR,
3989                                                       lntype, rl_mask)),
3990                                         0)))
3991         {
3992           warning ("comparison is always %d", wanted_code == NE_EXPR);
3993
3994           return convert (truth_type,
3995                           wanted_code == NE_EXPR
3996                           ? integer_one_node : integer_zero_node);
3997         }
3998     }
3999
4000   /* If the right sides are not constant, do the same for it.  Also,
4001      disallow this optimization if a size or signedness mismatch occurs
4002      between the left and right sides.  */
4003   if (l_const == 0)
4004     {
4005       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4006           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4007           /* Make sure the two fields on the right
4008              correspond to the left without being swapped.  */
4009           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4010         return 0;
4011
4012       first_bit = MIN (lr_bitpos, rr_bitpos);
4013       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4014       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4015                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4016                               volatilep);
4017       if (rnmode == VOIDmode)
4018         return 0;
4019
4020       rnbitsize = GET_MODE_BITSIZE (rnmode);
4021       rnbitpos = first_bit & ~ (rnbitsize - 1);
4022       rntype = type_for_size (rnbitsize, 1);
4023       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4024
4025       if (BYTES_BIG_ENDIAN)
4026         {
4027           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4028           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4029         }
4030
4031       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
4032                              size_int (xlr_bitpos), 0);
4033       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
4034                              size_int (xrr_bitpos), 0);
4035
4036       /* Make a mask that corresponds to both fields being compared.
4037          Do this for both items being compared.  If the operands are the
4038          same size and the bits being compared are in the same position
4039          then we can do this by masking both and comparing the masked
4040          results.  */
4041       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4042       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4043       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4044         {
4045           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4046                                     ll_unsignedp || rl_unsignedp);
4047           if (! all_ones_mask_p (ll_mask, lnbitsize))
4048             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
4049
4050           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4051                                     lr_unsignedp || rr_unsignedp);
4052           if (! all_ones_mask_p (lr_mask, rnbitsize))
4053             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
4054
4055           return build (wanted_code, truth_type, lhs, rhs);
4056         }
4057
4058       /* There is still another way we can do something:  If both pairs of
4059          fields being compared are adjacent, we may be able to make a wider
4060          field containing them both.
4061
4062          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4063          the mask must be shifted to account for the shift done by
4064          make_bit_field_ref.  */
4065       if ((ll_bitsize + ll_bitpos == rl_bitpos
4066            && lr_bitsize + lr_bitpos == rr_bitpos)
4067           || (ll_bitpos == rl_bitpos + rl_bitsize
4068               && lr_bitpos == rr_bitpos + rr_bitsize))
4069         {
4070           tree type;
4071
4072           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4073                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4074           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4075                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4076
4077           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4078                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4079           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4080                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4081
4082           /* Convert to the smaller type before masking out unwanted bits.  */
4083           type = lntype;
4084           if (lntype != rntype)
4085             {
4086               if (lnbitsize > rnbitsize)
4087                 {
4088                   lhs = convert (rntype, lhs);
4089                   ll_mask = convert (rntype, ll_mask);
4090                   type = rntype;
4091                 }
4092               else if (lnbitsize < rnbitsize)
4093                 {
4094                   rhs = convert (lntype, rhs);
4095                   lr_mask = convert (lntype, lr_mask);
4096                   type = lntype;
4097                 }
4098             }
4099
4100           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4101             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
4102
4103           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4104             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
4105
4106           return build (wanted_code, truth_type, lhs, rhs);
4107         }
4108
4109       return 0;
4110     }
4111
4112   /* Handle the case of comparisons with constants.  If there is something in
4113      common between the masks, those bits of the constants must be the same.
4114      If not, the condition is always false.  Test for this to avoid generating
4115      incorrect code below.  */
4116   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4117   if (! integer_zerop (result)
4118       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4119                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4120     {
4121       if (wanted_code == NE_EXPR)
4122         {
4123           warning ("`or' of unmatched not-equal tests is always 1");
4124           return convert (truth_type, integer_one_node);
4125         }
4126       else
4127         {
4128           warning ("`and' of mutually exclusive equal-tests is always 0");
4129           return convert (truth_type, integer_zero_node);
4130         }
4131     }
4132
4133   /* Construct the expression we will return.  First get the component
4134      reference we will make.  Unless the mask is all ones the width of
4135      that field, perform the mask operation.  Then compare with the
4136      merged constant.  */
4137   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4138                                ll_unsignedp || rl_unsignedp);
4139
4140   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4141   if (! all_ones_mask_p (ll_mask, lnbitsize))
4142     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
4143
4144   return build (wanted_code, truth_type, result,
4145                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4146 }
4147 \f
4148 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4149    constant.  */
4150
4151 static tree
4152 optimize_minmax_comparison (t)
4153      tree t;
4154 {
4155   tree type = TREE_TYPE (t);
4156   tree arg0 = TREE_OPERAND (t, 0);
4157   enum tree_code op_code;
4158   tree comp_const = TREE_OPERAND (t, 1);
4159   tree minmax_const;
4160   int consts_equal, consts_lt;
4161   tree inner;
4162
4163   STRIP_SIGN_NOPS (arg0);
4164
4165   op_code = TREE_CODE (arg0);
4166   minmax_const = TREE_OPERAND (arg0, 1);
4167   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4168   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4169   inner = TREE_OPERAND (arg0, 0);
4170
4171   /* If something does not permit us to optimize, return the original tree.  */
4172   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4173       || TREE_CODE (comp_const) != INTEGER_CST
4174       || TREE_CONSTANT_OVERFLOW (comp_const)
4175       || TREE_CODE (minmax_const) != INTEGER_CST
4176       || TREE_CONSTANT_OVERFLOW (minmax_const))
4177     return t;
4178
4179   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4180      and GT_EXPR, doing the rest with recursive calls using logical
4181      simplifications.  */
4182   switch (TREE_CODE (t))
4183     {
4184     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4185       return
4186         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4187
4188     case GE_EXPR:
4189       return
4190         fold (build (TRUTH_ORIF_EXPR, type,
4191                      optimize_minmax_comparison
4192                      (build (EQ_EXPR, type, arg0, comp_const)),
4193                      optimize_minmax_comparison
4194                      (build (GT_EXPR, type, arg0, comp_const))));
4195
4196     case EQ_EXPR:
4197       if (op_code == MAX_EXPR && consts_equal)
4198         /* MAX (X, 0) == 0  ->  X <= 0  */
4199         return fold (build (LE_EXPR, type, inner, comp_const));
4200
4201       else if (op_code == MAX_EXPR && consts_lt)
4202         /* MAX (X, 0) == 5  ->  X == 5   */
4203         return fold (build (EQ_EXPR, type, inner, comp_const));
4204
4205       else if (op_code == MAX_EXPR)
4206         /* MAX (X, 0) == -1  ->  false  */
4207         return omit_one_operand (type, integer_zero_node, inner);
4208
4209       else if (consts_equal)
4210         /* MIN (X, 0) == 0  ->  X >= 0  */
4211         return fold (build (GE_EXPR, type, inner, comp_const));
4212
4213       else if (consts_lt)
4214         /* MIN (X, 0) == 5  ->  false  */
4215         return omit_one_operand (type, integer_zero_node, inner);
4216
4217       else
4218         /* MIN (X, 0) == -1  ->  X == -1  */
4219         return fold (build (EQ_EXPR, type, inner, comp_const));
4220
4221     case GT_EXPR:
4222       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4223         /* MAX (X, 0) > 0  ->  X > 0
4224            MAX (X, 0) > 5  ->  X > 5  */
4225         return fold (build (GT_EXPR, type, inner, comp_const));
4226
4227       else if (op_code == MAX_EXPR)
4228         /* MAX (X, 0) > -1  ->  true  */
4229         return omit_one_operand (type, integer_one_node, inner);
4230
4231       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4232         /* MIN (X, 0) > 0  ->  false
4233            MIN (X, 0) > 5  ->  false  */
4234         return omit_one_operand (type, integer_zero_node, inner);
4235
4236       else
4237         /* MIN (X, 0) > -1  ->  X > -1  */
4238         return fold (build (GT_EXPR, type, inner, comp_const));
4239
4240     default:
4241       return t;
4242     }
4243 }
4244 \f
4245 /* T is an integer expression that is being multiplied, divided, or taken a
4246    modulus (CODE says which and what kind of divide or modulus) by a
4247    constant C.  See if we can eliminate that operation by folding it with
4248    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4249    should be used for the computation if wider than our type.
4250
4251    For example, if we are dividing (X * 8) + (Y + 16) by 4, we can return
4252    (X * 2) + (Y + 4).  We also canonicalize (X + 7) * 4 into X * 4 + 28
4253    in the hope that either the machine has a multiply-accumulate insn
4254    or that this is part of an addressing calculation.
4255
4256    If we return a non-null expression, it is an equivalent form of the
4257    original computation, but need not be in the original type.  */
4258
4259 static tree
4260 extract_muldiv (t, c, code, wide_type)
4261      tree t;
4262      tree c;
4263      enum tree_code code;
4264      tree wide_type;
4265 {
4266   tree type = TREE_TYPE (t);
4267   enum tree_code tcode = TREE_CODE (t);
4268   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4269                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4270                 ? wide_type : type);
4271   tree t1, t2;
4272   int same_p = tcode == code;
4273   tree op0 = NULL_TREE, op1 = NULL_TREE;
4274
4275   /* Don't deal with constants of zero here; they confuse the code below.  */
4276   if (integer_zerop (c))
4277     return 0;
4278
4279   if (TREE_CODE_CLASS (tcode) == '1')
4280     op0 = TREE_OPERAND (t, 0);
4281
4282   if (TREE_CODE_CLASS (tcode) == '2')
4283     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4284
4285   /* Note that we need not handle conditional operations here since fold
4286      already handles those cases.  So just do arithmetic here.  */
4287   switch (tcode)
4288     {
4289     case INTEGER_CST:
4290       /* For a constant, we can always simplify if we are a multiply
4291          or (for divide and modulus) if it is a multiple of our constant.  */
4292       if (code == MULT_EXPR
4293           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4294         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4295       break;
4296
4297     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4298
4299       /* Pass the constant down and see if we can make a simplification.  If
4300          we can, replace this expression with the inner simplification for
4301          possible later conversion to our or some other type.  */
4302       if (0 != (t1 = extract_muldiv (op0, convert (TREE_TYPE (op0), c), code,
4303                                      code == MULT_EXPR ? ctype : NULL_TREE)))
4304         return t1;
4305       break;
4306
4307     case NEGATE_EXPR:  case ABS_EXPR:
4308       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4309         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4310       break;
4311
4312     case MIN_EXPR:  case MAX_EXPR:
4313       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4314       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4315           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4316         {
4317           if (tree_int_cst_sgn (c) < 0)
4318             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4319
4320           return fold (build (tcode, ctype, convert (ctype, t1),
4321                               convert (ctype, t2)));
4322         }
4323       break;
4324
4325     case WITH_RECORD_EXPR:
4326       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4327         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4328                       TREE_OPERAND (t, 1));
4329       break;
4330
4331     case SAVE_EXPR:
4332       /* If this has not been evaluated and the operand has no side effects,
4333          we can see if we can do something inside it and make a new one.
4334          Note that this test is overly conservative since we can do this
4335          if the only reason it had side effects is that it was another
4336          similar SAVE_EXPR, but that isn't worth bothering with.  */
4337       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4338           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4339                                         wide_type)))
4340         return save_expr (t1);
4341       break;
4342
4343     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4344       /* If the second operand is constant, this is a multiplication
4345          or floor division, by a power of two, so we can treat it that
4346          way unless the multiplier or divisor overflows.  */
4347       if (TREE_CODE (op1) == INTEGER_CST
4348           && 0 != (t1 = convert (ctype,
4349                                  const_binop (LSHIFT_EXPR, size_one_node,
4350                                               op1, 0)))
4351           && ! TREE_OVERFLOW (t1))
4352         return extract_muldiv (build (tcode == LSHIFT_EXPR
4353                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4354                                       ctype, convert (ctype, op0), t1),
4355                                c, code, wide_type);
4356       break;
4357
4358     case PLUS_EXPR:  case MINUS_EXPR:
4359       /* See if we can eliminate the operation on both sides.  If we can, we
4360          can return a new PLUS or MINUS.  If we can't, the only remaining
4361          cases where we can do anything are if the second operand is a
4362          constant.  */
4363       t1 = extract_muldiv (op0, c, code, wide_type);
4364       t2 = extract_muldiv (op1, c, code, wide_type);
4365       if (t1 != 0 && t2 != 0)
4366         return fold (build (tcode, ctype, convert (ctype, t1),
4367                             convert (ctype, t2)));
4368
4369       /* If this was a subtraction, negate OP1 and set it to be an addition.
4370          This simplifies the logic below.  */
4371       if (tcode == MINUS_EXPR)
4372         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4373
4374       if (TREE_CODE (op1) != INTEGER_CST)
4375         break;
4376
4377       /* If either OP1 or C are negative, this optimization is not safe for
4378          some of the division and remainder types while for others we need
4379          to change the code.  */
4380       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4381         {
4382           if (code == CEIL_DIV_EXPR)
4383             code = FLOOR_DIV_EXPR;
4384           else if (code == CEIL_MOD_EXPR)
4385             code = FLOOR_MOD_EXPR;
4386           else if (code == FLOOR_DIV_EXPR)
4387             code = CEIL_DIV_EXPR;
4388           else if (code == FLOOR_MOD_EXPR)
4389             code = CEIL_MOD_EXPR;
4390           else if (code != MULT_EXPR)
4391             break;
4392         }
4393
4394       /* Now do the operation and verify it doesn't overflow.  */
4395       op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4396       if (op1 == 0 || TREE_OVERFLOW (op1))
4397         break;
4398
4399       /* If we were able to eliminate our operation from the first side,
4400          apply our operation to the second side and reform the PLUS.  */
4401       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4402         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4403
4404       /* The last case is if we are a multiply.  In that case, we can
4405          apply the distributive law to commute the multiply and addition
4406          if the multiplication of the constants doesn't overflow. */
4407       if (code == MULT_EXPR)
4408         return fold (build (tcode, ctype, fold (build (code, ctype,
4409                                                        convert (ctype, op0),
4410                                                        convert (ctype, c))),
4411                             op1));
4412
4413       break;
4414
4415     case MULT_EXPR:
4416       /* We have a special case here if we are doing something like
4417          (C * 8) % 4 since we know that's zero.  */
4418       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4419            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4420           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4421           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4422         return omit_one_operand (type, integer_zero_node, op0);
4423
4424       /* ... fall through ... */
4425
4426     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4427     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4428       /* If we can extract our operation from the LHS, do so and return a
4429          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4430          do something only if the second operand is a constant.  */
4431       if (same_p
4432           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4433         return fold (build (tcode, ctype, convert (ctype, t1),
4434                             convert (ctype, op1)));
4435       else if (tcode == MULT_EXPR && code == MULT_EXPR
4436                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4437         return fold (build (tcode, ctype, convert (ctype, op0),
4438                             convert (ctype, t1)));
4439       else if (TREE_CODE (op1) != INTEGER_CST)
4440         return 0;
4441
4442       /* If these are the same operation types, we can associate them
4443          assuming no overflow.  */
4444       if (tcode == code
4445           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4446                                      convert (ctype, c), 0))
4447           && ! TREE_OVERFLOW (t1))
4448         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4449
4450       /* If these operations "cancel" each other, we have the main
4451          optimizations of this pass, which occur when either constant is a
4452          multiple of the other, in which case we replace this with either an
4453          operation or CODE or TCODE.  */
4454       if ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4455           || (tcode == MULT_EXPR
4456               && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4457               && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR))
4458         {
4459           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4460             return fold (build (tcode, ctype, convert (ctype, op0),
4461                                 convert (ctype,
4462                                          const_binop (TRUNC_DIV_EXPR,
4463                                                       op1, c, 0))));
4464           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4465             return fold (build (code, ctype, convert (ctype, op0),
4466                                 convert (ctype,
4467                                          const_binop (TRUNC_DIV_EXPR,
4468                                                       c, op1, 0))));
4469         }
4470       break;
4471
4472     default:
4473       break;
4474     }
4475
4476   return 0;
4477 }
4478 \f
4479 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4480    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4481    that we may sometimes modify the tree.  */
4482
4483 static tree
4484 strip_compound_expr (t, s)
4485      tree t;
4486      tree s;
4487 {
4488   enum tree_code code = TREE_CODE (t);
4489
4490   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4491   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4492       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4493     return TREE_OPERAND (t, 1);
4494
4495   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4496      don't bother handling any other types.  */
4497   else if (code == COND_EXPR)
4498     {
4499       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4500       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4501       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4502     }
4503   else if (TREE_CODE_CLASS (code) == '1')
4504     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4505   else if (TREE_CODE_CLASS (code) == '<'
4506            || TREE_CODE_CLASS (code) == '2')
4507     {
4508       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4509       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4510     }
4511
4512   return t;
4513 }
4514 \f
4515 /* Return a node which has the indicated constant VALUE (either 0 or
4516    1), and is of the indicated TYPE.  */
4517
4518 static tree
4519 constant_boolean_node (value, type)
4520      int value;
4521      tree type;
4522 {
4523   if (type == integer_type_node)
4524     return value ? integer_one_node : integer_zero_node;
4525   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4526     return truthvalue_conversion (value ? integer_one_node :
4527                                   integer_zero_node);
4528   else
4529     {
4530       tree t = build_int_2 (value, 0);
4531
4532       TREE_TYPE (t) = type;
4533       return t;
4534     }
4535 }
4536
4537 /* Utility function for the following routine, to see how complex a nesting of
4538    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4539    we don't care (to avoid spending too much time on complex expressions.).  */
4540
4541 static int
4542 count_cond (expr, lim)
4543      tree expr;
4544      int lim;
4545 {
4546   int true, false;
4547
4548   if (TREE_CODE (expr) != COND_EXPR)
4549     return 0;
4550   else if (lim <= 0)
4551     return 0;
4552
4553   true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4554   false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
4555   return MIN (lim, 1 + true + false);
4556 }
4557 \f
4558 /* Perform constant folding and related simplification of EXPR.
4559    The related simplifications include x*1 => x, x*0 => 0, etc.,
4560    and application of the associative law.
4561    NOP_EXPR conversions may be removed freely (as long as we
4562    are careful not to change the C type of the overall expression)
4563    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4564    but we can constant-fold them if they have constant operands.  */
4565
4566 tree
4567 fold (expr)
4568      tree expr;
4569 {
4570   register tree t = expr;
4571   tree t1 = NULL_TREE;
4572   tree tem;
4573   tree type = TREE_TYPE (expr);
4574   register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4575   register enum tree_code code = TREE_CODE (t);
4576   register int kind;
4577   int invert;
4578   /* WINS will be nonzero when the switch is done
4579      if all operands are constant.  */
4580   int wins = 1;
4581
4582   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4583      Likewise for a SAVE_EXPR that's already been evaluated.  */
4584   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
4585     return t;
4586
4587   /* Return right away if already constant.  */
4588   if (TREE_CONSTANT (t))
4589     {
4590       if (code == CONST_DECL)
4591         return DECL_INITIAL (t);
4592       return t;
4593     }
4594
4595 #ifdef MAX_INTEGER_COMPUTATION_MODE
4596   check_max_integer_computation_mode (expr);
4597 #endif
4598
4599   kind = TREE_CODE_CLASS (code);
4600   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4601     {
4602       tree subop;
4603
4604       /* Special case for conversion ops that can have fixed point args.  */
4605       arg0 = TREE_OPERAND (t, 0);
4606
4607       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4608       if (arg0 != 0)
4609         STRIP_SIGN_NOPS (arg0);
4610
4611       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4612         subop = TREE_REALPART (arg0);
4613       else
4614         subop = arg0;
4615
4616       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4617 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4618           && TREE_CODE (subop) != REAL_CST
4619 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4620           )
4621         /* Note that TREE_CONSTANT isn't enough:
4622            static var addresses are constant but we can't
4623            do arithmetic on them.  */
4624         wins = 0;
4625     }
4626   else if (kind == 'e' || kind == '<'
4627            || kind == '1' || kind == '2' || kind == 'r')
4628     {
4629       register int len = tree_code_length[(int) code];
4630       register int i;
4631       for (i = 0; i < len; i++)
4632         {
4633           tree op = TREE_OPERAND (t, i);
4634           tree subop;
4635
4636           if (op == 0)
4637             continue;           /* Valid for CALL_EXPR, at least.  */
4638
4639           if (kind == '<' || code == RSHIFT_EXPR)
4640             {
4641               /* Signedness matters here.  Perhaps we can refine this
4642                  later.  */
4643               STRIP_SIGN_NOPS (op);
4644             }
4645           else
4646             {
4647               /* Strip any conversions that don't change the mode.  */
4648               STRIP_NOPS (op);
4649             }
4650
4651           if (TREE_CODE (op) == COMPLEX_CST)
4652             subop = TREE_REALPART (op);
4653           else
4654             subop = op;
4655
4656           if (TREE_CODE (subop) != INTEGER_CST
4657 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4658               && TREE_CODE (subop) != REAL_CST
4659 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4660               )
4661             /* Note that TREE_CONSTANT isn't enough:
4662                static var addresses are constant but we can't
4663                do arithmetic on them.  */
4664             wins = 0;
4665
4666           if (i == 0)
4667             arg0 = op;
4668           else if (i == 1)
4669             arg1 = op;
4670         }
4671     }
4672
4673   /* If this is a commutative operation, and ARG0 is a constant, move it
4674      to ARG1 to reduce the number of tests below.  */
4675   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4676        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4677        || code == BIT_AND_EXPR)
4678       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4679     {
4680       tem = arg0; arg0 = arg1; arg1 = tem;
4681
4682       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4683       TREE_OPERAND (t, 1) = tem;
4684     }
4685
4686   /* Now WINS is set as described above,
4687      ARG0 is the first operand of EXPR,
4688      and ARG1 is the second operand (if it has more than one operand).
4689
4690      First check for cases where an arithmetic operation is applied to a
4691      compound, conditional, or comparison operation.  Push the arithmetic
4692      operation inside the compound or conditional to see if any folding
4693      can then be done.  Convert comparison to conditional for this purpose.
4694      The also optimizes non-constant cases that used to be done in
4695      expand_expr.
4696
4697      Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
4698      one of the operands is a comparison and the other is a comparison, a
4699      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
4700      code below would make the expression more complex.  Change it to a
4701      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
4702      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
4703
4704   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4705        || code == EQ_EXPR || code == NE_EXPR)
4706       && ((truth_value_p (TREE_CODE (arg0))
4707            && (truth_value_p (TREE_CODE (arg1))
4708                || (TREE_CODE (arg1) == BIT_AND_EXPR
4709                    && integer_onep (TREE_OPERAND (arg1, 1)))))
4710           || (truth_value_p (TREE_CODE (arg1))
4711               && (truth_value_p (TREE_CODE (arg0))
4712                   || (TREE_CODE (arg0) == BIT_AND_EXPR
4713                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
4714     {
4715       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4716                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4717                        : TRUTH_XOR_EXPR,
4718                        type, arg0, arg1));
4719
4720       if (code == EQ_EXPR)
4721         t = invert_truthvalue (t);
4722
4723       return t;
4724     }
4725
4726   if (TREE_CODE_CLASS (code) == '1')
4727     {
4728       if (TREE_CODE (arg0) == COMPOUND_EXPR)
4729         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4730                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4731       else if (TREE_CODE (arg0) == COND_EXPR)
4732         {
4733           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4734                            fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
4735                            fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
4736
4737           /* If this was a conversion, and all we did was to move into
4738              inside the COND_EXPR, bring it back out.  But leave it if
4739              it is a conversion from integer to integer and the
4740              result precision is no wider than a word since such a
4741              conversion is cheap and may be optimized away by combine,
4742              while it couldn't if it were outside the COND_EXPR.  Then return
4743              so we don't get into an infinite recursion loop taking the
4744              conversion out and then back in.  */
4745
4746           if ((code == NOP_EXPR || code == CONVERT_EXPR
4747                || code == NON_LVALUE_EXPR)
4748               && TREE_CODE (t) == COND_EXPR
4749               && TREE_CODE (TREE_OPERAND (t, 1)) == code
4750               && TREE_CODE (TREE_OPERAND (t, 2)) == code
4751               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4752                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4753               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4754                     && (INTEGRAL_TYPE_P
4755                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
4756                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4757             t = build1 (code, type,
4758                         build (COND_EXPR,
4759                                TREE_TYPE (TREE_OPERAND
4760                                           (TREE_OPERAND (t, 1), 0)),
4761                                TREE_OPERAND (t, 0),
4762                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4763                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4764           return t;
4765         }
4766       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4767         return fold (build (COND_EXPR, type, arg0,
4768                             fold (build1 (code, type, integer_one_node)),
4769                             fold (build1 (code, type, integer_zero_node))));
4770    }
4771   else if (TREE_CODE_CLASS (code) == '2'
4772            || TREE_CODE_CLASS (code) == '<')
4773     {
4774       if (TREE_CODE (arg1) == COMPOUND_EXPR)
4775         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4776                       fold (build (code, type,
4777                                    arg0, TREE_OPERAND (arg1, 1))));
4778       else if ((TREE_CODE (arg1) == COND_EXPR
4779                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4780                     && TREE_CODE_CLASS (code) != '<'))
4781                && (TREE_CODE (arg0) != COND_EXPR
4782                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4783                && (! TREE_SIDE_EFFECTS (arg0)
4784                    || (global_bindings_p () == 0
4785                        && ! contains_placeholder_p (arg0))))
4786         {
4787           tree test, true_value, false_value;
4788           tree lhs = 0, rhs = 0;
4789
4790           if (TREE_CODE (arg1) == COND_EXPR)
4791             {
4792               test = TREE_OPERAND (arg1, 0);
4793               true_value = TREE_OPERAND (arg1, 1);
4794               false_value = TREE_OPERAND (arg1, 2);
4795             }
4796           else
4797             {
4798               tree testtype = TREE_TYPE (arg1);
4799               test = arg1;
4800               true_value = convert (testtype, integer_one_node);
4801               false_value = convert (testtype, integer_zero_node);
4802             }
4803
4804           /* If ARG0 is complex we want to make sure we only evaluate
4805              it once.  Though this is only required if it is volatile, it
4806              might be more efficient even if it is not.  However, if we
4807              succeed in folding one part to a constant, we do not need
4808              to make this SAVE_EXPR.  Since we do this optimization
4809              primarily to see if we do end up with constant and this
4810              SAVE_EXPR interferes with later optimizations, suppressing
4811              it when we can is important.
4812
4813              If we are not in a function, we can't make a SAVE_EXPR, so don't
4814              try to do so.  Don't try to see if the result is a constant
4815              if an arm is a COND_EXPR since we get exponential behavior
4816              in that case.  */
4817
4818           if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4819               && global_bindings_p () == 0
4820               && ((TREE_CODE (arg0) != VAR_DECL
4821                    && TREE_CODE (arg0) != PARM_DECL)
4822                   || TREE_SIDE_EFFECTS (arg0)))
4823             {
4824               if (TREE_CODE (true_value) != COND_EXPR)
4825                 lhs = fold (build (code, type, arg0, true_value));
4826
4827               if (TREE_CODE (false_value) != COND_EXPR)
4828                 rhs = fold (build (code, type, arg0, false_value));
4829
4830               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4831                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
4832                 arg0 = save_expr (arg0), lhs = rhs = 0;
4833             }
4834
4835           if (lhs == 0)
4836             lhs = fold (build (code, type, arg0, true_value));
4837           if (rhs == 0)
4838             rhs = fold (build (code, type, arg0, false_value));
4839
4840           test = fold (build (COND_EXPR, type, test, lhs, rhs));
4841
4842           if (TREE_CODE (arg0) == SAVE_EXPR)
4843             return build (COMPOUND_EXPR, type,
4844                           convert (void_type_node, arg0),
4845                           strip_compound_expr (test, arg0));
4846           else
4847             return convert (type, test);
4848         }
4849
4850       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4851         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4852                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4853       else if ((TREE_CODE (arg0) == COND_EXPR
4854                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4855                     && TREE_CODE_CLASS (code) != '<'))
4856                && (TREE_CODE (arg1) != COND_EXPR
4857                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4858                && (! TREE_SIDE_EFFECTS (arg1)
4859                    || (global_bindings_p () == 0
4860                        && ! contains_placeholder_p (arg1))))
4861         {
4862           tree test, true_value, false_value;
4863           tree lhs = 0, rhs = 0;
4864
4865           if (TREE_CODE (arg0) == COND_EXPR)
4866             {
4867               test = TREE_OPERAND (arg0, 0);
4868               true_value = TREE_OPERAND (arg0, 1);
4869               false_value = TREE_OPERAND (arg0, 2);
4870             }
4871           else
4872             {
4873               tree testtype = TREE_TYPE (arg0);
4874               test = arg0;
4875               true_value = convert (testtype, integer_one_node);
4876               false_value = convert (testtype, integer_zero_node);
4877             }
4878
4879           if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4880               && global_bindings_p () == 0
4881               && ((TREE_CODE (arg1) != VAR_DECL
4882                    && TREE_CODE (arg1) != PARM_DECL)
4883                   || TREE_SIDE_EFFECTS (arg1)))
4884             {
4885               if (TREE_CODE (true_value) != COND_EXPR)
4886                 lhs = fold (build (code, type, true_value, arg1));
4887
4888               if (TREE_CODE (false_value) != COND_EXPR)
4889                 rhs = fold (build (code, type, false_value, arg1));
4890
4891               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4892                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
4893                 arg1 = save_expr (arg1), lhs = rhs = 0;
4894             }
4895
4896           if (lhs == 0)
4897             lhs = fold (build (code, type, true_value, arg1));
4898
4899           if (rhs == 0)
4900             rhs = fold (build (code, type, false_value, arg1));
4901
4902           test = fold (build (COND_EXPR, type, test, lhs, rhs));
4903           if (TREE_CODE (arg1) == SAVE_EXPR)
4904             return build (COMPOUND_EXPR, type,
4905                           convert (void_type_node, arg1),
4906                           strip_compound_expr (test, arg1));
4907           else
4908             return convert (type, test);
4909         }
4910     }
4911   else if (TREE_CODE_CLASS (code) == '<'
4912            && TREE_CODE (arg0) == COMPOUND_EXPR)
4913     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4914                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4915   else if (TREE_CODE_CLASS (code) == '<'
4916            && TREE_CODE (arg1) == COMPOUND_EXPR)
4917     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4918                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4919
4920   switch (code)
4921     {
4922     case INTEGER_CST:
4923     case REAL_CST:
4924     case STRING_CST:
4925     case COMPLEX_CST:
4926     case CONSTRUCTOR:
4927       return t;
4928
4929     case CONST_DECL:
4930       return fold (DECL_INITIAL (t));
4931
4932     case NOP_EXPR:
4933     case FLOAT_EXPR:
4934     case CONVERT_EXPR:
4935     case FIX_TRUNC_EXPR:
4936       /* Other kinds of FIX are not handled properly by fold_convert.  */
4937
4938       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4939         return TREE_OPERAND (t, 0);
4940
4941       /* Handle cases of two conversions in a row.  */
4942       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4943           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4944         {
4945           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4946           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4947           tree final_type = TREE_TYPE (t);
4948           int inside_int = INTEGRAL_TYPE_P (inside_type);
4949           int inside_ptr = POINTER_TYPE_P (inside_type);
4950           int inside_float = FLOAT_TYPE_P (inside_type);
4951           int inside_prec = TYPE_PRECISION (inside_type);
4952           int inside_unsignedp = TREE_UNSIGNED (inside_type);
4953           int inter_int = INTEGRAL_TYPE_P (inter_type);
4954           int inter_ptr = POINTER_TYPE_P (inter_type);
4955           int inter_float = FLOAT_TYPE_P (inter_type);
4956           int inter_prec = TYPE_PRECISION (inter_type);
4957           int inter_unsignedp = TREE_UNSIGNED (inter_type);
4958           int final_int = INTEGRAL_TYPE_P (final_type);
4959           int final_ptr = POINTER_TYPE_P (final_type);
4960           int final_float = FLOAT_TYPE_P (final_type);
4961           int final_prec = TYPE_PRECISION (final_type);
4962           int final_unsignedp = TREE_UNSIGNED (final_type);
4963
4964           /* In addition to the cases of two conversions in a row
4965              handled below, if we are converting something to its own
4966              type via an object of identical or wider precision, neither
4967              conversion is needed.  */
4968           if (inside_type == final_type
4969               && ((inter_int && final_int) || (inter_float && final_float))
4970               && inter_prec >= final_prec)
4971             return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
4972
4973           /* Likewise, if the intermediate and final types are either both
4974              float or both integer, we don't need the middle conversion if
4975              it is wider than the final type and doesn't change the signedness
4976              (for integers).  Avoid this if the final type is a pointer
4977              since then we sometimes need the inner conversion.  Likewise if
4978              the outer has a precision not equal to the size of its mode.  */
4979           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4980                || (inter_float && inside_float))
4981               && inter_prec >= inside_prec
4982               && (inter_float || inter_unsignedp == inside_unsignedp)
4983               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4984                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4985               && ! final_ptr)
4986             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4987
4988           /* If we have a sign-extension of a zero-extended value, we can
4989              replace that by a single zero-extension.  */
4990           if (inside_int && inter_int && final_int
4991               && inside_prec < inter_prec && inter_prec < final_prec
4992               && inside_unsignedp && !inter_unsignedp)
4993             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4994
4995           /* Two conversions in a row are not needed unless:
4996              - some conversion is floating-point (overstrict for now), or
4997              - the intermediate type is narrower than both initial and
4998                final, or
4999              - the intermediate type and innermost type differ in signedness,
5000                and the outermost type is wider than the intermediate, or
5001              - the initial type is a pointer type and the precisions of the
5002                intermediate and final types differ, or
5003              - the final type is a pointer type and the precisions of the
5004                initial and intermediate types differ.  */
5005           if (! inside_float && ! inter_float && ! final_float
5006               && (inter_prec > inside_prec || inter_prec > final_prec)
5007               && ! (inside_int && inter_int
5008                     && inter_unsignedp != inside_unsignedp
5009                     && inter_prec < final_prec)
5010               && ((inter_unsignedp && inter_prec > inside_prec)
5011                   == (final_unsignedp && final_prec > inter_prec))
5012               && ! (inside_ptr && inter_prec != final_prec)
5013               && ! (final_ptr && inside_prec != inter_prec)
5014               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5015                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5016               && ! final_ptr)
5017             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5018         }
5019
5020       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5021           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5022           /* Detect assigning a bitfield.  */
5023           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5024                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5025         {
5026           /* Don't leave an assignment inside a conversion
5027              unless assigning a bitfield.  */
5028           tree prev = TREE_OPERAND (t, 0);
5029           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5030           /* First do the assignment, then return converted constant.  */
5031           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5032           TREE_USED (t) = 1;
5033           return t;
5034         }
5035       if (!wins)
5036         {
5037           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5038           return t;
5039         }
5040       return fold_convert (t, arg0);
5041
5042 #if 0  /* This loses on &"foo"[0].  */
5043     case ARRAY_REF:
5044         {
5045           int i;
5046
5047           /* Fold an expression like: "foo"[2] */
5048           if (TREE_CODE (arg0) == STRING_CST
5049               && TREE_CODE (arg1) == INTEGER_CST
5050               && !TREE_INT_CST_HIGH (arg1)
5051               && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
5052             {
5053               t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
5054               TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
5055               force_fit_type (t, 0);
5056             }
5057         }
5058       return t;
5059 #endif /* 0 */
5060
5061     case COMPONENT_REF:
5062       if (TREE_CODE (arg0) == CONSTRUCTOR)
5063         {
5064           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5065           if (m)
5066             t = TREE_VALUE (m);
5067         }
5068       return t;
5069
5070     case RANGE_EXPR:
5071       TREE_CONSTANT (t) = wins;
5072       return t;
5073
5074     case NEGATE_EXPR:
5075       if (wins)
5076         {
5077           if (TREE_CODE (arg0) == INTEGER_CST)
5078             {
5079               HOST_WIDE_INT low, high;
5080               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5081                                          TREE_INT_CST_HIGH (arg0),
5082                                          &low, &high);
5083               t = build_int_2 (low, high);
5084               TREE_TYPE (t) = type;
5085               TREE_OVERFLOW (t)
5086                 = (TREE_OVERFLOW (arg0)
5087                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5088               TREE_CONSTANT_OVERFLOW (t)
5089                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5090             }
5091           else if (TREE_CODE (arg0) == REAL_CST)
5092             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5093         }
5094       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5095         return TREE_OPERAND (arg0, 0);
5096
5097       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5098       else if (TREE_CODE (arg0) == MINUS_EXPR
5099                && (! FLOAT_TYPE_P (type) || flag_fast_math))
5100         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5101                       TREE_OPERAND (arg0, 0));
5102
5103       return t;
5104
5105     case ABS_EXPR:
5106       if (wins)
5107         {
5108           if (TREE_CODE (arg0) == INTEGER_CST)
5109             {
5110               if (! TREE_UNSIGNED (type)
5111                   && TREE_INT_CST_HIGH (arg0) < 0)
5112                 {
5113                   HOST_WIDE_INT low, high;
5114                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5115                                              TREE_INT_CST_HIGH (arg0),
5116                                              &low, &high);
5117                   t = build_int_2 (low, high);
5118                   TREE_TYPE (t) = type;
5119                   TREE_OVERFLOW (t)
5120                     = (TREE_OVERFLOW (arg0)
5121                        | force_fit_type (t, overflow));
5122                   TREE_CONSTANT_OVERFLOW (t)
5123                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5124                 }
5125             }
5126           else if (TREE_CODE (arg0) == REAL_CST)
5127             {
5128               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5129                 t = build_real (type,
5130                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5131             }
5132         }
5133       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5134         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5135       return t;
5136
5137     case CONJ_EXPR:
5138       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5139         return arg0;
5140       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5141         return build (COMPLEX_EXPR, TREE_TYPE (arg0),
5142                       TREE_OPERAND (arg0, 0),
5143                       negate_expr (TREE_OPERAND (arg0, 1)));
5144       else if (TREE_CODE (arg0) == COMPLEX_CST)
5145         return build_complex (type, TREE_OPERAND (arg0, 0),
5146                               negate_expr (TREE_OPERAND (arg0, 1)));
5147       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5148         return fold (build (TREE_CODE (arg0), type,
5149                             fold (build1 (CONJ_EXPR, type,
5150                                           TREE_OPERAND (arg0, 0))),
5151                             fold (build1 (CONJ_EXPR,
5152                                           type, TREE_OPERAND (arg0, 1)))));
5153       else if (TREE_CODE (arg0) == CONJ_EXPR)
5154         return TREE_OPERAND (arg0, 0);
5155       return t;
5156
5157     case BIT_NOT_EXPR:
5158       if (wins)
5159         {
5160           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5161                            ~ TREE_INT_CST_HIGH (arg0));
5162           TREE_TYPE (t) = type;
5163           force_fit_type (t, 0);
5164           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5165           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5166         }
5167       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5168         return TREE_OPERAND (arg0, 0);
5169       return t;
5170
5171     case PLUS_EXPR:
5172       /* A + (-B) -> A - B */
5173       if (TREE_CODE (arg1) == NEGATE_EXPR)
5174         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5175       /* (-A) + B -> B - A */
5176       if (TREE_CODE (arg0) == NEGATE_EXPR)
5177         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5178       else if (! FLOAT_TYPE_P (type))
5179         {
5180           if (integer_zerop (arg1))
5181             return non_lvalue (convert (type, arg0));
5182
5183           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5184              with a constant, and the two constants have no bits in common,
5185              we should treat this as a BIT_IOR_EXPR since this may produce more
5186              simplifications.  */
5187           if (TREE_CODE (arg0) == BIT_AND_EXPR
5188               && TREE_CODE (arg1) == BIT_AND_EXPR
5189               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5190               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5191               && integer_zerop (const_binop (BIT_AND_EXPR,
5192                                              TREE_OPERAND (arg0, 1),
5193                                              TREE_OPERAND (arg1, 1), 0)))
5194             {
5195               code = BIT_IOR_EXPR;
5196               goto bit_ior;
5197             }
5198
5199           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5200              (plus (plus (mult) (mult)) (foo)) so that we can
5201              take advantage of the factoring cases below.  */
5202           if ((TREE_CODE (arg0) == PLUS_EXPR
5203                && TREE_CODE (arg1) == MULT_EXPR)
5204               || (TREE_CODE (arg1) == PLUS_EXPR
5205                   && TREE_CODE (arg0) == MULT_EXPR))
5206             {
5207               tree parg0, parg1, parg, marg;
5208
5209               if (TREE_CODE (arg0) == PLUS_EXPR)
5210                 parg = arg0, marg = arg1;
5211               else
5212                 parg = arg1, marg = arg0;
5213               parg0 = TREE_OPERAND (parg, 0);
5214               parg1 = TREE_OPERAND (parg, 1);
5215               STRIP_NOPS (parg0);
5216               STRIP_NOPS (parg1);
5217
5218               if (TREE_CODE (parg0) == MULT_EXPR
5219                   && TREE_CODE (parg1) != MULT_EXPR)
5220                 return fold (build (PLUS_EXPR, type,
5221                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5222                                     parg1));
5223               if (TREE_CODE (parg0) != MULT_EXPR
5224                   && TREE_CODE (parg1) == MULT_EXPR)
5225                 return fold (build (PLUS_EXPR, type,
5226                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5227                                     parg0));
5228             }
5229
5230           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5231             {
5232               tree arg00, arg01, arg10, arg11;
5233               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5234
5235               /* (A * C) + (B * C) -> (A+B) * C.
5236                  We are most concerned about the case where C is a constant,
5237                  but other combinations show up during loop reduction.  Since
5238                  it is not difficult, try all four possibilities.  */
5239
5240               arg00 = TREE_OPERAND (arg0, 0);
5241               arg01 = TREE_OPERAND (arg0, 1);
5242               arg10 = TREE_OPERAND (arg1, 0);
5243               arg11 = TREE_OPERAND (arg1, 1);
5244               same = NULL_TREE;
5245
5246               if (operand_equal_p (arg01, arg11, 0))
5247                 same = arg01, alt0 = arg00, alt1 = arg10;
5248               else if (operand_equal_p (arg00, arg10, 0))
5249                 same = arg00, alt0 = arg01, alt1 = arg11;
5250               else if (operand_equal_p (arg00, arg11, 0))
5251                 same = arg00, alt0 = arg01, alt1 = arg10;
5252               else if (operand_equal_p (arg01, arg10, 0))
5253                 same = arg01, alt0 = arg00, alt1 = arg11;
5254
5255               /* No identical multiplicands; see if we can find a common
5256                  power-of-two factor in non-power-of-two multiplies.  This
5257                  can help in multi-dimensional array access.  */
5258               else if (TREE_CODE (arg01) == INTEGER_CST
5259                        && TREE_CODE (arg11) == INTEGER_CST
5260                        && TREE_INT_CST_HIGH (arg01) == 0
5261                        && TREE_INT_CST_HIGH (arg11) == 0)
5262                 {
5263                   HOST_WIDE_INT int01, int11, tmp;
5264                   int01 = TREE_INT_CST_LOW (arg01);
5265                   int11 = TREE_INT_CST_LOW (arg11);
5266
5267                   /* Move min of absolute values to int11.  */
5268                   if ((int01 >= 0 ? int01 : -int01)
5269                       < (int11 >= 0 ? int11 : -int11))
5270                     {
5271                       tmp = int01, int01 = int11, int11 = tmp;
5272                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5273                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5274                     }
5275
5276                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5277                     {
5278                       alt0 = fold (build (MULT_EXPR, type, arg00,
5279                                           build_int_2 (int01 / int11, 0)));
5280                       alt1 = arg10;
5281                       same = arg11;
5282                     }
5283                 }
5284
5285               if (same)
5286                 return fold (build (MULT_EXPR, type,
5287                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5288                                     same));
5289             }
5290         }
5291       /* In IEEE floating point, x+0 may not equal x.  */
5292       else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5293                 || flag_fast_math)
5294                && real_zerop (arg1))
5295         return non_lvalue (convert (type, arg0));
5296       /* x+(-0) equals x, even for IEEE.  */
5297       else if (TREE_CODE (arg1) == REAL_CST
5298                && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5299         return non_lvalue (convert (type, arg0));
5300
5301      bit_rotate:
5302       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5303          is a rotate of A by C1 bits.  */
5304       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5305          is a rotate of A by B bits.  */
5306       {
5307         register enum tree_code code0, code1;
5308         code0 = TREE_CODE (arg0);
5309         code1 = TREE_CODE (arg1);
5310         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5311             || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5312             && operand_equal_p (TREE_OPERAND (arg0, 0),
5313                                 TREE_OPERAND (arg1,0), 0)
5314             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5315           {
5316             register tree tree01, tree11;
5317             register enum tree_code code01, code11;
5318
5319             tree01 = TREE_OPERAND (arg0, 1);
5320             tree11 = TREE_OPERAND (arg1, 1);
5321             STRIP_NOPS (tree01);
5322             STRIP_NOPS (tree11);
5323             code01 = TREE_CODE (tree01);
5324             code11 = TREE_CODE (tree11);
5325             if (code01 == INTEGER_CST
5326               && code11 == INTEGER_CST
5327               && TREE_INT_CST_HIGH (tree01) == 0
5328               && TREE_INT_CST_HIGH (tree11) == 0
5329               && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5330                 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5331               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5332                         code0 == LSHIFT_EXPR ? tree01 : tree11);
5333             else if (code11 == MINUS_EXPR)
5334               {
5335                 tree tree110, tree111;
5336                 tree110 = TREE_OPERAND (tree11, 0);
5337                 tree111 = TREE_OPERAND (tree11, 1);
5338                 STRIP_NOPS (tree110);
5339                 STRIP_NOPS (tree111);
5340                 if (TREE_CODE (tree110) == INTEGER_CST
5341                     && TREE_INT_CST_HIGH (tree110) == 0
5342                     && (TREE_INT_CST_LOW (tree110)
5343                         == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5344                     && operand_equal_p (tree01, tree111, 0))
5345                   return build ((code0 == LSHIFT_EXPR
5346                                  ? LROTATE_EXPR
5347                                  : RROTATE_EXPR),
5348                                 type, TREE_OPERAND (arg0, 0), tree01);
5349               }
5350             else if (code01 == MINUS_EXPR)
5351               {
5352                 tree tree010, tree011;
5353                 tree010 = TREE_OPERAND (tree01, 0);
5354                 tree011 = TREE_OPERAND (tree01, 1);
5355                 STRIP_NOPS (tree010);
5356                 STRIP_NOPS (tree011);
5357                 if (TREE_CODE (tree010) == INTEGER_CST
5358                     && TREE_INT_CST_HIGH (tree010) == 0
5359                     && (TREE_INT_CST_LOW (tree010)
5360                         == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5361                     && operand_equal_p (tree11, tree011, 0))
5362                   return build ((code0 != LSHIFT_EXPR
5363                                  ? LROTATE_EXPR
5364                                  : RROTATE_EXPR),
5365                                  type, TREE_OPERAND (arg0, 0), tree11);
5366               }
5367           }
5368       }
5369
5370
5371     associate:
5372       /* In most languages, can't associate operations on floats through
5373          parentheses.  Rather than remember where the parentheses were, we
5374          don't associate floats at all.  It shouldn't matter much.  However,
5375          associating multiplications is only very slightly inaccurate, so do
5376          that if -ffast-math is specified.  */
5377
5378       if (! wins
5379           && (! FLOAT_TYPE_P (type)
5380               || (flag_fast_math && code != MULT_EXPR)))
5381         {
5382           tree var0, con0, lit0, var1, con1, lit1;
5383
5384           /* Split both trees into variables, constants, and literals.  Then
5385              associate each group together, the constants with literals,
5386              then the result with variables.  This increases the chances of
5387              literals being recombined later and of generating relocatable
5388              expressions for the sum of a constant and literal. */
5389           var0 = split_tree (arg0, code, &con0, &lit0, 0);
5390           var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
5391
5392           /* Only do something if we found more than two objects.  Otherwise,
5393              nothing has changed and we risk infinite recursion.  */
5394           if (2 < ((var0 != 0) + (var1 != 0) + (con0 != 0) + (con1 != 0)
5395                    + (lit0 != 0) + (lit1 != 0)))
5396             {
5397               var0 = associate_trees (var0, var1, code, type);
5398               con0 = associate_trees (con0, con1, code, type);
5399               lit0 = associate_trees (lit0, lit1, code, type);
5400               con0 = associate_trees (con0, lit0, code, type);
5401               return convert (type, associate_trees (var0, con0, code, type));
5402             }
5403         }
5404
5405     binary:
5406 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
5407       if (TREE_CODE (arg1) == REAL_CST)
5408         return t;
5409 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
5410       if (wins)
5411         t1 = const_binop (code, arg0, arg1, 0);
5412       if (t1 != NULL_TREE)
5413         {
5414           /* The return value should always have
5415              the same type as the original expression.  */
5416           if (TREE_TYPE (t1) != TREE_TYPE (t))
5417             t1 = convert (TREE_TYPE (t), t1);
5418
5419           return t1;
5420         }
5421       return t;
5422
5423     case MINUS_EXPR:
5424       /* A - (-B) -> A + B */
5425       if (TREE_CODE (arg1) == NEGATE_EXPR)
5426         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5427       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5428       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5429         return
5430           fold (build (MINUS_EXPR, type,
5431                        build_real (TREE_TYPE (arg1),
5432                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5433                        TREE_OPERAND (arg0, 0)));
5434
5435       if (! FLOAT_TYPE_P (type))
5436         {
5437           if (! wins && integer_zerop (arg0))
5438             return negate_expr (arg1);
5439           if (integer_zerop (arg1))
5440             return non_lvalue (convert (type, arg0));
5441
5442           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5443              about the case where C is a constant, just try one of the
5444              four possibilities.  */
5445
5446           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5447               && operand_equal_p (TREE_OPERAND (arg0, 1),
5448                                   TREE_OPERAND (arg1, 1), 0))
5449             return fold (build (MULT_EXPR, type,
5450                                 fold (build (MINUS_EXPR, type,
5451                                              TREE_OPERAND (arg0, 0),
5452                                              TREE_OPERAND (arg1, 0))),
5453                                 TREE_OPERAND (arg0, 1)));
5454         }
5455
5456       else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5457                || flag_fast_math)
5458         {
5459           /* Except with IEEE floating point, 0-x equals -x.  */
5460           if (! wins && real_zerop (arg0))
5461             return negate_expr (arg1);
5462           /* Except with IEEE floating point, x-0 equals x.  */
5463           if (real_zerop (arg1))
5464             return non_lvalue (convert (type, arg0));
5465         }
5466
5467       /* Fold &x - &x.  This can happen from &x.foo - &x.
5468          This is unsafe for certain floats even in non-IEEE formats.
5469          In IEEE, it is unsafe because it does wrong for NaNs.
5470          Also note that operand_equal_p is always false if an operand
5471          is volatile.  */
5472
5473       if ((! FLOAT_TYPE_P (type) || flag_fast_math)
5474           && operand_equal_p (arg0, arg1, 0))
5475         return convert (type, integer_zero_node);
5476
5477       goto associate;
5478
5479     case MULT_EXPR:
5480       /* (-A) * (-B) -> A * B  */
5481       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5482         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5483                             TREE_OPERAND (arg1, 0)));
5484
5485       if (! FLOAT_TYPE_P (type))
5486         {
5487           if (integer_zerop (arg1))
5488             return omit_one_operand (type, arg1, arg0);
5489           if (integer_onep (arg1))
5490             return non_lvalue (convert (type, arg0));
5491
5492           /* (a * (1 << b)) is (a << b)  */
5493           if (TREE_CODE (arg1) == LSHIFT_EXPR
5494               && integer_onep (TREE_OPERAND (arg1, 0)))
5495             return fold (build (LSHIFT_EXPR, type, arg0,
5496                                 TREE_OPERAND (arg1, 1)));
5497           if (TREE_CODE (arg0) == LSHIFT_EXPR
5498               && integer_onep (TREE_OPERAND (arg0, 0)))
5499             return fold (build (LSHIFT_EXPR, type, arg1,
5500                                 TREE_OPERAND (arg0, 1)));
5501
5502           if (TREE_CODE (arg1) == INTEGER_CST
5503               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5504                                              code, NULL_TREE)))
5505             return convert (type, tem);
5506
5507         }
5508       else
5509         {
5510           /* x*0 is 0, except for IEEE floating point.  */
5511           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5512                || flag_fast_math)
5513               && real_zerop (arg1))
5514             return omit_one_operand (type, arg1, arg0);
5515           /* In IEEE floating point, x*1 is not equivalent to x for snans.
5516              However, ANSI says we can drop signals,
5517              so we can do this anyway.  */
5518           if (real_onep (arg1))
5519             return non_lvalue (convert (type, arg0));
5520           /* x*2 is x+x */
5521           if (! wins && real_twop (arg1) && global_bindings_p () == 0
5522               && ! contains_placeholder_p (arg0))
5523             {
5524               tree arg = save_expr (arg0);
5525               return build (PLUS_EXPR, type, arg, arg);
5526             }
5527         }
5528       goto associate;
5529
5530     case BIT_IOR_EXPR:
5531     bit_ior:
5532       if (integer_all_onesp (arg1))
5533         return omit_one_operand (type, arg1, arg0);
5534       if (integer_zerop (arg1))
5535         return non_lvalue (convert (type, arg0));
5536       t1 = distribute_bit_expr (code, type, arg0, arg1);
5537       if (t1 != NULL_TREE)
5538         return t1;
5539
5540       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5541
5542          This results in more efficient code for machines without a NAND
5543          instruction.  Combine will canonicalize to the first form
5544          which will allow use of NAND instructions provided by the
5545          backend if they exist.  */
5546       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5547           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5548         {
5549           return fold (build1 (BIT_NOT_EXPR, type,
5550                                build (BIT_AND_EXPR, type,
5551                                       TREE_OPERAND (arg0, 0),
5552                                       TREE_OPERAND (arg1, 0))));
5553         }
5554
5555       /* See if this can be simplified into a rotate first.  If that
5556          is unsuccessful continue in the association code.  */
5557       goto bit_rotate;
5558
5559     case BIT_XOR_EXPR:
5560       if (integer_zerop (arg1))
5561         return non_lvalue (convert (type, arg0));
5562       if (integer_all_onesp (arg1))
5563         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5564
5565       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5566          with a constant, and the two constants have no bits in common,
5567          we should treat this as a BIT_IOR_EXPR since this may produce more
5568          simplifications.  */
5569       if (TREE_CODE (arg0) == BIT_AND_EXPR
5570           && TREE_CODE (arg1) == BIT_AND_EXPR
5571           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5572           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5573           && integer_zerop (const_binop (BIT_AND_EXPR,
5574                                          TREE_OPERAND (arg0, 1),
5575                                          TREE_OPERAND (arg1, 1), 0)))
5576         {
5577            code = BIT_IOR_EXPR;
5578            goto bit_ior;
5579         }
5580
5581       /* See if this can be simplified into a rotate first.  If that
5582          is unsuccessful continue in the association code.  */
5583       goto bit_rotate;
5584
5585     case BIT_AND_EXPR:
5586     bit_and:
5587       if (integer_all_onesp (arg1))
5588         return non_lvalue (convert (type, arg0));
5589       if (integer_zerop (arg1))
5590         return omit_one_operand (type, arg1, arg0);
5591       t1 = distribute_bit_expr (code, type, arg0, arg1);
5592       if (t1 != NULL_TREE)
5593         return t1;
5594       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5595       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5596           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5597         {
5598           int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5599           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5600               && (~TREE_INT_CST_LOW (arg0)
5601                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5602             return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5603         }
5604       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5605           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5606         {
5607           int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5608           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5609               && (~TREE_INT_CST_LOW (arg1)
5610                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5611             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5612         }
5613
5614       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5615
5616          This results in more efficient code for machines without a NOR
5617          instruction.  Combine will canonicalize to the first form
5618          which will allow use of NOR instructions provided by the
5619          backend if they exist.  */
5620       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5621           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5622         {
5623           return fold (build1 (BIT_NOT_EXPR, type,
5624                                build (BIT_IOR_EXPR, type,
5625                                       TREE_OPERAND (arg0, 0),
5626                                       TREE_OPERAND (arg1, 0))));
5627         }
5628
5629       goto associate;
5630
5631     case BIT_ANDTC_EXPR:
5632       if (integer_all_onesp (arg0))
5633         return non_lvalue (convert (type, arg1));
5634       if (integer_zerop (arg0))
5635         return omit_one_operand (type, arg0, arg1);
5636       if (TREE_CODE (arg1) == INTEGER_CST)
5637         {
5638           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5639           code = BIT_AND_EXPR;
5640           goto bit_and;
5641         }
5642       goto binary;
5643
5644     case RDIV_EXPR:
5645       /* In most cases, do nothing with a divide by zero.  */
5646 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5647 #ifndef REAL_INFINITY
5648       if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5649         return t;
5650 #endif
5651 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5652
5653       /* (-A) / (-B) -> A / B  */
5654       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5655         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5656                             TREE_OPERAND (arg1, 0)));
5657
5658       /* In IEEE floating point, x/1 is not equivalent to x for snans.
5659          However, ANSI says we can drop signals, so we can do this anyway.  */
5660       if (real_onep (arg1))
5661         return non_lvalue (convert (type, arg0));
5662
5663       /* If ARG1 is a constant, we can convert this to a multiply by the
5664          reciprocal.  This does not have the same rounding properties,
5665          so only do this if -ffast-math.  We can actually always safely
5666          do it if ARG1 is a power of two, but it's hard to tell if it is
5667          or not in a portable manner.  */
5668       if (TREE_CODE (arg1) == REAL_CST)
5669         {
5670           if (flag_fast_math
5671               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5672                                           arg1, 0)))
5673             return fold (build (MULT_EXPR, type, arg0, tem));
5674           /* Find the reciprocal if optimizing and the result is exact. */
5675           else if (optimize)
5676             {
5677               REAL_VALUE_TYPE r;
5678               r = TREE_REAL_CST (arg1);
5679               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5680                   {
5681                     tem = build_real (type, r);
5682                     return fold (build (MULT_EXPR, type, arg0, tem));
5683                   }
5684             }
5685         }
5686       goto binary;
5687
5688     case TRUNC_DIV_EXPR:
5689     case ROUND_DIV_EXPR:
5690     case FLOOR_DIV_EXPR:
5691     case CEIL_DIV_EXPR:
5692     case EXACT_DIV_EXPR:
5693       if (integer_onep (arg1))
5694         return non_lvalue (convert (type, arg0));
5695       if (integer_zerop (arg1))
5696         return t;
5697
5698       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5699          operation, EXACT_DIV_EXPR.
5700
5701          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5702          At one time others generated faster code, it's not clear if they do
5703          after the last round to changes to the DIV code in expmed.c.  */
5704       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5705           && multiple_of_p (type, arg0, arg1))
5706         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5707
5708         if (TREE_CODE (arg1) == INTEGER_CST
5709           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5710                                          code, NULL_TREE)))
5711         return convert (type, tem);
5712
5713       goto binary;
5714
5715     case CEIL_MOD_EXPR:
5716     case FLOOR_MOD_EXPR:
5717     case ROUND_MOD_EXPR:
5718     case TRUNC_MOD_EXPR:
5719       if (integer_onep (arg1))
5720         return omit_one_operand (type, integer_zero_node, arg0);
5721       if (integer_zerop (arg1))
5722         return t;
5723
5724       if (TREE_CODE (arg1) == INTEGER_CST
5725           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5726                                          code, NULL_TREE)))
5727         return convert (type, tem);
5728
5729       goto binary;
5730
5731     case LSHIFT_EXPR:
5732     case RSHIFT_EXPR:
5733     case LROTATE_EXPR:
5734     case RROTATE_EXPR:
5735       if (integer_zerop (arg1))
5736         return non_lvalue (convert (type, arg0));
5737       /* Since negative shift count is not well-defined,
5738          don't try to compute it in the compiler.  */
5739       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5740         return t;
5741       /* Rewrite an LROTATE_EXPR by a constant into an
5742          RROTATE_EXPR by a new constant.  */
5743       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5744         {
5745           TREE_SET_CODE (t, RROTATE_EXPR);
5746           code = RROTATE_EXPR;
5747           TREE_OPERAND (t, 1) = arg1
5748             = const_binop
5749               (MINUS_EXPR,
5750                convert (TREE_TYPE (arg1),
5751                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5752                arg1, 0);
5753           if (tree_int_cst_sgn (arg1) < 0)
5754             return t;
5755         }
5756
5757       /* If we have a rotate of a bit operation with the rotate count and
5758          the second operand of the bit operation both constant,
5759          permute the two operations.  */
5760       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5761           && (TREE_CODE (arg0) == BIT_AND_EXPR
5762               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5763               || TREE_CODE (arg0) == BIT_IOR_EXPR
5764               || TREE_CODE (arg0) == BIT_XOR_EXPR)
5765           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5766         return fold (build (TREE_CODE (arg0), type,
5767                             fold (build (code, type,
5768                                          TREE_OPERAND (arg0, 0), arg1)),
5769                             fold (build (code, type,
5770                                          TREE_OPERAND (arg0, 1), arg1))));
5771
5772       /* Two consecutive rotates adding up to the width of the mode can
5773          be ignored.  */
5774       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5775           && TREE_CODE (arg0) == RROTATE_EXPR
5776           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5777           && TREE_INT_CST_HIGH (arg1) == 0
5778           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5779           && ((TREE_INT_CST_LOW (arg1)
5780                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5781               == GET_MODE_BITSIZE (TYPE_MODE (type))))
5782         return TREE_OPERAND (arg0, 0);
5783
5784       goto binary;
5785
5786     case MIN_EXPR:
5787       if (operand_equal_p (arg0, arg1, 0))
5788         return arg0;
5789       if (INTEGRAL_TYPE_P (type)
5790           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5791         return omit_one_operand (type, arg1, arg0);
5792       goto associate;
5793
5794     case MAX_EXPR:
5795       if (operand_equal_p (arg0, arg1, 0))
5796         return arg0;
5797       if (INTEGRAL_TYPE_P (type)
5798           && TYPE_MAX_VALUE (type)
5799           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5800         return omit_one_operand (type, arg1, arg0);
5801       goto associate;
5802
5803     case TRUTH_NOT_EXPR:
5804       /* Note that the operand of this must be an int
5805          and its values must be 0 or 1.
5806          ("true" is a fixed value perhaps depending on the language,
5807          but we don't handle values other than 1 correctly yet.)  */
5808       tem = invert_truthvalue (arg0);
5809       /* Avoid infinite recursion.  */
5810       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5811         return t;
5812       return convert (type, tem);
5813
5814     case TRUTH_ANDIF_EXPR:
5815       /* Note that the operands of this must be ints
5816          and their values must be 0 or 1.
5817          ("true" is a fixed value perhaps depending on the language.)  */
5818       /* If first arg is constant zero, return it.  */
5819       if (integer_zerop (arg0))
5820         return arg0;
5821     case TRUTH_AND_EXPR:
5822       /* If either arg is constant true, drop it.  */
5823       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5824         return non_lvalue (arg1);
5825       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5826         return non_lvalue (arg0);
5827       /* If second arg is constant zero, result is zero, but first arg
5828          must be evaluated.  */
5829       if (integer_zerop (arg1))
5830         return omit_one_operand (type, arg1, arg0);
5831       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5832          case will be handled here.  */
5833       if (integer_zerop (arg0))
5834         return omit_one_operand (type, arg0, arg1);
5835
5836     truth_andor:
5837       /* We only do these simplifications if we are optimizing.  */
5838       if (!optimize)
5839         return t;
5840
5841       /* Check for things like (A || B) && (A || C).  We can convert this
5842          to A || (B && C).  Note that either operator can be any of the four
5843          truth and/or operations and the transformation will still be
5844          valid.   Also note that we only care about order for the
5845          ANDIF and ORIF operators.  If B contains side effects, this
5846          might change the truth-value of A. */
5847       if (TREE_CODE (arg0) == TREE_CODE (arg1)
5848           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5849               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5850               || TREE_CODE (arg0) == TRUTH_AND_EXPR
5851               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5852           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5853         {
5854           tree a00 = TREE_OPERAND (arg0, 0);
5855           tree a01 = TREE_OPERAND (arg0, 1);
5856           tree a10 = TREE_OPERAND (arg1, 0);
5857           tree a11 = TREE_OPERAND (arg1, 1);
5858           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5859                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5860                              && (code == TRUTH_AND_EXPR
5861                                  || code == TRUTH_OR_EXPR));
5862
5863           if (operand_equal_p (a00, a10, 0))
5864             return fold (build (TREE_CODE (arg0), type, a00,
5865                                 fold (build (code, type, a01, a11))));
5866           else if (commutative && operand_equal_p (a00, a11, 0))
5867             return fold (build (TREE_CODE (arg0), type, a00,
5868                                 fold (build (code, type, a01, a10))));
5869           else if (commutative && operand_equal_p (a01, a10, 0))
5870             return fold (build (TREE_CODE (arg0), type, a01,
5871                                 fold (build (code, type, a00, a11))));
5872
5873           /* This case if tricky because we must either have commutative
5874              operators or else A10 must not have side-effects.  */
5875
5876           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5877                    && operand_equal_p (a01, a11, 0))
5878             return fold (build (TREE_CODE (arg0), type,
5879                                 fold (build (code, type, a00, a10)),
5880                                 a01));
5881         }
5882
5883       /* See if we can build a range comparison.  */
5884       if (0 != (tem = fold_range_test (t)))
5885         return tem;
5886
5887       /* Check for the possibility of merging component references.  If our
5888          lhs is another similar operation, try to merge its rhs with our
5889          rhs.  Then try to merge our lhs and rhs.  */
5890       if (TREE_CODE (arg0) == code
5891           && 0 != (tem = fold_truthop (code, type,
5892                                        TREE_OPERAND (arg0, 1), arg1)))
5893         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5894
5895       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5896         return tem;
5897
5898       return t;
5899
5900     case TRUTH_ORIF_EXPR:
5901       /* Note that the operands of this must be ints
5902          and their values must be 0 or true.
5903          ("true" is a fixed value perhaps depending on the language.)  */
5904       /* If first arg is constant true, return it.  */
5905       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5906         return arg0;
5907     case TRUTH_OR_EXPR:
5908       /* If either arg is constant zero, drop it.  */
5909       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5910         return non_lvalue (arg1);
5911       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
5912         return non_lvalue (arg0);
5913       /* If second arg is constant true, result is true, but we must
5914          evaluate first arg.  */
5915       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5916         return omit_one_operand (type, arg1, arg0);
5917       /* Likewise for first arg, but note this only occurs here for
5918          TRUTH_OR_EXPR.  */
5919       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5920         return omit_one_operand (type, arg0, arg1);
5921       goto truth_andor;
5922
5923     case TRUTH_XOR_EXPR:
5924       /* If either arg is constant zero, drop it.  */
5925       if (integer_zerop (arg0))
5926         return non_lvalue (arg1);
5927       if (integer_zerop (arg1))
5928         return non_lvalue (arg0);
5929       /* If either arg is constant true, this is a logical inversion.  */
5930       if (integer_onep (arg0))
5931         return non_lvalue (invert_truthvalue (arg1));
5932       if (integer_onep (arg1))
5933         return non_lvalue (invert_truthvalue (arg0));
5934       return t;
5935
5936     case EQ_EXPR:
5937     case NE_EXPR:
5938     case LT_EXPR:
5939     case GT_EXPR:
5940     case LE_EXPR:
5941     case GE_EXPR:
5942       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
5943         {
5944           /* (-a) CMP (-b) -> b CMP a  */
5945           if (TREE_CODE (arg0) == NEGATE_EXPR
5946               && TREE_CODE (arg1) == NEGATE_EXPR)
5947             return fold (build (code, type, TREE_OPERAND (arg1, 0),
5948                                 TREE_OPERAND (arg0, 0)));
5949           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
5950           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5951             return
5952               fold (build
5953                      (swap_tree_comparison (code), type,
5954                       TREE_OPERAND (arg0, 0),
5955                       build_real (TREE_TYPE (arg1),
5956                                   REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
5957           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
5958           /* a CMP (-0) -> a CMP 0  */
5959           if (TREE_CODE (arg1) == REAL_CST
5960               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5961             return fold (build (code, type, arg0,
5962                                 build_real (TREE_TYPE (arg1), dconst0)));
5963         }
5964
5965
5966       /* If one arg is a constant integer, put it last.  */
5967       if (TREE_CODE (arg0) == INTEGER_CST
5968           && TREE_CODE (arg1) != INTEGER_CST)
5969         {
5970           TREE_OPERAND (t, 0) = arg1;
5971           TREE_OPERAND (t, 1) = arg0;
5972           arg0 = TREE_OPERAND (t, 0);
5973           arg1 = TREE_OPERAND (t, 1);
5974           code = swap_tree_comparison (code);
5975           TREE_SET_CODE (t, code);
5976         }
5977
5978       /* Convert foo++ == CONST into ++foo == CONST + INCR.
5979          First, see if one arg is constant; find the constant arg
5980          and the other one.  */
5981       {
5982         tree constop = 0, varop = NULL_TREE;
5983         int constopnum = -1;
5984
5985         if (TREE_CONSTANT (arg1))
5986           constopnum = 1, constop = arg1, varop = arg0;
5987         if (TREE_CONSTANT (arg0))
5988           constopnum = 0, constop = arg0, varop = arg1;
5989
5990         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5991           {
5992             /* This optimization is invalid for ordered comparisons
5993                if CONST+INCR overflows or if foo+incr might overflow.
5994                This optimization is invalid for floating point due to rounding.
5995                For pointer types we assume overflow doesn't happen.  */
5996             if (POINTER_TYPE_P (TREE_TYPE (varop))
5997                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5998                     && (code == EQ_EXPR || code == NE_EXPR)))
5999               {
6000                 tree newconst
6001                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6002                                  constop, TREE_OPERAND (varop, 1)));
6003                 TREE_SET_CODE (varop, PREINCREMENT_EXPR);
6004
6005                 /* If VAROP is a reference to a bitfield, we must mask
6006                    the constant by the width of the field.  */
6007                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6008                     && DECL_BIT_FIELD(TREE_OPERAND
6009                                       (TREE_OPERAND (varop, 0), 1)))
6010                   {
6011                     int size
6012                       = TREE_INT_CST_LOW (DECL_SIZE
6013                                           (TREE_OPERAND
6014                                            (TREE_OPERAND (varop, 0), 1)));
6015                     tree mask, unsigned_type;
6016                     int precision;
6017                     tree folded_compare;
6018
6019                     /* First check whether the comparison would come out
6020                        always the same.  If we don't do that we would
6021                        change the meaning with the masking.  */
6022                     if (constopnum == 0)
6023                       folded_compare = fold (build (code, type, constop,
6024                                                     TREE_OPERAND (varop, 0)));
6025                     else
6026                       folded_compare = fold (build (code, type,
6027                                                     TREE_OPERAND (varop, 0),
6028                                                     constop));
6029                     if (integer_zerop (folded_compare)
6030                         || integer_onep (folded_compare))
6031                       return omit_one_operand (type, folded_compare, varop);
6032
6033                     unsigned_type = type_for_size (size, 1);
6034                     precision = TYPE_PRECISION (unsigned_type);
6035                     mask = build_int_2 (~0, ~0);
6036                     TREE_TYPE (mask) = unsigned_type;
6037                     force_fit_type (mask, 0);
6038                     mask = const_binop (RSHIFT_EXPR, mask,
6039                                         size_int (precision - size), 0);
6040                     newconst = fold (build (BIT_AND_EXPR,
6041                                             TREE_TYPE (varop), newconst,
6042                                             convert (TREE_TYPE (varop),
6043                                                      mask)));
6044                   }
6045
6046
6047                 t = build (code, type, TREE_OPERAND (t, 0),
6048                            TREE_OPERAND (t, 1));
6049                 TREE_OPERAND (t, constopnum) = newconst;
6050                 return t;
6051               }
6052           }
6053         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6054           {
6055             if (POINTER_TYPE_P (TREE_TYPE (varop))
6056                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6057                     && (code == EQ_EXPR || code == NE_EXPR)))
6058               {
6059                 tree newconst
6060                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6061                                  constop, TREE_OPERAND (varop, 1)));
6062                 TREE_SET_CODE (varop, PREDECREMENT_EXPR);
6063
6064                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6065                     && DECL_BIT_FIELD(TREE_OPERAND
6066                                       (TREE_OPERAND (varop, 0), 1)))
6067                   {
6068                     int size
6069                       = TREE_INT_CST_LOW (DECL_SIZE
6070                                           (TREE_OPERAND
6071                                            (TREE_OPERAND (varop, 0), 1)));
6072                     tree mask, unsigned_type;
6073                     int precision;
6074                     tree folded_compare;
6075
6076                     if (constopnum == 0)
6077                       folded_compare = fold (build (code, type, constop,
6078                                                     TREE_OPERAND (varop, 0)));
6079                     else
6080                       folded_compare = fold (build (code, type,
6081                                                     TREE_OPERAND (varop, 0),
6082                                                     constop));
6083                     if (integer_zerop (folded_compare)
6084                         || integer_onep (folded_compare))
6085                       return omit_one_operand (type, folded_compare, varop);
6086
6087                     unsigned_type = type_for_size (size, 1);
6088                     precision = TYPE_PRECISION (unsigned_type);
6089                     mask = build_int_2 (~0, ~0);
6090                     TREE_TYPE (mask) = TREE_TYPE (varop);
6091                     force_fit_type (mask, 0);
6092                     mask = const_binop (RSHIFT_EXPR, mask,
6093                                         size_int (precision - size), 0);
6094                     newconst = fold (build (BIT_AND_EXPR,
6095                                             TREE_TYPE (varop), newconst,
6096                                             convert (TREE_TYPE (varop),
6097                                                      mask)));
6098                   }
6099
6100
6101                 t = build (code, type, TREE_OPERAND (t, 0),
6102                            TREE_OPERAND (t, 1));
6103                 TREE_OPERAND (t, constopnum) = newconst;
6104                 return t;
6105               }
6106           }
6107       }
6108
6109       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
6110       if (TREE_CODE (arg1) == INTEGER_CST
6111           && TREE_CODE (arg0) != INTEGER_CST
6112           && tree_int_cst_sgn (arg1) > 0)
6113         {
6114           switch (TREE_CODE (t))
6115             {
6116             case GE_EXPR:
6117               code = GT_EXPR;
6118               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6119               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6120               break;
6121
6122             case LT_EXPR:
6123               code = LE_EXPR;
6124               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6125               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6126               break;
6127
6128             default:
6129               break;
6130             }
6131         }
6132
6133       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6134          a MINUS_EXPR of a constant, we can convert it into a comparison with
6135          a revised constant as long as no overflow occurs.  */
6136       if ((code == EQ_EXPR || code == NE_EXPR)
6137           && TREE_CODE (arg1) == INTEGER_CST
6138           && (TREE_CODE (arg0) == PLUS_EXPR
6139               || TREE_CODE (arg0) == MINUS_EXPR)
6140           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6141           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6142                                       ? MINUS_EXPR : PLUS_EXPR,
6143                                       arg1, TREE_OPERAND (arg0, 1), 0))
6144           && ! TREE_CONSTANT_OVERFLOW (tem))
6145         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6146
6147       /* Similarly for a NEGATE_EXPR.  */
6148       else if ((code == EQ_EXPR || code == NE_EXPR)
6149                && TREE_CODE (arg0) == NEGATE_EXPR
6150                && TREE_CODE (arg1) == INTEGER_CST
6151                && 0 != (tem = negate_expr (arg1))
6152                && TREE_CODE (tem) == INTEGER_CST
6153                && ! TREE_CONSTANT_OVERFLOW (tem))
6154         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6155
6156       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6157          for !=.  Don't do this for ordered comparisons due to overflow.  */
6158       else if ((code == NE_EXPR || code == EQ_EXPR)
6159                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6160         return fold (build (code, type,
6161                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6162
6163       /* If we are widening one operand of an integer comparison,
6164          see if the other operand is similarly being widened.  Perhaps we
6165          can do the comparison in the narrower type.  */
6166       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6167                && TREE_CODE (arg0) == NOP_EXPR
6168                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6169                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6170                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6171                    || (TREE_CODE (t1) == INTEGER_CST
6172                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6173         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6174
6175       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6176          constant, we can simplify it.  */
6177       else if (TREE_CODE (arg1) == INTEGER_CST
6178                && (TREE_CODE (arg0) == MIN_EXPR
6179                    || TREE_CODE (arg0) == MAX_EXPR)
6180                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6181         return optimize_minmax_comparison (t);
6182
6183       /* If we are comparing an ABS_EXPR with a constant, we can
6184          convert all the cases into explicit comparisons, but they may
6185          well not be faster than doing the ABS and one comparison.
6186          But ABS (X) <= C is a range comparison, which becomes a subtraction
6187          and a comparison, and is probably faster.  */
6188       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6189                && TREE_CODE (arg0) == ABS_EXPR
6190                && ! TREE_SIDE_EFFECTS (arg0)
6191                && (0 != (tem = negate_expr (arg1)))
6192                && TREE_CODE (tem) == INTEGER_CST
6193                && ! TREE_CONSTANT_OVERFLOW (tem))
6194         return fold (build (TRUTH_ANDIF_EXPR, type,
6195                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6196                             build (LE_EXPR, type,
6197                                    TREE_OPERAND (arg0, 0), arg1)));
6198
6199       /* If this is an EQ or NE comparison with zero and ARG0 is
6200          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6201          two operations, but the latter can be done in one less insn
6202          on machines that have only two-operand insns or on which a
6203          constant cannot be the first operand.  */
6204       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6205           && TREE_CODE (arg0) == BIT_AND_EXPR)
6206         {
6207           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6208               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6209             return
6210               fold (build (code, type,
6211                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6212                                   build (RSHIFT_EXPR,
6213                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6214                                          TREE_OPERAND (arg0, 1),
6215                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6216                                   convert (TREE_TYPE (arg0),
6217                                            integer_one_node)),
6218                            arg1));
6219           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6220                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6221             return
6222               fold (build (code, type,
6223                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6224                                   build (RSHIFT_EXPR,
6225                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6226                                          TREE_OPERAND (arg0, 0),
6227                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6228                                   convert (TREE_TYPE (arg0),
6229                                            integer_one_node)),
6230                            arg1));
6231         }
6232
6233       /* If this is an NE or EQ comparison of zero against the result of a
6234          signed MOD operation whose second operand is a power of 2, make
6235          the MOD operation unsigned since it is simpler and equivalent.  */
6236       if ((code == NE_EXPR || code == EQ_EXPR)
6237           && integer_zerop (arg1)
6238           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6239           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6240               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6241               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6242               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6243           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6244         {
6245           tree newtype = unsigned_type (TREE_TYPE (arg0));
6246           tree newmod = build (TREE_CODE (arg0), newtype,
6247                                convert (newtype, TREE_OPERAND (arg0, 0)),
6248                                convert (newtype, TREE_OPERAND (arg0, 1)));
6249
6250           return build (code, type, newmod, convert (newtype, arg1));
6251         }
6252
6253       /* If this is an NE comparison of zero with an AND of one, remove the
6254          comparison since the AND will give the correct value.  */
6255       if (code == NE_EXPR && integer_zerop (arg1)
6256           && TREE_CODE (arg0) == BIT_AND_EXPR
6257           && integer_onep (TREE_OPERAND (arg0, 1)))
6258         return convert (type, arg0);
6259
6260       /* If we have (A & C) == C where C is a power of 2, convert this into
6261          (A & C) != 0.  Similarly for NE_EXPR.  */
6262       if ((code == EQ_EXPR || code == NE_EXPR)
6263           && TREE_CODE (arg0) == BIT_AND_EXPR
6264           && integer_pow2p (TREE_OPERAND (arg0, 1))
6265           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6266         return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6267                       arg0, integer_zero_node);
6268
6269       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6270          and similarly for >= into !=.  */
6271       if ((code == LT_EXPR || code == GE_EXPR)
6272           && TREE_UNSIGNED (TREE_TYPE (arg0))
6273           && TREE_CODE (arg1) == LSHIFT_EXPR
6274           && integer_onep (TREE_OPERAND (arg1, 0)))
6275         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6276                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6277                              TREE_OPERAND (arg1, 1)),
6278                       convert (TREE_TYPE (arg0), integer_zero_node));
6279
6280       else if ((code == LT_EXPR || code == GE_EXPR)
6281                && TREE_UNSIGNED (TREE_TYPE (arg0))
6282                && (TREE_CODE (arg1) == NOP_EXPR
6283                    || TREE_CODE (arg1) == CONVERT_EXPR)
6284                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6285                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6286         return
6287           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6288                  convert (TREE_TYPE (arg0),
6289                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6290                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6291                  convert (TREE_TYPE (arg0), integer_zero_node));
6292
6293       /* Simplify comparison of something with itself.  (For IEEE
6294          floating-point, we can only do some of these simplifications.)  */
6295       if (operand_equal_p (arg0, arg1, 0))
6296         {
6297           switch (code)
6298             {
6299             case EQ_EXPR:
6300             case GE_EXPR:
6301             case LE_EXPR:
6302               if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6303                 return constant_boolean_node (1, type);
6304               code = EQ_EXPR;
6305               TREE_SET_CODE (t, code);
6306               break;
6307
6308             case NE_EXPR:
6309               /* For NE, we can only do this simplification if integer.  */
6310               if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6311                 break;
6312               /* ... fall through ...  */
6313             case GT_EXPR:
6314             case LT_EXPR:
6315               return constant_boolean_node (0, type);
6316             default:
6317               abort ();
6318             }
6319         }
6320
6321       /* An unsigned comparison against 0 can be simplified.  */
6322       if (integer_zerop (arg1)
6323           && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6324               || POINTER_TYPE_P (TREE_TYPE (arg1)))
6325           && TREE_UNSIGNED (TREE_TYPE (arg1)))
6326         {
6327           switch (TREE_CODE (t))
6328             {
6329             case GT_EXPR:
6330               code = NE_EXPR;
6331               TREE_SET_CODE (t, NE_EXPR);
6332               break;
6333             case LE_EXPR:
6334               code = EQ_EXPR;
6335               TREE_SET_CODE (t, EQ_EXPR);
6336               break;
6337             case GE_EXPR:
6338               return omit_one_operand (type,
6339                                        convert (type, integer_one_node),
6340                                        arg0);
6341             case LT_EXPR:
6342               return omit_one_operand (type,
6343                                        convert (type, integer_zero_node),
6344                                        arg0);
6345             default:
6346               break;
6347             }
6348         }
6349
6350       /* Comparisons with the highest or lowest possible integer of
6351          the specified size will have known values and an unsigned
6352          <= 0x7fffffff can be simplified.  */
6353       {
6354         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6355
6356         if (TREE_CODE (arg1) == INTEGER_CST
6357             && ! TREE_CONSTANT_OVERFLOW (arg1)
6358             && width <= HOST_BITS_PER_WIDE_INT
6359             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6360                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6361           {
6362             if (TREE_INT_CST_HIGH (arg1) == 0
6363                 && (TREE_INT_CST_LOW (arg1)
6364                     == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
6365                 && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6366               switch (TREE_CODE (t))
6367                 {
6368                 case GT_EXPR:
6369                   return omit_one_operand (type,
6370                                            convert (type, integer_zero_node),
6371                                            arg0);
6372                 case GE_EXPR:
6373                   TREE_SET_CODE (t, EQ_EXPR);
6374                   break;
6375
6376                 case LE_EXPR:
6377                   return omit_one_operand (type,
6378                                            convert (type, integer_one_node),
6379                                            arg0);
6380                 case LT_EXPR:
6381                   TREE_SET_CODE (t, NE_EXPR);
6382                   break;
6383
6384                 default:
6385                   break;
6386                 }
6387
6388             else if (TREE_INT_CST_HIGH (arg1) == -1
6389                      && (- TREE_INT_CST_LOW (arg1)
6390                          == ((HOST_WIDE_INT) 1 << (width - 1)))
6391                      && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6392               switch (TREE_CODE (t))
6393                 {
6394                 case LT_EXPR:
6395                   return omit_one_operand (type,
6396                                            convert (type, integer_zero_node),
6397                                            arg0);
6398                 case LE_EXPR:
6399                   TREE_SET_CODE (t, EQ_EXPR);
6400                   break;
6401
6402                 case GE_EXPR:
6403                   return omit_one_operand (type,
6404                                            convert (type, integer_one_node),
6405                                            arg0);
6406                 case GT_EXPR:
6407                   TREE_SET_CODE (t, NE_EXPR);
6408                   break;
6409
6410                 default:
6411                   break;
6412                 }
6413
6414             else if (TREE_INT_CST_HIGH (arg1) == 0
6415                       && (TREE_INT_CST_LOW (arg1)
6416                           == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
6417                       && TREE_UNSIGNED (TREE_TYPE (arg1)))
6418
6419               switch (TREE_CODE (t))
6420                 {
6421                 case LE_EXPR:
6422                   return fold (build (GE_EXPR, type,
6423                                       convert (signed_type (TREE_TYPE (arg0)),
6424                                                arg0),
6425                                       convert (signed_type (TREE_TYPE (arg1)),
6426                                                integer_zero_node)));
6427                 case GT_EXPR:
6428                   return fold (build (LT_EXPR, type,
6429                                       convert (signed_type (TREE_TYPE (arg0)),
6430                                                arg0),
6431                                       convert (signed_type (TREE_TYPE (arg1)),
6432                                                integer_zero_node)));
6433
6434                 default:
6435                   break;
6436                 }
6437           }
6438       }
6439
6440       /* If we are comparing an expression that just has comparisons
6441          of two integer values, arithmetic expressions of those comparisons,
6442          and constants, we can simplify it.  There are only three cases
6443          to check: the two values can either be equal, the first can be
6444          greater, or the second can be greater.  Fold the expression for
6445          those three values.  Since each value must be 0 or 1, we have
6446          eight possibilities, each of which corresponds to the constant 0
6447          or 1 or one of the six possible comparisons.
6448
6449          This handles common cases like (a > b) == 0 but also handles
6450          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6451          occur in macroized code.  */
6452
6453       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6454         {
6455           tree cval1 = 0, cval2 = 0;
6456           int save_p = 0;
6457
6458           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6459               /* Don't handle degenerate cases here; they should already
6460                  have been handled anyway.  */
6461               && cval1 != 0 && cval2 != 0
6462               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6463               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6464               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6465               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6466               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6467               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6468                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6469             {
6470               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6471               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6472
6473               /* We can't just pass T to eval_subst in case cval1 or cval2
6474                  was the same as ARG1.  */
6475
6476               tree high_result
6477                 = fold (build (code, type,
6478                                eval_subst (arg0, cval1, maxval, cval2, minval),
6479                                arg1));
6480               tree equal_result
6481                 = fold (build (code, type,
6482                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6483                                arg1));
6484               tree low_result
6485                 = fold (build (code, type,
6486                                eval_subst (arg0, cval1, minval, cval2, maxval),
6487                                arg1));
6488
6489               /* All three of these results should be 0 or 1.  Confirm they
6490                  are.  Then use those values to select the proper code
6491                  to use.  */
6492
6493               if ((integer_zerop (high_result)
6494                    || integer_onep (high_result))
6495                   && (integer_zerop (equal_result)
6496                       || integer_onep (equal_result))
6497                   && (integer_zerop (low_result)
6498                       || integer_onep (low_result)))
6499                 {
6500                   /* Make a 3-bit mask with the high-order bit being the
6501                      value for `>', the next for '=', and the low for '<'.  */
6502                   switch ((integer_onep (high_result) * 4)
6503                           + (integer_onep (equal_result) * 2)
6504                           + integer_onep (low_result))
6505                     {
6506                     case 0:
6507                       /* Always false.  */
6508                       return omit_one_operand (type, integer_zero_node, arg0);
6509                     case 1:
6510                       code = LT_EXPR;
6511                       break;
6512                     case 2:
6513                       code = EQ_EXPR;
6514                       break;
6515                     case 3:
6516                       code = LE_EXPR;
6517                       break;
6518                     case 4:
6519                       code = GT_EXPR;
6520                       break;
6521                     case 5:
6522                       code = NE_EXPR;
6523                       break;
6524                     case 6:
6525                       code = GE_EXPR;
6526                       break;
6527                     case 7:
6528                       /* Always true.  */
6529                       return omit_one_operand (type, integer_one_node, arg0);
6530                     }
6531
6532                   t = build (code, type, cval1, cval2);
6533                   if (save_p)
6534                     return save_expr (t);
6535                   else
6536                     return fold (t);
6537                 }
6538             }
6539         }
6540
6541       /* If this is a comparison of a field, we may be able to simplify it.  */
6542       if ((TREE_CODE (arg0) == COMPONENT_REF
6543            || TREE_CODE (arg0) == BIT_FIELD_REF)
6544           && (code == EQ_EXPR || code == NE_EXPR)
6545           /* Handle the constant case even without -O
6546              to make sure the warnings are given.  */
6547           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6548         {
6549           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6550           return t1 ? t1 : t;
6551         }
6552
6553       /* If this is a comparison of complex values and either or both sides
6554          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6555          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6556          This may prevent needless evaluations.  */
6557       if ((code == EQ_EXPR || code == NE_EXPR)
6558           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6559           && (TREE_CODE (arg0) == COMPLEX_EXPR
6560               || TREE_CODE (arg1) == COMPLEX_EXPR
6561               || TREE_CODE (arg0) == COMPLEX_CST
6562               || TREE_CODE (arg1) == COMPLEX_CST))
6563         {
6564           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6565           tree real0, imag0, real1, imag1;
6566
6567           arg0 = save_expr (arg0);
6568           arg1 = save_expr (arg1);
6569           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6570           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6571           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6572           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6573
6574           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6575                                : TRUTH_ORIF_EXPR),
6576                               type,
6577                               fold (build (code, type, real0, real1)),
6578                               fold (build (code, type, imag0, imag1))));
6579         }
6580
6581       /* From here on, the only cases we handle are when the result is
6582          known to be a constant.
6583
6584          To compute GT, swap the arguments and do LT.
6585          To compute GE, do LT and invert the result.
6586          To compute LE, swap the arguments, do LT and invert the result.
6587          To compute NE, do EQ and invert the result.
6588
6589          Therefore, the code below must handle only EQ and LT.  */
6590
6591       if (code == LE_EXPR || code == GT_EXPR)
6592         {
6593           tem = arg0, arg0 = arg1, arg1 = tem;
6594           code = swap_tree_comparison (code);
6595         }
6596
6597       /* Note that it is safe to invert for real values here because we
6598          will check below in the one case that it matters.  */
6599
6600       t1 = NULL_TREE;
6601       invert = 0;
6602       if (code == NE_EXPR || code == GE_EXPR)
6603         {
6604           invert = 1;
6605           code = invert_tree_comparison (code);
6606         }
6607
6608       /* Compute a result for LT or EQ if args permit;
6609          otherwise return T.  */
6610       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6611         {
6612           if (code == EQ_EXPR)
6613             t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
6614                                == TREE_INT_CST_LOW (arg1))
6615                               && (TREE_INT_CST_HIGH (arg0)
6616                                   == TREE_INT_CST_HIGH (arg1)),
6617                               0);
6618           else
6619             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6620                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6621                                : INT_CST_LT (arg0, arg1)),
6622                               0);
6623         }
6624
6625 #if 0 /* This is no longer useful, but breaks some real code.  */
6626       /* Assume a nonexplicit constant cannot equal an explicit one,
6627          since such code would be undefined anyway.
6628          Exception: on sysvr4, using #pragma weak,
6629          a label can come out as 0.  */
6630       else if (TREE_CODE (arg1) == INTEGER_CST
6631                && !integer_zerop (arg1)
6632                && TREE_CONSTANT (arg0)
6633                && TREE_CODE (arg0) == ADDR_EXPR
6634                && code == EQ_EXPR)
6635         t1 = build_int_2 (0, 0);
6636 #endif
6637       /* Two real constants can be compared explicitly.  */
6638       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6639         {
6640           /* If either operand is a NaN, the result is false with two
6641              exceptions: First, an NE_EXPR is true on NaNs, but that case
6642              is already handled correctly since we will be inverting the
6643              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6644              or a GE_EXPR into a LT_EXPR, we must return true so that it
6645              will be inverted into false.  */
6646
6647           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6648               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6649             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6650
6651           else if (code == EQ_EXPR)
6652             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6653                                                  TREE_REAL_CST (arg1)),
6654                               0);
6655           else
6656             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6657                                                 TREE_REAL_CST (arg1)),
6658                               0);
6659         }
6660
6661       if (t1 == NULL_TREE)
6662         return t;
6663
6664       if (invert)
6665         TREE_INT_CST_LOW (t1) ^= 1;
6666
6667       TREE_TYPE (t1) = type;
6668       if (TREE_CODE (type) == BOOLEAN_TYPE)
6669         return truthvalue_conversion (t1);
6670       return t1;
6671
6672     case COND_EXPR:
6673       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6674          so all simple results must be passed through pedantic_non_lvalue.  */
6675       if (TREE_CODE (arg0) == INTEGER_CST)
6676         return pedantic_non_lvalue
6677           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6678       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6679         return pedantic_omit_one_operand (type, arg1, arg0);
6680
6681       /* If the second operand is zero, invert the comparison and swap
6682          the second and third operands.  Likewise if the second operand
6683          is constant and the third is not or if the third operand is
6684          equivalent to the first operand of the comparison.  */
6685
6686       if (integer_zerop (arg1)
6687           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6688           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6689               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6690                                                  TREE_OPERAND (t, 2),
6691                                                  TREE_OPERAND (arg0, 1))))
6692         {
6693           /* See if this can be inverted.  If it can't, possibly because
6694              it was a floating-point inequality comparison, don't do
6695              anything.  */
6696           tem = invert_truthvalue (arg0);
6697
6698           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6699             {
6700               t = build (code, type, tem,
6701                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6702               arg0 = tem;
6703               /* arg1 should be the first argument of the new T.  */
6704               arg1 = TREE_OPERAND (t, 1);
6705               STRIP_NOPS (arg1);
6706             }
6707         }
6708
6709       /* If we have A op B ? A : C, we may be able to convert this to a
6710          simpler expression, depending on the operation and the values
6711          of B and C.  IEEE floating point prevents this though,
6712          because A or B might be -0.0 or a NaN.  */
6713
6714       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6715           && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
6716               || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
6717               || flag_fast_math)
6718           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6719                                              arg1, TREE_OPERAND (arg0, 1)))
6720         {
6721           tree arg2 = TREE_OPERAND (t, 2);
6722           enum tree_code comp_code = TREE_CODE (arg0);
6723
6724           STRIP_NOPS (arg2);
6725
6726           /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
6727              depending on the comparison operation.  */
6728           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
6729                ? real_zerop (TREE_OPERAND (arg0, 1))
6730                : integer_zerop (TREE_OPERAND (arg0, 1)))
6731               && TREE_CODE (arg2) == NEGATE_EXPR
6732               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
6733             switch (comp_code)
6734               {
6735               case EQ_EXPR:
6736                 return pedantic_non_lvalue (negate_expr (arg1));
6737               case NE_EXPR:
6738                 return pedantic_non_lvalue (convert (type, arg1));
6739               case GE_EXPR:
6740               case GT_EXPR:
6741                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6742                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6743                 return pedantic_non_lvalue
6744                   (convert (type, fold (build1 (ABS_EXPR,
6745                                                 TREE_TYPE (arg1), arg1))));
6746               case LE_EXPR:
6747               case LT_EXPR:
6748                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6749                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6750                 return pedantic_non_lvalue
6751                   (negate_expr (convert (type,
6752                                          fold (build1 (ABS_EXPR,
6753                                                        TREE_TYPE (arg1),
6754                                                        arg1)))));
6755               default:
6756                 abort ();
6757               }
6758
6759           /* If this is A != 0 ? A : 0, this is simply A.  For ==, it is
6760              always zero.  */
6761
6762           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
6763             {
6764               if (comp_code == NE_EXPR)
6765                 return pedantic_non_lvalue (convert (type, arg1));
6766               else if (comp_code == EQ_EXPR)
6767                 return pedantic_non_lvalue (convert (type, integer_zero_node));
6768             }
6769
6770           /* If this is A op B ? A : B, this is either A, B, min (A, B),
6771              or max (A, B), depending on the operation.  */
6772
6773           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
6774                                               arg2, TREE_OPERAND (arg0, 0)))
6775             {
6776               tree comp_op0 = TREE_OPERAND (arg0, 0);
6777               tree comp_op1 = TREE_OPERAND (arg0, 1);
6778               tree comp_type = TREE_TYPE (comp_op0);
6779
6780               switch (comp_code)
6781                 {
6782                 case EQ_EXPR:
6783                   return pedantic_non_lvalue (convert (type, arg2));
6784                 case NE_EXPR:
6785                   return pedantic_non_lvalue (convert (type, arg1));
6786                 case LE_EXPR:
6787                 case LT_EXPR:
6788                   /* In C++ a ?: expression can be an lvalue, so put the
6789                      operand which will be used if they are equal first
6790                      so that we can convert this back to the
6791                      corresponding COND_EXPR.  */
6792                   return pedantic_non_lvalue
6793                     (convert (type, (fold (build (MIN_EXPR, comp_type,
6794                                                   (comp_code == LE_EXPR
6795                                                    ? comp_op0 : comp_op1),
6796                                                   (comp_code == LE_EXPR
6797                                                    ? comp_op1 : comp_op0))))));
6798                   break;
6799                 case GE_EXPR:
6800                 case GT_EXPR:
6801                   return pedantic_non_lvalue
6802                     (convert (type, fold (build (MAX_EXPR, comp_type,
6803                                                  (comp_code == GE_EXPR
6804                                                   ? comp_op0 : comp_op1),
6805                                                  (comp_code == GE_EXPR
6806                                                   ? comp_op1 : comp_op0)))));
6807                   break;
6808                 default:
6809                   abort ();
6810                 }
6811             }
6812
6813           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6814              we might still be able to simplify this.  For example,
6815              if C1 is one less or one more than C2, this might have started
6816              out as a MIN or MAX and been transformed by this function.
6817              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
6818
6819           if (INTEGRAL_TYPE_P (type)
6820               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6821               && TREE_CODE (arg2) == INTEGER_CST)
6822             switch (comp_code)
6823               {
6824               case EQ_EXPR:
6825                 /* We can replace A with C1 in this case.  */
6826                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
6827                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
6828                            TREE_OPERAND (t, 2));
6829                 break;
6830
6831               case LT_EXPR:
6832                 /* If C1 is C2 + 1, this is min(A, C2).  */
6833                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6834                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6835                                         const_binop (PLUS_EXPR, arg2,
6836                                                      integer_one_node, 0), 1))
6837                   return pedantic_non_lvalue
6838                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6839                 break;
6840
6841               case LE_EXPR:
6842                 /* If C1 is C2 - 1, this is min(A, C2).  */
6843                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6844                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6845                                         const_binop (MINUS_EXPR, arg2,
6846                                                      integer_one_node, 0), 1))
6847                   return pedantic_non_lvalue
6848                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6849                 break;
6850
6851               case GT_EXPR:
6852                 /* If C1 is C2 - 1, this is max(A, C2).  */
6853                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6854                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6855                                         const_binop (MINUS_EXPR, arg2,
6856                                                      integer_one_node, 0), 1))
6857                   return pedantic_non_lvalue
6858                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6859                 break;
6860
6861               case GE_EXPR:
6862                 /* If C1 is C2 + 1, this is max(A, C2).  */
6863                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6864                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6865                                         const_binop (PLUS_EXPR, arg2,
6866                                                      integer_one_node, 0), 1))
6867                   return pedantic_non_lvalue
6868                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6869                 break;
6870               case NE_EXPR:
6871                 break;
6872               default:
6873                 abort ();
6874               }
6875         }
6876
6877       /* If the second operand is simpler than the third, swap them
6878          since that produces better jump optimization results.  */
6879       if ((TREE_CONSTANT (arg1) || TREE_CODE_CLASS (TREE_CODE (arg1)) == 'd'
6880            || TREE_CODE (arg1) == SAVE_EXPR)
6881           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
6882                 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 2))) == 'd'
6883                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
6884         {
6885           /* See if this can be inverted.  If it can't, possibly because
6886              it was a floating-point inequality comparison, don't do
6887              anything.  */
6888           tem = invert_truthvalue (arg0);
6889
6890           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6891             {
6892               t = build (code, type, tem,
6893                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6894               arg0 = tem;
6895               /* arg1 should be the first argument of the new T.  */
6896               arg1 = TREE_OPERAND (t, 1);
6897               STRIP_NOPS (arg1);
6898             }
6899         }
6900
6901       /* Convert A ? 1 : 0 to simply A.  */
6902       if (integer_onep (TREE_OPERAND (t, 1))
6903           && integer_zerop (TREE_OPERAND (t, 2))
6904           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
6905              call to fold will try to move the conversion inside
6906              a COND, which will recurse.  In that case, the COND_EXPR
6907              is probably the best choice, so leave it alone.  */
6908           && type == TREE_TYPE (arg0))
6909         return pedantic_non_lvalue (arg0);
6910
6911       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
6912          operation is simply A & 2.  */
6913
6914       if (integer_zerop (TREE_OPERAND (t, 2))
6915           && TREE_CODE (arg0) == NE_EXPR
6916           && integer_zerop (TREE_OPERAND (arg0, 1))
6917           && integer_pow2p (arg1)
6918           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
6919           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
6920                               arg1, 1))
6921         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
6922
6923       return t;
6924
6925     case COMPOUND_EXPR:
6926       /* When pedantic, a compound expression can be neither an lvalue
6927          nor an integer constant expression.  */
6928       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
6929         return t;
6930       /* Don't let (0, 0) be null pointer constant.  */
6931       if (integer_zerop (arg1))
6932         return build1 (NOP_EXPR, TREE_TYPE (arg1), arg1);
6933       return arg1;
6934
6935     case COMPLEX_EXPR:
6936       if (wins)
6937         return build_complex (type, arg0, arg1);
6938       return t;
6939
6940     case REALPART_EXPR:
6941       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6942         return t;
6943       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6944         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
6945                                  TREE_OPERAND (arg0, 1));
6946       else if (TREE_CODE (arg0) == COMPLEX_CST)
6947         return TREE_REALPART (arg0);
6948       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6949         return fold (build (TREE_CODE (arg0), type,
6950                             fold (build1 (REALPART_EXPR, type,
6951                                           TREE_OPERAND (arg0, 0))),
6952                             fold (build1 (REALPART_EXPR,
6953                                           type, TREE_OPERAND (arg0, 1)))));
6954       return t;
6955
6956     case IMAGPART_EXPR:
6957       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6958         return convert (type, integer_zero_node);
6959       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6960         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
6961                                  TREE_OPERAND (arg0, 0));
6962       else if (TREE_CODE (arg0) == COMPLEX_CST)
6963         return TREE_IMAGPART (arg0);
6964       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6965         return fold (build (TREE_CODE (arg0), type,
6966                             fold (build1 (IMAGPART_EXPR, type,
6967                                           TREE_OPERAND (arg0, 0))),
6968                             fold (build1 (IMAGPART_EXPR, type,
6969                                           TREE_OPERAND (arg0, 1)))));
6970       return t;
6971
6972       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6973          appropriate.  */
6974     case CLEANUP_POINT_EXPR:
6975       if (! has_cleanups (arg0))
6976         return TREE_OPERAND (t, 0);
6977
6978       {
6979         enum tree_code code0 = TREE_CODE (arg0);
6980         int kind0 = TREE_CODE_CLASS (code0);
6981         tree arg00 = TREE_OPERAND (arg0, 0);
6982         tree arg01;
6983
6984         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
6985           return fold (build1 (code0, type,
6986                                fold (build1 (CLEANUP_POINT_EXPR,
6987                                              TREE_TYPE (arg00), arg00))));
6988
6989         if (kind0 == '<' || kind0 == '2'
6990             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
6991             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
6992             || code0 == TRUTH_XOR_EXPR)
6993           {
6994             arg01 = TREE_OPERAND (arg0, 1);
6995
6996             if (TREE_CONSTANT (arg00)
6997                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
6998                     && ! has_cleanups (arg00)))
6999               return fold (build (code0, type, arg00,
7000                                   fold (build1 (CLEANUP_POINT_EXPR,
7001                                                 TREE_TYPE (arg01), arg01))));
7002
7003             if (TREE_CONSTANT (arg01))
7004               return fold (build (code0, type,
7005                                   fold (build1 (CLEANUP_POINT_EXPR,
7006                                                 TREE_TYPE (arg00), arg00)),
7007                                   arg01));
7008           }
7009
7010         return t;
7011       }
7012
7013     default:
7014       return t;
7015     } /* switch (code) */
7016 }
7017
7018 /* Determine if first argument is a multiple of second argument.  Return 0 if
7019    it is not, or we cannot easily determined it to be.
7020
7021    An example of the sort of thing we care about (at this point; this routine
7022    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7023    fold cases do now) is discovering that
7024
7025      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7026
7027    is a multiple of
7028
7029      SAVE_EXPR (J * 8)
7030
7031    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7032
7033    This code also handles discovering that
7034
7035      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7036
7037    is a multiple of 8 so we don't have to worry about dealing with a
7038    possible remainder.
7039
7040    Note that we *look* inside a SAVE_EXPR only to determine how it was
7041    calculated; it is not safe for fold to do much of anything else with the
7042    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7043    at run time.  For example, the latter example above *cannot* be implemented
7044    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7045    evaluation time of the original SAVE_EXPR is not necessarily the same at
7046    the time the new expression is evaluated.  The only optimization of this
7047    sort that would be valid is changing
7048
7049      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7050
7051    divided by 8 to
7052
7053      SAVE_EXPR (I) * SAVE_EXPR (J)
7054
7055    (where the same SAVE_EXPR (J) is used in the original and the
7056    transformed version).  */
7057
7058 static int
7059 multiple_of_p (type, top, bottom)
7060      tree type;
7061      tree top;
7062      tree bottom;
7063 {
7064   if (operand_equal_p (top, bottom, 0))
7065     return 1;
7066
7067   if (TREE_CODE (type) != INTEGER_TYPE)
7068     return 0;
7069
7070   switch (TREE_CODE (top))
7071     {
7072     case MULT_EXPR:
7073       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7074               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7075
7076     case PLUS_EXPR:
7077     case MINUS_EXPR:
7078       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7079               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7080
7081     case NOP_EXPR:
7082       /* Can't handle conversions from non-integral or wider integral type.  */
7083       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7084           || (TYPE_PRECISION (type)
7085               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7086         return 0;
7087
7088       /* .. fall through ... */
7089
7090     case SAVE_EXPR:
7091       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7092
7093     case INTEGER_CST:
7094       if ((TREE_CODE (bottom) != INTEGER_CST)
7095           || (tree_int_cst_sgn (top) < 0)
7096           || (tree_int_cst_sgn (bottom) < 0))
7097         return 0;
7098       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7099                                          top, bottom, 0));
7100
7101     default:
7102       return 0;
7103     }
7104 }