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),
2458                            TREE_OPERAND (arg1, 0), flags)
2459           && operand_equal_p (TREE_OPERAND (arg0, 1),
2460                               TREE_OPERAND (arg1, 1), flags))
2461         return 1;
2462
2463       /* For commutative ops, allow the other order.  */
2464       return (commutative_tree_code (TREE_CODE (arg0))
2465               && operand_equal_p (TREE_OPERAND (arg0, 0),
2466                                   TREE_OPERAND (arg1, 1), flags)
2467               && operand_equal_p (TREE_OPERAND (arg0, 1),
2468                                   TREE_OPERAND (arg1, 0), flags));
2469
2470     case 'r':
2471       /* If either of the pointer (or reference) expressions we are
2472          dereferencing contain a side effect, these cannot be equal.  */
2473       if (TREE_SIDE_EFFECTS (arg0)
2474           || TREE_SIDE_EFFECTS (arg1))
2475         return 0;
2476
2477       switch (TREE_CODE (arg0))
2478         {
2479         case INDIRECT_REF:
2480           return operand_equal_p (TREE_OPERAND (arg0, 0),
2481                                   TREE_OPERAND (arg1, 0), flags);
2482
2483         case COMPONENT_REF:
2484         case ARRAY_REF:
2485         case ARRAY_RANGE_REF:
2486           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2487                                    TREE_OPERAND (arg1, 0), flags)
2488                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2489                                       TREE_OPERAND (arg1, 1), flags));
2490
2491         case BIT_FIELD_REF:
2492           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2493                                    TREE_OPERAND (arg1, 0), flags)
2494                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2495                                       TREE_OPERAND (arg1, 1), flags)
2496                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2497                                       TREE_OPERAND (arg1, 2), flags));
2498         default:
2499           return 0;
2500         }
2501
2502     case 'e':
2503       switch (TREE_CODE (arg0))
2504         {
2505         case ADDR_EXPR:
2506         case TRUTH_NOT_EXPR:
2507           return operand_equal_p (TREE_OPERAND (arg0, 0),
2508                                   TREE_OPERAND (arg1, 0), flags);
2509
2510         case TRUTH_ANDIF_EXPR:
2511         case TRUTH_ORIF_EXPR:
2512           return operand_equal_p (TREE_OPERAND (arg0, 0),
2513                                   TREE_OPERAND (arg1, 0), flags)
2514                  && operand_equal_p (TREE_OPERAND (arg0, 1),
2515                                      TREE_OPERAND (arg1, 1), flags);
2516
2517         case TRUTH_AND_EXPR:
2518         case TRUTH_OR_EXPR:
2519         case TRUTH_XOR_EXPR:
2520           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2521                                    TREE_OPERAND (arg1, 0), flags)
2522                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2523                                       TREE_OPERAND (arg1, 1), flags))
2524                  || (operand_equal_p (TREE_OPERAND (arg0, 0),
2525                                       TREE_OPERAND (arg1, 1), flags)
2526                      && operand_equal_p (TREE_OPERAND (arg0, 1),
2527                                          TREE_OPERAND (arg1, 0), flags));
2528
2529         case RTL_EXPR:
2530           return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
2531
2532         case CALL_EXPR:
2533           /* If the CALL_EXPRs call different functions, then they
2534              clearly can not be equal.  */
2535           if (! operand_equal_p (TREE_OPERAND (arg0, 0),
2536                                  TREE_OPERAND (arg1, 0), flags))
2537             return 0;
2538
2539           {
2540             unsigned int cef = call_expr_flags (arg0);
2541             if (flags & OEP_PURE_SAME)
2542               cef &= ECF_CONST | ECF_PURE;
2543             else
2544               cef &= ECF_CONST;
2545             if (!cef)
2546               return 0;
2547           }
2548
2549           /* Now see if all the arguments are the same.  operand_equal_p
2550              does not handle TREE_LIST, so we walk the operands here
2551              feeding them to operand_equal_p.  */
2552           arg0 = TREE_OPERAND (arg0, 1);
2553           arg1 = TREE_OPERAND (arg1, 1);
2554           while (arg0 && arg1)
2555             {
2556               if (! operand_equal_p (TREE_VALUE (arg0), TREE_VALUE (arg1),
2557                                      flags))
2558                 return 0;
2559
2560               arg0 = TREE_CHAIN (arg0);
2561               arg1 = TREE_CHAIN (arg1);
2562             }
2563
2564           /* If we get here and both argument lists are exhausted
2565              then the CALL_EXPRs are equal.  */
2566           return ! (arg0 || arg1);
2567
2568         default:
2569           return 0;
2570         }
2571
2572     case 'd':
2573       /* Consider __builtin_sqrt equal to sqrt.  */
2574       return (TREE_CODE (arg0) == FUNCTION_DECL
2575               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2576               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2577               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2578
2579     default:
2580       return 0;
2581     }
2582 }
2583 \f
2584 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2585    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2586
2587    When in doubt, return 0.  */
2588
2589 static int
2590 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2591 {
2592   int unsignedp1, unsignedpo;
2593   tree primarg0, primarg1, primother;
2594   unsigned int correct_width;
2595
2596   if (operand_equal_p (arg0, arg1, 0))
2597     return 1;
2598
2599   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2600       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2601     return 0;
2602
2603   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2604      and see if the inner values are the same.  This removes any
2605      signedness comparison, which doesn't matter here.  */
2606   primarg0 = arg0, primarg1 = arg1;
2607   STRIP_NOPS (primarg0);
2608   STRIP_NOPS (primarg1);
2609   if (operand_equal_p (primarg0, primarg1, 0))
2610     return 1;
2611
2612   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2613      actual comparison operand, ARG0.
2614
2615      First throw away any conversions to wider types
2616      already present in the operands.  */
2617
2618   primarg1 = get_narrower (arg1, &unsignedp1);
2619   primother = get_narrower (other, &unsignedpo);
2620
2621   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2622   if (unsignedp1 == unsignedpo
2623       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2624       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2625     {
2626       tree type = TREE_TYPE (arg0);
2627
2628       /* Make sure shorter operand is extended the right way
2629          to match the longer operand.  */
2630       primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
2631                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2632
2633       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2634         return 1;
2635     }
2636
2637   return 0;
2638 }
2639 \f
2640 /* See if ARG is an expression that is either a comparison or is performing
2641    arithmetic on comparisons.  The comparisons must only be comparing
2642    two different values, which will be stored in *CVAL1 and *CVAL2; if
2643    they are nonzero it means that some operands have already been found.
2644    No variables may be used anywhere else in the expression except in the
2645    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2646    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2647
2648    If this is true, return 1.  Otherwise, return zero.  */
2649
2650 static int
2651 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2652 {
2653   enum tree_code code = TREE_CODE (arg);
2654   char class = TREE_CODE_CLASS (code);
2655
2656   /* We can handle some of the 'e' cases here.  */
2657   if (class == 'e' && code == TRUTH_NOT_EXPR)
2658     class = '1';
2659   else if (class == 'e'
2660            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2661                || code == COMPOUND_EXPR))
2662     class = '2';
2663
2664   else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0
2665            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2666     {
2667       /* If we've already found a CVAL1 or CVAL2, this expression is
2668          two complex to handle.  */
2669       if (*cval1 || *cval2)
2670         return 0;
2671
2672       class = '1';
2673       *save_p = 1;
2674     }
2675
2676   switch (class)
2677     {
2678     case '1':
2679       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2680
2681     case '2':
2682       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2683               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2684                                       cval1, cval2, save_p));
2685
2686     case 'c':
2687       return 1;
2688
2689     case 'e':
2690       if (code == COND_EXPR)
2691         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2692                                      cval1, cval2, save_p)
2693                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2694                                         cval1, cval2, save_p)
2695                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2696                                         cval1, cval2, save_p));
2697       return 0;
2698
2699     case '<':
2700       /* First see if we can handle the first operand, then the second.  For
2701          the second operand, we know *CVAL1 can't be zero.  It must be that
2702          one side of the comparison is each of the values; test for the
2703          case where this isn't true by failing if the two operands
2704          are the same.  */
2705
2706       if (operand_equal_p (TREE_OPERAND (arg, 0),
2707                            TREE_OPERAND (arg, 1), 0))
2708         return 0;
2709
2710       if (*cval1 == 0)
2711         *cval1 = TREE_OPERAND (arg, 0);
2712       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2713         ;
2714       else if (*cval2 == 0)
2715         *cval2 = TREE_OPERAND (arg, 0);
2716       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2717         ;
2718       else
2719         return 0;
2720
2721       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2722         ;
2723       else if (*cval2 == 0)
2724         *cval2 = TREE_OPERAND (arg, 1);
2725       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2726         ;
2727       else
2728         return 0;
2729
2730       return 1;
2731
2732     default:
2733       return 0;
2734     }
2735 }
2736 \f
2737 /* ARG is a tree that is known to contain just arithmetic operations and
2738    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2739    any occurrence of OLD0 as an operand of a comparison and likewise for
2740    NEW1 and OLD1.  */
2741
2742 static tree
2743 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
2744 {
2745   tree type = TREE_TYPE (arg);
2746   enum tree_code code = TREE_CODE (arg);
2747   char class = TREE_CODE_CLASS (code);
2748
2749   /* We can handle some of the 'e' cases here.  */
2750   if (class == 'e' && code == TRUTH_NOT_EXPR)
2751     class = '1';
2752   else if (class == 'e'
2753            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2754     class = '2';
2755
2756   switch (class)
2757     {
2758     case '1':
2759       return fold (build1 (code, type,
2760                            eval_subst (TREE_OPERAND (arg, 0),
2761                                        old0, new0, old1, new1)));
2762
2763     case '2':
2764       return fold (build2 (code, type,
2765                            eval_subst (TREE_OPERAND (arg, 0),
2766                                        old0, new0, old1, new1),
2767                            eval_subst (TREE_OPERAND (arg, 1),
2768                                        old0, new0, old1, new1)));
2769
2770     case 'e':
2771       switch (code)
2772         {
2773         case SAVE_EXPR:
2774           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2775
2776         case COMPOUND_EXPR:
2777           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2778
2779         case COND_EXPR:
2780           return fold (build3 (code, type,
2781                                eval_subst (TREE_OPERAND (arg, 0),
2782                                            old0, new0, old1, new1),
2783                                eval_subst (TREE_OPERAND (arg, 1),
2784                                            old0, new0, old1, new1),
2785                                eval_subst (TREE_OPERAND (arg, 2),
2786                                            old0, new0, old1, new1)));
2787         default:
2788           break;
2789         }
2790       /* Fall through - ???  */
2791
2792     case '<':
2793       {
2794         tree arg0 = TREE_OPERAND (arg, 0);
2795         tree arg1 = TREE_OPERAND (arg, 1);
2796
2797         /* We need to check both for exact equality and tree equality.  The
2798            former will be true if the operand has a side-effect.  In that
2799            case, we know the operand occurred exactly once.  */
2800
2801         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2802           arg0 = new0;
2803         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2804           arg0 = new1;
2805
2806         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2807           arg1 = new0;
2808         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2809           arg1 = new1;
2810
2811         return fold (build2 (code, type, arg0, arg1));
2812       }
2813
2814     default:
2815       return arg;
2816     }
2817 }
2818 \f
2819 /* Return a tree for the case when the result of an expression is RESULT
2820    converted to TYPE and OMITTED was previously an operand of the expression
2821    but is now not needed (e.g., we folded OMITTED * 0).
2822
2823    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2824    the conversion of RESULT to TYPE.  */
2825
2826 tree
2827 omit_one_operand (tree type, tree result, tree omitted)
2828 {
2829   tree t = fold_convert (type, result);
2830
2831   if (TREE_SIDE_EFFECTS (omitted))
2832     return build2 (COMPOUND_EXPR, type, omitted, t);
2833
2834   return non_lvalue (t);
2835 }
2836
2837 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2838
2839 static tree
2840 pedantic_omit_one_operand (tree type, tree result, tree omitted)
2841 {
2842   tree t = fold_convert (type, result);
2843
2844   if (TREE_SIDE_EFFECTS (omitted))
2845     return build2 (COMPOUND_EXPR, type, omitted, t);
2846
2847   return pedantic_non_lvalue (t);
2848 }
2849
2850 /* Return a tree for the case when the result of an expression is RESULT
2851    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
2852    of the expression but are now not needed.
2853
2854    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
2855    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
2856    evaluated before OMITTED2.  Otherwise, if neither has side effects,
2857    just do the conversion of RESULT to TYPE.  */
2858
2859 tree
2860 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
2861 {
2862   tree t = fold_convert (type, result);
2863
2864   if (TREE_SIDE_EFFECTS (omitted2))
2865     t = build2 (COMPOUND_EXPR, type, omitted2, t);
2866   if (TREE_SIDE_EFFECTS (omitted1))
2867     t = build2 (COMPOUND_EXPR, type, omitted1, t);
2868
2869   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
2870 }
2871
2872 \f
2873 /* Return a simplified tree node for the truth-negation of ARG.  This
2874    never alters ARG itself.  We assume that ARG is an operation that
2875    returns a truth value (0 or 1).
2876
2877    FIXME: one would think we would fold the result, but it causes
2878    problems with the dominator optimizer.  */
2879 tree
2880 invert_truthvalue (tree arg)
2881 {
2882   tree type = TREE_TYPE (arg);
2883   enum tree_code code = TREE_CODE (arg);
2884
2885   if (code == ERROR_MARK)
2886     return arg;
2887
2888   /* If this is a comparison, we can simply invert it, except for
2889      floating-point non-equality comparisons, in which case we just
2890      enclose a TRUTH_NOT_EXPR around what we have.  */
2891
2892   if (TREE_CODE_CLASS (code) == '<')
2893     {
2894       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
2895       if (FLOAT_TYPE_P (op_type)
2896           && flag_trapping_math
2897           && code != ORDERED_EXPR && code != UNORDERED_EXPR
2898           && code != NE_EXPR && code != EQ_EXPR)
2899         return build1 (TRUTH_NOT_EXPR, type, arg);
2900       else
2901         {
2902           code = invert_tree_comparison (code,
2903                                          HONOR_NANS (TYPE_MODE (op_type)));
2904           if (code == ERROR_MARK)
2905             return build1 (TRUTH_NOT_EXPR, type, arg);
2906           else
2907             return build2 (code, type,
2908                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2909         }
2910     }
2911
2912   switch (code)
2913     {
2914     case INTEGER_CST:
2915       return fold_convert (type, build_int_2 (integer_zerop (arg), 0));
2916
2917     case TRUTH_AND_EXPR:
2918       return build2 (TRUTH_OR_EXPR, type,
2919                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2920                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2921
2922     case TRUTH_OR_EXPR:
2923       return build2 (TRUTH_AND_EXPR, type,
2924                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2925                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2926
2927     case TRUTH_XOR_EXPR:
2928       /* Here we can invert either operand.  We invert the first operand
2929          unless the second operand is a TRUTH_NOT_EXPR in which case our
2930          result is the XOR of the first operand with the inside of the
2931          negation of the second operand.  */
2932
2933       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2934         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2935                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2936       else
2937         return build2 (TRUTH_XOR_EXPR, type,
2938                        invert_truthvalue (TREE_OPERAND (arg, 0)),
2939                        TREE_OPERAND (arg, 1));
2940
2941     case TRUTH_ANDIF_EXPR:
2942       return build2 (TRUTH_ORIF_EXPR, type,
2943                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2944                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2945
2946     case TRUTH_ORIF_EXPR:
2947       return build2 (TRUTH_ANDIF_EXPR, type,
2948                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2949                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2950
2951     case TRUTH_NOT_EXPR:
2952       return TREE_OPERAND (arg, 0);
2953
2954     case COND_EXPR:
2955       return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
2956                      invert_truthvalue (TREE_OPERAND (arg, 1)),
2957                      invert_truthvalue (TREE_OPERAND (arg, 2)));
2958
2959     case COMPOUND_EXPR:
2960       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2961                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2962
2963     case NON_LVALUE_EXPR:
2964       return invert_truthvalue (TREE_OPERAND (arg, 0));
2965
2966     case NOP_EXPR:
2967       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2968         break;
2969
2970     case CONVERT_EXPR:
2971     case FLOAT_EXPR:
2972       return build1 (TREE_CODE (arg), type,
2973                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2974
2975     case BIT_AND_EXPR:
2976       if (!integer_onep (TREE_OPERAND (arg, 1)))
2977         break;
2978       return build2 (EQ_EXPR, type, arg,
2979                      fold_convert (type, integer_zero_node));
2980
2981     case SAVE_EXPR:
2982       return build1 (TRUTH_NOT_EXPR, type, arg);
2983
2984     case CLEANUP_POINT_EXPR:
2985       return build1 (CLEANUP_POINT_EXPR, type,
2986                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2987
2988     default:
2989       break;
2990     }
2991   if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2992     abort ();
2993   return build1 (TRUTH_NOT_EXPR, type, arg);
2994 }
2995
2996 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2997    operands are another bit-wise operation with a common input.  If so,
2998    distribute the bit operations to save an operation and possibly two if
2999    constants are involved.  For example, convert
3000         (A | B) & (A | C) into A | (B & C)
3001    Further simplification will occur if B and C are constants.
3002
3003    If this optimization cannot be done, 0 will be returned.  */
3004
3005 static tree
3006 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3007 {
3008   tree common;
3009   tree left, right;
3010
3011   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3012       || TREE_CODE (arg0) == code
3013       || (TREE_CODE (arg0) != BIT_AND_EXPR
3014           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3015     return 0;
3016
3017   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3018     {
3019       common = TREE_OPERAND (arg0, 0);
3020       left = TREE_OPERAND (arg0, 1);
3021       right = TREE_OPERAND (arg1, 1);
3022     }
3023   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3024     {
3025       common = TREE_OPERAND (arg0, 0);
3026       left = TREE_OPERAND (arg0, 1);
3027       right = TREE_OPERAND (arg1, 0);
3028     }
3029   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3030     {
3031       common = TREE_OPERAND (arg0, 1);
3032       left = TREE_OPERAND (arg0, 0);
3033       right = TREE_OPERAND (arg1, 1);
3034     }
3035   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3036     {
3037       common = TREE_OPERAND (arg0, 1);
3038       left = TREE_OPERAND (arg0, 0);
3039       right = TREE_OPERAND (arg1, 0);
3040     }
3041   else
3042     return 0;
3043
3044   return fold (build2 (TREE_CODE (arg0), type, common,
3045                        fold (build2 (code, type, left, right))));
3046 }
3047 \f
3048 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3049    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3050
3051 static tree
3052 make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos,
3053                     int unsignedp)
3054 {
3055   tree result = build3 (BIT_FIELD_REF, type, inner,
3056                         size_int (bitsize), bitsize_int (bitpos));
3057
3058   BIT_FIELD_REF_UNSIGNED (result) = unsignedp;
3059
3060   return result;
3061 }
3062
3063 /* Optimize a bit-field compare.
3064
3065    There are two cases:  First is a compare against a constant and the
3066    second is a comparison of two items where the fields are at the same
3067    bit position relative to the start of a chunk (byte, halfword, word)
3068    large enough to contain it.  In these cases we can avoid the shift
3069    implicit in bitfield extractions.
3070
3071    For constants, we emit a compare of the shifted constant with the
3072    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3073    compared.  For two fields at the same position, we do the ANDs with the
3074    similar mask and compare the result of the ANDs.
3075
3076    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3077    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3078    are the left and right operands of the comparison, respectively.
3079
3080    If the optimization described above can be done, we return the resulting
3081    tree.  Otherwise we return zero.  */
3082
3083 static tree
3084 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3085                             tree lhs, tree rhs)
3086 {
3087   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3088   tree type = TREE_TYPE (lhs);
3089   tree signed_type, unsigned_type;
3090   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3091   enum machine_mode lmode, rmode, nmode;
3092   int lunsignedp, runsignedp;
3093   int lvolatilep = 0, rvolatilep = 0;
3094   tree linner, rinner = NULL_TREE;
3095   tree mask;
3096   tree offset;
3097
3098   /* Get all the information about the extractions being done.  If the bit size
3099      if the same as the size of the underlying object, we aren't doing an
3100      extraction at all and so can do nothing.  We also don't want to
3101      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3102      then will no longer be able to replace it.  */
3103   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3104                                 &lunsignedp, &lvolatilep);
3105   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3106       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3107     return 0;
3108
3109  if (!const_p)
3110    {
3111      /* If this is not a constant, we can only do something if bit positions,
3112         sizes, and signedness are the same.  */
3113      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3114                                    &runsignedp, &rvolatilep);
3115
3116      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3117          || lunsignedp != runsignedp || offset != 0
3118          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3119        return 0;
3120    }
3121
3122   /* See if we can find a mode to refer to this field.  We should be able to,
3123      but fail if we can't.  */
3124   nmode = get_best_mode (lbitsize, lbitpos,
3125                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3126                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3127                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3128                          word_mode, lvolatilep || rvolatilep);
3129   if (nmode == VOIDmode)
3130     return 0;
3131
3132   /* Set signed and unsigned types of the precision of this mode for the
3133      shifts below.  */
3134   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3135   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3136
3137   /* Compute the bit position and size for the new reference and our offset
3138      within it. If the new reference is the same size as the original, we
3139      won't optimize anything, so return zero.  */
3140   nbitsize = GET_MODE_BITSIZE (nmode);
3141   nbitpos = lbitpos & ~ (nbitsize - 1);
3142   lbitpos -= nbitpos;
3143   if (nbitsize == lbitsize)
3144     return 0;
3145
3146   if (BYTES_BIG_ENDIAN)
3147     lbitpos = nbitsize - lbitsize - lbitpos;
3148
3149   /* Make the mask to be used against the extracted field.  */
3150   mask = build_int_2 (~0, ~0);
3151   TREE_TYPE (mask) = unsigned_type;
3152   force_fit_type (mask, 0);
3153   mask = fold_convert (unsigned_type, mask);
3154   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3155   mask = const_binop (RSHIFT_EXPR, mask,
3156                       size_int (nbitsize - lbitsize - lbitpos), 0);
3157
3158   if (! const_p)
3159     /* If not comparing with constant, just rework the comparison
3160        and return.  */
3161     return build2 (code, compare_type,
3162                    build2 (BIT_AND_EXPR, unsigned_type,
3163                            make_bit_field_ref (linner, unsigned_type,
3164                                                nbitsize, nbitpos, 1),
3165                            mask),
3166                    build2 (BIT_AND_EXPR, unsigned_type,
3167                            make_bit_field_ref (rinner, unsigned_type,
3168                                                nbitsize, nbitpos, 1),
3169                            mask));
3170
3171   /* Otherwise, we are handling the constant case. See if the constant is too
3172      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3173      this not only for its own sake, but to avoid having to test for this
3174      error case below.  If we didn't, we might generate wrong code.
3175
3176      For unsigned fields, the constant shifted right by the field length should
3177      be all zero.  For signed fields, the high-order bits should agree with
3178      the sign bit.  */
3179
3180   if (lunsignedp)
3181     {
3182       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3183                                         fold_convert (unsigned_type, rhs),
3184                                         size_int (lbitsize), 0)))
3185         {
3186           warning ("comparison is always %d due to width of bit-field",
3187                    code == NE_EXPR);
3188           return constant_boolean_node (code == NE_EXPR, compare_type);
3189         }
3190     }
3191   else
3192     {
3193       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3194                               size_int (lbitsize - 1), 0);
3195       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3196         {
3197           warning ("comparison is always %d due to width of bit-field",
3198                    code == NE_EXPR);
3199           return constant_boolean_node (code == NE_EXPR, compare_type);
3200         }
3201     }
3202
3203   /* Single-bit compares should always be against zero.  */
3204   if (lbitsize == 1 && ! integer_zerop (rhs))
3205     {
3206       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3207       rhs = fold_convert (type, integer_zero_node);
3208     }
3209
3210   /* Make a new bitfield reference, shift the constant over the
3211      appropriate number of bits and mask it with the computed mask
3212      (in case this was a signed field).  If we changed it, make a new one.  */
3213   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3214   if (lvolatilep)
3215     {
3216       TREE_SIDE_EFFECTS (lhs) = 1;
3217       TREE_THIS_VOLATILE (lhs) = 1;
3218     }
3219
3220   rhs = fold (const_binop (BIT_AND_EXPR,
3221                            const_binop (LSHIFT_EXPR,
3222                                         fold_convert (unsigned_type, rhs),
3223                                         size_int (lbitpos), 0),
3224                            mask, 0));
3225
3226   return build2 (code, compare_type,
3227                  build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
3228                  rhs);
3229 }
3230 \f
3231 /* Subroutine for fold_truthop: decode a field reference.
3232
3233    If EXP is a comparison reference, we return the innermost reference.
3234
3235    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3236    set to the starting bit number.
3237
3238    If the innermost field can be completely contained in a mode-sized
3239    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3240
3241    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3242    otherwise it is not changed.
3243
3244    *PUNSIGNEDP is set to the signedness of the field.
3245
3246    *PMASK is set to the mask used.  This is either contained in a
3247    BIT_AND_EXPR or derived from the width of the field.
3248
3249    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3250
3251    Return 0 if this is not a component reference or is one that we can't
3252    do anything with.  */
3253
3254 static tree
3255 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
3256                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3257                         int *punsignedp, int *pvolatilep,
3258                         tree *pmask, tree *pand_mask)
3259 {
3260   tree outer_type = 0;
3261   tree and_mask = 0;
3262   tree mask, inner, offset;
3263   tree unsigned_type;
3264   unsigned int precision;
3265
3266   /* All the optimizations using this function assume integer fields.
3267      There are problems with FP fields since the type_for_size call
3268      below can fail for, e.g., XFmode.  */
3269   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3270     return 0;
3271
3272   /* We are interested in the bare arrangement of bits, so strip everything
3273      that doesn't affect the machine mode.  However, record the type of the
3274      outermost expression if it may matter below.  */
3275   if (TREE_CODE (exp) == NOP_EXPR
3276       || TREE_CODE (exp) == CONVERT_EXPR
3277       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3278     outer_type = TREE_TYPE (exp);
3279   STRIP_NOPS (exp);
3280
3281   if (TREE_CODE (exp) == BIT_AND_EXPR)
3282     {
3283       and_mask = TREE_OPERAND (exp, 1);
3284       exp = TREE_OPERAND (exp, 0);
3285       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3286       if (TREE_CODE (and_mask) != INTEGER_CST)
3287         return 0;
3288     }
3289
3290   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3291                                punsignedp, pvolatilep);
3292   if ((inner == exp && and_mask == 0)
3293       || *pbitsize < 0 || offset != 0
3294       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3295     return 0;
3296
3297   /* If the number of bits in the reference is the same as the bitsize of
3298      the outer type, then the outer type gives the signedness. Otherwise
3299      (in case of a small bitfield) the signedness is unchanged.  */
3300   if (outer_type && *pbitsize == tree_low_cst (TYPE_SIZE (outer_type), 1))
3301     *punsignedp = TYPE_UNSIGNED (outer_type);
3302
3303   /* Compute the mask to access the bitfield.  */
3304   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3305   precision = TYPE_PRECISION (unsigned_type);
3306
3307   mask = build_int_2 (~0, ~0);
3308   TREE_TYPE (mask) = unsigned_type;
3309   force_fit_type (mask, 0);
3310   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3311   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3312
3313   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3314   if (and_mask != 0)
3315     mask = fold (build2 (BIT_AND_EXPR, unsigned_type,
3316                          fold_convert (unsigned_type, and_mask), mask));
3317
3318   *pmask = mask;
3319   *pand_mask = and_mask;
3320   return inner;
3321 }
3322
3323 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3324    bit positions.  */
3325
3326 static int
3327 all_ones_mask_p (tree mask, int size)
3328 {
3329   tree type = TREE_TYPE (mask);
3330   unsigned int precision = TYPE_PRECISION (type);
3331   tree tmask;
3332
3333   tmask = build_int_2 (~0, ~0);
3334   TREE_TYPE (tmask) = lang_hooks.types.signed_type (type);
3335   force_fit_type (tmask, 0);
3336   return
3337     tree_int_cst_equal (mask,
3338                         const_binop (RSHIFT_EXPR,
3339                                      const_binop (LSHIFT_EXPR, tmask,
3340                                                   size_int (precision - size),
3341                                                   0),
3342                                      size_int (precision - size), 0));
3343 }
3344
3345 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3346    represents the sign bit of EXP's type.  If EXP represents a sign
3347    or zero extension, also test VAL against the unextended type.
3348    The return value is the (sub)expression whose sign bit is VAL,
3349    or NULL_TREE otherwise.  */
3350
3351 static tree
3352 sign_bit_p (tree exp, tree val)
3353 {
3354   unsigned HOST_WIDE_INT mask_lo, lo;
3355   HOST_WIDE_INT mask_hi, hi;
3356   int width;
3357   tree t;
3358
3359   /* Tree EXP must have an integral type.  */
3360   t = TREE_TYPE (exp);
3361   if (! INTEGRAL_TYPE_P (t))
3362     return NULL_TREE;
3363
3364   /* Tree VAL must be an integer constant.  */
3365   if (TREE_CODE (val) != INTEGER_CST
3366       || TREE_CONSTANT_OVERFLOW (val))
3367     return NULL_TREE;
3368
3369   width = TYPE_PRECISION (t);
3370   if (width > HOST_BITS_PER_WIDE_INT)
3371     {
3372       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3373       lo = 0;
3374
3375       mask_hi = ((unsigned HOST_WIDE_INT) -1
3376                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3377       mask_lo = -1;
3378     }
3379   else
3380     {
3381       hi = 0;
3382       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3383
3384       mask_hi = 0;
3385       mask_lo = ((unsigned HOST_WIDE_INT) -1
3386                  >> (HOST_BITS_PER_WIDE_INT - width));
3387     }
3388
3389   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3390      treat VAL as if it were unsigned.  */
3391   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3392       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3393     return exp;
3394
3395   /* Handle extension from a narrower type.  */
3396   if (TREE_CODE (exp) == NOP_EXPR
3397       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3398     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3399
3400   return NULL_TREE;
3401 }
3402
3403 /* Subroutine for fold_truthop: determine if an operand is simple enough
3404    to be evaluated unconditionally.  */
3405
3406 static int
3407 simple_operand_p (tree exp)
3408 {
3409   /* Strip any conversions that don't change the machine mode.  */
3410   while ((TREE_CODE (exp) == NOP_EXPR
3411           || TREE_CODE (exp) == CONVERT_EXPR)
3412          && (TYPE_MODE (TREE_TYPE (exp))
3413              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
3414     exp = TREE_OPERAND (exp, 0);
3415
3416   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
3417           || (DECL_P (exp)
3418               && ! TREE_ADDRESSABLE (exp)
3419               && ! TREE_THIS_VOLATILE (exp)
3420               && ! DECL_NONLOCAL (exp)
3421               /* Don't regard global variables as simple.  They may be
3422                  allocated in ways unknown to the compiler (shared memory,
3423                  #pragma weak, etc).  */
3424               && ! TREE_PUBLIC (exp)
3425               && ! DECL_EXTERNAL (exp)
3426               /* Loading a static variable is unduly expensive, but global
3427                  registers aren't expensive.  */
3428               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3429 }
3430 \f
3431 /* The following functions are subroutines to fold_range_test and allow it to
3432    try to change a logical combination of comparisons into a range test.
3433
3434    For example, both
3435         X == 2 || X == 3 || X == 4 || X == 5
3436    and
3437         X >= 2 && X <= 5
3438    are converted to
3439         (unsigned) (X - 2) <= 3
3440
3441    We describe each set of comparisons as being either inside or outside
3442    a range, using a variable named like IN_P, and then describe the
3443    range with a lower and upper bound.  If one of the bounds is omitted,
3444    it represents either the highest or lowest value of the type.
3445
3446    In the comments below, we represent a range by two numbers in brackets
3447    preceded by a "+" to designate being inside that range, or a "-" to
3448    designate being outside that range, so the condition can be inverted by
3449    flipping the prefix.  An omitted bound is represented by a "-".  For
3450    example, "- [-, 10]" means being outside the range starting at the lowest
3451    possible value and ending at 10, in other words, being greater than 10.
3452    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3453    always false.
3454
3455    We set up things so that the missing bounds are handled in a consistent
3456    manner so neither a missing bound nor "true" and "false" need to be
3457    handled using a special case.  */
3458
3459 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3460    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3461    and UPPER1_P are nonzero if the respective argument is an upper bound
3462    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3463    must be specified for a comparison.  ARG1 will be converted to ARG0's
3464    type if both are specified.  */
3465
3466 static tree
3467 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3468              tree arg1, int upper1_p)
3469 {
3470   tree tem;
3471   int result;
3472   int sgn0, sgn1;
3473
3474   /* If neither arg represents infinity, do the normal operation.
3475      Else, if not a comparison, return infinity.  Else handle the special
3476      comparison rules. Note that most of the cases below won't occur, but
3477      are handled for consistency.  */
3478
3479   if (arg0 != 0 && arg1 != 0)
3480     {
3481       tem = fold (build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3482                           arg0, fold_convert (TREE_TYPE (arg0), arg1)));
3483       STRIP_NOPS (tem);
3484       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3485     }
3486
3487   if (TREE_CODE_CLASS (code) != '<')
3488     return 0;
3489
3490   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3491      for neither.  In real maths, we cannot assume open ended ranges are
3492      the same. But, this is computer arithmetic, where numbers are finite.
3493      We can therefore make the transformation of any unbounded range with
3494      the value Z, Z being greater than any representable number. This permits
3495      us to treat unbounded ranges as equal.  */
3496   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3497   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3498   switch (code)
3499     {
3500     case EQ_EXPR:
3501       result = sgn0 == sgn1;
3502       break;
3503     case NE_EXPR:
3504       result = sgn0 != sgn1;
3505       break;
3506     case LT_EXPR:
3507       result = sgn0 < sgn1;
3508       break;
3509     case LE_EXPR:
3510       result = sgn0 <= sgn1;
3511       break;
3512     case GT_EXPR:
3513       result = sgn0 > sgn1;
3514       break;
3515     case GE_EXPR:
3516       result = sgn0 >= sgn1;
3517       break;
3518     default:
3519       abort ();
3520     }
3521
3522   return constant_boolean_node (result, type);
3523 }
3524 \f
3525 /* Given EXP, a logical expression, set the range it is testing into
3526    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3527    actually being tested.  *PLOW and *PHIGH will be made of the same type
3528    as the returned expression.  If EXP is not a comparison, we will most
3529    likely not be returning a useful value and range.  */
3530
3531 static tree
3532 make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
3533 {
3534   enum tree_code code;
3535   tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
3536   tree orig_type = NULL_TREE;
3537   int in_p, n_in_p;
3538   tree low, high, n_low, n_high;
3539
3540   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3541      and see if we can refine the range.  Some of the cases below may not
3542      happen, but it doesn't seem worth worrying about this.  We "continue"
3543      the outer loop when we've changed something; otherwise we "break"
3544      the switch, which will "break" the while.  */
3545
3546   in_p = 0;
3547   low = high = fold_convert (TREE_TYPE (exp), integer_zero_node);
3548
3549   while (1)
3550     {
3551       code = TREE_CODE (exp);
3552
3553       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3554         {
3555           if (first_rtl_op (code) > 0)
3556             arg0 = TREE_OPERAND (exp, 0);
3557           if (TREE_CODE_CLASS (code) == '<'
3558               || TREE_CODE_CLASS (code) == '1'
3559               || TREE_CODE_CLASS (code) == '2')
3560             type = TREE_TYPE (arg0);
3561           if (TREE_CODE_CLASS (code) == '2'
3562               || TREE_CODE_CLASS (code) == '<'
3563               || (TREE_CODE_CLASS (code) == 'e'
3564                   && TREE_CODE_LENGTH (code) > 1))
3565             arg1 = TREE_OPERAND (exp, 1);
3566         }
3567
3568       /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
3569          lose a cast by accident.  */
3570       if (type != NULL_TREE && orig_type == NULL_TREE)
3571         orig_type = type;
3572
3573       switch (code)
3574         {
3575         case TRUTH_NOT_EXPR:
3576           in_p = ! in_p, exp = arg0;
3577           continue;
3578
3579         case EQ_EXPR: case NE_EXPR:
3580         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3581           /* We can only do something if the range is testing for zero
3582              and if the second operand is an integer constant.  Note that
3583              saying something is "in" the range we make is done by
3584              complementing IN_P since it will set in the initial case of
3585              being not equal to zero; "out" is leaving it alone.  */
3586           if (low == 0 || high == 0
3587               || ! integer_zerop (low) || ! integer_zerop (high)
3588               || TREE_CODE (arg1) != INTEGER_CST)
3589             break;
3590
3591           switch (code)
3592             {
3593             case NE_EXPR:  /* - [c, c]  */
3594               low = high = arg1;
3595               break;
3596             case EQ_EXPR:  /* + [c, c]  */
3597               in_p = ! in_p, low = high = arg1;
3598               break;
3599             case GT_EXPR:  /* - [-, c] */
3600               low = 0, high = arg1;
3601               break;
3602             case GE_EXPR:  /* + [c, -] */
3603               in_p = ! in_p, low = arg1, high = 0;
3604               break;
3605             case LT_EXPR:  /* - [c, -] */
3606               low = arg1, high = 0;
3607               break;
3608             case LE_EXPR:  /* + [-, c] */
3609               in_p = ! in_p, low = 0, high = arg1;
3610               break;
3611             default:
3612               abort ();
3613             }
3614
3615           exp = arg0;
3616
3617           /* If this is an unsigned comparison, we also know that EXP is
3618              greater than or equal to zero.  We base the range tests we make
3619              on that fact, so we record it here so we can parse existing
3620              range tests.  */
3621           if (TYPE_UNSIGNED (type) && (low == 0 || high == 0))
3622             {
3623               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3624                                   1, fold_convert (type, integer_zero_node),
3625                                   NULL_TREE))
3626                 break;
3627
3628               in_p = n_in_p, low = n_low, high = n_high;
3629
3630               /* If the high bound is missing, but we have a nonzero low
3631                  bound, reverse the range so it goes from zero to the low bound
3632                  minus 1.  */
3633               if (high == 0 && low && ! integer_zerop (low))
3634                 {
3635                   in_p = ! in_p;
3636                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3637                                       integer_one_node, 0);
3638                   low = fold_convert (type, integer_zero_node);
3639                 }
3640             }
3641           continue;
3642
3643         case NEGATE_EXPR:
3644           /* (-x) IN [a,b] -> x in [-b, -a]  */
3645           n_low = range_binop (MINUS_EXPR, type,
3646                                fold_convert (type, integer_zero_node),
3647                                0, high, 1);
3648           n_high = range_binop (MINUS_EXPR, type,
3649                                 fold_convert (type, integer_zero_node),
3650                                 0, low, 0);
3651           low = n_low, high = n_high;
3652           exp = arg0;
3653           continue;
3654
3655         case BIT_NOT_EXPR:
3656           /* ~ X -> -X - 1  */
3657           exp = build2 (MINUS_EXPR, type, negate_expr (arg0),
3658                         fold_convert (type, integer_one_node));
3659           continue;
3660
3661         case PLUS_EXPR:  case MINUS_EXPR:
3662           if (TREE_CODE (arg1) != INTEGER_CST)
3663             break;
3664
3665           /* If EXP is signed, any overflow in the computation is undefined,
3666              so we don't worry about it so long as our computations on
3667              the bounds don't overflow.  For unsigned, overflow is defined
3668              and this is exactly the right thing.  */
3669           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3670                                type, low, 0, arg1, 0);
3671           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3672                                 type, high, 1, arg1, 0);
3673           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3674               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3675             break;
3676
3677           /* Check for an unsigned range which has wrapped around the maximum
3678              value thus making n_high < n_low, and normalize it.  */
3679           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3680             {
3681               low = range_binop (PLUS_EXPR, type, n_high, 0,
3682                                  integer_one_node, 0);
3683               high = range_binop (MINUS_EXPR, type, n_low, 0,
3684                                   integer_one_node, 0);
3685
3686               /* If the range is of the form +/- [ x+1, x ], we won't
3687                  be able to normalize it.  But then, it represents the
3688                  whole range or the empty set, so make it
3689                  +/- [ -, - ].  */
3690               if (tree_int_cst_equal (n_low, low)
3691                   && tree_int_cst_equal (n_high, high))
3692                 low = high = 0;
3693               else
3694                 in_p = ! in_p;
3695             }
3696           else
3697             low = n_low, high = n_high;
3698
3699           exp = arg0;
3700           continue;
3701
3702         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3703           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3704             break;
3705
3706           if (! INTEGRAL_TYPE_P (type)
3707               || (low != 0 && ! int_fits_type_p (low, type))
3708               || (high != 0 && ! int_fits_type_p (high, type)))
3709             break;
3710
3711           n_low = low, n_high = high;
3712
3713           if (n_low != 0)
3714             n_low = fold_convert (type, n_low);
3715
3716           if (n_high != 0)
3717             n_high = fold_convert (type, n_high);
3718
3719           /* If we're converting from an unsigned to a signed type,
3720              we will be doing the comparison as unsigned.  The tests above
3721              have already verified that LOW and HIGH are both positive.
3722
3723              So we have to make sure that the original unsigned value will
3724              be interpreted as positive.  */
3725           if (TYPE_UNSIGNED (type) && ! TYPE_UNSIGNED (TREE_TYPE (exp)))
3726             {
3727               tree equiv_type = lang_hooks.types.type_for_mode
3728                 (TYPE_MODE (type), 1);
3729               tree high_positive;
3730
3731               /* A range without an upper bound is, naturally, unbounded.
3732                  Since convert would have cropped a very large value, use
3733                  the max value for the destination type.  */
3734               high_positive
3735                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3736                   : TYPE_MAX_VALUE (type);
3737
3738               if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
3739                 high_positive = fold (build2 (RSHIFT_EXPR, type,
3740                                               fold_convert (type,
3741                                                             high_positive),
3742                                               fold_convert (type,
3743                                                             integer_one_node)));
3744
3745               /* If the low bound is specified, "and" the range with the
3746                  range for which the original unsigned value will be
3747                  positive.  */
3748               if (low != 0)
3749                 {
3750                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3751                                       1, n_low, n_high, 1,
3752                                       fold_convert (type, integer_zero_node),
3753                                       high_positive))
3754                     break;
3755
3756                   in_p = (n_in_p == in_p);
3757                 }
3758               else
3759                 {
3760                   /* Otherwise, "or" the range with the range of the input
3761                      that will be interpreted as negative.  */
3762                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3763                                       0, n_low, n_high, 1,
3764                                       fold_convert (type, integer_zero_node),
3765                                       high_positive))
3766                     break;
3767
3768                   in_p = (in_p != n_in_p);
3769                 }
3770             }
3771
3772           exp = arg0;
3773           low = n_low, high = n_high;
3774           continue;
3775
3776         default:
3777           break;
3778         }
3779
3780       break;
3781     }
3782
3783   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3784   if (TREE_CODE (exp) == INTEGER_CST)
3785     {
3786       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3787                                                  exp, 0, low, 0))
3788                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3789                                                     exp, 1, high, 1)));
3790       low = high = 0;
3791       exp = 0;
3792     }
3793
3794   *pin_p = in_p, *plow = low, *phigh = high;
3795   return exp;
3796 }
3797 \f
3798 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3799    type, TYPE, return an expression to test if EXP is in (or out of, depending
3800    on IN_P) the range.  Return 0 if the test couldn't be created.  */
3801
3802 static tree
3803 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
3804 {
3805   tree etype = TREE_TYPE (exp);
3806   tree value;
3807
3808   if (! in_p)
3809     {
3810       value = build_range_check (type, exp, 1, low, high);
3811       if (value != 0)
3812         return invert_truthvalue (value);
3813
3814       return 0;
3815     }
3816
3817   if (low == 0 && high == 0)
3818     return fold_convert (type, integer_one_node);
3819
3820   if (low == 0)
3821     return fold (build2 (LE_EXPR, type, exp, high));
3822
3823   if (high == 0)
3824     return fold (build2 (GE_EXPR, type, exp, low));
3825
3826   if (operand_equal_p (low, high, 0))
3827     return fold (build2 (EQ_EXPR, type, exp, low));
3828
3829   if (integer_zerop (low))
3830     {
3831       if (! TYPE_UNSIGNED (etype))
3832         {
3833           etype = lang_hooks.types.unsigned_type (etype);
3834           high = fold_convert (etype, high);
3835           exp = fold_convert (etype, exp);
3836         }
3837       return build_range_check (type, exp, 1, 0, high);
3838     }
3839
3840   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
3841   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
3842     {
3843       unsigned HOST_WIDE_INT lo;
3844       HOST_WIDE_INT hi;
3845       int prec;
3846
3847       prec = TYPE_PRECISION (etype);
3848       if (prec <= HOST_BITS_PER_WIDE_INT)
3849         {
3850           hi = 0;
3851           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
3852         }
3853       else
3854         {
3855           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
3856           lo = (unsigned HOST_WIDE_INT) -1;
3857         }
3858
3859       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
3860         {
3861           if (TYPE_UNSIGNED (etype))
3862             {
3863               etype = lang_hooks.types.signed_type (etype);
3864               exp = fold_convert (etype, exp);
3865             }
3866           return fold (build2 (GT_EXPR, type, exp,
3867                                fold_convert (etype, integer_zero_node)));
3868         }
3869     }
3870
3871   value = const_binop (MINUS_EXPR, high, low, 0);
3872   if (value != 0 && TREE_OVERFLOW (value) && ! TYPE_UNSIGNED (etype))
3873     {
3874       tree utype, minv, maxv;
3875
3876       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
3877          for the type in question, as we rely on this here.  */
3878       switch (TREE_CODE (etype))
3879         {
3880         case INTEGER_TYPE:
3881         case ENUMERAL_TYPE:
3882         case CHAR_TYPE:
3883           utype = lang_hooks.types.unsigned_type (etype);
3884           maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
3885           maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
3886                               integer_one_node, 1);
3887           minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
3888           if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
3889                                           minv, 1, maxv, 1)))
3890             {
3891               etype = utype;
3892               high = fold_convert (etype, high);
3893               low = fold_convert (etype, low);
3894               exp = fold_convert (etype, exp);
3895               value = const_binop (MINUS_EXPR, high, low, 0);
3896             }
3897           break;
3898         default:
3899           break;
3900         }
3901     }
3902
3903   if (value != 0 && ! TREE_OVERFLOW (value))
3904     return build_range_check (type,
3905                               fold (build2 (MINUS_EXPR, etype, exp, low)),
3906                               1, fold_convert (etype, integer_zero_node),
3907                               value);
3908
3909   return 0;
3910 }
3911 \f
3912 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3913    can, 0 if we can't.  Set the output range into the specified parameters.  */
3914
3915 static int
3916 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
3917               tree high0, int in1_p, tree low1, tree high1)
3918 {
3919   int no_overlap;
3920   int subset;
3921   int temp;
3922   tree tem;
3923   int in_p;
3924   tree low, high;
3925   int lowequal = ((low0 == 0 && low1 == 0)
3926                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3927                                                 low0, 0, low1, 0)));
3928   int highequal = ((high0 == 0 && high1 == 0)
3929                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3930                                                  high0, 1, high1, 1)));
3931
3932   /* Make range 0 be the range that starts first, or ends last if they
3933      start at the same value.  Swap them if it isn't.  */
3934   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3935                                  low0, 0, low1, 0))
3936       || (lowequal
3937           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3938                                         high1, 1, high0, 1))))
3939     {
3940       temp = in0_p, in0_p = in1_p, in1_p = temp;
3941       tem = low0, low0 = low1, low1 = tem;
3942       tem = high0, high0 = high1, high1 = tem;
3943     }
3944
3945   /* Now flag two cases, whether the ranges are disjoint or whether the
3946      second range is totally subsumed in the first.  Note that the tests
3947      below are simplified by the ones above.  */
3948   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3949                                           high0, 1, low1, 0));
3950   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3951                                       high1, 1, high0, 1));
3952
3953   /* We now have four cases, depending on whether we are including or
3954      excluding the two ranges.  */
3955   if (in0_p && in1_p)
3956     {
3957       /* If they don't overlap, the result is false.  If the second range
3958          is a subset it is the result.  Otherwise, the range is from the start
3959          of the second to the end of the first.  */
3960       if (no_overlap)
3961         in_p = 0, low = high = 0;
3962       else if (subset)
3963         in_p = 1, low = low1, high = high1;
3964       else
3965         in_p = 1, low = low1, high = high0;
3966     }
3967
3968   else if (in0_p && ! in1_p)
3969     {
3970       /* If they don't overlap, the result is the first range.  If they are
3971          equal, the result is false.  If the second range is a subset of the
3972          first, and the ranges begin at the same place, we go from just after
3973          the end of the first range to the end of the second.  If the second
3974          range is not a subset of the first, or if it is a subset and both
3975          ranges end at the same place, the range starts at the start of the
3976          first range and ends just before the second range.
3977          Otherwise, we can't describe this as a single range.  */
3978       if (no_overlap)
3979         in_p = 1, low = low0, high = high0;
3980       else if (lowequal && highequal)
3981         in_p = 0, low = high = 0;
3982       else if (subset && lowequal)
3983         {
3984           in_p = 1, high = high0;
3985           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3986                              integer_one_node, 0);
3987         }
3988       else if (! subset || highequal)
3989         {
3990           in_p = 1, low = low0;
3991           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3992                               integer_one_node, 0);
3993         }
3994       else
3995         return 0;
3996     }
3997
3998   else if (! in0_p && in1_p)
3999     {
4000       /* If they don't overlap, the result is the second range.  If the second
4001          is a subset of the first, the result is false.  Otherwise,
4002          the range starts just after the first range and ends at the
4003          end of the second.  */
4004       if (no_overlap)
4005         in_p = 1, low = low1, high = high1;
4006       else if (subset || highequal)
4007         in_p = 0, low = high = 0;
4008       else
4009         {
4010           in_p = 1, high = high1;
4011           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4012                              integer_one_node, 0);
4013         }
4014     }
4015
4016   else
4017     {
4018       /* The case where we are excluding both ranges.  Here the complex case
4019          is if they don't overlap.  In that case, the only time we have a
4020          range is if they are adjacent.  If the second is a subset of the
4021          first, the result is the first.  Otherwise, the range to exclude
4022          starts at the beginning of the first range and ends at the end of the
4023          second.  */
4024       if (no_overlap)
4025         {
4026           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4027                                          range_binop (PLUS_EXPR, NULL_TREE,
4028                                                       high0, 1,
4029                                                       integer_one_node, 1),
4030                                          1, low1, 0)))
4031             in_p = 0, low = low0, high = high1;
4032           else
4033             {
4034               /* Canonicalize - [min, x] into - [-, x].  */
4035               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4036                 switch (TREE_CODE (TREE_TYPE (low0)))
4037                   {
4038                   case ENUMERAL_TYPE:
4039                     if (TYPE_PRECISION (TREE_TYPE (low0))
4040                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4041                       break;
4042                     /* FALLTHROUGH */
4043                   case INTEGER_TYPE:
4044                   case CHAR_TYPE:
4045                     if (tree_int_cst_equal (low0,
4046                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4047                       low0 = 0;
4048                     break;
4049                   case POINTER_TYPE:
4050                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4051                         && integer_zerop (low0))
4052                       low0 = 0;
4053                     break;
4054                   default:
4055                     break;
4056                   }
4057
4058               /* Canonicalize - [x, max] into - [x, -].  */
4059               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4060                 switch (TREE_CODE (TREE_TYPE (high1)))
4061                   {
4062                   case ENUMERAL_TYPE:
4063                     if (TYPE_PRECISION (TREE_TYPE (high1))
4064                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4065                       break;
4066                     /* FALLTHROUGH */
4067                   case INTEGER_TYPE:
4068                   case CHAR_TYPE:
4069                     if (tree_int_cst_equal (high1,
4070                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4071                       high1 = 0;
4072                     break;
4073                   case POINTER_TYPE:
4074                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4075                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4076                                                        high1, 1,
4077                                                        integer_one_node, 1)))
4078                       high1 = 0;
4079                     break;
4080                   default:
4081                     break;
4082                   }
4083
4084               /* The ranges might be also adjacent between the maximum and
4085                  minimum values of the given type.  For
4086                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4087                  return + [x + 1, y - 1].  */
4088               if (low0 == 0 && high1 == 0)
4089                 {
4090                   low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4091                                      integer_one_node, 1);
4092                   high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
4093                                       integer_one_node, 0);
4094                   if (low == 0 || high == 0)
4095                     return 0;
4096
4097                   in_p = 1;
4098                 }
4099               else
4100                 return 0;
4101             }
4102         }
4103       else if (subset)
4104         in_p = 0, low = low0, high = high0;
4105       else
4106         in_p = 0, low = low0, high = high1;
4107     }
4108
4109   *pin_p = in_p, *plow = low, *phigh = high;
4110   return 1;
4111 }
4112 \f
4113
4114 /* Subroutine of fold, looking inside expressions of the form
4115    A op B ? A : C, where ARG0 is A op B and ARG2 is C.  This
4116    function is being used also to optimize A op B ? C : A, by
4117    reversing the comparison first.
4118
4119    Return a folded expression whose code is not a COND_EXPR
4120    anymore, or NULL_TREE if no folding opportunity is found.  */
4121
4122 static tree
4123 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg2)
4124 {
4125   enum tree_code comp_code = TREE_CODE (arg0);
4126   tree arg00 = TREE_OPERAND (arg0, 0);
4127   tree arg01 = TREE_OPERAND (arg0, 1);
4128   tree tem;
4129   STRIP_NOPS (arg2);
4130
4131   /* If we have A op 0 ? A : -A, consider applying the following
4132      transformations:
4133
4134      A == 0? A : -A    same as -A
4135      A != 0? A : -A    same as A
4136      A >= 0? A : -A    same as abs (A)
4137      A > 0?  A : -A    same as abs (A)
4138      A <= 0? A : -A    same as -abs (A)
4139      A < 0?  A : -A    same as -abs (A)
4140
4141      None of these transformations work for modes with signed
4142      zeros.  If A is +/-0, the first two transformations will
4143      change the sign of the result (from +0 to -0, or vice
4144      versa).  The last four will fix the sign of the result,
4145      even though the original expressions could be positive or
4146      negative, depending on the sign of A.
4147
4148      Note that all these transformations are correct if A is
4149      NaN, since the two alternatives (A and -A) are also NaNs.  */
4150   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
4151        ? real_zerop (arg01)
4152        : integer_zerop (arg01))
4153       && TREE_CODE (arg2) == NEGATE_EXPR
4154       && operand_equal_p (TREE_OPERAND (arg2, 0), arg00, 0))
4155     switch (comp_code)
4156       {
4157       case EQ_EXPR:
4158         return fold_convert (type, negate_expr (arg00));
4159       case NE_EXPR:
4160         return pedantic_non_lvalue (fold_convert (type, arg00));
4161       case GE_EXPR:
4162       case GT_EXPR:
4163         if (TYPE_UNSIGNED (TREE_TYPE (arg00)))
4164           arg00 = fold_convert (lang_hooks.types.signed_type
4165                                 (TREE_TYPE (arg00)), arg00);
4166         tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg00), arg00));
4167         return pedantic_non_lvalue (fold_convert (type, tem));
4168       case LE_EXPR:
4169       case LT_EXPR:
4170         if (TYPE_UNSIGNED (TREE_TYPE (arg00)))
4171           arg00 = fold_convert (lang_hooks.types.signed_type
4172                                 (TREE_TYPE (arg00)), arg00);
4173         tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg00), arg00));
4174         return negate_expr (fold_convert (type, tem));
4175       default:
4176         abort ();
4177       }
4178
4179   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4180      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4181      both transformations are correct when A is NaN: A != 0
4182      is then true, and A == 0 is false.  */
4183
4184   if (integer_zerop (arg01) && integer_zerop (arg2))
4185     {
4186       if (comp_code == NE_EXPR)
4187         return pedantic_non_lvalue (fold_convert (type, arg00));
4188       else if (comp_code == EQ_EXPR)
4189         return pedantic_non_lvalue (fold_convert (type, integer_zero_node));
4190     }
4191
4192   /* Try some transformations of A op B ? A : B.
4193
4194      A == B? A : B    same as B
4195      A != B? A : B    same as A
4196      A >= B? A : B    same as max (A, B)
4197      A > B?  A : B    same as max (B, A)
4198      A <= B? A : B    same as min (A, B)
4199      A < B?  A : B    same as min (B, A)
4200
4201      As above, these transformations don't work in the presence
4202      of signed zeros.  For example, if A and B are zeros of
4203      opposite sign, the first two transformations will change
4204      the sign of the result.  In the last four, the original
4205      expressions give different results for (A=+0, B=-0) and
4206      (A=-0, B=+0), but the transformed expressions do not.
4207
4208      The first two transformations are correct if either A or B
4209      is a NaN.  In the first transformation, the condition will
4210      be false, and B will indeed be chosen.  In the case of the
4211      second transformation, the condition A != B will be true,
4212      and A will be chosen.
4213
4214      The conversions to max() and min() are not correct if B is
4215      a number and A is not.  The conditions in the original
4216      expressions will be false, so all four give B.  The min()
4217      and max() versions would give a NaN instead.  */
4218   if (operand_equal_for_comparison_p (arg01, arg2, arg00))
4219     {
4220       tree comp_op0 = arg00;
4221       tree comp_op1 = arg01;
4222       tree comp_type = TREE_TYPE (comp_op0);
4223
4224       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4225       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4226         {
4227           comp_type = type;
4228           comp_op0 = arg00;
4229           comp_op1 = arg2;
4230         }
4231
4232       switch (comp_code)
4233         {
4234         case EQ_EXPR:
4235           return pedantic_non_lvalue (fold_convert (type, arg2));
4236         case NE_EXPR:
4237           return pedantic_non_lvalue (fold_convert (type, arg00));
4238         case LE_EXPR:
4239         case LT_EXPR:
4240           /* In C++ a ?: expression can be an lvalue, so put the
4241              operand which will be used if they are equal first
4242              so that we can convert this back to the
4243              corresponding COND_EXPR.  */
4244           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00))))
4245             return pedantic_non_lvalue (
4246                      fold_convert (type, fold (build2 (MIN_EXPR, comp_type,
4247                                          (comp_code == LE_EXPR
4248                                           ? comp_op0 : comp_op1),
4249                                          (comp_code == LE_EXPR
4250                                           ? comp_op1 : comp_op0)))));
4251           break;
4252         case GE_EXPR:
4253         case GT_EXPR:
4254           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00))))
4255             return pedantic_non_lvalue (
4256                      fold_convert (type, fold (build2 (MAX_EXPR, comp_type,
4257                                          (comp_code == GE_EXPR
4258                                           ? comp_op0 : comp_op1),
4259                                          (comp_code == GE_EXPR
4260                                           ? comp_op1 : comp_op0)))));
4261           break;
4262         default:
4263           abort ();
4264         }
4265     }
4266
4267   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4268      we might still be able to simplify this.  For example,
4269      if C1 is one less or one more than C2, this might have started
4270      out as a MIN or MAX and been transformed by this function.
4271      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4272
4273   if (INTEGRAL_TYPE_P (type)
4274       && TREE_CODE (arg01) == INTEGER_CST
4275       && TREE_CODE (arg2) == INTEGER_CST)
4276     switch (comp_code)
4277       {
4278       case EQ_EXPR:
4279         /* We can replace A with C1 in this case.  */
4280         arg00 = fold_convert (type, arg01);
4281         return fold (build3 (COND_EXPR, type, arg0, arg00, arg2));
4282
4283       case LT_EXPR:
4284         /* If C1 is C2 + 1, this is min(A, C2).  */
4285         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4286                                OEP_ONLY_CONST)
4287             && operand_equal_p (arg01,
4288                                 const_binop (PLUS_EXPR, arg2,
4289                                              integer_one_node, 0),
4290                                 OEP_ONLY_CONST))
4291           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4292                                                     type, arg00, arg2)));
4293         break;
4294
4295       case LE_EXPR:
4296         /* If C1 is C2 - 1, this is min(A, C2).  */
4297         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4298                                OEP_ONLY_CONST)
4299             && operand_equal_p (arg01,
4300                                 const_binop (MINUS_EXPR, arg2,
4301                                              integer_one_node, 0),
4302                                 OEP_ONLY_CONST))
4303           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4304                                                     type, arg00, arg2)));
4305         break;
4306
4307       case GT_EXPR:
4308         /* If C1 is C2 - 1, this is max(A, C2).  */
4309         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4310                                OEP_ONLY_CONST)
4311             && operand_equal_p (arg01,
4312                                 const_binop (MINUS_EXPR, arg2,
4313                                              integer_one_node, 0),
4314                                 OEP_ONLY_CONST))
4315           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4316                                                     type, arg00, arg2)));
4317         break;
4318
4319       case GE_EXPR:
4320         /* If C1 is C2 + 1, this is max(A, C2).  */
4321         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4322                                OEP_ONLY_CONST)
4323             && operand_equal_p (arg01,
4324                                 const_binop (PLUS_EXPR, arg2,
4325                                              integer_one_node, 0),
4326                                 OEP_ONLY_CONST))
4327           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4328                                                     type, arg00, arg2)));
4329         break;
4330       case NE_EXPR:
4331         break;
4332       default:
4333         abort ();
4334       }
4335
4336   return NULL_TREE;
4337 }
4338
4339
4340 \f
4341 #ifndef RANGE_TEST_NON_SHORT_CIRCUIT
4342 #define RANGE_TEST_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
4343 #endif
4344
4345 /* EXP is some logical combination of boolean tests.  See if we can
4346    merge it into some range test.  Return the new tree if so.  */
4347
4348 static tree
4349 fold_range_test (tree exp)
4350 {
4351   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
4352                || TREE_CODE (exp) == TRUTH_OR_EXPR);
4353   int in0_p, in1_p, in_p;
4354   tree low0, low1, low, high0, high1, high;
4355   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
4356   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
4357   tree tem;
4358
4359   /* If this is an OR operation, invert both sides; we will invert
4360      again at the end.  */
4361   if (or_op)
4362     in0_p = ! in0_p, in1_p = ! in1_p;
4363
4364   /* If both expressions are the same, if we can merge the ranges, and we
4365      can build the range test, return it or it inverted.  If one of the
4366      ranges is always true or always false, consider it to be the same
4367      expression as the other.  */
4368   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4369       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4370                        in1_p, low1, high1)
4371       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
4372                                          lhs != 0 ? lhs
4373                                          : rhs != 0 ? rhs : integer_zero_node,
4374                                          in_p, low, high))))
4375     return or_op ? invert_truthvalue (tem) : tem;
4376
4377   /* On machines where the branch cost is expensive, if this is a
4378      short-circuited branch and the underlying object on both sides
4379      is the same, make a non-short-circuit operation.  */
4380   else if (RANGE_TEST_NON_SHORT_CIRCUIT
4381            && lhs != 0 && rhs != 0
4382            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4383                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
4384            && operand_equal_p (lhs, rhs, 0))
4385     {
4386       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4387          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4388          which cases we can't do this.  */
4389       if (simple_operand_p (lhs))
4390         return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4391                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4392                        TREE_TYPE (exp), TREE_OPERAND (exp, 0),
4393                        TREE_OPERAND (exp, 1));
4394
4395       else if (lang_hooks.decls.global_bindings_p () == 0
4396                && ! CONTAINS_PLACEHOLDER_P (lhs))
4397         {
4398           tree common = save_expr (lhs);
4399
4400           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
4401                                              or_op ? ! in0_p : in0_p,
4402                                              low0, high0))
4403               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
4404                                                  or_op ? ! in1_p : in1_p,
4405                                                  low1, high1))))
4406             return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4407                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4408                            TREE_TYPE (exp), lhs, rhs);
4409         }
4410     }
4411
4412   return 0;
4413 }
4414 \f
4415 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4416    bit value.  Arrange things so the extra bits will be set to zero if and
4417    only if C is signed-extended to its full width.  If MASK is nonzero,
4418    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4419
4420 static tree
4421 unextend (tree c, int p, int unsignedp, tree mask)
4422 {
4423   tree type = TREE_TYPE (c);
4424   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4425   tree temp;
4426
4427   if (p == modesize || unsignedp)
4428     return c;
4429
4430   /* We work by getting just the sign bit into the low-order bit, then
4431      into the high-order bit, then sign-extend.  We then XOR that value
4432      with C.  */
4433   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
4434   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
4435
4436   /* We must use a signed type in order to get an arithmetic right shift.
4437      However, we must also avoid introducing accidental overflows, so that
4438      a subsequent call to integer_zerop will work.  Hence we must
4439      do the type conversion here.  At this point, the constant is either
4440      zero or one, and the conversion to a signed type can never overflow.
4441      We could get an overflow if this conversion is done anywhere else.  */
4442   if (TYPE_UNSIGNED (type))
4443     temp = fold_convert (lang_hooks.types.signed_type (type), temp);
4444
4445   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
4446   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
4447   if (mask != 0)
4448     temp = const_binop (BIT_AND_EXPR, temp,
4449                         fold_convert (TREE_TYPE (c), mask), 0);
4450   /* If necessary, convert the type back to match the type of C.  */
4451   if (TYPE_UNSIGNED (type))
4452     temp = fold_convert (type, temp);
4453
4454   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
4455 }
4456 \f
4457 /* Find ways of folding logical expressions of LHS and RHS:
4458    Try to merge two comparisons to the same innermost item.
4459    Look for range tests like "ch >= '0' && ch <= '9'".
4460    Look for combinations of simple terms on machines with expensive branches
4461    and evaluate the RHS unconditionally.
4462
4463    For example, if we have p->a == 2 && p->b == 4 and we can make an
4464    object large enough to span both A and B, we can do this with a comparison
4465    against the object ANDed with the a mask.
4466
4467    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
4468    operations to do this with one comparison.
4469
4470    We check for both normal comparisons and the BIT_AND_EXPRs made this by
4471    function and the one above.
4472
4473    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
4474    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
4475
4476    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
4477    two operands.
4478
4479    We return the simplified tree or 0 if no optimization is possible.  */
4480
4481 static tree
4482 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
4483 {
4484   /* If this is the "or" of two comparisons, we can do something if
4485      the comparisons are NE_EXPR.  If this is the "and", we can do something
4486      if the comparisons are EQ_EXPR.  I.e.,
4487         (a->b == 2 && a->c == 4) can become (a->new == NEW).
4488
4489      WANTED_CODE is this operation code.  For single bit fields, we can
4490      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
4491      comparison for one-bit fields.  */
4492
4493   enum tree_code wanted_code;
4494   enum tree_code lcode, rcode;
4495   tree ll_arg, lr_arg, rl_arg, rr_arg;
4496   tree ll_inner, lr_inner, rl_inner, rr_inner;
4497   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
4498   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
4499   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
4500   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
4501   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
4502   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
4503   enum machine_mode lnmode, rnmode;
4504   tree ll_mask, lr_mask, rl_mask, rr_mask;
4505   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
4506   tree l_const, r_const;
4507   tree lntype, rntype, result;
4508   int first_bit, end_bit;
4509   int volatilep;
4510
4511   /* Start by getting the comparison codes.  Fail if anything is volatile.
4512      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
4513      it were surrounded with a NE_EXPR.  */
4514
4515   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
4516     return 0;
4517
4518   lcode = TREE_CODE (lhs);
4519   rcode = TREE_CODE (rhs);
4520
4521   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
4522     {
4523       lhs = build2 (NE_EXPR, truth_type, lhs, integer_zero_node);
4524       lcode = NE_EXPR;
4525     }
4526
4527   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
4528     {
4529       rhs = build2 (NE_EXPR, truth_type, rhs, integer_zero_node);
4530       rcode = NE_EXPR;
4531     }
4532
4533   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
4534     return 0;
4535
4536   ll_arg = TREE_OPERAND (lhs, 0);
4537   lr_arg = TREE_OPERAND (lhs, 1);
4538   rl_arg = TREE_OPERAND (rhs, 0);
4539   rr_arg = TREE_OPERAND (rhs, 1);
4540
4541   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
4542   if (simple_operand_p (ll_arg)
4543       && simple_operand_p (lr_arg))
4544     {
4545       tree result;
4546       if (operand_equal_p (ll_arg, rl_arg, 0)
4547           && operand_equal_p (lr_arg, rr_arg, 0))
4548         {
4549           result = combine_comparisons (code, lcode, rcode,
4550                                         truth_type, ll_arg, lr_arg);
4551           if (result)
4552             return result;
4553         }
4554       else if (operand_equal_p (ll_arg, rr_arg, 0)
4555                && operand_equal_p (lr_arg, rl_arg, 0))
4556         {
4557           result = combine_comparisons (code, lcode,
4558                                         swap_tree_comparison (rcode),
4559                                         truth_type, ll_arg, lr_arg);
4560           if (result)
4561             return result;
4562         }
4563     }
4564
4565   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
4566           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
4567
4568   /* If the RHS can be evaluated unconditionally and its operands are
4569      simple, it wins to evaluate the RHS unconditionally on machines
4570      with expensive branches.  In this case, this isn't a comparison
4571      that can be merged.  Avoid doing this if the RHS is a floating-point
4572      comparison since those can trap.  */
4573
4574   if (BRANCH_COST >= 2
4575       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
4576       && simple_operand_p (rl_arg)
4577       && simple_operand_p (rr_arg))
4578     {
4579       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
4580       if (code == TRUTH_OR_EXPR
4581           && lcode == NE_EXPR && integer_zerop (lr_arg)
4582           && rcode == NE_EXPR && integer_zerop (rr_arg)
4583           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4584         return build2 (NE_EXPR, truth_type,
4585                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4586                                ll_arg, rl_arg),
4587                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4588
4589       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
4590       if (code == TRUTH_AND_EXPR
4591           && lcode == EQ_EXPR && integer_zerop (lr_arg)
4592           && rcode == EQ_EXPR && integer_zerop (rr_arg)
4593           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4594         return build2 (EQ_EXPR, truth_type,
4595                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4596                                ll_arg, rl_arg),
4597                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4598
4599       return build2 (code, truth_type, lhs, rhs);
4600     }
4601
4602   /* See if the comparisons can be merged.  Then get all the parameters for
4603      each side.  */
4604
4605   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
4606       || (rcode != EQ_EXPR && rcode != NE_EXPR))
4607     return 0;
4608
4609   volatilep = 0;
4610   ll_inner = decode_field_reference (ll_arg,
4611                                      &ll_bitsize, &ll_bitpos, &ll_mode,
4612                                      &ll_unsignedp, &volatilep, &ll_mask,
4613                                      &ll_and_mask);
4614   lr_inner = decode_field_reference (lr_arg,
4615                                      &lr_bitsize, &lr_bitpos, &lr_mode,
4616                                      &lr_unsignedp, &volatilep, &lr_mask,
4617                                      &lr_and_mask);
4618   rl_inner = decode_field_reference (rl_arg,
4619                                      &rl_bitsize, &rl_bitpos, &rl_mode,
4620                                      &rl_unsignedp, &volatilep, &rl_mask,
4621                                      &rl_and_mask);
4622   rr_inner = decode_field_reference (rr_arg,
4623                                      &rr_bitsize, &rr_bitpos, &rr_mode,
4624                                      &rr_unsignedp, &volatilep, &rr_mask,
4625                                      &rr_and_mask);
4626
4627   /* It must be true that the inner operation on the lhs of each
4628      comparison must be the same if we are to be able to do anything.
4629      Then see if we have constants.  If not, the same must be true for
4630      the rhs's.  */
4631   if (volatilep || ll_inner == 0 || rl_inner == 0
4632       || ! operand_equal_p (ll_inner, rl_inner, 0))
4633     return 0;
4634
4635   if (TREE_CODE (lr_arg) == INTEGER_CST
4636       && TREE_CODE (rr_arg) == INTEGER_CST)
4637     l_const = lr_arg, r_const = rr_arg;
4638   else if (lr_inner == 0 || rr_inner == 0
4639            || ! operand_equal_p (lr_inner, rr_inner, 0))
4640     return 0;
4641   else
4642     l_const = r_const = 0;
4643
4644   /* If either comparison code is not correct for our logical operation,
4645      fail.  However, we can convert a one-bit comparison against zero into
4646      the opposite comparison against that bit being set in the field.  */
4647
4648   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
4649   if (lcode != wanted_code)
4650     {
4651       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
4652         {
4653           /* Make the left operand unsigned, since we are only interested
4654              in the value of one bit.  Otherwise we are doing the wrong
4655              thing below.  */
4656           ll_unsignedp = 1;
4657           l_const = ll_mask;
4658         }
4659       else
4660         return 0;
4661     }
4662
4663   /* This is analogous to the code for l_const above.  */
4664   if (rcode != wanted_code)
4665     {
4666       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
4667         {
4668           rl_unsignedp = 1;
4669           r_const = rl_mask;
4670         }
4671       else
4672         return 0;
4673     }
4674
4675   /* After this point all optimizations will generate bit-field
4676      references, which we might not want.  */
4677   if (! lang_hooks.can_use_bit_fields_p ())
4678     return 0;
4679
4680   /* See if we can find a mode that contains both fields being compared on
4681      the left.  If we can't, fail.  Otherwise, update all constants and masks
4682      to be relative to a field of that size.  */
4683   first_bit = MIN (ll_bitpos, rl_bitpos);
4684   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
4685   lnmode = get_best_mode (end_bit - first_bit, first_bit,
4686                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
4687                           volatilep);
4688   if (lnmode == VOIDmode)
4689     return 0;
4690
4691   lnbitsize = GET_MODE_BITSIZE (lnmode);
4692   lnbitpos = first_bit & ~ (lnbitsize - 1);
4693   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
4694   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
4695
4696   if (BYTES_BIG_ENDIAN)
4697     {
4698       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
4699       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
4700     }
4701
4702   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
4703                          size_int (xll_bitpos), 0);
4704   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
4705                          size_int (xrl_bitpos), 0);
4706
4707   if (l_const)
4708     {
4709       l_const = fold_convert (lntype, l_const);
4710       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
4711       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
4712       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
4713                                         fold (build1 (BIT_NOT_EXPR,
4714                                                       lntype, ll_mask)),
4715                                         0)))
4716         {
4717           warning ("comparison is always %d", wanted_code == NE_EXPR);
4718
4719           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4720         }
4721     }
4722   if (r_const)
4723     {
4724       r_const = fold_convert (lntype, r_const);
4725       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
4726       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
4727       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
4728                                         fold (build1 (BIT_NOT_EXPR,
4729                                                       lntype, rl_mask)),
4730                                         0)))
4731         {
4732           warning ("comparison is always %d", wanted_code == NE_EXPR);
4733
4734           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4735         }
4736     }
4737
4738   /* If the right sides are not constant, do the same for it.  Also,
4739      disallow this optimization if a size or signedness mismatch occurs
4740      between the left and right sides.  */
4741   if (l_const == 0)
4742     {
4743       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4744           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4745           /* Make sure the two fields on the right
4746              correspond to the left without being swapped.  */
4747           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4748         return 0;
4749
4750       first_bit = MIN (lr_bitpos, rr_bitpos);
4751       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4752       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4753                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4754                               volatilep);
4755       if (rnmode == VOIDmode)
4756         return 0;
4757
4758       rnbitsize = GET_MODE_BITSIZE (rnmode);
4759       rnbitpos = first_bit & ~ (rnbitsize - 1);
4760       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
4761       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4762
4763       if (BYTES_BIG_ENDIAN)
4764         {
4765           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4766           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4767         }
4768
4769       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
4770                              size_int (xlr_bitpos), 0);
4771       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
4772                              size_int (xrr_bitpos), 0);
4773
4774       /* Make a mask that corresponds to both fields being compared.
4775          Do this for both items being compared.  If the operands are the
4776          same size and the bits being compared are in the same position
4777          then we can do this by masking both and comparing the masked
4778          results.  */
4779       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4780       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4781       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4782         {
4783           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4784                                     ll_unsignedp || rl_unsignedp);
4785           if (! all_ones_mask_p (ll_mask, lnbitsize))
4786             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
4787
4788           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4789                                     lr_unsignedp || rr_unsignedp);
4790           if (! all_ones_mask_p (lr_mask, rnbitsize))
4791             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
4792
4793           return build2 (wanted_code, truth_type, lhs, rhs);
4794         }
4795
4796       /* There is still another way we can do something:  If both pairs of
4797          fields being compared are adjacent, we may be able to make a wider
4798          field containing them both.
4799
4800          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4801          the mask must be shifted to account for the shift done by
4802          make_bit_field_ref.  */
4803       if ((ll_bitsize + ll_bitpos == rl_bitpos
4804            && lr_bitsize + lr_bitpos == rr_bitpos)
4805           || (ll_bitpos == rl_bitpos + rl_bitsize
4806               && lr_bitpos == rr_bitpos + rr_bitsize))
4807         {
4808           tree type;
4809
4810           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4811                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4812           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4813                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4814
4815           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4816                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4817           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4818                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4819
4820           /* Convert to the smaller type before masking out unwanted bits.  */
4821           type = lntype;
4822           if (lntype != rntype)
4823             {
4824               if (lnbitsize > rnbitsize)
4825                 {
4826                   lhs = fold_convert (rntype, lhs);
4827                   ll_mask = fold_convert (rntype, ll_mask);
4828                   type = rntype;
4829                 }
4830               else if (lnbitsize < rnbitsize)
4831                 {
4832                   rhs = fold_convert (lntype, rhs);
4833                   lr_mask = fold_convert (lntype, lr_mask);
4834                   type = lntype;
4835                 }
4836             }
4837
4838           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4839             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
4840
4841           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4842             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
4843
4844           return build2 (wanted_code, truth_type, lhs, rhs);
4845         }
4846
4847       return 0;
4848     }
4849
4850   /* Handle the case of comparisons with constants.  If there is something in
4851      common between the masks, those bits of the constants must be the same.
4852      If not, the condition is always false.  Test for this to avoid generating
4853      incorrect code below.  */
4854   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4855   if (! integer_zerop (result)
4856       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4857                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4858     {
4859       if (wanted_code == NE_EXPR)
4860         {
4861           warning ("`or' of unmatched not-equal tests is always 1");
4862           return constant_boolean_node (true, truth_type);
4863         }
4864       else
4865         {
4866           warning ("`and' of mutually exclusive equal-tests is always 0");
4867           return constant_boolean_node (false, truth_type);
4868         }
4869     }
4870
4871   /* Construct the expression we will return.  First get the component
4872      reference we will make.  Unless the mask is all ones the width of
4873      that field, perform the mask operation.  Then compare with the
4874      merged constant.  */
4875   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4876                                ll_unsignedp || rl_unsignedp);
4877
4878   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4879   if (! all_ones_mask_p (ll_mask, lnbitsize))
4880     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
4881
4882   return build2 (wanted_code, truth_type, result,
4883                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4884 }
4885 \f
4886 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4887    constant.  */
4888
4889 static tree
4890 optimize_minmax_comparison (tree t)
4891 {
4892   tree type = TREE_TYPE (t);
4893   tree arg0 = TREE_OPERAND (t, 0);
4894   enum tree_code op_code;
4895   tree comp_const = TREE_OPERAND (t, 1);
4896   tree minmax_const;
4897   int consts_equal, consts_lt;
4898   tree inner;
4899
4900   STRIP_SIGN_NOPS (arg0);
4901
4902   op_code = TREE_CODE (arg0);
4903   minmax_const = TREE_OPERAND (arg0, 1);
4904   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4905   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4906   inner = TREE_OPERAND (arg0, 0);
4907
4908   /* If something does not permit us to optimize, return the original tree.  */
4909   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4910       || TREE_CODE (comp_const) != INTEGER_CST
4911       || TREE_CONSTANT_OVERFLOW (comp_const)
4912       || TREE_CODE (minmax_const) != INTEGER_CST
4913       || TREE_CONSTANT_OVERFLOW (minmax_const))
4914     return t;
4915
4916   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4917      and GT_EXPR, doing the rest with recursive calls using logical
4918      simplifications.  */
4919   switch (TREE_CODE (t))
4920     {
4921     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4922       return
4923         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4924
4925     case GE_EXPR:
4926       return
4927         fold (build2 (TRUTH_ORIF_EXPR, type,
4928                       optimize_minmax_comparison
4929                       (build2 (EQ_EXPR, type, arg0, comp_const)),
4930                       optimize_minmax_comparison
4931                       (build2 (GT_EXPR, type, arg0, comp_const))));
4932
4933     case EQ_EXPR:
4934       if (op_code == MAX_EXPR && consts_equal)
4935         /* MAX (X, 0) == 0  ->  X <= 0  */
4936         return fold (build2 (LE_EXPR, type, inner, comp_const));
4937
4938       else if (op_code == MAX_EXPR && consts_lt)
4939         /* MAX (X, 0) == 5  ->  X == 5   */
4940         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4941
4942       else if (op_code == MAX_EXPR)
4943         /* MAX (X, 0) == -1  ->  false  */
4944         return omit_one_operand (type, integer_zero_node, inner);
4945
4946       else if (consts_equal)
4947         /* MIN (X, 0) == 0  ->  X >= 0  */
4948         return fold (build2 (GE_EXPR, type, inner, comp_const));
4949
4950       else if (consts_lt)
4951         /* MIN (X, 0) == 5  ->  false  */
4952         return omit_one_operand (type, integer_zero_node, inner);
4953
4954       else
4955         /* MIN (X, 0) == -1  ->  X == -1  */
4956         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4957
4958     case GT_EXPR:
4959       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4960         /* MAX (X, 0) > 0  ->  X > 0
4961            MAX (X, 0) > 5  ->  X > 5  */
4962         return fold (build2 (GT_EXPR, type, inner, comp_const));
4963
4964       else if (op_code == MAX_EXPR)
4965         /* MAX (X, 0) > -1  ->  true  */
4966         return omit_one_operand (type, integer_one_node, inner);
4967
4968       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4969         /* MIN (X, 0) > 0  ->  false
4970            MIN (X, 0) > 5  ->  false  */
4971         return omit_one_operand (type, integer_zero_node, inner);
4972
4973       else
4974         /* MIN (X, 0) > -1  ->  X > -1  */
4975         return fold (build2 (GT_EXPR, type, inner, comp_const));
4976
4977     default:
4978       return t;
4979     }
4980 }
4981 \f
4982 /* T is an integer expression that is being multiplied, divided, or taken a
4983    modulus (CODE says which and what kind of divide or modulus) by a
4984    constant C.  See if we can eliminate that operation by folding it with
4985    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4986    should be used for the computation if wider than our type.
4987
4988    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
4989    (X * 2) + (Y * 4).  We must, however, be assured that either the original
4990    expression would not overflow or that overflow is undefined for the type
4991    in the language in question.
4992
4993    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4994    the machine has a multiply-accumulate insn or that this is part of an
4995    addressing calculation.
4996
4997    If we return a non-null expression, it is an equivalent form of the
4998    original computation, but need not be in the original type.  */
4999
5000 static tree
5001 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type)
5002 {
5003   /* To avoid exponential search depth, refuse to allow recursion past
5004      three levels.  Beyond that (1) it's highly unlikely that we'll find
5005      something interesting and (2) we've probably processed it before
5006      when we built the inner expression.  */
5007
5008   static int depth;
5009   tree ret;
5010
5011   if (depth > 3)
5012     return NULL;
5013
5014   depth++;
5015   ret = extract_muldiv_1 (t, c, code, wide_type);
5016   depth--;
5017
5018   return ret;
5019 }
5020
5021 static tree
5022 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
5023 {
5024   tree type = TREE_TYPE (t);
5025   enum tree_code tcode = TREE_CODE (t);
5026   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5027                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5028                 ? wide_type : type);
5029   tree t1, t2;
5030   int same_p = tcode == code;
5031   tree op0 = NULL_TREE, op1 = NULL_TREE;
5032
5033   /* Don't deal with constants of zero here; they confuse the code below.  */
5034   if (integer_zerop (c))
5035     return NULL_TREE;
5036
5037   if (TREE_CODE_CLASS (tcode) == '1')
5038     op0 = TREE_OPERAND (t, 0);
5039
5040   if (TREE_CODE_CLASS (tcode) == '2')
5041     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5042
5043   /* Note that we need not handle conditional operations here since fold
5044      already handles those cases.  So just do arithmetic here.  */
5045   switch (tcode)
5046     {
5047     case INTEGER_CST:
5048       /* For a constant, we can always simplify if we are a multiply
5049          or (for divide and modulus) if it is a multiple of our constant.  */
5050       if (code == MULT_EXPR
5051           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
5052         return const_binop (code, fold_convert (ctype, t),
5053                             fold_convert (ctype, c), 0);
5054       break;
5055
5056     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
5057       /* If op0 is an expression ...  */
5058       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
5059            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
5060            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
5061            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
5062           /* ... and is unsigned, and its type is smaller than ctype,
5063              then we cannot pass through as widening.  */
5064           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
5065                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5066                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5067                && (GET_MODE_SIZE (TYPE_MODE (ctype))
5068                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
5069               /* ... or its type is larger than ctype,
5070                  then we cannot pass through this truncation.  */
5071               || (GET_MODE_SIZE (TYPE_MODE (ctype))
5072                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
5073               /* ... or signedness changes for division or modulus,
5074                  then we cannot pass through this conversion.  */
5075               || (code != MULT_EXPR
5076                   && (TYPE_UNSIGNED (ctype)
5077                       != TYPE_UNSIGNED (TREE_TYPE (op0))))))
5078         break;
5079
5080       /* Pass the constant down and see if we can make a simplification.  If
5081          we can, replace this expression with the inner simplification for
5082          possible later conversion to our or some other type.  */
5083       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5084           && TREE_CODE (t2) == INTEGER_CST
5085           && ! TREE_CONSTANT_OVERFLOW (t2)
5086           && (0 != (t1 = extract_muldiv (op0, t2, code,
5087                                          code == MULT_EXPR
5088                                          ? ctype : NULL_TREE))))
5089         return t1;
5090       break;
5091
5092     case NEGATE_EXPR:  case ABS_EXPR:
5093       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5094         return fold (build1 (tcode, ctype, fold_convert (ctype, t1)));
5095       break;
5096
5097     case MIN_EXPR:  case MAX_EXPR:
5098       /* If widening the type changes the signedness, then we can't perform
5099          this optimization as that changes the result.  */
5100       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5101         break;
5102
5103       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5104       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
5105           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
5106         {
5107           if (tree_int_cst_sgn (c) < 0)
5108             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5109
5110           return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5111                                fold_convert (ctype, t2)));
5112         }
5113       break;
5114
5115     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5116       /* If the second operand is constant, this is a multiplication
5117          or floor division, by a power of two, so we can treat it that
5118          way unless the multiplier or divisor overflows.  */
5119       if (TREE_CODE (op1) == INTEGER_CST
5120           /* const_binop may not detect overflow correctly,
5121              so check for it explicitly here.  */
5122           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5123           && TREE_INT_CST_HIGH (op1) == 0
5124           && 0 != (t1 = fold_convert (ctype,
5125                                       const_binop (LSHIFT_EXPR,
5126                                                    size_one_node,
5127                                                    op1, 0)))
5128           && ! TREE_OVERFLOW (t1))
5129         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5130                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5131                                        ctype, fold_convert (ctype, op0), t1),
5132                                c, code, wide_type);
5133       break;
5134
5135     case PLUS_EXPR:  case MINUS_EXPR:
5136       /* See if we can eliminate the operation on both sides.  If we can, we
5137          can return a new PLUS or MINUS.  If we can't, the only remaining
5138          cases where we can do anything are if the second operand is a
5139          constant.  */
5140       t1 = extract_muldiv (op0, c, code, wide_type);
5141       t2 = extract_muldiv (op1, c, code, wide_type);
5142       if (t1 != 0 && t2 != 0
5143           && (code == MULT_EXPR
5144               /* If not multiplication, we can only do this if both operands
5145                  are divisible by c.  */
5146               || (multiple_of_p (ctype, op0, c)
5147                   && multiple_of_p (ctype, op1, c))))
5148         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5149                              fold_convert (ctype, t2)));
5150
5151       /* If this was a subtraction, negate OP1 and set it to be an addition.
5152          This simplifies the logic below.  */
5153       if (tcode == MINUS_EXPR)
5154         tcode = PLUS_EXPR, op1 = negate_expr (op1);
5155
5156       if (TREE_CODE (op1) != INTEGER_CST)
5157         break;
5158
5159       /* If either OP1 or C are negative, this optimization is not safe for
5160          some of the division and remainder types while for others we need
5161          to change the code.  */
5162       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5163         {
5164           if (code == CEIL_DIV_EXPR)
5165             code = FLOOR_DIV_EXPR;
5166           else if (code == FLOOR_DIV_EXPR)
5167             code = CEIL_DIV_EXPR;
5168           else if (code != MULT_EXPR
5169                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5170             break;
5171         }
5172
5173       /* If it's a multiply or a division/modulus operation of a multiple
5174          of our constant, do the operation and verify it doesn't overflow.  */
5175       if (code == MULT_EXPR
5176           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5177         {
5178           op1 = const_binop (code, fold_convert (ctype, op1),
5179                              fold_convert (ctype, c), 0);
5180           /* We allow the constant to overflow with wrapping semantics.  */
5181           if (op1 == 0
5182               || (TREE_OVERFLOW (op1) && ! flag_wrapv))
5183             break;
5184         }
5185       else
5186         break;
5187
5188       /* If we have an unsigned type is not a sizetype, we cannot widen
5189          the operation since it will change the result if the original
5190          computation overflowed.  */
5191       if (TYPE_UNSIGNED (ctype)
5192           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5193           && ctype != type)
5194         break;
5195
5196       /* If we were able to eliminate our operation from the first side,
5197          apply our operation to the second side and reform the PLUS.  */
5198       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5199         return fold (build2 (tcode, ctype, fold_convert (ctype, t1), op1));
5200
5201       /* The last case is if we are a multiply.  In that case, we can
5202          apply the distributive law to commute the multiply and addition
5203          if the multiplication of the constants doesn't overflow.  */
5204       if (code == MULT_EXPR)
5205         return fold (build2 (tcode, ctype,
5206                              fold (build2 (code, ctype,
5207                                            fold_convert (ctype, op0),
5208                                            fold_convert (ctype, c))),
5209                              op1));
5210
5211       break;
5212
5213     case MULT_EXPR:
5214       /* We have a special case here if we are doing something like
5215          (C * 8) % 4 since we know that's zero.  */
5216       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5217            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5218           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5219           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5220         return omit_one_operand (type, integer_zero_node, op0);
5221
5222       /* ... fall through ...  */
5223
5224     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5225     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5226       /* If we can extract our operation from the LHS, do so and return a
5227          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5228          do something only if the second operand is a constant.  */
5229       if (same_p
5230           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5231         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5232                              fold_convert (ctype, op1)));
5233       else if (tcode == MULT_EXPR && code == MULT_EXPR
5234                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
5235         return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5236                              fold_convert (ctype, t1)));
5237       else if (TREE_CODE (op1) != INTEGER_CST)
5238         return 0;
5239
5240       /* If these are the same operation types, we can associate them
5241          assuming no overflow.  */
5242       if (tcode == code
5243           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5244                                      fold_convert (ctype, c), 0))
5245           && ! TREE_OVERFLOW (t1))
5246         return fold (build2 (tcode, ctype, fold_convert (ctype, op0), t1));
5247
5248       /* If these operations "cancel" each other, we have the main
5249          optimizations of this pass, which occur when either constant is a
5250          multiple of the other, in which case we replace this with either an
5251          operation or CODE or TCODE.
5252
5253          If we have an unsigned type that is not a sizetype, we cannot do
5254          this since it will change the result if the original computation
5255          overflowed.  */
5256       if ((! TYPE_UNSIGNED (ctype)
5257            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5258           && ! flag_wrapv
5259           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5260               || (tcode == MULT_EXPR
5261                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5262                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
5263         {
5264           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5265             return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5266                                  fold_convert (ctype,
5267                                                const_binop (TRUNC_DIV_EXPR,
5268                                                             op1, c, 0))));
5269           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5270             return fold (build2 (code, ctype, fold_convert (ctype, op0),
5271                                  fold_convert (ctype,
5272                                                const_binop (TRUNC_DIV_EXPR,
5273                                                             c, op1, 0))));
5274         }
5275       break;
5276
5277     default:
5278       break;
5279     }
5280
5281   return 0;
5282 }
5283 \f
5284 /* Return a node which has the indicated constant VALUE (either 0 or
5285    1), and is of the indicated TYPE.  */
5286
5287 static tree
5288 constant_boolean_node (int value, tree type)
5289 {
5290   if (type == integer_type_node)
5291     return value ? integer_one_node : integer_zero_node;
5292   else if (type == boolean_type_node)
5293     return value ? boolean_true_node : boolean_false_node;
5294   else if (TREE_CODE (type) == BOOLEAN_TYPE)
5295     return lang_hooks.truthvalue_conversion (value ? integer_one_node
5296                                                    : integer_zero_node);
5297   else
5298     {
5299       tree t = build_int_2 (value, 0);
5300
5301       TREE_TYPE (t) = type;
5302       return t;
5303     }
5304 }
5305
5306 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5307    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5308    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5309    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5310    COND is the first argument to CODE; otherwise (as in the example
5311    given here), it is the second argument.  TYPE is the type of the
5312    original expression.  Return NULL_TREE if no simplification is
5313    possible.  */
5314
5315 static tree
5316 fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
5317                                      tree cond, tree arg, int cond_first_p)
5318 {
5319   tree test, true_value, false_value;
5320   tree lhs = NULL_TREE;
5321   tree rhs = NULL_TREE;
5322
5323   /* This transformation is only worthwhile if we don't have to wrap
5324      arg in a SAVE_EXPR, and the operation can be simplified on atleast
5325      one of the branches once its pushed inside the COND_EXPR.  */
5326   if (!TREE_CONSTANT (arg))
5327     return NULL_TREE;
5328
5329   if (TREE_CODE (cond) == COND_EXPR)
5330     {
5331       test = TREE_OPERAND (cond, 0);
5332       true_value = TREE_OPERAND (cond, 1);
5333       false_value = TREE_OPERAND (cond, 2);
5334       /* If this operand throws an expression, then it does not make
5335          sense to try to perform a logical or arithmetic operation
5336          involving it.  */
5337       if (VOID_TYPE_P (TREE_TYPE (true_value)))
5338         lhs = true_value;
5339       if (VOID_TYPE_P (TREE_TYPE (false_value)))
5340         rhs = false_value;
5341     }
5342   else
5343     {
5344       tree testtype = TREE_TYPE (cond);
5345       test = cond;
5346       true_value = constant_boolean_node (true, testtype);
5347       false_value = constant_boolean_node (false, testtype);
5348     }
5349
5350   if (lhs == 0)
5351     lhs = fold (cond_first_p ? build2 (code, type, true_value, arg)
5352                              : build2 (code, type, arg, true_value));
5353   if (rhs == 0)
5354     rhs = fold (cond_first_p ? build2 (code, type, false_value, arg)
5355                              : build2 (code, type, arg, false_value));
5356
5357   test = fold (build3 (COND_EXPR, type, test, lhs, rhs));
5358   return fold_convert (type, test);
5359 }
5360
5361 \f
5362 /* Subroutine of fold() that checks for the addition of +/- 0.0.
5363
5364    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
5365    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
5366    ADDEND is the same as X.
5367
5368    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
5369    and finite.  The problematic cases are when X is zero, and its mode
5370    has signed zeros.  In the case of rounding towards -infinity,
5371    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
5372    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
5373
5374 static bool
5375 fold_real_zero_addition_p (tree type, tree addend, int negate)
5376 {
5377   if (!real_zerop (addend))
5378     return false;
5379
5380   /* Don't allow the fold with -fsignaling-nans.  */
5381   if (HONOR_SNANS (TYPE_MODE (type)))
5382     return false;
5383
5384   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
5385   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
5386     return true;
5387
5388   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
5389   if (TREE_CODE (addend) == REAL_CST
5390       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
5391     negate = !negate;
5392
5393   /* The mode has signed zeros, and we have to honor their sign.
5394      In this situation, there is only one case we can return true for.
5395      X - 0 is the same as X unless rounding towards -infinity is
5396      supported.  */
5397   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
5398 }
5399
5400 /* Subroutine of fold() that checks comparisons of built-in math
5401    functions against real constants.
5402
5403    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
5404    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
5405    is the type of the result and ARG0 and ARG1 are the operands of the
5406    comparison.  ARG1 must be a TREE_REAL_CST.
5407
5408    The function returns the constant folded tree if a simplification
5409    can be made, and NULL_TREE otherwise.  */
5410
5411 static tree
5412 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
5413                      tree type, tree arg0, tree arg1)
5414 {
5415   REAL_VALUE_TYPE c;
5416
5417   if (BUILTIN_SQRT_P (fcode))
5418     {
5419       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
5420       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
5421
5422       c = TREE_REAL_CST (arg1);
5423       if (REAL_VALUE_NEGATIVE (c))
5424         {
5425           /* sqrt(x) < y is always false, if y is negative.  */
5426           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
5427             return omit_one_operand (type, integer_zero_node, arg);
5428
5429           /* sqrt(x) > y is always true, if y is negative and we
5430              don't care about NaNs, i.e. negative values of x.  */
5431           if (code == NE_EXPR || !HONOR_NANS (mode))
5432             return omit_one_operand (type, integer_one_node, arg);
5433
5434           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
5435           return fold (build2 (GE_EXPR, type, arg,
5436                                build_real (TREE_TYPE (arg), dconst0)));
5437         }
5438       else if (code == GT_EXPR || code == GE_EXPR)
5439         {
5440           REAL_VALUE_TYPE c2;
5441
5442           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5443           real_convert (&c2, mode, &c2);
5444
5445           if (REAL_VALUE_ISINF (c2))
5446             {
5447               /* sqrt(x) > y is x == +Inf, when y is very large.  */
5448               if (HONOR_INFINITIES (mode))
5449                 return fold (build2 (EQ_EXPR, type, arg,
5450                                      build_real (TREE_TYPE (arg), c2)));
5451
5452               /* sqrt(x) > y is always false, when y is very large
5453                  and we don't care about infinities.  */
5454               return omit_one_operand (type, integer_zero_node, arg);
5455             }
5456
5457           /* sqrt(x) > c is the same as x > c*c.  */
5458           return fold (build2 (code, type, arg,
5459                                build_real (TREE_TYPE (arg), c2)));
5460         }
5461       else if (code == LT_EXPR || code == LE_EXPR)
5462         {
5463           REAL_VALUE_TYPE c2;
5464
5465           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5466           real_convert (&c2, mode, &c2);
5467
5468           if (REAL_VALUE_ISINF (c2))
5469             {
5470               /* sqrt(x) < y is always true, when y is a very large
5471                  value and we don't care about NaNs or Infinities.  */
5472               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
5473                 return omit_one_operand (type, integer_one_node, arg);
5474
5475               /* sqrt(x) < y is x != +Inf when y is very large and we
5476                  don't care about NaNs.  */
5477               if (! HONOR_NANS (mode))
5478                 return fold (build2 (NE_EXPR, type, arg,
5479                                      build_real (TREE_TYPE (arg), c2)));
5480
5481               /* sqrt(x) < y is x >= 0 when y is very large and we
5482                  don't care about Infinities.  */
5483               if (! HONOR_INFINITIES (mode))
5484                 return fold (build2 (GE_EXPR, type, arg,
5485                                      build_real (TREE_TYPE (arg), dconst0)));
5486
5487               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
5488               if (lang_hooks.decls.global_bindings_p () != 0
5489                   || CONTAINS_PLACEHOLDER_P (arg))
5490                 return NULL_TREE;
5491
5492               arg = save_expr (arg);
5493               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5494                                    fold (build2 (GE_EXPR, type, arg,
5495                                                  build_real (TREE_TYPE (arg),
5496                                                              dconst0))),
5497                                    fold (build2 (NE_EXPR, type, arg,
5498                                                  build_real (TREE_TYPE (arg),
5499                                                              c2)))));
5500             }
5501
5502           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
5503           if (! HONOR_NANS (mode))
5504             return fold (build2 (code, type, arg,
5505                                  build_real (TREE_TYPE (arg), c2)));
5506
5507           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
5508           if (lang_hooks.decls.global_bindings_p () == 0
5509               && ! CONTAINS_PLACEHOLDER_P (arg))
5510             {
5511               arg = save_expr (arg);
5512               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5513                                    fold (build2 (GE_EXPR, type, arg,
5514                                                  build_real (TREE_TYPE (arg),
5515                                                              dconst0))),
5516                                    fold (build2 (code, type, arg,
5517                                                  build_real (TREE_TYPE (arg),
5518                                                              c2)))));
5519             }
5520         }
5521     }
5522
5523   return NULL_TREE;
5524 }
5525
5526 /* Subroutine of fold() that optimizes comparisons against Infinities,
5527    either +Inf or -Inf.
5528
5529    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5530    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5531    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5532
5533    The function returns the constant folded tree if a simplification
5534    can be made, and NULL_TREE otherwise.  */
5535
5536 static tree
5537 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5538 {
5539   enum machine_mode mode;
5540   REAL_VALUE_TYPE max;
5541   tree temp;
5542   bool neg;
5543
5544   mode = TYPE_MODE (TREE_TYPE (arg0));
5545
5546   /* For negative infinity swap the sense of the comparison.  */
5547   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
5548   if (neg)
5549     code = swap_tree_comparison (code);
5550
5551   switch (code)
5552     {
5553     case GT_EXPR:
5554       /* x > +Inf is always false, if with ignore sNANs.  */
5555       if (HONOR_SNANS (mode))
5556         return NULL_TREE;
5557       return omit_one_operand (type, integer_zero_node, arg0);
5558
5559     case LE_EXPR:
5560       /* x <= +Inf is always true, if we don't case about NaNs.  */
5561       if (! HONOR_NANS (mode))
5562         return omit_one_operand (type, integer_one_node, arg0);
5563
5564       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
5565       if (lang_hooks.decls.global_bindings_p () == 0
5566           && ! CONTAINS_PLACEHOLDER_P (arg0))
5567         {
5568           arg0 = save_expr (arg0);
5569           return fold (build2 (EQ_EXPR, type, arg0, arg0));
5570         }
5571       break;
5572
5573     case EQ_EXPR:
5574     case GE_EXPR:
5575       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
5576       real_maxval (&max, neg, mode);
5577       return fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5578                            arg0, build_real (TREE_TYPE (arg0), max)));
5579
5580     case LT_EXPR:
5581       /* x < +Inf is always equal to x <= DBL_MAX.  */
5582       real_maxval (&max, neg, mode);
5583       return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5584                            arg0, build_real (TREE_TYPE (arg0), max)));
5585
5586     case NE_EXPR:
5587       /* x != +Inf is always equal to !(x > DBL_MAX).  */
5588       real_maxval (&max, neg, mode);
5589       if (! HONOR_NANS (mode))
5590         return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5591                              arg0, build_real (TREE_TYPE (arg0), max)));
5592
5593       /* The transformation below creates non-gimple code and thus is
5594          not appropriate if we are in gimple form.  */
5595       if (in_gimple_form)
5596         return NULL_TREE;
5597
5598       temp = fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5599                            arg0, build_real (TREE_TYPE (arg0), max)));
5600       return fold (build1 (TRUTH_NOT_EXPR, type, temp));
5601
5602     default:
5603       break;
5604     }
5605
5606   return NULL_TREE;
5607 }
5608
5609 /* Subroutine of fold() that optimizes comparisons of a division by
5610    a nonzero integer constant against an integer constant, i.e.
5611    X/C1 op C2.
5612
5613    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5614    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5615    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5616
5617    The function returns the constant folded tree if a simplification
5618    can be made, and NULL_TREE otherwise.  */
5619
5620 static tree
5621 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5622 {
5623   tree prod, tmp, hi, lo;
5624   tree arg00 = TREE_OPERAND (arg0, 0);
5625   tree arg01 = TREE_OPERAND (arg0, 1);
5626   unsigned HOST_WIDE_INT lpart;
5627   HOST_WIDE_INT hpart;
5628   int overflow;
5629
5630   /* We have to do this the hard way to detect unsigned overflow.
5631      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
5632   overflow = mul_double (TREE_INT_CST_LOW (arg01),
5633                          TREE_INT_CST_HIGH (arg01),
5634                          TREE_INT_CST_LOW (arg1),
5635                          TREE_INT_CST_HIGH (arg1), &lpart, &hpart);
5636   prod = build_int_2 (lpart, hpart);
5637   TREE_TYPE (prod) = TREE_TYPE (arg00);
5638   TREE_OVERFLOW (prod) = force_fit_type (prod, overflow)
5639                          || TREE_INT_CST_HIGH (prod) != hpart
5640                          || TREE_INT_CST_LOW (prod) != lpart;
5641   TREE_CONSTANT_OVERFLOW (prod) = TREE_OVERFLOW (prod);
5642
5643   if (TYPE_UNSIGNED (TREE_TYPE (arg0)))
5644     {
5645       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5646       lo = prod;
5647
5648       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
5649       overflow = add_double (TREE_INT_CST_LOW (prod),
5650                              TREE_INT_CST_HIGH (prod),
5651                              TREE_INT_CST_LOW (tmp),
5652                              TREE_INT_CST_HIGH (tmp),
5653                              &lpart, &hpart);
5654       hi = build_int_2 (lpart, hpart);
5655       TREE_TYPE (hi) = TREE_TYPE (arg00);
5656       TREE_OVERFLOW (hi) = force_fit_type (hi, overflow)
5657                            || TREE_INT_CST_HIGH (hi) != hpart
5658                            || TREE_INT_CST_LOW (hi) != lpart
5659                            || TREE_OVERFLOW (prod);
5660       TREE_CONSTANT_OVERFLOW (hi) = TREE_OVERFLOW (hi);
5661     }
5662   else if (tree_int_cst_sgn (arg01) >= 0)
5663     {
5664       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5665       switch (tree_int_cst_sgn (arg1))
5666         {
5667         case -1:
5668           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5669           hi = prod;
5670           break;
5671
5672         case  0:
5673           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
5674           hi = tmp;
5675           break;
5676
5677         case  1:
5678           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5679           lo = prod;
5680           break;
5681
5682         default:
5683           abort ();
5684         }
5685     }
5686   else
5687     {
5688       tmp = int_const_binop (PLUS_EXPR, arg01, integer_one_node, 0);
5689       switch (tree_int_cst_sgn (arg1))
5690         {
5691         case -1:
5692           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5693           lo = prod;
5694           break;
5695
5696         case  0:
5697           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
5698           lo = tmp;
5699           break;
5700
5701         case  1:
5702           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5703           hi = prod;
5704           break;
5705
5706         default:
5707           abort ();
5708         }
5709     }
5710
5711   switch (code)
5712     {
5713     case EQ_EXPR:
5714       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5715         return omit_one_operand (type, integer_zero_node, arg00);
5716       if (TREE_OVERFLOW (hi))
5717         return fold (build2 (GE_EXPR, type, arg00, lo));
5718       if (TREE_OVERFLOW (lo))
5719         return fold (build2 (LE_EXPR, type, arg00, hi));
5720       return build_range_check (type, arg00, 1, lo, hi);
5721
5722     case NE_EXPR:
5723       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5724         return omit_one_operand (type, integer_one_node, arg00);
5725       if (TREE_OVERFLOW (hi))
5726         return fold (build2 (LT_EXPR, type, arg00, lo));
5727       if (TREE_OVERFLOW (lo))
5728         return fold (build2 (GT_EXPR, type, arg00, hi));
5729       return build_range_check (type, arg00, 0, lo, hi);
5730
5731     case LT_EXPR:
5732       if (TREE_OVERFLOW (lo))
5733         return omit_one_operand (type, integer_zero_node, arg00);
5734       return fold (build2 (LT_EXPR, type, arg00, lo));
5735
5736     case LE_EXPR:
5737       if (TREE_OVERFLOW (hi))
5738         return omit_one_operand (type, integer_one_node, arg00);
5739       return fold (build2 (LE_EXPR, type, arg00, hi));
5740
5741     case GT_EXPR:
5742       if (TREE_OVERFLOW (hi))
5743         return omit_one_operand (type, integer_zero_node, arg00);
5744       return fold (build2 (GT_EXPR, type, arg00, hi));
5745
5746     case GE_EXPR:
5747       if (TREE_OVERFLOW (lo))
5748         return omit_one_operand (type, integer_one_node, arg00);
5749       return fold (build2 (GE_EXPR, type, arg00, lo));
5750
5751     default:
5752       break;
5753     }
5754
5755   return NULL_TREE;
5756 }
5757
5758
5759 /* If CODE with arguments ARG0 and ARG1 represents a single bit
5760    equality/inequality test, then return a simplified form of
5761    the test using shifts and logical operations.  Otherwise return
5762    NULL.  TYPE is the desired result type.  */
5763
5764 tree
5765 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
5766                       tree result_type)
5767 {
5768   /* If this is a TRUTH_NOT_EXPR, it may have a single bit test inside
5769      operand 0.  */
5770   if (code == TRUTH_NOT_EXPR)
5771     {
5772       code = TREE_CODE (arg0);
5773       if (code != NE_EXPR && code != EQ_EXPR)
5774         return NULL_TREE;
5775
5776       /* Extract the arguments of the EQ/NE.  */
5777       arg1 = TREE_OPERAND (arg0, 1);
5778       arg0 = TREE_OPERAND (arg0, 0);
5779
5780       /* This requires us to invert the code.  */
5781       code = (code == EQ_EXPR ? NE_EXPR : EQ_EXPR);
5782     }
5783
5784   /* If this is testing a single bit, we can optimize the test.  */
5785   if ((code == NE_EXPR || code == EQ_EXPR)
5786       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
5787       && integer_pow2p (TREE_OPERAND (arg0, 1)))
5788     {
5789       tree inner = TREE_OPERAND (arg0, 0);
5790       tree type = TREE_TYPE (arg0);
5791       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
5792       enum machine_mode operand_mode = TYPE_MODE (type);
5793       int ops_unsigned;
5794       tree signed_type, unsigned_type, intermediate_type;
5795       tree arg00;
5796
5797       /* If we have (A & C) != 0 where C is the sign bit of A, convert
5798          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
5799       arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
5800       if (arg00 != NULL_TREE
5801           /* This is only a win if casting to a signed type is cheap,
5802              i.e. when arg00's type is not a partial mode.  */
5803           && TYPE_PRECISION (TREE_TYPE (arg00))
5804              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
5805         {
5806           tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
5807           return fold (build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
5808                                result_type, fold_convert (stype, arg00),
5809                                fold_convert (stype, integer_zero_node)));
5810         }
5811
5812       /* Otherwise we have (A & C) != 0 where C is a single bit,
5813          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
5814          Similarly for (A & C) == 0.  */
5815
5816       /* If INNER is a right shift of a constant and it plus BITNUM does
5817          not overflow, adjust BITNUM and INNER.  */
5818       if (TREE_CODE (inner) == RSHIFT_EXPR
5819           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
5820           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
5821           && bitnum < TYPE_PRECISION (type)
5822           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
5823                                    bitnum - TYPE_PRECISION (type)))
5824         {
5825           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
5826           inner = TREE_OPERAND (inner, 0);
5827         }
5828
5829       /* If we are going to be able to omit the AND below, we must do our
5830          operations as unsigned.  If we must use the AND, we have a choice.
5831          Normally unsigned is faster, but for some machines signed is.  */
5832 #ifdef LOAD_EXTEND_OP
5833       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1);
5834 #else
5835       ops_unsigned = 1;
5836 #endif
5837
5838       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
5839       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
5840       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
5841       inner = fold_convert (intermediate_type, inner);
5842
5843       if (bitnum != 0)
5844         inner = build2 (RSHIFT_EXPR, intermediate_type,
5845                         inner, size_int (bitnum));
5846
5847       if (code == EQ_EXPR)
5848         inner = build2 (BIT_XOR_EXPR, intermediate_type,
5849                         inner, integer_one_node);
5850
5851       /* Put the AND last so it can combine with more things.  */
5852       inner = build2 (BIT_AND_EXPR, intermediate_type,
5853                       inner, integer_one_node);
5854
5855       /* Make sure to return the proper type.  */
5856       inner = fold_convert (result_type, inner);
5857
5858       return inner;
5859     }
5860   return NULL_TREE;
5861 }
5862
5863 /* Check whether we are allowed to reorder operands arg0 and arg1,
5864    such that the evaluation of arg1 occurs before arg0.  */
5865
5866 static bool
5867 reorder_operands_p (tree arg0, tree arg1)
5868 {
5869   if (! flag_evaluation_order)
5870     return true;
5871   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
5872     return true;
5873   return ! TREE_SIDE_EFFECTS (arg0)
5874          && ! TREE_SIDE_EFFECTS (arg1);
5875 }
5876
5877 /* Test whether it is preferable two swap two operands, ARG0 and
5878    ARG1, for example because ARG0 is an integer constant and ARG1
5879    isn't.  If REORDER is true, only recommend swapping if we can
5880    evaluate the operands in reverse order.  */
5881
5882 bool
5883 tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
5884 {
5885   STRIP_SIGN_NOPS (arg0);
5886   STRIP_SIGN_NOPS (arg1);
5887
5888   if (TREE_CODE (arg1) == INTEGER_CST)
5889     return 0;
5890   if (TREE_CODE (arg0) == INTEGER_CST)
5891     return 1;
5892
5893   if (TREE_CODE (arg1) == REAL_CST)
5894     return 0;
5895   if (TREE_CODE (arg0) == REAL_CST)
5896     return 1;
5897
5898   if (TREE_CODE (arg1) == COMPLEX_CST)
5899     return 0;
5900   if (TREE_CODE (arg0) == COMPLEX_CST)
5901     return 1;
5902
5903   if (TREE_CONSTANT (arg1))
5904     return 0;
5905   if (TREE_CONSTANT (arg0))
5906     return 1;
5907
5908   if (optimize_size)
5909     return 0;
5910
5911   if (reorder && flag_evaluation_order
5912       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5913     return 0;
5914
5915   if (DECL_P (arg1))
5916     return 0;
5917   if (DECL_P (arg0))
5918     return 1;
5919
5920   if (reorder && flag_evaluation_order
5921       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5922     return 0;
5923
5924   if (DECL_P (arg1))
5925     return 0;
5926   if (DECL_P (arg0))
5927     return 1;
5928
5929   /* It is preferable to swap two SSA_NAME to ensure a canonical form
5930      for commutative and comparison operators.  Ensuring a canonical
5931      form allows the optimizers to find additional redundancies without
5932      having to explicitly check for both orderings.  */
5933   if (TREE_CODE (arg0) == SSA_NAME
5934       && TREE_CODE (arg1) == SSA_NAME
5935       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
5936     return 1;
5937
5938   return 0;
5939 }
5940
5941 /* Perform constant folding and related simplification of EXPR.
5942    The related simplifications include x*1 => x, x*0 => 0, etc.,
5943    and application of the associative law.
5944    NOP_EXPR conversions may be removed freely (as long as we
5945    are careful not to change the type of the overall expression).
5946    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
5947    but we can constant-fold them if they have constant operands.  */
5948
5949 #ifdef ENABLE_FOLD_CHECKING
5950 # define fold(x) fold_1 (x)
5951 static tree fold_1 (tree);
5952 static
5953 #endif
5954 tree
5955 fold (tree expr)
5956 {
5957   const tree t = expr;
5958   const tree type = TREE_TYPE (expr);
5959   tree t1 = NULL_TREE;
5960   tree tem;
5961   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
5962   enum tree_code code = TREE_CODE (t);
5963   int kind = TREE_CODE_CLASS (code);
5964
5965   /* WINS will be nonzero when the switch is done
5966      if all operands are constant.  */
5967   int wins = 1;
5968
5969   /* Don't try to process an RTL_EXPR since its operands aren't trees.
5970      Likewise for a SAVE_EXPR that's already been evaluated.  */
5971   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
5972     return t;
5973
5974   /* Return right away if a constant.  */
5975   if (kind == 'c')
5976     return t;
5977
5978   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
5979     {
5980       tree subop;
5981
5982       /* Special case for conversion ops that can have fixed point args.  */
5983       arg0 = TREE_OPERAND (t, 0);
5984
5985       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
5986       if (arg0 != 0)
5987         STRIP_SIGN_NOPS (arg0);
5988
5989       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
5990         subop = TREE_REALPART (arg0);
5991       else
5992         subop = arg0;
5993
5994       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
5995           && TREE_CODE (subop) != REAL_CST)
5996         /* Note that TREE_CONSTANT isn't enough:
5997            static var addresses are constant but we can't
5998            do arithmetic on them.  */
5999         wins = 0;
6000     }
6001   else if (IS_EXPR_CODE_CLASS (kind))
6002     {
6003       int len = first_rtl_op (code);
6004       int i;
6005       for (i = 0; i < len; i++)
6006         {
6007           tree op = TREE_OPERAND (t, i);
6008           tree subop;
6009
6010           if (op == 0)
6011             continue;           /* Valid for CALL_EXPR, at least.  */
6012
6013           /* Strip any conversions that don't change the mode.  This is
6014              safe for every expression, except for a comparison expression
6015              because its signedness is derived from its operands.  So, in
6016              the latter case, only strip conversions that don't change the
6017              signedness.
6018
6019              Note that this is done as an internal manipulation within the
6020              constant folder, in order to find the simplest representation
6021              of the arguments so that their form can be studied.  In any
6022              cases, the appropriate type conversions should be put back in
6023              the tree that will get out of the constant folder.  */
6024           if (kind == '<')
6025             STRIP_SIGN_NOPS (op);
6026           else
6027             STRIP_NOPS (op);
6028
6029           if (TREE_CODE (op) == COMPLEX_CST)
6030             subop = TREE_REALPART (op);
6031           else
6032             subop = op;
6033
6034           if (TREE_CODE (subop) != INTEGER_CST
6035               && TREE_CODE (subop) != REAL_CST)
6036             /* Note that TREE_CONSTANT isn't enough:
6037                static var addresses are constant but we can't
6038                do arithmetic on them.  */
6039             wins = 0;
6040
6041           if (i == 0)
6042             arg0 = op;
6043           else if (i == 1)
6044             arg1 = op;
6045         }
6046     }
6047
6048   /* If this is a commutative operation, and ARG0 is a constant, move it
6049      to ARG1 to reduce the number of tests below.  */
6050   if (commutative_tree_code (code)
6051       && tree_swap_operands_p (arg0, arg1, true))
6052     return fold (build2 (code, type, TREE_OPERAND (t, 1),
6053                          TREE_OPERAND (t, 0)));
6054
6055   /* Now WINS is set as described above,
6056      ARG0 is the first operand of EXPR,
6057      and ARG1 is the second operand (if it has more than one operand).
6058
6059      First check for cases where an arithmetic operation is applied to a
6060      compound, conditional, or comparison operation.  Push the arithmetic
6061      operation inside the compound or conditional to see if any folding
6062      can then be done.  Convert comparison to conditional for this purpose.
6063      The also optimizes non-constant cases that used to be done in
6064      expand_expr.
6065
6066      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
6067      one of the operands is a comparison and the other is a comparison, a
6068      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
6069      code below would make the expression more complex.  Change it to a
6070      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
6071      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
6072
6073   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
6074        || code == EQ_EXPR || code == NE_EXPR)
6075       && ((truth_value_p (TREE_CODE (arg0))
6076            && (truth_value_p (TREE_CODE (arg1))
6077                || (TREE_CODE (arg1) == BIT_AND_EXPR
6078                    && integer_onep (TREE_OPERAND (arg1, 1)))))
6079           || (truth_value_p (TREE_CODE (arg1))
6080               && (truth_value_p (TREE_CODE (arg0))
6081                   || (TREE_CODE (arg0) == BIT_AND_EXPR
6082                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
6083     {
6084       tem = fold (build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
6085                           : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
6086                           : TRUTH_XOR_EXPR,
6087                           type, fold_convert (boolean_type_node, arg0),
6088                           fold_convert (boolean_type_node, arg1)));
6089
6090       if (code == EQ_EXPR)
6091         tem = invert_truthvalue (tem);
6092
6093       return tem;
6094     }
6095
6096   if (TREE_CODE_CLASS (code) == '1')
6097     {
6098       if (TREE_CODE (arg0) == COMPOUND_EXPR)
6099         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6100                        fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
6101       else if (TREE_CODE (arg0) == COND_EXPR)
6102         {
6103           tree arg01 = TREE_OPERAND (arg0, 1);
6104           tree arg02 = TREE_OPERAND (arg0, 2);
6105           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
6106             arg01 = fold (build1 (code, type, arg01));
6107           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
6108             arg02 = fold (build1 (code, type, arg02));
6109           tem = fold (build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
6110                               arg01, arg02));
6111
6112           /* If this was a conversion, and all we did was to move into
6113              inside the COND_EXPR, bring it back out.  But leave it if
6114              it is a conversion from integer to integer and the
6115              result precision is no wider than a word since such a
6116              conversion is cheap and may be optimized away by combine,
6117              while it couldn't if it were outside the COND_EXPR.  Then return
6118              so we don't get into an infinite recursion loop taking the
6119              conversion out and then back in.  */
6120
6121           if ((code == NOP_EXPR || code == CONVERT_EXPR
6122                || code == NON_LVALUE_EXPR)
6123               && TREE_CODE (tem) == COND_EXPR
6124               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
6125               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
6126               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
6127               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
6128               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
6129                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
6130               && ! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
6131                     && (INTEGRAL_TYPE_P
6132                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
6133                     && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD))
6134             tem = build1 (code, type,
6135                           build3 (COND_EXPR,
6136                                   TREE_TYPE (TREE_OPERAND
6137                                              (TREE_OPERAND (tem, 1), 0)),
6138                                   TREE_OPERAND (tem, 0),
6139                                   TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
6140                                   TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
6141           return tem;
6142         }
6143       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
6144         {
6145           if (TREE_CODE (type) == BOOLEAN_TYPE)
6146             {
6147               arg0 = copy_node (arg0);
6148               TREE_TYPE (arg0) = type;
6149               return arg0;
6150             }
6151           else if (TREE_CODE (type) != INTEGER_TYPE)
6152             return fold (build3 (COND_EXPR, type, arg0,
6153                                  fold (build1 (code, type,
6154                                                integer_one_node)),
6155                                  fold (build1 (code, type,
6156                                                integer_zero_node))));
6157         }
6158    }
6159   else if (TREE_CODE_CLASS (code) == '<'
6160            && TREE_CODE (arg0) == COMPOUND_EXPR)
6161     return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6162                    fold (build2 (code, type, TREE_OPERAND (arg0, 1), arg1)));
6163   else if (TREE_CODE_CLASS (code) == '<'
6164            && TREE_CODE (arg1) == COMPOUND_EXPR)
6165     return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
6166                    fold (build2 (code, type, arg0, TREE_OPERAND (arg1, 1))));
6167   else if (TREE_CODE_CLASS (code) == '2'
6168            || TREE_CODE_CLASS (code) == '<')
6169     {
6170       if (TREE_CODE (arg0) == COMPOUND_EXPR)
6171         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6172                        fold (build2 (code, type, TREE_OPERAND (arg0, 1),
6173                                      arg1)));
6174       if (TREE_CODE (arg1) == COMPOUND_EXPR
6175           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
6176         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
6177                        fold (build2 (code, type,
6178                                      arg0, TREE_OPERAND (arg1, 1))));
6179
6180       if (TREE_CODE (arg0) == COND_EXPR
6181           || TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
6182         {
6183           tem = fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
6184                                                      /*cond_first_p=*/1);
6185           if (tem != NULL_TREE)
6186             return tem;
6187         }
6188
6189       if (TREE_CODE (arg1) == COND_EXPR
6190           || TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
6191         {
6192           tem = fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
6193                                                      /*cond_first_p=*/0);
6194           if (tem != NULL_TREE)
6195             return tem;
6196         }
6197     }
6198
6199   switch (code)
6200     {
6201     case CONST_DECL:
6202       return fold (DECL_INITIAL (t));
6203
6204     case NOP_EXPR:
6205     case FLOAT_EXPR:
6206     case CONVERT_EXPR:
6207     case FIX_TRUNC_EXPR:
6208     case FIX_CEIL_EXPR:
6209     case FIX_FLOOR_EXPR:
6210     case FIX_ROUND_EXPR:
6211       if (TREE_TYPE (TREE_OPERAND (t, 0)) == type)
6212         return TREE_OPERAND (t, 0);
6213
6214       /* Handle cases of two conversions in a row.  */
6215       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
6216           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
6217         {
6218           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
6219           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
6220           int inside_int = INTEGRAL_TYPE_P (inside_type);
6221           int inside_ptr = POINTER_TYPE_P (inside_type);
6222           int inside_float = FLOAT_TYPE_P (inside_type);
6223           unsigned int inside_prec = TYPE_PRECISION (inside_type);
6224           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
6225           int inter_int = INTEGRAL_TYPE_P (inter_type);
6226           int inter_ptr = POINTER_TYPE_P (inter_type);
6227           int inter_float = FLOAT_TYPE_P (inter_type);
6228           unsigned int inter_prec = TYPE_PRECISION (inter_type);
6229           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
6230           int final_int = INTEGRAL_TYPE_P (type);
6231           int final_ptr = POINTER_TYPE_P (type);
6232           int final_float = FLOAT_TYPE_P (type);
6233           unsigned int final_prec = TYPE_PRECISION (type);
6234           int final_unsignedp = TYPE_UNSIGNED (type);
6235
6236           /* In addition to the cases of two conversions in a row
6237              handled below, if we are converting something to its own
6238              type via an object of identical or wider precision, neither
6239              conversion is needed.  */
6240           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
6241               && ((inter_int && final_int) || (inter_float && final_float))
6242               && inter_prec >= final_prec)
6243             return fold (build1 (code, type,
6244                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6245
6246           /* Likewise, if the intermediate and final types are either both
6247              float or both integer, we don't need the middle conversion if
6248              it is wider than the final type and doesn't change the signedness
6249              (for integers).  Avoid this if the final type is a pointer
6250              since then we sometimes need the inner conversion.  Likewise if
6251              the outer has a precision not equal to the size of its mode.  */
6252           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
6253                || (inter_float && inside_float))
6254               && inter_prec >= inside_prec
6255               && (inter_float || inter_unsignedp == inside_unsignedp)
6256               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
6257                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
6258               && ! final_ptr)
6259             return fold (build1 (code, type,
6260                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6261
6262           /* If we have a sign-extension of a zero-extended value, we can
6263              replace that by a single zero-extension.  */
6264           if (inside_int && inter_int && final_int
6265               && inside_prec < inter_prec && inter_prec < final_prec
6266               && inside_unsignedp && !inter_unsignedp)
6267             return fold (build1 (code, type,
6268                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6269
6270           /* Two conversions in a row are not needed unless:
6271              - some conversion is floating-point (overstrict for now), or
6272              - the intermediate type is narrower than both initial and
6273                final, or
6274              - the intermediate type and innermost type differ in signedness,
6275                and the outermost type is wider than the intermediate, or
6276              - the initial type is a pointer type and the precisions of the
6277                intermediate and final types differ, or
6278              - the final type is a pointer type and the precisions of the
6279                initial and intermediate types differ.  */
6280           if (! inside_float && ! inter_float && ! final_float
6281               && (inter_prec > inside_prec || inter_prec > final_prec)
6282               && ! (inside_int && inter_int
6283                     && inter_unsignedp != inside_unsignedp
6284                     && inter_prec < final_prec)
6285               && ((inter_unsignedp && inter_prec > inside_prec)
6286                   == (final_unsignedp && final_prec > inter_prec))
6287               && ! (inside_ptr && inter_prec != final_prec)
6288               && ! (final_ptr && inside_prec != inter_prec)
6289               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
6290                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
6291               && ! final_ptr)
6292             return fold (build1 (code, type,
6293                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6294         }
6295
6296       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
6297           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
6298           /* Detect assigning a bitfield.  */
6299           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
6300                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
6301         {
6302           /* Don't leave an assignment inside a conversion
6303              unless assigning a bitfield.  */
6304           tree prev = TREE_OPERAND (t, 0);
6305           tem = copy_node (t);
6306           TREE_OPERAND (tem, 0) = TREE_OPERAND (prev, 1);
6307           /* First do the assignment, then return converted constant.  */
6308           tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), prev, fold (tem));
6309           TREE_NO_WARNING (tem) = 1;
6310           TREE_USED (tem) = 1;
6311           return tem;
6312         }
6313
6314       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
6315          constants (if x has signed type, the sign bit cannot be set
6316          in c).  This folds extension into the BIT_AND_EXPR.  */
6317       if (INTEGRAL_TYPE_P (type)
6318           && TREE_CODE (type) != BOOLEAN_TYPE
6319           && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
6320           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
6321         {
6322           tree and = TREE_OPERAND (t, 0);
6323           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
6324           int change = 0;
6325
6326           if (TYPE_UNSIGNED (TREE_TYPE (and))
6327               || (TYPE_PRECISION (type)
6328                   <= TYPE_PRECISION (TREE_TYPE (and))))
6329             change = 1;
6330           else if (TYPE_PRECISION (TREE_TYPE (and1))
6331                    <= HOST_BITS_PER_WIDE_INT
6332                    && host_integerp (and1, 1))
6333             {
6334               unsigned HOST_WIDE_INT cst;
6335
6336               cst = tree_low_cst (and1, 1);
6337               cst &= (HOST_WIDE_INT) -1
6338                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
6339               change = (cst == 0);
6340 #ifdef LOAD_EXTEND_OP
6341               if (change
6342                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
6343                       == ZERO_EXTEND))
6344                 {
6345                   tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
6346                   and0 = fold_convert (uns, and0);
6347                   and1 = fold_convert (uns, and1);
6348                 }
6349 #endif
6350             }
6351           if (change)
6352             return fold (build2 (BIT_AND_EXPR, type,
6353                                  fold_convert (type, and0),
6354                                  fold_convert (type, and1)));
6355         }
6356
6357       /* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
6358          T2 being pointers to types of the same size.  */
6359       if (POINTER_TYPE_P (TREE_TYPE (t))
6360           && TREE_CODE_CLASS (TREE_CODE (arg0)) == '2'
6361           && TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
6362           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6363         {
6364           tree arg00 = TREE_OPERAND (arg0, 0);
6365           tree t0 = TREE_TYPE (t);
6366           tree t1 = TREE_TYPE (arg00);
6367           tree tt0 = TREE_TYPE (t0);
6368           tree tt1 = TREE_TYPE (t1);
6369           tree s0 = TYPE_SIZE (tt0);
6370           tree s1 = TYPE_SIZE (tt1);
6371
6372           if (s0 && s1 && operand_equal_p (s0, s1, OEP_ONLY_CONST))
6373             return build2 (TREE_CODE (arg0), t0, fold_convert (t0, arg00),
6374                            TREE_OPERAND (arg0, 1));
6375         }
6376
6377       tem = fold_convert_const (code, type, arg0);
6378       return tem ? tem : t;
6379
6380     case VIEW_CONVERT_EXPR:
6381       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
6382         return build1 (VIEW_CONVERT_EXPR, type,
6383                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
6384       return t;
6385
6386     case COMPONENT_REF:
6387       if (TREE_CODE (arg0) == CONSTRUCTOR
6388           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
6389         {
6390           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
6391           if (m)
6392             return TREE_VALUE (m);
6393         }
6394       return t;
6395
6396     case RANGE_EXPR:
6397       if (TREE_CONSTANT (t) != wins)
6398         {
6399           tem = copy_node (t);
6400           TREE_CONSTANT (tem) = wins;
6401           TREE_INVARIANT (tem) = wins;
6402           return tem;
6403         }
6404       return t;
6405
6406     case NEGATE_EXPR:
6407       if (negate_expr_p (arg0))
6408         return fold_convert (type, negate_expr (arg0));
6409       return t;
6410
6411     case ABS_EXPR:
6412       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
6413         return fold_abs_const (arg0, type);
6414       else if (TREE_CODE (arg0) == NEGATE_EXPR)
6415         return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0)));
6416       /* Convert fabs((double)float) into (double)fabsf(float).  */
6417       else if (TREE_CODE (arg0) == NOP_EXPR
6418                && TREE_CODE (type) == REAL_TYPE)
6419         {
6420           tree targ0 = strip_float_extensions (arg0);
6421           if (targ0 != arg0)
6422             return fold_convert (type, fold (build1 (ABS_EXPR,
6423                                                      TREE_TYPE (targ0),
6424                                                      targ0)));
6425         }
6426       else if (tree_expr_nonnegative_p (arg0))
6427         return arg0;
6428       return t;
6429
6430     case CONJ_EXPR:
6431       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6432         return fold_convert (type, arg0);
6433       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6434         return build2 (COMPLEX_EXPR, type,
6435                        TREE_OPERAND (arg0, 0),
6436                        negate_expr (TREE_OPERAND (arg0, 1)));
6437       else if (TREE_CODE (arg0) == COMPLEX_CST)
6438         return build_complex (type, TREE_REALPART (arg0),
6439                               negate_expr (TREE_IMAGPART (arg0)));
6440       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6441         return fold (build2 (TREE_CODE (arg0), type,
6442                              fold (build1 (CONJ_EXPR, type,
6443                                            TREE_OPERAND (arg0, 0))),
6444                              fold (build1 (CONJ_EXPR, type,
6445                                            TREE_OPERAND (arg0, 1)))));
6446       else if (TREE_CODE (arg0) == CONJ_EXPR)
6447         return TREE_OPERAND (arg0, 0);
6448       return t;
6449
6450     case BIT_NOT_EXPR:
6451       if (TREE_CODE (arg0) == INTEGER_CST)
6452         return fold_not_const (arg0, type);
6453       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
6454         return TREE_OPERAND (arg0, 0);
6455       return t;
6456
6457     case PLUS_EXPR:
6458       /* A + (-B) -> A - B */
6459       if (TREE_CODE (arg1) == NEGATE_EXPR)
6460         return fold (build2 (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
6461       /* (-A) + B -> B - A */
6462       if (TREE_CODE (arg0) == NEGATE_EXPR
6463           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
6464         return fold (build2 (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
6465       if (! FLOAT_TYPE_P (type))
6466         {
6467           if (integer_zerop (arg1))
6468             return non_lvalue (fold_convert (type, arg0));
6469
6470           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
6471              with a constant, and the two constants have no bits in common,
6472              we should treat this as a BIT_IOR_EXPR since this may produce more
6473              simplifications.  */
6474           if (TREE_CODE (arg0) == BIT_AND_EXPR
6475               && TREE_CODE (arg1) == BIT_AND_EXPR
6476               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6477               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
6478               && integer_zerop (const_binop (BIT_AND_EXPR,
6479                                              TREE_OPERAND (arg0, 1),
6480                                              TREE_OPERAND (arg1, 1), 0)))
6481             {
6482               code = BIT_IOR_EXPR;
6483               goto bit_ior;
6484             }
6485
6486           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
6487              (plus (plus (mult) (mult)) (foo)) so that we can
6488              take advantage of the factoring cases below.  */
6489           if ((TREE_CODE (arg0) == PLUS_EXPR
6490                && TREE_CODE (arg1) == MULT_EXPR)
6491               || (TREE_CODE (arg1) == PLUS_EXPR
6492                   && TREE_CODE (arg0) == MULT_EXPR))
6493             {
6494               tree parg0, parg1, parg, marg;
6495
6496               if (TREE_CODE (arg0) == PLUS_EXPR)
6497                 parg = arg0, marg = arg1;
6498               else
6499                 parg = arg1, marg = arg0;
6500               parg0 = TREE_OPERAND (parg, 0);
6501               parg1 = TREE_OPERAND (parg, 1);
6502               STRIP_NOPS (parg0);
6503               STRIP_NOPS (parg1);
6504
6505               if (TREE_CODE (parg0) == MULT_EXPR
6506                   && TREE_CODE (parg1) != MULT_EXPR)
6507                 return fold (build2 (PLUS_EXPR, type,
6508                                      fold (build2 (PLUS_EXPR, type,
6509                                                    fold_convert (type, parg0),
6510                                                    fold_convert (type, marg))),
6511                                      fold_convert (type, parg1)));
6512               if (TREE_CODE (parg0) != MULT_EXPR
6513                   && TREE_CODE (parg1) == MULT_EXPR)
6514                 return fold (build2 (PLUS_EXPR, type,
6515                                      fold (build2 (PLUS_EXPR, type,
6516                                                    fold_convert (type, parg1),
6517                                                    fold_convert (type, marg))),
6518                                      fold_convert (type, parg0)));
6519             }
6520
6521           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
6522             {
6523               tree arg00, arg01, arg10, arg11;
6524               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6525
6526               /* (A * C) + (B * C) -> (A+B) * C.
6527                  We are most concerned about the case where C is a constant,
6528                  but other combinations show up during loop reduction.  Since
6529                  it is not difficult, try all four possibilities.  */
6530
6531               arg00 = TREE_OPERAND (arg0, 0);
6532               arg01 = TREE_OPERAND (arg0, 1);
6533               arg10 = TREE_OPERAND (arg1, 0);
6534               arg11 = TREE_OPERAND (arg1, 1);
6535               same = NULL_TREE;
6536
6537               if (operand_equal_p (arg01, arg11, 0))
6538                 same = arg01, alt0 = arg00, alt1 = arg10;
6539               else if (operand_equal_p (arg00, arg10, 0))
6540                 same = arg00, alt0 = arg01, alt1 = arg11;
6541               else if (operand_equal_p (arg00, arg11, 0))
6542                 same = arg00, alt0 = arg01, alt1 = arg10;
6543               else if (operand_equal_p (arg01, arg10, 0))
6544                 same = arg01, alt0 = arg00, alt1 = arg11;
6545
6546               /* No identical multiplicands; see if we can find a common
6547                  power-of-two factor in non-power-of-two multiplies.  This
6548                  can help in multi-dimensional array access.  */
6549               else if (TREE_CODE (arg01) == INTEGER_CST
6550                        && TREE_CODE (arg11) == INTEGER_CST
6551                        && TREE_INT_CST_HIGH (arg01) == 0
6552                        && TREE_INT_CST_HIGH (arg11) == 0)
6553                 {
6554                   HOST_WIDE_INT int01, int11, tmp;
6555                   int01 = TREE_INT_CST_LOW (arg01);
6556                   int11 = TREE_INT_CST_LOW (arg11);
6557
6558                   /* Move min of absolute values to int11.  */
6559                   if ((int01 >= 0 ? int01 : -int01)
6560                       < (int11 >= 0 ? int11 : -int11))
6561                     {
6562                       tmp = int01, int01 = int11, int11 = tmp;
6563                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
6564                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
6565                     }
6566
6567                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
6568                     {
6569                       alt0 = fold (build2 (MULT_EXPR, type, arg00,
6570                                            build_int_2 (int01 / int11, 0)));
6571                       alt1 = arg10;
6572                       same = arg11;
6573                     }
6574                 }
6575
6576               if (same)
6577                 return fold (build2 (MULT_EXPR, type,
6578                                      fold (build2 (PLUS_EXPR, type,
6579                                                    alt0, alt1)),
6580                                      same));
6581             }
6582         }
6583       else
6584         {
6585           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
6586           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
6587             return non_lvalue (fold_convert (type, arg0));
6588
6589           /* Likewise if the operands are reversed.  */
6590           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
6591             return non_lvalue (fold_convert (type, arg1));
6592
6593           /* Convert x+x into x*2.0.  */
6594           if (operand_equal_p (arg0, arg1, 0)
6595               && SCALAR_FLOAT_TYPE_P (type))
6596             return fold (build2 (MULT_EXPR, type, arg0,
6597                                  build_real (type, dconst2)));
6598
6599           /* Convert x*c+x into x*(c+1).  */
6600           if (flag_unsafe_math_optimizations
6601               && TREE_CODE (arg0) == MULT_EXPR
6602               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6603               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6604               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
6605             {
6606               REAL_VALUE_TYPE c;
6607
6608               c = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6609               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6610               return fold (build2 (MULT_EXPR, type, arg1,
6611                                    build_real (type, c)));
6612             }
6613
6614           /* Convert x+x*c into x*(c+1).  */
6615           if (flag_unsafe_math_optimizations
6616               && TREE_CODE (arg1) == MULT_EXPR
6617               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6618               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6619               && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
6620             {
6621               REAL_VALUE_TYPE c;
6622
6623               c = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6624               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6625               return fold (build2 (MULT_EXPR, type, arg0,
6626                                    build_real (type, c)));
6627             }
6628
6629           /* Convert x*c1+x*c2 into x*(c1+c2).  */
6630           if (flag_unsafe_math_optimizations
6631               && TREE_CODE (arg0) == MULT_EXPR
6632               && TREE_CODE (arg1) == MULT_EXPR
6633               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6634               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6635               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6636               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6637               && operand_equal_p (TREE_OPERAND (arg0, 0),
6638                                   TREE_OPERAND (arg1, 0), 0))
6639             {
6640               REAL_VALUE_TYPE c1, c2;
6641
6642               c1 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6643               c2 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6644               real_arithmetic (&c1, PLUS_EXPR, &c1, &c2);
6645               return fold (build2 (MULT_EXPR, type,
6646                                    TREE_OPERAND (arg0, 0),
6647                                    build_real (type, c1)));
6648             }
6649           /* Convert a + (b*c + d*e) into (a + b*c) + d*e */
6650           if (flag_unsafe_math_optimizations
6651               && TREE_CODE (arg1) == PLUS_EXPR
6652               && TREE_CODE (arg0) != MULT_EXPR)
6653             {
6654               tree tree10 = TREE_OPERAND (arg1, 0);
6655               tree tree11 = TREE_OPERAND (arg1, 1);
6656               if (TREE_CODE (tree11) == MULT_EXPR
6657                   && TREE_CODE (tree10) == MULT_EXPR)
6658                 {
6659                   tree tree0;
6660                   tree0 = fold (build2 (PLUS_EXPR, type, arg0, tree10));
6661                   return fold (build2 (PLUS_EXPR, type, tree0, tree11));
6662                 }
6663             }
6664           /* Convert (b*c + d*e) + a into b*c + (d*e +a) */
6665           if (flag_unsafe_math_optimizations
6666               && TREE_CODE (arg0) == PLUS_EXPR
6667               && TREE_CODE (arg1) != MULT_EXPR)
6668             {
6669               tree tree00 = TREE_OPERAND (arg0, 0);
6670               tree tree01 = TREE_OPERAND (arg0, 1);
6671               if (TREE_CODE (tree01) == MULT_EXPR
6672                   && TREE_CODE (tree00) == MULT_EXPR)
6673                 {
6674                   tree tree0;
6675                   tree0 = fold (build2 (PLUS_EXPR, type, tree01, arg1));
6676                   return fold (build2 (PLUS_EXPR, type, tree00, tree0));
6677                 }
6678             }
6679         }
6680
6681      bit_rotate:
6682       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
6683          is a rotate of A by C1 bits.  */
6684       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
6685          is a rotate of A by B bits.  */
6686       {
6687         enum tree_code code0, code1;
6688         code0 = TREE_CODE (arg0);
6689         code1 = TREE_CODE (arg1);
6690         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
6691              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
6692             && operand_equal_p (TREE_OPERAND (arg0, 0),
6693                                 TREE_OPERAND (arg1, 0), 0)
6694             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6695           {
6696             tree tree01, tree11;
6697             enum tree_code code01, code11;
6698
6699             tree01 = TREE_OPERAND (arg0, 1);
6700             tree11 = TREE_OPERAND (arg1, 1);
6701             STRIP_NOPS (tree01);
6702             STRIP_NOPS (tree11);
6703             code01 = TREE_CODE (tree01);
6704             code11 = TREE_CODE (tree11);
6705             if (code01 == INTEGER_CST
6706                 && code11 == INTEGER_CST
6707                 && TREE_INT_CST_HIGH (tree01) == 0
6708                 && TREE_INT_CST_HIGH (tree11) == 0
6709                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
6710                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
6711               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
6712                              code0 == LSHIFT_EXPR ? tree01 : tree11);
6713             else if (code11 == MINUS_EXPR)
6714               {
6715                 tree tree110, tree111;
6716                 tree110 = TREE_OPERAND (tree11, 0);
6717                 tree111 = TREE_OPERAND (tree11, 1);
6718                 STRIP_NOPS (tree110);
6719                 STRIP_NOPS (tree111);
6720                 if (TREE_CODE (tree110) == INTEGER_CST
6721                     && 0 == compare_tree_int (tree110,
6722                                               TYPE_PRECISION
6723                                               (TREE_TYPE (TREE_OPERAND
6724                                                           (arg0, 0))))
6725                     && operand_equal_p (tree01, tree111, 0))
6726                   return build2 ((code0 == LSHIFT_EXPR
6727                                   ? LROTATE_EXPR
6728                                   : RROTATE_EXPR),
6729                                  type, TREE_OPERAND (arg0, 0), tree01);
6730               }
6731             else if (code01 == MINUS_EXPR)
6732               {
6733                 tree tree010, tree011;
6734                 tree010 = TREE_OPERAND (tree01, 0);
6735                 tree011 = TREE_OPERAND (tree01, 1);
6736                 STRIP_NOPS (tree010);
6737                 STRIP_NOPS (tree011);
6738                 if (TREE_CODE (tree010) == INTEGER_CST
6739                     && 0 == compare_tree_int (tree010,
6740                                               TYPE_PRECISION
6741                                               (TREE_TYPE (TREE_OPERAND
6742                                                           (arg0, 0))))
6743                     && operand_equal_p (tree11, tree011, 0))
6744                   return build2 ((code0 != LSHIFT_EXPR
6745                                   ? LROTATE_EXPR
6746                                   : RROTATE_EXPR),
6747                                  type, TREE_OPERAND (arg0, 0), tree11);
6748               }
6749           }
6750       }
6751
6752     associate:
6753       /* In most languages, can't associate operations on floats through
6754          parentheses.  Rather than remember where the parentheses were, we
6755          don't associate floats at all, unless the user has specified
6756          -funsafe-math-optimizations.  */
6757
6758       if (! wins
6759           && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
6760         {
6761           tree var0, con0, lit0, minus_lit0;
6762           tree var1, con1, lit1, minus_lit1;
6763
6764           /* Split both trees into variables, constants, and literals.  Then
6765              associate each group together, the constants with literals,
6766              then the result with variables.  This increases the chances of
6767              literals being recombined later and of generating relocatable
6768              expressions for the sum of a constant and literal.  */
6769           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
6770           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
6771                              code == MINUS_EXPR);
6772
6773           /* Only do something if we found more than two objects.  Otherwise,
6774              nothing has changed and we risk infinite recursion.  */
6775           if (2 < ((var0 != 0) + (var1 != 0)
6776                    + (con0 != 0) + (con1 != 0)
6777                    + (lit0 != 0) + (lit1 != 0)
6778                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
6779             {
6780               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
6781               if (code == MINUS_EXPR)
6782                 code = PLUS_EXPR;
6783
6784               var0 = associate_trees (var0, var1, code, type);
6785               con0 = associate_trees (con0, con1, code, type);
6786               lit0 = associate_trees (lit0, lit1, code, type);
6787               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
6788
6789               /* Preserve the MINUS_EXPR if the negative part of the literal is
6790                  greater than the positive part.  Otherwise, the multiplicative
6791                  folding code (i.e extract_muldiv) may be fooled in case
6792                  unsigned constants are subtracted, like in the following
6793                  example: ((X*2 + 4) - 8U)/2.  */
6794               if (minus_lit0 && lit0)
6795                 {
6796                   if (TREE_CODE (lit0) == INTEGER_CST
6797                       && TREE_CODE (minus_lit0) == INTEGER_CST
6798                       && tree_int_cst_lt (lit0, minus_lit0))
6799                     {
6800                       minus_lit0 = associate_trees (minus_lit0, lit0,
6801                                                     MINUS_EXPR, type);
6802                       lit0 = 0;
6803                     }
6804                   else
6805                     {
6806                       lit0 = associate_trees (lit0, minus_lit0,
6807                                               MINUS_EXPR, type);
6808                       minus_lit0 = 0;
6809                     }
6810                 }
6811               if (minus_lit0)
6812                 {
6813                   if (con0 == 0)
6814                     return fold_convert (type,
6815                                          associate_trees (var0, minus_lit0,
6816                                                           MINUS_EXPR, type));
6817                   else
6818                     {
6819                       con0 = associate_trees (con0, minus_lit0,
6820                                               MINUS_EXPR, type);
6821                       return fold_convert (type,
6822                                            associate_trees (var0, con0,
6823                                                             PLUS_EXPR, type));
6824                     }
6825                 }
6826
6827               con0 = associate_trees (con0, lit0, code, type);
6828               return fold_convert (type, associate_trees (var0, con0,
6829                                                           code, type));
6830             }
6831         }
6832
6833     binary:
6834       if (wins)
6835         t1 = const_binop (code, arg0, arg1, 0);
6836       if (t1 != NULL_TREE)
6837         {
6838           /* The return value should always have
6839              the same type as the original expression.  */
6840           if (TREE_TYPE (t1) != type)
6841             t1 = fold_convert (type, t1);
6842
6843           return t1;
6844         }
6845       return t;
6846
6847     case MINUS_EXPR:
6848       /* A - (-B) -> A + B */
6849       if (TREE_CODE (arg1) == NEGATE_EXPR)
6850         return fold (build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
6851       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
6852       if (TREE_CODE (arg0) == NEGATE_EXPR
6853           && (FLOAT_TYPE_P (type)
6854               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
6855           && negate_expr_p (arg1)
6856           && reorder_operands_p (arg0, arg1))
6857         return fold (build2 (MINUS_EXPR, type, negate_expr (arg1),
6858                              TREE_OPERAND (arg0, 0)));
6859
6860       if (! FLOAT_TYPE_P (type))
6861         {
6862           if (! wins && integer_zerop (arg0))
6863             return negate_expr (fold_convert (type, arg1));
6864           if (integer_zerop (arg1))
6865             return non_lvalue (fold_convert (type, arg0));
6866
6867           /* Fold A - (A & B) into ~B & A.  */
6868           if (!TREE_SIDE_EFFECTS (arg0)
6869               && TREE_CODE (arg1) == BIT_AND_EXPR)
6870             {
6871               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
6872                 return fold (build2 (BIT_AND_EXPR, type,
6873                                      fold (build1 (BIT_NOT_EXPR, type,
6874                                                    TREE_OPERAND (arg1, 0))),
6875                                      arg0));
6876               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
6877                 return fold (build2 (BIT_AND_EXPR, type,
6878                                      fold (build1 (BIT_NOT_EXPR, type,
6879                                                    TREE_OPERAND (arg1, 1))),
6880                                      arg0));
6881             }
6882
6883           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
6884              any power of 2 minus 1.  */
6885           if (TREE_CODE (arg0) == BIT_AND_EXPR
6886               && TREE_CODE (arg1) == BIT_AND_EXPR
6887               && operand_equal_p (TREE_OPERAND (arg0, 0),
6888                                   TREE_OPERAND (arg1, 0), 0))
6889             {
6890               tree mask0 = TREE_OPERAND (arg0, 1);
6891               tree mask1 = TREE_OPERAND (arg1, 1);
6892               tree tem = fold (build1 (BIT_NOT_EXPR, type, mask0));
6893
6894               if (operand_equal_p (tem, mask1, 0))
6895                 {
6896                   tem = fold (build2 (BIT_XOR_EXPR, type,
6897                                       TREE_OPERAND (arg0, 0), mask1));
6898                   return fold (build2 (MINUS_EXPR, type, tem, mask1));
6899                 }
6900             }
6901         }
6902
6903       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
6904       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
6905         return non_lvalue (fold_convert (type, arg0));
6906
6907       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
6908          ARG0 is zero and X + ARG0 reduces to X, since that would mean
6909          (-ARG1 + ARG0) reduces to -ARG1.  */
6910       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
6911         return negate_expr (fold_convert (type, arg1));
6912
6913       /* Fold &x - &x.  This can happen from &x.foo - &x.
6914          This is unsafe for certain floats even in non-IEEE formats.
6915          In IEEE, it is unsafe because it does wrong for NaNs.
6916          Also note that operand_equal_p is always false if an operand
6917          is volatile.  */
6918
6919       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
6920           && operand_equal_p (arg0, arg1, 0))
6921         return fold_convert (type, integer_zero_node);
6922
6923       /* A - B -> A + (-B) if B is easily negatable.  */
6924       if (!wins && negate_expr_p (arg1)
6925           && (FLOAT_TYPE_P (type)
6926               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
6927         return fold (build2 (PLUS_EXPR, type, arg0, negate_expr (arg1)));
6928
6929       if (TREE_CODE (arg0) == MULT_EXPR
6930           && TREE_CODE (arg1) == MULT_EXPR
6931           && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
6932         {
6933           /* (A * C) - (B * C) -> (A-B) * C.  */
6934           if (operand_equal_p (TREE_OPERAND (arg0, 1),
6935                                TREE_OPERAND (arg1, 1), 0))
6936             return fold (build2 (MULT_EXPR, type,
6937                                  fold (build2 (MINUS_EXPR, type,
6938                                                TREE_OPERAND (arg0, 0),
6939                                                TREE_OPERAND (arg1, 0))),
6940                                  TREE_OPERAND (arg0, 1)));
6941           /* (A * C1) - (A * C2) -> A * (C1-C2).  */
6942           if (operand_equal_p (TREE_OPERAND (arg0, 0),
6943                                TREE_OPERAND (arg1, 0), 0))
6944             return fold (build2 (MULT_EXPR, type,
6945                                  TREE_OPERAND (arg0, 0),
6946                                  fold (build2 (MINUS_EXPR, type,
6947                                                TREE_OPERAND (arg0, 1),
6948                                                TREE_OPERAND (arg1, 1)))));
6949         }
6950
6951       goto associate;
6952
6953     case MULT_EXPR:
6954       /* (-A) * (-B) -> A * B  */
6955       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
6956         return fold (build2 (MULT_EXPR, type,
6957                              TREE_OPERAND (arg0, 0),
6958                              negate_expr (arg1)));
6959       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
6960         return fold (build2 (MULT_EXPR, type,
6961                              negate_expr (arg0),
6962                              TREE_OPERAND (arg1, 0)));
6963
6964       if (! FLOAT_TYPE_P (type))
6965         {
6966           if (integer_zerop (arg1))
6967             return omit_one_operand (type, arg1, arg0);
6968           if (integer_onep (arg1))
6969             return non_lvalue (fold_convert (type, arg0));
6970
6971           /* (a * (1 << b)) is (a << b)  */
6972           if (TREE_CODE (arg1) == LSHIFT_EXPR
6973               && integer_onep (TREE_OPERAND (arg1, 0)))
6974             return fold (build2 (LSHIFT_EXPR, type, arg0,
6975                                  TREE_OPERAND (arg1, 1)));
6976           if (TREE_CODE (arg0) == LSHIFT_EXPR
6977               && integer_onep (TREE_OPERAND (arg0, 0)))
6978             return fold (build2 (LSHIFT_EXPR, type, arg1,
6979                                  TREE_OPERAND (arg0, 1)));
6980
6981           if (TREE_CODE (arg1) == INTEGER_CST
6982               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
6983                                              fold_convert (type, arg1),
6984                                              code, NULL_TREE)))
6985             return fold_convert (type, tem);
6986
6987         }
6988       else
6989         {
6990           /* Maybe fold x * 0 to 0.  The expressions aren't the same
6991              when x is NaN, since x * 0 is also NaN.  Nor are they the
6992              same in modes with signed zeros, since multiplying a
6993              negative value by 0 gives -0, not +0.  */
6994           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
6995               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
6996               && real_zerop (arg1))
6997             return omit_one_operand (type, arg1, arg0);
6998           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
6999           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7000               && real_onep (arg1))
7001             return non_lvalue (fold_convert (type, arg0));
7002
7003           /* Transform x * -1.0 into -x.  */
7004           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7005               && real_minus_onep (arg1))
7006             return fold_convert (type, negate_expr (arg0));
7007
7008           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
7009           if (flag_unsafe_math_optimizations
7010               && TREE_CODE (arg0) == RDIV_EXPR
7011               && TREE_CODE (arg1) == REAL_CST
7012               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
7013             {
7014               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
7015                                       arg1, 0);
7016               if (tem)
7017                 return fold (build2 (RDIV_EXPR, type, tem,
7018                                      TREE_OPERAND (arg0, 1)));
7019             }
7020
7021           if (flag_unsafe_math_optimizations)
7022             {
7023               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7024               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7025
7026               /* Optimizations of root(...)*root(...).  */
7027               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
7028                 {
7029                   tree rootfn, arg, arglist;
7030                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7031                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7032
7033                   /* Optimize sqrt(x)*sqrt(x) as x.  */
7034                   if (BUILTIN_SQRT_P (fcode0)
7035                       && operand_equal_p (arg00, arg10, 0)
7036                       && ! HONOR_SNANS (TYPE_MODE (type)))
7037                     return arg00;
7038
7039                   /* Optimize root(x)*root(y) as root(x*y).  */
7040                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7041                   arg = fold (build2 (MULT_EXPR, type, arg00, arg10));
7042                   arglist = build_tree_list (NULL_TREE, arg);
7043                   return build_function_call_expr (rootfn, arglist);
7044                 }
7045
7046               /* Optimize expN(x)*expN(y) as expN(x+y).  */
7047               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
7048                 {
7049                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7050                   tree arg = build2 (PLUS_EXPR, type,
7051                                      TREE_VALUE (TREE_OPERAND (arg0, 1)),
7052                                      TREE_VALUE (TREE_OPERAND (arg1, 1)));
7053                   tree arglist = build_tree_list (NULL_TREE, fold (arg));
7054                   return build_function_call_expr (expfn, arglist);
7055                 }
7056
7057               /* Optimizations of pow(...)*pow(...).  */
7058               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
7059                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
7060                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
7061                 {
7062                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7063                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7064                                                                      1)));
7065                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7066                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7067                                                                      1)));
7068
7069                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
7070                   if (operand_equal_p (arg01, arg11, 0))
7071                     {
7072                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7073                       tree arg = build2 (MULT_EXPR, type, arg00, arg10);
7074                       tree arglist = tree_cons (NULL_TREE, fold (arg),
7075                                                 build_tree_list (NULL_TREE,
7076                                                                  arg01));
7077                       return build_function_call_expr (powfn, arglist);
7078                     }
7079
7080                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
7081                   if (operand_equal_p (arg00, arg10, 0))
7082                     {
7083                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7084                       tree arg = fold (build2 (PLUS_EXPR, type, arg01, arg11));
7085                       tree arglist = tree_cons (NULL_TREE, arg00,
7086                                                 build_tree_list (NULL_TREE,
7087                                                                  arg));
7088                       return build_function_call_expr (powfn, arglist);
7089                     }
7090                 }
7091
7092               /* Optimize tan(x)*cos(x) as sin(x).  */
7093               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
7094                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
7095                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
7096                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
7097                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
7098                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
7099                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7100                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7101                 {
7102                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
7103
7104                   if (sinfn != NULL_TREE)
7105                     return build_function_call_expr (sinfn,
7106                                                      TREE_OPERAND (arg0, 1));
7107                 }
7108
7109               /* Optimize x*pow(x,c) as pow(x,c+1).  */
7110               if (fcode1 == BUILT_IN_POW
7111                   || fcode1 == BUILT_IN_POWF
7112                   || fcode1 == BUILT_IN_POWL)
7113                 {
7114                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7115                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7116                                                                      1)));
7117                   if (TREE_CODE (arg11) == REAL_CST
7118                       && ! TREE_CONSTANT_OVERFLOW (arg11)
7119                       && operand_equal_p (arg0, arg10, 0))
7120                     {
7121                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7122                       REAL_VALUE_TYPE c;
7123                       tree arg, arglist;
7124
7125                       c = TREE_REAL_CST (arg11);
7126                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7127                       arg = build_real (type, c);
7128                       arglist = build_tree_list (NULL_TREE, arg);
7129                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7130                       return build_function_call_expr (powfn, arglist);
7131                     }
7132                 }
7133
7134               /* Optimize pow(x,c)*x as pow(x,c+1).  */
7135               if (fcode0 == BUILT_IN_POW
7136                   || fcode0 == BUILT_IN_POWF
7137                   || fcode0 == BUILT_IN_POWL)
7138                 {
7139                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7140                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7141                                                                      1)));
7142                   if (TREE_CODE (arg01) == REAL_CST
7143                       && ! TREE_CONSTANT_OVERFLOW (arg01)
7144                       && operand_equal_p (arg1, arg00, 0))
7145                     {
7146                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7147                       REAL_VALUE_TYPE c;
7148                       tree arg, arglist;
7149
7150                       c = TREE_REAL_CST (arg01);
7151                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7152                       arg = build_real (type, c);
7153                       arglist = build_tree_list (NULL_TREE, arg);
7154                       arglist = tree_cons (NULL_TREE, arg1, arglist);
7155                       return build_function_call_expr (powfn, arglist);
7156                     }
7157                 }
7158
7159               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
7160               if (! optimize_size
7161                   && operand_equal_p (arg0, arg1, 0))
7162                 {
7163                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7164
7165                   if (powfn)
7166                     {
7167                       tree arg = build_real (type, dconst2);
7168                       tree arglist = build_tree_list (NULL_TREE, arg);
7169                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7170                       return build_function_call_expr (powfn, arglist);
7171                     }
7172                 }
7173             }
7174         }
7175       goto associate;
7176
7177     case BIT_IOR_EXPR:
7178     bit_ior:
7179       if (integer_all_onesp (arg1))
7180         return omit_one_operand (type, arg1, arg0);
7181       if (integer_zerop (arg1))
7182         return non_lvalue (fold_convert (type, arg0));
7183       if (operand_equal_p (arg0, arg1, 0))
7184         return non_lvalue (fold_convert (type, arg0));
7185       t1 = distribute_bit_expr (code, type, arg0, arg1);
7186       if (t1 != NULL_TREE)
7187         return t1;
7188
7189       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
7190
7191          This results in more efficient code for machines without a NAND
7192          instruction.  Combine will canonicalize to the first form
7193          which will allow use of NAND instructions provided by the
7194          backend if they exist.  */
7195       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7196           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7197         {
7198           return fold (build1 (BIT_NOT_EXPR, type,
7199                                build2 (BIT_AND_EXPR, type,
7200                                        TREE_OPERAND (arg0, 0),
7201                                        TREE_OPERAND (arg1, 0))));
7202         }
7203
7204       /* See if this can be simplified into a rotate first.  If that
7205          is unsuccessful continue in the association code.  */
7206       goto bit_rotate;
7207
7208     case BIT_XOR_EXPR:
7209       if (integer_zerop (arg1))
7210         return non_lvalue (fold_convert (type, arg0));
7211       if (integer_all_onesp (arg1))
7212         return fold (build1 (BIT_NOT_EXPR, type, arg0));
7213       if (operand_equal_p (arg0, arg1, 0))
7214         return omit_one_operand (type, integer_zero_node, arg0);
7215
7216       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
7217          with a constant, and the two constants have no bits in common,
7218          we should treat this as a BIT_IOR_EXPR since this may produce more
7219          simplifications.  */
7220       if (TREE_CODE (arg0) == BIT_AND_EXPR
7221           && TREE_CODE (arg1) == BIT_AND_EXPR
7222           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7223           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7224           && integer_zerop (const_binop (BIT_AND_EXPR,
7225                                          TREE_OPERAND (arg0, 1),
7226                                          TREE_OPERAND (arg1, 1), 0)))
7227         {
7228           code = BIT_IOR_EXPR;
7229           goto bit_ior;
7230         }
7231
7232       /* See if this can be simplified into a rotate first.  If that
7233          is unsuccessful continue in the association code.  */
7234       goto bit_rotate;
7235
7236     case BIT_AND_EXPR:
7237       if (integer_all_onesp (arg1))
7238         return non_lvalue (fold_convert (type, arg0));
7239       if (integer_zerop (arg1))
7240         return omit_one_operand (type, arg1, arg0);
7241       if (operand_equal_p (arg0, arg1, 0))
7242         return non_lvalue (fold_convert (type, arg0));
7243       t1 = distribute_bit_expr (code, type, arg0, arg1);
7244       if (t1 != NULL_TREE)
7245         return t1;
7246       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
7247       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
7248           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7249         {
7250           unsigned int prec
7251             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
7252
7253           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
7254               && (~TREE_INT_CST_LOW (arg1)
7255                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
7256             return fold_convert (type, TREE_OPERAND (arg0, 0));
7257         }
7258
7259       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
7260
7261          This results in more efficient code for machines without a NOR
7262          instruction.  Combine will canonicalize to the first form
7263          which will allow use of NOR instructions provided by the
7264          backend if they exist.  */
7265       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7266           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7267         {
7268           return fold (build1 (BIT_NOT_EXPR, type,
7269                                build2 (BIT_IOR_EXPR, type,
7270                                        TREE_OPERAND (arg0, 0),
7271                                        TREE_OPERAND (arg1, 0))));
7272         }
7273
7274       goto associate;
7275
7276     case RDIV_EXPR:
7277       /* Don't touch a floating-point divide by zero unless the mode
7278          of the constant can represent infinity.  */
7279       if (TREE_CODE (arg1) == REAL_CST
7280           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
7281           && real_zerop (arg1))
7282         return t;
7283
7284       /* (-A) / (-B) -> A / B  */
7285       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7286         return fold (build2 (RDIV_EXPR, type,
7287                              TREE_OPERAND (arg0, 0),
7288                              negate_expr (arg1)));
7289       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7290         return fold (build2 (RDIV_EXPR, type,
7291                              negate_expr (arg0),
7292                              TREE_OPERAND (arg1, 0)));
7293
7294       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
7295       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7296           && real_onep (arg1))
7297         return non_lvalue (fold_convert (type, arg0));
7298
7299       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
7300       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7301           && real_minus_onep (arg1))
7302         return non_lvalue (fold_convert (type, negate_expr (arg0)));
7303
7304       /* If ARG1 is a constant, we can convert this to a multiply by the
7305          reciprocal.  This does not have the same rounding properties,
7306          so only do this if -funsafe-math-optimizations.  We can actually
7307          always safely do it if ARG1 is a power of two, but it's hard to
7308          tell if it is or not in a portable manner.  */
7309       if (TREE_CODE (arg1) == REAL_CST)
7310         {
7311           if (flag_unsafe_math_optimizations
7312               && 0 != (tem = const_binop (code, build_real (type, dconst1),
7313                                           arg1, 0)))
7314             return fold (build2 (MULT_EXPR, type, arg0, tem));
7315           /* Find the reciprocal if optimizing and the result is exact.  */
7316           if (optimize)
7317             {
7318               REAL_VALUE_TYPE r;
7319               r = TREE_REAL_CST (arg1);
7320               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
7321                 {
7322                   tem = build_real (type, r);
7323                   return fold (build2 (MULT_EXPR, type, arg0, tem));
7324                 }
7325             }
7326         }
7327       /* Convert A/B/C to A/(B*C).  */
7328       if (flag_unsafe_math_optimizations
7329           && TREE_CODE (arg0) == RDIV_EXPR)
7330         return fold (build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
7331                              fold (build2 (MULT_EXPR, type,
7332                                            TREE_OPERAND (arg0, 1), arg1))));
7333
7334       /* Convert A/(B/C) to (A/B)*C.  */
7335       if (flag_unsafe_math_optimizations
7336           && TREE_CODE (arg1) == RDIV_EXPR)
7337         return fold (build2 (MULT_EXPR, type,
7338                              fold (build2 (RDIV_EXPR, type, arg0,
7339                                            TREE_OPERAND (arg1, 0))),
7340                              TREE_OPERAND (arg1, 1)));
7341
7342       /* Convert C1/(X*C2) into (C1/C2)/X.  */
7343       if (flag_unsafe_math_optimizations
7344           && TREE_CODE (arg1) == MULT_EXPR
7345           && TREE_CODE (arg0) == REAL_CST
7346           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
7347         {
7348           tree tem = const_binop (RDIV_EXPR, arg0,
7349                                   TREE_OPERAND (arg1, 1), 0);
7350           if (tem)
7351             return fold (build2 (RDIV_EXPR, type, tem,
7352                                  TREE_OPERAND (arg1, 0)));
7353         }
7354
7355       if (flag_unsafe_math_optimizations)
7356         {
7357           enum built_in_function fcode = builtin_mathfn_code (arg1);
7358           /* Optimize x/expN(y) into x*expN(-y).  */
7359           if (BUILTIN_EXPONENT_P (fcode))
7360             {
7361               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7362               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
7363               tree arglist = build_tree_list (NULL_TREE,
7364                                               fold_convert (type, arg));
7365               arg1 = build_function_call_expr (expfn, arglist);
7366               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7367             }
7368
7369           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
7370           if (fcode == BUILT_IN_POW
7371               || fcode == BUILT_IN_POWF
7372               || fcode == BUILT_IN_POWL)
7373             {
7374               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7375               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7376               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
7377               tree neg11 = fold_convert (type, negate_expr (arg11));
7378               tree arglist = tree_cons(NULL_TREE, arg10,
7379                                        build_tree_list (NULL_TREE, neg11));
7380               arg1 = build_function_call_expr (powfn, arglist);
7381               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7382             }
7383         }
7384
7385       if (flag_unsafe_math_optimizations)
7386         {
7387           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7388           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7389
7390           /* Optimize sin(x)/cos(x) as tan(x).  */
7391           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
7392                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
7393                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
7394               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7395                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7396             {
7397               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7398
7399               if (tanfn != NULL_TREE)
7400                 return build_function_call_expr (tanfn,
7401                                                  TREE_OPERAND (arg0, 1));
7402             }
7403
7404           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
7405           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
7406                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
7407                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
7408               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7409                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7410             {
7411               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7412
7413               if (tanfn != NULL_TREE)
7414                 {
7415                   tree tmp = TREE_OPERAND (arg0, 1);
7416                   tmp = build_function_call_expr (tanfn, tmp);
7417                   return fold (build2 (RDIV_EXPR, type,
7418                                        build_real (type, dconst1), tmp));
7419                 }
7420             }
7421
7422           /* Optimize pow(x,c)/x as pow(x,c-1).  */
7423           if (fcode0 == BUILT_IN_POW
7424               || fcode0 == BUILT_IN_POWF
7425               || fcode0 == BUILT_IN_POWL)
7426             {
7427               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7428               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7429               if (TREE_CODE (arg01) == REAL_CST
7430                   && ! TREE_CONSTANT_OVERFLOW (arg01)
7431                   && operand_equal_p (arg1, arg00, 0))
7432                 {
7433                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7434                   REAL_VALUE_TYPE c;
7435                   tree arg, arglist;
7436
7437                   c = TREE_REAL_CST (arg01);
7438                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
7439                   arg = build_real (type, c);
7440                   arglist = build_tree_list (NULL_TREE, arg);
7441                   arglist = tree_cons (NULL_TREE, arg1, arglist);
7442                   return build_function_call_expr (powfn, arglist);
7443                 }
7444             }
7445         }
7446       goto binary;
7447
7448     case TRUNC_DIV_EXPR:
7449     case ROUND_DIV_EXPR:
7450     case FLOOR_DIV_EXPR:
7451     case CEIL_DIV_EXPR:
7452     case EXACT_DIV_EXPR:
7453       if (integer_onep (arg1))
7454         return non_lvalue (fold_convert (type, arg0));
7455       if (integer_zerop (arg1))
7456         return t;
7457       /* X / -1 is -X.  */
7458       if (!TYPE_UNSIGNED (type)
7459           && TREE_CODE (arg1) == INTEGER_CST
7460           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7461           && TREE_INT_CST_HIGH (arg1) == -1)
7462         return fold_convert (type, negate_expr (arg0));
7463
7464       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
7465          operation, EXACT_DIV_EXPR.
7466
7467          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
7468          At one time others generated faster code, it's not clear if they do
7469          after the last round to changes to the DIV code in expmed.c.  */
7470       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
7471           && multiple_of_p (type, arg0, arg1))
7472         return fold (build2 (EXACT_DIV_EXPR, type, arg0, arg1));
7473
7474       if (TREE_CODE (arg1) == INTEGER_CST
7475           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7476                                          code, NULL_TREE)))
7477         return fold_convert (type, tem);
7478
7479       goto binary;
7480
7481     case CEIL_MOD_EXPR:
7482     case FLOOR_MOD_EXPR:
7483     case ROUND_MOD_EXPR:
7484     case TRUNC_MOD_EXPR:
7485       if (integer_onep (arg1))
7486         return omit_one_operand (type, integer_zero_node, arg0);
7487       if (integer_zerop (arg1))
7488         return t;
7489       /* X % -1 is zero.  */
7490       if (!TYPE_UNSIGNED (type)
7491           && TREE_CODE (arg1) == INTEGER_CST
7492           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7493           && TREE_INT_CST_HIGH (arg1) == -1)
7494         return omit_one_operand (type, integer_zero_node, arg0);
7495
7496       if (TREE_CODE (arg1) == INTEGER_CST
7497           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7498                                          code, NULL_TREE)))
7499         return fold_convert (type, tem);
7500
7501       goto binary;
7502
7503     case LROTATE_EXPR:
7504     case RROTATE_EXPR:
7505       if (integer_all_onesp (arg0))
7506         return omit_one_operand (type, arg0, arg1);
7507       goto shift;
7508
7509     case RSHIFT_EXPR:
7510       /* Optimize -1 >> x for arithmetic right shifts.  */
7511       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
7512         return omit_one_operand (type, arg0, arg1);
7513       /* ... fall through ...  */
7514
7515     case LSHIFT_EXPR:
7516     shift:
7517       if (integer_zerop (arg1))
7518         return non_lvalue (fold_convert (type, arg0));
7519       if (integer_zerop (arg0))
7520         return omit_one_operand (type, arg0, arg1);
7521
7522       /* Since negative shift count is not well-defined,
7523          don't try to compute it in the compiler.  */
7524       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
7525         return t;
7526       /* Rewrite an LROTATE_EXPR by a constant into an
7527          RROTATE_EXPR by a new constant.  */
7528       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
7529         {
7530           tree tem = build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
7531           tem = fold_convert (TREE_TYPE (arg1), tem);
7532           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
7533           return fold (build2 (RROTATE_EXPR, type, arg0, tem));
7534         }
7535
7536       /* If we have a rotate of a bit operation with the rotate count and
7537          the second operand of the bit operation both constant,
7538          permute the two operations.  */
7539       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7540           && (TREE_CODE (arg0) == BIT_AND_EXPR
7541               || TREE_CODE (arg0) == BIT_IOR_EXPR
7542               || TREE_CODE (arg0) == BIT_XOR_EXPR)
7543           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7544         return fold (build2 (TREE_CODE (arg0), type,
7545                              fold (build2 (code, type,
7546                                            TREE_OPERAND (arg0, 0), arg1)),
7547                              fold (build2 (code, type,
7548                                            TREE_OPERAND (arg0, 1), arg1))));
7549
7550       /* Two consecutive rotates adding up to the width of the mode can
7551          be ignored.  */
7552       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7553           && TREE_CODE (arg0) == RROTATE_EXPR
7554           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7555           && TREE_INT_CST_HIGH (arg1) == 0
7556           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
7557           && ((TREE_INT_CST_LOW (arg1)
7558                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
7559               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
7560         return TREE_OPERAND (arg0, 0);
7561
7562       goto binary;
7563
7564     case MIN_EXPR:
7565       if (operand_equal_p (arg0, arg1, 0))
7566         return omit_one_operand (type, arg0, arg1);
7567       if (INTEGRAL_TYPE_P (type)
7568           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
7569         return omit_one_operand (type, arg1, arg0);
7570       goto associate;
7571
7572     case MAX_EXPR:
7573       if (operand_equal_p (arg0, arg1, 0))
7574         return omit_one_operand (type, arg0, arg1);
7575       if (INTEGRAL_TYPE_P (type)
7576           && TYPE_MAX_VALUE (type)
7577           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
7578         return omit_one_operand (type, arg1, arg0);
7579       goto associate;
7580
7581     case TRUTH_NOT_EXPR:
7582       /* The argument to invert_truthvalue must have Boolean type.  */
7583       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7584           arg0 = fold_convert (boolean_type_node, arg0);
7585
7586       /* Note that the operand of this must be an int
7587          and its values must be 0 or 1.
7588          ("true" is a fixed value perhaps depending on the language,
7589          but we don't handle values other than 1 correctly yet.)  */
7590       tem = invert_truthvalue (arg0);
7591       /* Avoid infinite recursion.  */
7592       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
7593         {
7594           tem = fold_single_bit_test (code, arg0, arg1, type);
7595           if (tem)
7596             return tem;
7597           return t;
7598         }
7599       return fold_convert (type, tem);
7600
7601     case TRUTH_ANDIF_EXPR:
7602       /* Note that the operands of this must be ints
7603          and their values must be 0 or 1.
7604          ("true" is a fixed value perhaps depending on the language.)  */
7605       /* If first arg is constant zero, return it.  */
7606       if (integer_zerop (arg0))
7607         return fold_convert (type, arg0);
7608     case TRUTH_AND_EXPR:
7609       /* If either arg is constant true, drop it.  */
7610       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7611         return non_lvalue (fold_convert (type, arg1));
7612       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
7613           /* Preserve sequence points.  */
7614           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7615         return non_lvalue (fold_convert (type, arg0));
7616       /* If second arg is constant zero, result is zero, but first arg
7617          must be evaluated.  */
7618       if (integer_zerop (arg1))
7619         return omit_one_operand (type, arg1, arg0);
7620       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
7621          case will be handled here.  */
7622       if (integer_zerop (arg0))
7623         return omit_one_operand (type, arg0, arg1);
7624
7625     truth_andor:
7626       /* We only do these simplifications if we are optimizing.  */
7627       if (!optimize)
7628         return t;
7629
7630       /* Check for things like (A || B) && (A || C).  We can convert this
7631          to A || (B && C).  Note that either operator can be any of the four
7632          truth and/or operations and the transformation will still be
7633          valid.   Also note that we only care about order for the
7634          ANDIF and ORIF operators.  If B contains side effects, this
7635          might change the truth-value of A.  */
7636       if (TREE_CODE (arg0) == TREE_CODE (arg1)
7637           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7638               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7639               || TREE_CODE (arg0) == TRUTH_AND_EXPR
7640               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7641           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7642         {
7643           tree a00 = TREE_OPERAND (arg0, 0);
7644           tree a01 = TREE_OPERAND (arg0, 1);
7645           tree a10 = TREE_OPERAND (arg1, 0);
7646           tree a11 = TREE_OPERAND (arg1, 1);
7647           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7648                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7649                              && (code == TRUTH_AND_EXPR
7650                                  || code == TRUTH_OR_EXPR));
7651
7652           if (operand_equal_p (a00, a10, 0))
7653             return fold (build2 (TREE_CODE (arg0), type, a00,
7654                                  fold (build2 (code, type, a01, a11))));
7655           else if (commutative && operand_equal_p (a00, a11, 0))
7656             return fold (build2 (TREE_CODE (arg0), type, a00,
7657                                  fold (build2 (code, type, a01, a10))));
7658           else if (commutative && operand_equal_p (a01, a10, 0))
7659             return fold (build2 (TREE_CODE (arg0), type, a01,
7660                                  fold (build2 (code, type, a00, a11))));
7661
7662           /* This case if tricky because we must either have commutative
7663              operators or else A10 must not have side-effects.  */
7664
7665           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7666                    && operand_equal_p (a01, a11, 0))
7667             return fold (build2 (TREE_CODE (arg0), type,
7668                                  fold (build2 (code, type, a00, a10)),
7669                                  a01));
7670         }
7671
7672       /* See if we can build a range comparison.  */
7673       if (0 != (tem = fold_range_test (t)))
7674         return tem;
7675
7676       /* Check for the possibility of merging component references.  If our
7677          lhs is another similar operation, try to merge its rhs with our
7678          rhs.  Then try to merge our lhs and rhs.  */
7679       if (TREE_CODE (arg0) == code
7680           && 0 != (tem = fold_truthop (code, type,
7681                                        TREE_OPERAND (arg0, 1), arg1)))
7682         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7683
7684       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
7685         return tem;
7686
7687       return t;
7688
7689     case TRUTH_ORIF_EXPR:
7690       /* Note that the operands of this must be ints
7691          and their values must be 0 or true.
7692          ("true" is a fixed value perhaps depending on the language.)  */
7693       /* If first arg is constant true, return it.  */
7694       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7695         return fold_convert (type, arg0);
7696     case TRUTH_OR_EXPR:
7697       /* If either arg is constant zero, drop it.  */
7698       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
7699         return non_lvalue (fold_convert (type, arg1));
7700       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
7701           /* Preserve sequence points.  */
7702           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7703         return non_lvalue (fold_convert (type, arg0));
7704       /* If second arg is constant true, result is true, but we must
7705          evaluate first arg.  */
7706       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
7707         return omit_one_operand (type, arg1, arg0);
7708       /* Likewise for first arg, but note this only occurs here for
7709          TRUTH_OR_EXPR.  */
7710       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7711         return omit_one_operand (type, arg0, arg1);
7712       goto truth_andor;
7713
7714     case TRUTH_XOR_EXPR:
7715       /* If either arg is constant zero, drop it.  */
7716       if (integer_zerop (arg0))
7717         return non_lvalue (fold_convert (type, arg1));
7718       if (integer_zerop (arg1))
7719         return non_lvalue (fold_convert (type, arg0));
7720       /* If either arg is constant true, this is a logical inversion.  */
7721       if (integer_onep (arg0))
7722         return non_lvalue (fold_convert (type, invert_truthvalue (arg1)));
7723       if (integer_onep (arg1))
7724         return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
7725       /* Identical arguments cancel to zero.  */
7726       if (operand_equal_p (arg0, arg1, 0))
7727         return omit_one_operand (type, integer_zero_node, arg0);
7728       return t;
7729
7730     case EQ_EXPR:
7731     case NE_EXPR:
7732     case LT_EXPR:
7733     case GT_EXPR:
7734     case LE_EXPR:
7735     case GE_EXPR:
7736       /* If one arg is a real or integer constant, put it last.  */
7737       if (tree_swap_operands_p (arg0, arg1, true))
7738         return fold (build2 (swap_tree_comparison (code), type, arg1, arg0));
7739
7740       /* If this is an equality comparison of the address of a non-weak
7741          object against zero, then we know the result.  */
7742       if ((code == EQ_EXPR || code == NE_EXPR)
7743           && TREE_CODE (arg0) == ADDR_EXPR
7744           && DECL_P (TREE_OPERAND (arg0, 0))
7745           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7746           && integer_zerop (arg1))
7747         return constant_boolean_node (code != EQ_EXPR, type);
7748
7749       /* If this is an equality comparison of the address of two non-weak,
7750          unaliased symbols neither of which are extern (since we do not
7751          have access to attributes for externs), then we know the result.  */
7752       if ((code == EQ_EXPR || code == NE_EXPR)
7753           && TREE_CODE (arg0) == ADDR_EXPR
7754           && DECL_P (TREE_OPERAND (arg0, 0))
7755           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7756           && ! lookup_attribute ("alias",
7757                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
7758           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
7759           && TREE_CODE (arg1) == ADDR_EXPR
7760           && DECL_P (TREE_OPERAND (arg1, 0))
7761           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
7762           && ! lookup_attribute ("alias",
7763                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
7764           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
7765         return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
7766                                       ? code == EQ_EXPR : code != EQ_EXPR,
7767                                       type);
7768
7769       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
7770         {
7771           tree targ0 = strip_float_extensions (arg0);
7772           tree targ1 = strip_float_extensions (arg1);
7773           tree newtype = TREE_TYPE (targ0);
7774
7775           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
7776             newtype = TREE_TYPE (targ1);
7777
7778           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
7779           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
7780             return fold (build2 (code, type, fold_convert (newtype, targ0),
7781                                  fold_convert (newtype, targ1)));
7782
7783           /* (-a) CMP (-b) -> b CMP a  */
7784           if (TREE_CODE (arg0) == NEGATE_EXPR
7785               && TREE_CODE (arg1) == NEGATE_EXPR)
7786             return fold (build2 (code, type, TREE_OPERAND (arg1, 0),
7787                                  TREE_OPERAND (arg0, 0)));
7788
7789           if (TREE_CODE (arg1) == REAL_CST)
7790           {
7791             REAL_VALUE_TYPE cst;
7792             cst = TREE_REAL_CST (arg1);
7793
7794             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
7795             if (TREE_CODE (arg0) == NEGATE_EXPR)
7796               return
7797                 fold (build2 (swap_tree_comparison (code), type,
7798                               TREE_OPERAND (arg0, 0),
7799                               build_real (TREE_TYPE (arg1),
7800                                           REAL_VALUE_NEGATE (cst))));
7801
7802             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
7803             /* a CMP (-0) -> a CMP 0  */
7804             if (REAL_VALUE_MINUS_ZERO (cst))
7805               return fold (build2 (code, type, arg0,
7806                                    build_real (TREE_TYPE (arg1), dconst0)));
7807
7808             /* x != NaN is always true, other ops are always false.  */
7809             if (REAL_VALUE_ISNAN (cst)
7810                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
7811               {
7812                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
7813                 return omit_one_operand (type, tem, arg0);
7814               }
7815
7816             /* Fold comparisons against infinity.  */
7817             if (REAL_VALUE_ISINF (cst))
7818               {
7819                 tem = fold_inf_compare (code, type, arg0, arg1);
7820                 if (tem != NULL_TREE)
7821                   return tem;
7822               }
7823           }
7824
7825           /* If this is a comparison of a real constant with a PLUS_EXPR
7826              or a MINUS_EXPR of a real constant, we can convert it into a
7827              comparison with a revised real constant as long as no overflow
7828              occurs when unsafe_math_optimizations are enabled.  */
7829           if (flag_unsafe_math_optimizations
7830               && TREE_CODE (arg1) == REAL_CST
7831               && (TREE_CODE (arg0) == PLUS_EXPR
7832                   || TREE_CODE (arg0) == MINUS_EXPR)
7833               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7834               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
7835                                           ? MINUS_EXPR : PLUS_EXPR,
7836                                           arg1, TREE_OPERAND (arg0, 1), 0))
7837               && ! TREE_CONSTANT_OVERFLOW (tem))
7838             return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7839
7840           /* Likewise, we can simplify a comparison of a real constant with
7841              a MINUS_EXPR whose first operand is also a real constant, i.e.
7842              (c1 - x) < c2 becomes x > c1-c2.  */
7843           if (flag_unsafe_math_optimizations
7844               && TREE_CODE (arg1) == REAL_CST
7845               && TREE_CODE (arg0) == MINUS_EXPR
7846               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
7847               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
7848                                           arg1, 0))
7849               && ! TREE_CONSTANT_OVERFLOW (tem))
7850             return fold (build2 (swap_tree_comparison (code), type,
7851                                  TREE_OPERAND (arg0, 1), tem));
7852
7853           /* Fold comparisons against built-in math functions.  */
7854           if (TREE_CODE (arg1) == REAL_CST
7855               && flag_unsafe_math_optimizations
7856               && ! flag_errno_math)
7857             {
7858               enum built_in_function fcode = builtin_mathfn_code (arg0);
7859
7860               if (fcode != END_BUILTINS)
7861                 {
7862                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
7863                   if (tem != NULL_TREE)
7864                     return tem;
7865                 }
7866             }
7867         }
7868
7869       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
7870       if (TREE_CONSTANT (arg1)
7871           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
7872               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
7873           /* This optimization is invalid for ordered comparisons
7874              if CONST+INCR overflows or if foo+incr might overflow.
7875              This optimization is invalid for floating point due to rounding.
7876              For pointer types we assume overflow doesn't happen.  */
7877           && (POINTER_TYPE_P (TREE_TYPE (arg0))
7878               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
7879                   && (code == EQ_EXPR || code == NE_EXPR))))
7880         {
7881           tree varop, newconst;
7882
7883           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
7884             {
7885               newconst = fold (build2 (PLUS_EXPR, TREE_TYPE (arg0),
7886                                        arg1, TREE_OPERAND (arg0, 1)));
7887               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
7888                               TREE_OPERAND (arg0, 0),
7889                               TREE_OPERAND (arg0, 1));
7890             }
7891           else
7892             {
7893               newconst = fold (build2 (MINUS_EXPR, TREE_TYPE (arg0),
7894                                        arg1, TREE_OPERAND (arg0, 1)));
7895               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
7896                               TREE_OPERAND (arg0, 0),
7897                               TREE_OPERAND (arg0, 1));
7898             }
7899
7900
7901           /* If VAROP is a reference to a bitfield, we must mask
7902              the constant by the width of the field.  */
7903           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
7904               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1)))
7905             {
7906               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
7907               int size = TREE_INT_CST_LOW (DECL_SIZE (fielddecl));
7908               tree folded_compare, shift;
7909
7910               /* First check whether the comparison would come out
7911                  always the same.  If we don't do that we would
7912                  change the meaning with the masking.  */
7913               folded_compare = fold (build2 (code, type,
7914                                              TREE_OPERAND (varop, 0),
7915                                              arg1));
7916               if (integer_zerop (folded_compare)
7917                   || integer_onep (folded_compare))
7918                 return omit_one_operand (type, folded_compare, varop);
7919
7920               shift = build_int_2 (TYPE_PRECISION (TREE_TYPE (varop)) - size,
7921                                    0);
7922               newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
7923                                        newconst, shift));
7924               newconst = fold (build2 (RSHIFT_EXPR, TREE_TYPE (varop),
7925                                        newconst, shift));
7926             }
7927
7928           return fold (build2 (code, type, varop, newconst));
7929         }
7930
7931       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
7932          This transformation affects the cases which are handled in later
7933          optimizations involving comparisons with non-negative constants.  */
7934       if (TREE_CODE (arg1) == INTEGER_CST
7935           && TREE_CODE (arg0) != INTEGER_CST
7936           && tree_int_cst_sgn (arg1) > 0)
7937         {
7938           switch (code)
7939             {
7940             case GE_EXPR:
7941               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
7942               return fold (build2 (GT_EXPR, type, arg0, arg1));
7943
7944             case LT_EXPR:
7945               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
7946               return fold (build2 (LE_EXPR, type, arg0, arg1));
7947
7948             default:
7949               break;
7950             }
7951         }
7952
7953       /* Comparisons with the highest or lowest possible integer of
7954          the specified size will have known values.
7955
7956          This is quite similar to fold_relational_hi_lo; however, my
7957          attempts to share the code have been nothing but trouble.
7958          I give up for now.  */
7959       {
7960         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
7961
7962         if (TREE_CODE (arg1) == INTEGER_CST
7963             && ! TREE_CONSTANT_OVERFLOW (arg1)
7964             && width <= HOST_BITS_PER_WIDE_INT
7965             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
7966                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
7967           {
7968             unsigned HOST_WIDE_INT signed_max;
7969             unsigned HOST_WIDE_INT max, min;
7970
7971             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
7972
7973             if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
7974               {
7975                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
7976                 min = 0;
7977               }
7978             else
7979               {
7980                 max = signed_max;
7981                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
7982               }
7983
7984             if (TREE_INT_CST_HIGH (arg1) == 0
7985                 && TREE_INT_CST_LOW (arg1) == max)
7986               switch (code)
7987                 {
7988                 case GT_EXPR:
7989                   return omit_one_operand (type, integer_zero_node, arg0);
7990
7991                 case GE_EXPR:
7992                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
7993
7994                 case LE_EXPR:
7995                   return omit_one_operand (type, integer_one_node, arg0);
7996
7997                 case LT_EXPR:
7998                   return fold (build2 (NE_EXPR, type, arg0, arg1));
7999
8000                 /* The GE_EXPR and LT_EXPR cases above are not normally
8001                    reached because of previous transformations.  */
8002
8003                 default:
8004                   break;
8005                 }
8006             else if (TREE_INT_CST_HIGH (arg1) == 0
8007                      && TREE_INT_CST_LOW (arg1) == max - 1)
8008               switch (code)
8009                 {
8010                 case GT_EXPR:
8011                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8012                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8013                 case LE_EXPR:
8014                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8015                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8016                 default:
8017                   break;
8018                 }
8019             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8020                      && TREE_INT_CST_LOW (arg1) == min)
8021               switch (code)
8022                 {
8023                 case LT_EXPR:
8024                   return omit_one_operand (type, integer_zero_node, arg0);
8025
8026                 case LE_EXPR:
8027                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8028
8029                 case GE_EXPR:
8030                   return omit_one_operand (type, integer_one_node, arg0);
8031
8032                 case GT_EXPR:
8033                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8034
8035                 default:
8036                   break;
8037                 }
8038             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8039                      && TREE_INT_CST_LOW (arg1) == min + 1)
8040               switch (code)
8041                 {
8042                 case GE_EXPR:
8043                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8044                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8045                 case LT_EXPR:
8046                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8047                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8048                 default:
8049                   break;
8050                 }
8051
8052             else if (!in_gimple_form
8053                      && TREE_INT_CST_HIGH (arg1) == 0
8054                      && TREE_INT_CST_LOW (arg1) == signed_max
8055                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
8056                      /* signed_type does not work on pointer types.  */
8057                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
8058               {
8059                 /* The following case also applies to X < signed_max+1
8060                    and X >= signed_max+1 because previous transformations.  */
8061                 if (code == LE_EXPR || code == GT_EXPR)
8062                   {
8063                     tree st0, st1;
8064                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
8065                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
8066                     return fold
8067                       (build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
8068                                type, fold_convert (st0, arg0),
8069                                fold_convert (st1, integer_zero_node)));
8070                   }
8071               }
8072           }
8073       }
8074
8075       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
8076          a MINUS_EXPR of a constant, we can convert it into a comparison with
8077          a revised constant as long as no overflow occurs.  */
8078       if ((code == EQ_EXPR || code == NE_EXPR)
8079           && TREE_CODE (arg1) == INTEGER_CST
8080           && (TREE_CODE (arg0) == PLUS_EXPR
8081               || TREE_CODE (arg0) == MINUS_EXPR)
8082           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8083           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8084                                       ? MINUS_EXPR : PLUS_EXPR,
8085                                       arg1, TREE_OPERAND (arg0, 1), 0))
8086           && ! TREE_CONSTANT_OVERFLOW (tem))
8087         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8088
8089       /* Similarly for a NEGATE_EXPR.  */
8090       else if ((code == EQ_EXPR || code == NE_EXPR)
8091                && TREE_CODE (arg0) == NEGATE_EXPR
8092                && TREE_CODE (arg1) == INTEGER_CST
8093                && 0 != (tem = negate_expr (arg1))
8094                && TREE_CODE (tem) == INTEGER_CST
8095                && ! TREE_CONSTANT_OVERFLOW (tem))
8096         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8097
8098       /* If we have X - Y == 0, we can convert that to X == Y and similarly
8099          for !=.  Don't do this for ordered comparisons due to overflow.  */
8100       else if ((code == NE_EXPR || code == EQ_EXPR)
8101                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
8102         return fold (build2 (code, type,
8103                              TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
8104
8105       /* If we are widening one operand of an integer comparison,
8106          see if the other operand is similarly being widened.  Perhaps we
8107          can do the comparison in the narrower type.  */
8108       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8109                && TREE_CODE (arg0) == NOP_EXPR
8110                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
8111                && (code == EQ_EXPR || code == NE_EXPR
8112                    || TYPE_UNSIGNED (TREE_TYPE (arg0))
8113                       == TYPE_UNSIGNED (TREE_TYPE (tem)))
8114                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
8115                && (TREE_TYPE (t1) == TREE_TYPE (tem)
8116                    || (TREE_CODE (t1) == INTEGER_CST
8117                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
8118         return fold (build2 (code, type, tem,
8119                              fold_convert (TREE_TYPE (tem), t1)));
8120
8121       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8122          constant, we can simplify it.  */
8123       else if (TREE_CODE (arg1) == INTEGER_CST
8124                && (TREE_CODE (arg0) == MIN_EXPR
8125                    || TREE_CODE (arg0) == MAX_EXPR)
8126                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8127         return optimize_minmax_comparison (t);
8128
8129       /* If we are comparing an ABS_EXPR with a constant, we can
8130          convert all the cases into explicit comparisons, but they may
8131          well not be faster than doing the ABS and one comparison.
8132          But ABS (X) <= C is a range comparison, which becomes a subtraction
8133          and a comparison, and is probably faster.  */
8134       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8135                && TREE_CODE (arg0) == ABS_EXPR
8136                && ! TREE_SIDE_EFFECTS (arg0)
8137                && (0 != (tem = negate_expr (arg1)))
8138                && TREE_CODE (tem) == INTEGER_CST
8139                && ! TREE_CONSTANT_OVERFLOW (tem))
8140         return fold (build2 (TRUTH_ANDIF_EXPR, type,
8141                              build2 (GE_EXPR, type,
8142                                      TREE_OPERAND (arg0, 0), tem),
8143                              build2 (LE_EXPR, type,
8144                                      TREE_OPERAND (arg0, 0), arg1)));
8145
8146       /* If this is an EQ or NE comparison with zero and ARG0 is
8147          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
8148          two operations, but the latter can be done in one less insn
8149          on machines that have only two-operand insns or on which a
8150          constant cannot be the first operand.  */
8151       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
8152           && TREE_CODE (arg0) == BIT_AND_EXPR)
8153         {
8154           tree arg00 = TREE_OPERAND (arg0, 0);
8155           tree arg01 = TREE_OPERAND (arg0, 1);
8156           if (TREE_CODE (arg00) == LSHIFT_EXPR
8157               && integer_onep (TREE_OPERAND (arg00, 0)))
8158             return
8159               fold (build2 (code, type,
8160                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8161                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
8162                                             arg01, TREE_OPERAND (arg00, 1)),
8163                                     fold_convert (TREE_TYPE (arg0),
8164                                                   integer_one_node)),
8165                             arg1));
8166           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
8167                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
8168             return
8169               fold (build2 (code, type,
8170                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8171                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
8172                                             arg00, TREE_OPERAND (arg01, 1)),
8173                                     fold_convert (TREE_TYPE (arg0),
8174                                                   integer_one_node)),
8175                             arg1));
8176         }
8177
8178       /* If this is an NE or EQ comparison of zero against the result of a
8179          signed MOD operation whose second operand is a power of 2, make
8180          the MOD operation unsigned since it is simpler and equivalent.  */
8181       if ((code == NE_EXPR || code == EQ_EXPR)
8182           && integer_zerop (arg1)
8183           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
8184           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
8185               || TREE_CODE (arg0) == CEIL_MOD_EXPR
8186               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
8187               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
8188           && integer_pow2p (TREE_OPERAND (arg0, 1)))
8189         {
8190           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
8191           tree newmod = build2 (TREE_CODE (arg0), newtype,
8192                                 fold_convert (newtype,
8193                                               TREE_OPERAND (arg0, 0)),
8194                                 fold_convert (newtype,
8195                                               TREE_OPERAND (arg0, 1)));
8196
8197           return build2 (code, type, newmod, fold_convert (newtype, arg1));
8198         }
8199
8200       /* If this is an NE comparison of zero with an AND of one, remove the
8201          comparison since the AND will give the correct value.  */
8202       if (code == NE_EXPR && integer_zerop (arg1)
8203           && TREE_CODE (arg0) == BIT_AND_EXPR
8204           && integer_onep (TREE_OPERAND (arg0, 1)))
8205         return fold_convert (type, arg0);
8206
8207       /* If we have (A & C) == C where C is a power of 2, convert this into
8208          (A & C) != 0.  Similarly for NE_EXPR.  */
8209       if ((code == EQ_EXPR || code == NE_EXPR)
8210           && TREE_CODE (arg0) == BIT_AND_EXPR
8211           && integer_pow2p (TREE_OPERAND (arg0, 1))
8212           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8213         return fold (build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
8214                              arg0, integer_zero_node));
8215
8216       /* If we have (A & C) != 0 or (A & C) == 0 and C is a power of
8217          2, then fold the expression into shifts and logical operations.  */
8218       tem = fold_single_bit_test (code, arg0, arg1, type);
8219       if (tem)
8220         return tem;
8221
8222       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
8223          Similarly for NE_EXPR.  */
8224       if ((code == EQ_EXPR || code == NE_EXPR)
8225           && TREE_CODE (arg0) == BIT_AND_EXPR
8226           && TREE_CODE (arg1) == INTEGER_CST
8227           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8228         {
8229           tree dandnotc
8230             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8231                             arg1, build1 (BIT_NOT_EXPR,
8232                                           TREE_TYPE (TREE_OPERAND (arg0, 1)),
8233                                           TREE_OPERAND (arg0, 1))));
8234           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8235           if (integer_nonzerop (dandnotc))
8236             return omit_one_operand (type, rslt, arg0);
8237         }
8238
8239       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
8240          Similarly for NE_EXPR.  */
8241       if ((code == EQ_EXPR || code == NE_EXPR)
8242           && TREE_CODE (arg0) == BIT_IOR_EXPR
8243           && TREE_CODE (arg1) == INTEGER_CST
8244           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8245         {
8246           tree candnotd
8247             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8248                             TREE_OPERAND (arg0, 1),
8249                             build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1)));
8250           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8251           if (integer_nonzerop (candnotd))
8252             return omit_one_operand (type, rslt, arg0);
8253         }
8254
8255       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
8256          and similarly for >= into !=.  */
8257       if ((code == LT_EXPR || code == GE_EXPR)
8258           && TYPE_UNSIGNED (TREE_TYPE (arg0))
8259           && TREE_CODE (arg1) == LSHIFT_EXPR
8260           && integer_onep (TREE_OPERAND (arg1, 0)))
8261         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8262                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8263                                TREE_OPERAND (arg1, 1)),
8264                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
8265
8266       else if ((code == LT_EXPR || code == GE_EXPR)
8267                && TYPE_UNSIGNED (TREE_TYPE (arg0))
8268                && (TREE_CODE (arg1) == NOP_EXPR
8269                    || TREE_CODE (arg1) == CONVERT_EXPR)
8270                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
8271                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
8272         return
8273           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8274                   fold_convert (TREE_TYPE (arg0),
8275                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8276                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
8277                                                       1))),
8278                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
8279
8280       /* Simplify comparison of something with itself.  (For IEEE
8281          floating-point, we can only do some of these simplifications.)  */
8282       if (operand_equal_p (arg0, arg1, 0))
8283         {
8284           switch (code)
8285             {
8286             case EQ_EXPR:
8287               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8288                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8289                 return constant_boolean_node (1, type);
8290               break;
8291
8292             case GE_EXPR:
8293             case LE_EXPR:
8294               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8295                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8296                 return constant_boolean_node (1, type);
8297               return fold (build2 (EQ_EXPR, type, arg0, arg1));
8298
8299             case NE_EXPR:
8300               /* For NE, we can only do this simplification if integer
8301                  or we don't honor IEEE floating point NaNs.  */
8302               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8303                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8304                 break;
8305               /* ... fall through ...  */
8306             case GT_EXPR:
8307             case LT_EXPR:
8308               return constant_boolean_node (0, type);
8309             default:
8310               abort ();
8311             }
8312         }
8313
8314       /* If we are comparing an expression that just has comparisons
8315          of two integer values, arithmetic expressions of those comparisons,
8316          and constants, we can simplify it.  There are only three cases
8317          to check: the two values can either be equal, the first can be
8318          greater, or the second can be greater.  Fold the expression for
8319          those three values.  Since each value must be 0 or 1, we have
8320          eight possibilities, each of which corresponds to the constant 0
8321          or 1 or one of the six possible comparisons.
8322
8323          This handles common cases like (a > b) == 0 but also handles
8324          expressions like  ((x > y) - (y > x)) > 0, which supposedly
8325          occur in macroized code.  */
8326
8327       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8328         {
8329           tree cval1 = 0, cval2 = 0;
8330           int save_p = 0;
8331
8332           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8333               /* Don't handle degenerate cases here; they should already
8334                  have been handled anyway.  */
8335               && cval1 != 0 && cval2 != 0
8336               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8337               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8338               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8339               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8340               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8341               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8342                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8343             {
8344               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8345               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8346
8347               /* We can't just pass T to eval_subst in case cval1 or cval2
8348                  was the same as ARG1.  */
8349
8350               tree high_result
8351                 = fold (build2 (code, type,
8352                                 eval_subst (arg0, cval1, maxval,
8353                                             cval2, minval),
8354                                 arg1));
8355               tree equal_result
8356                 = fold (build2 (code, type,
8357                                 eval_subst (arg0, cval1, maxval,
8358                                             cval2, maxval),
8359                                 arg1));
8360               tree low_result
8361                 = fold (build2 (code, type,
8362                                 eval_subst (arg0, cval1, minval,
8363                                             cval2, maxval),
8364                                 arg1));
8365
8366               /* All three of these results should be 0 or 1.  Confirm they
8367                  are.  Then use those values to select the proper code
8368                  to use.  */
8369
8370               if ((integer_zerop (high_result)
8371                    || integer_onep (high_result))
8372                   && (integer_zerop (equal_result)
8373                       || integer_onep (equal_result))
8374                   && (integer_zerop (low_result)
8375                       || integer_onep (low_result)))
8376                 {
8377                   /* Make a 3-bit mask with the high-order bit being the
8378                      value for `>', the next for '=', and the low for '<'.  */
8379                   switch ((integer_onep (high_result) * 4)
8380                           + (integer_onep (equal_result) * 2)
8381                           + integer_onep (low_result))
8382                     {
8383                     case 0:
8384                       /* Always false.  */
8385                       return omit_one_operand (type, integer_zero_node, arg0);
8386                     case 1:
8387                       code = LT_EXPR;
8388                       break;
8389                     case 2:
8390                       code = EQ_EXPR;
8391                       break;
8392                     case 3:
8393                       code = LE_EXPR;
8394                       break;
8395                     case 4:
8396                       code = GT_EXPR;
8397                       break;
8398                     case 5:
8399                       code = NE_EXPR;
8400                       break;
8401                     case 6:
8402                       code = GE_EXPR;
8403                       break;
8404                     case 7:
8405                       /* Always true.  */
8406                       return omit_one_operand (type, integer_one_node, arg0);
8407                     }
8408
8409                   tem = build2 (code, type, cval1, cval2);
8410                   if (save_p)
8411                     return save_expr (tem);
8412                   else
8413                     return fold (tem);
8414                 }
8415             }
8416         }
8417
8418       /* If this is a comparison of a field, we may be able to simplify it.  */
8419       if (((TREE_CODE (arg0) == COMPONENT_REF
8420             && lang_hooks.can_use_bit_fields_p ())
8421            || TREE_CODE (arg0) == BIT_FIELD_REF)
8422           && (code == EQ_EXPR || code == NE_EXPR)
8423           /* Handle the constant case even without -O
8424              to make sure the warnings are given.  */
8425           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
8426         {
8427           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
8428           if (t1)
8429             return t1;
8430         }
8431
8432       /* If this is a comparison of complex values and either or both sides
8433          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
8434          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
8435          This may prevent needless evaluations.  */
8436       if ((code == EQ_EXPR || code == NE_EXPR)
8437           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
8438           && (TREE_CODE (arg0) == COMPLEX_EXPR
8439               || TREE_CODE (arg1) == COMPLEX_EXPR
8440               || TREE_CODE (arg0) == COMPLEX_CST
8441               || TREE_CODE (arg1) == COMPLEX_CST))
8442         {
8443           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
8444           tree real0, imag0, real1, imag1;
8445
8446           arg0 = save_expr (arg0);
8447           arg1 = save_expr (arg1);
8448           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
8449           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
8450           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
8451           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
8452
8453           return fold (build2 ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
8454                                 : TRUTH_ORIF_EXPR),
8455                                type,
8456                                fold (build2 (code, type, real0, real1)),
8457                                fold (build2 (code, type, imag0, imag1))));
8458         }
8459
8460       /* Optimize comparisons of strlen vs zero to a compare of the
8461          first character of the string vs zero.  To wit,
8462                 strlen(ptr) == 0   =>  *ptr == 0
8463                 strlen(ptr) != 0   =>  *ptr != 0
8464          Other cases should reduce to one of these two (or a constant)
8465          due to the return value of strlen being unsigned.  */
8466       if ((code == EQ_EXPR || code == NE_EXPR)
8467           && integer_zerop (arg1)
8468           && TREE_CODE (arg0) == CALL_EXPR)
8469         {
8470           tree fndecl = get_callee_fndecl (arg0);
8471           tree arglist;
8472
8473           if (fndecl
8474               && DECL_BUILT_IN (fndecl)
8475               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
8476               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
8477               && (arglist = TREE_OPERAND (arg0, 1))
8478               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
8479               && ! TREE_CHAIN (arglist))
8480             return fold (build2 (code, type,
8481                                  build1 (INDIRECT_REF, char_type_node,
8482                                          TREE_VALUE(arglist)),
8483                                  integer_zero_node));
8484         }
8485
8486       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8487          into a single range test.  */
8488       if (TREE_CODE (arg0) == TRUNC_DIV_EXPR
8489           && TREE_CODE (arg1) == INTEGER_CST
8490           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8491           && !integer_zerop (TREE_OPERAND (arg0, 1))
8492           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8493           && !TREE_OVERFLOW (arg1))
8494         {
8495           t1 = fold_div_compare (code, type, arg0, arg1);
8496           if (t1 != NULL_TREE)
8497             return t1;
8498         }
8499
8500       /* Both ARG0 and ARG1 are known to be constants at this point.  */
8501       t1 = fold_relational_const (code, type, arg0, arg1);
8502       return (t1 == NULL_TREE ? t : t1);
8503
8504     case UNORDERED_EXPR:
8505     case ORDERED_EXPR:
8506     case UNLT_EXPR:
8507     case UNLE_EXPR:
8508     case UNGT_EXPR:
8509     case UNGE_EXPR:
8510     case UNEQ_EXPR:
8511     case LTGT_EXPR:
8512       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8513         {
8514           t1 = fold_relational_const (code, type, arg0, arg1);
8515           if (t1 != NULL_TREE)
8516             return t1;
8517         }
8518
8519       /* If the first operand is NaN, the result is constant.  */
8520       if (TREE_CODE (arg0) == REAL_CST
8521           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
8522           && (code != LTGT_EXPR || ! flag_trapping_math))
8523         {
8524           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8525                ? integer_zero_node
8526                : integer_one_node;
8527           return omit_one_operand (type, t1, arg1);
8528         }
8529
8530       /* If the second operand is NaN, the result is constant.  */
8531       if (TREE_CODE (arg1) == REAL_CST
8532           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
8533           && (code != LTGT_EXPR || ! flag_trapping_math))
8534         {
8535           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8536                ? integer_zero_node
8537                : integer_one_node;
8538           return omit_one_operand (type, t1, arg0);
8539         }
8540
8541       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8542       {
8543         tree targ0 = strip_float_extensions (arg0);
8544         tree targ1 = strip_float_extensions (arg1);
8545         tree newtype = TREE_TYPE (targ0);
8546
8547         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8548           newtype = TREE_TYPE (targ1);
8549
8550         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8551           return fold (build2 (code, type, fold_convert (newtype, targ0),
8552                                fold_convert (newtype, targ1)));
8553       }
8554
8555       return t;
8556
8557     case COND_EXPR:
8558       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
8559          so all simple results must be passed through pedantic_non_lvalue.  */
8560       if (TREE_CODE (arg0) == INTEGER_CST)
8561         {
8562           tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
8563           /* Only optimize constant conditions when the selected branch
8564              has the same type as the COND_EXPR.  This avoids optimizing
8565              away "c ? x : throw", where the throw has a void type.  */
8566           if (! VOID_TYPE_P (TREE_TYPE (tem))
8567               || VOID_TYPE_P (type))
8568             return pedantic_non_lvalue (tem);
8569           return t;
8570         }
8571       if (operand_equal_p (arg1, TREE_OPERAND (t, 2), 0))
8572         return pedantic_omit_one_operand (type, arg1, arg0);
8573
8574       /* If we have A op B ? A : C, we may be able to convert this to a
8575          simpler expression, depending on the operation and the values
8576          of B and C.  Signed zeros prevent all of these transformations,
8577          for reasons given above each one.
8578
8579          Also try swapping the arguments and inverting the conditional.  */
8580       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8581           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8582                                              arg1, TREE_OPERAND (arg0, 1))
8583           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
8584         {
8585           tem = fold_cond_expr_with_comparison (type, arg0,
8586                                                 TREE_OPERAND (t, 2));
8587           if (tem)
8588             return tem;
8589         }
8590
8591       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8592           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8593                                              TREE_OPERAND (t, 2),
8594                                              TREE_OPERAND (arg0, 1))
8595           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
8596         {
8597           tem = invert_truthvalue (arg0);
8598           if (TREE_CODE_CLASS (TREE_CODE (tem)) == '<')
8599             {
8600               tem = fold_cond_expr_with_comparison (type, tem, arg1);
8601               if (tem)
8602                 return tem;
8603             }
8604         }
8605
8606       /* If the second operand is simpler than the third, swap them
8607          since that produces better jump optimization results.  */
8608       if (tree_swap_operands_p (TREE_OPERAND (t, 1),
8609                                 TREE_OPERAND (t, 2), false))
8610         {
8611           /* See if this can be inverted.  If it can't, possibly because
8612              it was a floating-point inequality comparison, don't do
8613              anything.  */
8614           tem = invert_truthvalue (arg0);
8615
8616           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8617             return fold (build3 (code, type, tem,
8618                                  TREE_OPERAND (t, 2), TREE_OPERAND (t, 1)));
8619         }
8620
8621       /* Convert A ? 1 : 0 to simply A.  */
8622       if (integer_onep (TREE_OPERAND (t, 1))
8623           && integer_zerop (TREE_OPERAND (t, 2))
8624           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
8625              call to fold will try to move the conversion inside
8626              a COND, which will recurse.  In that case, the COND_EXPR
8627              is probably the best choice, so leave it alone.  */
8628           && type == TREE_TYPE (arg0))
8629         return pedantic_non_lvalue (arg0);
8630
8631       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
8632          over COND_EXPR in cases such as floating point comparisons.  */
8633       if (integer_zerop (TREE_OPERAND (t, 1))
8634           && integer_onep (TREE_OPERAND (t, 2))
8635           && truth_value_p (TREE_CODE (arg0)))
8636         return pedantic_non_lvalue (fold_convert (type,
8637                                                   invert_truthvalue (arg0)));
8638
8639       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
8640       if (TREE_CODE (arg0) == LT_EXPR
8641           && integer_zerop (TREE_OPERAND (arg0, 1))
8642           && integer_zerop (TREE_OPERAND (t, 2))
8643           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
8644         return fold_convert (type, fold (build2 (BIT_AND_EXPR,
8645                                                  TREE_TYPE (tem), tem, arg1)));
8646
8647       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
8648          already handled above.  */
8649       if (TREE_CODE (arg0) == BIT_AND_EXPR
8650           && integer_onep (TREE_OPERAND (arg0, 1))
8651           && integer_zerop (TREE_OPERAND (t, 2))
8652           && integer_pow2p (arg1))
8653         {
8654           tree tem = TREE_OPERAND (arg0, 0);
8655           STRIP_NOPS (tem);
8656           if (TREE_CODE (tem) == RSHIFT_EXPR
8657               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
8658                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
8659             return fold (build2 (BIT_AND_EXPR, type,
8660                                  TREE_OPERAND (tem, 0), arg1));
8661         }
8662
8663       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
8664          is probably obsolete because the first operand should be a
8665          truth value (that's why we have the two cases above), but let's
8666          leave it in until we can confirm this for all front-ends.  */
8667       if (integer_zerop (TREE_OPERAND (t, 2))
8668           && TREE_CODE (arg0) == NE_EXPR
8669           && integer_zerop (TREE_OPERAND (arg0, 1))
8670           && integer_pow2p (arg1)
8671           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
8672           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
8673                               arg1, OEP_ONLY_CONST))
8674         return pedantic_non_lvalue (fold_convert (type,
8675                                                   TREE_OPERAND (arg0, 0)));
8676
8677       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
8678       if (integer_zerop (TREE_OPERAND (t, 2))
8679           && truth_value_p (TREE_CODE (arg0))
8680           && truth_value_p (TREE_CODE (arg1)))
8681         return fold (build2 (TRUTH_ANDIF_EXPR, type, arg0, arg1));
8682
8683       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
8684       if (integer_onep (TREE_OPERAND (t, 2))
8685           && truth_value_p (TREE_CODE (arg0))
8686           && truth_value_p (TREE_CODE (arg1)))
8687         {
8688           /* Only perform transformation if ARG0 is easily inverted.  */
8689           tem = invert_truthvalue (arg0);
8690           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8691             return fold (build2 (TRUTH_ORIF_EXPR, type, tem, arg1));
8692         }
8693
8694       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
8695       if (integer_zerop (arg1)
8696           && truth_value_p (TREE_CODE (arg0))
8697           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8698         {
8699           /* Only perform transformation if ARG0 is easily inverted.  */
8700           tem = invert_truthvalue (arg0);
8701           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8702             return fold (build2 (TRUTH_ANDIF_EXPR, type, tem,
8703                                  TREE_OPERAND (t, 2)));
8704         }
8705
8706       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
8707       if (integer_onep (arg1)
8708           && truth_value_p (TREE_CODE (arg0))
8709           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8710         return fold (build2 (TRUTH_ORIF_EXPR, type, arg0,
8711                              TREE_OPERAND (t, 2)));
8712
8713       return t;
8714
8715     case COMPOUND_EXPR:
8716       /* When pedantic, a compound expression can be neither an lvalue
8717          nor an integer constant expression.  */
8718       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
8719         return t;
8720       /* Don't let (0, 0) be null pointer constant.  */
8721       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
8722                                  : fold_convert (type, arg1);
8723       return pedantic_non_lvalue (tem);
8724
8725     case COMPLEX_EXPR:
8726       if (wins)
8727         return build_complex (type, arg0, arg1);
8728       return t;
8729
8730     case REALPART_EXPR:
8731       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8732         return t;
8733       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8734         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8735                                  TREE_OPERAND (arg0, 1));
8736       else if (TREE_CODE (arg0) == COMPLEX_CST)
8737         return TREE_REALPART (arg0);
8738       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8739         return fold (build2 (TREE_CODE (arg0), type,
8740                              fold (build1 (REALPART_EXPR, type,
8741                                            TREE_OPERAND (arg0, 0))),
8742                              fold (build1 (REALPART_EXPR, type,
8743                                            TREE_OPERAND (arg0, 1)))));
8744       return t;
8745
8746     case IMAGPART_EXPR:
8747       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8748         return fold_convert (type, integer_zero_node);
8749       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8750         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8751                                  TREE_OPERAND (arg0, 0));
8752       else if (TREE_CODE (arg0) == COMPLEX_CST)
8753         return TREE_IMAGPART (arg0);
8754       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8755         return fold (build2 (TREE_CODE (arg0), type,
8756                              fold (build1 (IMAGPART_EXPR, type,
8757                                            TREE_OPERAND (arg0, 0))),
8758                              fold (build1 (IMAGPART_EXPR, type,
8759                                            TREE_OPERAND (arg0, 1)))));
8760       return t;
8761
8762       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
8763          appropriate.  */
8764     case CLEANUP_POINT_EXPR:
8765       if (! has_cleanups (arg0))
8766         return TREE_OPERAND (t, 0);
8767
8768       {
8769         enum tree_code code0 = TREE_CODE (arg0);
8770         int kind0 = TREE_CODE_CLASS (code0);
8771         tree arg00 = TREE_OPERAND (arg0, 0);
8772         tree arg01;
8773
8774         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
8775           return fold (build1 (code0, type,
8776                                fold (build1 (CLEANUP_POINT_EXPR,
8777                                              TREE_TYPE (arg00), arg00))));
8778
8779         if (kind0 == '<' || kind0 == '2'
8780             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
8781             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
8782             || code0 == TRUTH_XOR_EXPR)
8783           {
8784             arg01 = TREE_OPERAND (arg0, 1);
8785
8786             if (TREE_CONSTANT (arg00)
8787                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
8788                     && ! has_cleanups (arg00)))
8789               return fold (build2 (code0, type, arg00,
8790                                    fold (build1 (CLEANUP_POINT_EXPR,
8791                                                  TREE_TYPE (arg01), arg01))));
8792
8793             if (TREE_CONSTANT (arg01))
8794               return fold (build2 (code0, type,
8795                                    fold (build1 (CLEANUP_POINT_EXPR,
8796                                                  TREE_TYPE (arg00), arg00)),
8797                                    arg01));
8798           }
8799
8800         return t;
8801       }
8802
8803     case CALL_EXPR:
8804       /* Check for a built-in function.  */
8805       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
8806           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
8807               == FUNCTION_DECL)
8808           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
8809         {
8810           tree tmp = fold_builtin (t);
8811           if (tmp)
8812             return tmp;
8813         }
8814       return t;
8815
8816     default:
8817       return t;
8818     } /* switch (code) */
8819 }
8820
8821 #ifdef ENABLE_FOLD_CHECKING
8822 #undef fold
8823
8824 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
8825 static void fold_check_failed (tree, tree);
8826 void print_fold_checksum (tree);
8827
8828 /* When --enable-checking=fold, compute a digest of expr before
8829    and after actual fold call to see if fold did not accidentally
8830    change original expr.  */
8831
8832 tree
8833 fold (tree expr)
8834 {
8835   tree ret;
8836   struct md5_ctx ctx;
8837   unsigned char checksum_before[16], checksum_after[16];
8838   htab_t ht;
8839
8840   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
8841   md5_init_ctx (&ctx);
8842   fold_checksum_tree (expr, &ctx, ht);
8843   md5_finish_ctx (&ctx, checksum_before);
8844   htab_empty (ht);
8845
8846   ret = fold_1 (expr);
8847
8848   md5_init_ctx (&ctx);
8849   fold_checksum_tree (expr, &ctx, ht);
8850   md5_finish_ctx (&ctx, checksum_after);
8851   htab_delete (ht);
8852
8853   if (memcmp (checksum_before, checksum_after, 16))
8854     fold_check_failed (expr, ret);
8855
8856   return ret;
8857 }
8858
8859 void
8860 print_fold_checksum (tree expr)
8861 {
8862   struct md5_ctx ctx;
8863   unsigned char checksum[16], cnt;
8864   htab_t ht;
8865
8866   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
8867   md5_init_ctx (&ctx);
8868   fold_checksum_tree (expr, &ctx, ht);
8869   md5_finish_ctx (&ctx, checksum);
8870   htab_delete (ht);
8871   for (cnt = 0; cnt < 16; ++cnt)
8872     fprintf (stderr, "%02x", checksum[cnt]);
8873   putc ('\n', stderr);
8874 }
8875
8876 static void
8877 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
8878 {
8879   internal_error ("fold check: original tree changed by fold");
8880 }
8881
8882 static void
8883 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
8884 {
8885   void **slot;
8886   enum tree_code code;
8887   char buf[sizeof (struct tree_decl)];
8888   int i, len;
8889
8890   if (sizeof (struct tree_exp) + 5 * sizeof (tree)
8891       > sizeof (struct tree_decl)
8892       || sizeof (struct tree_type) > sizeof (struct tree_decl))
8893     abort ();
8894   if (expr == NULL)
8895     return;
8896   slot = htab_find_slot (ht, expr, INSERT);
8897   if (*slot != NULL)
8898     return;
8899   *slot = expr;
8900   code = TREE_CODE (expr);
8901   if (code == SAVE_EXPR && SAVE_EXPR_NOPLACEHOLDER (expr))
8902     {
8903       /* Allow SAVE_EXPR_NOPLACEHOLDER flag to be modified.  */
8904       memcpy (buf, expr, tree_size (expr));
8905       expr = (tree) buf;
8906       SAVE_EXPR_NOPLACEHOLDER (expr) = 0;
8907     }
8908   else if (TREE_CODE_CLASS (code) == 'd' && DECL_ASSEMBLER_NAME_SET_P (expr))
8909     {
8910       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
8911       memcpy (buf, expr, tree_size (expr));
8912       expr = (tree) buf;
8913       SET_DECL_ASSEMBLER_NAME (expr, NULL);
8914     }
8915   else if (TREE_CODE_CLASS (code) == 't'
8916            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)))
8917     {
8918       /* Allow TYPE_POINTER_TO and TYPE_REFERENCE_TO to be modified.  */
8919       memcpy (buf, expr, tree_size (expr));
8920       expr = (tree) buf;
8921       TYPE_POINTER_TO (expr) = NULL;
8922       TYPE_REFERENCE_TO (expr) = NULL;
8923     }
8924   md5_process_bytes (expr, tree_size (expr), ctx);
8925   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
8926   if (TREE_CODE_CLASS (code) != 't' && TREE_CODE_CLASS (code) != 'd')
8927     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
8928   len = TREE_CODE_LENGTH (code);
8929   switch (TREE_CODE_CLASS (code))
8930     {
8931     case 'c':
8932       switch (code)
8933         {
8934         case STRING_CST:
8935           md5_process_bytes (TREE_STRING_POINTER (expr),
8936                              TREE_STRING_LENGTH (expr), ctx);
8937           break;
8938         case COMPLEX_CST:
8939           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
8940           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
8941           break;
8942         case VECTOR_CST:
8943           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
8944           break;
8945         default:
8946           break;
8947         }
8948       break;
8949     case 'x':
8950       switch (code)
8951         {
8952         case TREE_LIST:
8953           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
8954           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
8955           break;
8956         case TREE_VEC:
8957           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
8958             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
8959           break;
8960         default:
8961           break;
8962         }
8963       break;
8964     case 'e':
8965       switch (code)
8966         {
8967         case SAVE_EXPR: len = 2; break;
8968         case GOTO_SUBROUTINE_EXPR: len = 0; break;
8969         case RTL_EXPR: len = 0; break;
8970         case WITH_CLEANUP_EXPR: len = 2; break;
8971         default: break;
8972         }
8973       /* Fall through.  */
8974     case 'r':
8975     case '<':
8976     case '1':
8977     case '2':
8978     case 's':
8979       for (i = 0; i < len; ++i)
8980         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
8981       break;
8982     case 'd':
8983       fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
8984       fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
8985       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
8986       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
8987       fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
8988       fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
8989       fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
8990       fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
8991       fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
8992       fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
8993       fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
8994       break;
8995     case 't':
8996       if (TREE_CODE (expr) == ENUMERAL_TYPE)
8997         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
8998       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
8999       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
9000       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
9001       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
9002       if (INTEGRAL_TYPE_P (expr)
9003           || SCALAR_FLOAT_TYPE_P (expr))
9004         {
9005           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
9006           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
9007         }
9008       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
9009       fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
9010       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
9011       break;
9012     default:
9013       break;
9014     }
9015 }
9016
9017 #endif
9018
9019 /* Perform constant folding and related simplification of initializer
9020    expression EXPR.  This behaves identically to "fold" but ignores
9021    potential run-time traps and exceptions that fold must preserve.  */
9022
9023 tree
9024 fold_initializer (tree expr)
9025 {
9026   int saved_signaling_nans = flag_signaling_nans;
9027   int saved_trapping_math = flag_trapping_math;
9028   int saved_trapv = flag_trapv;
9029   tree result;
9030
9031   flag_signaling_nans = 0;
9032   flag_trapping_math = 0;
9033   flag_trapv = 0;
9034
9035   result = fold (expr);
9036
9037   flag_signaling_nans = saved_signaling_nans;
9038   flag_trapping_math = saved_trapping_math;
9039   flag_trapv = saved_trapv;
9040
9041   return result;
9042 }
9043
9044 /* Determine if first argument is a multiple of second argument.  Return 0 if
9045    it is not, or we cannot easily determined it to be.
9046
9047    An example of the sort of thing we care about (at this point; this routine
9048    could surely be made more general, and expanded to do what the *_DIV_EXPR's
9049    fold cases do now) is discovering that
9050
9051      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9052
9053    is a multiple of
9054
9055      SAVE_EXPR (J * 8)
9056
9057    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
9058
9059    This code also handles discovering that
9060
9061      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9062
9063    is a multiple of 8 so we don't have to worry about dealing with a
9064    possible remainder.
9065
9066    Note that we *look* inside a SAVE_EXPR only to determine how it was
9067    calculated; it is not safe for fold to do much of anything else with the
9068    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
9069    at run time.  For example, the latter example above *cannot* be implemented
9070    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
9071    evaluation time of the original SAVE_EXPR is not necessarily the same at
9072    the time the new expression is evaluated.  The only optimization of this
9073    sort that would be valid is changing
9074
9075      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
9076
9077    divided by 8 to
9078
9079      SAVE_EXPR (I) * SAVE_EXPR (J)
9080
9081    (where the same SAVE_EXPR (J) is used in the original and the
9082    transformed version).  */
9083
9084 static int
9085 multiple_of_p (tree type, tree top, tree bottom)
9086 {
9087   if (operand_equal_p (top, bottom, 0))
9088     return 1;
9089
9090   if (TREE_CODE (type) != INTEGER_TYPE)
9091     return 0;
9092
9093   switch (TREE_CODE (top))
9094     {
9095     case MULT_EXPR:
9096       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9097               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9098
9099     case PLUS_EXPR:
9100     case MINUS_EXPR:
9101       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9102               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9103
9104     case LSHIFT_EXPR:
9105       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
9106         {
9107           tree op1, t1;
9108
9109           op1 = TREE_OPERAND (top, 1);
9110           /* const_binop may not detect overflow correctly,
9111              so check for it explicitly here.  */
9112           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
9113               > TREE_INT_CST_LOW (op1)
9114               && TREE_INT_CST_HIGH (op1) == 0
9115               && 0 != (t1 = fold_convert (type,
9116                                           const_binop (LSHIFT_EXPR,
9117                                                        size_one_node,
9118                                                        op1, 0)))
9119               && ! TREE_OVERFLOW (t1))
9120             return multiple_of_p (type, t1, bottom);
9121         }
9122       return 0;
9123
9124     case NOP_EXPR:
9125       /* Can't handle conversions from non-integral or wider integral type.  */
9126       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
9127           || (TYPE_PRECISION (type)
9128               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
9129         return 0;
9130
9131       /* .. fall through ...  */
9132
9133     case SAVE_EXPR:
9134       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
9135
9136     case INTEGER_CST:
9137       if (TREE_CODE (bottom) != INTEGER_CST
9138           || (TYPE_UNSIGNED (type)
9139               && (tree_int_cst_sgn (top) < 0
9140                   || tree_int_cst_sgn (bottom) < 0)))
9141         return 0;
9142       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
9143                                          top, bottom, 0));
9144
9145     default:
9146       return 0;
9147     }
9148 }
9149
9150 /* Return true if `t' is known to be non-negative.  */
9151
9152 int
9153 tree_expr_nonnegative_p (tree t)
9154 {
9155   switch (TREE_CODE (t))
9156     {
9157     case ABS_EXPR:
9158       return 1;
9159
9160     case INTEGER_CST:
9161       return tree_int_cst_sgn (t) >= 0;
9162
9163     case REAL_CST:
9164       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
9165
9166     case PLUS_EXPR:
9167       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9168         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9169                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9170
9171       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
9172          both unsigned and at least 2 bits shorter than the result.  */
9173       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9174           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9175           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9176         {
9177           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9178           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9179           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9180               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9181             {
9182               unsigned int prec = MAX (TYPE_PRECISION (inner1),
9183                                        TYPE_PRECISION (inner2)) + 1;
9184               return prec < TYPE_PRECISION (TREE_TYPE (t));
9185             }
9186         }
9187       break;
9188
9189     case MULT_EXPR:
9190       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9191         {
9192           /* x * x for floating point x is always non-negative.  */
9193           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
9194             return 1;
9195           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9196                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9197         }
9198
9199       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
9200          both unsigned and their total bits is shorter than the result.  */
9201       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9202           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9203           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9204         {
9205           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9206           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9207           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9208               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9209             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
9210                    < TYPE_PRECISION (TREE_TYPE (t));
9211         }
9212       return 0;
9213
9214     case TRUNC_DIV_EXPR:
9215     case CEIL_DIV_EXPR:
9216     case FLOOR_DIV_EXPR:
9217     case ROUND_DIV_EXPR:
9218       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9219              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9220
9221     case TRUNC_MOD_EXPR:
9222     case CEIL_MOD_EXPR:
9223     case FLOOR_MOD_EXPR:
9224     case ROUND_MOD_EXPR:
9225       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9226
9227     case RDIV_EXPR:
9228       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9229              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9230
9231     case BIT_AND_EXPR:
9232       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9233              || tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9234     case BIT_IOR_EXPR:
9235     case BIT_XOR_EXPR:
9236       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9237              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9238
9239     case NOP_EXPR:
9240       {
9241         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9242         tree outer_type = TREE_TYPE (t);
9243
9244         if (TREE_CODE (outer_type) == REAL_TYPE)
9245           {
9246             if (TREE_CODE (inner_type) == REAL_TYPE)
9247               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9248             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9249               {
9250                 if (TYPE_UNSIGNED (inner_type))
9251                   return 1;
9252                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9253               }
9254           }
9255         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
9256           {
9257             if (TREE_CODE (inner_type) == REAL_TYPE)
9258               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
9259             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9260               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
9261                       && TYPE_UNSIGNED (inner_type);
9262           }
9263       }
9264       break;
9265
9266     case COND_EXPR:
9267       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9268         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
9269     case COMPOUND_EXPR:
9270       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9271     case MIN_EXPR:
9272       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9273         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9274     case MAX_EXPR:
9275       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9276         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9277     case MODIFY_EXPR:
9278       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9279     case BIND_EXPR:
9280       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
9281     case SAVE_EXPR:
9282       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9283     case NON_LVALUE_EXPR:
9284       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9285     case FLOAT_EXPR:
9286       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9287     case RTL_EXPR:
9288       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
9289
9290     case TARGET_EXPR:
9291       {
9292         tree temp = TARGET_EXPR_SLOT (t);
9293         t = TARGET_EXPR_INITIAL (t);
9294
9295         /* If the initializer is non-void, then it's a normal expression
9296            that will be assigned to the slot.  */
9297         if (!VOID_TYPE_P (t))
9298           return tree_expr_nonnegative_p (t);
9299
9300         /* Otherwise, the initializer sets the slot in some way.  One common
9301            way is an assignment statement at the end of the initializer.  */
9302         while (1)
9303           {
9304             if (TREE_CODE (t) == BIND_EXPR)
9305               t = expr_last (BIND_EXPR_BODY (t));
9306             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
9307                      || TREE_CODE (t) == TRY_CATCH_EXPR)
9308               t = expr_last (TREE_OPERAND (t, 0));
9309             else if (TREE_CODE (t) == STATEMENT_LIST)
9310               t = expr_last (t);
9311             else
9312               break;
9313           }
9314         if (TREE_CODE (t) == MODIFY_EXPR
9315             && TREE_OPERAND (t, 0) == temp)
9316           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9317
9318         return 0;
9319       }
9320
9321     case CALL_EXPR:
9322       {
9323         tree fndecl = get_callee_fndecl (t);
9324         tree arglist = TREE_OPERAND (t, 1);
9325         if (fndecl
9326             && DECL_BUILT_IN (fndecl)
9327             && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
9328           switch (DECL_FUNCTION_CODE (fndecl))
9329             {
9330 #define CASE_BUILTIN_F(BUILT_IN_FN) \
9331   case BUILT_IN_FN: case BUILT_IN_FN##F: case BUILT_IN_FN##L:
9332 #define CASE_BUILTIN_I(BUILT_IN_FN) \
9333   case BUILT_IN_FN: case BUILT_IN_FN##L: case BUILT_IN_FN##LL:
9334
9335             CASE_BUILTIN_F (BUILT_IN_ACOS)
9336             CASE_BUILTIN_F (BUILT_IN_ACOSH)
9337             CASE_BUILTIN_F (BUILT_IN_CABS)
9338             CASE_BUILTIN_F (BUILT_IN_COSH)
9339             CASE_BUILTIN_F (BUILT_IN_ERFC)
9340             CASE_BUILTIN_F (BUILT_IN_EXP)
9341             CASE_BUILTIN_F (BUILT_IN_EXP10)
9342             CASE_BUILTIN_F (BUILT_IN_EXP2)
9343             CASE_BUILTIN_F (BUILT_IN_FABS)
9344             CASE_BUILTIN_F (BUILT_IN_FDIM)
9345             CASE_BUILTIN_F (BUILT_IN_FREXP)
9346             CASE_BUILTIN_F (BUILT_IN_HYPOT)
9347             CASE_BUILTIN_F (BUILT_IN_POW10)
9348             CASE_BUILTIN_I (BUILT_IN_FFS)
9349             CASE_BUILTIN_I (BUILT_IN_PARITY)
9350             CASE_BUILTIN_I (BUILT_IN_POPCOUNT)
9351               /* Always true.  */
9352               return 1;
9353
9354             CASE_BUILTIN_F (BUILT_IN_SQRT)
9355               /* sqrt(-0.0) is -0.0.  */
9356               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
9357                 return 1;
9358               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9359
9360             CASE_BUILTIN_F (BUILT_IN_ASINH)
9361             CASE_BUILTIN_F (BUILT_IN_ATAN)
9362             CASE_BUILTIN_F (BUILT_IN_ATANH)
9363             CASE_BUILTIN_F (BUILT_IN_CBRT)
9364             CASE_BUILTIN_F (BUILT_IN_CEIL)
9365             CASE_BUILTIN_F (BUILT_IN_ERF)
9366             CASE_BUILTIN_F (BUILT_IN_EXPM1)
9367             CASE_BUILTIN_F (BUILT_IN_FLOOR)
9368             CASE_BUILTIN_F (BUILT_IN_FMOD)
9369             CASE_BUILTIN_F (BUILT_IN_LDEXP)
9370             CASE_BUILTIN_F (BUILT_IN_LLRINT)
9371             CASE_BUILTIN_F (BUILT_IN_LLROUND)
9372             CASE_BUILTIN_F (BUILT_IN_LRINT)
9373             CASE_BUILTIN_F (BUILT_IN_LROUND)
9374             CASE_BUILTIN_F (BUILT_IN_MODF)
9375             CASE_BUILTIN_F (BUILT_IN_NEARBYINT)
9376             CASE_BUILTIN_F (BUILT_IN_POW)
9377             CASE_BUILTIN_F (BUILT_IN_RINT)
9378             CASE_BUILTIN_F (BUILT_IN_ROUND)
9379             CASE_BUILTIN_F (BUILT_IN_SIGNBIT)
9380             CASE_BUILTIN_F (BUILT_IN_SINH)
9381             CASE_BUILTIN_F (BUILT_IN_TANH)
9382             CASE_BUILTIN_F (BUILT_IN_TRUNC)
9383               /* True if the 1st argument is nonnegative.  */
9384               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9385
9386             CASE_BUILTIN_F (BUILT_IN_FMAX)
9387               /* True if the 1st OR 2nd arguments are nonnegative.  */
9388               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9389                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9390
9391             CASE_BUILTIN_F (BUILT_IN_FMIN)
9392               /* True if the 1st AND 2nd arguments are nonnegative.  */
9393               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9394                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9395
9396             CASE_BUILTIN_F (BUILT_IN_COPYSIGN)
9397               /* True if the 2nd argument is nonnegative.  */
9398               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9399
9400             default:
9401               break;
9402 #undef CASE_BUILTIN_F
9403 #undef CASE_BUILTIN_I
9404             }
9405       }
9406
9407       /* ... fall through ...  */
9408
9409     default:
9410       if (truth_value_p (TREE_CODE (t)))
9411         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
9412         return 1;
9413     }
9414
9415   /* We don't know sign of `t', so be conservative and return false.  */
9416   return 0;
9417 }
9418
9419 /* Return true when T is an address and is known to be nonzero.
9420    For floating point we further ensure that T is not denormal.
9421    Similar logic is present in nonzero_address in rtlanal.h  */
9422
9423 static bool
9424 tree_expr_nonzero_p (tree t)
9425 {
9426   tree type = TREE_TYPE (t);
9427
9428   /* Doing something useful for floating point would need more work.  */
9429   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9430     return false;
9431
9432   switch (TREE_CODE (t))
9433     {
9434     case ABS_EXPR:
9435       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9436         return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9437
9438     case INTEGER_CST:
9439       return !integer_zerop (t);
9440
9441     case PLUS_EXPR:
9442       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9443         {
9444           /* With the presence of negative values it is hard
9445              to say something.  */
9446           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9447               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9448             return false;
9449           /* One of operands must be positive and the other non-negative.  */
9450           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9451                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9452         }
9453       break;
9454
9455     case MULT_EXPR:
9456       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9457         {
9458           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9459                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9460         }
9461       break;
9462
9463     case NOP_EXPR:
9464       {
9465         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9466         tree outer_type = TREE_TYPE (t);
9467
9468         return (TYPE_PRECISION (inner_type) >= TYPE_PRECISION (outer_type)
9469                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
9470       }
9471       break;
9472
9473    case ADDR_EXPR:
9474       /* Weak declarations may link to NULL.  */
9475       if (DECL_P (TREE_OPERAND (t, 0)))
9476         return !DECL_WEAK (TREE_OPERAND (t, 0));
9477       /* Constants and all other cases are never weak.  */
9478       return true;
9479
9480     case COND_EXPR:
9481       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9482               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
9483
9484     case MIN_EXPR:
9485       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9486               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9487
9488     case MAX_EXPR:
9489       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
9490         {
9491           /* When both operands are nonzero, then MAX must be too.  */
9492           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
9493             return true;
9494
9495           /* MAX where operand 0 is positive is positive.  */
9496           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9497         }
9498       /* MAX where operand 1 is positive is positive.  */
9499       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9500                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9501         return true;
9502       break;
9503
9504     case COMPOUND_EXPR:
9505     case MODIFY_EXPR:
9506     case BIND_EXPR:
9507       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
9508
9509     case SAVE_EXPR:
9510     case NON_LVALUE_EXPR:
9511       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9512
9513     case BIT_IOR_EXPR:
9514       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9515              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9516
9517     default:
9518       break;
9519     }
9520   return false;
9521 }
9522
9523 /* Return true if `r' is known to be non-negative.
9524    Only handles constants at the moment.  */
9525
9526 int
9527 rtl_expr_nonnegative_p (rtx r)
9528 {
9529   switch (GET_CODE (r))
9530     {
9531     case CONST_INT:
9532       return INTVAL (r) >= 0;
9533
9534     case CONST_DOUBLE:
9535       if (GET_MODE (r) == VOIDmode)
9536         return CONST_DOUBLE_HIGH (r) >= 0;
9537       return 0;
9538
9539     case CONST_VECTOR:
9540       {
9541         int units, i;
9542         rtx elt;
9543
9544         units = CONST_VECTOR_NUNITS (r);
9545
9546         for (i = 0; i < units; ++i)
9547           {
9548             elt = CONST_VECTOR_ELT (r, i);
9549             if (!rtl_expr_nonnegative_p (elt))
9550               return 0;
9551           }
9552
9553         return 1;
9554       }
9555
9556     case SYMBOL_REF:
9557     case LABEL_REF:
9558       /* These are always nonnegative.  */
9559       return 1;
9560
9561     default:
9562       return 0;
9563     }
9564 }
9565
9566
9567 /* See if we are applying CODE, a relational to the highest or lowest
9568    possible integer of TYPE.  If so, then the result is a compile
9569    time constant.  */
9570
9571 static tree
9572 fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
9573                        tree *op1_p)
9574 {
9575   tree op0 = *op0_p;
9576   tree op1 = *op1_p;
9577   enum tree_code code = *code_p;
9578   int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (op1)));
9579
9580   if (TREE_CODE (op1) == INTEGER_CST
9581       && ! TREE_CONSTANT_OVERFLOW (op1)
9582       && width <= HOST_BITS_PER_WIDE_INT
9583       && (INTEGRAL_TYPE_P (TREE_TYPE (op1))
9584           || POINTER_TYPE_P (TREE_TYPE (op1))))
9585     {
9586       unsigned HOST_WIDE_INT signed_max;
9587       unsigned HOST_WIDE_INT max, min;
9588
9589       signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
9590
9591       if (TYPE_UNSIGNED (TREE_TYPE (op1)))
9592         {
9593           max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9594           min = 0;
9595         }
9596       else
9597         {
9598           max = signed_max;
9599           min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9600         }
9601
9602       if (TREE_INT_CST_HIGH (op1) == 0
9603           && TREE_INT_CST_LOW (op1) == max)
9604         switch (code)
9605           {
9606           case GT_EXPR:
9607             return omit_one_operand (type, integer_zero_node, op0);
9608
9609           case GE_EXPR:
9610             *code_p = EQ_EXPR;
9611             break;
9612           case LE_EXPR:
9613             return omit_one_operand (type, integer_one_node, op0);
9614
9615           case LT_EXPR:
9616             *code_p = NE_EXPR;
9617             break;
9618
9619           /* The GE_EXPR and LT_EXPR cases above are not normally
9620              reached because of  previous transformations.  */
9621
9622           default:
9623             break;
9624           }
9625       else if (TREE_INT_CST_HIGH (op1) == 0
9626                && TREE_INT_CST_LOW (op1) == max - 1)
9627         switch (code)
9628           {
9629           case GT_EXPR:
9630             *code_p = EQ_EXPR;
9631             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9632             break;
9633           case LE_EXPR:
9634             *code_p = NE_EXPR;
9635             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9636             break;
9637           default:
9638             break;
9639           }
9640       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9641                && TREE_INT_CST_LOW (op1) == min)
9642        switch (code)
9643           {
9644           case LT_EXPR:
9645             return omit_one_operand (type, integer_zero_node, op0);
9646
9647           case LE_EXPR:
9648             *code_p = EQ_EXPR;
9649             break;
9650
9651           case GE_EXPR:
9652             return omit_one_operand (type, integer_one_node, op0);
9653
9654           case GT_EXPR:
9655             *code_p = NE_EXPR;
9656             break;
9657
9658           default:
9659             break;
9660           }
9661       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9662                && TREE_INT_CST_LOW (op1) == min + 1)
9663         switch (code)
9664           {
9665           case GE_EXPR:
9666             *code_p = NE_EXPR;
9667             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9668             break;
9669           case LT_EXPR:
9670             *code_p = EQ_EXPR;
9671             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9672             break;
9673           default:
9674             break;
9675           }
9676
9677       else if (TREE_INT_CST_HIGH (op1) == 0
9678                && TREE_INT_CST_LOW (op1) == signed_max
9679                && TYPE_UNSIGNED (TREE_TYPE (op1))
9680                /* signed_type does not work on pointer types.  */
9681                && INTEGRAL_TYPE_P (TREE_TYPE (op1)))
9682         {
9683           /* The following case also applies to X < signed_max+1
9684              and X >= signed_max+1 because previous transformations.  */
9685           if (code == LE_EXPR || code == GT_EXPR)
9686             {
9687               tree st0, st1, exp, retval;
9688               st0 = lang_hooks.types.signed_type (TREE_TYPE (op0));
9689               st1 = lang_hooks.types.signed_type (TREE_TYPE (op1));
9690
9691               exp = build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9692                             type,
9693                             fold_convert (st0, op0),
9694                             fold_convert (st1, integer_zero_node));
9695
9696               retval
9697                 = nondestructive_fold_binary_to_constant (TREE_CODE (exp),
9698                                                           TREE_TYPE (exp),
9699                                                           TREE_OPERAND (exp, 0),
9700                                                           TREE_OPERAND (exp, 1));
9701
9702               /* If we are in gimple form, then returning EXP would create
9703                  non-gimple expressions.  Clearing it is safe and insures
9704                  we do not allow a non-gimple expression to escape.  */
9705               if (in_gimple_form)
9706                 exp = NULL;
9707
9708               return (retval ? retval : exp);
9709             }
9710         }
9711     }
9712
9713   return NULL_TREE;
9714 }
9715
9716
9717 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
9718    attempt to fold the expression to a constant without modifying TYPE,
9719    OP0 or OP1.
9720
9721    If the expression could be simplified to a constant, then return
9722    the constant.  If the expression would not be simplified to a
9723    constant, then return NULL_TREE.
9724
9725    Note this is primarily designed to be called after gimplification
9726    of the tree structures and when at least one operand is a constant.
9727    As a result of those simplifying assumptions this routine is far
9728    simpler than the generic fold routine.  */
9729
9730 tree
9731 nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
9732                                         tree op0, tree op1)
9733 {
9734   int wins = 1;
9735   tree subop0;
9736   tree subop1;
9737   tree tem;
9738
9739   /* If this is a commutative operation, and ARG0 is a constant, move it
9740      to ARG1 to reduce the number of tests below.  */
9741   if (commutative_tree_code (code)
9742       && (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST))
9743     {
9744       tem = op0;
9745       op0 = op1;
9746       op1 = tem;
9747     }
9748
9749   /* If either operand is a complex type, extract its real component.  */
9750   if (TREE_CODE (op0) == COMPLEX_CST)
9751     subop0 = TREE_REALPART (op0);
9752   else
9753     subop0 = op0;
9754
9755   if (TREE_CODE (op1) == COMPLEX_CST)
9756     subop1 = TREE_REALPART (op1);
9757   else
9758     subop1 = op1;
9759
9760   /* Note if either argument is not a real or integer constant.
9761      With a few exceptions, simplification is limited to cases
9762      where both arguments are constants.  */
9763   if ((TREE_CODE (subop0) != INTEGER_CST
9764        && TREE_CODE (subop0) != REAL_CST)
9765       || (TREE_CODE (subop1) != INTEGER_CST
9766           && TREE_CODE (subop1) != REAL_CST))
9767     wins = 0;
9768
9769   switch (code)
9770     {
9771     case PLUS_EXPR:
9772       /* (plus (address) (const_int)) is a constant.  */
9773       if (TREE_CODE (op0) == PLUS_EXPR
9774           && TREE_CODE (op1) == INTEGER_CST
9775           && (TREE_CODE (TREE_OPERAND (op0, 0)) == ADDR_EXPR
9776               || (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
9777                   && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (op0, 0), 0))
9778                       == ADDR_EXPR)))
9779           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
9780         {
9781           return build2 (PLUS_EXPR, type, TREE_OPERAND (op0, 0),
9782                          const_binop (PLUS_EXPR, op1,
9783                                       TREE_OPERAND (op0, 1), 0));
9784         }
9785     case BIT_XOR_EXPR:
9786
9787     binary:
9788       if (!wins)
9789         return NULL_TREE;
9790
9791       /* Both arguments are constants.  Simplify.  */
9792       tem = const_binop (code, op0, op1, 0);
9793       if (tem != NULL_TREE)
9794         {
9795           /* The return value should always have the same type as
9796              the original expression.  */
9797           if (TREE_TYPE (tem) != type)
9798             tem = fold_convert (type, tem);
9799
9800           return tem;
9801         }
9802       return NULL_TREE;
9803
9804     case MINUS_EXPR:
9805       /* Fold &x - &x.  This can happen from &x.foo - &x.
9806          This is unsafe for certain floats even in non-IEEE formats.
9807          In IEEE, it is unsafe because it does wrong for NaNs.
9808          Also note that operand_equal_p is always false if an
9809          operand is volatile.  */
9810       if (! FLOAT_TYPE_P (type) && operand_equal_p (op0, op1, 0))
9811         return fold_convert (type, integer_zero_node);
9812
9813       goto binary;
9814
9815     case MULT_EXPR:
9816     case BIT_AND_EXPR:
9817       /* Special case multiplication or bitwise AND where one argument
9818          is zero.  */
9819       if (! FLOAT_TYPE_P (type) && integer_zerop (op1))
9820         return omit_one_operand (type, op1, op0);
9821       else
9822         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (op0)))
9823             && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op0)))
9824             && real_zerop (op1))
9825           return omit_one_operand (type, op1, op0);
9826
9827       goto binary;
9828
9829     case BIT_IOR_EXPR:
9830       /* Special case when we know the result will be all ones.  */
9831       if (integer_all_onesp (op1))
9832         return omit_one_operand (type, op1, op0);
9833
9834       goto binary;
9835
9836     case TRUNC_DIV_EXPR:
9837     case ROUND_DIV_EXPR:
9838     case FLOOR_DIV_EXPR:
9839     case CEIL_DIV_EXPR:
9840     case EXACT_DIV_EXPR:
9841     case TRUNC_MOD_EXPR:
9842     case ROUND_MOD_EXPR:
9843     case FLOOR_MOD_EXPR:
9844     case CEIL_MOD_EXPR:
9845     case RDIV_EXPR:
9846       /* Division by zero is undefined.  */
9847       if (integer_zerop (op1))
9848         return NULL_TREE;
9849
9850       if (TREE_CODE (op1) == REAL_CST
9851           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (op1)))
9852           && real_zerop (op1))
9853         return NULL_TREE;
9854
9855       goto binary;
9856
9857     case MIN_EXPR:
9858       if (INTEGRAL_TYPE_P (type)
9859           && operand_equal_p (op1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
9860         return omit_one_operand (type, op1, op0);
9861
9862       goto binary;
9863
9864     case MAX_EXPR:
9865       if (INTEGRAL_TYPE_P (type)
9866           && TYPE_MAX_VALUE (type)
9867           && operand_equal_p (op1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
9868         return omit_one_operand (type, op1, op0);
9869
9870       goto binary;
9871
9872     case RSHIFT_EXPR:
9873       /* Optimize -1 >> x for arithmetic right shifts.  */
9874       if (integer_all_onesp (op0) && ! TYPE_UNSIGNED (type))
9875         return omit_one_operand (type, op0, op1);
9876       /* ... fall through ...  */
9877
9878     case LSHIFT_EXPR:
9879       if (integer_zerop (op0))
9880         return omit_one_operand (type, op0, op1);
9881
9882       /* Since negative shift count is not well-defined, don't
9883          try to compute it in the compiler.  */
9884       if (TREE_CODE (op1) == INTEGER_CST && tree_int_cst_sgn (op1) < 0)
9885         return NULL_TREE;
9886
9887       goto binary;
9888
9889     case LROTATE_EXPR:
9890     case RROTATE_EXPR:
9891       /* -1 rotated either direction by any amount is still -1.  */
9892       if (integer_all_onesp (op0))
9893         return omit_one_operand (type, op0, op1);
9894
9895       /* 0 rotated either direction by any amount is still zero.  */
9896       if (integer_zerop (op0))
9897         return omit_one_operand (type, op0, op1);
9898
9899       goto binary;
9900
9901     case COMPLEX_EXPR:
9902       if (wins)
9903         return build_complex (type, op0, op1);
9904       return NULL_TREE;
9905
9906     case LT_EXPR:
9907     case LE_EXPR:
9908     case GT_EXPR:
9909     case GE_EXPR:
9910     case EQ_EXPR:
9911     case NE_EXPR:
9912       /* If one arg is a real or integer constant, put it last.  */
9913       if ((TREE_CODE (op0) == INTEGER_CST
9914            && TREE_CODE (op1) != INTEGER_CST)
9915           || (TREE_CODE (op0) == REAL_CST
9916               && TREE_CODE (op0) != REAL_CST))
9917         {
9918           tree temp;
9919
9920           temp = op0;
9921           op0 = op1;
9922           op1 = temp;
9923           code = swap_tree_comparison (code);
9924         }
9925
9926       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
9927          This transformation affects the cases which are handled in later
9928          optimizations involving comparisons with non-negative constants.  */
9929       if (TREE_CODE (op1) == INTEGER_CST
9930           && TREE_CODE (op0) != INTEGER_CST
9931           && tree_int_cst_sgn (op1) > 0)
9932         {
9933           switch (code)
9934             {
9935             case GE_EXPR:
9936               code = GT_EXPR;
9937               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9938               break;
9939
9940             case LT_EXPR:
9941               code = LE_EXPR;
9942               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9943               break;
9944
9945             default:
9946               break;
9947             }
9948         }
9949
9950       tem = fold_relational_hi_lo (&code, type, &op0, &op1);
9951       if (tem)
9952         return tem;
9953
9954       /* Fall through.  */
9955
9956     case ORDERED_EXPR:
9957     case UNORDERED_EXPR:
9958     case UNLT_EXPR:
9959     case UNLE_EXPR:
9960     case UNGT_EXPR:
9961     case UNGE_EXPR:
9962     case UNEQ_EXPR:
9963     case LTGT_EXPR:
9964       if (!wins)
9965         return NULL_TREE;
9966
9967       return fold_relational_const (code, type, op0, op1);
9968
9969     case RANGE_EXPR:
9970       /* This could probably be handled.  */
9971       return NULL_TREE;
9972
9973     case TRUTH_AND_EXPR:
9974       /* If second arg is constant zero, result is zero, but first arg
9975          must be evaluated.  */
9976       if (integer_zerop (op1))
9977         return omit_one_operand (type, op1, op0);
9978       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
9979          case will be handled here.  */
9980       if (integer_zerop (op0))
9981         return omit_one_operand (type, op0, op1);
9982       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
9983         return constant_boolean_node (true, type);
9984       return NULL_TREE;
9985
9986     case TRUTH_OR_EXPR:
9987       /* If second arg is constant true, result is true, but we must
9988          evaluate first arg.  */
9989       if (TREE_CODE (op1) == INTEGER_CST && ! integer_zerop (op1))
9990         return omit_one_operand (type, op1, op0);
9991       /* Likewise for first arg, but note this only occurs here for
9992          TRUTH_OR_EXPR.  */
9993       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
9994         return omit_one_operand (type, op0, op1);
9995       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
9996         return constant_boolean_node (false, type);
9997       return NULL_TREE;
9998
9999     case TRUTH_XOR_EXPR:
10000       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10001         {
10002           int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
10003           return constant_boolean_node (x, type);
10004         }
10005       return NULL_TREE;
10006
10007     default:
10008       return NULL_TREE;
10009     }
10010 }
10011
10012 /* Given the components of a unary expression CODE, TYPE and OP0,
10013    attempt to fold the expression to a constant without modifying
10014    TYPE or OP0.
10015
10016    If the expression could be simplified to a constant, then return
10017    the constant.  If the expression would not be simplified to a
10018    constant, then return NULL_TREE.
10019
10020    Note this is primarily designed to be called after gimplification
10021    of the tree structures and when op0 is a constant.  As a result
10022    of those simplifying assumptions this routine is far simpler than
10023    the generic fold routine.  */
10024
10025 tree
10026 nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
10027                                        tree op0)
10028 {
10029   /* Make sure we have a suitable constant argument.  */
10030   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
10031     {
10032       tree subop;
10033
10034       if (TREE_CODE (op0) == COMPLEX_CST)
10035         subop = TREE_REALPART (op0);
10036       else
10037         subop = op0;
10038
10039       if (TREE_CODE (subop) != INTEGER_CST && TREE_CODE (subop) != REAL_CST)
10040         return NULL_TREE;
10041     }
10042
10043   switch (code)
10044     {
10045     case NOP_EXPR:
10046     case FLOAT_EXPR:
10047     case CONVERT_EXPR:
10048     case FIX_TRUNC_EXPR:
10049     case FIX_FLOOR_EXPR:
10050     case FIX_CEIL_EXPR:
10051       return fold_convert_const (code, type, op0);
10052
10053     case NEGATE_EXPR:
10054       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10055         return fold_negate_const (op0, type);
10056       else
10057         return NULL_TREE;
10058
10059     case ABS_EXPR:
10060       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10061         return fold_abs_const (op0, type);
10062       else
10063         return NULL_TREE;
10064
10065     case BIT_NOT_EXPR:
10066       if (TREE_CODE (op0) == INTEGER_CST)
10067         return fold_not_const (op0, type);
10068       else
10069         return NULL_TREE;
10070
10071     case REALPART_EXPR:
10072       if (TREE_CODE (op0) == COMPLEX_CST)
10073         return TREE_REALPART (op0);
10074       else
10075         return NULL_TREE;
10076
10077     case IMAGPART_EXPR:
10078       if (TREE_CODE (op0) == COMPLEX_CST)
10079         return TREE_IMAGPART (op0);
10080       else
10081         return NULL_TREE;
10082
10083     case CONJ_EXPR:
10084       if (TREE_CODE (op0) == COMPLEX_CST
10085           && TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
10086         return build_complex (type, TREE_REALPART (op0),
10087                               negate_expr (TREE_IMAGPART (op0)));
10088       return NULL_TREE;
10089
10090     default:
10091       return NULL_TREE;
10092     }
10093 }
10094
10095 /* If EXP represents referencing an element in a constant string
10096    (either via pointer arithmetic or array indexing), return the
10097    tree representing the value accessed, otherwise return NULL.  */
10098
10099 tree
10100 fold_read_from_constant_string (tree exp)
10101 {
10102   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
10103     {
10104       tree exp1 = TREE_OPERAND (exp, 0);
10105       tree index;
10106       tree string;
10107
10108       if (TREE_CODE (exp) == INDIRECT_REF)
10109         {
10110           string = string_constant (exp1, &index);
10111         }
10112       else
10113         {
10114           tree domain = TYPE_DOMAIN (TREE_TYPE (exp1));
10115           tree low_bound = domain ? TYPE_MIN_VALUE (domain) : integer_zero_node;
10116           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
10117
10118           /* Optimize the special-case of a zero lower bound.
10119
10120              We convert the low_bound to sizetype to avoid some problems
10121              with constant folding.  (E.g. suppose the lower bound is 1,
10122              and its mode is QI.  Without the conversion,l (ARRAY
10123              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
10124              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
10125           if (! integer_zerop (low_bound))
10126             index = size_diffop (index, fold_convert (sizetype, low_bound));
10127
10128           string = exp1;
10129         }
10130
10131       if (string
10132           && TREE_CODE (string) == STRING_CST
10133           && TREE_CODE (index) == INTEGER_CST
10134           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
10135           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
10136               == MODE_INT)
10137           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
10138         return fold_convert (TREE_TYPE (exp),
10139                              build_int_2 ((TREE_STRING_POINTER (string)
10140                                           [TREE_INT_CST_LOW (index)]), 0));
10141     }
10142   return NULL;
10143 }
10144
10145 /* Return the tree for neg (ARG0) when ARG0 is known to be either
10146    an integer constant or real constant.
10147
10148    TYPE is the type of the result.  */
10149
10150 static tree
10151 fold_negate_const (tree arg0, tree type)
10152 {
10153   tree t = NULL_TREE;
10154
10155   if (TREE_CODE (arg0) == INTEGER_CST)
10156     {
10157       unsigned HOST_WIDE_INT low;
10158       HOST_WIDE_INT high;
10159       int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10160                                  TREE_INT_CST_HIGH (arg0),
10161                                  &low, &high);
10162       t = build_int_2 (low, high);
10163       TREE_TYPE (t) = type;
10164       TREE_OVERFLOW (t)
10165         = (TREE_OVERFLOW (arg0)
10166            | force_fit_type (t, overflow && !TYPE_UNSIGNED (type)));
10167       TREE_CONSTANT_OVERFLOW (t)
10168         = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
10169     }
10170   else if (TREE_CODE (arg0) == REAL_CST)
10171     t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10172 #ifdef ENABLE_CHECKING
10173   else
10174     abort ();
10175 #endif
10176
10177   return t;
10178 }
10179
10180 /* Return the tree for abs (ARG0) when ARG0 is known to be either
10181    an integer constant or real constant.
10182
10183    TYPE is the type of the result.  */
10184
10185 tree
10186 fold_abs_const (tree arg0, tree type)
10187 {
10188   tree t = NULL_TREE;
10189
10190   if (TREE_CODE (arg0) == INTEGER_CST)
10191     {
10192       /* If the value is unsigned, then the absolute value is
10193          the same as the ordinary value.  */
10194       if (TYPE_UNSIGNED (type))
10195         return arg0;
10196       /* Similarly, if the value is non-negative.  */
10197       else if (INT_CST_LT (integer_minus_one_node, arg0))
10198         return arg0;
10199       /* If the value is negative, then the absolute value is
10200          its negation.  */
10201       else
10202         {
10203           unsigned HOST_WIDE_INT low;
10204           HOST_WIDE_INT high;
10205           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10206                                      TREE_INT_CST_HIGH (arg0),
10207                                      &low, &high);
10208           t = build_int_2 (low, high);
10209           TREE_TYPE (t) = type;
10210           TREE_OVERFLOW (t)
10211             = (TREE_OVERFLOW (arg0)
10212                | force_fit_type (t, overflow));
10213           TREE_CONSTANT_OVERFLOW (t)
10214             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
10215           return t;
10216         }
10217     }
10218   else if (TREE_CODE (arg0) == REAL_CST)
10219     {
10220       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
10221         return build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10222       else
10223         return arg0;
10224     }
10225 #ifdef ENABLE_CHECKING
10226   else
10227     abort ();
10228 #endif
10229
10230   return t;
10231 }
10232
10233 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
10234    constant.  TYPE is the type of the result.  */
10235
10236 static tree
10237 fold_not_const (tree arg0, tree type)
10238 {
10239   tree t = NULL_TREE;
10240
10241   if (TREE_CODE (arg0) == INTEGER_CST)
10242     {
10243       t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
10244                        ~ TREE_INT_CST_HIGH (arg0));
10245       TREE_TYPE (t) = type;
10246       force_fit_type (t, 0);
10247       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
10248       TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
10249     }
10250 #ifdef ENABLE_CHECKING
10251   else
10252     abort ();
10253 #endif
10254
10255   return t;
10256 }
10257
10258 /* Given CODE, a relational operator, the target type, TYPE and two
10259    constant operands OP0 and OP1, return the result of the
10260    relational operation.  If the result is not a compile time
10261    constant, then return NULL_TREE.  */
10262
10263 static tree
10264 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
10265 {
10266   int result, invert;
10267
10268   /* From here on, the only cases we handle are when the result is
10269      known to be a constant.  */
10270
10271   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10272     {
10273       /* Handle the cases where either operand is a NaN.  */
10274       if (REAL_VALUE_ISNAN (TREE_REAL_CST (op0))
10275           || REAL_VALUE_ISNAN (TREE_REAL_CST (op1)))
10276         {
10277           switch (code)
10278             {
10279             case EQ_EXPR:
10280             case ORDERED_EXPR:
10281               result = 0;
10282               break;
10283
10284             case NE_EXPR:
10285             case UNORDERED_EXPR:
10286             case UNLT_EXPR:
10287             case UNLE_EXPR:
10288             case UNGT_EXPR:
10289             case UNGE_EXPR:
10290             case UNEQ_EXPR:
10291               result = 1;
10292               break;
10293
10294             case LT_EXPR:
10295             case LE_EXPR:
10296             case GT_EXPR:
10297             case GE_EXPR:
10298             case LTGT_EXPR:
10299               if (flag_trapping_math)
10300                 return NULL_TREE;
10301               result = 0;
10302               break;
10303
10304             default:
10305               abort ();
10306             }
10307
10308           return constant_boolean_node (result, type);
10309         }
10310
10311       /* From here on we're sure there are no NaNs.  */
10312       switch (code)
10313         {
10314         case ORDERED_EXPR:
10315           return constant_boolean_node (true, type);
10316
10317         case UNORDERED_EXPR:
10318           return constant_boolean_node (false, type);
10319
10320         case UNLT_EXPR:
10321           code = LT_EXPR;
10322           break;
10323         case UNLE_EXPR:
10324           code = LE_EXPR;
10325           break;
10326         case UNGT_EXPR:
10327           code = GT_EXPR;
10328           break;
10329         case UNGE_EXPR:
10330           code = GE_EXPR;
10331           break;
10332         case UNEQ_EXPR:
10333           code = EQ_EXPR;
10334           break;
10335         case LTGT_EXPR:
10336           code = NE_EXPR;
10337           break;
10338
10339         default:
10340           break;
10341         }
10342     }
10343
10344   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
10345
10346      To compute GT, swap the arguments and do LT.
10347      To compute GE, do LT and invert the result.
10348      To compute LE, swap the arguments, do LT and invert the result.
10349      To compute NE, do EQ and invert the result.
10350
10351      Therefore, the code below must handle only EQ and LT.  */
10352
10353   if (code == LE_EXPR || code == GT_EXPR)
10354     {
10355       tree tem = op0;
10356       op0 = op1;
10357       op1 = tem;
10358       code = swap_tree_comparison (code);
10359     }
10360
10361   /* Note that it is safe to invert for real values here because we
10362      have already handled the one case that it matters.  */
10363
10364   invert = 0;
10365   if (code == NE_EXPR || code == GE_EXPR)
10366     {
10367       invert = 1;
10368       code = invert_tree_comparison (code, false);
10369     }
10370
10371   /* Compute a result for LT or EQ if args permit;
10372      Otherwise return T.  */
10373   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10374     {
10375       if (code == EQ_EXPR)
10376         result = tree_int_cst_equal (op0, op1);
10377       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
10378         result = INT_CST_LT_UNSIGNED (op0, op1);
10379       else
10380         result = INT_CST_LT (op0, op1);
10381     }
10382
10383   else if (code == EQ_EXPR && !TREE_SIDE_EFFECTS (op0)
10384            && integer_zerop (op1) && tree_expr_nonzero_p (op0))
10385     result = 0;
10386
10387   /* Two real constants can be compared explicitly.  */
10388   else if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10389     {
10390       if (code == EQ_EXPR)
10391         result = REAL_VALUES_EQUAL (TREE_REAL_CST (op0),
10392                                     TREE_REAL_CST (op1));
10393       else
10394         result = REAL_VALUES_LESS (TREE_REAL_CST (op0),
10395                                    TREE_REAL_CST (op1));
10396     }
10397   else
10398     return NULL_TREE;
10399
10400   if (invert)
10401     result ^= 1;
10402   return constant_boolean_node (result, type);
10403 }
10404
10405 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
10406    avoid confusing the gimplify process.  */
10407
10408 tree
10409 build_fold_addr_expr_with_type (tree t, tree ptrtype)
10410 {
10411   if (TREE_CODE (t) == INDIRECT_REF)
10412     {
10413       t = TREE_OPERAND (t, 0);
10414       if (TREE_TYPE (t) != ptrtype)
10415         t = build1 (NOP_EXPR, ptrtype, t);
10416     }
10417   else
10418     {
10419       tree base = t;
10420       while (TREE_CODE (base) == COMPONENT_REF
10421              || TREE_CODE (base) == ARRAY_REF)
10422         base = TREE_OPERAND (base, 0);
10423       if (DECL_P (base))
10424         TREE_ADDRESSABLE (base) = 1;
10425
10426       t = build1 (ADDR_EXPR, ptrtype, t);
10427     }
10428
10429   return t;
10430 }
10431
10432 tree
10433 build_fold_addr_expr (tree t)
10434 {
10435   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
10436 }
10437
10438 /* Builds an expression for an indirection through T, simplifying some
10439    cases.  */
10440
10441 tree
10442 build_fold_indirect_ref (tree t)
10443 {
10444   tree type = TREE_TYPE (TREE_TYPE (t));
10445   tree sub = t;
10446   tree subtype;
10447
10448   STRIP_NOPS (sub);
10449   if (TREE_CODE (sub) == ADDR_EXPR)
10450     {
10451       tree op = TREE_OPERAND (sub, 0);
10452       tree optype = TREE_TYPE (op);
10453       /* *&p => p */
10454       if (lang_hooks.types_compatible_p (type, optype))
10455         return op;
10456       /* *(foo *)&fooarray => fooarray[0] */
10457       else if (TREE_CODE (optype) == ARRAY_TYPE
10458                && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
10459         return build2 (ARRAY_REF, type, op, size_zero_node);
10460     }
10461
10462   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
10463   subtype = TREE_TYPE (sub);
10464   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
10465       && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
10466     {
10467       sub = build_fold_indirect_ref (sub);
10468       return build2 (ARRAY_REF, type, sub, size_zero_node);
10469     }
10470
10471   return build1 (INDIRECT_REF, type, t);
10472 }
10473
10474 #include "gt-fold-const.h"