gcc/fold-const.c

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