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