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