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