gcc/fold-const.c

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