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