gcc/fold-const.c

   1 /* Fold a constant sub-tree into a single node for C-compiler
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /*@@ This file should be rewritten to use an arbitrary precision
  23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  25   @@ The routines that translate from the ap rep should
  26   @@ warn if precision et. al. is lost.
  27   @@ This would also make life easier when this technology is used
  28   @@ for cross-compilers.  */
  29
  30 /* The entry points in this file are fold, size_int_wide, size_binop
  31    and force_fit_type.
  32
  33    fold takes a tree as argument and returns a simplified tree.
  34
  35    size_binop takes a tree code for an arithmetic operation
  36    and two operands that are trees, and produces a tree for the
  37    result, assuming the type comes from `sizetype'.
  38
  39    size_int takes an integer value, and creates a tree constant
  40    with type from `sizetype'.
  41
  42    force_fit_type takes a constant and prior overflow indicator, and
  43    forces the value to fit the type.  It returns an overflow indicator.  */
  44
  45 #include "config.h"
  46 #include "system.h"
  47 #include "coretypes.h"
  48 #include "tm.h"
  49 #include "flags.h"
  50 #include "tree.h"
  51 #include "real.h"
  52 #include "rtl.h"
  53 #include "expr.h"
  54 #include "tm_p.h"
  55 #include "toplev.h"
  56 #include "ggc.h"
  57 #include "hashtab.h"
  58 #include "langhooks.h"
  59 #include "md5.h"
  60
  61 /* The following constants represent a bit based encoding of GCC's
  62    comparison operators.  This encoding simplifies transformations
  63    on relational comparison operators, such as AND and OR.  */
  64 enum comparison_code {
  65   COMPCODE_FALSE = 0,
  66   COMPCODE_LT = 1,
  67   COMPCODE_EQ = 2,
  68   COMPCODE_LE = 3,
  69   COMPCODE_GT = 4,
  70   COMPCODE_LTGT = 5,
  71   COMPCODE_GE = 6,
  72   COMPCODE_ORD = 7,
  73   COMPCODE_UNORD = 8,
  74   COMPCODE_UNLT = 9,
  75   COMPCODE_UNEQ = 10,
  76   COMPCODE_UNLE = 11,
  77   COMPCODE_UNGT = 12,
  78   COMPCODE_NE = 13,
  79   COMPCODE_UNGE = 14,
  80   COMPCODE_TRUE = 15
  81 };
  82
  83 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
  84 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
  85 static bool negate_mathfn_p (enum built_in_function);
  86 static bool negate_expr_p (tree);
  87 static tree negate_expr (tree);
  88 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
  89 static tree associate_trees (tree, tree, enum tree_code, tree);
  90 static tree const_binop (enum tree_code, tree, tree, int);
  91 static hashval_t size_htab_hash (const void *);
  92 static int size_htab_eq (const void *, const void *);
  93 static tree fold_convert_const (enum tree_code, tree, tree);
  94 static enum tree_code invert_tree_comparison (enum tree_code, bool);
  95 static enum comparison_code comparison_to_compcode (enum tree_code);
  96 static enum tree_code compcode_to_comparison (enum comparison_code);
  97 static tree combine_comparisons (enum tree_code, enum tree_code,
  98                                  enum tree_code, tree, tree, tree);
  99 static int truth_value_p (enum tree_code);
 100 static int operand_equal_for_comparison_p (tree, tree, tree);
 101 static int twoval_comparison_p (tree, tree *, tree *, int *);
 102 static tree eval_subst (tree, tree, tree, tree, tree);
 103 static tree pedantic_omit_one_operand (tree, tree, tree);
 104 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
 105 static tree make_bit_field_ref (tree, tree, int, int, int);
 106 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
 107 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
 108                                     enum machine_mode *, int *, int *,
 109                                     tree *, tree *);
 110 static int all_ones_mask_p (tree, int);
 111 static tree sign_bit_p (tree, tree);
 112 static int simple_operand_p (tree);
 113 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 114 static tree make_range (tree, int *, tree *, tree *);
 115 static tree build_range_check (tree, tree, int, tree, tree);
 116 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
 117                          tree);
 118 static tree fold_range_test (tree);
 119 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
 120 static tree unextend (tree, int, int, tree);
 121 static tree fold_truthop (enum tree_code, tree, tree, tree);
 122 static tree optimize_minmax_comparison (tree);
 123 static tree extract_muldiv (tree, tree, enum tree_code, tree);
 124 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree);
 125 static int multiple_of_p (tree, tree, tree);
 126 static tree constant_boolean_node (int, tree);
 127 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree, tree,
 128                                                  tree, int);
 129 static bool fold_real_zero_addition_p (tree, tree, int);
 130 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
 131                                  tree, tree, tree);
 132 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
 133 static tree fold_div_compare (enum tree_code, tree, tree, tree);
 134 static bool reorder_operands_p (tree, tree);
 135 static tree fold_negate_const (tree, tree);
 136 static tree fold_not_const (tree, tree);
 137 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 138 static tree fold_relational_hi_lo (enum tree_code *, const tree,
 139                                    tree *, tree *);
 140
 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       || lang_hooks.types_compatible_p (TYPE_MAIN_VARIANT (type),
1912                                         TYPE_MAIN_VARIANT (orig)))
1913     return fold (build1 (NOP_EXPR, type, arg));
1914
1915   if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)
1916       || TREE_CODE (type) == OFFSET_TYPE)
1917     {
1918       if (TREE_CODE (arg) == INTEGER_CST)
1919         {
1920           tem = fold_convert_const (NOP_EXPR, type, arg);
1921           if (tem != NULL_TREE)
1922             return tem;
1923         }
1924       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1925           || TREE_CODE (orig) == OFFSET_TYPE)
1926         return fold (build1 (NOP_EXPR, type, arg));
1927       if (TREE_CODE (orig) == COMPLEX_TYPE)
1928         {
1929           tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1930           return fold_convert (type, tem);
1931         }
1932       if (TREE_CODE (orig) == VECTOR_TYPE
1933           && GET_MODE_SIZE (TYPE_MODE (type))
1934              == GET_MODE_SIZE (TYPE_MODE (orig)))
1935         return fold (build1 (NOP_EXPR, type, arg));
1936     }
1937   else if (TREE_CODE (type) == REAL_TYPE)
1938     {
1939       if (TREE_CODE (arg) == INTEGER_CST)
1940         {
1941           tem = fold_convert_const (FLOAT_EXPR, type, arg);
1942           if (tem != NULL_TREE)
1943             return tem;
1944         }
1945       else if (TREE_CODE (arg) == REAL_CST)
1946         {
1947           tem = fold_convert_const (NOP_EXPR, type, arg);
1948           if (tem != NULL_TREE)
1949             return tem;
1950         }
1951
1952       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
1953         return fold (build1 (FLOAT_EXPR, type, arg));
1954       if (TREE_CODE (orig) == REAL_TYPE)
1955         return fold (build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
1956                              type, arg));
1957       if (TREE_CODE (orig) == COMPLEX_TYPE)
1958         {
1959           tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1960           return fold_convert (type, tem);
1961         }
1962     }
1963   else if (TREE_CODE (type) == COMPLEX_TYPE)
1964     {
1965       if (INTEGRAL_TYPE_P (orig)
1966           || POINTER_TYPE_P (orig)
1967           || TREE_CODE (orig) == REAL_TYPE)
1968         return build2 (COMPLEX_EXPR, type,
1969                        fold_convert (TREE_TYPE (type), arg),
1970                        fold_convert (TREE_TYPE (type), integer_zero_node));
1971       if (TREE_CODE (orig) == COMPLEX_TYPE)
1972         {
1973           tree rpart, ipart;
1974
1975           if (TREE_CODE (arg) == COMPLEX_EXPR)
1976             {
1977               rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
1978               ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
1979               return fold (build2 (COMPLEX_EXPR, type, rpart, ipart));
1980             }
1981
1982           arg = save_expr (arg);
1983           rpart = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1984           ipart = fold (build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg));
1985           rpart = fold_convert (TREE_TYPE (type), rpart);
1986           ipart = fold_convert (TREE_TYPE (type), ipart);
1987           return fold (build2 (COMPLEX_EXPR, type, rpart, ipart));
1988         }
1989     }
1990   else if (TREE_CODE (type) == VECTOR_TYPE)
1991     {
1992       if ((INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig))
1993           && GET_MODE_SIZE (TYPE_MODE (type))
1994              == GET_MODE_SIZE (TYPE_MODE (orig)))
1995         return fold (build1 (NOP_EXPR, type, arg));
1996       if (TREE_CODE (orig) == VECTOR_TYPE
1997           && GET_MODE_SIZE (TYPE_MODE (type))
1998              == GET_MODE_SIZE (TYPE_MODE (orig)))
1999         return fold (build1 (NOP_EXPR, type, arg));
2000     }
2001   else if (VOID_TYPE_P (type))
2002     return fold (build1 (CONVERT_EXPR, type, arg));
2003   abort ();
2004 }
2005 \f
2006 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2007
2008 tree
2009 non_lvalue (tree x)
2010 {
2011   /* We only need to wrap lvalue tree codes.  */
2012   switch (TREE_CODE (x))
2013   {
2014   case VAR_DECL:
2015   case PARM_DECL:
2016   case RESULT_DECL:
2017   case LABEL_DECL:
2018   case FUNCTION_DECL:
2019   case SSA_NAME:
2020
2021   case COMPONENT_REF:
2022   case INDIRECT_REF:
2023   case ARRAY_REF:
2024   case ARRAY_RANGE_REF:
2025   case BIT_FIELD_REF:
2026   case BUFFER_REF:
2027   case OBJ_TYPE_REF:
2028
2029   case REALPART_EXPR:
2030   case IMAGPART_EXPR:
2031   case PREINCREMENT_EXPR:
2032   case PREDECREMENT_EXPR:
2033   case SAVE_EXPR:
2034   case UNSAVE_EXPR:
2035   case TRY_CATCH_EXPR:
2036   case WITH_CLEANUP_EXPR:
2037   case COMPOUND_EXPR:
2038   case MODIFY_EXPR:
2039   case TARGET_EXPR:
2040   case COND_EXPR:
2041   case BIND_EXPR:
2042   case MIN_EXPR:
2043   case MAX_EXPR:
2044     break;
2045
2046   default:
2047     /* Assume the worst for front-end tree codes.  */
2048     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2049       break;
2050     return x;
2051   }
2052   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2053 }
2054
2055 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2056    Zero means allow extended lvalues.  */
2057
2058 int pedantic_lvalues;
2059
2060 /* When pedantic, return an expr equal to X but certainly not valid as a
2061    pedantic lvalue.  Otherwise, return X.  */
2062
2063 tree
2064 pedantic_non_lvalue (tree x)
2065 {
2066   if (pedantic_lvalues)
2067     return non_lvalue (x);
2068   else
2069     return x;
2070 }
2071 \f
2072 /* Given a tree comparison code, return the code that is the logical inverse
2073    of the given code.  It is not safe to do this for floating-point
2074    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2075    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2076
2077 static enum tree_code
2078 invert_tree_comparison (enum tree_code code, bool honor_nans)
2079 {
2080   if (honor_nans && flag_trapping_math)
2081     return ERROR_MARK;
2082
2083   switch (code)
2084     {
2085     case EQ_EXPR:
2086       return NE_EXPR;
2087     case NE_EXPR:
2088       return EQ_EXPR;
2089     case GT_EXPR:
2090       return honor_nans ? UNLE_EXPR : LE_EXPR;
2091     case GE_EXPR:
2092       return honor_nans ? UNLT_EXPR : LT_EXPR;
2093     case LT_EXPR:
2094       return honor_nans ? UNGE_EXPR : GE_EXPR;
2095     case LE_EXPR:
2096       return honor_nans ? UNGT_EXPR : GT_EXPR;
2097     case LTGT_EXPR:
2098       return UNEQ_EXPR;
2099     case UNEQ_EXPR:
2100       return LTGT_EXPR;
2101     case UNGT_EXPR:
2102       return LE_EXPR;
2103     case UNGE_EXPR:
2104       return LT_EXPR;
2105     case UNLT_EXPR:
2106       return GE_EXPR;
2107     case UNLE_EXPR:
2108       return GT_EXPR;
2109     case ORDERED_EXPR:
2110       return UNORDERED_EXPR;
2111     case UNORDERED_EXPR:
2112       return ORDERED_EXPR;
2113     default:
2114       abort ();
2115     }
2116 }
2117
2118 /* Similar, but return the comparison that results if the operands are
2119    swapped.  This is safe for floating-point.  */
2120
2121 enum tree_code
2122 swap_tree_comparison (enum tree_code code)
2123 {
2124   switch (code)
2125     {
2126     case EQ_EXPR:
2127     case NE_EXPR:
2128       return code;
2129     case GT_EXPR:
2130       return LT_EXPR;
2131     case GE_EXPR:
2132       return LE_EXPR;
2133     case LT_EXPR:
2134       return GT_EXPR;
2135     case LE_EXPR:
2136       return GE_EXPR;
2137     default:
2138       abort ();
2139     }
2140 }
2141
2142
2143 /* Convert a comparison tree code from an enum tree_code representation
2144    into a compcode bit-based encoding.  This function is the inverse of
2145    compcode_to_comparison.  */
2146
2147 static enum comparison_code
2148 comparison_to_compcode (enum tree_code code)
2149 {
2150   switch (code)
2151     {
2152     case LT_EXPR:
2153       return COMPCODE_LT;
2154     case EQ_EXPR:
2155       return COMPCODE_EQ;
2156     case LE_EXPR:
2157       return COMPCODE_LE;
2158     case GT_EXPR:
2159       return COMPCODE_GT;
2160     case NE_EXPR:
2161       return COMPCODE_NE;
2162     case GE_EXPR:
2163       return COMPCODE_GE;
2164     case ORDERED_EXPR:
2165       return COMPCODE_ORD;
2166     case UNORDERED_EXPR:
2167       return COMPCODE_UNORD;
2168     case UNLT_EXPR:
2169       return COMPCODE_UNLT;
2170     case UNEQ_EXPR:
2171       return COMPCODE_UNEQ;
2172     case UNLE_EXPR:
2173       return COMPCODE_UNLE;
2174     case UNGT_EXPR:
2175       return COMPCODE_UNGT;
2176     case LTGT_EXPR:
2177       return COMPCODE_LTGT;
2178     case UNGE_EXPR:
2179       return COMPCODE_UNGE;
2180     default:
2181       abort ();
2182     }
2183 }
2184
2185 /* Convert a compcode bit-based encoding of a comparison operator back
2186    to GCC's enum tree_code representation.  This function is the
2187    inverse of comparison_to_compcode.  */
2188
2189 static enum tree_code
2190 compcode_to_comparison (enum comparison_code code)
2191 {
2192   switch (code)
2193     {
2194     case COMPCODE_LT:
2195       return LT_EXPR;
2196     case COMPCODE_EQ:
2197       return EQ_EXPR;
2198     case COMPCODE_LE:
2199       return LE_EXPR;
2200     case COMPCODE_GT:
2201       return GT_EXPR;
2202     case COMPCODE_NE:
2203       return NE_EXPR;
2204     case COMPCODE_GE:
2205       return GE_EXPR;
2206     case COMPCODE_ORD:
2207       return ORDERED_EXPR;
2208     case COMPCODE_UNORD:
2209       return UNORDERED_EXPR;
2210     case COMPCODE_UNLT:
2211       return UNLT_EXPR;
2212     case COMPCODE_UNEQ:
2213       return UNEQ_EXPR;
2214     case COMPCODE_UNLE:
2215       return UNLE_EXPR;
2216     case COMPCODE_UNGT:
2217       return UNGT_EXPR;
2218     case COMPCODE_LTGT:
2219       return LTGT_EXPR;
2220     case COMPCODE_UNGE:
2221       return UNGE_EXPR;
2222     default:
2223       abort ();
2224     }
2225 }
2226
2227 /* Return a tree for the comparison which is the combination of
2228    doing the AND or OR (depending on CODE) of the two operations LCODE
2229    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2230    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2231    if this makes the transformation invalid.  */
2232
2233 tree
2234 combine_comparisons (enum tree_code code, enum tree_code lcode,
2235                      enum tree_code rcode, tree truth_type,
2236                      tree ll_arg, tree lr_arg)
2237 {
2238   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2239   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2240   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2241   enum comparison_code compcode;
2242
2243   switch (code)
2244     {
2245     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2246       compcode = lcompcode & rcompcode;
2247       break;
2248
2249     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2250       compcode = lcompcode | rcompcode;
2251       break;
2252
2253     default:
2254       return NULL_TREE;
2255     }
2256
2257   if (!honor_nans)
2258     {
2259       /* Eliminate unordered comparisons, as well as LTGT and ORD
2260          which are not used unless the mode has NaNs.  */
2261       compcode &= ~COMPCODE_UNORD;
2262       if (compcode == COMPCODE_LTGT)
2263         compcode = COMPCODE_NE;
2264       else if (compcode == COMPCODE_ORD)
2265         compcode = COMPCODE_TRUE;
2266     }
2267    else if (flag_trapping_math)
2268      {
2269         /* Check that the original operation and the optimized ones will trap
2270            under the same condition.  */
2271         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2272                      && (lcompcode != COMPCODE_EQ)
2273                      && (lcompcode != COMPCODE_ORD);
2274         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2275                      && (rcompcode != COMPCODE_EQ)
2276                      && (rcompcode != COMPCODE_ORD);
2277         bool trap = (compcode & COMPCODE_UNORD) == 0
2278                     && (compcode != COMPCODE_EQ)
2279                     && (compcode != COMPCODE_ORD);
2280
2281         /* In a short-circuited boolean expression the LHS might be
2282            such that the RHS, if evaluated, will never trap.  For
2283            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2284            if neither x nor y is NaN.  (This is a mixed blessing: for
2285            example, the expression above will never trap, hence
2286            optimizing it to x < y would be invalid).  */
2287         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2288             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2289           rtrap = false;
2290
2291         /* If the comparison was short-circuited, and only the RHS
2292            trapped, we may now generate a spurious trap.  */
2293         if (rtrap && !ltrap
2294             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2295           return NULL_TREE;
2296
2297         /* If we changed the conditions that cause a trap, we lose.  */
2298         if ((ltrap || rtrap) != trap)
2299           return NULL_TREE;
2300       }
2301
2302   if (compcode == COMPCODE_TRUE)
2303     return constant_boolean_node (true, truth_type);
2304   else if (compcode == COMPCODE_FALSE)
2305     return constant_boolean_node (false, truth_type);
2306   else
2307     return fold (build2 (compcode_to_comparison (compcode),
2308                          truth_type, ll_arg, lr_arg));
2309 }
2310
2311 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2312
2313 static int
2314 truth_value_p (enum tree_code code)
2315 {
2316   return (TREE_CODE_CLASS (code) == '<'
2317           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2318           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2319           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2320 }
2321 \f
2322 /* Return nonzero if two operands (typically of the same tree node)
2323    are necessarily equal.  If either argument has side-effects this
2324    function returns zero.  FLAGS modifies behavior as follows:
2325
2326    If OEP_ONLY_CONST is set, only return nonzero for constants.
2327    This function tests whether the operands are indistinguishable;
2328    it does not test whether they are equal using C's == operation.
2329    The distinction is important for IEEE floating point, because
2330    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2331    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2332
2333    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2334    even though it may hold multiple values during a function.
2335    This is because a GCC tree node guarantees that nothing else is
2336    executed between the evaluation of its "operands" (which may often
2337    be evaluated in arbitrary order).  Hence if the operands themselves
2338    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2339    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2340    unset means assuming isochronic (or instantaneous) tree equivalence.
2341    Unless comparing arbitrary expression trees, such as from different
2342    statements, this flag can usually be left unset.
2343
2344    If OEP_PURE_SAME is set, then pure functions with identical arguments
2345    are considered the same.  It is used when the caller has other ways
2346    to ensure that global memory is unchanged in between.  */
2347
2348 int
2349 operand_equal_p (tree arg0, tree arg1, unsigned int flags)
2350 {
2351   /* If either is ERROR_MARK, they aren't equal.  */
2352   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
2353     return 0;
2354
2355   /* If both types don't have the same signedness, then we can't consider
2356      them equal.  We must check this before the STRIP_NOPS calls
2357      because they may change the signedness of the arguments.  */
2358   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2359     return 0;
2360
2361   STRIP_NOPS (arg0);
2362   STRIP_NOPS (arg1);
2363
2364   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2365       /* This is needed for conversions and for COMPONENT_REF.
2366          Might as well play it safe and always test this.  */
2367       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2368       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2369       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2370     return 0;
2371
2372   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2373      We don't care about side effects in that case because the SAVE_EXPR
2374      takes care of that for us. In all other cases, two expressions are
2375      equal if they have no side effects.  If we have two identical
2376      expressions with side effects that should be treated the same due
2377      to the only side effects being identical SAVE_EXPR's, that will
2378      be detected in the recursive calls below.  */
2379   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2380       && (TREE_CODE (arg0) == SAVE_EXPR
2381           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2382     return 1;
2383
2384   /* Next handle constant cases, those for which we can return 1 even
2385      if ONLY_CONST is set.  */
2386   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2387     switch (TREE_CODE (arg0))
2388       {
2389       case INTEGER_CST:
2390         return (! TREE_CONSTANT_OVERFLOW (arg0)
2391                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2392                 && tree_int_cst_equal (arg0, arg1));
2393
2394       case REAL_CST:
2395         return (! TREE_CONSTANT_OVERFLOW (arg0)
2396                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2397                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2398                                           TREE_REAL_CST (arg1)));
2399
2400       case VECTOR_CST:
2401         {
2402           tree v1, v2;
2403
2404           if (TREE_CONSTANT_OVERFLOW (arg0)
2405               || TREE_CONSTANT_OVERFLOW (arg1))
2406             return 0;
2407
2408           v1 = TREE_VECTOR_CST_ELTS (arg0);
2409           v2 = TREE_VECTOR_CST_ELTS (arg1);
2410           while (v1 && v2)
2411             {
2412               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2413                                     flags))
2414                 return 0;
2415               v1 = TREE_CHAIN (v1);
2416               v2 = TREE_CHAIN (v2);
2417             }
2418
2419           return 1;
2420         }
2421
2422       case COMPLEX_CST:
2423         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2424                                  flags)
2425                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2426                                     flags));
2427
2428       case STRING_CST:
2429         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2430                 && ! memcmp (TREE_STRING_POINTER (arg0),
2431                               TREE_STRING_POINTER (arg1),
2432                               TREE_STRING_LENGTH (arg0)));
2433
2434       case ADDR_EXPR:
2435         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2436                                 0);
2437       default:
2438         break;
2439       }
2440
2441   if (flags & OEP_ONLY_CONST)
2442     return 0;
2443
2444   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2445     {
2446     case '1':
2447       /* Two conversions are equal only if signedness and modes match.  */
2448       if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
2449           && (TYPE_UNSIGNED (TREE_TYPE (arg0))
2450               != TYPE_UNSIGNED (TREE_TYPE (arg1))))
2451         return 0;
2452
2453       return operand_equal_p (TREE_OPERAND (arg0, 0),
2454                               TREE_OPERAND (arg1, 0), flags);
2455
2456     case '<':
2457     case '2':
2458       if (operand_equal_p (TREE_OPERAND (arg0, 0),
2459                            TREE_OPERAND (arg1, 0), flags)
2460           && operand_equal_p (TREE_OPERAND (arg0, 1),
2461                               TREE_OPERAND (arg1, 1), flags))
2462         return 1;
2463
2464       /* For commutative ops, allow the other order.  */
2465       return (commutative_tree_code (TREE_CODE (arg0))
2466               && operand_equal_p (TREE_OPERAND (arg0, 0),
2467                                   TREE_OPERAND (arg1, 1), flags)
2468               && operand_equal_p (TREE_OPERAND (arg0, 1),
2469                                   TREE_OPERAND (arg1, 0), flags));
2470
2471     case 'r':
2472       /* If either of the pointer (or reference) expressions we are
2473          dereferencing contain a side effect, these cannot be equal.  */
2474       if (TREE_SIDE_EFFECTS (arg0)
2475           || TREE_SIDE_EFFECTS (arg1))
2476         return 0;
2477
2478       switch (TREE_CODE (arg0))
2479         {
2480         case INDIRECT_REF:
2481         case REALPART_EXPR:
2482         case IMAGPART_EXPR:
2483           return operand_equal_p (TREE_OPERAND (arg0, 0),
2484                                   TREE_OPERAND (arg1, 0), flags);
2485
2486         case COMPONENT_REF:
2487         case ARRAY_REF:
2488         case ARRAY_RANGE_REF:
2489           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2490                                    TREE_OPERAND (arg1, 0), flags)
2491                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2492                                       TREE_OPERAND (arg1, 1), flags));
2493
2494         case BIT_FIELD_REF:
2495           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2496                                    TREE_OPERAND (arg1, 0), flags)
2497                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2498                                       TREE_OPERAND (arg1, 1), flags)
2499                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2500                                       TREE_OPERAND (arg1, 2), flags));
2501         default:
2502           return 0;
2503         }
2504
2505     case 'e':
2506       switch (TREE_CODE (arg0))
2507         {
2508         case ADDR_EXPR:
2509         case TRUTH_NOT_EXPR:
2510           return operand_equal_p (TREE_OPERAND (arg0, 0),
2511                                   TREE_OPERAND (arg1, 0), flags);
2512
2513         case TRUTH_ANDIF_EXPR:
2514         case TRUTH_ORIF_EXPR:
2515           return operand_equal_p (TREE_OPERAND (arg0, 0),
2516                                   TREE_OPERAND (arg1, 0), flags)
2517                  && operand_equal_p (TREE_OPERAND (arg0, 1),
2518                                      TREE_OPERAND (arg1, 1), flags);
2519
2520         case TRUTH_AND_EXPR:
2521         case TRUTH_OR_EXPR:
2522         case TRUTH_XOR_EXPR:
2523           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2524                                    TREE_OPERAND (arg1, 0), flags)
2525                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2526                                       TREE_OPERAND (arg1, 1), flags))
2527                  || (operand_equal_p (TREE_OPERAND (arg0, 0),
2528                                       TREE_OPERAND (arg1, 1), flags)
2529                      && operand_equal_p (TREE_OPERAND (arg0, 1),
2530                                          TREE_OPERAND (arg1, 0), flags));
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
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;
3536   tree exp_type = NULL_TREE, arg0_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       exp_type = TREE_TYPE (exp);
3553
3554       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3555         {
3556           if (first_rtl_op (code) > 0)
3557             arg0 = TREE_OPERAND (exp, 0);
3558           if (TREE_CODE_CLASS (code) == '<'
3559               || TREE_CODE_CLASS (code) == '1'
3560               || TREE_CODE_CLASS (code) == '2')
3561             arg0_type = TREE_TYPE (arg0);
3562           if (TREE_CODE_CLASS (code) == '2'
3563               || TREE_CODE_CLASS (code) == '<'
3564               || (TREE_CODE_CLASS (code) == 'e'
3565                   && TREE_CODE_LENGTH (code) > 1))
3566             arg1 = TREE_OPERAND (exp, 1);
3567         }
3568
3569       switch (code)
3570         {
3571         case TRUTH_NOT_EXPR:
3572           in_p = ! in_p, exp = arg0;
3573           continue;
3574
3575         case EQ_EXPR: case NE_EXPR:
3576         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3577           /* We can only do something if the range is testing for zero
3578              and if the second operand is an integer constant.  Note that
3579              saying something is "in" the range we make is done by
3580              complementing IN_P since it will set in the initial case of
3581              being not equal to zero; "out" is leaving it alone.  */
3582           if (low == 0 || high == 0
3583               || ! integer_zerop (low) || ! integer_zerop (high)
3584               || TREE_CODE (arg1) != INTEGER_CST)
3585             break;
3586
3587           switch (code)
3588             {
3589             case NE_EXPR:  /* - [c, c]  */
3590               low = high = arg1;
3591               break;
3592             case EQ_EXPR:  /* + [c, c]  */
3593               in_p = ! in_p, low = high = arg1;
3594               break;
3595             case GT_EXPR:  /* - [-, c] */
3596               low = 0, high = arg1;
3597               break;
3598             case GE_EXPR:  /* + [c, -] */
3599               in_p = ! in_p, low = arg1, high = 0;
3600               break;
3601             case LT_EXPR:  /* - [c, -] */
3602               low = arg1, high = 0;
3603               break;
3604             case LE_EXPR:  /* + [-, c] */
3605               in_p = ! in_p, low = 0, high = arg1;
3606               break;
3607             default:
3608               abort ();
3609             }
3610
3611           /* If this is an unsigned comparison, we also know that EXP is
3612              greater than or equal to zero.  We base the range tests we make
3613              on that fact, so we record it here so we can parse existing
3614              range tests.  We test arg0_type since often the return type
3615              of, e.g. EQ_EXPR, is boolean.  */
3616           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3617             {
3618               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3619                                   1, fold_convert (arg0_type, integer_zero_node),
3620                                   NULL_TREE))
3621                 break;
3622
3623               in_p = n_in_p, low = n_low, high = n_high;
3624
3625               /* If the high bound is missing, but we have a nonzero low
3626                  bound, reverse the range so it goes from zero to the low bound
3627                  minus 1.  */
3628               if (high == 0 && low && ! integer_zerop (low))
3629                 {
3630                   in_p = ! in_p;
3631                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3632                                       integer_one_node, 0);
3633                   low = fold_convert (arg0_type, integer_zero_node);
3634                 }
3635             }
3636
3637           exp = arg0;
3638           continue;
3639
3640         case NEGATE_EXPR:
3641           /* (-x) IN [a,b] -> x in [-b, -a]  */
3642           n_low = range_binop (MINUS_EXPR, exp_type,
3643                                fold_convert (exp_type, integer_zero_node),
3644                                0, high, 1);
3645           n_high = range_binop (MINUS_EXPR, exp_type,
3646                                 fold_convert (exp_type, integer_zero_node),
3647                                 0, low, 0);
3648           low = n_low, high = n_high;
3649           exp = arg0;
3650           continue;
3651
3652         case BIT_NOT_EXPR:
3653           /* ~ X -> -X - 1  */
3654           exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
3655                         fold_convert (exp_type, integer_one_node));
3656           continue;
3657
3658         case PLUS_EXPR:  case MINUS_EXPR:
3659           if (TREE_CODE (arg1) != INTEGER_CST)
3660             break;
3661
3662           /* If EXP is signed, any overflow in the computation is undefined,
3663              so we don't worry about it so long as our computations on
3664              the bounds don't overflow.  For unsigned, overflow is defined
3665              and this is exactly the right thing.  */
3666           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3667                                arg0_type, low, 0, arg1, 0);
3668           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3669                                 arg0_type, high, 1, arg1, 0);
3670           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3671               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3672             break;
3673
3674           /* Check for an unsigned range which has wrapped around the maximum
3675              value thus making n_high < n_low, and normalize it.  */
3676           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3677             {
3678               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
3679                                  integer_one_node, 0);
3680               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
3681                                   integer_one_node, 0);
3682
3683               /* If the range is of the form +/- [ x+1, x ], we won't
3684                  be able to normalize it.  But then, it represents the
3685                  whole range or the empty set, so make it
3686                  +/- [ -, - ].  */
3687               if (tree_int_cst_equal (n_low, low)
3688                   && tree_int_cst_equal (n_high, high))
3689                 low = high = 0;
3690               else
3691                 in_p = ! in_p;
3692             }
3693           else
3694             low = n_low, high = n_high;
3695
3696           exp = arg0;
3697           continue;
3698
3699         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3700           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
3701             break;
3702
3703           if (! INTEGRAL_TYPE_P (arg0_type)
3704               || (low != 0 && ! int_fits_type_p (low, arg0_type))
3705               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
3706             break;
3707
3708           n_low = low, n_high = high;
3709
3710           if (n_low != 0)
3711             n_low = fold_convert (arg0_type, n_low);
3712
3713           if (n_high != 0)
3714             n_high = fold_convert (arg0_type, n_high);
3715
3716
3717           /* If we're converting arg0 from an unsigned type, to exp,
3718              a signed type,  we will be doing the comparison as unsigned.
3719              The tests above have already verified that LOW and HIGH
3720              are both positive.
3721
3722              So we have to ensure that we will handle large unsigned
3723              values the same way that the current signed bounds treat
3724              negative values.  */
3725
3726           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
3727             {
3728               tree high_positive;
3729               tree equiv_type = lang_hooks.types.type_for_mode
3730                 (TYPE_MODE (arg0_type), 1);
3731
3732               /* A range without an upper bound is, naturally, unbounded.
3733                  Since convert would have cropped a very large value, use
3734                  the max value for the destination type.  */
3735               high_positive
3736                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3737                 : TYPE_MAX_VALUE (arg0_type);
3738
3739               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
3740                 high_positive = fold (build2 (RSHIFT_EXPR, arg0_type,
3741                                               fold_convert (arg0_type,
3742                                                             high_positive),
3743                                               fold_convert (arg0_type,
3744                                                             integer_one_node)));
3745
3746               /* If the low bound is specified, "and" the range with the
3747                  range for which the original unsigned value will be
3748                  positive.  */
3749               if (low != 0)
3750                 {
3751                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3752                                       1, n_low, n_high, 1,
3753                                       fold_convert (arg0_type, integer_zero_node),
3754                                       high_positive))
3755                     break;
3756
3757                   in_p = (n_in_p == in_p);
3758                 }
3759               else
3760                 {
3761                   /* Otherwise, "or" the range with the range of the input
3762                      that will be interpreted as negative.  */
3763                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3764                                       0, n_low, n_high, 1,
3765                                       fold_convert (arg0_type, integer_zero_node),
3766                                       high_positive))
3767                     break;
3768
3769                   in_p = (in_p != n_in_p);
3770                 }
3771             }
3772
3773           exp = arg0;
3774           low = n_low, high = n_high;
3775           continue;
3776
3777         default:
3778           break;
3779         }
3780
3781       break;
3782     }
3783
3784   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3785   if (TREE_CODE (exp) == INTEGER_CST)
3786     {
3787       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3788                                                  exp, 0, low, 0))
3789                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3790                                                     exp, 1, high, 1)));
3791       low = high = 0;
3792       exp = 0;
3793     }
3794
3795   *pin_p = in_p, *plow = low, *phigh = high;
3796   return exp;
3797 }
3798 \f
3799 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3800    type, TYPE, return an expression to test if EXP is in (or out of, depending
3801    on IN_P) the range.  Return 0 if the test couldn't be created.  */
3802
3803 static tree
3804 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
3805 {
3806   tree etype = TREE_TYPE (exp);
3807   tree value;
3808
3809   if (! in_p)
3810     {
3811       value = build_range_check (type, exp, 1, low, high);
3812       if (value != 0)
3813         return invert_truthvalue (value);
3814
3815       return 0;
3816     }
3817
3818   if (low == 0 && high == 0)
3819     return fold_convert (type, integer_one_node);
3820
3821   if (low == 0)
3822     return fold (build2 (LE_EXPR, type, exp, high));
3823
3824   if (high == 0)
3825     return fold (build2 (GE_EXPR, type, exp, low));
3826
3827   if (operand_equal_p (low, high, 0))
3828     return fold (build2 (EQ_EXPR, type, exp, low));
3829
3830   if (integer_zerop (low))
3831     {
3832       if (! TYPE_UNSIGNED (etype))
3833         {
3834           etype = lang_hooks.types.unsigned_type (etype);
3835           high = fold_convert (etype, high);
3836           exp = fold_convert (etype, exp);
3837         }
3838       return build_range_check (type, exp, 1, 0, high);
3839     }
3840
3841   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
3842   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
3843     {
3844       unsigned HOST_WIDE_INT lo;
3845       HOST_WIDE_INT hi;
3846       int prec;
3847
3848       prec = TYPE_PRECISION (etype);
3849       if (prec <= HOST_BITS_PER_WIDE_INT)
3850         {
3851           hi = 0;
3852           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
3853         }
3854       else
3855         {
3856           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
3857           lo = (unsigned HOST_WIDE_INT) -1;
3858         }
3859
3860       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
3861         {
3862           if (TYPE_UNSIGNED (etype))
3863             {
3864               etype = lang_hooks.types.signed_type (etype);
3865               exp = fold_convert (etype, exp);
3866             }
3867           return fold (build2 (GT_EXPR, type, exp,
3868                                fold_convert (etype, integer_zero_node)));
3869         }
3870     }
3871
3872   value = const_binop (MINUS_EXPR, high, low, 0);
3873   if (value != 0 && TREE_OVERFLOW (value) && ! TYPE_UNSIGNED (etype))
3874     {
3875       tree utype, minv, maxv;
3876
3877       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
3878          for the type in question, as we rely on this here.  */
3879       switch (TREE_CODE (etype))
3880         {
3881         case INTEGER_TYPE:
3882         case ENUMERAL_TYPE:
3883         case CHAR_TYPE:
3884           utype = lang_hooks.types.unsigned_type (etype);
3885           maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
3886           maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
3887                               integer_one_node, 1);
3888           minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
3889           if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
3890                                           minv, 1, maxv, 1)))
3891             {
3892               etype = utype;
3893               high = fold_convert (etype, high);
3894               low = fold_convert (etype, low);
3895               exp = fold_convert (etype, exp);
3896               value = const_binop (MINUS_EXPR, high, low, 0);
3897             }
3898           break;
3899         default:
3900           break;
3901         }
3902     }
3903
3904   if (value != 0 && ! TREE_OVERFLOW (value))
3905     return build_range_check (type,
3906                               fold (build2 (MINUS_EXPR, etype, exp, low)),
3907                               1, fold_convert (etype, integer_zero_node),
3908                               value);
3909
3910   return 0;
3911 }
3912 \f
3913 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3914    can, 0 if we can't.  Set the output range into the specified parameters.  */
3915
3916 static int
3917 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
3918               tree high0, int in1_p, tree low1, tree high1)
3919 {
3920   int no_overlap;
3921   int subset;
3922   int temp;
3923   tree tem;
3924   int in_p;
3925   tree low, high;
3926   int lowequal = ((low0 == 0 && low1 == 0)
3927                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3928                                                 low0, 0, low1, 0)));
3929   int highequal = ((high0 == 0 && high1 == 0)
3930                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3931                                                  high0, 1, high1, 1)));
3932
3933   /* Make range 0 be the range that starts first, or ends last if they
3934      start at the same value.  Swap them if it isn't.  */
3935   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3936                                  low0, 0, low1, 0))
3937       || (lowequal
3938           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3939                                         high1, 1, high0, 1))))
3940     {
3941       temp = in0_p, in0_p = in1_p, in1_p = temp;
3942       tem = low0, low0 = low1, low1 = tem;
3943       tem = high0, high0 = high1, high1 = tem;
3944     }
3945
3946   /* Now flag two cases, whether the ranges are disjoint or whether the
3947      second range is totally subsumed in the first.  Note that the tests
3948      below are simplified by the ones above.  */
3949   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3950                                           high0, 1, low1, 0));
3951   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3952                                       high1, 1, high0, 1));
3953
3954   /* We now have four cases, depending on whether we are including or
3955      excluding the two ranges.  */
3956   if (in0_p && in1_p)
3957     {
3958       /* If they don't overlap, the result is false.  If the second range
3959          is a subset it is the result.  Otherwise, the range is from the start
3960          of the second to the end of the first.  */
3961       if (no_overlap)
3962         in_p = 0, low = high = 0;
3963       else if (subset)
3964         in_p = 1, low = low1, high = high1;
3965       else
3966         in_p = 1, low = low1, high = high0;
3967     }
3968
3969   else if (in0_p && ! in1_p)
3970     {
3971       /* If they don't overlap, the result is the first range.  If they are
3972          equal, the result is false.  If the second range is a subset of the
3973          first, and the ranges begin at the same place, we go from just after
3974          the end of the first range to the end of the second.  If the second
3975          range is not a subset of the first, or if it is a subset and both
3976          ranges end at the same place, the range starts at the start of the
3977          first range and ends just before the second range.
3978          Otherwise, we can't describe this as a single range.  */
3979       if (no_overlap)
3980         in_p = 1, low = low0, high = high0;
3981       else if (lowequal && highequal)
3982         in_p = 0, low = high = 0;
3983       else if (subset && lowequal)
3984         {
3985           in_p = 1, high = high0;
3986           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3987                              integer_one_node, 0);
3988         }
3989       else if (! subset || highequal)
3990         {
3991           in_p = 1, low = low0;
3992           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3993                               integer_one_node, 0);
3994         }
3995       else
3996         return 0;
3997     }
3998
3999   else if (! in0_p && in1_p)
4000     {
4001       /* If they don't overlap, the result is the second range.  If the second
4002          is a subset of the first, the result is false.  Otherwise,
4003          the range starts just after the first range and ends at the
4004          end of the second.  */
4005       if (no_overlap)
4006         in_p = 1, low = low1, high = high1;
4007       else if (subset || highequal)
4008         in_p = 0, low = high = 0;
4009       else
4010         {
4011           in_p = 1, high = high1;
4012           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4013                              integer_one_node, 0);
4014         }
4015     }
4016
4017   else
4018     {
4019       /* The case where we are excluding both ranges.  Here the complex case
4020          is if they don't overlap.  In that case, the only time we have a
4021          range is if they are adjacent.  If the second is a subset of the
4022          first, the result is the first.  Otherwise, the range to exclude
4023          starts at the beginning of the first range and ends at the end of the
4024          second.  */
4025       if (no_overlap)
4026         {
4027           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4028                                          range_binop (PLUS_EXPR, NULL_TREE,
4029                                                       high0, 1,
4030                                                       integer_one_node, 1),
4031                                          1, low1, 0)))
4032             in_p = 0, low = low0, high = high1;
4033           else
4034             {
4035               /* Canonicalize - [min, x] into - [-, x].  */
4036               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4037                 switch (TREE_CODE (TREE_TYPE (low0)))
4038                   {
4039                   case ENUMERAL_TYPE:
4040                     if (TYPE_PRECISION (TREE_TYPE (low0))
4041                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4042                       break;
4043                     /* FALLTHROUGH */
4044                   case INTEGER_TYPE:
4045                   case CHAR_TYPE:
4046                     if (tree_int_cst_equal (low0,
4047                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4048                       low0 = 0;
4049                     break;
4050                   case POINTER_TYPE:
4051                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4052                         && integer_zerop (low0))
4053                       low0 = 0;
4054                     break;
4055                   default:
4056                     break;
4057                   }
4058
4059               /* Canonicalize - [x, max] into - [x, -].  */
4060               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4061                 switch (TREE_CODE (TREE_TYPE (high1)))
4062                   {
4063                   case ENUMERAL_TYPE:
4064                     if (TYPE_PRECISION (TREE_TYPE (high1))
4065                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4066                       break;
4067                     /* FALLTHROUGH */
4068                   case INTEGER_TYPE:
4069                   case CHAR_TYPE:
4070                     if (tree_int_cst_equal (high1,
4071                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4072                       high1 = 0;
4073                     break;
4074                   case POINTER_TYPE:
4075                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4076                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4077                                                        high1, 1,
4078                                                        integer_one_node, 1)))
4079                       high1 = 0;
4080                     break;
4081                   default:
4082                     break;
4083                   }
4084
4085               /* The ranges might be also adjacent between the maximum and
4086                  minimum values of the given type.  For
4087                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4088                  return + [x + 1, y - 1].  */
4089               if (low0 == 0 && high1 == 0)
4090                 {
4091                   low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4092                                      integer_one_node, 1);
4093                   high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
4094                                       integer_one_node, 0);
4095                   if (low == 0 || high == 0)
4096                     return 0;
4097
4098                   in_p = 1;
4099                 }
4100               else
4101                 return 0;
4102             }
4103         }
4104       else if (subset)
4105         in_p = 0, low = low0, high = high0;
4106       else
4107         in_p = 0, low = low0, high = high1;
4108     }
4109
4110   *pin_p = in_p, *plow = low, *phigh = high;
4111   return 1;
4112 }
4113 \f
4114
4115 /* Subroutine of fold, looking inside expressions of the form
4116    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4117    of the COND_EXPR.  This function is being used also to optimize
4118    A op B ? C : A, by reversing the comparison first.
4119
4120    Return a folded expression whose code is not a COND_EXPR
4121    anymore, or NULL_TREE if no folding opportunity is found.  */
4122
4123 static tree
4124 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
4125 {
4126   enum tree_code comp_code = TREE_CODE (arg0);
4127   tree arg00 = TREE_OPERAND (arg0, 0);
4128   tree arg01 = TREE_OPERAND (arg0, 1);
4129   tree arg1_type = TREE_TYPE (arg1);
4130   tree tem;
4131
4132   STRIP_NOPS (arg1);
4133   STRIP_NOPS (arg2);
4134
4135   /* If we have A op 0 ? A : -A, consider applying the following
4136      transformations:
4137
4138      A == 0? A : -A    same as -A
4139      A != 0? A : -A    same as A
4140      A >= 0? A : -A    same as abs (A)
4141      A > 0?  A : -A    same as abs (A)
4142      A <= 0? A : -A    same as -abs (A)
4143      A < 0?  A : -A    same as -abs (A)
4144
4145      None of these transformations work for modes with signed
4146      zeros.  If A is +/-0, the first two transformations will
4147      change the sign of the result (from +0 to -0, or vice
4148      versa).  The last four will fix the sign of the result,
4149      even though the original expressions could be positive or
4150      negative, depending on the sign of A.
4151
4152      Note that all these transformations are correct if A is
4153      NaN, since the two alternatives (A and -A) are also NaNs.  */
4154   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
4155        ? real_zerop (arg01)
4156        : integer_zerop (arg01))
4157       && TREE_CODE (arg2) == NEGATE_EXPR
4158       && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4159     switch (comp_code)
4160       {
4161       case EQ_EXPR:
4162         tem = fold_convert (arg1_type, arg1);
4163         return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
4164       case NE_EXPR:
4165         return pedantic_non_lvalue (fold_convert (type, arg1));
4166       case GE_EXPR:
4167       case GT_EXPR:
4168         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4169           arg1 = fold_convert (lang_hooks.types.signed_type
4170                                (TREE_TYPE (arg1)), arg1);
4171         tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
4172         return pedantic_non_lvalue (fold_convert (type, tem));
4173       case LE_EXPR:
4174       case LT_EXPR:
4175         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4176           arg1 = fold_convert (lang_hooks.types.signed_type
4177                                (TREE_TYPE (arg1)), arg1);
4178         tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
4179         return negate_expr (fold_convert (type, tem));
4180       default:
4181         abort ();
4182       }
4183
4184   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4185      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4186      both transformations are correct when A is NaN: A != 0
4187      is then true, and A == 0 is false.  */
4188
4189   if (integer_zerop (arg01) && integer_zerop (arg2))
4190     {
4191       if (comp_code == NE_EXPR)
4192         return pedantic_non_lvalue (fold_convert (type, arg1));
4193       else if (comp_code == EQ_EXPR)
4194         return pedantic_non_lvalue (fold_convert (type, integer_zero_node));
4195     }
4196
4197   /* Try some transformations of A op B ? A : B.
4198
4199      A == B? A : B    same as B
4200      A != B? A : B    same as A
4201      A >= B? A : B    same as max (A, B)
4202      A > B?  A : B    same as max (B, A)
4203      A <= B? A : B    same as min (A, B)
4204      A < B?  A : B    same as min (B, A)
4205
4206      As above, these transformations don't work in the presence
4207      of signed zeros.  For example, if A and B are zeros of
4208      opposite sign, the first two transformations will change
4209      the sign of the result.  In the last four, the original
4210      expressions give different results for (A=+0, B=-0) and
4211      (A=-0, B=+0), but the transformed expressions do not.
4212
4213      The first two transformations are correct if either A or B
4214      is a NaN.  In the first transformation, the condition will
4215      be false, and B will indeed be chosen.  In the case of the
4216      second transformation, the condition A != B will be true,
4217      and A will be chosen.
4218
4219      The conversions to max() and min() are not correct if B is
4220      a number and A is not.  The conditions in the original
4221      expressions will be false, so all four give B.  The min()
4222      and max() versions would give a NaN instead.  */
4223   if (operand_equal_for_comparison_p (arg01, arg2, arg00))
4224     {
4225       tree comp_op0 = arg00;
4226       tree comp_op1 = arg01;
4227       tree comp_type = TREE_TYPE (comp_op0);
4228
4229       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4230       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4231         {
4232           comp_type = type;
4233           comp_op0 = arg1;
4234           comp_op1 = arg2;
4235         }
4236
4237       switch (comp_code)
4238         {
4239         case EQ_EXPR:
4240           return pedantic_non_lvalue (fold_convert (type, arg2));
4241         case NE_EXPR:
4242           return pedantic_non_lvalue (fold_convert (type, arg1));
4243         case LE_EXPR:
4244         case LT_EXPR:
4245           /* In C++ a ?: expression can be an lvalue, so put the
4246              operand which will be used if they are equal first
4247              so that we can convert this back to the
4248              corresponding COND_EXPR.  */
4249           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4250             return pedantic_non_lvalue (
4251                      fold_convert (type, fold (build2 (MIN_EXPR, comp_type,
4252                                          (comp_code == LE_EXPR
4253                                           ? comp_op0 : comp_op1),
4254                                          (comp_code == LE_EXPR
4255                                           ? comp_op1 : comp_op0)))));
4256           break;
4257         case GE_EXPR:
4258         case GT_EXPR:
4259           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4260             return pedantic_non_lvalue (
4261                      fold_convert (type, fold (build2 (MAX_EXPR, comp_type,
4262                                          (comp_code == GE_EXPR
4263                                           ? comp_op0 : comp_op1),
4264                                          (comp_code == GE_EXPR
4265                                           ? comp_op1 : comp_op0)))));
4266           break;
4267         default:
4268           abort ();
4269         }
4270     }
4271
4272   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4273      we might still be able to simplify this.  For example,
4274      if C1 is one less or one more than C2, this might have started
4275      out as a MIN or MAX and been transformed by this function.
4276      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4277
4278   if (INTEGRAL_TYPE_P (type)
4279       && TREE_CODE (arg01) == INTEGER_CST
4280       && TREE_CODE (arg2) == INTEGER_CST)
4281     switch (comp_code)
4282       {
4283       case EQ_EXPR:
4284         /* We can replace A with C1 in this case.  */
4285         arg1 = fold_convert (type, arg01);
4286         return fold (build3 (COND_EXPR, type, arg0, arg1, arg2));
4287
4288       case LT_EXPR:
4289         /* If C1 is C2 + 1, this is min(A, C2).  */
4290         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4291                                OEP_ONLY_CONST)
4292             && operand_equal_p (arg01,
4293                                 const_binop (PLUS_EXPR, arg2,
4294                                              integer_one_node, 0),
4295                                 OEP_ONLY_CONST))
4296           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4297                                                     type, arg1, arg2)));
4298         break;
4299
4300       case LE_EXPR:
4301         /* If C1 is C2 - 1, this is min(A, C2).  */
4302         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4303                                OEP_ONLY_CONST)
4304             && operand_equal_p (arg01,
4305                                 const_binop (MINUS_EXPR, arg2,
4306                                              integer_one_node, 0),
4307                                 OEP_ONLY_CONST))
4308           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4309                                                     type, arg1, arg2)));
4310         break;
4311
4312       case GT_EXPR:
4313         /* If C1 is C2 - 1, this is max(A, C2).  */
4314         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4315                                OEP_ONLY_CONST)
4316             && operand_equal_p (arg01,
4317                                 const_binop (MINUS_EXPR, arg2,
4318                                              integer_one_node, 0),
4319                                 OEP_ONLY_CONST))
4320           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4321                                                     type, arg1, arg2)));
4322         break;
4323
4324       case GE_EXPR:
4325         /* If C1 is C2 + 1, this is max(A, C2).  */
4326         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4327                                OEP_ONLY_CONST)
4328             && operand_equal_p (arg01,
4329                                 const_binop (PLUS_EXPR, arg2,
4330                                              integer_one_node, 0),
4331                                 OEP_ONLY_CONST))
4332           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4333                                                     type, arg1, arg2)));
4334         break;
4335       case NE_EXPR:
4336         break;
4337       default:
4338         abort ();
4339       }
4340
4341   return NULL_TREE;
4342 }
4343
4344
4345 \f
4346 #ifndef RANGE_TEST_NON_SHORT_CIRCUIT
4347 #define RANGE_TEST_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
4348 #endif
4349
4350 /* EXP is some logical combination of boolean tests.  See if we can
4351    merge it into some range test.  Return the new tree if so.  */
4352
4353 static tree
4354 fold_range_test (tree exp)
4355 {
4356   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
4357                || TREE_CODE (exp) == TRUTH_OR_EXPR);
4358   int in0_p, in1_p, in_p;
4359   tree low0, low1, low, high0, high1, high;
4360   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
4361   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
4362   tree tem;
4363
4364   /* If this is an OR operation, invert both sides; we will invert
4365      again at the end.  */
4366   if (or_op)
4367     in0_p = ! in0_p, in1_p = ! in1_p;
4368
4369   /* If both expressions are the same, if we can merge the ranges, and we
4370      can build the range test, return it or it inverted.  If one of the
4371      ranges is always true or always false, consider it to be the same
4372      expression as the other.  */
4373   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4374       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4375                        in1_p, low1, high1)
4376       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
4377                                          lhs != 0 ? lhs
4378                                          : rhs != 0 ? rhs : integer_zero_node,
4379                                          in_p, low, high))))
4380     return or_op ? invert_truthvalue (tem) : tem;
4381
4382   /* On machines where the branch cost is expensive, if this is a
4383      short-circuited branch and the underlying object on both sides
4384      is the same, make a non-short-circuit operation.  */
4385   else if (RANGE_TEST_NON_SHORT_CIRCUIT
4386            && lhs != 0 && rhs != 0
4387            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4388                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
4389            && operand_equal_p (lhs, rhs, 0))
4390     {
4391       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4392          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4393          which cases we can't do this.  */
4394       if (simple_operand_p (lhs))
4395         return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4396                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4397                        TREE_TYPE (exp), TREE_OPERAND (exp, 0),
4398                        TREE_OPERAND (exp, 1));
4399
4400       else if (lang_hooks.decls.global_bindings_p () == 0
4401                && ! CONTAINS_PLACEHOLDER_P (lhs))
4402         {
4403           tree common = save_expr (lhs);
4404
4405           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
4406                                              or_op ? ! in0_p : in0_p,
4407                                              low0, high0))
4408               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
4409                                                  or_op ? ! in1_p : in1_p,
4410                                                  low1, high1))))
4411             return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4412                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4413                            TREE_TYPE (exp), lhs, rhs);
4414         }
4415     }
4416
4417   return 0;
4418 }
4419 \f
4420 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4421    bit value.  Arrange things so the extra bits will be set to zero if and
4422    only if C is signed-extended to its full width.  If MASK is nonzero,
4423    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4424
4425 static tree
4426 unextend (tree c, int p, int unsignedp, tree mask)
4427 {
4428   tree type = TREE_TYPE (c);
4429   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4430   tree temp;
4431
4432   if (p == modesize || unsignedp)
4433     return c;
4434
4435   /* We work by getting just the sign bit into the low-order bit, then
4436      into the high-order bit, then sign-extend.  We then XOR that value
4437      with C.  */
4438   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
4439   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
4440
4441   /* We must use a signed type in order to get an arithmetic right shift.
4442      However, we must also avoid introducing accidental overflows, so that
4443      a subsequent call to integer_zerop will work.  Hence we must
4444      do the type conversion here.  At this point, the constant is either
4445      zero or one, and the conversion to a signed type can never overflow.
4446      We could get an overflow if this conversion is done anywhere else.  */
4447   if (TYPE_UNSIGNED (type))
4448     temp = fold_convert (lang_hooks.types.signed_type (type), temp);
4449
4450   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
4451   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
4452   if (mask != 0)
4453     temp = const_binop (BIT_AND_EXPR, temp,
4454                         fold_convert (TREE_TYPE (c), mask), 0);
4455   /* If necessary, convert the type back to match the type of C.  */
4456   if (TYPE_UNSIGNED (type))
4457     temp = fold_convert (type, temp);
4458
4459   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
4460 }
4461 \f
4462 /* Find ways of folding logical expressions of LHS and RHS:
4463    Try to merge two comparisons to the same innermost item.
4464    Look for range tests like "ch >= '0' && ch <= '9'".
4465    Look for combinations of simple terms on machines with expensive branches
4466    and evaluate the RHS unconditionally.
4467
4468    For example, if we have p->a == 2 && p->b == 4 and we can make an
4469    object large enough to span both A and B, we can do this with a comparison
4470    against the object ANDed with the a mask.
4471
4472    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
4473    operations to do this with one comparison.
4474
4475    We check for both normal comparisons and the BIT_AND_EXPRs made this by
4476    function and the one above.
4477
4478    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
4479    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
4480
4481    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
4482    two operands.
4483
4484    We return the simplified tree or 0 if no optimization is possible.  */
4485
4486 static tree
4487 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
4488 {
4489   /* If this is the "or" of two comparisons, we can do something if
4490      the comparisons are NE_EXPR.  If this is the "and", we can do something
4491      if the comparisons are EQ_EXPR.  I.e.,
4492         (a->b == 2 && a->c == 4) can become (a->new == NEW).
4493
4494      WANTED_CODE is this operation code.  For single bit fields, we can
4495      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
4496      comparison for one-bit fields.  */
4497
4498   enum tree_code wanted_code;
4499   enum tree_code lcode, rcode;
4500   tree ll_arg, lr_arg, rl_arg, rr_arg;
4501   tree ll_inner, lr_inner, rl_inner, rr_inner;
4502   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
4503   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
4504   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
4505   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
4506   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
4507   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
4508   enum machine_mode lnmode, rnmode;
4509   tree ll_mask, lr_mask, rl_mask, rr_mask;
4510   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
4511   tree l_const, r_const;
4512   tree lntype, rntype, result;
4513   int first_bit, end_bit;
4514   int volatilep;
4515
4516   /* Start by getting the comparison codes.  Fail if anything is volatile.
4517      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
4518      it were surrounded with a NE_EXPR.  */
4519
4520   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
4521     return 0;
4522
4523   lcode = TREE_CODE (lhs);
4524   rcode = TREE_CODE (rhs);
4525
4526   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
4527     {
4528       lhs = build2 (NE_EXPR, truth_type, lhs, integer_zero_node);
4529       lcode = NE_EXPR;
4530     }
4531
4532   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
4533     {
4534       rhs = build2 (NE_EXPR, truth_type, rhs, integer_zero_node);
4535       rcode = NE_EXPR;
4536     }
4537
4538   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
4539     return 0;
4540
4541   ll_arg = TREE_OPERAND (lhs, 0);
4542   lr_arg = TREE_OPERAND (lhs, 1);
4543   rl_arg = TREE_OPERAND (rhs, 0);
4544   rr_arg = TREE_OPERAND (rhs, 1);
4545
4546   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
4547   if (simple_operand_p (ll_arg)
4548       && simple_operand_p (lr_arg))
4549     {
4550       tree result;
4551       if (operand_equal_p (ll_arg, rl_arg, 0)
4552           && operand_equal_p (lr_arg, rr_arg, 0))
4553         {
4554           result = combine_comparisons (code, lcode, rcode,
4555                                         truth_type, ll_arg, lr_arg);
4556           if (result)
4557             return result;
4558         }
4559       else if (operand_equal_p (ll_arg, rr_arg, 0)
4560                && operand_equal_p (lr_arg, rl_arg, 0))
4561         {
4562           result = combine_comparisons (code, lcode,
4563                                         swap_tree_comparison (rcode),
4564                                         truth_type, ll_arg, lr_arg);
4565           if (result)
4566             return result;
4567         }
4568     }
4569
4570   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
4571           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
4572
4573   /* If the RHS can be evaluated unconditionally and its operands are
4574      simple, it wins to evaluate the RHS unconditionally on machines
4575      with expensive branches.  In this case, this isn't a comparison
4576      that can be merged.  Avoid doing this if the RHS is a floating-point
4577      comparison since those can trap.  */
4578
4579   if (BRANCH_COST >= 2
4580       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
4581       && simple_operand_p (rl_arg)
4582       && simple_operand_p (rr_arg))
4583     {
4584       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
4585       if (code == TRUTH_OR_EXPR
4586           && lcode == NE_EXPR && integer_zerop (lr_arg)
4587           && rcode == NE_EXPR && integer_zerop (rr_arg)
4588           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4589         return build2 (NE_EXPR, truth_type,
4590                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4591                                ll_arg, rl_arg),
4592                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4593
4594       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
4595       if (code == TRUTH_AND_EXPR
4596           && lcode == EQ_EXPR && integer_zerop (lr_arg)
4597           && rcode == EQ_EXPR && integer_zerop (rr_arg)
4598           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4599         return build2 (EQ_EXPR, truth_type,
4600                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4601                                ll_arg, rl_arg),
4602                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4603
4604       return build2 (code, truth_type, lhs, rhs);
4605     }
4606
4607   /* See if the comparisons can be merged.  Then get all the parameters for
4608      each side.  */
4609
4610   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
4611       || (rcode != EQ_EXPR && rcode != NE_EXPR))
4612     return 0;
4613
4614   volatilep = 0;
4615   ll_inner = decode_field_reference (ll_arg,
4616                                      &ll_bitsize, &ll_bitpos, &ll_mode,
4617                                      &ll_unsignedp, &volatilep, &ll_mask,
4618                                      &ll_and_mask);
4619   lr_inner = decode_field_reference (lr_arg,
4620                                      &lr_bitsize, &lr_bitpos, &lr_mode,
4621                                      &lr_unsignedp, &volatilep, &lr_mask,
4622                                      &lr_and_mask);
4623   rl_inner = decode_field_reference (rl_arg,
4624                                      &rl_bitsize, &rl_bitpos, &rl_mode,
4625                                      &rl_unsignedp, &volatilep, &rl_mask,
4626                                      &rl_and_mask);
4627   rr_inner = decode_field_reference (rr_arg,
4628                                      &rr_bitsize, &rr_bitpos, &rr_mode,
4629                                      &rr_unsignedp, &volatilep, &rr_mask,
4630                                      &rr_and_mask);
4631
4632   /* It must be true that the inner operation on the lhs of each
4633      comparison must be the same if we are to be able to do anything.
4634      Then see if we have constants.  If not, the same must be true for
4635      the rhs's.  */
4636   if (volatilep || ll_inner == 0 || rl_inner == 0
4637       || ! operand_equal_p (ll_inner, rl_inner, 0))
4638     return 0;
4639
4640   if (TREE_CODE (lr_arg) == INTEGER_CST
4641       && TREE_CODE (rr_arg) == INTEGER_CST)
4642     l_const = lr_arg, r_const = rr_arg;
4643   else if (lr_inner == 0 || rr_inner == 0
4644            || ! operand_equal_p (lr_inner, rr_inner, 0))
4645     return 0;
4646   else
4647     l_const = r_const = 0;
4648
4649   /* If either comparison code is not correct for our logical operation,
4650      fail.  However, we can convert a one-bit comparison against zero into
4651      the opposite comparison against that bit being set in the field.  */
4652
4653   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
4654   if (lcode != wanted_code)
4655     {
4656       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
4657         {
4658           /* Make the left operand unsigned, since we are only interested
4659              in the value of one bit.  Otherwise we are doing the wrong
4660              thing below.  */
4661           ll_unsignedp = 1;
4662           l_const = ll_mask;
4663         }
4664       else
4665         return 0;
4666     }
4667
4668   /* This is analogous to the code for l_const above.  */
4669   if (rcode != wanted_code)
4670     {
4671       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
4672         {
4673           rl_unsignedp = 1;
4674           r_const = rl_mask;
4675         }
4676       else
4677         return 0;
4678     }
4679
4680   /* After this point all optimizations will generate bit-field
4681      references, which we might not want.  */
4682   if (! lang_hooks.can_use_bit_fields_p ())
4683     return 0;
4684
4685   /* See if we can find a mode that contains both fields being compared on
4686      the left.  If we can't, fail.  Otherwise, update all constants and masks
4687      to be relative to a field of that size.  */
4688   first_bit = MIN (ll_bitpos, rl_bitpos);
4689   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
4690   lnmode = get_best_mode (end_bit - first_bit, first_bit,
4691                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
4692                           volatilep);
4693   if (lnmode == VOIDmode)
4694     return 0;
4695
4696   lnbitsize = GET_MODE_BITSIZE (lnmode);
4697   lnbitpos = first_bit & ~ (lnbitsize - 1);
4698   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
4699   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
4700
4701   if (BYTES_BIG_ENDIAN)
4702     {
4703       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
4704       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
4705     }
4706
4707   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
4708                          size_int (xll_bitpos), 0);
4709   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
4710                          size_int (xrl_bitpos), 0);
4711
4712   if (l_const)
4713     {
4714       l_const = fold_convert (lntype, l_const);
4715       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
4716       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
4717       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
4718                                         fold (build1 (BIT_NOT_EXPR,
4719                                                       lntype, ll_mask)),
4720                                         0)))
4721         {
4722           warning ("comparison is always %d", wanted_code == NE_EXPR);
4723
4724           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4725         }
4726     }
4727   if (r_const)
4728     {
4729       r_const = fold_convert (lntype, r_const);
4730       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
4731       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
4732       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
4733                                         fold (build1 (BIT_NOT_EXPR,
4734                                                       lntype, rl_mask)),
4735                                         0)))
4736         {
4737           warning ("comparison is always %d", wanted_code == NE_EXPR);
4738
4739           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4740         }
4741     }
4742
4743   /* If the right sides are not constant, do the same for it.  Also,
4744      disallow this optimization if a size or signedness mismatch occurs
4745      between the left and right sides.  */
4746   if (l_const == 0)
4747     {
4748       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4749           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4750           /* Make sure the two fields on the right
4751              correspond to the left without being swapped.  */
4752           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4753         return 0;
4754
4755       first_bit = MIN (lr_bitpos, rr_bitpos);
4756       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4757       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4758                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4759                               volatilep);
4760       if (rnmode == VOIDmode)
4761         return 0;
4762
4763       rnbitsize = GET_MODE_BITSIZE (rnmode);
4764       rnbitpos = first_bit & ~ (rnbitsize - 1);
4765       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
4766       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4767
4768       if (BYTES_BIG_ENDIAN)
4769         {
4770           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4771           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4772         }
4773
4774       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
4775                              size_int (xlr_bitpos), 0);
4776       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
4777                              size_int (xrr_bitpos), 0);
4778
4779       /* Make a mask that corresponds to both fields being compared.
4780          Do this for both items being compared.  If the operands are the
4781          same size and the bits being compared are in the same position
4782          then we can do this by masking both and comparing the masked
4783          results.  */
4784       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4785       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4786       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4787         {
4788           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4789                                     ll_unsignedp || rl_unsignedp);
4790           if (! all_ones_mask_p (ll_mask, lnbitsize))
4791             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
4792
4793           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4794                                     lr_unsignedp || rr_unsignedp);
4795           if (! all_ones_mask_p (lr_mask, rnbitsize))
4796             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
4797
4798           return build2 (wanted_code, truth_type, lhs, rhs);
4799         }
4800
4801       /* There is still another way we can do something:  If both pairs of
4802          fields being compared are adjacent, we may be able to make a wider
4803          field containing them both.
4804
4805          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4806          the mask must be shifted to account for the shift done by
4807          make_bit_field_ref.  */
4808       if ((ll_bitsize + ll_bitpos == rl_bitpos
4809            && lr_bitsize + lr_bitpos == rr_bitpos)
4810           || (ll_bitpos == rl_bitpos + rl_bitsize
4811               && lr_bitpos == rr_bitpos + rr_bitsize))
4812         {
4813           tree type;
4814
4815           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4816                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4817           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4818                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4819
4820           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4821                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4822           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4823                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4824
4825           /* Convert to the smaller type before masking out unwanted bits.  */
4826           type = lntype;
4827           if (lntype != rntype)
4828             {
4829               if (lnbitsize > rnbitsize)
4830                 {
4831                   lhs = fold_convert (rntype, lhs);
4832                   ll_mask = fold_convert (rntype, ll_mask);
4833                   type = rntype;
4834                 }
4835               else if (lnbitsize < rnbitsize)
4836                 {
4837                   rhs = fold_convert (lntype, rhs);
4838                   lr_mask = fold_convert (lntype, lr_mask);
4839                   type = lntype;
4840                 }
4841             }
4842
4843           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4844             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
4845
4846           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4847             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
4848
4849           return build2 (wanted_code, truth_type, lhs, rhs);
4850         }
4851
4852       return 0;
4853     }
4854
4855   /* Handle the case of comparisons with constants.  If there is something in
4856      common between the masks, those bits of the constants must be the same.
4857      If not, the condition is always false.  Test for this to avoid generating
4858      incorrect code below.  */
4859   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4860   if (! integer_zerop (result)
4861       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4862                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4863     {
4864       if (wanted_code == NE_EXPR)
4865         {
4866           warning ("`or' of unmatched not-equal tests is always 1");
4867           return constant_boolean_node (true, truth_type);
4868         }
4869       else
4870         {
4871           warning ("`and' of mutually exclusive equal-tests is always 0");
4872           return constant_boolean_node (false, truth_type);
4873         }
4874     }
4875
4876   /* Construct the expression we will return.  First get the component
4877      reference we will make.  Unless the mask is all ones the width of
4878      that field, perform the mask operation.  Then compare with the
4879      merged constant.  */
4880   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4881                                ll_unsignedp || rl_unsignedp);
4882
4883   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4884   if (! all_ones_mask_p (ll_mask, lnbitsize))
4885     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
4886
4887   return build2 (wanted_code, truth_type, result,
4888                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4889 }
4890 \f
4891 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4892    constant.  */
4893
4894 static tree
4895 optimize_minmax_comparison (tree t)
4896 {
4897   tree type = TREE_TYPE (t);
4898   tree arg0 = TREE_OPERAND (t, 0);
4899   enum tree_code op_code;
4900   tree comp_const = TREE_OPERAND (t, 1);
4901   tree minmax_const;
4902   int consts_equal, consts_lt;
4903   tree inner;
4904
4905   STRIP_SIGN_NOPS (arg0);
4906
4907   op_code = TREE_CODE (arg0);
4908   minmax_const = TREE_OPERAND (arg0, 1);
4909   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4910   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4911   inner = TREE_OPERAND (arg0, 0);
4912
4913   /* If something does not permit us to optimize, return the original tree.  */
4914   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4915       || TREE_CODE (comp_const) != INTEGER_CST
4916       || TREE_CONSTANT_OVERFLOW (comp_const)
4917       || TREE_CODE (minmax_const) != INTEGER_CST
4918       || TREE_CONSTANT_OVERFLOW (minmax_const))
4919     return t;
4920
4921   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4922      and GT_EXPR, doing the rest with recursive calls using logical
4923      simplifications.  */
4924   switch (TREE_CODE (t))
4925     {
4926     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4927       return
4928         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4929
4930     case GE_EXPR:
4931       return
4932         fold (build2 (TRUTH_ORIF_EXPR, type,
4933                       optimize_minmax_comparison
4934                       (build2 (EQ_EXPR, type, arg0, comp_const)),
4935                       optimize_minmax_comparison
4936                       (build2 (GT_EXPR, type, arg0, comp_const))));
4937
4938     case EQ_EXPR:
4939       if (op_code == MAX_EXPR && consts_equal)
4940         /* MAX (X, 0) == 0  ->  X <= 0  */
4941         return fold (build2 (LE_EXPR, type, inner, comp_const));
4942
4943       else if (op_code == MAX_EXPR && consts_lt)
4944         /* MAX (X, 0) == 5  ->  X == 5   */
4945         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4946
4947       else if (op_code == MAX_EXPR)
4948         /* MAX (X, 0) == -1  ->  false  */
4949         return omit_one_operand (type, integer_zero_node, inner);
4950
4951       else if (consts_equal)
4952         /* MIN (X, 0) == 0  ->  X >= 0  */
4953         return fold (build2 (GE_EXPR, type, inner, comp_const));
4954
4955       else if (consts_lt)
4956         /* MIN (X, 0) == 5  ->  false  */
4957         return omit_one_operand (type, integer_zero_node, inner);
4958
4959       else
4960         /* MIN (X, 0) == -1  ->  X == -1  */
4961         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4962
4963     case GT_EXPR:
4964       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4965         /* MAX (X, 0) > 0  ->  X > 0
4966            MAX (X, 0) > 5  ->  X > 5  */
4967         return fold (build2 (GT_EXPR, type, inner, comp_const));
4968
4969       else if (op_code == MAX_EXPR)
4970         /* MAX (X, 0) > -1  ->  true  */
4971         return omit_one_operand (type, integer_one_node, inner);
4972
4973       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4974         /* MIN (X, 0) > 0  ->  false
4975            MIN (X, 0) > 5  ->  false  */
4976         return omit_one_operand (type, integer_zero_node, inner);
4977
4978       else
4979         /* MIN (X, 0) > -1  ->  X > -1  */
4980         return fold (build2 (GT_EXPR, type, inner, comp_const));
4981
4982     default:
4983       return t;
4984     }
4985 }
4986 \f
4987 /* T is an integer expression that is being multiplied, divided, or taken a
4988    modulus (CODE says which and what kind of divide or modulus) by a
4989    constant C.  See if we can eliminate that operation by folding it with
4990    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4991    should be used for the computation if wider than our type.
4992
4993    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
4994    (X * 2) + (Y * 4).  We must, however, be assured that either the original
4995    expression would not overflow or that overflow is undefined for the type
4996    in the language in question.
4997
4998    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4999    the machine has a multiply-accumulate insn or that this is part of an
5000    addressing calculation.
5001
5002    If we return a non-null expression, it is an equivalent form of the
5003    original computation, but need not be in the original type.  */
5004
5005 static tree
5006 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type)
5007 {
5008   /* To avoid exponential search depth, refuse to allow recursion past
5009      three levels.  Beyond that (1) it's highly unlikely that we'll find
5010      something interesting and (2) we've probably processed it before
5011      when we built the inner expression.  */
5012
5013   static int depth;
5014   tree ret;
5015
5016   if (depth > 3)
5017     return NULL;
5018
5019   depth++;
5020   ret = extract_muldiv_1 (t, c, code, wide_type);
5021   depth--;
5022
5023   return ret;
5024 }
5025
5026 static tree
5027 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
5028 {
5029   tree type = TREE_TYPE (t);
5030   enum tree_code tcode = TREE_CODE (t);
5031   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5032                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5033                 ? wide_type : type);
5034   tree t1, t2;
5035   int same_p = tcode == code;
5036   tree op0 = NULL_TREE, op1 = NULL_TREE;
5037
5038   /* Don't deal with constants of zero here; they confuse the code below.  */
5039   if (integer_zerop (c))
5040     return NULL_TREE;
5041
5042   if (TREE_CODE_CLASS (tcode) == '1')
5043     op0 = TREE_OPERAND (t, 0);
5044
5045   if (TREE_CODE_CLASS (tcode) == '2')
5046     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5047
5048   /* Note that we need not handle conditional operations here since fold
5049      already handles those cases.  So just do arithmetic here.  */
5050   switch (tcode)
5051     {
5052     case INTEGER_CST:
5053       /* For a constant, we can always simplify if we are a multiply
5054          or (for divide and modulus) if it is a multiple of our constant.  */
5055       if (code == MULT_EXPR
5056           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
5057         return const_binop (code, fold_convert (ctype, t),
5058                             fold_convert (ctype, c), 0);
5059       break;
5060
5061     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
5062       /* If op0 is an expression ...  */
5063       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
5064            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
5065            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
5066            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
5067           /* ... and is unsigned, and its type is smaller than ctype,
5068              then we cannot pass through as widening.  */
5069           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
5070                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5071                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5072                && (GET_MODE_SIZE (TYPE_MODE (ctype))
5073                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
5074               /* ... or its type is larger than ctype,
5075                  then we cannot pass through this truncation.  */
5076               || (GET_MODE_SIZE (TYPE_MODE (ctype))
5077                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
5078               /* ... or signedness changes for division or modulus,
5079                  then we cannot pass through this conversion.  */
5080               || (code != MULT_EXPR
5081                   && (TYPE_UNSIGNED (ctype)
5082                       != TYPE_UNSIGNED (TREE_TYPE (op0))))))
5083         break;
5084
5085       /* Pass the constant down and see if we can make a simplification.  If
5086          we can, replace this expression with the inner simplification for
5087          possible later conversion to our or some other type.  */
5088       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5089           && TREE_CODE (t2) == INTEGER_CST
5090           && ! TREE_CONSTANT_OVERFLOW (t2)
5091           && (0 != (t1 = extract_muldiv (op0, t2, code,
5092                                          code == MULT_EXPR
5093                                          ? ctype : NULL_TREE))))
5094         return t1;
5095       break;
5096
5097     case NEGATE_EXPR:  case ABS_EXPR:
5098       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5099         return fold (build1 (tcode, ctype, fold_convert (ctype, t1)));
5100       break;
5101
5102     case MIN_EXPR:  case MAX_EXPR:
5103       /* If widening the type changes the signedness, then we can't perform
5104          this optimization as that changes the result.  */
5105       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5106         break;
5107
5108       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5109       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
5110           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
5111         {
5112           if (tree_int_cst_sgn (c) < 0)
5113             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5114
5115           return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5116                                fold_convert (ctype, t2)));
5117         }
5118       break;
5119
5120     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5121       /* If the second operand is constant, this is a multiplication
5122          or floor division, by a power of two, so we can treat it that
5123          way unless the multiplier or divisor overflows.  */
5124       if (TREE_CODE (op1) == INTEGER_CST
5125           /* const_binop may not detect overflow correctly,
5126              so check for it explicitly here.  */
5127           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5128           && TREE_INT_CST_HIGH (op1) == 0
5129           && 0 != (t1 = fold_convert (ctype,
5130                                       const_binop (LSHIFT_EXPR,
5131                                                    size_one_node,
5132                                                    op1, 0)))
5133           && ! TREE_OVERFLOW (t1))
5134         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5135                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5136                                        ctype, fold_convert (ctype, op0), t1),
5137                                c, code, wide_type);
5138       break;
5139
5140     case PLUS_EXPR:  case MINUS_EXPR:
5141       /* See if we can eliminate the operation on both sides.  If we can, we
5142          can return a new PLUS or MINUS.  If we can't, the only remaining
5143          cases where we can do anything are if the second operand is a
5144          constant.  */
5145       t1 = extract_muldiv (op0, c, code, wide_type);
5146       t2 = extract_muldiv (op1, c, code, wide_type);
5147       if (t1 != 0 && t2 != 0
5148           && (code == MULT_EXPR
5149               /* If not multiplication, we can only do this if both operands
5150                  are divisible by c.  */
5151               || (multiple_of_p (ctype, op0, c)
5152                   && multiple_of_p (ctype, op1, c))))
5153         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5154                              fold_convert (ctype, t2)));
5155
5156       /* If this was a subtraction, negate OP1 and set it to be an addition.
5157          This simplifies the logic below.  */
5158       if (tcode == MINUS_EXPR)
5159         tcode = PLUS_EXPR, op1 = negate_expr (op1);
5160
5161       if (TREE_CODE (op1) != INTEGER_CST)
5162         break;
5163
5164       /* If either OP1 or C are negative, this optimization is not safe for
5165          some of the division and remainder types while for others we need
5166          to change the code.  */
5167       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5168         {
5169           if (code == CEIL_DIV_EXPR)
5170             code = FLOOR_DIV_EXPR;
5171           else if (code == FLOOR_DIV_EXPR)
5172             code = CEIL_DIV_EXPR;
5173           else if (code != MULT_EXPR
5174                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5175             break;
5176         }
5177
5178       /* If it's a multiply or a division/modulus operation of a multiple
5179          of our constant, do the operation and verify it doesn't overflow.  */
5180       if (code == MULT_EXPR
5181           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5182         {
5183           op1 = const_binop (code, fold_convert (ctype, op1),
5184                              fold_convert (ctype, c), 0);
5185           /* We allow the constant to overflow with wrapping semantics.  */
5186           if (op1 == 0
5187               || (TREE_OVERFLOW (op1) && ! flag_wrapv))
5188             break;
5189         }
5190       else
5191         break;
5192
5193       /* If we have an unsigned type is not a sizetype, we cannot widen
5194          the operation since it will change the result if the original
5195          computation overflowed.  */
5196       if (TYPE_UNSIGNED (ctype)
5197           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5198           && ctype != type)
5199         break;
5200
5201       /* If we were able to eliminate our operation from the first side,
5202          apply our operation to the second side and reform the PLUS.  */
5203       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5204         return fold (build2 (tcode, ctype, fold_convert (ctype, t1), op1));
5205
5206       /* The last case is if we are a multiply.  In that case, we can
5207          apply the distributive law to commute the multiply and addition
5208          if the multiplication of the constants doesn't overflow.  */
5209       if (code == MULT_EXPR)
5210         return fold (build2 (tcode, ctype,
5211                              fold (build2 (code, ctype,
5212                                            fold_convert (ctype, op0),
5213                                            fold_convert (ctype, c))),
5214                              op1));
5215
5216       break;
5217
5218     case MULT_EXPR:
5219       /* We have a special case here if we are doing something like
5220          (C * 8) % 4 since we know that's zero.  */
5221       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5222            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5223           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5224           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5225         return omit_one_operand (type, integer_zero_node, op0);
5226
5227       /* ... fall through ...  */
5228
5229     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5230     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5231       /* If we can extract our operation from the LHS, do so and return a
5232          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5233          do something only if the second operand is a constant.  */
5234       if (same_p
5235           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5236         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5237                              fold_convert (ctype, op1)));
5238       else if (tcode == MULT_EXPR && code == MULT_EXPR
5239                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
5240         return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5241                              fold_convert (ctype, t1)));
5242       else if (TREE_CODE (op1) != INTEGER_CST)
5243         return 0;
5244
5245       /* If these are the same operation types, we can associate them
5246          assuming no overflow.  */
5247       if (tcode == code
5248           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5249                                      fold_convert (ctype, c), 0))
5250           && ! TREE_OVERFLOW (t1))
5251         return fold (build2 (tcode, ctype, fold_convert (ctype, op0), t1));
5252
5253       /* If these operations "cancel" each other, we have the main
5254          optimizations of this pass, which occur when either constant is a
5255          multiple of the other, in which case we replace this with either an
5256          operation or CODE or TCODE.
5257
5258          If we have an unsigned type that is not a sizetype, we cannot do
5259          this since it will change the result if the original computation
5260          overflowed.  */
5261       if ((! TYPE_UNSIGNED (ctype)
5262            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5263           && ! flag_wrapv
5264           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5265               || (tcode == MULT_EXPR
5266                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5267                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
5268         {
5269           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5270             return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5271                                  fold_convert (ctype,
5272                                                const_binop (TRUNC_DIV_EXPR,
5273                                                             op1, c, 0))));
5274           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5275             return fold (build2 (code, ctype, fold_convert (ctype, op0),
5276                                  fold_convert (ctype,
5277                                                const_binop (TRUNC_DIV_EXPR,
5278                                                             c, op1, 0))));
5279         }
5280       break;
5281
5282     default:
5283       break;
5284     }
5285
5286   return 0;
5287 }
5288 \f
5289 /* Return a node which has the indicated constant VALUE (either 0 or
5290    1), and is of the indicated TYPE.  */
5291
5292 static tree
5293 constant_boolean_node (int value, tree type)
5294 {
5295   if (type == integer_type_node)
5296     return value ? integer_one_node : integer_zero_node;
5297   else if (type == boolean_type_node)
5298     return value ? boolean_true_node : boolean_false_node;
5299   else if (TREE_CODE (type) == BOOLEAN_TYPE)
5300     return lang_hooks.truthvalue_conversion (value ? integer_one_node
5301                                                    : integer_zero_node);
5302   else
5303     {
5304       tree t = build_int_2 (value, 0);
5305
5306       TREE_TYPE (t) = type;
5307       return t;
5308     }
5309 }
5310
5311 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5312    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5313    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5314    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5315    COND is the first argument to CODE; otherwise (as in the example
5316    given here), it is the second argument.  TYPE is the type of the
5317    original expression.  Return NULL_TREE if no simplification is
5318    possible.  */
5319
5320 static tree
5321 fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
5322                                      tree cond, tree arg, int cond_first_p)
5323 {
5324   tree test, true_value, false_value;
5325   tree lhs = NULL_TREE;
5326   tree rhs = NULL_TREE;
5327
5328   /* This transformation is only worthwhile if we don't have to wrap
5329      arg in a SAVE_EXPR, and the operation can be simplified on atleast
5330      one of the branches once its pushed inside the COND_EXPR.  */
5331   if (!TREE_CONSTANT (arg))
5332     return NULL_TREE;
5333
5334   if (TREE_CODE (cond) == COND_EXPR)
5335     {
5336       test = TREE_OPERAND (cond, 0);
5337       true_value = TREE_OPERAND (cond, 1);
5338       false_value = TREE_OPERAND (cond, 2);
5339       /* If this operand throws an expression, then it does not make
5340          sense to try to perform a logical or arithmetic operation
5341          involving it.  */
5342       if (VOID_TYPE_P (TREE_TYPE (true_value)))
5343         lhs = true_value;
5344       if (VOID_TYPE_P (TREE_TYPE (false_value)))
5345         rhs = false_value;
5346     }
5347   else
5348     {
5349       tree testtype = TREE_TYPE (cond);
5350       test = cond;
5351       true_value = constant_boolean_node (true, testtype);
5352       false_value = constant_boolean_node (false, testtype);
5353     }
5354
5355   if (lhs == 0)
5356     lhs = fold (cond_first_p ? build2 (code, type, true_value, arg)
5357                              : build2 (code, type, arg, true_value));
5358   if (rhs == 0)
5359     rhs = fold (cond_first_p ? build2 (code, type, false_value, arg)
5360                              : build2 (code, type, arg, false_value));
5361
5362   test = fold (build3 (COND_EXPR, type, test, lhs, rhs));
5363   return fold_convert (type, test);
5364 }
5365
5366 \f
5367 /* Subroutine of fold() that checks for the addition of +/- 0.0.
5368
5369    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
5370    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
5371    ADDEND is the same as X.
5372
5373    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
5374    and finite.  The problematic cases are when X is zero, and its mode
5375    has signed zeros.  In the case of rounding towards -infinity,
5376    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
5377    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
5378
5379 static bool
5380 fold_real_zero_addition_p (tree type, tree addend, int negate)
5381 {
5382   if (!real_zerop (addend))
5383     return false;
5384
5385   /* Don't allow the fold with -fsignaling-nans.  */
5386   if (HONOR_SNANS (TYPE_MODE (type)))
5387     return false;
5388
5389   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
5390   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
5391     return true;
5392
5393   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
5394   if (TREE_CODE (addend) == REAL_CST
5395       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
5396     negate = !negate;
5397
5398   /* The mode has signed zeros, and we have to honor their sign.
5399      In this situation, there is only one case we can return true for.
5400      X - 0 is the same as X unless rounding towards -infinity is
5401      supported.  */
5402   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
5403 }
5404
5405 /* Subroutine of fold() that checks comparisons of built-in math
5406    functions against real constants.
5407
5408    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
5409    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
5410    is the type of the result and ARG0 and ARG1 are the operands of the
5411    comparison.  ARG1 must be a TREE_REAL_CST.
5412
5413    The function returns the constant folded tree if a simplification
5414    can be made, and NULL_TREE otherwise.  */
5415
5416 static tree
5417 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
5418                      tree type, tree arg0, tree arg1)
5419 {
5420   REAL_VALUE_TYPE c;
5421
5422   if (BUILTIN_SQRT_P (fcode))
5423     {
5424       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
5425       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
5426
5427       c = TREE_REAL_CST (arg1);
5428       if (REAL_VALUE_NEGATIVE (c))
5429         {
5430           /* sqrt(x) < y is always false, if y is negative.  */
5431           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
5432             return omit_one_operand (type, integer_zero_node, arg);
5433
5434           /* sqrt(x) > y is always true, if y is negative and we
5435              don't care about NaNs, i.e. negative values of x.  */
5436           if (code == NE_EXPR || !HONOR_NANS (mode))
5437             return omit_one_operand (type, integer_one_node, arg);
5438
5439           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
5440           return fold (build2 (GE_EXPR, type, arg,
5441                                build_real (TREE_TYPE (arg), dconst0)));
5442         }
5443       else if (code == GT_EXPR || code == GE_EXPR)
5444         {
5445           REAL_VALUE_TYPE c2;
5446
5447           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5448           real_convert (&c2, mode, &c2);
5449
5450           if (REAL_VALUE_ISINF (c2))
5451             {
5452               /* sqrt(x) > y is x == +Inf, when y is very large.  */
5453               if (HONOR_INFINITIES (mode))
5454                 return fold (build2 (EQ_EXPR, type, arg,
5455                                      build_real (TREE_TYPE (arg), c2)));
5456
5457               /* sqrt(x) > y is always false, when y is very large
5458                  and we don't care about infinities.  */
5459               return omit_one_operand (type, integer_zero_node, arg);
5460             }
5461
5462           /* sqrt(x) > c is the same as x > c*c.  */
5463           return fold (build2 (code, type, arg,
5464                                build_real (TREE_TYPE (arg), c2)));
5465         }
5466       else if (code == LT_EXPR || code == LE_EXPR)
5467         {
5468           REAL_VALUE_TYPE c2;
5469
5470           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5471           real_convert (&c2, mode, &c2);
5472
5473           if (REAL_VALUE_ISINF (c2))
5474             {
5475               /* sqrt(x) < y is always true, when y is a very large
5476                  value and we don't care about NaNs or Infinities.  */
5477               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
5478                 return omit_one_operand (type, integer_one_node, arg);
5479
5480               /* sqrt(x) < y is x != +Inf when y is very large and we
5481                  don't care about NaNs.  */
5482               if (! HONOR_NANS (mode))
5483                 return fold (build2 (NE_EXPR, type, arg,
5484                                      build_real (TREE_TYPE (arg), c2)));
5485
5486               /* sqrt(x) < y is x >= 0 when y is very large and we
5487                  don't care about Infinities.  */
5488               if (! HONOR_INFINITIES (mode))
5489                 return fold (build2 (GE_EXPR, type, arg,
5490                                      build_real (TREE_TYPE (arg), dconst0)));
5491
5492               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
5493               if (lang_hooks.decls.global_bindings_p () != 0
5494                   || CONTAINS_PLACEHOLDER_P (arg))
5495                 return NULL_TREE;
5496
5497               arg = save_expr (arg);
5498               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5499                                    fold (build2 (GE_EXPR, type, arg,
5500                                                  build_real (TREE_TYPE (arg),
5501                                                              dconst0))),
5502                                    fold (build2 (NE_EXPR, type, arg,
5503                                                  build_real (TREE_TYPE (arg),
5504                                                              c2)))));
5505             }
5506
5507           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
5508           if (! HONOR_NANS (mode))
5509             return fold (build2 (code, type, arg,
5510                                  build_real (TREE_TYPE (arg), c2)));
5511
5512           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
5513           if (lang_hooks.decls.global_bindings_p () == 0
5514               && ! CONTAINS_PLACEHOLDER_P (arg))
5515             {
5516               arg = save_expr (arg);
5517               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5518                                    fold (build2 (GE_EXPR, type, arg,
5519                                                  build_real (TREE_TYPE (arg),
5520                                                              dconst0))),
5521                                    fold (build2 (code, type, arg,
5522                                                  build_real (TREE_TYPE (arg),
5523                                                              c2)))));
5524             }
5525         }
5526     }
5527
5528   return NULL_TREE;
5529 }
5530
5531 /* Subroutine of fold() that optimizes comparisons against Infinities,
5532    either +Inf or -Inf.
5533
5534    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5535    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5536    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5537
5538    The function returns the constant folded tree if a simplification
5539    can be made, and NULL_TREE otherwise.  */
5540
5541 static tree
5542 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5543 {
5544   enum machine_mode mode;
5545   REAL_VALUE_TYPE max;
5546   tree temp;
5547   bool neg;
5548
5549   mode = TYPE_MODE (TREE_TYPE (arg0));
5550
5551   /* For negative infinity swap the sense of the comparison.  */
5552   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
5553   if (neg)
5554     code = swap_tree_comparison (code);
5555
5556   switch (code)
5557     {
5558     case GT_EXPR:
5559       /* x > +Inf is always false, if with ignore sNANs.  */
5560       if (HONOR_SNANS (mode))
5561         return NULL_TREE;
5562       return omit_one_operand (type, integer_zero_node, arg0);
5563
5564     case LE_EXPR:
5565       /* x <= +Inf is always true, if we don't case about NaNs.  */
5566       if (! HONOR_NANS (mode))
5567         return omit_one_operand (type, integer_one_node, arg0);
5568
5569       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
5570       if (lang_hooks.decls.global_bindings_p () == 0
5571           && ! CONTAINS_PLACEHOLDER_P (arg0))
5572         {
5573           arg0 = save_expr (arg0);
5574           return fold (build2 (EQ_EXPR, type, arg0, arg0));
5575         }
5576       break;
5577
5578     case EQ_EXPR:
5579     case GE_EXPR:
5580       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
5581       real_maxval (&max, neg, mode);
5582       return fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5583                            arg0, build_real (TREE_TYPE (arg0), max)));
5584
5585     case LT_EXPR:
5586       /* x < +Inf is always equal to x <= DBL_MAX.  */
5587       real_maxval (&max, neg, mode);
5588       return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5589                            arg0, build_real (TREE_TYPE (arg0), max)));
5590
5591     case NE_EXPR:
5592       /* x != +Inf is always equal to !(x > DBL_MAX).  */
5593       real_maxval (&max, neg, mode);
5594       if (! HONOR_NANS (mode))
5595         return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5596                              arg0, build_real (TREE_TYPE (arg0), max)));
5597
5598       /* The transformation below creates non-gimple code and thus is
5599          not appropriate if we are in gimple form.  */
5600       if (in_gimple_form)
5601         return NULL_TREE;
5602
5603       temp = fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5604                            arg0, build_real (TREE_TYPE (arg0), max)));
5605       return fold (build1 (TRUTH_NOT_EXPR, type, temp));
5606
5607     default:
5608       break;
5609     }
5610
5611   return NULL_TREE;
5612 }
5613
5614 /* Subroutine of fold() that optimizes comparisons of a division by
5615    a nonzero integer constant against an integer constant, i.e.
5616    X/C1 op C2.
5617
5618    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5619    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5620    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5621
5622    The function returns the constant folded tree if a simplification
5623    can be made, and NULL_TREE otherwise.  */
5624
5625 static tree
5626 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5627 {
5628   tree prod, tmp, hi, lo;
5629   tree arg00 = TREE_OPERAND (arg0, 0);
5630   tree arg01 = TREE_OPERAND (arg0, 1);
5631   unsigned HOST_WIDE_INT lpart;
5632   HOST_WIDE_INT hpart;
5633   int overflow;
5634
5635   /* We have to do this the hard way to detect unsigned overflow.
5636      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
5637   overflow = mul_double (TREE_INT_CST_LOW (arg01),
5638                          TREE_INT_CST_HIGH (arg01),
5639                          TREE_INT_CST_LOW (arg1),
5640                          TREE_INT_CST_HIGH (arg1), &lpart, &hpart);
5641   prod = build_int_2 (lpart, hpart);
5642   TREE_TYPE (prod) = TREE_TYPE (arg00);
5643   TREE_OVERFLOW (prod) = force_fit_type (prod, overflow)
5644                          || TREE_INT_CST_HIGH (prod) != hpart
5645                          || TREE_INT_CST_LOW (prod) != lpart;
5646   TREE_CONSTANT_OVERFLOW (prod) = TREE_OVERFLOW (prod);
5647
5648   if (TYPE_UNSIGNED (TREE_TYPE (arg0)))
5649     {
5650       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5651       lo = prod;
5652
5653       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
5654       overflow = add_double (TREE_INT_CST_LOW (prod),
5655                              TREE_INT_CST_HIGH (prod),
5656                              TREE_INT_CST_LOW (tmp),
5657                              TREE_INT_CST_HIGH (tmp),
5658                              &lpart, &hpart);
5659       hi = build_int_2 (lpart, hpart);
5660       TREE_TYPE (hi) = TREE_TYPE (arg00);
5661       TREE_OVERFLOW (hi) = force_fit_type (hi, overflow)
5662                            || TREE_INT_CST_HIGH (hi) != hpart
5663                            || TREE_INT_CST_LOW (hi) != lpart
5664                            || TREE_OVERFLOW (prod);
5665       TREE_CONSTANT_OVERFLOW (hi) = TREE_OVERFLOW (hi);
5666     }
5667   else if (tree_int_cst_sgn (arg01) >= 0)
5668     {
5669       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5670       switch (tree_int_cst_sgn (arg1))
5671         {
5672         case -1:
5673           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5674           hi = prod;
5675           break;
5676
5677         case  0:
5678           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
5679           hi = tmp;
5680           break;
5681
5682         case  1:
5683           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5684           lo = prod;
5685           break;
5686
5687         default:
5688           abort ();
5689         }
5690     }
5691   else
5692     {
5693       tmp = int_const_binop (PLUS_EXPR, arg01, integer_one_node, 0);
5694       switch (tree_int_cst_sgn (arg1))
5695         {
5696         case -1:
5697           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5698           lo = prod;
5699           break;
5700
5701         case  0:
5702           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
5703           lo = tmp;
5704           break;
5705
5706         case  1:
5707           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5708           hi = prod;
5709           break;
5710
5711         default:
5712           abort ();
5713         }
5714     }
5715
5716   switch (code)
5717     {
5718     case EQ_EXPR:
5719       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5720         return omit_one_operand (type, integer_zero_node, arg00);
5721       if (TREE_OVERFLOW (hi))
5722         return fold (build2 (GE_EXPR, type, arg00, lo));
5723       if (TREE_OVERFLOW (lo))
5724         return fold (build2 (LE_EXPR, type, arg00, hi));
5725       return build_range_check (type, arg00, 1, lo, hi);
5726
5727     case NE_EXPR:
5728       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5729         return omit_one_operand (type, integer_one_node, arg00);
5730       if (TREE_OVERFLOW (hi))
5731         return fold (build2 (LT_EXPR, type, arg00, lo));
5732       if (TREE_OVERFLOW (lo))
5733         return fold (build2 (GT_EXPR, type, arg00, hi));
5734       return build_range_check (type, arg00, 0, lo, hi);
5735
5736     case LT_EXPR:
5737       if (TREE_OVERFLOW (lo))
5738         return omit_one_operand (type, integer_zero_node, arg00);
5739       return fold (build2 (LT_EXPR, type, arg00, lo));
5740
5741     case LE_EXPR:
5742       if (TREE_OVERFLOW (hi))
5743         return omit_one_operand (type, integer_one_node, arg00);
5744       return fold (build2 (LE_EXPR, type, arg00, hi));
5745
5746     case GT_EXPR:
5747       if (TREE_OVERFLOW (hi))
5748         return omit_one_operand (type, integer_zero_node, arg00);
5749       return fold (build2 (GT_EXPR, type, arg00, hi));
5750
5751     case GE_EXPR:
5752       if (TREE_OVERFLOW (lo))
5753         return omit_one_operand (type, integer_one_node, arg00);
5754       return fold (build2 (GE_EXPR, type, arg00, lo));
5755
5756     default:
5757       break;
5758     }
5759
5760   return NULL_TREE;
5761 }
5762
5763
5764 /* If CODE with arguments ARG0 and ARG1 represents a single bit
5765    equality/inequality test, then return a simplified form of
5766    the test using shifts and logical operations.  Otherwise return
5767    NULL.  TYPE is the desired result type.  */
5768
5769 tree
5770 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
5771                       tree result_type)
5772 {
5773   /* If this is a TRUTH_NOT_EXPR, it may have a single bit test inside
5774      operand 0.  */
5775   if (code == TRUTH_NOT_EXPR)
5776     {
5777       code = TREE_CODE (arg0);
5778       if (code != NE_EXPR && code != EQ_EXPR)
5779         return NULL_TREE;
5780
5781       /* Extract the arguments of the EQ/NE.  */
5782       arg1 = TREE_OPERAND (arg0, 1);
5783       arg0 = TREE_OPERAND (arg0, 0);
5784
5785       /* This requires us to invert the code.  */
5786       code = (code == EQ_EXPR ? NE_EXPR : EQ_EXPR);
5787     }
5788
5789   /* If this is testing a single bit, we can optimize the test.  */
5790   if ((code == NE_EXPR || code == EQ_EXPR)
5791       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
5792       && integer_pow2p (TREE_OPERAND (arg0, 1)))
5793     {
5794       tree inner = TREE_OPERAND (arg0, 0);
5795       tree type = TREE_TYPE (arg0);
5796       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
5797       enum machine_mode operand_mode = TYPE_MODE (type);
5798       int ops_unsigned;
5799       tree signed_type, unsigned_type, intermediate_type;
5800       tree arg00;
5801
5802       /* If we have (A & C) != 0 where C is the sign bit of A, convert
5803          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
5804       arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
5805       if (arg00 != NULL_TREE
5806           /* This is only a win if casting to a signed type is cheap,
5807              i.e. when arg00's type is not a partial mode.  */
5808           && TYPE_PRECISION (TREE_TYPE (arg00))
5809              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
5810         {
5811           tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
5812           return fold (build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
5813                                result_type, fold_convert (stype, arg00),
5814                                fold_convert (stype, integer_zero_node)));
5815         }
5816
5817       /* Otherwise we have (A & C) != 0 where C is a single bit,
5818          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
5819          Similarly for (A & C) == 0.  */
5820
5821       /* If INNER is a right shift of a constant and it plus BITNUM does
5822          not overflow, adjust BITNUM and INNER.  */
5823       if (TREE_CODE (inner) == RSHIFT_EXPR
5824           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
5825           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
5826           && bitnum < TYPE_PRECISION (type)
5827           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
5828                                    bitnum - TYPE_PRECISION (type)))
5829         {
5830           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
5831           inner = TREE_OPERAND (inner, 0);
5832         }
5833
5834       /* If we are going to be able to omit the AND below, we must do our
5835          operations as unsigned.  If we must use the AND, we have a choice.
5836          Normally unsigned is faster, but for some machines signed is.  */
5837 #ifdef LOAD_EXTEND_OP
5838       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1);
5839 #else
5840       ops_unsigned = 1;
5841 #endif
5842
5843       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
5844       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
5845       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
5846       inner = fold_convert (intermediate_type, inner);
5847
5848       if (bitnum != 0)
5849         inner = build2 (RSHIFT_EXPR, intermediate_type,
5850                         inner, size_int (bitnum));
5851
5852       if (code == EQ_EXPR)
5853         inner = build2 (BIT_XOR_EXPR, intermediate_type,
5854                         inner, integer_one_node);
5855
5856       /* Put the AND last so it can combine with more things.  */
5857       inner = build2 (BIT_AND_EXPR, intermediate_type,
5858                       inner, integer_one_node);
5859
5860       /* Make sure to return the proper type.  */
5861       inner = fold_convert (result_type, inner);
5862
5863       return inner;
5864     }
5865   return NULL_TREE;
5866 }
5867
5868 /* Check whether we are allowed to reorder operands arg0 and arg1,
5869    such that the evaluation of arg1 occurs before arg0.  */
5870
5871 static bool
5872 reorder_operands_p (tree arg0, tree arg1)
5873 {
5874   if (! flag_evaluation_order)
5875     return true;
5876   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
5877     return true;
5878   return ! TREE_SIDE_EFFECTS (arg0)
5879          && ! TREE_SIDE_EFFECTS (arg1);
5880 }
5881
5882 /* Test whether it is preferable two swap two operands, ARG0 and
5883    ARG1, for example because ARG0 is an integer constant and ARG1
5884    isn't.  If REORDER is true, only recommend swapping if we can
5885    evaluate the operands in reverse order.  */
5886
5887 bool
5888 tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
5889 {
5890   STRIP_SIGN_NOPS (arg0);
5891   STRIP_SIGN_NOPS (arg1);
5892
5893   if (TREE_CODE (arg1) == INTEGER_CST)
5894     return 0;
5895   if (TREE_CODE (arg0) == INTEGER_CST)
5896     return 1;
5897
5898   if (TREE_CODE (arg1) == REAL_CST)
5899     return 0;
5900   if (TREE_CODE (arg0) == REAL_CST)
5901     return 1;
5902
5903   if (TREE_CODE (arg1) == COMPLEX_CST)
5904     return 0;
5905   if (TREE_CODE (arg0) == COMPLEX_CST)
5906     return 1;
5907
5908   if (TREE_CONSTANT (arg1))
5909     return 0;
5910   if (TREE_CONSTANT (arg0))
5911     return 1;
5912
5913   if (optimize_size)
5914     return 0;
5915
5916   if (reorder && flag_evaluation_order
5917       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5918     return 0;
5919
5920   if (DECL_P (arg1))
5921     return 0;
5922   if (DECL_P (arg0))
5923     return 1;
5924
5925   if (reorder && flag_evaluation_order
5926       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5927     return 0;
5928
5929   if (DECL_P (arg1))
5930     return 0;
5931   if (DECL_P (arg0))
5932     return 1;
5933
5934   /* It is preferable to swap two SSA_NAME to ensure a canonical form
5935      for commutative and comparison operators.  Ensuring a canonical
5936      form allows the optimizers to find additional redundancies without
5937      having to explicitly check for both orderings.  */
5938   if (TREE_CODE (arg0) == SSA_NAME
5939       && TREE_CODE (arg1) == SSA_NAME
5940       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
5941     return 1;
5942
5943   return 0;
5944 }
5945
5946 /* Perform constant folding and related simplification of EXPR.
5947    The related simplifications include x*1 => x, x*0 => 0, etc.,
5948    and application of the associative law.
5949    NOP_EXPR conversions may be removed freely (as long as we
5950    are careful not to change the type of the overall expression).
5951    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
5952    but we can constant-fold them if they have constant operands.  */
5953
5954 #ifdef ENABLE_FOLD_CHECKING
5955 # define fold(x) fold_1 (x)
5956 static tree fold_1 (tree);
5957 static
5958 #endif
5959 tree
5960 fold (tree expr)
5961 {
5962   const tree t = expr;
5963   const tree type = TREE_TYPE (expr);
5964   tree t1 = NULL_TREE;
5965   tree tem;
5966   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
5967   enum tree_code code = TREE_CODE (t);
5968   int kind = TREE_CODE_CLASS (code);
5969
5970   /* WINS will be nonzero when the switch is done
5971      if all operands are constant.  */
5972   int wins = 1;
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
7186       /* ~X | X is -1.  */
7187       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7188           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7189         {
7190           t1 = build_int_2 (-1, -1);
7191           TREE_TYPE (t1) = type;
7192           force_fit_type (t1, 0);
7193           return omit_one_operand (type, t1, arg1);
7194         }
7195
7196       /* X | ~X is -1.  */
7197       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7198           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7199         {
7200           t1 = build_int_2 (-1, -1);
7201           TREE_TYPE (t1) = type;
7202           force_fit_type (t1, 0);
7203           return omit_one_operand (type, t1, arg0);
7204         }
7205
7206       t1 = distribute_bit_expr (code, type, arg0, arg1);
7207       if (t1 != NULL_TREE)
7208         return t1;
7209
7210       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
7211
7212          This results in more efficient code for machines without a NAND
7213          instruction.  Combine will canonicalize to the first form
7214          which will allow use of NAND instructions provided by the
7215          backend if they exist.  */
7216       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7217           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7218         {
7219           return fold (build1 (BIT_NOT_EXPR, type,
7220                                build2 (BIT_AND_EXPR, type,
7221                                        TREE_OPERAND (arg0, 0),
7222                                        TREE_OPERAND (arg1, 0))));
7223         }
7224
7225       /* See if this can be simplified into a rotate first.  If that
7226          is unsuccessful continue in the association code.  */
7227       goto bit_rotate;
7228
7229     case BIT_XOR_EXPR:
7230       if (integer_zerop (arg1))
7231         return non_lvalue (fold_convert (type, arg0));
7232       if (integer_all_onesp (arg1))
7233         return fold (build1 (BIT_NOT_EXPR, type, arg0));
7234       if (operand_equal_p (arg0, arg1, 0))
7235         return omit_one_operand (type, integer_zero_node, arg0);
7236
7237       /* ~X ^ X is -1.  */
7238       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7239           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7240         {
7241           t1 = build_int_2 (-1, -1);
7242           TREE_TYPE (t1) = type;
7243           force_fit_type (t1, 0);
7244           return omit_one_operand (type, t1, arg1);
7245         }
7246
7247       /* X ^ ~X is -1.  */
7248       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7249           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7250         {
7251           t1 = build_int_2 (-1, -1);
7252           TREE_TYPE (t1) = type;
7253           force_fit_type (t1, 0);
7254           return omit_one_operand (type, t1, arg0);
7255         }
7256
7257       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
7258          with a constant, and the two constants have no bits in common,
7259          we should treat this as a BIT_IOR_EXPR since this may produce more
7260          simplifications.  */
7261       if (TREE_CODE (arg0) == BIT_AND_EXPR
7262           && TREE_CODE (arg1) == BIT_AND_EXPR
7263           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7264           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7265           && integer_zerop (const_binop (BIT_AND_EXPR,
7266                                          TREE_OPERAND (arg0, 1),
7267                                          TREE_OPERAND (arg1, 1), 0)))
7268         {
7269           code = BIT_IOR_EXPR;
7270           goto bit_ior;
7271         }
7272
7273       /* See if this can be simplified into a rotate first.  If that
7274          is unsuccessful continue in the association code.  */
7275       goto bit_rotate;
7276
7277     case BIT_AND_EXPR:
7278       if (integer_all_onesp (arg1))
7279         return non_lvalue (fold_convert (type, arg0));
7280       if (integer_zerop (arg1))
7281         return omit_one_operand (type, arg1, arg0);
7282       if (operand_equal_p (arg0, arg1, 0))
7283         return non_lvalue (fold_convert (type, arg0));
7284
7285       /* ~X & X is always zero.  */
7286       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7287           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7288         return omit_one_operand (type, integer_zero_node, arg1);
7289
7290       /* X & ~X is always zero.  */
7291       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7292           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7293         return omit_one_operand (type, integer_zero_node, arg0);
7294
7295       t1 = distribute_bit_expr (code, type, arg0, arg1);
7296       if (t1 != NULL_TREE)
7297         return t1;
7298       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
7299       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
7300           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7301         {
7302           unsigned int prec
7303             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
7304
7305           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
7306               && (~TREE_INT_CST_LOW (arg1)
7307                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
7308             return fold_convert (type, TREE_OPERAND (arg0, 0));
7309         }
7310
7311       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
7312
7313          This results in more efficient code for machines without a NOR
7314          instruction.  Combine will canonicalize to the first form
7315          which will allow use of NOR instructions provided by the
7316          backend if they exist.  */
7317       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7318           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7319         {
7320           return fold (build1 (BIT_NOT_EXPR, type,
7321                                build2 (BIT_IOR_EXPR, type,
7322                                        TREE_OPERAND (arg0, 0),
7323                                        TREE_OPERAND (arg1, 0))));
7324         }
7325
7326       goto associate;
7327
7328     case RDIV_EXPR:
7329       /* Don't touch a floating-point divide by zero unless the mode
7330          of the constant can represent infinity.  */
7331       if (TREE_CODE (arg1) == REAL_CST
7332           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
7333           && real_zerop (arg1))
7334         return t;
7335
7336       /* (-A) / (-B) -> A / B  */
7337       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7338         return fold (build2 (RDIV_EXPR, type,
7339                              TREE_OPERAND (arg0, 0),
7340                              negate_expr (arg1)));
7341       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7342         return fold (build2 (RDIV_EXPR, type,
7343                              negate_expr (arg0),
7344                              TREE_OPERAND (arg1, 0)));
7345
7346       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
7347       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7348           && real_onep (arg1))
7349         return non_lvalue (fold_convert (type, arg0));
7350
7351       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
7352       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7353           && real_minus_onep (arg1))
7354         return non_lvalue (fold_convert (type, negate_expr (arg0)));
7355
7356       /* If ARG1 is a constant, we can convert this to a multiply by the
7357          reciprocal.  This does not have the same rounding properties,
7358          so only do this if -funsafe-math-optimizations.  We can actually
7359          always safely do it if ARG1 is a power of two, but it's hard to
7360          tell if it is or not in a portable manner.  */
7361       if (TREE_CODE (arg1) == REAL_CST)
7362         {
7363           if (flag_unsafe_math_optimizations
7364               && 0 != (tem = const_binop (code, build_real (type, dconst1),
7365                                           arg1, 0)))
7366             return fold (build2 (MULT_EXPR, type, arg0, tem));
7367           /* Find the reciprocal if optimizing and the result is exact.  */
7368           if (optimize)
7369             {
7370               REAL_VALUE_TYPE r;
7371               r = TREE_REAL_CST (arg1);
7372               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
7373                 {
7374                   tem = build_real (type, r);
7375                   return fold (build2 (MULT_EXPR, type, arg0, tem));
7376                 }
7377             }
7378         }
7379       /* Convert A/B/C to A/(B*C).  */
7380       if (flag_unsafe_math_optimizations
7381           && TREE_CODE (arg0) == RDIV_EXPR)
7382         return fold (build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
7383                              fold (build2 (MULT_EXPR, type,
7384                                            TREE_OPERAND (arg0, 1), arg1))));
7385
7386       /* Convert A/(B/C) to (A/B)*C.  */
7387       if (flag_unsafe_math_optimizations
7388           && TREE_CODE (arg1) == RDIV_EXPR)
7389         return fold (build2 (MULT_EXPR, type,
7390                              fold (build2 (RDIV_EXPR, type, arg0,
7391                                            TREE_OPERAND (arg1, 0))),
7392                              TREE_OPERAND (arg1, 1)));
7393
7394       /* Convert C1/(X*C2) into (C1/C2)/X.  */
7395       if (flag_unsafe_math_optimizations
7396           && TREE_CODE (arg1) == MULT_EXPR
7397           && TREE_CODE (arg0) == REAL_CST
7398           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
7399         {
7400           tree tem = const_binop (RDIV_EXPR, arg0,
7401                                   TREE_OPERAND (arg1, 1), 0);
7402           if (tem)
7403             return fold (build2 (RDIV_EXPR, type, tem,
7404                                  TREE_OPERAND (arg1, 0)));
7405         }
7406
7407       if (flag_unsafe_math_optimizations)
7408         {
7409           enum built_in_function fcode = builtin_mathfn_code (arg1);
7410           /* Optimize x/expN(y) into x*expN(-y).  */
7411           if (BUILTIN_EXPONENT_P (fcode))
7412             {
7413               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7414               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
7415               tree arglist = build_tree_list (NULL_TREE,
7416                                               fold_convert (type, arg));
7417               arg1 = build_function_call_expr (expfn, arglist);
7418               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7419             }
7420
7421           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
7422           if (fcode == BUILT_IN_POW
7423               || fcode == BUILT_IN_POWF
7424               || fcode == BUILT_IN_POWL)
7425             {
7426               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7427               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7428               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
7429               tree neg11 = fold_convert (type, negate_expr (arg11));
7430               tree arglist = tree_cons(NULL_TREE, arg10,
7431                                        build_tree_list (NULL_TREE, neg11));
7432               arg1 = build_function_call_expr (powfn, arglist);
7433               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7434             }
7435         }
7436
7437       if (flag_unsafe_math_optimizations)
7438         {
7439           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7440           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7441
7442           /* Optimize sin(x)/cos(x) as tan(x).  */
7443           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
7444                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
7445                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
7446               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7447                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7448             {
7449               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7450
7451               if (tanfn != NULL_TREE)
7452                 return build_function_call_expr (tanfn,
7453                                                  TREE_OPERAND (arg0, 1));
7454             }
7455
7456           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
7457           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
7458                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
7459                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
7460               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7461                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7462             {
7463               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7464
7465               if (tanfn != NULL_TREE)
7466                 {
7467                   tree tmp = TREE_OPERAND (arg0, 1);
7468                   tmp = build_function_call_expr (tanfn, tmp);
7469                   return fold (build2 (RDIV_EXPR, type,
7470                                        build_real (type, dconst1), tmp));
7471                 }
7472             }
7473
7474           /* Optimize pow(x,c)/x as pow(x,c-1).  */
7475           if (fcode0 == BUILT_IN_POW
7476               || fcode0 == BUILT_IN_POWF
7477               || fcode0 == BUILT_IN_POWL)
7478             {
7479               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7480               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7481               if (TREE_CODE (arg01) == REAL_CST
7482                   && ! TREE_CONSTANT_OVERFLOW (arg01)
7483                   && operand_equal_p (arg1, arg00, 0))
7484                 {
7485                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7486                   REAL_VALUE_TYPE c;
7487                   tree arg, arglist;
7488
7489                   c = TREE_REAL_CST (arg01);
7490                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
7491                   arg = build_real (type, c);
7492                   arglist = build_tree_list (NULL_TREE, arg);
7493                   arglist = tree_cons (NULL_TREE, arg1, arglist);
7494                   return build_function_call_expr (powfn, arglist);
7495                 }
7496             }
7497         }
7498       goto binary;
7499
7500     case TRUNC_DIV_EXPR:
7501     case ROUND_DIV_EXPR:
7502     case FLOOR_DIV_EXPR:
7503     case CEIL_DIV_EXPR:
7504     case EXACT_DIV_EXPR:
7505       if (integer_onep (arg1))
7506         return non_lvalue (fold_convert (type, arg0));
7507       if (integer_zerop (arg1))
7508         return t;
7509       /* X / -1 is -X.  */
7510       if (!TYPE_UNSIGNED (type)
7511           && TREE_CODE (arg1) == INTEGER_CST
7512           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7513           && TREE_INT_CST_HIGH (arg1) == -1)
7514         return fold_convert (type, negate_expr (arg0));
7515
7516       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
7517          operation, EXACT_DIV_EXPR.
7518
7519          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
7520          At one time others generated faster code, it's not clear if they do
7521          after the last round to changes to the DIV code in expmed.c.  */
7522       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
7523           && multiple_of_p (type, arg0, arg1))
7524         return fold (build2 (EXACT_DIV_EXPR, type, arg0, arg1));
7525
7526       if (TREE_CODE (arg1) == INTEGER_CST
7527           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7528                                          code, NULL_TREE)))
7529         return fold_convert (type, tem);
7530
7531       goto binary;
7532
7533     case CEIL_MOD_EXPR:
7534     case FLOOR_MOD_EXPR:
7535     case ROUND_MOD_EXPR:
7536     case TRUNC_MOD_EXPR:
7537       if (integer_onep (arg1))
7538         return omit_one_operand (type, integer_zero_node, arg0);
7539       if (integer_zerop (arg1))
7540         return t;
7541       /* X % -1 is zero.  */
7542       if (!TYPE_UNSIGNED (type)
7543           && TREE_CODE (arg1) == INTEGER_CST
7544           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7545           && TREE_INT_CST_HIGH (arg1) == -1)
7546         return omit_one_operand (type, integer_zero_node, arg0);
7547
7548       if (TREE_CODE (arg1) == INTEGER_CST
7549           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7550                                          code, NULL_TREE)))
7551         return fold_convert (type, tem);
7552
7553       goto binary;
7554
7555     case LROTATE_EXPR:
7556     case RROTATE_EXPR:
7557       if (integer_all_onesp (arg0))
7558         return omit_one_operand (type, arg0, arg1);
7559       goto shift;
7560
7561     case RSHIFT_EXPR:
7562       /* Optimize -1 >> x for arithmetic right shifts.  */
7563       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
7564         return omit_one_operand (type, arg0, arg1);
7565       /* ... fall through ...  */
7566
7567     case LSHIFT_EXPR:
7568     shift:
7569       if (integer_zerop (arg1))
7570         return non_lvalue (fold_convert (type, arg0));
7571       if (integer_zerop (arg0))
7572         return omit_one_operand (type, arg0, arg1);
7573
7574       /* Since negative shift count is not well-defined,
7575          don't try to compute it in the compiler.  */
7576       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
7577         return t;
7578       /* Rewrite an LROTATE_EXPR by a constant into an
7579          RROTATE_EXPR by a new constant.  */
7580       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
7581         {
7582           tree tem = build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
7583           tem = fold_convert (TREE_TYPE (arg1), tem);
7584           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
7585           return fold (build2 (RROTATE_EXPR, type, arg0, tem));
7586         }
7587
7588       /* If we have a rotate of a bit operation with the rotate count and
7589          the second operand of the bit operation both constant,
7590          permute the two operations.  */
7591       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7592           && (TREE_CODE (arg0) == BIT_AND_EXPR
7593               || TREE_CODE (arg0) == BIT_IOR_EXPR
7594               || TREE_CODE (arg0) == BIT_XOR_EXPR)
7595           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7596         return fold (build2 (TREE_CODE (arg0), type,
7597                              fold (build2 (code, type,
7598                                            TREE_OPERAND (arg0, 0), arg1)),
7599                              fold (build2 (code, type,
7600                                            TREE_OPERAND (arg0, 1), arg1))));
7601
7602       /* Two consecutive rotates adding up to the width of the mode can
7603          be ignored.  */
7604       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7605           && TREE_CODE (arg0) == RROTATE_EXPR
7606           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7607           && TREE_INT_CST_HIGH (arg1) == 0
7608           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
7609           && ((TREE_INT_CST_LOW (arg1)
7610                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
7611               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
7612         return TREE_OPERAND (arg0, 0);
7613
7614       goto binary;
7615
7616     case MIN_EXPR:
7617       if (operand_equal_p (arg0, arg1, 0))
7618         return omit_one_operand (type, arg0, arg1);
7619       if (INTEGRAL_TYPE_P (type)
7620           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
7621         return omit_one_operand (type, arg1, arg0);
7622       goto associate;
7623
7624     case MAX_EXPR:
7625       if (operand_equal_p (arg0, arg1, 0))
7626         return omit_one_operand (type, arg0, arg1);
7627       if (INTEGRAL_TYPE_P (type)
7628           && TYPE_MAX_VALUE (type)
7629           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
7630         return omit_one_operand (type, arg1, arg0);
7631       goto associate;
7632
7633     case TRUTH_NOT_EXPR:
7634       /* The argument to invert_truthvalue must have Boolean type.  */
7635       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7636           arg0 = fold_convert (boolean_type_node, arg0);
7637
7638       /* Note that the operand of this must be an int
7639          and its values must be 0 or 1.
7640          ("true" is a fixed value perhaps depending on the language,
7641          but we don't handle values other than 1 correctly yet.)  */
7642       tem = invert_truthvalue (arg0);
7643       /* Avoid infinite recursion.  */
7644       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
7645         {
7646           tem = fold_single_bit_test (code, arg0, arg1, type);
7647           if (tem)
7648             return tem;
7649           return t;
7650         }
7651       return fold_convert (type, tem);
7652
7653     case TRUTH_ANDIF_EXPR:
7654       /* Note that the operands of this must be ints
7655          and their values must be 0 or 1.
7656          ("true" is a fixed value perhaps depending on the language.)  */
7657       /* If first arg is constant zero, return it.  */
7658       if (integer_zerop (arg0))
7659         return fold_convert (type, arg0);
7660     case TRUTH_AND_EXPR:
7661       /* If either arg is constant true, drop it.  */
7662       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7663         return non_lvalue (fold_convert (type, arg1));
7664       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
7665           /* Preserve sequence points.  */
7666           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7667         return non_lvalue (fold_convert (type, arg0));
7668       /* If second arg is constant zero, result is zero, but first arg
7669          must be evaluated.  */
7670       if (integer_zerop (arg1))
7671         return omit_one_operand (type, arg1, arg0);
7672       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
7673          case will be handled here.  */
7674       if (integer_zerop (arg0))
7675         return omit_one_operand (type, arg0, arg1);
7676
7677       /* !X && X is always false.  */
7678       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7679           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7680         return omit_one_operand (type, integer_zero_node, arg1);
7681       /* X && !X is always false.  */
7682       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7683           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7684         return omit_one_operand (type, integer_zero_node, arg0);
7685
7686     truth_andor:
7687       /* We only do these simplifications if we are optimizing.  */
7688       if (!optimize)
7689         return t;
7690
7691       /* Check for things like (A || B) && (A || C).  We can convert this
7692          to A || (B && C).  Note that either operator can be any of the four
7693          truth and/or operations and the transformation will still be
7694          valid.   Also note that we only care about order for the
7695          ANDIF and ORIF operators.  If B contains side effects, this
7696          might change the truth-value of A.  */
7697       if (TREE_CODE (arg0) == TREE_CODE (arg1)
7698           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7699               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7700               || TREE_CODE (arg0) == TRUTH_AND_EXPR
7701               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7702           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7703         {
7704           tree a00 = TREE_OPERAND (arg0, 0);
7705           tree a01 = TREE_OPERAND (arg0, 1);
7706           tree a10 = TREE_OPERAND (arg1, 0);
7707           tree a11 = TREE_OPERAND (arg1, 1);
7708           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7709                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7710                              && (code == TRUTH_AND_EXPR
7711                                  || code == TRUTH_OR_EXPR));
7712
7713           if (operand_equal_p (a00, a10, 0))
7714             return fold (build2 (TREE_CODE (arg0), type, a00,
7715                                  fold (build2 (code, type, a01, a11))));
7716           else if (commutative && operand_equal_p (a00, a11, 0))
7717             return fold (build2 (TREE_CODE (arg0), type, a00,
7718                                  fold (build2 (code, type, a01, a10))));
7719           else if (commutative && operand_equal_p (a01, a10, 0))
7720             return fold (build2 (TREE_CODE (arg0), type, a01,
7721                                  fold (build2 (code, type, a00, a11))));
7722
7723           /* This case if tricky because we must either have commutative
7724              operators or else A10 must not have side-effects.  */
7725
7726           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7727                    && operand_equal_p (a01, a11, 0))
7728             return fold (build2 (TREE_CODE (arg0), type,
7729                                  fold (build2 (code, type, a00, a10)),
7730                                  a01));
7731         }
7732
7733       /* See if we can build a range comparison.  */
7734       if (0 != (tem = fold_range_test (t)))
7735         return tem;
7736
7737       /* Check for the possibility of merging component references.  If our
7738          lhs is another similar operation, try to merge its rhs with our
7739          rhs.  Then try to merge our lhs and rhs.  */
7740       if (TREE_CODE (arg0) == code
7741           && 0 != (tem = fold_truthop (code, type,
7742                                        TREE_OPERAND (arg0, 1), arg1)))
7743         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7744
7745       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
7746         return tem;
7747
7748       return t;
7749
7750     case TRUTH_ORIF_EXPR:
7751       /* Note that the operands of this must be ints
7752          and their values must be 0 or true.
7753          ("true" is a fixed value perhaps depending on the language.)  */
7754       /* If first arg is constant true, return it.  */
7755       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7756         return fold_convert (type, arg0);
7757     case TRUTH_OR_EXPR:
7758       /* If either arg is constant zero, drop it.  */
7759       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
7760         return non_lvalue (fold_convert (type, arg1));
7761       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
7762           /* Preserve sequence points.  */
7763           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7764         return non_lvalue (fold_convert (type, arg0));
7765       /* If second arg is constant true, result is true, but we must
7766          evaluate first arg.  */
7767       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
7768         return omit_one_operand (type, arg1, arg0);
7769       /* Likewise for first arg, but note this only occurs here for
7770          TRUTH_OR_EXPR.  */
7771       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7772         return omit_one_operand (type, arg0, arg1);
7773
7774       /* !X || X is always true.  */
7775       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7776           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7777         return omit_one_operand (type, integer_one_node, arg1);
7778       /* X || !X is always true.  */
7779       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7780           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7781         return omit_one_operand (type, integer_one_node, arg0);
7782
7783       goto truth_andor;
7784
7785     case TRUTH_XOR_EXPR:
7786       /* If the second arg is constant zero, drop it.  */
7787       if (integer_zerop (arg1))
7788         return non_lvalue (fold_convert (type, arg0));
7789       /* If the second arg is constant true, this is a logical inversion.  */
7790       if (integer_onep (arg1))
7791         return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
7792       /* Identical arguments cancel to zero.  */
7793       if (operand_equal_p (arg0, arg1, 0))
7794         return omit_one_operand (type, integer_zero_node, arg0);
7795
7796       /* !X ^ X is always true.  */
7797       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7798           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7799         return omit_one_operand (type, integer_one_node, arg1);
7800
7801       /* X ^ !X is always true.  */
7802       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7803           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7804         return omit_one_operand (type, integer_one_node, arg0);
7805
7806       return t;
7807
7808     case EQ_EXPR:
7809     case NE_EXPR:
7810     case LT_EXPR:
7811     case GT_EXPR:
7812     case LE_EXPR:
7813     case GE_EXPR:
7814       /* If one arg is a real or integer constant, put it last.  */
7815       if (tree_swap_operands_p (arg0, arg1, true))
7816         return fold (build2 (swap_tree_comparison (code), type, arg1, arg0));
7817
7818       /* If this is an equality comparison of the address of a non-weak
7819          object against zero, then we know the result.  */
7820       if ((code == EQ_EXPR || code == NE_EXPR)
7821           && TREE_CODE (arg0) == ADDR_EXPR
7822           && DECL_P (TREE_OPERAND (arg0, 0))
7823           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7824           && integer_zerop (arg1))
7825         return constant_boolean_node (code != EQ_EXPR, type);
7826
7827       /* If this is an equality comparison of the address of two non-weak,
7828          unaliased symbols neither of which are extern (since we do not
7829          have access to attributes for externs), then we know the result.  */
7830       if ((code == EQ_EXPR || code == NE_EXPR)
7831           && TREE_CODE (arg0) == ADDR_EXPR
7832           && DECL_P (TREE_OPERAND (arg0, 0))
7833           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7834           && ! lookup_attribute ("alias",
7835                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
7836           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
7837           && TREE_CODE (arg1) == ADDR_EXPR
7838           && DECL_P (TREE_OPERAND (arg1, 0))
7839           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
7840           && ! lookup_attribute ("alias",
7841                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
7842           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
7843         return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
7844                                       ? code == EQ_EXPR : code != EQ_EXPR,
7845                                       type);
7846
7847       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
7848         {
7849           tree targ0 = strip_float_extensions (arg0);
7850           tree targ1 = strip_float_extensions (arg1);
7851           tree newtype = TREE_TYPE (targ0);
7852
7853           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
7854             newtype = TREE_TYPE (targ1);
7855
7856           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
7857           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
7858             return fold (build2 (code, type, fold_convert (newtype, targ0),
7859                                  fold_convert (newtype, targ1)));
7860
7861           /* (-a) CMP (-b) -> b CMP a  */
7862           if (TREE_CODE (arg0) == NEGATE_EXPR
7863               && TREE_CODE (arg1) == NEGATE_EXPR)
7864             return fold (build2 (code, type, TREE_OPERAND (arg1, 0),
7865                                  TREE_OPERAND (arg0, 0)));
7866
7867           if (TREE_CODE (arg1) == REAL_CST)
7868           {
7869             REAL_VALUE_TYPE cst;
7870             cst = TREE_REAL_CST (arg1);
7871
7872             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
7873             if (TREE_CODE (arg0) == NEGATE_EXPR)
7874               return
7875                 fold (build2 (swap_tree_comparison (code), type,
7876                               TREE_OPERAND (arg0, 0),
7877                               build_real (TREE_TYPE (arg1),
7878                                           REAL_VALUE_NEGATE (cst))));
7879
7880             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
7881             /* a CMP (-0) -> a CMP 0  */
7882             if (REAL_VALUE_MINUS_ZERO (cst))
7883               return fold (build2 (code, type, arg0,
7884                                    build_real (TREE_TYPE (arg1), dconst0)));
7885
7886             /* x != NaN is always true, other ops are always false.  */
7887             if (REAL_VALUE_ISNAN (cst)
7888                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
7889               {
7890                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
7891                 return omit_one_operand (type, tem, arg0);
7892               }
7893
7894             /* Fold comparisons against infinity.  */
7895             if (REAL_VALUE_ISINF (cst))
7896               {
7897                 tem = fold_inf_compare (code, type, arg0, arg1);
7898                 if (tem != NULL_TREE)
7899                   return tem;
7900               }
7901           }
7902
7903           /* If this is a comparison of a real constant with a PLUS_EXPR
7904              or a MINUS_EXPR of a real constant, we can convert it into a
7905              comparison with a revised real constant as long as no overflow
7906              occurs when unsafe_math_optimizations are enabled.  */
7907           if (flag_unsafe_math_optimizations
7908               && TREE_CODE (arg1) == REAL_CST
7909               && (TREE_CODE (arg0) == PLUS_EXPR
7910                   || TREE_CODE (arg0) == MINUS_EXPR)
7911               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7912               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
7913                                           ? MINUS_EXPR : PLUS_EXPR,
7914                                           arg1, TREE_OPERAND (arg0, 1), 0))
7915               && ! TREE_CONSTANT_OVERFLOW (tem))
7916             return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7917
7918           /* Likewise, we can simplify a comparison of a real constant with
7919              a MINUS_EXPR whose first operand is also a real constant, i.e.
7920              (c1 - x) < c2 becomes x > c1-c2.  */
7921           if (flag_unsafe_math_optimizations
7922               && TREE_CODE (arg1) == REAL_CST
7923               && TREE_CODE (arg0) == MINUS_EXPR
7924               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
7925               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
7926                                           arg1, 0))
7927               && ! TREE_CONSTANT_OVERFLOW (tem))
7928             return fold (build2 (swap_tree_comparison (code), type,
7929                                  TREE_OPERAND (arg0, 1), tem));
7930
7931           /* Fold comparisons against built-in math functions.  */
7932           if (TREE_CODE (arg1) == REAL_CST
7933               && flag_unsafe_math_optimizations
7934               && ! flag_errno_math)
7935             {
7936               enum built_in_function fcode = builtin_mathfn_code (arg0);
7937
7938               if (fcode != END_BUILTINS)
7939                 {
7940                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
7941                   if (tem != NULL_TREE)
7942                     return tem;
7943                 }
7944             }
7945         }
7946
7947       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
7948       if (TREE_CONSTANT (arg1)
7949           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
7950               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
7951           /* This optimization is invalid for ordered comparisons
7952              if CONST+INCR overflows or if foo+incr might overflow.
7953              This optimization is invalid for floating point due to rounding.
7954              For pointer types we assume overflow doesn't happen.  */
7955           && (POINTER_TYPE_P (TREE_TYPE (arg0))
7956               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
7957                   && (code == EQ_EXPR || code == NE_EXPR))))
7958         {
7959           tree varop, newconst;
7960
7961           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
7962             {
7963               newconst = fold (build2 (PLUS_EXPR, TREE_TYPE (arg0),
7964                                        arg1, TREE_OPERAND (arg0, 1)));
7965               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
7966                               TREE_OPERAND (arg0, 0),
7967                               TREE_OPERAND (arg0, 1));
7968             }
7969           else
7970             {
7971               newconst = fold (build2 (MINUS_EXPR, TREE_TYPE (arg0),
7972                                        arg1, TREE_OPERAND (arg0, 1)));
7973               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
7974                               TREE_OPERAND (arg0, 0),
7975                               TREE_OPERAND (arg0, 1));
7976             }
7977
7978
7979           /* If VAROP is a reference to a bitfield, we must mask
7980              the constant by the width of the field.  */
7981           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
7982               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
7983               && host_integerp (DECL_SIZE (TREE_OPERAND
7984                                            (TREE_OPERAND (varop, 0), 1)), 1))
7985             {
7986               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
7987               HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
7988               tree folded_compare, shift;
7989
7990               /* First check whether the comparison would come out
7991                  always the same.  If we don't do that we would
7992                  change the meaning with the masking.  */
7993               folded_compare = fold (build2 (code, type,
7994                                              TREE_OPERAND (varop, 0), arg1));
7995               if (integer_zerop (folded_compare)
7996                   || integer_onep (folded_compare))
7997                 return omit_one_operand (type, folded_compare, varop);
7998
7999               shift = build_int_2 (TYPE_PRECISION (TREE_TYPE (varop)) - size,
8000                                    0);
8001               shift = fold_convert (TREE_TYPE (varop), shift);
8002               newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8003                                        newconst, shift));
8004               newconst = fold (build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8005                                        newconst, shift));
8006             }
8007
8008           return fold (build2 (code, type, varop, newconst));
8009         }
8010
8011       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
8012          This transformation affects the cases which are handled in later
8013          optimizations involving comparisons with non-negative constants.  */
8014       if (TREE_CODE (arg1) == INTEGER_CST
8015           && TREE_CODE (arg0) != INTEGER_CST
8016           && tree_int_cst_sgn (arg1) > 0)
8017         {
8018           switch (code)
8019             {
8020             case GE_EXPR:
8021               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8022               return fold (build2 (GT_EXPR, type, arg0, arg1));
8023
8024             case LT_EXPR:
8025               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8026               return fold (build2 (LE_EXPR, type, arg0, arg1));
8027
8028             default:
8029               break;
8030             }
8031         }
8032
8033       /* Comparisons with the highest or lowest possible integer of
8034          the specified size will have known values.
8035
8036          This is quite similar to fold_relational_hi_lo; however, my
8037          attempts to share the code have been nothing but trouble.
8038          I give up for now.  */
8039       {
8040         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
8041
8042         if (TREE_CODE (arg1) == INTEGER_CST
8043             && ! TREE_CONSTANT_OVERFLOW (arg1)
8044             && width <= HOST_BITS_PER_WIDE_INT
8045             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
8046                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
8047           {
8048             unsigned HOST_WIDE_INT signed_max;
8049             unsigned HOST_WIDE_INT max, min;
8050
8051             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
8052
8053             if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
8054               {
8055                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
8056                 min = 0;
8057               }
8058             else
8059               {
8060                 max = signed_max;
8061                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
8062               }
8063
8064             if (TREE_INT_CST_HIGH (arg1) == 0
8065                 && TREE_INT_CST_LOW (arg1) == max)
8066               switch (code)
8067                 {
8068                 case GT_EXPR:
8069                   return omit_one_operand (type, integer_zero_node, arg0);
8070
8071                 case GE_EXPR:
8072                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8073
8074                 case LE_EXPR:
8075                   return omit_one_operand (type, integer_one_node, arg0);
8076
8077                 case LT_EXPR:
8078                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8079
8080                 /* The GE_EXPR and LT_EXPR cases above are not normally
8081                    reached because of previous transformations.  */
8082
8083                 default:
8084                   break;
8085                 }
8086             else if (TREE_INT_CST_HIGH (arg1) == 0
8087                      && TREE_INT_CST_LOW (arg1) == max - 1)
8088               switch (code)
8089                 {
8090                 case GT_EXPR:
8091                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8092                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8093                 case LE_EXPR:
8094                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8095                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8096                 default:
8097                   break;
8098                 }
8099             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8100                      && TREE_INT_CST_LOW (arg1) == min)
8101               switch (code)
8102                 {
8103                 case LT_EXPR:
8104                   return omit_one_operand (type, integer_zero_node, arg0);
8105
8106                 case LE_EXPR:
8107                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8108
8109                 case GE_EXPR:
8110                   return omit_one_operand (type, integer_one_node, arg0);
8111
8112                 case GT_EXPR:
8113                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8114
8115                 default:
8116                   break;
8117                 }
8118             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8119                      && TREE_INT_CST_LOW (arg1) == min + 1)
8120               switch (code)
8121                 {
8122                 case GE_EXPR:
8123                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8124                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8125                 case LT_EXPR:
8126                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8127                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8128                 default:
8129                   break;
8130                 }
8131
8132             else if (!in_gimple_form
8133                      && TREE_INT_CST_HIGH (arg1) == 0
8134                      && TREE_INT_CST_LOW (arg1) == signed_max
8135                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
8136                      /* signed_type does not work on pointer types.  */
8137                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
8138               {
8139                 /* The following case also applies to X < signed_max+1
8140                    and X >= signed_max+1 because previous transformations.  */
8141                 if (code == LE_EXPR || code == GT_EXPR)
8142                   {
8143                     tree st0, st1;
8144                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
8145                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
8146                     return fold
8147                       (build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
8148                                type, fold_convert (st0, arg0),
8149                                fold_convert (st1, integer_zero_node)));
8150                   }
8151               }
8152           }
8153       }
8154
8155       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
8156          a MINUS_EXPR of a constant, we can convert it into a comparison with
8157          a revised constant as long as no overflow occurs.  */
8158       if ((code == EQ_EXPR || code == NE_EXPR)
8159           && TREE_CODE (arg1) == INTEGER_CST
8160           && (TREE_CODE (arg0) == PLUS_EXPR
8161               || TREE_CODE (arg0) == MINUS_EXPR)
8162           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8163           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8164                                       ? MINUS_EXPR : PLUS_EXPR,
8165                                       arg1, TREE_OPERAND (arg0, 1), 0))
8166           && ! TREE_CONSTANT_OVERFLOW (tem))
8167         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8168
8169       /* Similarly for a NEGATE_EXPR.  */
8170       else if ((code == EQ_EXPR || code == NE_EXPR)
8171                && TREE_CODE (arg0) == NEGATE_EXPR
8172                && TREE_CODE (arg1) == INTEGER_CST
8173                && 0 != (tem = negate_expr (arg1))
8174                && TREE_CODE (tem) == INTEGER_CST
8175                && ! TREE_CONSTANT_OVERFLOW (tem))
8176         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8177
8178       /* If we have X - Y == 0, we can convert that to X == Y and similarly
8179          for !=.  Don't do this for ordered comparisons due to overflow.  */
8180       else if ((code == NE_EXPR || code == EQ_EXPR)
8181                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
8182         return fold (build2 (code, type,
8183                              TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
8184
8185       /* If we are widening one operand of an integer comparison,
8186          see if the other operand is similarly being widened.  Perhaps we
8187          can do the comparison in the narrower type.  */
8188       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8189                && TREE_CODE (arg0) == NOP_EXPR
8190                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
8191                && (code == EQ_EXPR || code == NE_EXPR
8192                    || TYPE_UNSIGNED (TREE_TYPE (arg0))
8193                       == TYPE_UNSIGNED (TREE_TYPE (tem)))
8194                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
8195                && (TREE_TYPE (t1) == TREE_TYPE (tem)
8196                    || (TREE_CODE (t1) == INTEGER_CST
8197                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
8198         return fold (build2 (code, type, tem,
8199                              fold_convert (TREE_TYPE (tem), t1)));
8200
8201       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8202          constant, we can simplify it.  */
8203       else if (TREE_CODE (arg1) == INTEGER_CST
8204                && (TREE_CODE (arg0) == MIN_EXPR
8205                    || TREE_CODE (arg0) == MAX_EXPR)
8206                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8207         return optimize_minmax_comparison (t);
8208
8209       /* If we are comparing an ABS_EXPR with a constant, we can
8210          convert all the cases into explicit comparisons, but they may
8211          well not be faster than doing the ABS and one comparison.
8212          But ABS (X) <= C is a range comparison, which becomes a subtraction
8213          and a comparison, and is probably faster.  */
8214       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8215                && TREE_CODE (arg0) == ABS_EXPR
8216                && ! TREE_SIDE_EFFECTS (arg0)
8217                && (0 != (tem = negate_expr (arg1)))
8218                && TREE_CODE (tem) == INTEGER_CST
8219                && ! TREE_CONSTANT_OVERFLOW (tem))
8220         return fold (build2 (TRUTH_ANDIF_EXPR, type,
8221                              build2 (GE_EXPR, type,
8222                                      TREE_OPERAND (arg0, 0), tem),
8223                              build2 (LE_EXPR, type,
8224                                      TREE_OPERAND (arg0, 0), arg1)));
8225
8226       /* If this is an EQ or NE comparison with zero and ARG0 is
8227          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
8228          two operations, but the latter can be done in one less insn
8229          on machines that have only two-operand insns or on which a
8230          constant cannot be the first operand.  */
8231       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
8232           && TREE_CODE (arg0) == BIT_AND_EXPR)
8233         {
8234           tree arg00 = TREE_OPERAND (arg0, 0);
8235           tree arg01 = TREE_OPERAND (arg0, 1);
8236           if (TREE_CODE (arg00) == LSHIFT_EXPR
8237               && integer_onep (TREE_OPERAND (arg00, 0)))
8238             return
8239               fold (build2 (code, type,
8240                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8241                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
8242                                             arg01, TREE_OPERAND (arg00, 1)),
8243                                     fold_convert (TREE_TYPE (arg0),
8244                                                   integer_one_node)),
8245                             arg1));
8246           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
8247                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
8248             return
8249               fold (build2 (code, type,
8250                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8251                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
8252                                             arg00, TREE_OPERAND (arg01, 1)),
8253                                     fold_convert (TREE_TYPE (arg0),
8254                                                   integer_one_node)),
8255                             arg1));
8256         }
8257
8258       /* If this is an NE or EQ comparison of zero against the result of a
8259          signed MOD operation whose second operand is a power of 2, make
8260          the MOD operation unsigned since it is simpler and equivalent.  */
8261       if ((code == NE_EXPR || code == EQ_EXPR)
8262           && integer_zerop (arg1)
8263           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
8264           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
8265               || TREE_CODE (arg0) == CEIL_MOD_EXPR
8266               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
8267               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
8268           && integer_pow2p (TREE_OPERAND (arg0, 1)))
8269         {
8270           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
8271           tree newmod = build2 (TREE_CODE (arg0), newtype,
8272                                 fold_convert (newtype,
8273                                               TREE_OPERAND (arg0, 0)),
8274                                 fold_convert (newtype,
8275                                               TREE_OPERAND (arg0, 1)));
8276
8277           return build2 (code, type, newmod, fold_convert (newtype, arg1));
8278         }
8279
8280       /* If this is an NE comparison of zero with an AND of one, remove the
8281          comparison since the AND will give the correct value.  */
8282       if (code == NE_EXPR && integer_zerop (arg1)
8283           && TREE_CODE (arg0) == BIT_AND_EXPR
8284           && integer_onep (TREE_OPERAND (arg0, 1)))
8285         return fold_convert (type, arg0);
8286
8287       /* If we have (A & C) == C where C is a power of 2, convert this into
8288          (A & C) != 0.  Similarly for NE_EXPR.  */
8289       if ((code == EQ_EXPR || code == NE_EXPR)
8290           && TREE_CODE (arg0) == BIT_AND_EXPR
8291           && integer_pow2p (TREE_OPERAND (arg0, 1))
8292           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8293         return fold (build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
8294                              arg0, integer_zero_node));
8295
8296       /* If we have (A & C) != 0 or (A & C) == 0 and C is a power of
8297          2, then fold the expression into shifts and logical operations.  */
8298       tem = fold_single_bit_test (code, arg0, arg1, type);
8299       if (tem)
8300         return tem;
8301
8302       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
8303          Similarly for NE_EXPR.  */
8304       if ((code == EQ_EXPR || code == NE_EXPR)
8305           && TREE_CODE (arg0) == BIT_AND_EXPR
8306           && TREE_CODE (arg1) == INTEGER_CST
8307           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8308         {
8309           tree dandnotc
8310             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8311                             arg1, build1 (BIT_NOT_EXPR,
8312                                           TREE_TYPE (TREE_OPERAND (arg0, 1)),
8313                                           TREE_OPERAND (arg0, 1))));
8314           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8315           if (integer_nonzerop (dandnotc))
8316             return omit_one_operand (type, rslt, arg0);
8317         }
8318
8319       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
8320          Similarly for NE_EXPR.  */
8321       if ((code == EQ_EXPR || code == NE_EXPR)
8322           && TREE_CODE (arg0) == BIT_IOR_EXPR
8323           && TREE_CODE (arg1) == INTEGER_CST
8324           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8325         {
8326           tree candnotd
8327             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8328                             TREE_OPERAND (arg0, 1),
8329                             build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1)));
8330           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8331           if (integer_nonzerop (candnotd))
8332             return omit_one_operand (type, rslt, arg0);
8333         }
8334
8335       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
8336          and similarly for >= into !=.  */
8337       if ((code == LT_EXPR || code == GE_EXPR)
8338           && TYPE_UNSIGNED (TREE_TYPE (arg0))
8339           && TREE_CODE (arg1) == LSHIFT_EXPR
8340           && integer_onep (TREE_OPERAND (arg1, 0)))
8341         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8342                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8343                                TREE_OPERAND (arg1, 1)),
8344                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
8345
8346       else if ((code == LT_EXPR || code == GE_EXPR)
8347                && TYPE_UNSIGNED (TREE_TYPE (arg0))
8348                && (TREE_CODE (arg1) == NOP_EXPR
8349                    || TREE_CODE (arg1) == CONVERT_EXPR)
8350                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
8351                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
8352         return
8353           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8354                   fold_convert (TREE_TYPE (arg0),
8355                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8356                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
8357                                                       1))),
8358                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
8359
8360       /* Simplify comparison of something with itself.  (For IEEE
8361          floating-point, we can only do some of these simplifications.)  */
8362       if (operand_equal_p (arg0, arg1, 0))
8363         {
8364           switch (code)
8365             {
8366             case EQ_EXPR:
8367               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8368                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8369                 return constant_boolean_node (1, type);
8370               break;
8371
8372             case GE_EXPR:
8373             case LE_EXPR:
8374               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8375                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8376                 return constant_boolean_node (1, type);
8377               return fold (build2 (EQ_EXPR, type, arg0, arg1));
8378
8379             case NE_EXPR:
8380               /* For NE, we can only do this simplification if integer
8381                  or we don't honor IEEE floating point NaNs.  */
8382               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8383                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8384                 break;
8385               /* ... fall through ...  */
8386             case GT_EXPR:
8387             case LT_EXPR:
8388               return constant_boolean_node (0, type);
8389             default:
8390               abort ();
8391             }
8392         }
8393
8394       /* If we are comparing an expression that just has comparisons
8395          of two integer values, arithmetic expressions of those comparisons,
8396          and constants, we can simplify it.  There are only three cases
8397          to check: the two values can either be equal, the first can be
8398          greater, or the second can be greater.  Fold the expression for
8399          those three values.  Since each value must be 0 or 1, we have
8400          eight possibilities, each of which corresponds to the constant 0
8401          or 1 or one of the six possible comparisons.
8402
8403          This handles common cases like (a > b) == 0 but also handles
8404          expressions like  ((x > y) - (y > x)) > 0, which supposedly
8405          occur in macroized code.  */
8406
8407       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8408         {
8409           tree cval1 = 0, cval2 = 0;
8410           int save_p = 0;
8411
8412           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8413               /* Don't handle degenerate cases here; they should already
8414                  have been handled anyway.  */
8415               && cval1 != 0 && cval2 != 0
8416               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8417               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8418               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8419               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8420               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8421               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8422                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8423             {
8424               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8425               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8426
8427               /* We can't just pass T to eval_subst in case cval1 or cval2
8428                  was the same as ARG1.  */
8429
8430               tree high_result
8431                 = fold (build2 (code, type,
8432                                 eval_subst (arg0, cval1, maxval,
8433                                             cval2, minval),
8434                                 arg1));
8435               tree equal_result
8436                 = fold (build2 (code, type,
8437                                 eval_subst (arg0, cval1, maxval,
8438                                             cval2, maxval),
8439                                 arg1));
8440               tree low_result
8441                 = fold (build2 (code, type,
8442                                 eval_subst (arg0, cval1, minval,
8443                                             cval2, maxval),
8444                                 arg1));
8445
8446               /* All three of these results should be 0 or 1.  Confirm they
8447                  are.  Then use those values to select the proper code
8448                  to use.  */
8449
8450               if ((integer_zerop (high_result)
8451                    || integer_onep (high_result))
8452                   && (integer_zerop (equal_result)
8453                       || integer_onep (equal_result))
8454                   && (integer_zerop (low_result)
8455                       || integer_onep (low_result)))
8456                 {
8457                   /* Make a 3-bit mask with the high-order bit being the
8458                      value for `>', the next for '=', and the low for '<'.  */
8459                   switch ((integer_onep (high_result) * 4)
8460                           + (integer_onep (equal_result) * 2)
8461                           + integer_onep (low_result))
8462                     {
8463                     case 0:
8464                       /* Always false.  */
8465                       return omit_one_operand (type, integer_zero_node, arg0);
8466                     case 1:
8467                       code = LT_EXPR;
8468                       break;
8469                     case 2:
8470                       code = EQ_EXPR;
8471                       break;
8472                     case 3:
8473                       code = LE_EXPR;
8474                       break;
8475                     case 4:
8476                       code = GT_EXPR;
8477                       break;
8478                     case 5:
8479                       code = NE_EXPR;
8480                       break;
8481                     case 6:
8482                       code = GE_EXPR;
8483                       break;
8484                     case 7:
8485                       /* Always true.  */
8486                       return omit_one_operand (type, integer_one_node, arg0);
8487                     }
8488
8489                   tem = build2 (code, type, cval1, cval2);
8490                   if (save_p)
8491                     return save_expr (tem);
8492                   else
8493                     return fold (tem);
8494                 }
8495             }
8496         }
8497
8498       /* If this is a comparison of a field, we may be able to simplify it.  */
8499       if (((TREE_CODE (arg0) == COMPONENT_REF
8500             && lang_hooks.can_use_bit_fields_p ())
8501            || TREE_CODE (arg0) == BIT_FIELD_REF)
8502           && (code == EQ_EXPR || code == NE_EXPR)
8503           /* Handle the constant case even without -O
8504              to make sure the warnings are given.  */
8505           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
8506         {
8507           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
8508           if (t1)
8509             return t1;
8510         }
8511
8512       /* If this is a comparison of complex values and either or both sides
8513          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
8514          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
8515          This may prevent needless evaluations.  */
8516       if ((code == EQ_EXPR || code == NE_EXPR)
8517           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
8518           && (TREE_CODE (arg0) == COMPLEX_EXPR
8519               || TREE_CODE (arg1) == COMPLEX_EXPR
8520               || TREE_CODE (arg0) == COMPLEX_CST
8521               || TREE_CODE (arg1) == COMPLEX_CST))
8522         {
8523           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
8524           tree real0, imag0, real1, imag1;
8525
8526           arg0 = save_expr (arg0);
8527           arg1 = save_expr (arg1);
8528           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
8529           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
8530           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
8531           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
8532
8533           return fold (build2 ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
8534                                 : TRUTH_ORIF_EXPR),
8535                                type,
8536                                fold (build2 (code, type, real0, real1)),
8537                                fold (build2 (code, type, imag0, imag1))));
8538         }
8539
8540       /* Optimize comparisons of strlen vs zero to a compare of the
8541          first character of the string vs zero.  To wit,
8542                 strlen(ptr) == 0   =>  *ptr == 0
8543                 strlen(ptr) != 0   =>  *ptr != 0
8544          Other cases should reduce to one of these two (or a constant)
8545          due to the return value of strlen being unsigned.  */
8546       if ((code == EQ_EXPR || code == NE_EXPR)
8547           && integer_zerop (arg1)
8548           && TREE_CODE (arg0) == CALL_EXPR)
8549         {
8550           tree fndecl = get_callee_fndecl (arg0);
8551           tree arglist;
8552
8553           if (fndecl
8554               && DECL_BUILT_IN (fndecl)
8555               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
8556               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
8557               && (arglist = TREE_OPERAND (arg0, 1))
8558               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
8559               && ! TREE_CHAIN (arglist))
8560             return fold (build2 (code, type,
8561                                  build1 (INDIRECT_REF, char_type_node,
8562                                          TREE_VALUE(arglist)),
8563                                  integer_zero_node));
8564         }
8565
8566       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8567          into a single range test.  */
8568       if (TREE_CODE (arg0) == TRUNC_DIV_EXPR
8569           && TREE_CODE (arg1) == INTEGER_CST
8570           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8571           && !integer_zerop (TREE_OPERAND (arg0, 1))
8572           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8573           && !TREE_OVERFLOW (arg1))
8574         {
8575           t1 = fold_div_compare (code, type, arg0, arg1);
8576           if (t1 != NULL_TREE)
8577             return t1;
8578         }
8579
8580       /* Both ARG0 and ARG1 are known to be constants at this point.  */
8581       t1 = fold_relational_const (code, type, arg0, arg1);
8582       return (t1 == NULL_TREE ? t : t1);
8583
8584     case UNORDERED_EXPR:
8585     case ORDERED_EXPR:
8586     case UNLT_EXPR:
8587     case UNLE_EXPR:
8588     case UNGT_EXPR:
8589     case UNGE_EXPR:
8590     case UNEQ_EXPR:
8591     case LTGT_EXPR:
8592       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8593         {
8594           t1 = fold_relational_const (code, type, arg0, arg1);
8595           if (t1 != NULL_TREE)
8596             return t1;
8597         }
8598
8599       /* If the first operand is NaN, the result is constant.  */
8600       if (TREE_CODE (arg0) == REAL_CST
8601           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
8602           && (code != LTGT_EXPR || ! flag_trapping_math))
8603         {
8604           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8605                ? integer_zero_node
8606                : integer_one_node;
8607           return omit_one_operand (type, t1, arg1);
8608         }
8609
8610       /* If the second operand is NaN, the result is constant.  */
8611       if (TREE_CODE (arg1) == REAL_CST
8612           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
8613           && (code != LTGT_EXPR || ! flag_trapping_math))
8614         {
8615           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8616                ? integer_zero_node
8617                : integer_one_node;
8618           return omit_one_operand (type, t1, arg0);
8619         }
8620
8621       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8622       {
8623         tree targ0 = strip_float_extensions (arg0);
8624         tree targ1 = strip_float_extensions (arg1);
8625         tree newtype = TREE_TYPE (targ0);
8626
8627         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8628           newtype = TREE_TYPE (targ1);
8629
8630         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8631           return fold (build2 (code, type, fold_convert (newtype, targ0),
8632                                fold_convert (newtype, targ1)));
8633       }
8634
8635       return t;
8636
8637     case COND_EXPR:
8638       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
8639          so all simple results must be passed through pedantic_non_lvalue.  */
8640       if (TREE_CODE (arg0) == INTEGER_CST)
8641         {
8642           tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
8643           /* Only optimize constant conditions when the selected branch
8644              has the same type as the COND_EXPR.  This avoids optimizing
8645              away "c ? x : throw", where the throw has a void type.  */
8646           if (! VOID_TYPE_P (TREE_TYPE (tem))
8647               || VOID_TYPE_P (type))
8648             return pedantic_non_lvalue (tem);
8649           return t;
8650         }
8651       if (operand_equal_p (arg1, TREE_OPERAND (t, 2), 0))
8652         return pedantic_omit_one_operand (type, arg1, arg0);
8653
8654       /* If we have A op B ? A : C, we may be able to convert this to a
8655          simpler expression, depending on the operation and the values
8656          of B and C.  Signed zeros prevent all of these transformations,
8657          for reasons given above each one.
8658
8659          Also try swapping the arguments and inverting the conditional.  */
8660       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8661           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8662                                              arg1, TREE_OPERAND (arg0, 1))
8663           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
8664         {
8665           tem = fold_cond_expr_with_comparison (type, arg0,
8666                                                 TREE_OPERAND (t, 1),
8667                                                 TREE_OPERAND (t, 2));
8668           if (tem)
8669             return tem;
8670         }
8671
8672       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8673           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8674                                              TREE_OPERAND (t, 2),
8675                                              TREE_OPERAND (arg0, 1))
8676           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
8677         {
8678           tem = invert_truthvalue (arg0);
8679           if (TREE_CODE_CLASS (TREE_CODE (tem)) == '<')
8680             {
8681               tem = fold_cond_expr_with_comparison (type, tem,
8682                                                     TREE_OPERAND (t, 2),
8683                                                     TREE_OPERAND (t, 1));
8684               if (tem)
8685                 return tem;
8686             }
8687         }
8688
8689       /* If the second operand is simpler than the third, swap them
8690          since that produces better jump optimization results.  */
8691       if (tree_swap_operands_p (TREE_OPERAND (t, 1),
8692                                 TREE_OPERAND (t, 2), false))
8693         {
8694           /* See if this can be inverted.  If it can't, possibly because
8695              it was a floating-point inequality comparison, don't do
8696              anything.  */
8697           tem = invert_truthvalue (arg0);
8698
8699           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8700             return fold (build3 (code, type, tem,
8701                                  TREE_OPERAND (t, 2), TREE_OPERAND (t, 1)));
8702         }
8703
8704       /* Convert A ? 1 : 0 to simply A.  */
8705       if (integer_onep (TREE_OPERAND (t, 1))
8706           && integer_zerop (TREE_OPERAND (t, 2))
8707           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
8708              call to fold will try to move the conversion inside
8709              a COND, which will recurse.  In that case, the COND_EXPR
8710              is probably the best choice, so leave it alone.  */
8711           && type == TREE_TYPE (arg0))
8712         return pedantic_non_lvalue (arg0);
8713
8714       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
8715          over COND_EXPR in cases such as floating point comparisons.  */
8716       if (integer_zerop (TREE_OPERAND (t, 1))
8717           && integer_onep (TREE_OPERAND (t, 2))
8718           && truth_value_p (TREE_CODE (arg0)))
8719         return pedantic_non_lvalue (fold_convert (type,
8720                                                   invert_truthvalue (arg0)));
8721
8722       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
8723       if (TREE_CODE (arg0) == LT_EXPR
8724           && integer_zerop (TREE_OPERAND (arg0, 1))
8725           && integer_zerop (TREE_OPERAND (t, 2))
8726           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
8727         return fold_convert (type, fold (build2 (BIT_AND_EXPR,
8728                                                  TREE_TYPE (tem), tem, arg1)));
8729
8730       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
8731          already handled above.  */
8732       if (TREE_CODE (arg0) == BIT_AND_EXPR
8733           && integer_onep (TREE_OPERAND (arg0, 1))
8734           && integer_zerop (TREE_OPERAND (t, 2))
8735           && integer_pow2p (arg1))
8736         {
8737           tree tem = TREE_OPERAND (arg0, 0);
8738           STRIP_NOPS (tem);
8739           if (TREE_CODE (tem) == RSHIFT_EXPR
8740               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
8741                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
8742             return fold (build2 (BIT_AND_EXPR, type,
8743                                  TREE_OPERAND (tem, 0), arg1));
8744         }
8745
8746       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
8747          is probably obsolete because the first operand should be a
8748          truth value (that's why we have the two cases above), but let's
8749          leave it in until we can confirm this for all front-ends.  */
8750       if (integer_zerop (TREE_OPERAND (t, 2))
8751           && TREE_CODE (arg0) == NE_EXPR
8752           && integer_zerop (TREE_OPERAND (arg0, 1))
8753           && integer_pow2p (arg1)
8754           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
8755           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
8756                               arg1, OEP_ONLY_CONST))
8757         return pedantic_non_lvalue (fold_convert (type,
8758                                                   TREE_OPERAND (arg0, 0)));
8759
8760       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
8761       if (integer_zerop (TREE_OPERAND (t, 2))
8762           && truth_value_p (TREE_CODE (arg0))
8763           && truth_value_p (TREE_CODE (arg1)))
8764         return fold (build2 (TRUTH_ANDIF_EXPR, type, arg0, arg1));
8765
8766       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
8767       if (integer_onep (TREE_OPERAND (t, 2))
8768           && truth_value_p (TREE_CODE (arg0))
8769           && truth_value_p (TREE_CODE (arg1)))
8770         {
8771           /* Only perform transformation if ARG0 is easily inverted.  */
8772           tem = invert_truthvalue (arg0);
8773           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8774             return fold (build2 (TRUTH_ORIF_EXPR, type, tem, arg1));
8775         }
8776
8777       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
8778       if (integer_zerop (arg1)
8779           && truth_value_p (TREE_CODE (arg0))
8780           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8781         {
8782           /* Only perform transformation if ARG0 is easily inverted.  */
8783           tem = invert_truthvalue (arg0);
8784           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8785             return fold (build2 (TRUTH_ANDIF_EXPR, type, tem,
8786                                  TREE_OPERAND (t, 2)));
8787         }
8788
8789       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
8790       if (integer_onep (arg1)
8791           && truth_value_p (TREE_CODE (arg0))
8792           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8793         return fold (build2 (TRUTH_ORIF_EXPR, type, arg0,
8794                              TREE_OPERAND (t, 2)));
8795
8796       return t;
8797
8798     case COMPOUND_EXPR:
8799       /* When pedantic, a compound expression can be neither an lvalue
8800          nor an integer constant expression.  */
8801       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
8802         return t;
8803       /* Don't let (0, 0) be null pointer constant.  */
8804       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
8805                                  : fold_convert (type, arg1);
8806       return pedantic_non_lvalue (tem);
8807
8808     case COMPLEX_EXPR:
8809       if (wins)
8810         return build_complex (type, arg0, arg1);
8811       return t;
8812
8813     case REALPART_EXPR:
8814       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8815         return t;
8816       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8817         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8818                                  TREE_OPERAND (arg0, 1));
8819       else if (TREE_CODE (arg0) == COMPLEX_CST)
8820         return TREE_REALPART (arg0);
8821       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8822         return fold (build2 (TREE_CODE (arg0), type,
8823                              fold (build1 (REALPART_EXPR, type,
8824                                            TREE_OPERAND (arg0, 0))),
8825                              fold (build1 (REALPART_EXPR, type,
8826                                            TREE_OPERAND (arg0, 1)))));
8827       return t;
8828
8829     case IMAGPART_EXPR:
8830       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8831         return fold_convert (type, integer_zero_node);
8832       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8833         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8834                                  TREE_OPERAND (arg0, 0));
8835       else if (TREE_CODE (arg0) == COMPLEX_CST)
8836         return TREE_IMAGPART (arg0);
8837       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8838         return fold (build2 (TREE_CODE (arg0), type,
8839                              fold (build1 (IMAGPART_EXPR, type,
8840                                            TREE_OPERAND (arg0, 0))),
8841                              fold (build1 (IMAGPART_EXPR, type,
8842                                            TREE_OPERAND (arg0, 1)))));
8843       return t;
8844
8845       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
8846          appropriate.  */
8847     case CLEANUP_POINT_EXPR:
8848       if (! has_cleanups (arg0))
8849         return TREE_OPERAND (t, 0);
8850
8851       {
8852         enum tree_code code0 = TREE_CODE (arg0);
8853         int kind0 = TREE_CODE_CLASS (code0);
8854         tree arg00 = TREE_OPERAND (arg0, 0);
8855         tree arg01;
8856
8857         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
8858           return fold (build1 (code0, type,
8859                                fold (build1 (CLEANUP_POINT_EXPR,
8860                                              TREE_TYPE (arg00), arg00))));
8861
8862         if (kind0 == '<' || kind0 == '2'
8863             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
8864             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
8865             || code0 == TRUTH_XOR_EXPR)
8866           {
8867             arg01 = TREE_OPERAND (arg0, 1);
8868
8869             if (TREE_CONSTANT (arg00)
8870                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
8871                     && ! has_cleanups (arg00)))
8872               return fold (build2 (code0, type, arg00,
8873                                    fold (build1 (CLEANUP_POINT_EXPR,
8874                                                  TREE_TYPE (arg01), arg01))));
8875
8876             if (TREE_CONSTANT (arg01))
8877               return fold (build2 (code0, type,
8878                                    fold (build1 (CLEANUP_POINT_EXPR,
8879                                                  TREE_TYPE (arg00), arg00)),
8880                                    arg01));
8881           }
8882
8883         return t;
8884       }
8885
8886     case CALL_EXPR:
8887       /* Check for a built-in function.  */
8888       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
8889           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
8890               == FUNCTION_DECL)
8891           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
8892         {
8893           tree tmp = fold_builtin (t);
8894           if (tmp)
8895             return tmp;
8896         }
8897       return t;
8898
8899     default:
8900       return t;
8901     } /* switch (code) */
8902 }
8903
8904 #ifdef ENABLE_FOLD_CHECKING
8905 #undef fold
8906
8907 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
8908 static void fold_check_failed (tree, tree);
8909 void print_fold_checksum (tree);
8910
8911 /* When --enable-checking=fold, compute a digest of expr before
8912    and after actual fold call to see if fold did not accidentally
8913    change original expr.  */
8914
8915 tree
8916 fold (tree expr)
8917 {
8918   tree ret;
8919   struct md5_ctx ctx;
8920   unsigned char checksum_before[16], checksum_after[16];
8921   htab_t ht;
8922
8923   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
8924   md5_init_ctx (&ctx);
8925   fold_checksum_tree (expr, &ctx, ht);
8926   md5_finish_ctx (&ctx, checksum_before);
8927   htab_empty (ht);
8928
8929   ret = fold_1 (expr);
8930
8931   md5_init_ctx (&ctx);
8932   fold_checksum_tree (expr, &ctx, ht);
8933   md5_finish_ctx (&ctx, checksum_after);
8934   htab_delete (ht);
8935
8936   if (memcmp (checksum_before, checksum_after, 16))
8937     fold_check_failed (expr, ret);
8938
8939   return ret;
8940 }
8941
8942 void
8943 print_fold_checksum (tree expr)
8944 {
8945   struct md5_ctx ctx;
8946   unsigned char checksum[16], cnt;
8947   htab_t ht;
8948
8949   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
8950   md5_init_ctx (&ctx);
8951   fold_checksum_tree (expr, &ctx, ht);
8952   md5_finish_ctx (&ctx, checksum);
8953   htab_delete (ht);
8954   for (cnt = 0; cnt < 16; ++cnt)
8955     fprintf (stderr, "%02x", checksum[cnt]);
8956   putc ('\n', stderr);
8957 }
8958
8959 static void
8960 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
8961 {
8962   internal_error ("fold check: original tree changed by fold");
8963 }
8964
8965 static void
8966 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
8967 {
8968   void **slot;
8969   enum tree_code code;
8970   char buf[sizeof (struct tree_decl)];
8971   int i, len;
8972
8973   if (sizeof (struct tree_exp) + 5 * sizeof (tree)
8974       > sizeof (struct tree_decl)
8975       || sizeof (struct tree_type) > sizeof (struct tree_decl))
8976     abort ();
8977   if (expr == NULL)
8978     return;
8979   slot = htab_find_slot (ht, expr, INSERT);
8980   if (*slot != NULL)
8981     return;
8982   *slot = expr;
8983   code = TREE_CODE (expr);
8984   if (TREE_CODE_CLASS (code) == 'd' && DECL_ASSEMBLER_NAME_SET_P (expr))
8985     {
8986       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
8987       memcpy (buf, expr, tree_size (expr));
8988       expr = (tree) buf;
8989       SET_DECL_ASSEMBLER_NAME (expr, NULL);
8990     }
8991   else if (TREE_CODE_CLASS (code) == 't'
8992            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)))
8993     {
8994       /* Allow TYPE_POINTER_TO and TYPE_REFERENCE_TO to be modified.  */
8995       memcpy (buf, expr, tree_size (expr));
8996       expr = (tree) buf;
8997       TYPE_POINTER_TO (expr) = NULL;
8998       TYPE_REFERENCE_TO (expr) = NULL;
8999     }
9000   md5_process_bytes (expr, tree_size (expr), ctx);
9001   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
9002   if (TREE_CODE_CLASS (code) != 't' && TREE_CODE_CLASS (code) != 'd')
9003     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
9004   len = TREE_CODE_LENGTH (code);
9005   switch (TREE_CODE_CLASS (code))
9006     {
9007     case 'c':
9008       switch (code)
9009         {
9010         case STRING_CST:
9011           md5_process_bytes (TREE_STRING_POINTER (expr),
9012                              TREE_STRING_LENGTH (expr), ctx);
9013           break;
9014         case COMPLEX_CST:
9015           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
9016           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
9017           break;
9018         case VECTOR_CST:
9019           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
9020           break;
9021         default:
9022           break;
9023         }
9024       break;
9025     case 'x':
9026       switch (code)
9027         {
9028         case TREE_LIST:
9029           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
9030           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
9031           break;
9032         case TREE_VEC:
9033           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
9034             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
9035           break;
9036         default:
9037           break;
9038         }
9039       break;
9040     case 'e':
9041       switch (code)
9042         {
9043         case GOTO_SUBROUTINE_EXPR: len = 0; break;
9044         case WITH_CLEANUP_EXPR: len = 2; break;
9045         default: break;
9046         }
9047       /* Fall through.  */
9048     case 'r':
9049     case '<':
9050     case '1':
9051     case '2':
9052     case 's':
9053       for (i = 0; i < len; ++i)
9054         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
9055       break;
9056     case 'd':
9057       fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
9058       fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
9059       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
9060       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
9061       fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
9062       fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
9063       fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
9064       fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
9065       fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
9066       fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
9067       fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
9068       break;
9069     case 't':
9070       if (TREE_CODE (expr) == ENUMERAL_TYPE)
9071         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
9072       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
9073       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
9074       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
9075       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
9076       if (INTEGRAL_TYPE_P (expr)
9077           || SCALAR_FLOAT_TYPE_P (expr))
9078         {
9079           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
9080           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
9081         }
9082       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
9083       fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
9084       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
9085       break;
9086     default:
9087       break;
9088     }
9089 }
9090
9091 #endif
9092
9093 /* Perform constant folding and related simplification of initializer
9094    expression EXPR.  This behaves identically to "fold" but ignores
9095    potential run-time traps and exceptions that fold must preserve.  */
9096
9097 tree
9098 fold_initializer (tree expr)
9099 {
9100   int saved_signaling_nans = flag_signaling_nans;
9101   int saved_trapping_math = flag_trapping_math;
9102   int saved_trapv = flag_trapv;
9103   tree result;
9104
9105   flag_signaling_nans = 0;
9106   flag_trapping_math = 0;
9107   flag_trapv = 0;
9108
9109   result = fold (expr);
9110
9111   flag_signaling_nans = saved_signaling_nans;
9112   flag_trapping_math = saved_trapping_math;
9113   flag_trapv = saved_trapv;
9114
9115   return result;
9116 }
9117
9118 /* Determine if first argument is a multiple of second argument.  Return 0 if
9119    it is not, or we cannot easily determined it to be.
9120
9121    An example of the sort of thing we care about (at this point; this routine
9122    could surely be made more general, and expanded to do what the *_DIV_EXPR's
9123    fold cases do now) is discovering that
9124
9125      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9126
9127    is a multiple of
9128
9129      SAVE_EXPR (J * 8)
9130
9131    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
9132
9133    This code also handles discovering that
9134
9135      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9136
9137    is a multiple of 8 so we don't have to worry about dealing with a
9138    possible remainder.
9139
9140    Note that we *look* inside a SAVE_EXPR only to determine how it was
9141    calculated; it is not safe for fold to do much of anything else with the
9142    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
9143    at run time.  For example, the latter example above *cannot* be implemented
9144    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
9145    evaluation time of the original SAVE_EXPR is not necessarily the same at
9146    the time the new expression is evaluated.  The only optimization of this
9147    sort that would be valid is changing
9148
9149      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
9150
9151    divided by 8 to
9152
9153      SAVE_EXPR (I) * SAVE_EXPR (J)
9154
9155    (where the same SAVE_EXPR (J) is used in the original and the
9156    transformed version).  */
9157
9158 static int
9159 multiple_of_p (tree type, tree top, tree bottom)
9160 {
9161   if (operand_equal_p (top, bottom, 0))
9162     return 1;
9163
9164   if (TREE_CODE (type) != INTEGER_TYPE)
9165     return 0;
9166
9167   switch (TREE_CODE (top))
9168     {
9169     case MULT_EXPR:
9170       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9171               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9172
9173     case PLUS_EXPR:
9174     case MINUS_EXPR:
9175       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9176               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9177
9178     case LSHIFT_EXPR:
9179       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
9180         {
9181           tree op1, t1;
9182
9183           op1 = TREE_OPERAND (top, 1);
9184           /* const_binop may not detect overflow correctly,
9185              so check for it explicitly here.  */
9186           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
9187               > TREE_INT_CST_LOW (op1)
9188               && TREE_INT_CST_HIGH (op1) == 0
9189               && 0 != (t1 = fold_convert (type,
9190                                           const_binop (LSHIFT_EXPR,
9191                                                        size_one_node,
9192                                                        op1, 0)))
9193               && ! TREE_OVERFLOW (t1))
9194             return multiple_of_p (type, t1, bottom);
9195         }
9196       return 0;
9197
9198     case NOP_EXPR:
9199       /* Can't handle conversions from non-integral or wider integral type.  */
9200       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
9201           || (TYPE_PRECISION (type)
9202               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
9203         return 0;
9204
9205       /* .. fall through ...  */
9206
9207     case SAVE_EXPR:
9208       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
9209
9210     case INTEGER_CST:
9211       if (TREE_CODE (bottom) != INTEGER_CST
9212           || (TYPE_UNSIGNED (type)
9213               && (tree_int_cst_sgn (top) < 0
9214                   || tree_int_cst_sgn (bottom) < 0)))
9215         return 0;
9216       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
9217                                          top, bottom, 0));
9218
9219     default:
9220       return 0;
9221     }
9222 }
9223
9224 /* Return true if `t' is known to be non-negative.  */
9225
9226 int
9227 tree_expr_nonnegative_p (tree t)
9228 {
9229   switch (TREE_CODE (t))
9230     {
9231     case ABS_EXPR:
9232       return 1;
9233
9234     case INTEGER_CST:
9235       return tree_int_cst_sgn (t) >= 0;
9236
9237     case REAL_CST:
9238       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
9239
9240     case PLUS_EXPR:
9241       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9242         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9243                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9244
9245       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
9246          both unsigned and at least 2 bits shorter than the result.  */
9247       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9248           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9249           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9250         {
9251           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9252           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9253           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9254               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9255             {
9256               unsigned int prec = MAX (TYPE_PRECISION (inner1),
9257                                        TYPE_PRECISION (inner2)) + 1;
9258               return prec < TYPE_PRECISION (TREE_TYPE (t));
9259             }
9260         }
9261       break;
9262
9263     case MULT_EXPR:
9264       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9265         {
9266           /* x * x for floating point x is always non-negative.  */
9267           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
9268             return 1;
9269           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9270                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9271         }
9272
9273       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
9274          both unsigned and their total bits is shorter than the result.  */
9275       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9276           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9277           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9278         {
9279           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9280           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9281           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9282               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9283             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
9284                    < TYPE_PRECISION (TREE_TYPE (t));
9285         }
9286       return 0;
9287
9288     case TRUNC_DIV_EXPR:
9289     case CEIL_DIV_EXPR:
9290     case FLOOR_DIV_EXPR:
9291     case ROUND_DIV_EXPR:
9292       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9293              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9294
9295     case TRUNC_MOD_EXPR:
9296     case CEIL_MOD_EXPR:
9297     case FLOOR_MOD_EXPR:
9298     case ROUND_MOD_EXPR:
9299       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9300
9301     case RDIV_EXPR:
9302       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9303              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9304
9305     case BIT_AND_EXPR:
9306       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9307              || tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9308     case BIT_IOR_EXPR:
9309     case BIT_XOR_EXPR:
9310       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9311              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9312
9313     case NOP_EXPR:
9314       {
9315         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9316         tree outer_type = TREE_TYPE (t);
9317
9318         if (TREE_CODE (outer_type) == REAL_TYPE)
9319           {
9320             if (TREE_CODE (inner_type) == REAL_TYPE)
9321               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9322             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9323               {
9324                 if (TYPE_UNSIGNED (inner_type))
9325                   return 1;
9326                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9327               }
9328           }
9329         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
9330           {
9331             if (TREE_CODE (inner_type) == REAL_TYPE)
9332               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
9333             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9334               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
9335                       && TYPE_UNSIGNED (inner_type);
9336           }
9337       }
9338       break;
9339
9340     case COND_EXPR:
9341       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9342         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
9343     case COMPOUND_EXPR:
9344       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9345     case MIN_EXPR:
9346       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9347         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9348     case MAX_EXPR:
9349       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9350         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9351     case MODIFY_EXPR:
9352       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9353     case BIND_EXPR:
9354       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
9355     case SAVE_EXPR:
9356       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9357     case NON_LVALUE_EXPR:
9358       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9359     case FLOAT_EXPR:
9360       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9361
9362     case TARGET_EXPR:
9363       {
9364         tree temp = TARGET_EXPR_SLOT (t);
9365         t = TARGET_EXPR_INITIAL (t);
9366
9367         /* If the initializer is non-void, then it's a normal expression
9368            that will be assigned to the slot.  */
9369         if (!VOID_TYPE_P (t))
9370           return tree_expr_nonnegative_p (t);
9371
9372         /* Otherwise, the initializer sets the slot in some way.  One common
9373            way is an assignment statement at the end of the initializer.  */
9374         while (1)
9375           {
9376             if (TREE_CODE (t) == BIND_EXPR)
9377               t = expr_last (BIND_EXPR_BODY (t));
9378             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
9379                      || TREE_CODE (t) == TRY_CATCH_EXPR)
9380               t = expr_last (TREE_OPERAND (t, 0));
9381             else if (TREE_CODE (t) == STATEMENT_LIST)
9382               t = expr_last (t);
9383             else
9384               break;
9385           }
9386         if (TREE_CODE (t) == MODIFY_EXPR
9387             && TREE_OPERAND (t, 0) == temp)
9388           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9389
9390         return 0;
9391       }
9392
9393     case CALL_EXPR:
9394       {
9395         tree fndecl = get_callee_fndecl (t);
9396         tree arglist = TREE_OPERAND (t, 1);
9397         if (fndecl
9398             && DECL_BUILT_IN (fndecl)
9399             && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
9400           switch (DECL_FUNCTION_CODE (fndecl))
9401             {
9402 #define CASE_BUILTIN_F(BUILT_IN_FN) \
9403   case BUILT_IN_FN: case BUILT_IN_FN##F: case BUILT_IN_FN##L:
9404 #define CASE_BUILTIN_I(BUILT_IN_FN) \
9405   case BUILT_IN_FN: case BUILT_IN_FN##L: case BUILT_IN_FN##LL:
9406
9407             CASE_BUILTIN_F (BUILT_IN_ACOS)
9408             CASE_BUILTIN_F (BUILT_IN_ACOSH)
9409             CASE_BUILTIN_F (BUILT_IN_CABS)
9410             CASE_BUILTIN_F (BUILT_IN_COSH)
9411             CASE_BUILTIN_F (BUILT_IN_ERFC)
9412             CASE_BUILTIN_F (BUILT_IN_EXP)
9413             CASE_BUILTIN_F (BUILT_IN_EXP10)
9414             CASE_BUILTIN_F (BUILT_IN_EXP2)
9415             CASE_BUILTIN_F (BUILT_IN_FABS)
9416             CASE_BUILTIN_F (BUILT_IN_FDIM)
9417             CASE_BUILTIN_F (BUILT_IN_FREXP)
9418             CASE_BUILTIN_F (BUILT_IN_HYPOT)
9419             CASE_BUILTIN_F (BUILT_IN_POW10)
9420             CASE_BUILTIN_I (BUILT_IN_FFS)
9421             CASE_BUILTIN_I (BUILT_IN_PARITY)
9422             CASE_BUILTIN_I (BUILT_IN_POPCOUNT)
9423               /* Always true.  */
9424               return 1;
9425
9426             CASE_BUILTIN_F (BUILT_IN_SQRT)
9427               /* sqrt(-0.0) is -0.0.  */
9428               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
9429                 return 1;
9430               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9431
9432             CASE_BUILTIN_F (BUILT_IN_ASINH)
9433             CASE_BUILTIN_F (BUILT_IN_ATAN)
9434             CASE_BUILTIN_F (BUILT_IN_ATANH)
9435             CASE_BUILTIN_F (BUILT_IN_CBRT)
9436             CASE_BUILTIN_F (BUILT_IN_CEIL)
9437             CASE_BUILTIN_F (BUILT_IN_ERF)
9438             CASE_BUILTIN_F (BUILT_IN_EXPM1)
9439             CASE_BUILTIN_F (BUILT_IN_FLOOR)
9440             CASE_BUILTIN_F (BUILT_IN_FMOD)
9441             CASE_BUILTIN_F (BUILT_IN_LDEXP)
9442             CASE_BUILTIN_F (BUILT_IN_LLRINT)
9443             CASE_BUILTIN_F (BUILT_IN_LLROUND)
9444             CASE_BUILTIN_F (BUILT_IN_LRINT)
9445             CASE_BUILTIN_F (BUILT_IN_LROUND)
9446             CASE_BUILTIN_F (BUILT_IN_MODF)
9447             CASE_BUILTIN_F (BUILT_IN_NEARBYINT)
9448             CASE_BUILTIN_F (BUILT_IN_POW)
9449             CASE_BUILTIN_F (BUILT_IN_RINT)
9450             CASE_BUILTIN_F (BUILT_IN_ROUND)
9451             CASE_BUILTIN_F (BUILT_IN_SIGNBIT)
9452             CASE_BUILTIN_F (BUILT_IN_SINH)
9453             CASE_BUILTIN_F (BUILT_IN_TANH)
9454             CASE_BUILTIN_F (BUILT_IN_TRUNC)
9455               /* True if the 1st argument is nonnegative.  */
9456               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9457
9458             CASE_BUILTIN_F (BUILT_IN_FMAX)
9459               /* True if the 1st OR 2nd arguments are nonnegative.  */
9460               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9461                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9462
9463             CASE_BUILTIN_F (BUILT_IN_FMIN)
9464               /* True if the 1st AND 2nd arguments are nonnegative.  */
9465               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9466                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9467
9468             CASE_BUILTIN_F (BUILT_IN_COPYSIGN)
9469               /* True if the 2nd argument is nonnegative.  */
9470               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9471
9472             default:
9473               break;
9474 #undef CASE_BUILTIN_F
9475 #undef CASE_BUILTIN_I
9476             }
9477       }
9478
9479       /* ... fall through ...  */
9480
9481     default:
9482       if (truth_value_p (TREE_CODE (t)))
9483         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
9484         return 1;
9485     }
9486
9487   /* We don't know sign of `t', so be conservative and return false.  */
9488   return 0;
9489 }
9490
9491 /* Return true when T is an address and is known to be nonzero.
9492    For floating point we further ensure that T is not denormal.
9493    Similar logic is present in nonzero_address in rtlanal.h  */
9494
9495 static bool
9496 tree_expr_nonzero_p (tree t)
9497 {
9498   tree type = TREE_TYPE (t);
9499
9500   /* Doing something useful for floating point would need more work.  */
9501   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9502     return false;
9503
9504   switch (TREE_CODE (t))
9505     {
9506     case ABS_EXPR:
9507       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9508         return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9509
9510     case INTEGER_CST:
9511       return !integer_zerop (t);
9512
9513     case PLUS_EXPR:
9514       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9515         {
9516           /* With the presence of negative values it is hard
9517              to say something.  */
9518           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9519               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9520             return false;
9521           /* One of operands must be positive and the other non-negative.  */
9522           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9523                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9524         }
9525       break;
9526
9527     case MULT_EXPR:
9528       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9529         {
9530           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9531                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9532         }
9533       break;
9534
9535     case NOP_EXPR:
9536       {
9537         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9538         tree outer_type = TREE_TYPE (t);
9539
9540         return (TYPE_PRECISION (inner_type) >= TYPE_PRECISION (outer_type)
9541                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
9542       }
9543       break;
9544
9545    case ADDR_EXPR:
9546       /* Weak declarations may link to NULL.  */
9547       if (DECL_P (TREE_OPERAND (t, 0)))
9548         return !DECL_WEAK (TREE_OPERAND (t, 0));
9549       /* Constants and all other cases are never weak.  */
9550       return true;
9551
9552     case COND_EXPR:
9553       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9554               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
9555
9556     case MIN_EXPR:
9557       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9558               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9559
9560     case MAX_EXPR:
9561       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
9562         {
9563           /* When both operands are nonzero, then MAX must be too.  */
9564           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
9565             return true;
9566
9567           /* MAX where operand 0 is positive is positive.  */
9568           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9569         }
9570       /* MAX where operand 1 is positive is positive.  */
9571       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9572                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9573         return true;
9574       break;
9575
9576     case COMPOUND_EXPR:
9577     case MODIFY_EXPR:
9578     case BIND_EXPR:
9579       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
9580
9581     case SAVE_EXPR:
9582     case NON_LVALUE_EXPR:
9583       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9584
9585     case BIT_IOR_EXPR:
9586       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9587              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9588
9589     default:
9590       break;
9591     }
9592   return false;
9593 }
9594
9595 /* Return true if `r' is known to be non-negative.
9596    Only handles constants at the moment.  */
9597
9598 int
9599 rtl_expr_nonnegative_p (rtx r)
9600 {
9601   switch (GET_CODE (r))
9602     {
9603     case CONST_INT:
9604       return INTVAL (r) >= 0;
9605
9606     case CONST_DOUBLE:
9607       if (GET_MODE (r) == VOIDmode)
9608         return CONST_DOUBLE_HIGH (r) >= 0;
9609       return 0;
9610
9611     case CONST_VECTOR:
9612       {
9613         int units, i;
9614         rtx elt;
9615
9616         units = CONST_VECTOR_NUNITS (r);
9617
9618         for (i = 0; i < units; ++i)
9619           {
9620             elt = CONST_VECTOR_ELT (r, i);
9621             if (!rtl_expr_nonnegative_p (elt))
9622               return 0;
9623           }
9624
9625         return 1;
9626       }
9627
9628     case SYMBOL_REF:
9629     case LABEL_REF:
9630       /* These are always nonnegative.  */
9631       return 1;
9632
9633     default:
9634       return 0;
9635     }
9636 }
9637
9638
9639 /* See if we are applying CODE, a relational to the highest or lowest
9640    possible integer of TYPE.  If so, then the result is a compile
9641    time constant.  */
9642
9643 static tree
9644 fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
9645                        tree *op1_p)
9646 {
9647   tree op0 = *op0_p;
9648   tree op1 = *op1_p;
9649   enum tree_code code = *code_p;
9650   int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (op1)));
9651
9652   if (TREE_CODE (op1) == INTEGER_CST
9653       && ! TREE_CONSTANT_OVERFLOW (op1)
9654       && width <= HOST_BITS_PER_WIDE_INT
9655       && (INTEGRAL_TYPE_P (TREE_TYPE (op1))
9656           || POINTER_TYPE_P (TREE_TYPE (op1))))
9657     {
9658       unsigned HOST_WIDE_INT signed_max;
9659       unsigned HOST_WIDE_INT max, min;
9660
9661       signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
9662
9663       if (TYPE_UNSIGNED (TREE_TYPE (op1)))
9664         {
9665           max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9666           min = 0;
9667         }
9668       else
9669         {
9670           max = signed_max;
9671           min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9672         }
9673
9674       if (TREE_INT_CST_HIGH (op1) == 0
9675           && TREE_INT_CST_LOW (op1) == max)
9676         switch (code)
9677           {
9678           case GT_EXPR:
9679             return omit_one_operand (type, integer_zero_node, op0);
9680
9681           case GE_EXPR:
9682             *code_p = EQ_EXPR;
9683             break;
9684           case LE_EXPR:
9685             return omit_one_operand (type, integer_one_node, op0);
9686
9687           case LT_EXPR:
9688             *code_p = NE_EXPR;
9689             break;
9690
9691           /* The GE_EXPR and LT_EXPR cases above are not normally
9692              reached because of  previous transformations.  */
9693
9694           default:
9695             break;
9696           }
9697       else if (TREE_INT_CST_HIGH (op1) == 0
9698                && TREE_INT_CST_LOW (op1) == max - 1)
9699         switch (code)
9700           {
9701           case GT_EXPR:
9702             *code_p = EQ_EXPR;
9703             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9704             break;
9705           case LE_EXPR:
9706             *code_p = NE_EXPR;
9707             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9708             break;
9709           default:
9710             break;
9711           }
9712       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9713                && TREE_INT_CST_LOW (op1) == min)
9714        switch (code)
9715           {
9716           case LT_EXPR:
9717             return omit_one_operand (type, integer_zero_node, op0);
9718
9719           case LE_EXPR:
9720             *code_p = EQ_EXPR;
9721             break;
9722
9723           case GE_EXPR:
9724             return omit_one_operand (type, integer_one_node, op0);
9725
9726           case GT_EXPR:
9727             *code_p = NE_EXPR;
9728             break;
9729
9730           default:
9731             break;
9732           }
9733       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9734                && TREE_INT_CST_LOW (op1) == min + 1)
9735         switch (code)
9736           {
9737           case GE_EXPR:
9738             *code_p = NE_EXPR;
9739             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9740             break;
9741           case LT_EXPR:
9742             *code_p = EQ_EXPR;
9743             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9744             break;
9745           default:
9746             break;
9747           }
9748
9749       else if (TREE_INT_CST_HIGH (op1) == 0
9750                && TREE_INT_CST_LOW (op1) == signed_max
9751                && TYPE_UNSIGNED (TREE_TYPE (op1))
9752                /* signed_type does not work on pointer types.  */
9753                && INTEGRAL_TYPE_P (TREE_TYPE (op1)))
9754         {
9755           /* The following case also applies to X < signed_max+1
9756              and X >= signed_max+1 because previous transformations.  */
9757           if (code == LE_EXPR || code == GT_EXPR)
9758             {
9759               tree st0, st1, exp, retval;
9760               st0 = lang_hooks.types.signed_type (TREE_TYPE (op0));
9761               st1 = lang_hooks.types.signed_type (TREE_TYPE (op1));
9762
9763               exp = build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9764                             type,
9765                             fold_convert (st0, op0),
9766                             fold_convert (st1, integer_zero_node));
9767
9768               retval
9769                 = nondestructive_fold_binary_to_constant (TREE_CODE (exp),
9770                                                           TREE_TYPE (exp),
9771                                                           TREE_OPERAND (exp, 0),
9772                                                           TREE_OPERAND (exp, 1));
9773
9774               /* If we are in gimple form, then returning EXP would create
9775                  non-gimple expressions.  Clearing it is safe and insures
9776                  we do not allow a non-gimple expression to escape.  */
9777               if (in_gimple_form)
9778                 exp = NULL;
9779
9780               return (retval ? retval : exp);
9781             }
9782         }
9783     }
9784
9785   return NULL_TREE;
9786 }
9787
9788
9789 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
9790    attempt to fold the expression to a constant without modifying TYPE,
9791    OP0 or OP1.
9792
9793    If the expression could be simplified to a constant, then return
9794    the constant.  If the expression would not be simplified to a
9795    constant, then return NULL_TREE.
9796
9797    Note this is primarily designed to be called after gimplification
9798    of the tree structures and when at least one operand is a constant.
9799    As a result of those simplifying assumptions this routine is far
9800    simpler than the generic fold routine.  */
9801
9802 tree
9803 nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
9804                                         tree op0, tree op1)
9805 {
9806   int wins = 1;
9807   tree subop0;
9808   tree subop1;
9809   tree tem;
9810
9811   /* If this is a commutative operation, and ARG0 is a constant, move it
9812      to ARG1 to reduce the number of tests below.  */
9813   if (commutative_tree_code (code)
9814       && (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST))
9815     {
9816       tem = op0;
9817       op0 = op1;
9818       op1 = tem;
9819     }
9820
9821   /* If either operand is a complex type, extract its real component.  */
9822   if (TREE_CODE (op0) == COMPLEX_CST)
9823     subop0 = TREE_REALPART (op0);
9824   else
9825     subop0 = op0;
9826
9827   if (TREE_CODE (op1) == COMPLEX_CST)
9828     subop1 = TREE_REALPART (op1);
9829   else
9830     subop1 = op1;
9831
9832   /* Note if either argument is not a real or integer constant.
9833      With a few exceptions, simplification is limited to cases
9834      where both arguments are constants.  */
9835   if ((TREE_CODE (subop0) != INTEGER_CST
9836        && TREE_CODE (subop0) != REAL_CST)
9837       || (TREE_CODE (subop1) != INTEGER_CST
9838           && TREE_CODE (subop1) != REAL_CST))
9839     wins = 0;
9840
9841   switch (code)
9842     {
9843     case PLUS_EXPR:
9844       /* (plus (address) (const_int)) is a constant.  */
9845       if (TREE_CODE (op0) == PLUS_EXPR
9846           && TREE_CODE (op1) == INTEGER_CST
9847           && (TREE_CODE (TREE_OPERAND (op0, 0)) == ADDR_EXPR
9848               || (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
9849                   && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (op0, 0), 0))
9850                       == ADDR_EXPR)))
9851           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
9852         {
9853           return build2 (PLUS_EXPR, type, TREE_OPERAND (op0, 0),
9854                          const_binop (PLUS_EXPR, op1,
9855                                       TREE_OPERAND (op0, 1), 0));
9856         }
9857     case BIT_XOR_EXPR:
9858
9859     binary:
9860       if (!wins)
9861         return NULL_TREE;
9862
9863       /* Both arguments are constants.  Simplify.  */
9864       tem = const_binop (code, op0, op1, 0);
9865       if (tem != NULL_TREE)
9866         {
9867           /* The return value should always have the same type as
9868              the original expression.  */
9869           if (TREE_TYPE (tem) != type)
9870             tem = fold_convert (type, tem);
9871
9872           return tem;
9873         }
9874       return NULL_TREE;
9875
9876     case MINUS_EXPR:
9877       /* Fold &x - &x.  This can happen from &x.foo - &x.
9878          This is unsafe for certain floats even in non-IEEE formats.
9879          In IEEE, it is unsafe because it does wrong for NaNs.
9880          Also note that operand_equal_p is always false if an
9881          operand is volatile.  */
9882       if (! FLOAT_TYPE_P (type) && operand_equal_p (op0, op1, 0))
9883         return fold_convert (type, integer_zero_node);
9884
9885       goto binary;
9886
9887     case MULT_EXPR:
9888     case BIT_AND_EXPR:
9889       /* Special case multiplication or bitwise AND where one argument
9890          is zero.  */
9891       if (! FLOAT_TYPE_P (type) && integer_zerop (op1))
9892         return omit_one_operand (type, op1, op0);
9893       else
9894         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (op0)))
9895             && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op0)))
9896             && real_zerop (op1))
9897           return omit_one_operand (type, op1, op0);
9898
9899       goto binary;
9900
9901     case BIT_IOR_EXPR:
9902       /* Special case when we know the result will be all ones.  */
9903       if (integer_all_onesp (op1))
9904         return omit_one_operand (type, op1, op0);
9905
9906       goto binary;
9907
9908     case TRUNC_DIV_EXPR:
9909     case ROUND_DIV_EXPR:
9910     case FLOOR_DIV_EXPR:
9911     case CEIL_DIV_EXPR:
9912     case EXACT_DIV_EXPR:
9913     case TRUNC_MOD_EXPR:
9914     case ROUND_MOD_EXPR:
9915     case FLOOR_MOD_EXPR:
9916     case CEIL_MOD_EXPR:
9917     case RDIV_EXPR:
9918       /* Division by zero is undefined.  */
9919       if (integer_zerop (op1))
9920         return NULL_TREE;
9921
9922       if (TREE_CODE (op1) == REAL_CST
9923           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (op1)))
9924           && real_zerop (op1))
9925         return NULL_TREE;
9926
9927       goto binary;
9928
9929     case MIN_EXPR:
9930       if (INTEGRAL_TYPE_P (type)
9931           && operand_equal_p (op1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
9932         return omit_one_operand (type, op1, op0);
9933
9934       goto binary;
9935
9936     case MAX_EXPR:
9937       if (INTEGRAL_TYPE_P (type)
9938           && TYPE_MAX_VALUE (type)
9939           && operand_equal_p (op1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
9940         return omit_one_operand (type, op1, op0);
9941
9942       goto binary;
9943
9944     case RSHIFT_EXPR:
9945       /* Optimize -1 >> x for arithmetic right shifts.  */
9946       if (integer_all_onesp (op0) && ! TYPE_UNSIGNED (type))
9947         return omit_one_operand (type, op0, op1);
9948       /* ... fall through ...  */
9949
9950     case LSHIFT_EXPR:
9951       if (integer_zerop (op0))
9952         return omit_one_operand (type, op0, op1);
9953
9954       /* Since negative shift count is not well-defined, don't
9955          try to compute it in the compiler.  */
9956       if (TREE_CODE (op1) == INTEGER_CST && tree_int_cst_sgn (op1) < 0)
9957         return NULL_TREE;
9958
9959       goto binary;
9960
9961     case LROTATE_EXPR:
9962     case RROTATE_EXPR:
9963       /* -1 rotated either direction by any amount is still -1.  */
9964       if (integer_all_onesp (op0))
9965         return omit_one_operand (type, op0, op1);
9966
9967       /* 0 rotated either direction by any amount is still zero.  */
9968       if (integer_zerop (op0))
9969         return omit_one_operand (type, op0, op1);
9970
9971       goto binary;
9972
9973     case COMPLEX_EXPR:
9974       if (wins)
9975         return build_complex (type, op0, op1);
9976       return NULL_TREE;
9977
9978     case LT_EXPR:
9979     case LE_EXPR:
9980     case GT_EXPR:
9981     case GE_EXPR:
9982     case EQ_EXPR:
9983     case NE_EXPR:
9984       /* If one arg is a real or integer constant, put it last.  */
9985       if ((TREE_CODE (op0) == INTEGER_CST
9986            && TREE_CODE (op1) != INTEGER_CST)
9987           || (TREE_CODE (op0) == REAL_CST
9988               && TREE_CODE (op0) != REAL_CST))
9989         {
9990           tree temp;
9991
9992           temp = op0;
9993           op0 = op1;
9994           op1 = temp;
9995           code = swap_tree_comparison (code);
9996         }
9997
9998       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
9999          This transformation affects the cases which are handled in later
10000          optimizations involving comparisons with non-negative constants.  */
10001       if (TREE_CODE (op1) == INTEGER_CST
10002           && TREE_CODE (op0) != INTEGER_CST
10003           && tree_int_cst_sgn (op1) > 0)
10004         {
10005           switch (code)
10006             {
10007             case GE_EXPR:
10008               code = GT_EXPR;
10009               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10010               break;
10011
10012             case LT_EXPR:
10013               code = LE_EXPR;
10014               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10015               break;
10016
10017             default:
10018               break;
10019             }
10020         }
10021
10022       tem = fold_relational_hi_lo (&code, type, &op0, &op1);
10023       if (tem)
10024         return tem;
10025
10026       /* Fall through.  */
10027
10028     case ORDERED_EXPR:
10029     case UNORDERED_EXPR:
10030     case UNLT_EXPR:
10031     case UNLE_EXPR:
10032     case UNGT_EXPR:
10033     case UNGE_EXPR:
10034     case UNEQ_EXPR:
10035     case LTGT_EXPR:
10036       if (!wins)
10037         return NULL_TREE;
10038
10039       return fold_relational_const (code, type, op0, op1);
10040
10041     case RANGE_EXPR:
10042       /* This could probably be handled.  */
10043       return NULL_TREE;
10044
10045     case TRUTH_AND_EXPR:
10046       /* If second arg is constant zero, result is zero, but first arg
10047          must be evaluated.  */
10048       if (integer_zerop (op1))
10049         return omit_one_operand (type, op1, op0);
10050       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10051          case will be handled here.  */
10052       if (integer_zerop (op0))
10053         return omit_one_operand (type, op0, op1);
10054       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10055         return constant_boolean_node (true, type);
10056       return NULL_TREE;
10057
10058     case TRUTH_OR_EXPR:
10059       /* If second arg is constant true, result is true, but we must
10060          evaluate first arg.  */
10061       if (TREE_CODE (op1) == INTEGER_CST && ! integer_zerop (op1))
10062         return omit_one_operand (type, op1, op0);
10063       /* Likewise for first arg, but note this only occurs here for
10064          TRUTH_OR_EXPR.  */
10065       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
10066         return omit_one_operand (type, op0, op1);
10067       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10068         return constant_boolean_node (false, type);
10069       return NULL_TREE;
10070
10071     case TRUTH_XOR_EXPR:
10072       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10073         {
10074           int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
10075           return constant_boolean_node (x, type);
10076         }
10077       return NULL_TREE;
10078
10079     default:
10080       return NULL_TREE;
10081     }
10082 }
10083
10084 /* Given the components of a unary expression CODE, TYPE and OP0,
10085    attempt to fold the expression to a constant without modifying
10086    TYPE or OP0.
10087
10088    If the expression could be simplified to a constant, then return
10089    the constant.  If the expression would not be simplified to a
10090    constant, then return NULL_TREE.
10091
10092    Note this is primarily designed to be called after gimplification
10093    of the tree structures and when op0 is a constant.  As a result
10094    of those simplifying assumptions this routine is far simpler than
10095    the generic fold routine.  */
10096
10097 tree
10098 nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
10099                                        tree op0)
10100 {
10101   /* Make sure we have a suitable constant argument.  */
10102   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
10103     {
10104       tree subop;
10105
10106       if (TREE_CODE (op0) == COMPLEX_CST)
10107         subop = TREE_REALPART (op0);
10108       else
10109         subop = op0;
10110
10111       if (TREE_CODE (subop) != INTEGER_CST && TREE_CODE (subop) != REAL_CST)
10112         return NULL_TREE;
10113     }
10114
10115   switch (code)
10116     {
10117     case NOP_EXPR:
10118     case FLOAT_EXPR:
10119     case CONVERT_EXPR:
10120     case FIX_TRUNC_EXPR:
10121     case FIX_FLOOR_EXPR:
10122     case FIX_CEIL_EXPR:
10123       return fold_convert_const (code, type, op0);
10124
10125     case NEGATE_EXPR:
10126       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10127         return fold_negate_const (op0, type);
10128       else
10129         return NULL_TREE;
10130
10131     case ABS_EXPR:
10132       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10133         return fold_abs_const (op0, type);
10134       else
10135         return NULL_TREE;
10136
10137     case BIT_NOT_EXPR:
10138       if (TREE_CODE (op0) == INTEGER_CST)
10139         return fold_not_const (op0, type);
10140       else
10141         return NULL_TREE;
10142
10143     case REALPART_EXPR:
10144       if (TREE_CODE (op0) == COMPLEX_CST)
10145         return TREE_REALPART (op0);
10146       else
10147         return NULL_TREE;
10148
10149     case IMAGPART_EXPR:
10150       if (TREE_CODE (op0) == COMPLEX_CST)
10151         return TREE_IMAGPART (op0);
10152       else
10153         return NULL_TREE;
10154
10155     case CONJ_EXPR:
10156       if (TREE_CODE (op0) == COMPLEX_CST
10157           && TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
10158         return build_complex (type, TREE_REALPART (op0),
10159                               negate_expr (TREE_IMAGPART (op0)));
10160       return NULL_TREE;
10161
10162     default:
10163       return NULL_TREE;
10164     }
10165 }
10166
10167 /* If EXP represents referencing an element in a constant string
10168    (either via pointer arithmetic or array indexing), return the
10169    tree representing the value accessed, otherwise return NULL.  */
10170
10171 tree
10172 fold_read_from_constant_string (tree exp)
10173 {
10174   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
10175     {
10176       tree exp1 = TREE_OPERAND (exp, 0);
10177       tree index;
10178       tree string;
10179
10180       if (TREE_CODE (exp) == INDIRECT_REF)
10181         string = string_constant (exp1, &index);
10182       else
10183         {
10184           tree low_bound = array_ref_low_bound (exp);
10185           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
10186
10187           /* Optimize the special-case of a zero lower bound.
10188
10189              We convert the low_bound to sizetype to avoid some problems
10190              with constant folding.  (E.g. suppose the lower bound is 1,
10191              and its mode is QI.  Without the conversion,l (ARRAY
10192              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
10193              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
10194           if (! integer_zerop (low_bound))
10195             index = size_diffop (index, fold_convert (sizetype, low_bound));
10196
10197           string = exp1;
10198         }
10199
10200       if (string
10201           && TREE_TYPE (exp) == TREE_TYPE (TREE_TYPE (string))
10202           && TREE_CODE (string) == STRING_CST
10203           && TREE_CODE (index) == INTEGER_CST
10204           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
10205           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
10206               == MODE_INT)
10207           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
10208         return fold_convert (TREE_TYPE (exp),
10209                              build_int_2 ((TREE_STRING_POINTER (string)
10210                                           [TREE_INT_CST_LOW (index)]), 0));
10211     }
10212   return NULL;
10213 }
10214
10215 /* Return the tree for neg (ARG0) when ARG0 is known to be either
10216    an integer constant or real constant.
10217
10218    TYPE is the type of the result.  */
10219
10220 static tree
10221 fold_negate_const (tree arg0, tree type)
10222 {
10223   tree t = NULL_TREE;
10224
10225   if (TREE_CODE (arg0) == INTEGER_CST)
10226     {
10227       unsigned HOST_WIDE_INT low;
10228       HOST_WIDE_INT high;
10229       int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10230                                  TREE_INT_CST_HIGH (arg0),
10231                                  &low, &high);
10232       t = build_int_2 (low, high);
10233       TREE_TYPE (t) = type;
10234       TREE_OVERFLOW (t)
10235         = (TREE_OVERFLOW (arg0)
10236            | force_fit_type (t, overflow && !TYPE_UNSIGNED (type)));
10237       TREE_CONSTANT_OVERFLOW (t)
10238         = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
10239     }
10240   else if (TREE_CODE (arg0) == REAL_CST)
10241     t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10242 #ifdef ENABLE_CHECKING
10243   else
10244     abort ();
10245 #endif
10246
10247   return t;
10248 }
10249
10250 /* Return the tree for abs (ARG0) when ARG0 is known to be either
10251    an integer constant or real constant.
10252
10253    TYPE is the type of the result.  */
10254
10255 tree
10256 fold_abs_const (tree arg0, tree type)
10257 {
10258   tree t = NULL_TREE;
10259
10260   if (TREE_CODE (arg0) == INTEGER_CST)
10261     {
10262       /* If the value is unsigned, then the absolute value is
10263          the same as the ordinary value.  */
10264       if (TYPE_UNSIGNED (type))
10265         return arg0;
10266       /* Similarly, if the value is non-negative.  */
10267       else if (INT_CST_LT (integer_minus_one_node, arg0))
10268         return arg0;
10269       /* If the value is negative, then the absolute value is
10270          its negation.  */
10271       else
10272         {
10273           unsigned HOST_WIDE_INT low;
10274           HOST_WIDE_INT high;
10275           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10276                                      TREE_INT_CST_HIGH (arg0),
10277                                      &low, &high);
10278           t = build_int_2 (low, high);
10279           TREE_TYPE (t) = type;
10280           TREE_OVERFLOW (t)
10281             = (TREE_OVERFLOW (arg0)
10282                | force_fit_type (t, overflow));
10283           TREE_CONSTANT_OVERFLOW (t)
10284             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
10285           return t;
10286         }
10287     }
10288   else if (TREE_CODE (arg0) == REAL_CST)
10289     {
10290       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
10291         return build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10292       else
10293         return arg0;
10294     }
10295 #ifdef ENABLE_CHECKING
10296   else
10297     abort ();
10298 #endif
10299
10300   return t;
10301 }
10302
10303 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
10304    constant.  TYPE is the type of the result.  */
10305
10306 static tree
10307 fold_not_const (tree arg0, tree type)
10308 {
10309   tree t = NULL_TREE;
10310
10311   if (TREE_CODE (arg0) == INTEGER_CST)
10312     {
10313       t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
10314                        ~ TREE_INT_CST_HIGH (arg0));
10315       TREE_TYPE (t) = type;
10316       force_fit_type (t, 0);
10317       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
10318       TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
10319     }
10320 #ifdef ENABLE_CHECKING
10321   else
10322     abort ();
10323 #endif
10324
10325   return t;
10326 }
10327
10328 /* Given CODE, a relational operator, the target type, TYPE and two
10329    constant operands OP0 and OP1, return the result of the
10330    relational operation.  If the result is not a compile time
10331    constant, then return NULL_TREE.  */
10332
10333 static tree
10334 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
10335 {
10336   int result, invert;
10337
10338   /* From here on, the only cases we handle are when the result is
10339      known to be a constant.  */
10340
10341   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10342     {
10343       /* Handle the cases where either operand is a NaN.  */
10344       if (REAL_VALUE_ISNAN (TREE_REAL_CST (op0))
10345           || REAL_VALUE_ISNAN (TREE_REAL_CST (op1)))
10346         {
10347           switch (code)
10348             {
10349             case EQ_EXPR:
10350             case ORDERED_EXPR:
10351               result = 0;
10352               break;
10353
10354             case NE_EXPR:
10355             case UNORDERED_EXPR:
10356             case UNLT_EXPR:
10357             case UNLE_EXPR:
10358             case UNGT_EXPR:
10359             case UNGE_EXPR:
10360             case UNEQ_EXPR:
10361               result = 1;
10362               break;
10363
10364             case LT_EXPR:
10365             case LE_EXPR:
10366             case GT_EXPR:
10367             case GE_EXPR:
10368             case LTGT_EXPR:
10369               if (flag_trapping_math)
10370                 return NULL_TREE;
10371               result = 0;
10372               break;
10373
10374             default:
10375               abort ();
10376             }
10377
10378           return constant_boolean_node (result, type);
10379         }
10380
10381       /* From here on we're sure there are no NaNs.  */
10382       switch (code)
10383         {
10384         case ORDERED_EXPR:
10385           return constant_boolean_node (true, type);
10386
10387         case UNORDERED_EXPR:
10388           return constant_boolean_node (false, type);
10389
10390         case UNLT_EXPR:
10391           code = LT_EXPR;
10392           break;
10393         case UNLE_EXPR:
10394           code = LE_EXPR;
10395           break;
10396         case UNGT_EXPR:
10397           code = GT_EXPR;
10398           break;
10399         case UNGE_EXPR:
10400           code = GE_EXPR;
10401           break;
10402         case UNEQ_EXPR:
10403           code = EQ_EXPR;
10404           break;
10405         case LTGT_EXPR:
10406           code = NE_EXPR;
10407           break;
10408
10409         default:
10410           break;
10411         }
10412     }
10413
10414   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
10415
10416      To compute GT, swap the arguments and do LT.
10417      To compute GE, do LT and invert the result.
10418      To compute LE, swap the arguments, do LT and invert the result.
10419      To compute NE, do EQ and invert the result.
10420
10421      Therefore, the code below must handle only EQ and LT.  */
10422
10423   if (code == LE_EXPR || code == GT_EXPR)
10424     {
10425       tree tem = op0;
10426       op0 = op1;
10427       op1 = tem;
10428       code = swap_tree_comparison (code);
10429     }
10430
10431   /* Note that it is safe to invert for real values here because we
10432      have already handled the one case that it matters.  */
10433
10434   invert = 0;
10435   if (code == NE_EXPR || code == GE_EXPR)
10436     {
10437       invert = 1;
10438       code = invert_tree_comparison (code, false);
10439     }
10440
10441   /* Compute a result for LT or EQ if args permit;
10442      Otherwise return T.  */
10443   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10444     {
10445       if (code == EQ_EXPR)
10446         result = tree_int_cst_equal (op0, op1);
10447       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
10448         result = INT_CST_LT_UNSIGNED (op0, op1);
10449       else
10450         result = INT_CST_LT (op0, op1);
10451     }
10452
10453   else if (code == EQ_EXPR && !TREE_SIDE_EFFECTS (op0)
10454            && integer_zerop (op1) && tree_expr_nonzero_p (op0))
10455     result = 0;
10456
10457   /* Two real constants can be compared explicitly.  */
10458   else if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10459     {
10460       if (code == EQ_EXPR)
10461         result = REAL_VALUES_EQUAL (TREE_REAL_CST (op0),
10462                                     TREE_REAL_CST (op1));
10463       else
10464         result = REAL_VALUES_LESS (TREE_REAL_CST (op0),
10465                                    TREE_REAL_CST (op1));
10466     }
10467   else
10468     return NULL_TREE;
10469
10470   if (invert)
10471     result ^= 1;
10472   return constant_boolean_node (result, type);
10473 }
10474
10475 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
10476    avoid confusing the gimplify process.  */
10477
10478 tree
10479 build_fold_addr_expr_with_type (tree t, tree ptrtype)
10480 {
10481   if (TREE_CODE (t) == INDIRECT_REF)
10482     {
10483       t = TREE_OPERAND (t, 0);
10484       if (TREE_TYPE (t) != ptrtype)
10485         t = build1 (NOP_EXPR, ptrtype, t);
10486     }
10487   else
10488     {
10489       tree base = t;
10490
10491       while (handled_component_p (base)
10492              || TREE_CODE (base) == REALPART_EXPR
10493              || TREE_CODE (base) == IMAGPART_EXPR)
10494         base = TREE_OPERAND (base, 0);
10495       if (DECL_P (base))
10496         TREE_ADDRESSABLE (base) = 1;
10497
10498       t = build1 (ADDR_EXPR, ptrtype, t);
10499     }
10500
10501   return t;
10502 }
10503
10504 tree
10505 build_fold_addr_expr (tree t)
10506 {
10507   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
10508 }
10509
10510 /* Builds an expression for an indirection through T, simplifying some
10511    cases.  */
10512
10513 tree
10514 build_fold_indirect_ref (tree t)
10515 {
10516   tree type = TREE_TYPE (TREE_TYPE (t));
10517   tree sub = t;
10518   tree subtype;
10519
10520   STRIP_NOPS (sub);
10521   if (TREE_CODE (sub) == ADDR_EXPR)
10522     {
10523       tree op = TREE_OPERAND (sub, 0);
10524       tree optype = TREE_TYPE (op);
10525       /* *&p => p */
10526       if (lang_hooks.types_compatible_p (type, optype))
10527         return op;
10528       /* *(foo *)&fooarray => fooarray[0] */
10529       else if (TREE_CODE (optype) == ARRAY_TYPE
10530                && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
10531         return build4 (ARRAY_REF, type, op, size_zero_node, NULL_TREE, NULL_TREE);
10532     }
10533
10534   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
10535   subtype = TREE_TYPE (sub);
10536   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
10537       && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
10538     {
10539       sub = build_fold_indirect_ref (sub);
10540       return build4 (ARRAY_REF, type, sub, size_zero_node, NULL_TREE, NULL_TREE);
10541     }
10542
10543   return build1 (INDIRECT_REF, type, t);
10544 }
10545
10546 #include "gt-fold-const.h"