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