gcc/fold-const.c

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