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