gcc/fold-const.c

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