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