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 tree const_binop         PROTO((enum tree_code, tree, tree, int));
  70 static tree fold_convert        PROTO((tree, tree));
  71 static enum tree_code invert_tree_comparison PROTO((enum tree_code));
  72 static enum tree_code swap_tree_comparison PROTO((enum tree_code));
  73 static int truth_value_p        PROTO((enum tree_code));
  74 static int operand_equal_for_comparison_p PROTO((tree, tree, tree));
  75 static int twoval_comparison_p  PROTO((tree, tree *, tree *, int *));
  76 static tree eval_subst          PROTO((tree, tree, tree, tree, tree));
  77 static tree omit_one_operand    PROTO((tree, tree, tree));
  78 static tree pedantic_omit_one_operand PROTO((tree, tree, tree));
  79 static tree distribute_bit_expr PROTO((enum tree_code, tree, tree, tree));
  80 static tree make_bit_field_ref  PROTO((tree, tree, int, int, int));
  81 static tree optimize_bit_field_compare PROTO((enum tree_code, tree,
  82                                               tree, tree));
  83 static tree decode_field_reference PROTO((tree, int *, int *,
  84                                           enum machine_mode *, int *,
  85                                           int *, tree *, tree *));
  86 static int all_ones_mask_p      PROTO((tree, int));
  87 static int simple_operand_p     PROTO((tree));
  88 static tree range_binop         PROTO((enum tree_code, tree, tree, int,
  89                                        tree, int));
  90 static tree make_range          PROTO((tree, int *, tree *, tree *));
  91 static tree build_range_check   PROTO((tree, tree, int, tree, tree));
  92 static int merge_ranges         PROTO((int *, tree *, tree *, int, tree, tree,
  93                                        int, tree, tree));
  94 static tree fold_range_test     PROTO((tree));
  95 static tree unextend            PROTO((tree, int, int, tree));
  96 static tree fold_truthop        PROTO((enum tree_code, tree, tree, tree));
  97 static tree optimize_minmax_comparison PROTO((tree));
  98 static tree extract_muldiv      PROTO((tree, tree, enum tree_code, tree));
  99 static tree strip_compound_expr PROTO((tree, tree));
 100 static int multiple_of_p        PROTO((tree, tree, tree));
 101 static tree constant_boolean_node PROTO((int, tree));
 102 static int count_cond           PROTO((tree, int));
 103 static void const_binop_1       PROTO((PTR));
 104 static void fold_convert_1      PROTO((PTR));
 105
 106 #ifndef BRANCH_COST
 107 #define BRANCH_COST 1
 108 #endif
 109
 110 /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
 111    Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
 112    Then this yields nonzero if overflow occurred during the addition.
 113    Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
 114    Use `^' to test whether signs differ, and `< 0' to isolate the sign.  */
 115 #define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 116 \f
 117 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
 118    We do that by representing the two-word integer in 4 words, with only
 119    HOST_BITS_PER_WIDE_INT/2 bits stored in each word, as a positive number.  */
 120
 121 #define LOWPART(x) \
 122   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT/2)) - 1))
 123 #define HIGHPART(x) \
 124   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT/2)
 125 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT/2)
 126
 127 /* Unpack a two-word integer into 4 words.
 128    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
 129    WORDS points to the array of HOST_WIDE_INTs.  */
 130
 131 static void
 132 encode (words, low, hi)
 133      HOST_WIDE_INT *words;
 134      HOST_WIDE_INT low, hi;
 135 {
 136   words[0] = LOWPART (low);
 137   words[1] = HIGHPART (low);
 138   words[2] = LOWPART (hi);
 139   words[3] = HIGHPART (hi);
 140 }
 141
 142 /* Pack an array of 4 words into a two-word integer.
 143    WORDS points to the array of words.
 144    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
 145
 146 static void
 147 decode (words, low, hi)
 148      HOST_WIDE_INT *words;
 149      HOST_WIDE_INT *low, *hi;
 150 {
 151   *low = words[0] | words[1] * BASE;
 152   *hi = words[2] | words[3] * BASE;
 153 }
 154 \f
 155 /* Make the integer constant T valid for its type
 156    by setting to 0 or 1 all the bits in the constant
 157    that don't belong in the type.
 158    Yield 1 if a signed overflow occurs, 0 otherwise.
 159    If OVERFLOW is nonzero, a signed overflow has already occurred
 160    in calculating T, so propagate it.
 161
 162    Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
 163    if it exists.  */
 164
 165 int
 166 force_fit_type (t, overflow)
 167      tree t;
 168      int overflow;
 169 {
 170   HOST_WIDE_INT low, high;
 171   register int prec;
 172
 173   if (TREE_CODE (t) == REAL_CST)
 174     {
 175 #ifdef CHECK_FLOAT_VALUE
 176       CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t)), TREE_REAL_CST (t),
 177                          overflow);
 178 #endif
 179       return overflow;
 180     }
 181
 182   else if (TREE_CODE (t) != INTEGER_CST)
 183     return overflow;
 184
 185   low = TREE_INT_CST_LOW (t);
 186   high = TREE_INT_CST_HIGH (t);
 187
 188   if (POINTER_TYPE_P (TREE_TYPE (t)))
 189     prec = POINTER_SIZE;
 190   else
 191     prec = TYPE_PRECISION (TREE_TYPE (t));
 192
 193   /* First clear all bits that are beyond the type's precision.  */
 194
 195   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 196     ;
 197   else if (prec > HOST_BITS_PER_WIDE_INT)
 198     {
 199       TREE_INT_CST_HIGH (t)
 200         &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 201     }
 202   else
 203     {
 204       TREE_INT_CST_HIGH (t) = 0;
 205       if (prec < HOST_BITS_PER_WIDE_INT)
 206         TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
 207     }
 208
 209   /* Unsigned types do not suffer sign extension or overflow.  */
 210   if (TREE_UNSIGNED (TREE_TYPE (t)))
 211     return overflow;
 212
 213   /* If the value's sign bit is set, extend the sign.  */
 214   if (prec != 2 * HOST_BITS_PER_WIDE_INT
 215       && (prec > HOST_BITS_PER_WIDE_INT
 216           ? (TREE_INT_CST_HIGH (t)
 217              & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
 218           : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
 219     {
 220       /* Value is negative:
 221          set to 1 all the bits that are outside this type's precision.  */
 222       if (prec > HOST_BITS_PER_WIDE_INT)
 223         {
 224           TREE_INT_CST_HIGH (t)
 225             |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 226         }
 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   /* Yield 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
 979 /* Convert C9X hexadecimal floating point string constant S.  Return
 980    real value type in mode MODE.  This function uses the host computer's
 981    fp arithmetic when there is no REAL_ARITHMETIC.  */
 982
 983 REAL_VALUE_TYPE
 984 real_hex_to_f (s, mode)
 985    char *s;
 986    enum machine_mode mode;
 987 {
 988    REAL_VALUE_TYPE ip;
 989    char *p = s;
 990    unsigned HOST_WIDE_INT low, high;
 991    int frexpon, expon, shcount, nrmcount, k;
 992    int sign, expsign, decpt, isfloat, isldouble, gotp, lost;
 993    char c;
 994
 995    isldouble = 0;
 996    isfloat = 0;
 997    frexpon = 0;
 998    expon = 0;
 999    expsign = 1;
1000    ip = 0.0;
1001
1002    while (*p == ' ' || *p == '\t')
1003      ++p;
1004
1005    /* Sign, if any, comes first.  */
1006    sign = 1;
1007    if (*p == '-')
1008      {
1009        sign = -1;
1010        ++p;
1011      }
1012
1013    /* The string is supposed to start with 0x or 0X .  */
1014    if (*p == '0')
1015      {
1016        ++p;
1017        if (*p == 'x' || *p == 'X')
1018          ++p;
1019        else
1020          abort ();
1021      }
1022    else
1023      abort ();
1024
1025    while (*p == '0')
1026      ++p;
1027
1028    high = 0;
1029    low = 0;
1030    lost = 0; /* Nonzero low order bits shifted out and discarded.  */
1031    frexpon = 0;  /* Bits after the decimal point.  */
1032    expon = 0;  /* Value of exponent.  */
1033    decpt = 0;  /* How many decimal points.  */
1034    gotp = 0;  /* How many P's.  */
1035    shcount = 0;
1036    while ((c = *p) != '\0')
1037      {
1038        if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
1039            || (c >= 'a' && c <= 'f'))
1040          {
1041            k = c & 0x7f;
1042            if (k >= 'a')
1043              k = k - 'a' + 10;
1044            else if (k >= 'A')
1045              k = k - 'A' + 10;
1046            else
1047              k = k - '0';
1048
1049            if ((high & 0xf0000000) == 0)
1050              {
1051                high = (high << 4) + ((low >> 28) & 15);
1052                low = (low << 4) + k;
1053                shcount += 4;
1054                if (decpt)
1055                  frexpon += 4;
1056              }
1057            else
1058              {
1059                /* Record nonzero lost bits.  */
1060                lost |= k;
1061                if (!decpt)
1062                  frexpon -= 4;
1063              }
1064            ++p;
1065          }
1066        else if ( c == '.')
1067          {
1068            ++decpt;
1069            ++p;
1070          }
1071        else if (c == 'p' || c == 'P')
1072          {
1073            ++gotp;
1074            ++p;
1075            /* Sign of exponent.  */
1076            if (*p == '-')
1077              {
1078                expsign = -1;
1079                ++p;
1080              }
1081            /* Value of exponent.
1082               The exponent field is a decimal integer.  */
1083            while (ISDIGIT(*p))
1084              {
1085                k = (*p++ & 0x7f) - '0';
1086                expon = 10 * expon + k;
1087              }
1088            expon *= expsign;
1089            /* F suffix is ambiguous in the significand part
1090               so it must appear after the decimal exponent field.  */
1091            if (*p == 'f' || *p == 'F')
1092              {
1093                isfloat = 1;
1094                ++p;
1095                break;
1096              }
1097          }
1098        else if (c == 'l' || c == 'L')
1099          {
1100            isldouble = 1;
1101            ++p;
1102            break;
1103          }
1104        else
1105          break;
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    /* There must be either one decimal point or one p.  */
1112    if (decpt == 0 && gotp == 0)
1113      abort ();
1114    shcount -= 4;
1115    if ((high == 0) && (low == 0))
1116      {
1117        return dconst0;
1118      }
1119
1120    /* Normalize.  */
1121    nrmcount = 0;
1122    if (high == 0)
1123      {
1124        high = low;
1125        low = 0;
1126        nrmcount += 32;
1127      }
1128    /* Leave a high guard bit for carry-out.  */
1129    if ((high & 0x80000000) != 0)
1130      {
1131        lost |= low & 1;
1132        low = (low >> 1) | (high << 31);
1133        high = high >> 1;
1134        nrmcount -= 1;
1135      }
1136    if ((high & 0xffff8000) == 0)
1137      {
1138        high = (high << 16) + ((low >> 16) & 0xffff);
1139        low = low << 16;
1140        nrmcount += 16;
1141      }
1142    while ((high & 0xc0000000) == 0)
1143      {
1144        high = (high << 1) + ((low >> 31) & 1);
1145        low = low << 1;
1146        nrmcount += 1;
1147      }
1148    if (isfloat || GET_MODE_SIZE(mode) == UNITS_PER_WORD)
1149      {
1150        /* Keep 24 bits precision, bits 0x7fffff80.
1151           Rounding bit is 0x40.  */
1152        lost = lost | low | (high & 0x3f);
1153        low = 0;
1154        if (high & 0x40)
1155          {
1156            if ((high & 0x80) || lost)
1157              high += 0x40;
1158          }
1159        high &= 0xffffff80;
1160      }
1161    else
1162      {
1163        /* We need real.c to do long double formats, so here default
1164           to double precision.  */
1165 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1166        /* IEEE double.
1167           Keep 53 bits precision, bits 0x7fffffff fffffc00.
1168           Rounding bit is low word 0x200.  */
1169        lost = lost | (low & 0x1ff);
1170        if (low & 0x200)
1171          {
1172            if ((low & 0x400) || lost)
1173              {
1174                low = (low + 0x200) & 0xfffffc00;
1175                if (low == 0)
1176                  high += 1;
1177              }
1178          }
1179        low &= 0xfffffc00;
1180 #else
1181        /* Assume it's a VAX with 56-bit significand,
1182           bits 0x7fffffff ffffff80.  */
1183        lost = lost | (low & 0x7f);
1184        if (low & 0x40)
1185          {
1186            if ((low & 0x80) || lost)
1187              {
1188                low = (low + 0x40) & 0xffffff80;
1189                if (low == 0)
1190                  high += 1;
1191              }
1192          }
1193        low &= 0xffffff80;
1194 #endif
1195      }
1196    ip = (double) high;
1197    ip =  REAL_VALUE_LDEXP (ip, 32) + (double) low;
1198    /* Apply shifts and exponent value as power of 2.  */
1199    ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
1200
1201    if (sign < 0)
1202      ip = -ip;
1203    return ip;
1204 }
1205
1206 #endif /* no REAL_ARITHMETIC */
1207 \f
1208 /* Given T, an expression, return the negation of T.  Allow for T to be
1209    null, in which case return null.  */
1210
1211 static tree
1212 negate_expr (t)
1213      tree t;
1214 {
1215   tree type;
1216   tree tem;
1217
1218   if (t == 0)
1219     return 0;
1220
1221   type = TREE_TYPE (t);
1222   STRIP_SIGN_NOPS (t);
1223
1224   switch (TREE_CODE (t))
1225     {
1226     case INTEGER_CST:
1227     case REAL_CST:
1228       if (! TREE_UNSIGNED (type)
1229           && 0 != (tem = fold (build1 (NEGATE_EXPR, type, t)))
1230           && ! TREE_OVERFLOW (tem))
1231         return tem;
1232       break;
1233
1234     case NEGATE_EXPR:
1235       return convert (type, TREE_OPERAND (t, 0));
1236
1237     case MINUS_EXPR:
1238       /* - (A - B) -> B - A  */
1239       if (! FLOAT_TYPE_P (type) || flag_fast_math)
1240         return convert (type,
1241                         fold (build (MINUS_EXPR, TREE_TYPE (t),
1242                                      TREE_OPERAND (t, 1),
1243                                      TREE_OPERAND (t, 0))));
1244       break;
1245
1246     default:
1247       break;
1248     }
1249
1250   return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (t), t));
1251 }
1252 \f
1253 /* Split a tree IN into a constant, literal and variable parts that could be
1254    combined with CODE to make IN.  "constant" means an expression with
1255    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1256    commutative arithmetic operation.  Store the constant part into *CONP,
1257    the literal in &LITP and return the variable part.  If a part isn't
1258    present, set it to null.  If the tree does not decompose in this way,
1259    return the entire tree as the variable part and the other parts as null.
1260
1261    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1262    case, we negate an operand that was subtracted.  If NEGATE_P is true, we
1263    are negating all of IN.
1264
1265    If IN is itself a literal or constant, return it as appropriate.
1266
1267    Note that we do not guarantee that any of the three values will be the
1268    same type as IN, but they will have the same signedness and mode.  */
1269
1270 static tree
1271 split_tree (in, code, conp, litp, negate_p)
1272      tree in;
1273      enum tree_code code;
1274      tree *conp, *litp;
1275      int negate_p;
1276 {
1277   tree var = 0;
1278
1279   *conp = 0;
1280   *litp = 0;
1281
1282   /* Strip any conversions that don't change the machine mode or signedness. */
1283   STRIP_SIGN_NOPS (in);
1284
1285   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
1286     *litp = in;
1287   else if (TREE_CONSTANT (in))
1288     *conp = in;
1289
1290   else if (TREE_CODE (in) == code
1291            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1292                /* We can associate addition and subtraction together (even
1293                   though the C standard doesn't say so) for integers because
1294                   the value is not affected.  For reals, the value might be
1295                   affected, so we can't.  */
1296                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1297                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1298     {
1299       tree op0 = TREE_OPERAND (in, 0);
1300       tree op1 = TREE_OPERAND (in, 1);
1301       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1302       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1303
1304       /* First see if either of the operands is a literal, then a constant.  */
1305       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
1306         *litp = op0, op0 = 0;
1307       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1308         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1309
1310       if (op0 != 0 && TREE_CONSTANT (op0))
1311         *conp = op0, op0 = 0;
1312       else if (op1 != 0 && TREE_CONSTANT (op1))
1313         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1314
1315       /* If we haven't dealt with either operand, this is not a case we can
1316          decompose.  Otherwise, VAR is either of the ones remaining, if any. */
1317       if (op0 != 0 && op1 != 0)
1318         var = in;
1319       else if (op0 != 0)
1320         var = op0;
1321       else
1322         var = op1, neg_var_p = neg1_p;
1323
1324       /* Now do any needed negations.  */
1325       if (neg_litp_p) *litp = negate_expr (*litp);
1326       if (neg_conp_p) *conp = negate_expr (*conp);
1327       if (neg_var_p) var = negate_expr (var);
1328     }
1329   else
1330     var = in;
1331
1332   if (negate_p)
1333     {
1334       var = negate_expr (var);
1335       *conp = negate_expr (*conp);
1336       *litp = negate_expr (*litp);
1337     }
1338
1339   return var;
1340 }
1341
1342 /* Re-associate trees split by the above function.  T1 and T2 are either
1343    expressions to associate or null.  Return the new expression, if any.  If
1344    we build an operation, do it in TYPE and with CODE, except if CODE is a
1345    MINUS_EXPR, in which case we use PLUS_EXPR since split_tree will already
1346    have taken care of the negations.  */
1347
1348 static tree
1349 associate_trees (t1, t2, code, type)
1350      tree t1, t2;
1351      enum tree_code code;
1352      tree type;
1353 {
1354   if (t1 == 0)
1355     return t2;
1356   else if (t2 == 0)
1357     return t1;
1358
1359   if (code == MINUS_EXPR)
1360     code = PLUS_EXPR;
1361
1362   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1363      try to fold this since we will have infinite recursion.  But do
1364      deal with any NEGATE_EXPRs.  */
1365   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1366       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1367     {
1368       if (TREE_CODE (t1) == NEGATE_EXPR)
1369         return build (MINUS_EXPR, type, convert (type, t2),
1370                       convert (type, TREE_OPERAND (t1, 0)));
1371       else if (TREE_CODE (t2) == NEGATE_EXPR)
1372         return build (MINUS_EXPR, type, convert (type, t1),
1373                       convert (type, TREE_OPERAND (t2, 0)));
1374       else
1375         return build (code, type, convert (type, t1), convert (type, t2));
1376     }
1377
1378   return fold (build (code, type, convert (type, t1), convert (type, t2)));
1379 }
1380 \f
1381 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1382    to produce a new constant.
1383
1384    If NOTRUNC is nonzero, do not truncate the result to fit the data type.
1385    If FORSIZE is nonzero, compute overflow for unsigned types.  */
1386
1387 static tree
1388 int_const_binop (code, arg1, arg2, notrunc, forsize)
1389      enum tree_code code;
1390      register tree arg1, arg2;
1391      int notrunc, forsize;
1392 {
1393   HOST_WIDE_INT int1l, int1h, int2l, int2h;
1394   HOST_WIDE_INT low, hi;
1395   HOST_WIDE_INT garbagel, garbageh;
1396   register tree t;
1397   int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1398   int overflow = 0;
1399   int no_overflow = 0;
1400
1401   int1l = TREE_INT_CST_LOW (arg1);
1402   int1h = TREE_INT_CST_HIGH (arg1);
1403   int2l = TREE_INT_CST_LOW (arg2);
1404   int2h = TREE_INT_CST_HIGH (arg2);
1405
1406   switch (code)
1407     {
1408     case BIT_IOR_EXPR:
1409       low = int1l | int2l, hi = int1h | int2h;
1410       break;
1411
1412     case BIT_XOR_EXPR:
1413       low = int1l ^ int2l, hi = int1h ^ int2h;
1414       break;
1415
1416     case BIT_AND_EXPR:
1417       low = int1l & int2l, hi = int1h & int2h;
1418       break;
1419
1420     case BIT_ANDTC_EXPR:
1421       low = int1l & ~int2l, hi = int1h & ~int2h;
1422       break;
1423
1424     case RSHIFT_EXPR:
1425       int2l = - int2l;
1426     case LSHIFT_EXPR:
1427       /* It's unclear from the C standard whether shifts can overflow.
1428          The following code ignores overflow; perhaps a C standard
1429          interpretation ruling is needed.  */
1430       lshift_double (int1l, int1h, int2l,
1431                      TYPE_PRECISION (TREE_TYPE (arg1)),
1432                      &low, &hi,
1433                      !uns);
1434       no_overflow = 1;
1435       break;
1436
1437     case RROTATE_EXPR:
1438       int2l = - int2l;
1439     case LROTATE_EXPR:
1440       lrotate_double (int1l, int1h, int2l,
1441                       TYPE_PRECISION (TREE_TYPE (arg1)),
1442                       &low, &hi);
1443       break;
1444
1445     case PLUS_EXPR:
1446       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1447       break;
1448
1449     case MINUS_EXPR:
1450       neg_double (int2l, int2h, &low, &hi);
1451       add_double (int1l, int1h, low, hi, &low, &hi);
1452       overflow = overflow_sum_sign (hi, int2h, int1h);
1453       break;
1454
1455     case MULT_EXPR:
1456       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1457       break;
1458
1459     case TRUNC_DIV_EXPR:
1460     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1461     case EXACT_DIV_EXPR:
1462       /* This is a shortcut for a common special case.  */
1463       if (int2h == 0 && int2l > 0
1464           && ! TREE_CONSTANT_OVERFLOW (arg1)
1465           && ! TREE_CONSTANT_OVERFLOW (arg2)
1466           && int1h == 0 && int1l >= 0)
1467         {
1468           if (code == CEIL_DIV_EXPR)
1469             int1l += int2l - 1;
1470           low = int1l / int2l, hi = 0;
1471           break;
1472         }
1473
1474       /* ... fall through ... */
1475
1476     case ROUND_DIV_EXPR:
1477       if (int2h == 0 && int2l == 1)
1478         {
1479           low = int1l, hi = int1h;
1480           break;
1481         }
1482       if (int1l == int2l && int1h == int2h
1483           && ! (int1l == 0 && int1h == 0))
1484         {
1485           low = 1, hi = 0;
1486           break;
1487         }
1488       overflow = div_and_round_double (code, uns,
1489                                        int1l, int1h, int2l, int2h,
1490                                        &low, &hi, &garbagel, &garbageh);
1491       break;
1492
1493     case TRUNC_MOD_EXPR:
1494     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1495       /* This is a shortcut for a common special case.  */
1496       if (int2h == 0 && int2l > 0
1497           && ! TREE_CONSTANT_OVERFLOW (arg1)
1498           && ! TREE_CONSTANT_OVERFLOW (arg2)
1499           && int1h == 0 && int1l >= 0)
1500         {
1501           if (code == CEIL_MOD_EXPR)
1502             int1l += int2l - 1;
1503           low = int1l % int2l, hi = 0;
1504           break;
1505         }
1506
1507       /* ... fall through ... */
1508
1509     case ROUND_MOD_EXPR:
1510       overflow = div_and_round_double (code, uns,
1511                                        int1l, int1h, int2l, int2h,
1512                                        &garbagel, &garbageh, &low, &hi);
1513       break;
1514
1515     case MIN_EXPR:
1516     case MAX_EXPR:
1517       if (uns)
1518         {
1519           low = (((unsigned HOST_WIDE_INT) int1h
1520                   < (unsigned HOST_WIDE_INT) int2h)
1521                  || (((unsigned HOST_WIDE_INT) int1h
1522                       == (unsigned HOST_WIDE_INT) int2h)
1523                      && ((unsigned HOST_WIDE_INT) int1l
1524                          < (unsigned HOST_WIDE_INT) int2l)));
1525         }
1526       else
1527         {
1528           low = ((int1h < int2h)
1529                  || ((int1h == int2h)
1530                      && ((unsigned HOST_WIDE_INT) int1l
1531                          < (unsigned HOST_WIDE_INT) int2l)));
1532         }
1533       if (low == (code == MIN_EXPR))
1534         low = int1l, hi = int1h;
1535       else
1536         low = int2l, hi = int2h;
1537       break;
1538
1539     default:
1540       abort ();
1541     }
1542
1543   if (TREE_TYPE (arg1) == sizetype && hi == 0
1544       && low >= 0
1545       && (TYPE_MAX_VALUE (sizetype) == NULL
1546           || low <= TREE_INT_CST_LOW (TYPE_MAX_VALUE (sizetype)))
1547       && ! overflow
1548       && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
1549     t = size_int (low);
1550   else
1551     {
1552       t = build_int_2 (low, hi);
1553       TREE_TYPE (t) = TREE_TYPE (arg1);
1554     }
1555
1556   TREE_OVERFLOW (t)
1557     = ((notrunc ? (!uns || forsize) && overflow
1558         : force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
1559        | TREE_OVERFLOW (arg1)
1560        | TREE_OVERFLOW (arg2));
1561   /* If we're doing a size calculation, unsigned arithmetic does overflow.
1562      So check if force_fit_type truncated the value.  */
1563   if (forsize
1564       && ! TREE_OVERFLOW (t)
1565       && (TREE_INT_CST_HIGH (t) != hi
1566           || TREE_INT_CST_LOW (t) != low))
1567     TREE_OVERFLOW (t) = 1;
1568   TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1569                                 | TREE_CONSTANT_OVERFLOW (arg1)
1570                                 | TREE_CONSTANT_OVERFLOW (arg2));
1571   return t;
1572 }
1573
1574 struct cb_args
1575 {
1576   /* Input */
1577   tree arg1;
1578   REAL_VALUE_TYPE d1, d2;
1579   enum tree_code code;
1580   /* Output */
1581   tree t;
1582 };
1583
1584 static void
1585 const_binop_1 (data)
1586   PTR data;
1587 {
1588   struct cb_args * args = (struct cb_args *) data;
1589   REAL_VALUE_TYPE value;
1590
1591 #ifdef REAL_ARITHMETIC
1592   REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
1593 #else
1594   switch (args->code)
1595     {
1596     case PLUS_EXPR:
1597       value = args->d1 + args->d2;
1598       break;
1599
1600     case MINUS_EXPR:
1601       value = args->d1 - args->d2;
1602       break;
1603
1604     case MULT_EXPR:
1605       value = args->d1 * args->d2;
1606       break;
1607
1608     case RDIV_EXPR:
1609 #ifndef REAL_INFINITY
1610       if (args->d2 == 0)
1611         abort ();
1612 #endif
1613
1614       value = args->d1 / args->d2;
1615       break;
1616
1617     case MIN_EXPR:
1618       value = MIN (args->d1, args->d2);
1619       break;
1620
1621     case MAX_EXPR:
1622       value = MAX (args->d1, args->d2);
1623       break;
1624
1625     default:
1626       abort ();
1627     }
1628 #endif /* no REAL_ARITHMETIC */
1629   args->t =
1630     build_real (TREE_TYPE (args->arg1),
1631                 real_value_truncate (TYPE_MODE (TREE_TYPE (args->arg1)),
1632                                      value));
1633 }
1634
1635 /* Combine two constants ARG1 and ARG2 under operation CODE
1636    to produce a new constant.
1637    We assume ARG1 and ARG2 have the same data type,
1638    or at least are the same kind of constant and the same machine mode.
1639
1640    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1641
1642 static tree
1643 const_binop (code, arg1, arg2, notrunc)
1644      enum tree_code code;
1645      register tree arg1, arg2;
1646      int notrunc;
1647 {
1648   STRIP_NOPS (arg1); STRIP_NOPS (arg2);
1649
1650   if (TREE_CODE (arg1) == INTEGER_CST)
1651     return int_const_binop (code, arg1, arg2, notrunc, 0);
1652
1653 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1654   if (TREE_CODE (arg1) == REAL_CST)
1655     {
1656       REAL_VALUE_TYPE d1;
1657       REAL_VALUE_TYPE d2;
1658       int overflow = 0;
1659       tree t;
1660       struct cb_args args;
1661
1662       d1 = TREE_REAL_CST (arg1);
1663       d2 = TREE_REAL_CST (arg2);
1664
1665       /* If either operand is a NaN, just return it.  Otherwise, set up
1666          for floating-point trap; we return an overflow.  */
1667       if (REAL_VALUE_ISNAN (d1))
1668         return arg1;
1669       else if (REAL_VALUE_ISNAN (d2))
1670         return arg2;
1671
1672       /* Setup input for const_binop_1() */
1673       args.arg1 = arg1;
1674       args.d1 = d1;
1675       args.d2 = d2;
1676       args.code = code;
1677
1678       if (do_float_handler (const_binop_1, (PTR) &args))
1679         {
1680           /* Receive output from const_binop_1() */
1681           t = args.t;
1682         }
1683       else
1684         {
1685           /* We got an exception from const_binop_1() */
1686           t = copy_node (arg1);
1687           overflow = 1;
1688         }
1689
1690       TREE_OVERFLOW (t)
1691         = (force_fit_type (t, overflow)
1692            | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1693       TREE_CONSTANT_OVERFLOW (t)
1694         = TREE_OVERFLOW (t)
1695           | TREE_CONSTANT_OVERFLOW (arg1)
1696           | TREE_CONSTANT_OVERFLOW (arg2);
1697       return t;
1698     }
1699 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1700   if (TREE_CODE (arg1) == COMPLEX_CST)
1701     {
1702       register tree type = TREE_TYPE (arg1);
1703       register tree r1 = TREE_REALPART (arg1);
1704       register tree i1 = TREE_IMAGPART (arg1);
1705       register tree r2 = TREE_REALPART (arg2);
1706       register tree i2 = TREE_IMAGPART (arg2);
1707       register tree t;
1708
1709       switch (code)
1710         {
1711         case PLUS_EXPR:
1712           t = build_complex (type,
1713                              const_binop (PLUS_EXPR, r1, r2, notrunc),
1714                              const_binop (PLUS_EXPR, i1, i2, notrunc));
1715           break;
1716
1717         case MINUS_EXPR:
1718           t = build_complex (type,
1719                              const_binop (MINUS_EXPR, r1, r2, notrunc),
1720                              const_binop (MINUS_EXPR, i1, i2, notrunc));
1721           break;
1722
1723         case MULT_EXPR:
1724           t = build_complex (type,
1725                              const_binop (MINUS_EXPR,
1726                                           const_binop (MULT_EXPR,
1727                                                        r1, r2, notrunc),
1728                                           const_binop (MULT_EXPR,
1729                                                        i1, i2, notrunc),
1730                                           notrunc),
1731                              const_binop (PLUS_EXPR,
1732                                           const_binop (MULT_EXPR,
1733                                                        r1, i2, notrunc),
1734                                           const_binop (MULT_EXPR,
1735                                                        i1, r2, notrunc),
1736                                           notrunc));
1737           break;
1738
1739         case RDIV_EXPR:
1740           {
1741             register tree magsquared
1742               = const_binop (PLUS_EXPR,
1743                              const_binop (MULT_EXPR, r2, r2, notrunc),
1744                              const_binop (MULT_EXPR, i2, i2, notrunc),
1745                              notrunc);
1746
1747             t = build_complex (type,
1748                                const_binop
1749                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1750                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1751                                 const_binop (PLUS_EXPR,
1752                                              const_binop (MULT_EXPR, r1, r2,
1753                                                           notrunc),
1754                                              const_binop (MULT_EXPR, i1, i2,
1755                                                           notrunc),
1756                                              notrunc),
1757                                 magsquared, notrunc),
1758                                const_binop
1759                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1760                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1761                                 const_binop (MINUS_EXPR,
1762                                              const_binop (MULT_EXPR, i1, r2,
1763                                                           notrunc),
1764                                              const_binop (MULT_EXPR, r1, i2,
1765                                                           notrunc),
1766                                              notrunc),
1767                                 magsquared, notrunc));
1768           }
1769           break;
1770
1771         default:
1772           abort ();
1773         }
1774       return t;
1775     }
1776   return 0;
1777 }
1778 \f
1779 /* Return an INTEGER_CST with value V .  The type is determined by bit_p:
1780    if it is zero, the type is taken from sizetype; if it is one, the type
1781    is taken from bitsizetype.  */
1782
1783 tree
1784 size_int_wide (number, high, bit_p)
1785      unsigned HOST_WIDE_INT number, high;
1786      int bit_p;
1787 {
1788   tree t;
1789
1790   if (!ggc_p)
1791     {
1792       /* Type-size nodes already made for small sizes.  */
1793       static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1][2];
1794
1795       if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high
1796           && size_table[number][bit_p] != 0)
1797         return size_table[number][bit_p];
1798       if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high)
1799         {
1800           push_obstacks_nochange ();
1801           /* Make this a permanent node.  */
1802           end_temporary_allocation ();
1803           t = build_int_2 (number, 0);
1804           TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1805           size_table[number][bit_p] = t;
1806           pop_obstacks ();
1807           return t;
1808         }
1809     }
1810
1811   t = build_int_2 (number, high);
1812   TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1813   TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
1814   return t;
1815 }
1816
1817 /* Combine operands OP1 and OP2 with arithmetic operation CODE.
1818    CODE is a tree code.  Data type is taken from `sizetype',
1819    If the operands are constant, so is the result.  */
1820
1821 tree
1822 size_binop (code, arg0, arg1)
1823      enum tree_code code;
1824      tree arg0, arg1;
1825 {
1826   /* Handle the special case of two integer constants faster.  */
1827   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1828     {
1829       /* And some specific cases even faster than that.  */
1830       if (code == PLUS_EXPR && integer_zerop (arg0))
1831         return arg1;
1832       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1833                && integer_zerop (arg1))
1834         return arg0;
1835       else if (code == MULT_EXPR && integer_onep (arg0))
1836         return arg1;
1837
1838       /* Handle general case of two integer constants.  */
1839       return int_const_binop (code, arg0, arg1, 0, 1);
1840     }
1841
1842   if (arg0 == error_mark_node || arg1 == error_mark_node)
1843     return error_mark_node;
1844
1845   return fold (build (code, sizetype, arg0, arg1));
1846 }
1847
1848 /* Combine operands OP1 and OP2 with arithmetic operation CODE.
1849    CODE is a tree code.  Data type is taken from `ssizetype',
1850    If the operands are constant, so is the result.  */
1851
1852 tree
1853 ssize_binop (code, arg0, arg1)
1854      enum tree_code code;
1855      tree arg0, arg1;
1856 {
1857   /* Handle the special case of two integer constants faster.  */
1858   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1859     {
1860       /* And some specific cases even faster than that.  */
1861       if (code == PLUS_EXPR && integer_zerop (arg0))
1862         return arg1;
1863       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1864                && integer_zerop (arg1))
1865         return arg0;
1866       else if (code == MULT_EXPR && integer_onep (arg0))
1867         return arg1;
1868
1869       /* Handle general case of two integer constants.  We convert
1870          arg0 to ssizetype because int_const_binop uses its type for the
1871          return value.  */
1872       arg0 = convert (ssizetype, arg0);
1873       return int_const_binop (code, arg0, arg1, 0, 0);
1874     }
1875
1876   if (arg0 == error_mark_node || arg1 == error_mark_node)
1877     return error_mark_node;
1878
1879   return fold (build (code, ssizetype, arg0, arg1));
1880 }
1881 \f
1882 struct fc_args
1883 {
1884   /* Input */
1885   tree arg1, type;
1886   /* Output */
1887   tree t;
1888 };
1889
1890 static void
1891 fold_convert_1 (data)
1892   PTR data;
1893 {
1894   struct fc_args * args = (struct fc_args *) data;
1895
1896   args->t = build_real (args->type,
1897                         real_value_truncate (TYPE_MODE (args->type),
1898                                              TREE_REAL_CST (args->arg1)));
1899 }
1900
1901 /* Given T, a tree representing type conversion of ARG1, a constant,
1902    return a constant tree representing the result of conversion.  */
1903
1904 static tree
1905 fold_convert (t, arg1)
1906      register tree t;
1907      register tree arg1;
1908 {
1909   register tree type = TREE_TYPE (t);
1910   int overflow = 0;
1911
1912   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1913     {
1914       if (TREE_CODE (arg1) == INTEGER_CST)
1915         {
1916           /* If we would build a constant wider than GCC supports,
1917              leave the conversion unfolded.  */
1918           if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1919             return t;
1920
1921           /* Given an integer constant, make new constant with new type,
1922              appropriately sign-extended or truncated.  */
1923           t = build_int_2 (TREE_INT_CST_LOW (arg1),
1924                            TREE_INT_CST_HIGH (arg1));
1925           TREE_TYPE (t) = type;
1926           /* Indicate an overflow if (1) ARG1 already overflowed,
1927              or (2) force_fit_type indicates an overflow.
1928              Tell force_fit_type that an overflow has already occurred
1929              if ARG1 is a too-large unsigned value and T is signed.
1930              But don't indicate an overflow if converting a pointer.  */
1931           TREE_OVERFLOW (t)
1932             = ((force_fit_type (t,
1933                                 (TREE_INT_CST_HIGH (arg1) < 0
1934                                  && (TREE_UNSIGNED (type)
1935                                     < TREE_UNSIGNED (TREE_TYPE (arg1)))))
1936                 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
1937                || TREE_OVERFLOW (arg1));
1938           TREE_CONSTANT_OVERFLOW (t)
1939             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1940         }
1941 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1942       else if (TREE_CODE (arg1) == REAL_CST)
1943         {
1944           /* Don't initialize these, use assignments.
1945              Initialized local aggregates don't work on old compilers.  */
1946           REAL_VALUE_TYPE x;
1947           REAL_VALUE_TYPE l;
1948           REAL_VALUE_TYPE u;
1949           tree type1 = TREE_TYPE (arg1);
1950           int no_upper_bound;
1951
1952           x = TREE_REAL_CST (arg1);
1953           l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
1954
1955           no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
1956           if (!no_upper_bound)
1957             u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
1958
1959           /* See if X will be in range after truncation towards 0.
1960              To compensate for truncation, move the bounds away from 0,
1961              but reject if X exactly equals the adjusted bounds.  */
1962 #ifdef REAL_ARITHMETIC
1963           REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
1964           if (!no_upper_bound)
1965             REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
1966 #else
1967           l--;
1968           if (!no_upper_bound)
1969             u++;
1970 #endif
1971           /* If X is a NaN, use zero instead and show we have an overflow.
1972              Otherwise, range check.  */
1973           if (REAL_VALUE_ISNAN (x))
1974             overflow = 1, x = dconst0;
1975           else if (! (REAL_VALUES_LESS (l, x)
1976                       && !no_upper_bound
1977                       && REAL_VALUES_LESS (x, u)))
1978             overflow = 1;
1979
1980 #ifndef REAL_ARITHMETIC
1981           {
1982             HOST_WIDE_INT low, high;
1983             HOST_WIDE_INT half_word
1984               = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
1985
1986             if (x < 0)
1987               x = -x;
1988
1989             high = (HOST_WIDE_INT) (x / half_word / half_word);
1990             x -= (REAL_VALUE_TYPE) high * half_word * half_word;
1991             if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
1992               {
1993                 low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
1994                 low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
1995               }
1996             else
1997               low = (HOST_WIDE_INT) x;
1998             if (TREE_REAL_CST (arg1) < 0)
1999               neg_double (low, high, &low, &high);
2000             t = build_int_2 (low, high);
2001           }
2002 #else
2003           {
2004             HOST_WIDE_INT low, high;
2005             REAL_VALUE_TO_INT (&low, &high, x);
2006             t = build_int_2 (low, high);
2007           }
2008 #endif
2009           TREE_TYPE (t) = type;
2010           TREE_OVERFLOW (t)
2011             = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
2012           TREE_CONSTANT_OVERFLOW (t)
2013             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2014         }
2015 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2016       TREE_TYPE (t) = type;
2017     }
2018   else if (TREE_CODE (type) == REAL_TYPE)
2019     {
2020 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2021       if (TREE_CODE (arg1) == INTEGER_CST)
2022         return build_real_from_int_cst (type, arg1);
2023 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2024       if (TREE_CODE (arg1) == REAL_CST)
2025         {
2026           struct fc_args args;
2027
2028           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
2029             {
2030               t = arg1;
2031               TREE_TYPE (arg1) = type;
2032               return t;
2033             }
2034
2035           /* Setup input for fold_convert_1() */
2036           args.arg1 = arg1;
2037           args.type = type;
2038
2039           if (do_float_handler (fold_convert_1, (PTR) &args))
2040             {
2041               /* Receive output from fold_convert_1() */
2042               t = args.t;
2043             }
2044           else
2045             {
2046               /* We got an exception from fold_convert_1() */
2047               overflow = 1;
2048               t = copy_node (arg1);
2049             }
2050
2051           TREE_OVERFLOW (t)
2052             = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
2053           TREE_CONSTANT_OVERFLOW (t)
2054             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2055           return t;
2056         }
2057     }
2058   TREE_CONSTANT (t) = 1;
2059   return t;
2060 }
2061 \f
2062 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2063
2064 tree
2065 non_lvalue (x)
2066      tree x;
2067 {
2068   tree result;
2069
2070   /* These things are certainly not lvalues.  */
2071   if (TREE_CODE (x) == NON_LVALUE_EXPR
2072       || TREE_CODE (x) == INTEGER_CST
2073       || TREE_CODE (x) == REAL_CST
2074       || TREE_CODE (x) == STRING_CST
2075       || TREE_CODE (x) == ADDR_EXPR)
2076     return x;
2077
2078   result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2079   TREE_CONSTANT (result) = TREE_CONSTANT (x);
2080   return result;
2081 }
2082
2083 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2084    Zero means allow extended lvalues.  */
2085
2086 int pedantic_lvalues;
2087
2088 /* When pedantic, return an expr equal to X but certainly not valid as a
2089    pedantic lvalue.  Otherwise, return X.  */
2090
2091 tree
2092 pedantic_non_lvalue (x)
2093      tree x;
2094 {
2095   if (pedantic_lvalues)
2096     return non_lvalue (x);
2097   else
2098     return x;
2099 }
2100 \f
2101 /* Given a tree comparison code, return the code that is the logical inverse
2102    of the given code.  It is not safe to do this for floating-point
2103    comparisons, except for NE_EXPR and EQ_EXPR.  */
2104
2105 static enum tree_code
2106 invert_tree_comparison (code)
2107      enum tree_code code;
2108 {
2109   switch (code)
2110     {
2111     case EQ_EXPR:
2112       return NE_EXPR;
2113     case NE_EXPR:
2114       return EQ_EXPR;
2115     case GT_EXPR:
2116       return LE_EXPR;
2117     case GE_EXPR:
2118       return LT_EXPR;
2119     case LT_EXPR:
2120       return GE_EXPR;
2121     case LE_EXPR:
2122       return GT_EXPR;
2123     default:
2124       abort ();
2125     }
2126 }
2127
2128 /* Similar, but return the comparison that results if the operands are
2129    swapped.  This is safe for floating-point.  */
2130
2131 static enum tree_code
2132 swap_tree_comparison (code)
2133      enum tree_code code;
2134 {
2135   switch (code)
2136     {
2137     case EQ_EXPR:
2138     case NE_EXPR:
2139       return code;
2140     case GT_EXPR:
2141       return LT_EXPR;
2142     case GE_EXPR:
2143       return LE_EXPR;
2144     case LT_EXPR:
2145       return GT_EXPR;
2146     case LE_EXPR:
2147       return GE_EXPR;
2148     default:
2149       abort ();
2150     }
2151 }
2152
2153 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2154
2155 static int
2156 truth_value_p (code)
2157      enum tree_code code;
2158 {
2159   return (TREE_CODE_CLASS (code) == '<'
2160           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2161           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2162           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2163 }
2164 \f
2165 /* Return nonzero if two operands are necessarily equal.
2166    If ONLY_CONST is non-zero, only return non-zero for constants.
2167    This function tests whether the operands are indistinguishable;
2168    it does not test whether they are equal using C's == operation.
2169    The distinction is important for IEEE floating point, because
2170    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2171    (2) two NaNs may be indistinguishable, but NaN!=NaN.  */
2172
2173 int
2174 operand_equal_p (arg0, arg1, only_const)
2175      tree arg0, arg1;
2176      int only_const;
2177 {
2178   /* If both types don't have the same signedness, then we can't consider
2179      them equal.  We must check this before the STRIP_NOPS calls
2180      because they may change the signedness of the arguments.  */
2181   if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
2182     return 0;
2183
2184   STRIP_NOPS (arg0);
2185   STRIP_NOPS (arg1);
2186
2187   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2188       /* This is needed for conversions and for COMPONENT_REF.
2189          Might as well play it safe and always test this.  */
2190       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2191       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2192       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2193     return 0;
2194
2195   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2196      We don't care about side effects in that case because the SAVE_EXPR
2197      takes care of that for us. In all other cases, two expressions are
2198      equal if they have no side effects.  If we have two identical
2199      expressions with side effects that should be treated the same due
2200      to the only side effects being identical SAVE_EXPR's, that will
2201      be detected in the recursive calls below.  */
2202   if (arg0 == arg1 && ! only_const
2203       && (TREE_CODE (arg0) == SAVE_EXPR
2204           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2205     return 1;
2206
2207   /* Next handle constant cases, those for which we can return 1 even
2208      if ONLY_CONST is set.  */
2209   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2210     switch (TREE_CODE (arg0))
2211       {
2212       case INTEGER_CST:
2213         return (! TREE_CONSTANT_OVERFLOW (arg0)
2214                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2215                 && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
2216                 && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
2217
2218       case REAL_CST:
2219         return (! TREE_CONSTANT_OVERFLOW (arg0)
2220                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2221                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2222                                           TREE_REAL_CST (arg1)));
2223
2224       case COMPLEX_CST:
2225         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2226                                  only_const)
2227                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2228                                     only_const));
2229
2230       case STRING_CST:
2231         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2232                 && ! strncmp (TREE_STRING_POINTER (arg0),
2233                               TREE_STRING_POINTER (arg1),
2234                               TREE_STRING_LENGTH (arg0)));
2235
2236       case ADDR_EXPR:
2237         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2238                                 0);
2239       default:
2240         break;
2241       }
2242
2243   if (only_const)
2244     return 0;
2245
2246   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2247     {
2248     case '1':
2249       /* Two conversions are equal only if signedness and modes match.  */
2250       if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
2251           && (TREE_UNSIGNED (TREE_TYPE (arg0))
2252               != TREE_UNSIGNED (TREE_TYPE (arg1))))
2253         return 0;
2254
2255       return operand_equal_p (TREE_OPERAND (arg0, 0),
2256                               TREE_OPERAND (arg1, 0), 0);
2257
2258     case '<':
2259     case '2':
2260       if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
2261           && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
2262                               0))
2263         return 1;
2264
2265       /* For commutative ops, allow the other order.  */
2266       return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
2267                || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
2268                || TREE_CODE (arg0) == BIT_IOR_EXPR
2269                || TREE_CODE (arg0) == BIT_XOR_EXPR
2270                || TREE_CODE (arg0) == BIT_AND_EXPR
2271                || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
2272               && operand_equal_p (TREE_OPERAND (arg0, 0),
2273                                   TREE_OPERAND (arg1, 1), 0)
2274               && operand_equal_p (TREE_OPERAND (arg0, 1),
2275                                   TREE_OPERAND (arg1, 0), 0));
2276
2277     case 'r':
2278       /* If either of the pointer (or reference) expressions we are dereferencing
2279          contain a side effect, these cannot be equal. */
2280       if (TREE_SIDE_EFFECTS (arg0)
2281           || TREE_SIDE_EFFECTS (arg1))
2282         return 0;
2283
2284       switch (TREE_CODE (arg0))
2285         {
2286         case INDIRECT_REF:
2287           return operand_equal_p (TREE_OPERAND (arg0, 0),
2288                                   TREE_OPERAND (arg1, 0), 0);
2289
2290         case COMPONENT_REF:
2291         case ARRAY_REF:
2292           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2293                                    TREE_OPERAND (arg1, 0), 0)
2294                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2295                                       TREE_OPERAND (arg1, 1), 0));
2296
2297         case BIT_FIELD_REF:
2298           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2299                                    TREE_OPERAND (arg1, 0), 0)
2300                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2301                                       TREE_OPERAND (arg1, 1), 0)
2302                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2303                                       TREE_OPERAND (arg1, 2), 0));
2304         default:
2305           return 0;
2306         }
2307
2308     case 'e':
2309       if (TREE_CODE (arg0) == RTL_EXPR)
2310         return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
2311       return 0;
2312
2313     default:
2314       return 0;
2315     }
2316 }
2317 \f
2318 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2319    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2320
2321    When in doubt, return 0.  */
2322
2323 static int
2324 operand_equal_for_comparison_p (arg0, arg1, other)
2325      tree arg0, arg1;
2326      tree other;
2327 {
2328   int unsignedp1, unsignedpo;
2329   tree primarg0, primarg1, primother;
2330   unsigned correct_width;
2331
2332   if (operand_equal_p (arg0, arg1, 0))
2333     return 1;
2334
2335   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2336       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2337     return 0;
2338
2339   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2340      and see if the inner values are the same.  This removes any
2341      signedness comparison, which doesn't matter here.  */
2342   primarg0 = arg0, primarg1 = arg1;
2343   STRIP_NOPS (primarg0);  STRIP_NOPS (primarg1);
2344   if (operand_equal_p (primarg0, primarg1, 0))
2345     return 1;
2346
2347   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2348      actual comparison operand, ARG0.
2349
2350      First throw away any conversions to wider types
2351      already present in the operands.  */
2352
2353   primarg1 = get_narrower (arg1, &unsignedp1);
2354   primother = get_narrower (other, &unsignedpo);
2355
2356   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2357   if (unsignedp1 == unsignedpo
2358       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2359       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2360     {
2361       tree type = TREE_TYPE (arg0);
2362
2363       /* Make sure shorter operand is extended the right way
2364          to match the longer operand.  */
2365       primarg1 = convert (signed_or_unsigned_type (unsignedp1,
2366                                                   TREE_TYPE (primarg1)),
2367                          primarg1);
2368
2369       if (operand_equal_p (arg0, convert (type, primarg1), 0))
2370         return 1;
2371     }
2372
2373   return 0;
2374 }
2375 \f
2376 /* See if ARG is an expression that is either a comparison or is performing
2377    arithmetic on comparisons.  The comparisons must only be comparing
2378    two different values, which will be stored in *CVAL1 and *CVAL2; if
2379    they are non-zero it means that some operands have already been found.
2380    No variables may be used anywhere else in the expression except in the
2381    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2382    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2383
2384    If this is true, return 1.  Otherwise, return zero.  */
2385
2386 static int
2387 twoval_comparison_p (arg, cval1, cval2, save_p)
2388      tree arg;
2389      tree *cval1, *cval2;
2390      int *save_p;
2391 {
2392   enum tree_code code = TREE_CODE (arg);
2393   char class = TREE_CODE_CLASS (code);
2394
2395   /* We can handle some of the 'e' cases here.  */
2396   if (class == 'e' && code == TRUTH_NOT_EXPR)
2397     class = '1';
2398   else if (class == 'e'
2399            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2400                || code == COMPOUND_EXPR))
2401     class = '2';
2402
2403   /* ??? Disable this since the SAVE_EXPR might already be in use outside
2404      the expression.  There may be no way to make this work, but it needs
2405      to be looked at again for 2.6.  */
2406 #if 0
2407   else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0)
2408     {
2409       /* If we've already found a CVAL1 or CVAL2, this expression is
2410          two complex to handle.  */
2411       if (*cval1 || *cval2)
2412         return 0;
2413
2414       class = '1';
2415       *save_p = 1;
2416     }
2417 #endif
2418
2419   switch (class)
2420     {
2421     case '1':
2422       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2423
2424     case '2':
2425       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2426               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2427                                       cval1, cval2, save_p));
2428
2429     case 'c':
2430       return 1;
2431
2432     case 'e':
2433       if (code == COND_EXPR)
2434         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2435                                      cval1, cval2, save_p)
2436                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2437                                         cval1, cval2, save_p)
2438                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2439                                         cval1, cval2, save_p));
2440       return 0;
2441
2442     case '<':
2443       /* First see if we can handle the first operand, then the second.  For
2444          the second operand, we know *CVAL1 can't be zero.  It must be that
2445          one side of the comparison is each of the values; test for the
2446          case where this isn't true by failing if the two operands
2447          are the same.  */
2448
2449       if (operand_equal_p (TREE_OPERAND (arg, 0),
2450                            TREE_OPERAND (arg, 1), 0))
2451         return 0;
2452
2453       if (*cval1 == 0)
2454         *cval1 = TREE_OPERAND (arg, 0);
2455       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2456         ;
2457       else if (*cval2 == 0)
2458         *cval2 = TREE_OPERAND (arg, 0);
2459       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2460         ;
2461       else
2462         return 0;
2463
2464       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2465         ;
2466       else if (*cval2 == 0)
2467         *cval2 = TREE_OPERAND (arg, 1);
2468       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2469         ;
2470       else
2471         return 0;
2472
2473       return 1;
2474
2475     default:
2476       return 0;
2477     }
2478 }
2479 \f
2480 /* ARG is a tree that is known to contain just arithmetic operations and
2481    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2482    any occurrence of OLD0 as an operand of a comparison and likewise for
2483    NEW1 and OLD1.  */
2484
2485 static tree
2486 eval_subst (arg, old0, new0, old1, new1)
2487      tree arg;
2488      tree old0, new0, old1, new1;
2489 {
2490   tree type = TREE_TYPE (arg);
2491   enum tree_code code = TREE_CODE (arg);
2492   char class = TREE_CODE_CLASS (code);
2493
2494   /* We can handle some of the 'e' cases here.  */
2495   if (class == 'e' && code == TRUTH_NOT_EXPR)
2496     class = '1';
2497   else if (class == 'e'
2498            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2499     class = '2';
2500
2501   switch (class)
2502     {
2503     case '1':
2504       return fold (build1 (code, type,
2505                            eval_subst (TREE_OPERAND (arg, 0),
2506                                        old0, new0, old1, new1)));
2507
2508     case '2':
2509       return fold (build (code, type,
2510                           eval_subst (TREE_OPERAND (arg, 0),
2511                                       old0, new0, old1, new1),
2512                           eval_subst (TREE_OPERAND (arg, 1),
2513                                       old0, new0, old1, new1)));
2514
2515     case 'e':
2516       switch (code)
2517         {
2518         case SAVE_EXPR:
2519           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2520
2521         case COMPOUND_EXPR:
2522           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2523
2524         case COND_EXPR:
2525           return fold (build (code, type,
2526                               eval_subst (TREE_OPERAND (arg, 0),
2527                                           old0, new0, old1, new1),
2528                               eval_subst (TREE_OPERAND (arg, 1),
2529                                           old0, new0, old1, new1),
2530                               eval_subst (TREE_OPERAND (arg, 2),
2531                                           old0, new0, old1, new1)));
2532         default:
2533           break;
2534         }
2535       /* fall through - ??? */
2536
2537     case '<':
2538       {
2539         tree arg0 = TREE_OPERAND (arg, 0);
2540         tree arg1 = TREE_OPERAND (arg, 1);
2541
2542         /* We need to check both for exact equality and tree equality.  The
2543            former will be true if the operand has a side-effect.  In that
2544            case, we know the operand occurred exactly once.  */
2545
2546         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2547           arg0 = new0;
2548         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2549           arg0 = new1;
2550
2551         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2552           arg1 = new0;
2553         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2554           arg1 = new1;
2555
2556         return fold (build (code, type, arg0, arg1));
2557       }
2558
2559     default:
2560       return arg;
2561     }
2562 }
2563 \f
2564 /* Return a tree for the case when the result of an expression is RESULT
2565    converted to TYPE and OMITTED was previously an operand of the expression
2566    but is now not needed (e.g., we folded OMITTED * 0).
2567
2568    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2569    the conversion of RESULT to TYPE.  */
2570
2571 static tree
2572 omit_one_operand (type, result, omitted)
2573      tree type, result, omitted;
2574 {
2575   tree t = convert (type, result);
2576
2577   if (TREE_SIDE_EFFECTS (omitted))
2578     return build (COMPOUND_EXPR, type, omitted, t);
2579
2580   return non_lvalue (t);
2581 }
2582
2583 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2584
2585 static tree
2586 pedantic_omit_one_operand (type, result, omitted)
2587      tree type, result, omitted;
2588 {
2589   tree t = convert (type, result);
2590
2591   if (TREE_SIDE_EFFECTS (omitted))
2592     return build (COMPOUND_EXPR, type, omitted, t);
2593
2594   return pedantic_non_lvalue (t);
2595 }
2596
2597
2598 \f
2599 /* Return a simplified tree node for the truth-negation of ARG.  This
2600    never alters ARG itself.  We assume that ARG is an operation that
2601    returns a truth value (0 or 1).  */
2602
2603 tree
2604 invert_truthvalue (arg)
2605      tree arg;
2606 {
2607   tree type = TREE_TYPE (arg);
2608   enum tree_code code = TREE_CODE (arg);
2609
2610   if (code == ERROR_MARK)
2611     return arg;
2612
2613   /* If this is a comparison, we can simply invert it, except for
2614      floating-point non-equality comparisons, in which case we just
2615      enclose a TRUTH_NOT_EXPR around what we have.  */
2616
2617   if (TREE_CODE_CLASS (code) == '<')
2618     {
2619       if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
2620           && !flag_fast_math && code != NE_EXPR && code != EQ_EXPR)
2621         return build1 (TRUTH_NOT_EXPR, type, arg);
2622       else
2623         return build (invert_tree_comparison (code), type,
2624                       TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2625     }
2626
2627   switch (code)
2628     {
2629     case INTEGER_CST:
2630       return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
2631                                          && TREE_INT_CST_HIGH (arg) == 0, 0));
2632
2633     case TRUTH_AND_EXPR:
2634       return build (TRUTH_OR_EXPR, type,
2635                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2636                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2637
2638     case TRUTH_OR_EXPR:
2639       return build (TRUTH_AND_EXPR, type,
2640                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2641                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2642
2643     case TRUTH_XOR_EXPR:
2644       /* Here we can invert either operand.  We invert the first operand
2645          unless the second operand is a TRUTH_NOT_EXPR in which case our
2646          result is the XOR of the first operand with the inside of the
2647          negation of the second operand.  */
2648
2649       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2650         return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2651                       TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2652       else
2653         return build (TRUTH_XOR_EXPR, type,
2654                       invert_truthvalue (TREE_OPERAND (arg, 0)),
2655                       TREE_OPERAND (arg, 1));
2656
2657     case TRUTH_ANDIF_EXPR:
2658       return build (TRUTH_ORIF_EXPR, type,
2659                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2660                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2661
2662     case TRUTH_ORIF_EXPR:
2663       return build (TRUTH_ANDIF_EXPR, type,
2664                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2665                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2666
2667     case TRUTH_NOT_EXPR:
2668       return TREE_OPERAND (arg, 0);
2669
2670     case COND_EXPR:
2671       return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2672                     invert_truthvalue (TREE_OPERAND (arg, 1)),
2673                     invert_truthvalue (TREE_OPERAND (arg, 2)));
2674
2675     case COMPOUND_EXPR:
2676       return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2677                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2678
2679     case WITH_RECORD_EXPR:
2680       return build (WITH_RECORD_EXPR, type,
2681                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2682                     TREE_OPERAND (arg, 1));
2683
2684     case NON_LVALUE_EXPR:
2685       return invert_truthvalue (TREE_OPERAND (arg, 0));
2686
2687     case NOP_EXPR:
2688     case CONVERT_EXPR:
2689     case FLOAT_EXPR:
2690       return build1 (TREE_CODE (arg), type,
2691                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2692
2693     case BIT_AND_EXPR:
2694       if (!integer_onep (TREE_OPERAND (arg, 1)))
2695         break;
2696       return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2697
2698     case SAVE_EXPR:
2699       return build1 (TRUTH_NOT_EXPR, type, arg);
2700
2701     case CLEANUP_POINT_EXPR:
2702       return build1 (CLEANUP_POINT_EXPR, type,
2703                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2704
2705     default:
2706       break;
2707     }
2708   if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2709     abort ();
2710   return build1 (TRUTH_NOT_EXPR, type, arg);
2711 }
2712
2713 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2714    operands are another bit-wise operation with a common input.  If so,
2715    distribute the bit operations to save an operation and possibly two if
2716    constants are involved.  For example, convert
2717         (A | B) & (A | C) into A | (B & C)
2718    Further simplification will occur if B and C are constants.
2719
2720    If this optimization cannot be done, 0 will be returned.  */
2721
2722 static tree
2723 distribute_bit_expr (code, type, arg0, arg1)
2724      enum tree_code code;
2725      tree type;
2726      tree arg0, arg1;
2727 {
2728   tree common;
2729   tree left, right;
2730
2731   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2732       || TREE_CODE (arg0) == code
2733       || (TREE_CODE (arg0) != BIT_AND_EXPR
2734           && TREE_CODE (arg0) != BIT_IOR_EXPR))
2735     return 0;
2736
2737   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2738     {
2739       common = TREE_OPERAND (arg0, 0);
2740       left = TREE_OPERAND (arg0, 1);
2741       right = TREE_OPERAND (arg1, 1);
2742     }
2743   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2744     {
2745       common = TREE_OPERAND (arg0, 0);
2746       left = TREE_OPERAND (arg0, 1);
2747       right = TREE_OPERAND (arg1, 0);
2748     }
2749   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2750     {
2751       common = TREE_OPERAND (arg0, 1);
2752       left = TREE_OPERAND (arg0, 0);
2753       right = TREE_OPERAND (arg1, 1);
2754     }
2755   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2756     {
2757       common = TREE_OPERAND (arg0, 1);
2758       left = TREE_OPERAND (arg0, 0);
2759       right = TREE_OPERAND (arg1, 0);
2760     }
2761   else
2762     return 0;
2763
2764   return fold (build (TREE_CODE (arg0), type, common,
2765                       fold (build (code, type, left, right))));
2766 }
2767 \f
2768 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2769    starting at BITPOS.  The field is unsigned if UNSIGNEDP is non-zero.  */
2770
2771 static tree
2772 make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2773      tree inner;
2774      tree type;
2775      int bitsize, bitpos;
2776      int unsignedp;
2777 {
2778   tree result = build (BIT_FIELD_REF, type, inner,
2779                        size_int (bitsize), bitsize_int (bitpos, 0L));
2780
2781   TREE_UNSIGNED (result) = unsignedp;
2782
2783   return result;
2784 }
2785
2786 /* Optimize a bit-field compare.
2787
2788    There are two cases:  First is a compare against a constant and the
2789    second is a comparison of two items where the fields are at the same
2790    bit position relative to the start of a chunk (byte, halfword, word)
2791    large enough to contain it.  In these cases we can avoid the shift
2792    implicit in bitfield extractions.
2793
2794    For constants, we emit a compare of the shifted constant with the
2795    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2796    compared.  For two fields at the same position, we do the ANDs with the
2797    similar mask and compare the result of the ANDs.
2798
2799    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2800    COMPARE_TYPE is the type of the comparison, and LHS and RHS
2801    are the left and right operands of the comparison, respectively.
2802
2803    If the optimization described above can be done, we return the resulting
2804    tree.  Otherwise we return zero.  */
2805
2806 static tree
2807 optimize_bit_field_compare (code, compare_type, lhs, rhs)
2808      enum tree_code code;
2809      tree compare_type;
2810      tree lhs, rhs;
2811 {
2812   int lbitpos, lbitsize, rbitpos, rbitsize;
2813   int lnbitpos, lnbitsize, rnbitpos = 0, rnbitsize = 0;
2814   tree type = TREE_TYPE (lhs);
2815   tree signed_type, unsigned_type;
2816   int const_p = TREE_CODE (rhs) == INTEGER_CST;
2817   enum machine_mode lmode, rmode, lnmode, rnmode = VOIDmode;
2818   int lunsignedp, runsignedp;
2819   int lvolatilep = 0, rvolatilep = 0;
2820   int alignment;
2821   tree linner, rinner = NULL_TREE;
2822   tree mask;
2823   tree offset;
2824
2825   /* Get all the information about the extractions being done.  If the bit size
2826      if the same as the size of the underlying object, we aren't doing an
2827      extraction at all and so can do nothing.  We also don't want to
2828      do anything if the inner expression is a PLACEHOLDER_EXPR since we
2829      then will no longer be able to replace it.  */
2830   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2831                                 &lunsignedp, &lvolatilep, &alignment);
2832   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2833       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
2834     return 0;
2835
2836  if (!const_p)
2837    {
2838      /* If this is not a constant, we can only do something if bit positions,
2839         sizes, and signedness are the same.   */
2840      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2841                                    &runsignedp, &rvolatilep, &alignment);
2842
2843      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2844          || lunsignedp != runsignedp || offset != 0
2845          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
2846        return 0;
2847    }
2848
2849   /* See if we can find a mode to refer to this field.  We should be able to,
2850      but fail if we can't.  */
2851   lnmode = get_best_mode (lbitsize, lbitpos,
2852                           TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
2853                           lvolatilep);
2854   if (lnmode == VOIDmode)
2855     return 0;
2856
2857   /* Set signed and unsigned types of the precision of this mode for the
2858      shifts below.  */
2859   signed_type = type_for_mode (lnmode, 0);
2860   unsigned_type = type_for_mode (lnmode, 1);
2861
2862   if (! const_p)
2863     {
2864       rnmode = get_best_mode (rbitsize, rbitpos,
2865                               TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
2866                               rvolatilep);
2867       if (rnmode == VOIDmode)
2868         return 0;
2869     }
2870
2871   /* Compute the bit position and size for the new reference and our offset
2872      within it. If the new reference is the same size as the original, we
2873      won't optimize anything, so return zero.  */
2874   lnbitsize = GET_MODE_BITSIZE (lnmode);
2875   lnbitpos = lbitpos & ~ (lnbitsize - 1);
2876   lbitpos -= lnbitpos;
2877   if (lnbitsize == lbitsize)
2878     return 0;
2879
2880   if (! const_p)
2881     {
2882       rnbitsize = GET_MODE_BITSIZE (rnmode);
2883       rnbitpos = rbitpos & ~ (rnbitsize - 1);
2884       rbitpos -= rnbitpos;
2885       if (rnbitsize == rbitsize)
2886         return 0;
2887     }
2888
2889   if (BYTES_BIG_ENDIAN)
2890     lbitpos = lnbitsize - 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 (lnbitsize - lbitsize), 0);
2898   mask = const_binop (RSHIFT_EXPR, mask,
2899                       size_int (lnbitsize - 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                                              lnbitsize, lnbitpos, 1),
2908                          mask),
2909                   build (BIT_AND_EXPR, unsigned_type,
2910                          make_bit_field_ref (rinner, unsigned_type,
2911                                              rnbitsize, rnbitpos, 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, lnbitsize, lnbitpos, 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.  */
3857
3858   /* @@ I'm not sure it wins on the m88110 to do this if the comparisons
3859      are with zero (tmw).  */
3860
3861   if (BRANCH_COST >= 2
3862       && INTEGRAL_TYPE_P (TREE_TYPE (rhs))
3863       && simple_operand_p (rl_arg)
3864       && simple_operand_p (rr_arg))
3865     return build (code, truth_type, lhs, rhs);
3866
3867   /* See if the comparisons can be merged.  Then get all the parameters for
3868      each side.  */
3869
3870   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3871       || (rcode != EQ_EXPR && rcode != NE_EXPR))
3872     return 0;
3873
3874   volatilep = 0;
3875   ll_inner = decode_field_reference (ll_arg,
3876                                      &ll_bitsize, &ll_bitpos, &ll_mode,
3877                                      &ll_unsignedp, &volatilep, &ll_mask,
3878                                      &ll_and_mask);
3879   lr_inner = decode_field_reference (lr_arg,
3880                                      &lr_bitsize, &lr_bitpos, &lr_mode,
3881                                      &lr_unsignedp, &volatilep, &lr_mask,
3882                                      &lr_and_mask);
3883   rl_inner = decode_field_reference (rl_arg,
3884                                      &rl_bitsize, &rl_bitpos, &rl_mode,
3885                                      &rl_unsignedp, &volatilep, &rl_mask,
3886                                      &rl_and_mask);
3887   rr_inner = decode_field_reference (rr_arg,
3888                                      &rr_bitsize, &rr_bitpos, &rr_mode,
3889                                      &rr_unsignedp, &volatilep, &rr_mask,
3890                                      &rr_and_mask);
3891
3892   /* It must be true that the inner operation on the lhs of each
3893      comparison must be the same if we are to be able to do anything.
3894      Then see if we have constants.  If not, the same must be true for
3895      the rhs's.  */
3896   if (volatilep || ll_inner == 0 || rl_inner == 0
3897       || ! operand_equal_p (ll_inner, rl_inner, 0))
3898     return 0;
3899
3900   if (TREE_CODE (lr_arg) == INTEGER_CST
3901       && TREE_CODE (rr_arg) == INTEGER_CST)
3902     l_const = lr_arg, r_const = rr_arg;
3903   else if (lr_inner == 0 || rr_inner == 0
3904            || ! operand_equal_p (lr_inner, rr_inner, 0))
3905     return 0;
3906   else
3907     l_const = r_const = 0;
3908
3909   /* If either comparison code is not correct for our logical operation,
3910      fail.  However, we can convert a one-bit comparison against zero into
3911      the opposite comparison against that bit being set in the field.  */
3912
3913   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3914   if (lcode != wanted_code)
3915     {
3916       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3917         {
3918           /* Make the left operand unsigned, since we are only interested
3919              in the value of one bit.  Otherwise we are doing the wrong
3920              thing below.  */
3921           ll_unsignedp = 1;
3922           l_const = ll_mask;
3923         }
3924       else
3925         return 0;
3926     }
3927
3928   /* This is analogous to the code for l_const above.  */
3929   if (rcode != wanted_code)
3930     {
3931       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3932         {
3933           rl_unsignedp = 1;
3934           r_const = rl_mask;
3935         }
3936       else
3937         return 0;
3938     }
3939
3940   /* See if we can find a mode that contains both fields being compared on
3941      the left.  If we can't, fail.  Otherwise, update all constants and masks
3942      to be relative to a field of that size.  */
3943   first_bit = MIN (ll_bitpos, rl_bitpos);
3944   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3945   lnmode = get_best_mode (end_bit - first_bit, first_bit,
3946                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3947                           volatilep);
3948   if (lnmode == VOIDmode)
3949     return 0;
3950
3951   lnbitsize = GET_MODE_BITSIZE (lnmode);
3952   lnbitpos = first_bit & ~ (lnbitsize - 1);
3953   lntype = type_for_size (lnbitsize, 1);
3954   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3955
3956   if (BYTES_BIG_ENDIAN)
3957     {
3958       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3959       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3960     }
3961
3962   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3963                          size_int (xll_bitpos), 0);
3964   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3965                          size_int (xrl_bitpos), 0);
3966
3967   if (l_const)
3968     {
3969       l_const = convert (lntype, l_const);
3970       l_const = unextend (l_const,  ll_bitsize, ll_unsignedp, ll_and_mask);
3971       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3972       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3973                                         fold (build1 (BIT_NOT_EXPR,
3974                                                       lntype, ll_mask)),
3975                                         0)))
3976         {
3977           warning ("comparison is always %d", wanted_code == NE_EXPR);
3978
3979           return convert (truth_type,
3980                           wanted_code == NE_EXPR
3981                           ? integer_one_node : integer_zero_node);
3982         }
3983     }
3984   if (r_const)
3985     {
3986       r_const = convert (lntype, r_const);
3987       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3988       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3989       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3990                                         fold (build1 (BIT_NOT_EXPR,
3991                                                       lntype, rl_mask)),
3992                                         0)))
3993         {
3994           warning ("comparison is always %d", wanted_code == NE_EXPR);
3995
3996           return convert (truth_type,
3997                           wanted_code == NE_EXPR
3998                           ? integer_one_node : integer_zero_node);
3999         }
4000     }
4001
4002   /* If the right sides are not constant, do the same for it.  Also,
4003      disallow this optimization if a size or signedness mismatch occurs
4004      between the left and right sides.  */
4005   if (l_const == 0)
4006     {
4007       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4008           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4009           /* Make sure the two fields on the right
4010              correspond to the left without being swapped.  */
4011           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4012         return 0;
4013
4014       first_bit = MIN (lr_bitpos, rr_bitpos);
4015       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4016       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4017                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4018                               volatilep);
4019       if (rnmode == VOIDmode)
4020         return 0;
4021
4022       rnbitsize = GET_MODE_BITSIZE (rnmode);
4023       rnbitpos = first_bit & ~ (rnbitsize - 1);
4024       rntype = type_for_size (rnbitsize, 1);
4025       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4026
4027       if (BYTES_BIG_ENDIAN)
4028         {
4029           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4030           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4031         }
4032
4033       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
4034                              size_int (xlr_bitpos), 0);
4035       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
4036                              size_int (xrr_bitpos), 0);
4037
4038       /* Make a mask that corresponds to both fields being compared.
4039          Do this for both items being compared.  If the operands are the
4040          same size and the bits being compared are in the same position
4041          then we can do this by masking both and comparing the masked
4042          results.  */
4043       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4044       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4045       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4046         {
4047           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4048                                     ll_unsignedp || rl_unsignedp);
4049           if (! all_ones_mask_p (ll_mask, lnbitsize))
4050             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
4051
4052           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4053                                     lr_unsignedp || rr_unsignedp);
4054           if (! all_ones_mask_p (lr_mask, rnbitsize))
4055             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
4056
4057           return build (wanted_code, truth_type, lhs, rhs);
4058         }
4059
4060       /* There is still another way we can do something:  If both pairs of
4061          fields being compared are adjacent, we may be able to make a wider
4062          field containing them both.
4063
4064          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4065          the mask must be shifted to account for the shift done by
4066          make_bit_field_ref.  */
4067       if ((ll_bitsize + ll_bitpos == rl_bitpos
4068            && lr_bitsize + lr_bitpos == rr_bitpos)
4069           || (ll_bitpos == rl_bitpos + rl_bitsize
4070               && lr_bitpos == rr_bitpos + rr_bitsize))
4071         {
4072           tree type;
4073
4074           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4075                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4076           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4077                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4078
4079           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4080                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4081           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4082                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4083
4084           /* Convert to the smaller type before masking out unwanted bits.  */
4085           type = lntype;
4086           if (lntype != rntype)
4087             {
4088               if (lnbitsize > rnbitsize)
4089                 {
4090                   lhs = convert (rntype, lhs);
4091                   ll_mask = convert (rntype, ll_mask);
4092                   type = rntype;
4093                 }
4094               else if (lnbitsize < rnbitsize)
4095                 {
4096                   rhs = convert (lntype, rhs);
4097                   lr_mask = convert (lntype, lr_mask);
4098                   type = lntype;
4099                 }
4100             }
4101
4102           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4103             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
4104
4105           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4106             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
4107
4108           return build (wanted_code, truth_type, lhs, rhs);
4109         }
4110
4111       return 0;
4112     }
4113
4114   /* Handle the case of comparisons with constants.  If there is something in
4115      common between the masks, those bits of the constants must be the same.
4116      If not, the condition is always false.  Test for this to avoid generating
4117      incorrect code below.  */
4118   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4119   if (! integer_zerop (result)
4120       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4121                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4122     {
4123       if (wanted_code == NE_EXPR)
4124         {
4125           warning ("`or' of unmatched not-equal tests is always 1");
4126           return convert (truth_type, integer_one_node);
4127         }
4128       else
4129         {
4130           warning ("`and' of mutually exclusive equal-tests is always 0");
4131           return convert (truth_type, integer_zero_node);
4132         }
4133     }
4134
4135   /* Construct the expression we will return.  First get the component
4136      reference we will make.  Unless the mask is all ones the width of
4137      that field, perform the mask operation.  Then compare with the
4138      merged constant.  */
4139   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4140                                ll_unsignedp || rl_unsignedp);
4141
4142   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4143   if (! all_ones_mask_p (ll_mask, lnbitsize))
4144     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
4145
4146   return build (wanted_code, truth_type, result,
4147                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4148 }
4149 \f
4150 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4151    constant.  */
4152
4153 static tree
4154 optimize_minmax_comparison (t)
4155      tree t;
4156 {
4157   tree type = TREE_TYPE (t);
4158   tree arg0 = TREE_OPERAND (t, 0);
4159   enum tree_code op_code;
4160   tree comp_const = TREE_OPERAND (t, 1);
4161   tree minmax_const;
4162   int consts_equal, consts_lt;
4163   tree inner;
4164
4165   STRIP_SIGN_NOPS (arg0);
4166
4167   op_code = TREE_CODE (arg0);
4168   minmax_const = TREE_OPERAND (arg0, 1);
4169   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4170   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4171   inner = TREE_OPERAND (arg0, 0);
4172
4173   /* If something does not permit us to optimize, return the original tree.  */
4174   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4175       || TREE_CODE (comp_const) != INTEGER_CST
4176       || TREE_CONSTANT_OVERFLOW (comp_const)
4177       || TREE_CODE (minmax_const) != INTEGER_CST
4178       || TREE_CONSTANT_OVERFLOW (minmax_const))
4179     return t;
4180
4181   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4182      and GT_EXPR, doing the rest with recursive calls using logical
4183      simplifications.  */
4184   switch (TREE_CODE (t))
4185     {
4186     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4187       return
4188         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4189
4190     case GE_EXPR:
4191       return
4192         fold (build (TRUTH_ORIF_EXPR, type,
4193                      optimize_minmax_comparison
4194                      (build (EQ_EXPR, type, arg0, comp_const)),
4195                      optimize_minmax_comparison
4196                      (build (GT_EXPR, type, arg0, comp_const))));
4197
4198     case EQ_EXPR:
4199       if (op_code == MAX_EXPR && consts_equal)
4200         /* MAX (X, 0) == 0  ->  X <= 0  */
4201         return fold (build (LE_EXPR, type, inner, comp_const));
4202
4203       else if (op_code == MAX_EXPR && consts_lt)
4204         /* MAX (X, 0) == 5  ->  X == 5   */
4205         return fold (build (EQ_EXPR, type, inner, comp_const));
4206
4207       else if (op_code == MAX_EXPR)
4208         /* MAX (X, 0) == -1  ->  false  */
4209         return omit_one_operand (type, integer_zero_node, inner);
4210
4211       else if (consts_equal)
4212         /* MIN (X, 0) == 0  ->  X >= 0  */
4213         return fold (build (GE_EXPR, type, inner, comp_const));
4214
4215       else if (consts_lt)
4216         /* MIN (X, 0) == 5  ->  false  */
4217         return omit_one_operand (type, integer_zero_node, inner);
4218
4219       else
4220         /* MIN (X, 0) == -1  ->  X == -1  */
4221         return fold (build (EQ_EXPR, type, inner, comp_const));
4222
4223     case GT_EXPR:
4224       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4225         /* MAX (X, 0) > 0  ->  X > 0
4226            MAX (X, 0) > 5  ->  X > 5  */
4227         return fold (build (GT_EXPR, type, inner, comp_const));
4228
4229       else if (op_code == MAX_EXPR)
4230         /* MAX (X, 0) > -1  ->  true  */
4231         return omit_one_operand (type, integer_one_node, inner);
4232
4233       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4234         /* MIN (X, 0) > 0  ->  false
4235            MIN (X, 0) > 5  ->  false  */
4236         return omit_one_operand (type, integer_zero_node, inner);
4237
4238       else
4239         /* MIN (X, 0) > -1  ->  X > -1  */
4240         return fold (build (GT_EXPR, type, inner, comp_const));
4241
4242     default:
4243       return t;
4244     }
4245 }
4246 \f
4247 /* T is an integer expression that is being multiplied, divided, or taken a
4248    modulus (CODE says which and what kind of divide or modulus) by a
4249    constant C.  See if we can eliminate that operation by folding it with
4250    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4251    should be used for the computation if wider than our type.
4252
4253    For example, if we are dividing (X * 8) + (Y + 16) by 4, we can return
4254    (X * 2) + (Y + 4).  We also canonicalize (X + 7) * 4 into X * 4 + 28
4255    in the hope that either the machine has a multiply-accumulate insn
4256    or that this is part of an addressing calculation.
4257
4258    If we return a non-null expression, it is an equivalent form of the
4259    original computation, but need not be in the original type.  */
4260
4261 static tree
4262 extract_muldiv (t, c, code, wide_type)
4263      tree t;
4264      tree c;
4265      enum tree_code code;
4266      tree wide_type;
4267 {
4268   tree type = TREE_TYPE (t);
4269   enum tree_code tcode = TREE_CODE (t);
4270   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4271                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4272                 ? wide_type : type);
4273   tree t1, t2;
4274   int same_p = tcode == code;
4275   tree op0, op1;
4276
4277   /* Don't deal with constants of zero here; they confuse the code below.  */
4278   if (integer_zerop (c))
4279     return 0;
4280
4281   if (TREE_CODE_CLASS (tcode) == '1')
4282     op0 = TREE_OPERAND (t, 0);
4283
4284   if (TREE_CODE_CLASS (tcode) == '2')
4285     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4286
4287   /* Note that we need not handle conditional operations here since fold
4288      already handles those cases.  So just do arithmetic here.  */
4289   switch (tcode)
4290     {
4291     case INTEGER_CST:
4292       /* For a constant, we can always simplify if we are a multiply
4293          or (for divide and modulus) if it is a multiple of our constant.  */
4294       if (code == MULT_EXPR
4295           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4296         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4297       break;
4298
4299     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4300
4301       /* Pass the constant down and see if we can make a simplification.  If
4302          we can, replace this expression with the inner simplification for
4303          possible later conversion to our or some other type.  */
4304       if (0 != (t1 = extract_muldiv (op0, convert (TREE_TYPE (op0), c), code,
4305                                      code == MULT_EXPR ? ctype : NULL_TREE)))
4306         return t1;
4307       break;
4308
4309     case NEGATE_EXPR:  case ABS_EXPR:
4310       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4311         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4312       break;
4313
4314     case MIN_EXPR:  case MAX_EXPR:
4315       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4316       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4317           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4318         {
4319           if (tree_int_cst_sgn (c) < 0)
4320             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4321
4322           return fold (build (tcode, ctype, convert (ctype, t1),
4323                               convert (ctype, t2)));
4324         }
4325       break;
4326
4327     case WITH_RECORD_EXPR:
4328       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4329         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4330                       TREE_OPERAND (t, 1));
4331       break;
4332
4333     case SAVE_EXPR:
4334       /* If this has not been evaluated and the operand has no side effects,
4335          we can see if we can do something inside it and make a new one.
4336          Note that this test is overly conservative since we can do this
4337          if the only reason it had side effects is that it was another
4338          similar SAVE_EXPR, but that isn't worth bothering with.  */
4339       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4340           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4341                                         wide_type)))
4342         return save_expr (t1);
4343       break;
4344
4345     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4346       /* If the second operand is constant, this is a multiplication
4347          or floor division, by a power of two, so we can treat it that
4348          way unless the multiplier or divisor overflows.  */
4349       if (TREE_CODE (op1) == INTEGER_CST
4350           && 0 != (t1 = convert (ctype,
4351                                  const_binop (LSHIFT_EXPR, size_one_node,
4352                                               op1, 0)))
4353           && ! TREE_OVERFLOW (t1))
4354         return extract_muldiv (build (tcode == LSHIFT_EXPR
4355                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4356                                       ctype, convert (ctype, op0), t1),
4357                                c, code, wide_type);
4358       break;
4359
4360     case PLUS_EXPR:  case MINUS_EXPR:
4361       /* See if we can eliminate the operation on both sides.  If we can, we
4362          can return a new PLUS or MINUS.  If we can't, the only remaining
4363          cases where we can do anything are if the second operand is a
4364          constant.  */
4365       t1 = extract_muldiv (op0, c, code, wide_type);
4366       t2 = extract_muldiv (op1, c, code, wide_type);
4367       if (t1 != 0 && t2 != 0)
4368         return fold (build (tcode, ctype, convert (ctype, t1),
4369                             convert (ctype, t2)));
4370
4371       /* If this was a subtraction, negate OP1 and set it to be an addition.
4372          This simplifies the logic below.  */
4373       if (tcode == MINUS_EXPR)
4374         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4375
4376       if (TREE_CODE (op1) != INTEGER_CST)
4377         break;
4378
4379       /* If either OP1 or C are negative, this optimization is not safe for
4380          some of the division and remainder types while for others we need
4381          to change the code.  */
4382       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4383         {
4384           if (code == CEIL_DIV_EXPR)
4385             code = FLOOR_DIV_EXPR;
4386           else if (code == CEIL_MOD_EXPR)
4387             code = FLOOR_MOD_EXPR;
4388           else if (code == FLOOR_DIV_EXPR)
4389             code = CEIL_DIV_EXPR;
4390           else if (code == FLOOR_MOD_EXPR)
4391             code = CEIL_MOD_EXPR;
4392           else if (code != MULT_EXPR)
4393             break;
4394         }
4395
4396       /* Now do the operation and verify it doesn't overflow.  */
4397       op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4398       if (op1 == 0 || TREE_OVERFLOW (op1))
4399         break;
4400
4401       /* If we were able to eliminate our operation from the first side,
4402          apply our operation to the second side and reform the PLUS.  */
4403       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4404         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4405
4406       /* The last case is if we are a multiply.  In that case, we can
4407          apply the distributive law to commute the multiply and addition
4408          if the multiplication of the constants doesn't overflow. */
4409       if (code == MULT_EXPR)
4410         return fold (build (tcode, ctype, fold (build (code, ctype,
4411                                                        convert (ctype, op0),
4412                                                        convert (ctype, c))),
4413                             op1));
4414
4415       break;
4416
4417     case MULT_EXPR:
4418       /* We have a special case here if we are doing something like
4419          (C * 8) % 4 since we know that's zero.  */
4420       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4421            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4422           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4423           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4424         return omit_one_operand (type, integer_zero_node, op0);
4425
4426       /* ... fall through ... */
4427
4428     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4429     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4430       /* If we can extract our operation from the LHS, do so and return a
4431          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4432          do something only if the second operand is a constant.  */
4433       if (same_p
4434           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4435         return fold (build (tcode, ctype, convert (ctype, t1),
4436                             convert (ctype, op1)));
4437       else if (tcode == MULT_EXPR && code == MULT_EXPR
4438                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4439         return fold (build (tcode, ctype, convert (ctype, op0),
4440                             convert (ctype, t1)));
4441       else if (TREE_CODE (op1) != INTEGER_CST)
4442         return 0;
4443
4444       /* If these are the same operation types, we can associate them
4445          assuming no overflow.  */
4446       if (tcode == code
4447           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4448                                      convert (ctype, c), 0))
4449           && ! TREE_OVERFLOW (t1))
4450         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4451
4452       /* If these operations "cancel" each other, we have the main
4453          optimizations of this pass, which occur when either constant is a
4454          multiple of the other, in which case we replace this with either an
4455          operation or CODE or TCODE.  */
4456       if ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4457           || (tcode == MULT_EXPR
4458               && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4459               && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR))
4460         {
4461           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4462             return fold (build (tcode, ctype, convert (ctype, op0),
4463                                 convert (ctype,
4464                                          const_binop (TRUNC_DIV_EXPR,
4465                                                       op1, c, 0))));
4466           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4467             return fold (build (code, ctype, convert (ctype, op0),
4468                                 convert (ctype,
4469                                          const_binop (TRUNC_DIV_EXPR,
4470                                                       c, op1, 0))));
4471         }
4472       break;
4473
4474     default:
4475       break;
4476     }
4477
4478   return 0;
4479 }
4480 \f
4481 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4482    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4483    that we may sometimes modify the tree.  */
4484
4485 static tree
4486 strip_compound_expr (t, s)
4487      tree t;
4488      tree s;
4489 {
4490   enum tree_code code = TREE_CODE (t);
4491
4492   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4493   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4494       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4495     return TREE_OPERAND (t, 1);
4496
4497   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4498      don't bother handling any other types.  */
4499   else if (code == COND_EXPR)
4500     {
4501       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4502       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4503       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4504     }
4505   else if (TREE_CODE_CLASS (code) == '1')
4506     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4507   else if (TREE_CODE_CLASS (code) == '<'
4508            || TREE_CODE_CLASS (code) == '2')
4509     {
4510       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4511       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4512     }
4513
4514   return t;
4515 }
4516 \f
4517 /* Return a node which has the indicated constant VALUE (either 0 or
4518    1), and is of the indicated TYPE.  */
4519
4520 static tree
4521 constant_boolean_node (value, type)
4522      int value;
4523      tree type;
4524 {
4525   if (type == integer_type_node)
4526     return value ? integer_one_node : integer_zero_node;
4527   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4528     return truthvalue_conversion (value ? integer_one_node :
4529                                   integer_zero_node);
4530   else
4531     {
4532       tree t = build_int_2 (value, 0);
4533       TREE_TYPE (t) = type;
4534       return t;
4535     }
4536 }
4537
4538 /* Utility function for the following routine, to see how complex a nesting of
4539    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4540    we don't care (to avoid spending too much time on complex expressions.).  */
4541
4542 static int
4543 count_cond (expr, lim)
4544      tree expr;
4545      int lim;
4546 {
4547   int true, false;
4548
4549   if (TREE_CODE (expr) != COND_EXPR)
4550     return 0;
4551   else if (lim <= 0)
4552     return 0;
4553
4554   true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4555   false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
4556   return MIN (lim, 1 + true + false);
4557 }
4558 \f
4559 /* Perform constant folding and related simplification of EXPR.
4560    The related simplifications include x*1 => x, x*0 => 0, etc.,
4561    and application of the associative law.
4562    NOP_EXPR conversions may be removed freely (as long as we
4563    are careful not to change the C type of the overall expression)
4564    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4565    but we can constant-fold them if they have constant operands.  */
4566
4567 tree
4568 fold (expr)
4569      tree expr;
4570 {
4571   register tree t = expr;
4572   tree t1 = NULL_TREE;
4573   tree tem;
4574   tree type = TREE_TYPE (expr);
4575   register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4576   register enum tree_code code = TREE_CODE (t);
4577   register int kind;
4578   int invert;
4579
4580   /* WINS will be nonzero when the switch is done
4581      if all operands are constant.  */
4582
4583   int wins = 1;
4584
4585   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4586      Likewise for a SAVE_EXPR that's already been evaluated.  */
4587   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
4588     return t;
4589
4590   /* Return right away if already constant.  */
4591   if (TREE_CONSTANT (t))
4592     {
4593       if (code == CONST_DECL)
4594         return DECL_INITIAL (t);
4595       return t;
4596     }
4597
4598 #ifdef MAX_INTEGER_COMPUTATION_MODE
4599   check_max_integer_computation_mode (expr);
4600 #endif
4601
4602   kind = TREE_CODE_CLASS (code);
4603   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4604     {
4605       tree subop;
4606
4607       /* Special case for conversion ops that can have fixed point args.  */
4608       arg0 = TREE_OPERAND (t, 0);
4609
4610       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4611       if (arg0 != 0)
4612         STRIP_SIGN_NOPS (arg0);
4613
4614       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4615         subop = TREE_REALPART (arg0);
4616       else
4617         subop = arg0;
4618
4619       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4620 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4621           && TREE_CODE (subop) != REAL_CST
4622 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4623           )
4624         /* Note that TREE_CONSTANT isn't enough:
4625            static var addresses are constant but we can't
4626            do arithmetic on them.  */
4627         wins = 0;
4628     }
4629   else if (kind == 'e' || kind == '<'
4630            || kind == '1' || kind == '2' || kind == 'r')
4631     {
4632       register int len = tree_code_length[(int) code];
4633       register int i;
4634       for (i = 0; i < len; i++)
4635         {
4636           tree op = TREE_OPERAND (t, i);
4637           tree subop;
4638
4639           if (op == 0)
4640             continue;           /* Valid for CALL_EXPR, at least.  */
4641
4642           if (kind == '<' || code == RSHIFT_EXPR)
4643             {
4644               /* Signedness matters here.  Perhaps we can refine this
4645                  later.  */
4646               STRIP_SIGN_NOPS (op);
4647             }
4648           else
4649             {
4650               /* Strip any conversions that don't change the mode.  */
4651               STRIP_NOPS (op);
4652             }
4653
4654           if (TREE_CODE (op) == COMPLEX_CST)
4655             subop = TREE_REALPART (op);
4656           else
4657             subop = op;
4658
4659           if (TREE_CODE (subop) != INTEGER_CST
4660 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4661               && TREE_CODE (subop) != REAL_CST
4662 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4663               )
4664             /* Note that TREE_CONSTANT isn't enough:
4665                static var addresses are constant but we can't
4666                do arithmetic on them.  */
4667             wins = 0;
4668
4669           if (i == 0)
4670             arg0 = op;
4671           else if (i == 1)
4672             arg1 = op;
4673         }
4674     }
4675
4676   /* If this is a commutative operation, and ARG0 is a constant, move it
4677      to ARG1 to reduce the number of tests below.  */
4678   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4679        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4680        || code == BIT_AND_EXPR)
4681       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4682     {
4683       tem = arg0; arg0 = arg1; arg1 = tem;
4684
4685       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4686       TREE_OPERAND (t, 1) = tem;
4687     }
4688
4689   /* Now WINS is set as described above,
4690      ARG0 is the first operand of EXPR,
4691      and ARG1 is the second operand (if it has more than one operand).
4692
4693      First check for cases where an arithmetic operation is applied to a
4694      compound, conditional, or comparison operation.  Push the arithmetic
4695      operation inside the compound or conditional to see if any folding
4696      can then be done.  Convert comparison to conditional for this purpose.
4697      The also optimizes non-constant cases that used to be done in
4698      expand_expr.
4699
4700      Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
4701      one of the operands is a comparison and the other is a comparison, a
4702      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
4703      code below would make the expression more complex.  Change it to a
4704      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
4705      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
4706
4707   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4708        || code == EQ_EXPR || code == NE_EXPR)
4709       && ((truth_value_p (TREE_CODE (arg0))
4710            && (truth_value_p (TREE_CODE (arg1))
4711                || (TREE_CODE (arg1) == BIT_AND_EXPR
4712                    && integer_onep (TREE_OPERAND (arg1, 1)))))
4713           || (truth_value_p (TREE_CODE (arg1))
4714               && (truth_value_p (TREE_CODE (arg0))
4715                   || (TREE_CODE (arg0) == BIT_AND_EXPR
4716                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
4717     {
4718       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4719                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4720                        : TRUTH_XOR_EXPR,
4721                        type, arg0, arg1));
4722
4723       if (code == EQ_EXPR)
4724         t = invert_truthvalue (t);
4725
4726       return t;
4727     }
4728
4729   if (TREE_CODE_CLASS (code) == '1')
4730     {
4731       if (TREE_CODE (arg0) == COMPOUND_EXPR)
4732         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4733                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4734       else if (TREE_CODE (arg0) == COND_EXPR)
4735         {
4736           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4737                            fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
4738                            fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
4739
4740           /* If this was a conversion, and all we did was to move into
4741              inside the COND_EXPR, bring it back out.  But leave it if
4742              it is a conversion from integer to integer and the
4743              result precision is no wider than a word since such a
4744              conversion is cheap and may be optimized away by combine,
4745              while it couldn't if it were outside the COND_EXPR.  Then return
4746              so we don't get into an infinite recursion loop taking the
4747              conversion out and then back in.  */
4748
4749           if ((code == NOP_EXPR || code == CONVERT_EXPR
4750                || code == NON_LVALUE_EXPR)
4751               && TREE_CODE (t) == COND_EXPR
4752               && TREE_CODE (TREE_OPERAND (t, 1)) == code
4753               && TREE_CODE (TREE_OPERAND (t, 2)) == code
4754               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4755                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4756               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4757                     && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)))
4758                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4759             t = build1 (code, type,
4760                         build (COND_EXPR,
4761                                TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)),
4762                                TREE_OPERAND (t, 0),
4763                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4764                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4765           return t;
4766         }
4767       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4768         return fold (build (COND_EXPR, type, arg0,
4769                             fold (build1 (code, type, integer_one_node)),
4770                             fold (build1 (code, type, integer_zero_node))));
4771    }
4772   else if (TREE_CODE_CLASS (code) == '2'
4773            || TREE_CODE_CLASS (code) == '<')
4774     {
4775       if (TREE_CODE (arg1) == COMPOUND_EXPR)
4776         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4777                       fold (build (code, type,
4778                                    arg0, TREE_OPERAND (arg1, 1))));
4779       else if ((TREE_CODE (arg1) == COND_EXPR
4780                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4781                     && TREE_CODE_CLASS (code) != '<'))
4782                && (TREE_CODE (arg0) != COND_EXPR
4783                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4784                && (! TREE_SIDE_EFFECTS (arg0)
4785                    || (global_bindings_p () == 0
4786                        && ! contains_placeholder_p (arg0))))
4787         {
4788           tree test, true_value, false_value;
4789           tree lhs = 0, rhs = 0;
4790
4791           if (TREE_CODE (arg1) == COND_EXPR)
4792             {
4793               test = TREE_OPERAND (arg1, 0);
4794               true_value = TREE_OPERAND (arg1, 1);
4795               false_value = TREE_OPERAND (arg1, 2);
4796             }
4797           else
4798             {
4799               tree testtype = TREE_TYPE (arg1);
4800               test = arg1;
4801               true_value = convert (testtype, integer_one_node);
4802               false_value = convert (testtype, integer_zero_node);
4803             }
4804
4805           /* If ARG0 is complex we want to make sure we only evaluate
4806              it once.  Though this is only required if it is volatile, it
4807              might be more efficient even if it is not.  However, if we
4808              succeed in folding one part to a constant, we do not need
4809              to make this SAVE_EXPR.  Since we do this optimization
4810              primarily to see if we do end up with constant and this
4811              SAVE_EXPR interferes with later optimizations, suppressing
4812              it when we can is important.
4813
4814              If we are not in a function, we can't make a SAVE_EXPR, so don't
4815              try to do so.  Don't try to see if the result is a constant
4816              if an arm is a COND_EXPR since we get exponential behavior
4817              in that case.  */
4818
4819           if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4820               && global_bindings_p () == 0
4821               && ((TREE_CODE (arg0) != VAR_DECL
4822                    && TREE_CODE (arg0) != PARM_DECL)
4823                   || TREE_SIDE_EFFECTS (arg0)))
4824             {
4825               if (TREE_CODE (true_value) != COND_EXPR)
4826                 lhs = fold (build (code, type, arg0, true_value));
4827
4828               if (TREE_CODE (false_value) != COND_EXPR)
4829                 rhs = fold (build (code, type, arg0, false_value));
4830
4831               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4832                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
4833                 arg0 = save_expr (arg0), lhs = rhs = 0;
4834             }
4835
4836           if (lhs == 0)
4837             lhs = fold (build (code, type, arg0, true_value));
4838           if (rhs == 0)
4839             rhs = fold (build (code, type, arg0, false_value));
4840
4841           test = fold (build (COND_EXPR, type, test, lhs, rhs));
4842
4843           if (TREE_CODE (arg0) == SAVE_EXPR)
4844             return build (COMPOUND_EXPR, type,
4845                           convert (void_type_node, arg0),
4846                           strip_compound_expr (test, arg0));
4847           else
4848             return convert (type, test);
4849         }
4850
4851       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4852         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4853                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4854       else if ((TREE_CODE (arg0) == COND_EXPR
4855                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4856                     && TREE_CODE_CLASS (code) != '<'))
4857                && (TREE_CODE (arg1) != COND_EXPR
4858                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4859                && (! TREE_SIDE_EFFECTS (arg1)
4860                    || (global_bindings_p () == 0
4861                        && ! contains_placeholder_p (arg1))))
4862         {
4863           tree test, true_value, false_value;
4864           tree lhs = 0, rhs = 0;
4865
4866           if (TREE_CODE (arg0) == COND_EXPR)
4867             {
4868               test = TREE_OPERAND (arg0, 0);
4869               true_value = TREE_OPERAND (arg0, 1);
4870               false_value = TREE_OPERAND (arg0, 2);
4871             }
4872           else
4873             {
4874               tree testtype = TREE_TYPE (arg0);
4875               test = arg0;
4876               true_value = convert (testtype, integer_one_node);
4877               false_value = convert (testtype, integer_zero_node);
4878             }
4879
4880           if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4881               && global_bindings_p () == 0
4882               && ((TREE_CODE (arg1) != VAR_DECL
4883                    && TREE_CODE (arg1) != PARM_DECL)
4884                   || TREE_SIDE_EFFECTS (arg1)))
4885             {
4886               if (TREE_CODE (true_value) != COND_EXPR)
4887                 lhs = fold (build (code, type, true_value, arg1));
4888
4889               if (TREE_CODE (false_value) != COND_EXPR)
4890                 rhs = fold (build (code, type, false_value, arg1));
4891
4892               if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4893                   && (rhs == 0 || !TREE_CONSTANT (rhs)))
4894                 arg1 = save_expr (arg1), lhs = rhs = 0;
4895             }
4896
4897           if (lhs == 0)
4898             lhs = fold (build (code, type, true_value, arg1));
4899
4900           if (rhs == 0)
4901             rhs = fold (build (code, type, false_value, arg1));
4902
4903           test = fold (build (COND_EXPR, type, test, lhs, rhs));
4904           if (TREE_CODE (arg1) == SAVE_EXPR)
4905             return build (COMPOUND_EXPR, type,
4906                           convert (void_type_node, arg1),
4907                           strip_compound_expr (test, arg1));
4908           else
4909             return convert (type, test);
4910         }
4911     }
4912   else if (TREE_CODE_CLASS (code) == '<'
4913            && TREE_CODE (arg0) == COMPOUND_EXPR)
4914     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4915                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4916   else if (TREE_CODE_CLASS (code) == '<'
4917            && TREE_CODE (arg1) == COMPOUND_EXPR)
4918     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4919                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4920
4921   switch (code)
4922     {
4923     case INTEGER_CST:
4924     case REAL_CST:
4925     case STRING_CST:
4926     case COMPLEX_CST:
4927     case CONSTRUCTOR:
4928       return t;
4929
4930     case CONST_DECL:
4931       return fold (DECL_INITIAL (t));
4932
4933     case NOP_EXPR:
4934     case FLOAT_EXPR:
4935     case CONVERT_EXPR:
4936     case FIX_TRUNC_EXPR:
4937       /* Other kinds of FIX are not handled properly by fold_convert.  */
4938
4939       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4940         return TREE_OPERAND (t, 0);
4941
4942       /* Handle cases of two conversions in a row.  */
4943       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4944           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4945         {
4946           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4947           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4948           tree final_type = TREE_TYPE (t);
4949           int inside_int = INTEGRAL_TYPE_P (inside_type);
4950           int inside_ptr = POINTER_TYPE_P (inside_type);
4951           int inside_float = FLOAT_TYPE_P (inside_type);
4952           int inside_prec = TYPE_PRECISION (inside_type);
4953           int inside_unsignedp = TREE_UNSIGNED (inside_type);
4954           int inter_int = INTEGRAL_TYPE_P (inter_type);
4955           int inter_ptr = POINTER_TYPE_P (inter_type);
4956           int inter_float = FLOAT_TYPE_P (inter_type);
4957           int inter_prec = TYPE_PRECISION (inter_type);
4958           int inter_unsignedp = TREE_UNSIGNED (inter_type);
4959           int final_int = INTEGRAL_TYPE_P (final_type);
4960           int final_ptr = POINTER_TYPE_P (final_type);
4961           int final_float = FLOAT_TYPE_P (final_type);
4962           int final_prec = TYPE_PRECISION (final_type);
4963           int final_unsignedp = TREE_UNSIGNED (final_type);
4964
4965           /* In addition to the cases of two conversions in a row
4966              handled below, if we are converting something to its own
4967              type via an object of identical or wider precision, neither
4968              conversion is needed.  */
4969           if (inside_type == final_type
4970               && ((inter_int && final_int) || (inter_float && final_float))
4971               && inter_prec >= final_prec)
4972             return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
4973
4974           /* Likewise, if the intermediate and final types are either both
4975              float or both integer, we don't need the middle conversion if
4976              it is wider than the final type and doesn't change the signedness
4977              (for integers).  Avoid this if the final type is a pointer
4978              since then we sometimes need the inner conversion.  Likewise if
4979              the outer has a precision not equal to the size of its mode.  */
4980           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4981                || (inter_float && inside_float))
4982               && inter_prec >= inside_prec
4983               && (inter_float || inter_unsignedp == inside_unsignedp)
4984               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4985                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4986               && ! final_ptr)
4987             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4988
4989           /* If we have a sign-extension of a zero-extended value, we can
4990              replace that by a single zero-extension.  */
4991           if (inside_int && inter_int && final_int
4992               && inside_prec < inter_prec && inter_prec < final_prec
4993               && inside_unsignedp && !inter_unsignedp)
4994             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4995
4996           /* Two conversions in a row are not needed unless:
4997              - some conversion is floating-point (overstrict for now), or
4998              - the intermediate type is narrower than both initial and
4999                final, or
5000              - the intermediate type and innermost type differ in signedness,
5001                and the outermost type is wider than the intermediate, or
5002              - the initial type is a pointer type and the precisions of the
5003                intermediate and final types differ, or
5004              - the final type is a pointer type and the precisions of the
5005                initial and intermediate types differ.  */
5006           if (! inside_float && ! inter_float && ! final_float
5007               && (inter_prec > inside_prec || inter_prec > final_prec)
5008               && ! (inside_int && inter_int
5009                     && inter_unsignedp != inside_unsignedp
5010                     && inter_prec < final_prec)
5011               && ((inter_unsignedp && inter_prec > inside_prec)
5012                   == (final_unsignedp && final_prec > inter_prec))
5013               && ! (inside_ptr && inter_prec != final_prec)
5014               && ! (final_ptr && inside_prec != inter_prec)
5015               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5016                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5017               && ! final_ptr)
5018             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5019         }
5020
5021       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5022           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5023           /* Detect assigning a bitfield.  */
5024           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5025                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5026         {
5027           /* Don't leave an assignment inside a conversion
5028              unless assigning a bitfield.  */
5029           tree prev = TREE_OPERAND (t, 0);
5030           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5031           /* First do the assignment, then return converted constant.  */
5032           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5033           TREE_USED (t) = 1;
5034           return t;
5035         }
5036       if (!wins)
5037         {
5038           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5039           return t;
5040         }
5041       return fold_convert (t, arg0);
5042
5043 #if 0  /* This loses on &"foo"[0].  */
5044     case ARRAY_REF:
5045         {
5046           int i;
5047
5048           /* Fold an expression like: "foo"[2] */
5049           if (TREE_CODE (arg0) == STRING_CST
5050               && TREE_CODE (arg1) == INTEGER_CST
5051               && !TREE_INT_CST_HIGH (arg1)
5052               && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
5053             {
5054               t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
5055               TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
5056               force_fit_type (t, 0);
5057             }
5058         }
5059       return t;
5060 #endif /* 0 */
5061
5062     case COMPONENT_REF:
5063       if (TREE_CODE (arg0) == CONSTRUCTOR)
5064         {
5065           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5066           if (m)
5067             t = TREE_VALUE (m);
5068         }
5069       return t;
5070
5071     case RANGE_EXPR:
5072       TREE_CONSTANT (t) = wins;
5073       return t;
5074
5075     case NEGATE_EXPR:
5076       if (wins)
5077         {
5078           if (TREE_CODE (arg0) == INTEGER_CST)
5079             {
5080               HOST_WIDE_INT low, high;
5081               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5082                                          TREE_INT_CST_HIGH (arg0),
5083                                          &low, &high);
5084               t = build_int_2 (low, high);
5085               TREE_TYPE (t) = type;
5086               TREE_OVERFLOW (t)
5087                 = (TREE_OVERFLOW (arg0)
5088                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5089               TREE_CONSTANT_OVERFLOW (t)
5090                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5091             }
5092           else if (TREE_CODE (arg0) == REAL_CST)
5093             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5094         }
5095       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5096         return TREE_OPERAND (arg0, 0);
5097
5098       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5099       else if (TREE_CODE (arg0) == MINUS_EXPR
5100                && (! FLOAT_TYPE_P (type) || flag_fast_math))
5101         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5102                       TREE_OPERAND (arg0, 0));
5103
5104       return t;
5105
5106     case ABS_EXPR:
5107       if (wins)
5108         {
5109           if (TREE_CODE (arg0) == INTEGER_CST)
5110             {
5111               if (! TREE_UNSIGNED (type)
5112                   && TREE_INT_CST_HIGH (arg0) < 0)
5113                 {
5114                   HOST_WIDE_INT low, high;
5115                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5116                                              TREE_INT_CST_HIGH (arg0),
5117                                              &low, &high);
5118                   t = build_int_2 (low, high);
5119                   TREE_TYPE (t) = type;
5120                   TREE_OVERFLOW (t)
5121                     = (TREE_OVERFLOW (arg0)
5122                        | force_fit_type (t, overflow));
5123                   TREE_CONSTANT_OVERFLOW (t)
5124                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5125                 }
5126             }
5127           else if (TREE_CODE (arg0) == REAL_CST)
5128             {
5129               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5130                 t = build_real (type,
5131                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5132             }
5133         }
5134       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5135         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5136       return t;
5137
5138     case CONJ_EXPR:
5139       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5140         return arg0;
5141       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5142         return build (COMPLEX_EXPR, TREE_TYPE (arg0),
5143                       TREE_OPERAND (arg0, 0),
5144                       negate_expr (TREE_OPERAND (arg0, 1)));
5145       else if (TREE_CODE (arg0) == COMPLEX_CST)
5146         return build_complex (type, TREE_OPERAND (arg0, 0),
5147                               negate_expr (TREE_OPERAND (arg0, 1)));
5148       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5149         return fold (build (TREE_CODE (arg0), type,
5150                             fold (build1 (CONJ_EXPR, type,
5151                                           TREE_OPERAND (arg0, 0))),
5152                             fold (build1 (CONJ_EXPR,
5153                                           type, TREE_OPERAND (arg0, 1)))));
5154       else if (TREE_CODE (arg0) == CONJ_EXPR)
5155         return TREE_OPERAND (arg0, 0);
5156       return t;
5157
5158     case BIT_NOT_EXPR:
5159       if (wins)
5160         {
5161           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5162                            ~ TREE_INT_CST_HIGH (arg0));
5163           TREE_TYPE (t) = type;
5164           force_fit_type (t, 0);
5165           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5166           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5167         }
5168       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5169         return TREE_OPERAND (arg0, 0);
5170       return t;
5171
5172     case PLUS_EXPR:
5173       /* A + (-B) -> A - B */
5174       if (TREE_CODE (arg1) == NEGATE_EXPR)
5175         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5176       /* (-A) + B -> B - A */
5177       if (TREE_CODE (arg0) == NEGATE_EXPR)
5178         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5179       else if (! FLOAT_TYPE_P (type))
5180         {
5181           if (integer_zerop (arg1))
5182             return non_lvalue (convert (type, arg0));
5183
5184           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5185              with a constant, and the two constants have no bits in common,
5186              we should treat this as a BIT_IOR_EXPR since this may produce more
5187              simplifications.  */
5188           if (TREE_CODE (arg0) == BIT_AND_EXPR
5189               && TREE_CODE (arg1) == BIT_AND_EXPR
5190               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5191               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5192               && integer_zerop (const_binop (BIT_AND_EXPR,
5193                                              TREE_OPERAND (arg0, 1),
5194                                              TREE_OPERAND (arg1, 1), 0)))
5195             {
5196               code = BIT_IOR_EXPR;
5197               goto bit_ior;
5198             }
5199
5200           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5201              (plus (plus (mult) (mult)) (foo)) so that we can
5202              take advantage of the factoring cases below.  */
5203           if ((TREE_CODE (arg0) == PLUS_EXPR
5204                && TREE_CODE (arg1) == MULT_EXPR)
5205               || (TREE_CODE (arg1) == PLUS_EXPR
5206                   && TREE_CODE (arg0) == MULT_EXPR))
5207             {
5208               tree parg0, parg1, parg, marg;
5209
5210               if (TREE_CODE (arg0) == PLUS_EXPR)
5211                 parg = arg0, marg = arg1;
5212               else
5213                 parg = arg1, marg = arg0;
5214               parg0 = TREE_OPERAND (parg, 0);
5215               parg1 = TREE_OPERAND (parg, 1);
5216               STRIP_NOPS (parg0);
5217               STRIP_NOPS (parg1);
5218
5219               if (TREE_CODE (parg0) == MULT_EXPR
5220                   && TREE_CODE (parg1) != MULT_EXPR)
5221                 return fold (build (PLUS_EXPR, type,
5222                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5223                                     parg1));
5224               if (TREE_CODE (parg0) != MULT_EXPR
5225                   && TREE_CODE (parg1) == MULT_EXPR)
5226                 return fold (build (PLUS_EXPR, type,
5227                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5228                                     parg0));
5229             }
5230
5231           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5232             {
5233               tree arg00, arg01, arg10, arg11;
5234               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5235
5236               /* (A * C) + (B * C) -> (A+B) * C.
5237                  We are most concerned about the case where C is a constant,
5238                  but other combinations show up during loop reduction.  Since
5239                  it is not difficult, try all four possibilities.  */
5240
5241               arg00 = TREE_OPERAND (arg0, 0);
5242               arg01 = TREE_OPERAND (arg0, 1);
5243               arg10 = TREE_OPERAND (arg1, 0);
5244               arg11 = TREE_OPERAND (arg1, 1);
5245               same = NULL_TREE;
5246
5247               if (operand_equal_p (arg01, arg11, 0))
5248                 same = arg01, alt0 = arg00, alt1 = arg10;
5249               else if (operand_equal_p (arg00, arg10, 0))
5250                 same = arg00, alt0 = arg01, alt1 = arg11;
5251               else if (operand_equal_p (arg00, arg11, 0))
5252                 same = arg00, alt0 = arg01, alt1 = arg10;
5253               else if (operand_equal_p (arg01, arg10, 0))
5254                 same = arg01, alt0 = arg00, alt1 = arg11;
5255
5256               /* No identical multiplicands; see if we can find a common
5257                  power-of-two factor in non-power-of-two multiplies.  This
5258                  can help in multi-dimensional array access.  */
5259               else if (TREE_CODE (arg01) == INTEGER_CST
5260                        && TREE_CODE (arg11) == INTEGER_CST
5261                        && TREE_INT_CST_HIGH (arg01) == 0
5262                        && TREE_INT_CST_HIGH (arg11) == 0)
5263                 {
5264                   HOST_WIDE_INT int01, int11, tmp;
5265                   int01 = TREE_INT_CST_LOW (arg01);
5266                   int11 = TREE_INT_CST_LOW (arg11);
5267
5268                   /* Move min of absolute values to int11.  */
5269                   if ((int01 >= 0 ? int01 : -int01)
5270                       < (int11 >= 0 ? int11 : -int11))
5271                     {
5272                       tmp = int01, int01 = int11, int11 = tmp;
5273                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5274                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5275                     }
5276
5277                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5278                     {
5279                       alt0 = fold (build (MULT_EXPR, type, arg00,
5280                                           build_int_2 (int01 / int11, 0)));
5281                       alt1 = arg10;
5282                       same = arg11;
5283                     }
5284                 }
5285
5286               if (same)
5287                 return fold (build (MULT_EXPR, type,
5288                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5289                                     same));
5290             }
5291         }
5292       /* In IEEE floating point, x+0 may not equal x.  */
5293       else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5294                 || flag_fast_math)
5295                && real_zerop (arg1))
5296         return non_lvalue (convert (type, arg0));
5297       /* x+(-0) equals x, even for IEEE.  */
5298       else if (TREE_CODE (arg1) == REAL_CST
5299                && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5300         return non_lvalue (convert (type, arg0));
5301
5302      bit_rotate:
5303       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5304          is a rotate of A by C1 bits.  */
5305       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5306          is a rotate of A by B bits.  */
5307       {
5308         register enum tree_code code0, code1;
5309         code0 = TREE_CODE (arg0);
5310         code1 = TREE_CODE (arg1);
5311         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5312             || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5313             && operand_equal_p (TREE_OPERAND (arg0, 0),
5314                                 TREE_OPERAND (arg1,0), 0)
5315             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5316           {
5317             register tree tree01, tree11;
5318             register enum tree_code code01, code11;
5319
5320             tree01 = TREE_OPERAND (arg0, 1);
5321             tree11 = TREE_OPERAND (arg1, 1);
5322             STRIP_NOPS (tree01);
5323             STRIP_NOPS (tree11);
5324             code01 = TREE_CODE (tree01);
5325             code11 = TREE_CODE (tree11);
5326             if (code01 == INTEGER_CST
5327               && code11 == INTEGER_CST
5328               && TREE_INT_CST_HIGH (tree01) == 0
5329               && TREE_INT_CST_HIGH (tree11) == 0
5330               && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5331                 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5332               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5333                         code0 == LSHIFT_EXPR ? tree01 : tree11);
5334             else if (code11 == MINUS_EXPR)
5335               {
5336                 tree tree110, tree111;
5337                 tree110 = TREE_OPERAND (tree11, 0);
5338                 tree111 = TREE_OPERAND (tree11, 1);
5339                 STRIP_NOPS (tree110);
5340                 STRIP_NOPS (tree111);
5341                 if (TREE_CODE (tree110) == INTEGER_CST
5342                     && TREE_INT_CST_HIGH (tree110) == 0
5343                     && (TREE_INT_CST_LOW (tree110)
5344                         == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5345                     && operand_equal_p (tree01, tree111, 0))
5346                   return build ((code0 == LSHIFT_EXPR
5347                                  ? LROTATE_EXPR
5348                                  : RROTATE_EXPR),
5349                                 type, TREE_OPERAND (arg0, 0), tree01);
5350               }
5351             else if (code01 == MINUS_EXPR)
5352               {
5353                 tree tree010, tree011;
5354                 tree010 = TREE_OPERAND (tree01, 0);
5355                 tree011 = TREE_OPERAND (tree01, 1);
5356                 STRIP_NOPS (tree010);
5357                 STRIP_NOPS (tree011);
5358                 if (TREE_CODE (tree010) == INTEGER_CST
5359                     && TREE_INT_CST_HIGH (tree010) == 0
5360                     && (TREE_INT_CST_LOW (tree010)
5361                         == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5362                     && operand_equal_p (tree11, tree011, 0))
5363                   return build ((code0 != LSHIFT_EXPR
5364                                  ? LROTATE_EXPR
5365                                  : RROTATE_EXPR),
5366                                  type, TREE_OPERAND (arg0, 0), tree11);
5367               }
5368           }
5369       }
5370
5371
5372     associate:
5373       /* In most languages, can't associate operations on floats through
5374          parentheses.  Rather than remember where the parentheses were, we
5375          don't associate floats at all.  It shouldn't matter much.  However,
5376          associating multiplications is only very slightly inaccurate, so do
5377          that if -ffast-math is specified.  */
5378
5379       if (! wins
5380           && (! FLOAT_TYPE_P (type)
5381               || (flag_fast_math && code != MULT_EXPR)))
5382         {
5383           tree var0, con0, lit0, var1, con1, lit1;
5384
5385           /* Split both trees into variables, constants, and literals.  Then
5386              associate each group together, the constants with literals,
5387              then the result with variables.  This increases the chances of
5388              literals being recombined later and of generating relocatable
5389              expressions for the sum of a constant and literal. */
5390           var0 = split_tree (arg0, code, &con0, &lit0, 0);
5391           var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
5392
5393           /* Only do something if we found more than two objects.  Otherwise,
5394              nothing has changed and we risk infinite recursion.  */
5395           if (2 < ((var0 != 0) + (var1 != 0) + (con0 != 0) + (con1 != 0)
5396                    + (lit0 != 0) + (lit1 != 0)))
5397             {
5398               var0 = associate_trees (var0, var1, code, type);
5399               con0 = associate_trees (con0, con1, code, type);
5400               lit0 = associate_trees (lit0, lit1, code, type);
5401               con0 = associate_trees (con0, lit0, code, type);
5402               return convert (type, associate_trees (var0, con0, code, type));
5403             }
5404         }
5405
5406     binary:
5407 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
5408       if (TREE_CODE (arg1) == REAL_CST)
5409         return t;
5410 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
5411       if (wins)
5412         t1 = const_binop (code, arg0, arg1, 0);
5413       if (t1 != NULL_TREE)
5414         {
5415           /* The return value should always have
5416              the same type as the original expression.  */
5417           if (TREE_TYPE (t1) != TREE_TYPE (t))
5418             t1 = convert (TREE_TYPE (t), t1);
5419
5420           return t1;
5421         }
5422       return t;
5423
5424     case MINUS_EXPR:
5425       /* A - (-B) -> A + B */
5426       if (TREE_CODE (arg1) == NEGATE_EXPR)
5427         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5428       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5429       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5430         return
5431           fold (build (MINUS_EXPR, type,
5432                        build_real (TREE_TYPE (arg1),
5433                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5434                        TREE_OPERAND (arg0, 0)));
5435
5436       if (! FLOAT_TYPE_P (type))
5437         {
5438           if (! wins && integer_zerop (arg0))
5439             return negate_expr (arg1);
5440           if (integer_zerop (arg1))
5441             return non_lvalue (convert (type, arg0));
5442
5443           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5444              about the case where C is a constant, just try one of the
5445              four possibilities.  */
5446
5447           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5448               && operand_equal_p (TREE_OPERAND (arg0, 1),
5449                                   TREE_OPERAND (arg1, 1), 0))
5450             return fold (build (MULT_EXPR, type,
5451                                 fold (build (MINUS_EXPR, type,
5452                                              TREE_OPERAND (arg0, 0),
5453                                              TREE_OPERAND (arg1, 0))),
5454                                 TREE_OPERAND (arg0, 1)));
5455         }
5456
5457       else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5458                || flag_fast_math)
5459         {
5460           /* Except with IEEE floating point, 0-x equals -x.  */
5461           if (! wins && real_zerop (arg0))
5462             return negate_expr (arg1);
5463           /* Except with IEEE floating point, x-0 equals x.  */
5464           if (real_zerop (arg1))
5465             return non_lvalue (convert (type, arg0));
5466         }
5467
5468       /* Fold &x - &x.  This can happen from &x.foo - &x.
5469          This is unsafe for certain floats even in non-IEEE formats.
5470          In IEEE, it is unsafe because it does wrong for NaNs.
5471          Also note that operand_equal_p is always false if an operand
5472          is volatile.  */
5473
5474       if ((! FLOAT_TYPE_P (type) || flag_fast_math)
5475           && operand_equal_p (arg0, arg1, 0))
5476         return convert (type, integer_zero_node);
5477
5478       goto associate;
5479
5480     case MULT_EXPR:
5481       /* (-A) * (-B) -> A * B  */
5482       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5483         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5484                             TREE_OPERAND (arg1, 0)));
5485
5486       if (! FLOAT_TYPE_P (type))
5487         {
5488           if (integer_zerop (arg1))
5489             return omit_one_operand (type, arg1, arg0);
5490           if (integer_onep (arg1))
5491             return non_lvalue (convert (type, arg0));
5492
5493           /* (a * (1 << b)) is (a << b)  */
5494           if (TREE_CODE (arg1) == LSHIFT_EXPR
5495               && integer_onep (TREE_OPERAND (arg1, 0)))
5496             return fold (build (LSHIFT_EXPR, type, arg0,
5497                                 TREE_OPERAND (arg1, 1)));
5498           if (TREE_CODE (arg0) == LSHIFT_EXPR
5499               && integer_onep (TREE_OPERAND (arg0, 0)))
5500             return fold (build (LSHIFT_EXPR, type, arg1,
5501                                 TREE_OPERAND (arg0, 1)));
5502
5503           if (TREE_CODE (arg1) == INTEGER_CST
5504               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5505                                              code, NULL_TREE)))
5506             return convert (type, tem);
5507
5508         }
5509       else
5510         {
5511           /* x*0 is 0, except for IEEE floating point.  */
5512           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5513                || flag_fast_math)
5514               && real_zerop (arg1))
5515             return omit_one_operand (type, arg1, arg0);
5516           /* In IEEE floating point, x*1 is not equivalent to x for snans.
5517              However, ANSI says we can drop signals,
5518              so we can do this anyway.  */
5519           if (real_onep (arg1))
5520             return non_lvalue (convert (type, arg0));
5521           /* x*2 is x+x */
5522           if (! wins && real_twop (arg1) && global_bindings_p () == 0
5523               && ! contains_placeholder_p (arg0))
5524             {
5525               tree arg = save_expr (arg0);
5526               return build (PLUS_EXPR, type, arg, arg);
5527             }
5528         }
5529       goto associate;
5530
5531     case BIT_IOR_EXPR:
5532     bit_ior:
5533       if (integer_all_onesp (arg1))
5534         return omit_one_operand (type, arg1, arg0);
5535       if (integer_zerop (arg1))
5536         return non_lvalue (convert (type, arg0));
5537       t1 = distribute_bit_expr (code, type, arg0, arg1);
5538       if (t1 != NULL_TREE)
5539         return t1;
5540
5541       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5542
5543          This results in more efficient code for machines without a NAND
5544          instruction.  Combine will canonicalize to the first form
5545          which will allow use of NAND instructions provided by the
5546          backend if they exist.  */
5547       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5548           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5549         {
5550           return fold (build1 (BIT_NOT_EXPR, type,
5551                                build (BIT_AND_EXPR, type,
5552                                       TREE_OPERAND (arg0, 0),
5553                                       TREE_OPERAND (arg1, 0))));
5554         }
5555
5556       /* See if this can be simplified into a rotate first.  If that
5557          is unsuccessful continue in the association code.  */
5558       goto bit_rotate;
5559
5560     case BIT_XOR_EXPR:
5561       if (integer_zerop (arg1))
5562         return non_lvalue (convert (type, arg0));
5563       if (integer_all_onesp (arg1))
5564         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5565
5566       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5567          with a constant, and the two constants have no bits in common,
5568          we should treat this as a BIT_IOR_EXPR since this may produce more
5569          simplifications.  */
5570       if (TREE_CODE (arg0) == BIT_AND_EXPR
5571           && TREE_CODE (arg1) == BIT_AND_EXPR
5572           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5573           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5574           && integer_zerop (const_binop (BIT_AND_EXPR,
5575                                          TREE_OPERAND (arg0, 1),
5576                                          TREE_OPERAND (arg1, 1), 0)))
5577         {
5578            code = BIT_IOR_EXPR;
5579            goto bit_ior;
5580         }
5581
5582       /* See if this can be simplified into a rotate first.  If that
5583          is unsuccessful continue in the association code.  */
5584       goto bit_rotate;
5585
5586     case BIT_AND_EXPR:
5587     bit_and:
5588       if (integer_all_onesp (arg1))
5589         return non_lvalue (convert (type, arg0));
5590       if (integer_zerop (arg1))
5591         return omit_one_operand (type, arg1, arg0);
5592       t1 = distribute_bit_expr (code, type, arg0, arg1);
5593       if (t1 != NULL_TREE)
5594         return t1;
5595       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5596       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5597           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5598         {
5599           int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5600           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5601               && (~TREE_INT_CST_LOW (arg0)
5602                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5603             return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5604         }
5605       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5606           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5607         {
5608           int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5609           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5610               && (~TREE_INT_CST_LOW (arg1)
5611                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5612             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5613         }
5614
5615       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5616
5617          This results in more efficient code for machines without a NOR
5618          instruction.  Combine will canonicalize to the first form
5619          which will allow use of NOR instructions provided by the
5620          backend if they exist.  */
5621       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5622           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5623         {
5624           return fold (build1 (BIT_NOT_EXPR, type,
5625                                build (BIT_IOR_EXPR, type,
5626                                       TREE_OPERAND (arg0, 0),
5627                                       TREE_OPERAND (arg1, 0))));
5628         }
5629
5630       goto associate;
5631
5632     case BIT_ANDTC_EXPR:
5633       if (integer_all_onesp (arg0))
5634         return non_lvalue (convert (type, arg1));
5635       if (integer_zerop (arg0))
5636         return omit_one_operand (type, arg0, arg1);
5637       if (TREE_CODE (arg1) == INTEGER_CST)
5638         {
5639           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5640           code = BIT_AND_EXPR;
5641           goto bit_and;
5642         }
5643       goto binary;
5644
5645     case RDIV_EXPR:
5646       /* In most cases, do nothing with a divide by zero.  */
5647 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5648 #ifndef REAL_INFINITY
5649       if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5650         return t;
5651 #endif
5652 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5653
5654       /* (-A) / (-B) -> A / B  */
5655       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5656         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5657                             TREE_OPERAND (arg1, 0)));
5658
5659       /* In IEEE floating point, x/1 is not equivalent to x for snans.
5660          However, ANSI says we can drop signals, so we can do this anyway.  */
5661       if (real_onep (arg1))
5662         return non_lvalue (convert (type, arg0));
5663
5664       /* If ARG1 is a constant, we can convert this to a multiply by the
5665          reciprocal.  This does not have the same rounding properties,
5666          so only do this if -ffast-math.  We can actually always safely
5667          do it if ARG1 is a power of two, but it's hard to tell if it is
5668          or not in a portable manner.  */
5669       if (TREE_CODE (arg1) == REAL_CST)
5670         {
5671           if (flag_fast_math
5672               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5673                                           arg1, 0)))
5674             return fold (build (MULT_EXPR, type, arg0, tem));
5675           /* Find the reciprocal if optimizing and the result is exact. */
5676           else if (optimize)
5677             {
5678               REAL_VALUE_TYPE r;
5679               r = TREE_REAL_CST (arg1);
5680               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5681                   {
5682                     tem = build_real (type, r);
5683                     return fold (build (MULT_EXPR, type, arg0, tem));
5684                   }
5685             }
5686         }
5687       goto binary;
5688
5689     case TRUNC_DIV_EXPR:
5690     case ROUND_DIV_EXPR:
5691     case FLOOR_DIV_EXPR:
5692     case CEIL_DIV_EXPR:
5693     case EXACT_DIV_EXPR:
5694       if (integer_onep (arg1))
5695         return non_lvalue (convert (type, arg0));
5696       if (integer_zerop (arg1))
5697         return t;
5698
5699       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5700          operation, EXACT_DIV_EXPR.
5701
5702          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5703          At one time others generated faster code, it's not clear if they do
5704          after the last round to changes to the DIV code in expmed.c.  */
5705       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5706           && multiple_of_p (type, arg0, arg1))
5707         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5708
5709         if (TREE_CODE (arg1) == INTEGER_CST
5710           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5711                                          code, NULL_TREE)))
5712         return convert (type, tem);
5713
5714       goto binary;
5715
5716     case CEIL_MOD_EXPR:
5717     case FLOOR_MOD_EXPR:
5718     case ROUND_MOD_EXPR:
5719     case TRUNC_MOD_EXPR:
5720       if (integer_onep (arg1))
5721         return omit_one_operand (type, integer_zero_node, arg0);
5722       if (integer_zerop (arg1))
5723         return t;
5724
5725       if (TREE_CODE (arg1) == INTEGER_CST
5726           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5727                                          code, NULL_TREE)))
5728         return convert (type, tem);
5729
5730       goto binary;
5731
5732     case LSHIFT_EXPR:
5733     case RSHIFT_EXPR:
5734     case LROTATE_EXPR:
5735     case RROTATE_EXPR:
5736       if (integer_zerop (arg1))
5737         return non_lvalue (convert (type, arg0));
5738       /* Since negative shift count is not well-defined,
5739          don't try to compute it in the compiler.  */
5740       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5741         return t;
5742       /* Rewrite an LROTATE_EXPR by a constant into an
5743          RROTATE_EXPR by a new constant.  */
5744       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5745         {
5746           TREE_SET_CODE (t, RROTATE_EXPR);
5747           code = RROTATE_EXPR;
5748           TREE_OPERAND (t, 1) = arg1
5749             = const_binop
5750               (MINUS_EXPR,
5751                convert (TREE_TYPE (arg1),
5752                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5753                arg1, 0);
5754           if (tree_int_cst_sgn (arg1) < 0)
5755             return t;
5756         }
5757
5758       /* If we have a rotate of a bit operation with the rotate count and
5759          the second operand of the bit operation both constant,
5760          permute the two operations.  */
5761       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5762           && (TREE_CODE (arg0) == BIT_AND_EXPR
5763               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5764               || TREE_CODE (arg0) == BIT_IOR_EXPR
5765               || TREE_CODE (arg0) == BIT_XOR_EXPR)
5766           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5767         return fold (build (TREE_CODE (arg0), type,
5768                             fold (build (code, type,
5769                                          TREE_OPERAND (arg0, 0), arg1)),
5770                             fold (build (code, type,
5771                                          TREE_OPERAND (arg0, 1), arg1))));
5772
5773       /* Two consecutive rotates adding up to the width of the mode can
5774          be ignored.  */
5775       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5776           && TREE_CODE (arg0) == RROTATE_EXPR
5777           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5778           && TREE_INT_CST_HIGH (arg1) == 0
5779           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5780           && ((TREE_INT_CST_LOW (arg1)
5781                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5782               == GET_MODE_BITSIZE (TYPE_MODE (type))))
5783         return TREE_OPERAND (arg0, 0);
5784
5785       goto binary;
5786
5787     case MIN_EXPR:
5788       if (operand_equal_p (arg0, arg1, 0))
5789         return arg0;
5790       if (INTEGRAL_TYPE_P (type)
5791           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5792         return omit_one_operand (type, arg1, arg0);
5793       goto associate;
5794
5795     case MAX_EXPR:
5796       if (operand_equal_p (arg0, arg1, 0))
5797         return arg0;
5798       if (INTEGRAL_TYPE_P (type)
5799           && TYPE_MAX_VALUE (type)
5800           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5801         return omit_one_operand (type, arg1, arg0);
5802       goto associate;
5803
5804     case TRUTH_NOT_EXPR:
5805       /* Note that the operand of this must be an int
5806          and its values must be 0 or 1.
5807          ("true" is a fixed value perhaps depending on the language,
5808          but we don't handle values other than 1 correctly yet.)  */
5809       tem = invert_truthvalue (arg0);
5810       /* Avoid infinite recursion.  */
5811       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5812         return t;
5813       return convert (type, tem);
5814
5815     case TRUTH_ANDIF_EXPR:
5816       /* Note that the operands of this must be ints
5817          and their values must be 0 or 1.
5818          ("true" is a fixed value perhaps depending on the language.)  */
5819       /* If first arg is constant zero, return it.  */
5820       if (integer_zerop (arg0))
5821         return arg0;
5822     case TRUTH_AND_EXPR:
5823       /* If either arg is constant true, drop it.  */
5824       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5825         return non_lvalue (arg1);
5826       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5827         return non_lvalue (arg0);
5828       /* If second arg is constant zero, result is zero, but first arg
5829          must be evaluated.  */
5830       if (integer_zerop (arg1))
5831         return omit_one_operand (type, arg1, arg0);
5832       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5833          case will be handled here.  */
5834       if (integer_zerop (arg0))
5835         return omit_one_operand (type, arg0, arg1);
5836
5837     truth_andor:
5838       /* We only do these simplifications if we are optimizing.  */
5839       if (!optimize)
5840         return t;
5841
5842       /* Check for things like (A || B) && (A || C).  We can convert this
5843          to A || (B && C).  Note that either operator can be any of the four
5844          truth and/or operations and the transformation will still be
5845          valid.   Also note that we only care about order for the
5846          ANDIF and ORIF operators.  If B contains side effects, this
5847          might change the truth-value of A. */
5848       if (TREE_CODE (arg0) == TREE_CODE (arg1)
5849           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5850               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5851               || TREE_CODE (arg0) == TRUTH_AND_EXPR
5852               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5853           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5854         {
5855           tree a00 = TREE_OPERAND (arg0, 0);
5856           tree a01 = TREE_OPERAND (arg0, 1);
5857           tree a10 = TREE_OPERAND (arg1, 0);
5858           tree a11 = TREE_OPERAND (arg1, 1);
5859           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5860                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5861                              && (code == TRUTH_AND_EXPR
5862                                  || code == TRUTH_OR_EXPR));
5863
5864           if (operand_equal_p (a00, a10, 0))
5865             return fold (build (TREE_CODE (arg0), type, a00,
5866                                 fold (build (code, type, a01, a11))));
5867           else if (commutative && operand_equal_p (a00, a11, 0))
5868             return fold (build (TREE_CODE (arg0), type, a00,
5869                                 fold (build (code, type, a01, a10))));
5870           else if (commutative && operand_equal_p (a01, a10, 0))
5871             return fold (build (TREE_CODE (arg0), type, a01,
5872                                 fold (build (code, type, a00, a11))));
5873
5874           /* This case if tricky because we must either have commutative
5875              operators or else A10 must not have side-effects.  */
5876
5877           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5878                    && operand_equal_p (a01, a11, 0))
5879             return fold (build (TREE_CODE (arg0), type,
5880                                 fold (build (code, type, a00, a10)),
5881                                 a01));
5882         }
5883
5884       /* See if we can build a range comparison.  */
5885       if (0 != (tem = fold_range_test (t)))
5886         return tem;
5887
5888       /* Check for the possibility of merging component references.  If our
5889          lhs is another similar operation, try to merge its rhs with our
5890          rhs.  Then try to merge our lhs and rhs.  */
5891       if (TREE_CODE (arg0) == code
5892           && 0 != (tem = fold_truthop (code, type,
5893                                        TREE_OPERAND (arg0, 1), arg1)))
5894         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5895
5896       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5897         return tem;
5898
5899       return t;
5900
5901     case TRUTH_ORIF_EXPR:
5902       /* Note that the operands of this must be ints
5903          and their values must be 0 or true.
5904          ("true" is a fixed value perhaps depending on the language.)  */
5905       /* If first arg is constant true, return it.  */
5906       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5907         return arg0;
5908     case TRUTH_OR_EXPR:
5909       /* If either arg is constant zero, drop it.  */
5910       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5911         return non_lvalue (arg1);
5912       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
5913         return non_lvalue (arg0);
5914       /* If second arg is constant true, result is true, but we must
5915          evaluate first arg.  */
5916       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5917         return omit_one_operand (type, arg1, arg0);
5918       /* Likewise for first arg, but note this only occurs here for
5919          TRUTH_OR_EXPR.  */
5920       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5921         return omit_one_operand (type, arg0, arg1);
5922       goto truth_andor;
5923
5924     case TRUTH_XOR_EXPR:
5925       /* If either arg is constant zero, drop it.  */
5926       if (integer_zerop (arg0))
5927         return non_lvalue (arg1);
5928       if (integer_zerop (arg1))
5929         return non_lvalue (arg0);
5930       /* If either arg is constant true, this is a logical inversion.  */
5931       if (integer_onep (arg0))
5932         return non_lvalue (invert_truthvalue (arg1));
5933       if (integer_onep (arg1))
5934         return non_lvalue (invert_truthvalue (arg0));
5935       return t;
5936
5937     case EQ_EXPR:
5938     case NE_EXPR:
5939     case LT_EXPR:
5940     case GT_EXPR:
5941     case LE_EXPR:
5942     case GE_EXPR:
5943       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
5944         {
5945           /* (-a) CMP (-b) -> b CMP a  */
5946           if (TREE_CODE (arg0) == NEGATE_EXPR
5947               && TREE_CODE (arg1) == NEGATE_EXPR)
5948             return fold (build (code, type, TREE_OPERAND (arg1, 0),
5949                                 TREE_OPERAND (arg0, 0)));
5950           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
5951           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5952             return
5953               fold (build
5954                      (swap_tree_comparison (code), type,
5955                       TREE_OPERAND (arg0, 0),
5956                       build_real (TREE_TYPE (arg1),
5957                                   REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
5958           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
5959           /* a CMP (-0) -> a CMP 0  */
5960           if (TREE_CODE (arg1) == REAL_CST
5961               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5962             return fold (build (code, type, arg0,
5963                                 build_real (TREE_TYPE (arg1), dconst0)));
5964         }
5965
5966
5967       /* If one arg is a constant integer, put it last.  */
5968       if (TREE_CODE (arg0) == INTEGER_CST
5969           && TREE_CODE (arg1) != INTEGER_CST)
5970         {
5971           TREE_OPERAND (t, 0) = arg1;
5972           TREE_OPERAND (t, 1) = arg0;
5973           arg0 = TREE_OPERAND (t, 0);
5974           arg1 = TREE_OPERAND (t, 1);
5975           code = swap_tree_comparison (code);
5976           TREE_SET_CODE (t, code);
5977         }
5978
5979       /* Convert foo++ == CONST into ++foo == CONST + INCR.
5980          First, see if one arg is constant; find the constant arg
5981          and the other one.  */
5982       {
5983         tree constop = 0, varop = NULL_TREE;
5984         int constopnum = -1;
5985
5986         if (TREE_CONSTANT (arg1))
5987           constopnum = 1, constop = arg1, varop = arg0;
5988         if (TREE_CONSTANT (arg0))
5989           constopnum = 0, constop = arg0, varop = arg1;
5990
5991         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5992           {
5993             /* This optimization is invalid for ordered comparisons
5994                if CONST+INCR overflows or if foo+incr might overflow.
5995                This optimization is invalid for floating point due to rounding.
5996                For pointer types we assume overflow doesn't happen.  */
5997             if (POINTER_TYPE_P (TREE_TYPE (varop))
5998                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5999                     && (code == EQ_EXPR || code == NE_EXPR)))
6000               {
6001                 tree newconst
6002                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6003                                  constop, TREE_OPERAND (varop, 1)));
6004                 TREE_SET_CODE (varop, PREINCREMENT_EXPR);
6005
6006                 /* If VAROP is a reference to a bitfield, we must mask
6007                    the constant by the width of the field.  */
6008                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6009                     && DECL_BIT_FIELD(TREE_OPERAND
6010                                       (TREE_OPERAND (varop, 0), 1)))
6011                   {
6012                     int size
6013                       = TREE_INT_CST_LOW (DECL_SIZE
6014                                           (TREE_OPERAND
6015                                            (TREE_OPERAND (varop, 0), 1)));
6016                     tree mask, unsigned_type;
6017                     int precision;
6018                     tree folded_compare;
6019
6020                     /* First check whether the comparison would come out
6021                        always the same.  If we don't do that we would
6022                        change the meaning with the masking.  */
6023                     if (constopnum == 0)
6024                       folded_compare = fold (build (code, type, constop,
6025                                                     TREE_OPERAND (varop, 0)));
6026                     else
6027                       folded_compare = fold (build (code, type,
6028                                                     TREE_OPERAND (varop, 0),
6029                                                     constop));
6030                     if (integer_zerop (folded_compare)
6031                         || integer_onep (folded_compare))
6032                       return omit_one_operand (type, folded_compare, varop);
6033
6034                     unsigned_type = type_for_size (size, 1);
6035                     precision = TYPE_PRECISION (unsigned_type);
6036                     mask = build_int_2 (~0, ~0);
6037                     TREE_TYPE (mask) = unsigned_type;
6038                     force_fit_type (mask, 0);
6039                     mask = const_binop (RSHIFT_EXPR, mask,
6040                                         size_int (precision - size), 0);
6041                     newconst = fold (build (BIT_AND_EXPR,
6042                                             TREE_TYPE (varop), newconst,
6043                                             convert (TREE_TYPE (varop),
6044                                                      mask)));
6045                   }
6046
6047
6048                 t = build (code, type, TREE_OPERAND (t, 0),
6049                            TREE_OPERAND (t, 1));
6050                 TREE_OPERAND (t, constopnum) = newconst;
6051                 return t;
6052               }
6053           }
6054         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6055           {
6056             if (POINTER_TYPE_P (TREE_TYPE (varop))
6057                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6058                     && (code == EQ_EXPR || code == NE_EXPR)))
6059               {
6060                 tree newconst
6061                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6062                                  constop, TREE_OPERAND (varop, 1)));
6063                 TREE_SET_CODE (varop, PREDECREMENT_EXPR);
6064
6065                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6066                     && DECL_BIT_FIELD(TREE_OPERAND
6067                                       (TREE_OPERAND (varop, 0), 1)))
6068                   {
6069                     int size
6070                       = TREE_INT_CST_LOW (DECL_SIZE
6071                                           (TREE_OPERAND
6072                                            (TREE_OPERAND (varop, 0), 1)));
6073                     tree mask, unsigned_type;
6074                     int precision;
6075                     tree folded_compare;
6076
6077                     if (constopnum == 0)
6078                       folded_compare = fold (build (code, type, constop,
6079                                                     TREE_OPERAND (varop, 0)));
6080                     else
6081                       folded_compare = fold (build (code, type,
6082                                                     TREE_OPERAND (varop, 0),
6083                                                     constop));
6084                     if (integer_zerop (folded_compare)
6085                         || integer_onep (folded_compare))
6086                       return omit_one_operand (type, folded_compare, varop);
6087
6088                     unsigned_type = type_for_size (size, 1);
6089                     precision = TYPE_PRECISION (unsigned_type);
6090                     mask = build_int_2 (~0, ~0);
6091                     TREE_TYPE (mask) = TREE_TYPE (varop);
6092                     force_fit_type (mask, 0);
6093                     mask = const_binop (RSHIFT_EXPR, mask,
6094                                         size_int (precision - size), 0);
6095                     newconst = fold (build (BIT_AND_EXPR,
6096                                             TREE_TYPE (varop), newconst,
6097                                             convert (TREE_TYPE (varop),
6098                                                      mask)));
6099                   }
6100
6101
6102                 t = build (code, type, TREE_OPERAND (t, 0),
6103                            TREE_OPERAND (t, 1));
6104                 TREE_OPERAND (t, constopnum) = newconst;
6105                 return t;
6106               }
6107           }
6108       }
6109
6110       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
6111       if (TREE_CODE (arg1) == INTEGER_CST
6112           && TREE_CODE (arg0) != INTEGER_CST
6113           && tree_int_cst_sgn (arg1) > 0)
6114         {
6115           switch (TREE_CODE (t))
6116             {
6117             case GE_EXPR:
6118               code = GT_EXPR;
6119               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6120               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6121               break;
6122
6123             case LT_EXPR:
6124               code = LE_EXPR;
6125               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6126               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6127               break;
6128
6129             default:
6130               break;
6131             }
6132         }
6133
6134       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6135          a MINUS_EXPR of a constant, we can convert it into a comparison with
6136          a revised constant as long as no overflow occurs.  */
6137       if ((code == EQ_EXPR || code == NE_EXPR)
6138           && TREE_CODE (arg1) == INTEGER_CST
6139           && (TREE_CODE (arg0) == PLUS_EXPR
6140               || TREE_CODE (arg0) == MINUS_EXPR)
6141           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6142           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6143                                       ? MINUS_EXPR : PLUS_EXPR,
6144                                       arg1, TREE_OPERAND (arg0, 1), 0))
6145           && ! TREE_CONSTANT_OVERFLOW (tem))
6146         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6147
6148       /* Similarly for a NEGATE_EXPR.  */
6149       else if ((code == EQ_EXPR || code == NE_EXPR)
6150                && TREE_CODE (arg0) == NEGATE_EXPR
6151                && TREE_CODE (arg1) == INTEGER_CST
6152                && 0 != (tem = negate_expr (arg1))
6153                && TREE_CODE (tem) == INTEGER_CST
6154                && ! TREE_CONSTANT_OVERFLOW (tem))
6155         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6156
6157       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6158          for !=.  Don't do this for ordered comparisons due to overflow.  */
6159       else if ((code == NE_EXPR || code == EQ_EXPR)
6160                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6161         return fold (build (code, type,
6162                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6163
6164       /* If we are widening one operand of an integer comparison,
6165          see if the other operand is similarly being widened.  Perhaps we
6166          can do the comparison in the narrower type.  */
6167       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6168                && TREE_CODE (arg0) == NOP_EXPR
6169                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6170                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6171                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6172                    || (TREE_CODE (t1) == INTEGER_CST
6173                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6174         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6175
6176       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6177          constant, we can simplify it.  */
6178       else if (TREE_CODE (arg1) == INTEGER_CST
6179                && (TREE_CODE (arg0) == MIN_EXPR
6180                    || TREE_CODE (arg0) == MAX_EXPR)
6181                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6182         return optimize_minmax_comparison (t);
6183
6184       /* If we are comparing an ABS_EXPR with a constant, we can
6185          convert all the cases into explicit comparisons, but they may
6186          well not be faster than doing the ABS and one comparison.
6187          But ABS (X) <= C is a range comparison, which becomes a subtraction
6188          and a comparison, and is probably faster.  */
6189       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6190                && TREE_CODE (arg0) == ABS_EXPR
6191                && ! TREE_SIDE_EFFECTS (arg0)
6192                && (0 != (tem = negate_expr (arg1)))
6193                && TREE_CODE (tem) == INTEGER_CST
6194                && ! TREE_CONSTANT_OVERFLOW (tem))
6195         return fold (build (TRUTH_ANDIF_EXPR, type,
6196                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6197                             build (LE_EXPR, type,
6198                                    TREE_OPERAND (arg0, 0), arg1)));
6199
6200       /* If this is an EQ or NE comparison with zero and ARG0 is
6201          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6202          two operations, but the latter can be done in one less insn
6203          on machines that have only two-operand insns or on which a
6204          constant cannot be the first operand.  */
6205       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6206           && TREE_CODE (arg0) == BIT_AND_EXPR)
6207         {
6208           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6209               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6210             return
6211               fold (build (code, type,
6212                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6213                                   build (RSHIFT_EXPR,
6214                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6215                                          TREE_OPERAND (arg0, 1),
6216                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6217                                   convert (TREE_TYPE (arg0),
6218                                            integer_one_node)),
6219                            arg1));
6220           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6221                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6222             return
6223               fold (build (code, type,
6224                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6225                                   build (RSHIFT_EXPR,
6226                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6227                                          TREE_OPERAND (arg0, 0),
6228                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6229                                   convert (TREE_TYPE (arg0),
6230                                            integer_one_node)),
6231                            arg1));
6232         }
6233
6234       /* If this is an NE or EQ comparison of zero against the result of a
6235          signed MOD operation whose second operand is a power of 2, make
6236          the MOD operation unsigned since it is simpler and equivalent.  */
6237       if ((code == NE_EXPR || code == EQ_EXPR)
6238           && integer_zerop (arg1)
6239           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6240           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6241               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6242               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6243               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6244           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6245         {
6246           tree newtype = unsigned_type (TREE_TYPE (arg0));
6247           tree newmod = build (TREE_CODE (arg0), newtype,
6248                                convert (newtype, TREE_OPERAND (arg0, 0)),
6249                                convert (newtype, TREE_OPERAND (arg0, 1)));
6250
6251           return build (code, type, newmod, convert (newtype, arg1));
6252         }
6253
6254       /* If this is an NE comparison of zero with an AND of one, remove the
6255          comparison since the AND will give the correct value.  */
6256       if (code == NE_EXPR && integer_zerop (arg1)
6257           && TREE_CODE (arg0) == BIT_AND_EXPR
6258           && integer_onep (TREE_OPERAND (arg0, 1)))
6259         return convert (type, arg0);
6260
6261       /* If we have (A & C) == C where C is a power of 2, convert this into
6262          (A & C) != 0.  Similarly for NE_EXPR.  */
6263       if ((code == EQ_EXPR || code == NE_EXPR)
6264           && TREE_CODE (arg0) == BIT_AND_EXPR
6265           && integer_pow2p (TREE_OPERAND (arg0, 1))
6266           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6267         return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6268                       arg0, integer_zero_node);
6269
6270       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6271          and similarly for >= into !=.  */
6272       if ((code == LT_EXPR || code == GE_EXPR)
6273           && TREE_UNSIGNED (TREE_TYPE (arg0))
6274           && TREE_CODE (arg1) == LSHIFT_EXPR
6275           && integer_onep (TREE_OPERAND (arg1, 0)))
6276         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6277                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6278                              TREE_OPERAND (arg1, 1)),
6279                       convert (TREE_TYPE (arg0), integer_zero_node));
6280
6281       else if ((code == LT_EXPR || code == GE_EXPR)
6282                && TREE_UNSIGNED (TREE_TYPE (arg0))
6283                && (TREE_CODE (arg1) == NOP_EXPR
6284                    || TREE_CODE (arg1) == CONVERT_EXPR)
6285                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6286                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6287         return
6288           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6289                  convert (TREE_TYPE (arg0),
6290                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6291                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6292                  convert (TREE_TYPE (arg0), integer_zero_node));
6293
6294       /* Simplify comparison of something with itself.  (For IEEE
6295          floating-point, we can only do some of these simplifications.)  */
6296       if (operand_equal_p (arg0, arg1, 0))
6297         {
6298           switch (code)
6299             {
6300             case EQ_EXPR:
6301             case GE_EXPR:
6302             case LE_EXPR:
6303               if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6304                 return constant_boolean_node (1, type);
6305               code = EQ_EXPR;
6306               TREE_SET_CODE (t, code);
6307               break;
6308
6309             case NE_EXPR:
6310               /* For NE, we can only do this simplification if integer.  */
6311               if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
6312                 break;
6313               /* ... fall through ...  */
6314             case GT_EXPR:
6315             case LT_EXPR:
6316               return constant_boolean_node (0, type);
6317             default:
6318               abort ();
6319             }
6320         }
6321
6322       /* An unsigned comparison against 0 can be simplified.  */
6323       if (integer_zerop (arg1)
6324           && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6325               || POINTER_TYPE_P (TREE_TYPE (arg1)))
6326           && TREE_UNSIGNED (TREE_TYPE (arg1)))
6327         {
6328           switch (TREE_CODE (t))
6329             {
6330             case GT_EXPR:
6331               code = NE_EXPR;
6332               TREE_SET_CODE (t, NE_EXPR);
6333               break;
6334             case LE_EXPR:
6335               code = EQ_EXPR;
6336               TREE_SET_CODE (t, EQ_EXPR);
6337               break;
6338             case GE_EXPR:
6339               return omit_one_operand (type,
6340                                        convert (type, integer_one_node),
6341                                        arg0);
6342             case LT_EXPR:
6343               return omit_one_operand (type,
6344                                        convert (type, integer_zero_node),
6345                                        arg0);
6346             default:
6347               break;
6348             }
6349         }
6350
6351       /* Comparisons with the highest or lowest possible integer of
6352          the specified size will have known values and an unsigned
6353          <= 0x7fffffff can be simplified.  */
6354       {
6355         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6356
6357         if (TREE_CODE (arg1) == INTEGER_CST
6358             && ! TREE_CONSTANT_OVERFLOW (arg1)
6359             && width <= HOST_BITS_PER_WIDE_INT
6360             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6361                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6362           {
6363             if (TREE_INT_CST_HIGH (arg1) == 0
6364                 && (TREE_INT_CST_LOW (arg1)
6365                     == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
6366                 && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6367               switch (TREE_CODE (t))
6368                 {
6369                 case GT_EXPR:
6370                   return omit_one_operand (type,
6371                                            convert (type, integer_zero_node),
6372                                            arg0);
6373                 case GE_EXPR:
6374                   TREE_SET_CODE (t, EQ_EXPR);
6375                   break;
6376
6377                 case LE_EXPR:
6378                   return omit_one_operand (type,
6379                                            convert (type, integer_one_node),
6380                                            arg0);
6381                 case LT_EXPR:
6382                   TREE_SET_CODE (t, NE_EXPR);
6383                   break;
6384
6385                 default:
6386                   break;
6387                 }
6388
6389             else if (TREE_INT_CST_HIGH (arg1) == -1
6390                      && (- TREE_INT_CST_LOW (arg1)
6391                          == ((HOST_WIDE_INT) 1 << (width - 1)))
6392                      && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6393               switch (TREE_CODE (t))
6394                 {
6395                 case LT_EXPR:
6396                   return omit_one_operand (type,
6397                                            convert (type, integer_zero_node),
6398                                            arg0);
6399                 case LE_EXPR:
6400                   TREE_SET_CODE (t, EQ_EXPR);
6401                   break;
6402
6403                 case GE_EXPR:
6404                   return omit_one_operand (type,
6405                                            convert (type, integer_one_node),
6406                                            arg0);
6407                 case GT_EXPR:
6408                   TREE_SET_CODE (t, NE_EXPR);
6409                   break;
6410
6411                 default:
6412                   break;
6413                 }
6414
6415             else if (TREE_INT_CST_HIGH (arg1) == 0
6416                       && (TREE_INT_CST_LOW (arg1)
6417                           == ((HOST_WIDE_INT) 1 << (width - 1)) - 1)
6418                       && TREE_UNSIGNED (TREE_TYPE (arg1)))
6419
6420               switch (TREE_CODE (t))
6421                 {
6422                 case LE_EXPR:
6423                   return fold (build (GE_EXPR, type,
6424                                       convert (signed_type (TREE_TYPE (arg0)),
6425                                                arg0),
6426                                       convert (signed_type (TREE_TYPE (arg1)),
6427                                                integer_zero_node)));
6428                 case GT_EXPR:
6429                   return fold (build (LT_EXPR, type,
6430                                       convert (signed_type (TREE_TYPE (arg0)),
6431                                                arg0),
6432                                       convert (signed_type (TREE_TYPE (arg1)),
6433                                                integer_zero_node)));
6434
6435                 default:
6436                   break;
6437                 }
6438           }
6439       }
6440
6441       /* If we are comparing an expression that just has comparisons
6442          of two integer values, arithmetic expressions of those comparisons,
6443          and constants, we can simplify it.  There are only three cases
6444          to check: the two values can either be equal, the first can be
6445          greater, or the second can be greater.  Fold the expression for
6446          those three values.  Since each value must be 0 or 1, we have
6447          eight possibilities, each of which corresponds to the constant 0
6448          or 1 or one of the six possible comparisons.
6449
6450          This handles common cases like (a > b) == 0 but also handles
6451          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6452          occur in macroized code.  */
6453
6454       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6455         {
6456           tree cval1 = 0, cval2 = 0;
6457           int save_p = 0;
6458
6459           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6460               /* Don't handle degenerate cases here; they should already
6461                  have been handled anyway.  */
6462               && cval1 != 0 && cval2 != 0
6463               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6464               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6465               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6466               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6467               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6468               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6469                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6470             {
6471               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6472               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6473
6474               /* We can't just pass T to eval_subst in case cval1 or cval2
6475                  was the same as ARG1.  */
6476
6477               tree high_result
6478                 = fold (build (code, type,
6479                                eval_subst (arg0, cval1, maxval, cval2, minval),
6480                                arg1));
6481               tree equal_result
6482                 = fold (build (code, type,
6483                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6484                                arg1));
6485               tree low_result
6486                 = fold (build (code, type,
6487                                eval_subst (arg0, cval1, minval, cval2, maxval),
6488                                arg1));
6489
6490               /* All three of these results should be 0 or 1.  Confirm they
6491                  are.  Then use those values to select the proper code
6492                  to use.  */
6493
6494               if ((integer_zerop (high_result)
6495                    || integer_onep (high_result))
6496                   && (integer_zerop (equal_result)
6497                       || integer_onep (equal_result))
6498                   && (integer_zerop (low_result)
6499                       || integer_onep (low_result)))
6500                 {
6501                   /* Make a 3-bit mask with the high-order bit being the
6502                      value for `>', the next for '=', and the low for '<'.  */
6503                   switch ((integer_onep (high_result) * 4)
6504                           + (integer_onep (equal_result) * 2)
6505                           + integer_onep (low_result))
6506                     {
6507                     case 0:
6508                       /* Always false.  */
6509                       return omit_one_operand (type, integer_zero_node, arg0);
6510                     case 1:
6511                       code = LT_EXPR;
6512                       break;
6513                     case 2:
6514                       code = EQ_EXPR;
6515                       break;
6516                     case 3:
6517                       code = LE_EXPR;
6518                       break;
6519                     case 4:
6520                       code = GT_EXPR;
6521                       break;
6522                     case 5:
6523                       code = NE_EXPR;
6524                       break;
6525                     case 6:
6526                       code = GE_EXPR;
6527                       break;
6528                     case 7:
6529                       /* Always true.  */
6530                       return omit_one_operand (type, integer_one_node, arg0);
6531                     }
6532
6533                   t = build (code, type, cval1, cval2);
6534                   if (save_p)
6535                     return save_expr (t);
6536                   else
6537                     return fold (t);
6538                 }
6539             }
6540         }
6541
6542       /* If this is a comparison of a field, we may be able to simplify it.  */
6543       if ((TREE_CODE (arg0) == COMPONENT_REF
6544            || TREE_CODE (arg0) == BIT_FIELD_REF)
6545           && (code == EQ_EXPR || code == NE_EXPR)
6546           /* Handle the constant case even without -O
6547              to make sure the warnings are given.  */
6548           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6549         {
6550           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6551           return t1 ? t1 : t;
6552         }
6553
6554       /* If this is a comparison of complex values and either or both sides
6555          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6556          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6557          This may prevent needless evaluations.  */
6558       if ((code == EQ_EXPR || code == NE_EXPR)
6559           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6560           && (TREE_CODE (arg0) == COMPLEX_EXPR
6561               || TREE_CODE (arg1) == COMPLEX_EXPR
6562               || TREE_CODE (arg0) == COMPLEX_CST
6563               || TREE_CODE (arg1) == COMPLEX_CST))
6564         {
6565           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6566           tree real0, imag0, real1, imag1;
6567
6568           arg0 = save_expr (arg0);
6569           arg1 = save_expr (arg1);
6570           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6571           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6572           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6573           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6574
6575           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6576                                : TRUTH_ORIF_EXPR),
6577                               type,
6578                               fold (build (code, type, real0, real1)),
6579                               fold (build (code, type, imag0, imag1))));
6580         }
6581
6582       /* From here on, the only cases we handle are when the result is
6583          known to be a constant.
6584
6585          To compute GT, swap the arguments and do LT.
6586          To compute GE, do LT and invert the result.
6587          To compute LE, swap the arguments, do LT and invert the result.
6588          To compute NE, do EQ and invert the result.
6589
6590          Therefore, the code below must handle only EQ and LT.  */
6591
6592       if (code == LE_EXPR || code == GT_EXPR)
6593         {
6594           tem = arg0, arg0 = arg1, arg1 = tem;
6595           code = swap_tree_comparison (code);
6596         }
6597
6598       /* Note that it is safe to invert for real values here because we
6599          will check below in the one case that it matters.  */
6600
6601       t1 = NULL_TREE;
6602       invert = 0;
6603       if (code == NE_EXPR || code == GE_EXPR)
6604         {
6605           invert = 1;
6606           code = invert_tree_comparison (code);
6607         }
6608
6609       /* Compute a result for LT or EQ if args permit;
6610          otherwise return T.  */
6611       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6612         {
6613           if (code == EQ_EXPR)
6614             t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
6615                                == TREE_INT_CST_LOW (arg1))
6616                               && (TREE_INT_CST_HIGH (arg0)
6617                                   == TREE_INT_CST_HIGH (arg1)),
6618                               0);
6619           else
6620             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6621                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6622                                : INT_CST_LT (arg0, arg1)),
6623                               0);
6624         }
6625
6626 #if 0 /* This is no longer useful, but breaks some real code.  */
6627       /* Assume a nonexplicit constant cannot equal an explicit one,
6628          since such code would be undefined anyway.
6629          Exception: on sysvr4, using #pragma weak,
6630          a label can come out as 0.  */
6631       else if (TREE_CODE (arg1) == INTEGER_CST
6632                && !integer_zerop (arg1)
6633                && TREE_CONSTANT (arg0)
6634                && TREE_CODE (arg0) == ADDR_EXPR
6635                && code == EQ_EXPR)
6636         t1 = build_int_2 (0, 0);
6637 #endif
6638       /* Two real constants can be compared explicitly.  */
6639       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6640         {
6641           /* If either operand is a NaN, the result is false with two
6642              exceptions: First, an NE_EXPR is true on NaNs, but that case
6643              is already handled correctly since we will be inverting the
6644              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6645              or a GE_EXPR into a LT_EXPR, we must return true so that it
6646              will be inverted into false.  */
6647
6648           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6649               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6650             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6651
6652           else if (code == EQ_EXPR)
6653             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6654                                                  TREE_REAL_CST (arg1)),
6655                               0);
6656           else
6657             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6658                                                 TREE_REAL_CST (arg1)),
6659                               0);
6660         }
6661
6662       if (t1 == NULL_TREE)
6663         return t;
6664
6665       if (invert)
6666         TREE_INT_CST_LOW (t1) ^= 1;
6667
6668       TREE_TYPE (t1) = type;
6669       if (TREE_CODE (type) == BOOLEAN_TYPE)
6670         return truthvalue_conversion (t1);
6671       return t1;
6672
6673     case COND_EXPR:
6674       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6675          so all simple results must be passed through pedantic_non_lvalue.  */
6676       if (TREE_CODE (arg0) == INTEGER_CST)
6677         return pedantic_non_lvalue
6678           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6679       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6680         return pedantic_omit_one_operand (type, arg1, arg0);
6681
6682       /* If the second operand is zero, invert the comparison and swap
6683          the second and third operands.  Likewise if the second operand
6684          is constant and the third is not or if the third operand is
6685          equivalent to the first operand of the comparison.  */
6686
6687       if (integer_zerop (arg1)
6688           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6689           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6690               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6691                                                  TREE_OPERAND (t, 2),
6692                                                  TREE_OPERAND (arg0, 1))))
6693         {
6694           /* See if this can be inverted.  If it can't, possibly because
6695              it was a floating-point inequality comparison, don't do
6696              anything.  */
6697           tem = invert_truthvalue (arg0);
6698
6699           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6700             {
6701               t = build (code, type, tem,
6702                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6703               arg0 = tem;
6704               /* arg1 should be the first argument of the new T.  */
6705               arg1 = TREE_OPERAND (t, 1);
6706               STRIP_NOPS (arg1);
6707             }
6708         }
6709
6710       /* If we have A op B ? A : C, we may be able to convert this to a
6711          simpler expression, depending on the operation and the values
6712          of B and C.  IEEE floating point prevents this though,
6713          because A or B might be -0.0 or a NaN.  */
6714
6715       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6716           && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
6717               || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
6718               || flag_fast_math)
6719           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6720                                              arg1, TREE_OPERAND (arg0, 1)))
6721         {
6722           tree arg2 = TREE_OPERAND (t, 2);
6723           enum tree_code comp_code = TREE_CODE (arg0);
6724
6725           STRIP_NOPS (arg2);
6726
6727           /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
6728              depending on the comparison operation.  */
6729           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
6730                ? real_zerop (TREE_OPERAND (arg0, 1))
6731                : integer_zerop (TREE_OPERAND (arg0, 1)))
6732               && TREE_CODE (arg2) == NEGATE_EXPR
6733               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
6734             switch (comp_code)
6735               {
6736               case EQ_EXPR:
6737                 return pedantic_non_lvalue (negate_expr (arg1));
6738               case NE_EXPR:
6739                 return pedantic_non_lvalue (convert (type, arg1));
6740               case GE_EXPR:
6741               case GT_EXPR:
6742                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6743                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6744                 return pedantic_non_lvalue
6745                   (convert (type, fold (build1 (ABS_EXPR,
6746                                                 TREE_TYPE (arg1), arg1))));
6747               case LE_EXPR:
6748               case LT_EXPR:
6749                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6750                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6751                 return pedantic_non_lvalue
6752                   (negate_expr (convert (type,
6753                                          fold (build1 (ABS_EXPR,
6754                                                        TREE_TYPE (arg1),
6755                                                        arg1)))));
6756               default:
6757                 abort ();
6758               }
6759
6760           /* If this is A != 0 ? A : 0, this is simply A.  For ==, it is
6761              always zero.  */
6762
6763           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
6764             {
6765               if (comp_code == NE_EXPR)
6766                 return pedantic_non_lvalue (convert (type, arg1));
6767               else if (comp_code == EQ_EXPR)
6768                 return pedantic_non_lvalue (convert (type, integer_zero_node));
6769             }
6770
6771           /* If this is A op B ? A : B, this is either A, B, min (A, B),
6772              or max (A, B), depending on the operation.  */
6773
6774           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
6775                                               arg2, TREE_OPERAND (arg0, 0)))
6776             {
6777               tree comp_op0 = TREE_OPERAND (arg0, 0);
6778               tree comp_op1 = TREE_OPERAND (arg0, 1);
6779               tree comp_type = TREE_TYPE (comp_op0);
6780
6781               switch (comp_code)
6782                 {
6783                 case EQ_EXPR:
6784                   return pedantic_non_lvalue (convert (type, arg2));
6785                 case NE_EXPR:
6786                   return pedantic_non_lvalue (convert (type, arg1));
6787                 case LE_EXPR:
6788                 case LT_EXPR:
6789                   /* In C++ a ?: expression can be an lvalue, so put the
6790                      operand which will be used if they are equal first
6791                      so that we can convert this back to the
6792                      corresponding COND_EXPR.  */
6793                   return pedantic_non_lvalue
6794                     (convert (type, (fold (build (MIN_EXPR, comp_type,
6795                                                   (comp_code == LE_EXPR
6796                                                    ? comp_op0 : comp_op1),
6797                                                   (comp_code == LE_EXPR
6798                                                    ? comp_op1 : comp_op0))))));
6799                   break;
6800                 case GE_EXPR:
6801                 case GT_EXPR:
6802                   return pedantic_non_lvalue
6803                     (convert (type, fold (build (MAX_EXPR, comp_type,
6804                                                  (comp_code == GE_EXPR
6805                                                   ? comp_op0 : comp_op1),
6806                                                  (comp_code == GE_EXPR
6807                                                   ? comp_op1 : comp_op0)))));
6808                   break;
6809                 default:
6810                   abort ();
6811                 }
6812             }
6813
6814           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6815              we might still be able to simplify this.  For example,
6816              if C1 is one less or one more than C2, this might have started
6817              out as a MIN or MAX and been transformed by this function.
6818              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
6819
6820           if (INTEGRAL_TYPE_P (type)
6821               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6822               && TREE_CODE (arg2) == INTEGER_CST)
6823             switch (comp_code)
6824               {
6825               case EQ_EXPR:
6826                 /* We can replace A with C1 in this case.  */
6827                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
6828                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
6829                            TREE_OPERAND (t, 2));
6830                 break;
6831
6832               case LT_EXPR:
6833                 /* If C1 is C2 + 1, this is min(A, C2).  */
6834                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6835                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6836                                         const_binop (PLUS_EXPR, arg2,
6837                                                      integer_one_node, 0), 1))
6838                   return pedantic_non_lvalue
6839                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6840                 break;
6841
6842               case LE_EXPR:
6843                 /* If C1 is C2 - 1, this is min(A, C2).  */
6844                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6845                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6846                                         const_binop (MINUS_EXPR, arg2,
6847                                                      integer_one_node, 0), 1))
6848                   return pedantic_non_lvalue
6849                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6850                 break;
6851
6852               case GT_EXPR:
6853                 /* If C1 is C2 - 1, this is max(A, C2).  */
6854                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6855                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6856                                         const_binop (MINUS_EXPR, arg2,
6857                                                      integer_one_node, 0), 1))
6858                   return pedantic_non_lvalue
6859                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6860                 break;
6861
6862               case GE_EXPR:
6863                 /* If C1 is C2 + 1, this is max(A, C2).  */
6864                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6865                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6866                                         const_binop (PLUS_EXPR, arg2,
6867                                                      integer_one_node, 0), 1))
6868                   return pedantic_non_lvalue
6869                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6870                 break;
6871               case NE_EXPR:
6872                 break;
6873               default:
6874                 abort ();
6875               }
6876         }
6877
6878       /* If the second operand is simpler than the third, swap them
6879          since that produces better jump optimization results.  */
6880       if ((TREE_CONSTANT (arg1) || TREE_CODE_CLASS (TREE_CODE (arg1)) == 'd'
6881            || TREE_CODE (arg1) == SAVE_EXPR)
6882           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
6883                 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 2))) == 'd'
6884                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
6885         {
6886           /* See if this can be inverted.  If it can't, possibly because
6887              it was a floating-point inequality comparison, don't do
6888              anything.  */
6889           tem = invert_truthvalue (arg0);
6890
6891           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6892             {
6893               t = build (code, type, tem,
6894                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6895               arg0 = tem;
6896               /* arg1 should be the first argument of the new T.  */
6897               arg1 = TREE_OPERAND (t, 1);
6898               STRIP_NOPS (arg1);
6899             }
6900         }
6901
6902       /* Convert A ? 1 : 0 to simply A.  */
6903       if (integer_onep (TREE_OPERAND (t, 1))
6904           && integer_zerop (TREE_OPERAND (t, 2))
6905           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
6906              call to fold will try to move the conversion inside
6907              a COND, which will recurse.  In that case, the COND_EXPR
6908              is probably the best choice, so leave it alone.  */
6909           && type == TREE_TYPE (arg0))
6910         return pedantic_non_lvalue (arg0);
6911
6912       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
6913          operation is simply A & 2.  */
6914
6915       if (integer_zerop (TREE_OPERAND (t, 2))
6916           && TREE_CODE (arg0) == NE_EXPR
6917           && integer_zerop (TREE_OPERAND (arg0, 1))
6918           && integer_pow2p (arg1)
6919           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
6920           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
6921                               arg1, 1))
6922         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
6923
6924       return t;
6925
6926     case COMPOUND_EXPR:
6927       /* When pedantic, a compound expression can be neither an lvalue
6928          nor an integer constant expression.  */
6929       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
6930         return t;
6931       /* Don't let (0, 0) be null pointer constant.  */
6932       if (integer_zerop (arg1))
6933         return build1 (NOP_EXPR, TREE_TYPE (arg1), arg1);
6934       return arg1;
6935
6936     case COMPLEX_EXPR:
6937       if (wins)
6938         return build_complex (type, arg0, arg1);
6939       return t;
6940
6941     case REALPART_EXPR:
6942       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6943         return t;
6944       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6945         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
6946                                  TREE_OPERAND (arg0, 1));
6947       else if (TREE_CODE (arg0) == COMPLEX_CST)
6948         return TREE_REALPART (arg0);
6949       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6950         return fold (build (TREE_CODE (arg0), type,
6951                             fold (build1 (REALPART_EXPR, type,
6952                                           TREE_OPERAND (arg0, 0))),
6953                             fold (build1 (REALPART_EXPR,
6954                                           type, TREE_OPERAND (arg0, 1)))));
6955       return t;
6956
6957     case IMAGPART_EXPR:
6958       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6959         return convert (type, integer_zero_node);
6960       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6961         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
6962                                  TREE_OPERAND (arg0, 0));
6963       else if (TREE_CODE (arg0) == COMPLEX_CST)
6964         return TREE_IMAGPART (arg0);
6965       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6966         return fold (build (TREE_CODE (arg0), type,
6967                             fold (build1 (IMAGPART_EXPR, type,
6968                                           TREE_OPERAND (arg0, 0))),
6969                             fold (build1 (IMAGPART_EXPR, type,
6970                                           TREE_OPERAND (arg0, 1)))));
6971       return t;
6972
6973       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6974          appropriate.  */
6975     case CLEANUP_POINT_EXPR:
6976       if (! has_cleanups (arg0))
6977         return TREE_OPERAND (t, 0);
6978
6979       {
6980         enum tree_code code0 = TREE_CODE (arg0);
6981         int kind0 = TREE_CODE_CLASS (code0);
6982         tree arg00 = TREE_OPERAND (arg0, 0);
6983         tree arg01;
6984
6985         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
6986           return fold (build1 (code0, type,
6987                                fold (build1 (CLEANUP_POINT_EXPR,
6988                                              TREE_TYPE (arg00), arg00))));
6989
6990         if (kind0 == '<' || kind0 == '2'
6991             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
6992             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
6993             || code0 == TRUTH_XOR_EXPR)
6994           {
6995             arg01 = TREE_OPERAND (arg0, 1);
6996
6997             if (TREE_CONSTANT (arg00)
6998                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
6999                     && ! has_cleanups (arg00)))
7000               return fold (build (code0, type, arg00,
7001                                   fold (build1 (CLEANUP_POINT_EXPR,
7002                                                 TREE_TYPE (arg01), arg01))));
7003
7004             if (TREE_CONSTANT (arg01))
7005               return fold (build (code0, type,
7006                                   fold (build1 (CLEANUP_POINT_EXPR,
7007                                                 TREE_TYPE (arg00), arg00)),
7008                                   arg01));
7009           }
7010
7011         return t;
7012       }
7013
7014     default:
7015       return t;
7016     } /* switch (code) */
7017 }
7018
7019 /* Determine if first argument is a multiple of second argument.  Return 0 if
7020    it is not, or we cannot easily determined it to be.
7021
7022    An example of the sort of thing we care about (at this point; this routine
7023    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7024    fold cases do now) is discovering that
7025
7026      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7027
7028    is a multiple of
7029
7030      SAVE_EXPR (J * 8)
7031
7032    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7033
7034    This code also handles discovering that
7035
7036      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7037
7038    is a multiple of 8 so we don't have to worry about dealing with a
7039    possible remainder.
7040
7041    Note that we *look* inside a SAVE_EXPR only to determine how it was
7042    calculated; it is not safe for fold to do much of anything else with the
7043    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7044    at run time.  For example, the latter example above *cannot* be implemented
7045    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7046    evaluation time of the original SAVE_EXPR is not necessarily the same at
7047    the time the new expression is evaluated.  The only optimization of this
7048    sort that would be valid is changing
7049
7050      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7051
7052    divided by 8 to
7053
7054      SAVE_EXPR (I) * SAVE_EXPR (J)
7055
7056    (where the same SAVE_EXPR (J) is used in the original and the
7057    transformed version).  */
7058
7059 static int
7060 multiple_of_p (type, top, bottom)
7061      tree type;
7062      tree top;
7063      tree bottom;
7064 {
7065   if (operand_equal_p (top, bottom, 0))
7066     return 1;
7067
7068   if (TREE_CODE (type) != INTEGER_TYPE)
7069     return 0;
7070
7071   switch (TREE_CODE (top))
7072     {
7073     case MULT_EXPR:
7074       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7075               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7076
7077     case PLUS_EXPR:
7078     case MINUS_EXPR:
7079       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7080               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7081
7082     case NOP_EXPR:
7083       /* Can't handle conversions from non-integral or wider integral type.  */
7084       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7085           || (TYPE_PRECISION (type)
7086               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7087         return 0;
7088
7089       /* .. fall through ... */
7090
7091     case SAVE_EXPR:
7092       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7093
7094     case INTEGER_CST:
7095       if ((TREE_CODE (bottom) != INTEGER_CST)
7096           || (tree_int_cst_sgn (top) < 0)
7097           || (tree_int_cst_sgn (bottom) < 0))
7098         return 0;
7099       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7100                                          top, bottom, 0));
7101
7102     default:
7103       return 0;
7104     }
7105 }