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 nonzero,
 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 nonzero
 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       case UNEQ_EXPR:
4166         tem = fold_convert (arg1_type, arg1);
4167         return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
4168       case NE_EXPR:
4169       case LTGT_EXPR:
4170         return pedantic_non_lvalue (fold_convert (type, arg1));
4171       case UNGE_EXPR:
4172       case UNGT_EXPR:
4173         if (flag_trapping_math)
4174           break;
4175         /* Fall through.  */
4176       case GE_EXPR:
4177       case GT_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 pedantic_non_lvalue (fold_convert (type, tem));
4183       case UNLE_EXPR:
4184       case UNLT_EXPR:
4185         if (flag_trapping_math)
4186           break;
4187       case LE_EXPR:
4188       case LT_EXPR:
4189         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4190           arg1 = fold_convert (lang_hooks.types.signed_type
4191                                (TREE_TYPE (arg1)), arg1);
4192         tem = fold (build1 (ABS_EXPR, TREE_TYPE (arg1), arg1));
4193         return negate_expr (fold_convert (type, tem));
4194       default:
4195         gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
4196         break;
4197       }
4198
4199   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4200      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4201      both transformations are correct when A is NaN: A != 0
4202      is then true, and A == 0 is false.  */
4203
4204   if (integer_zerop (arg01) && integer_zerop (arg2))
4205     {
4206       if (comp_code == NE_EXPR)
4207         return pedantic_non_lvalue (fold_convert (type, arg1));
4208       else if (comp_code == EQ_EXPR)
4209         return fold_convert (type, integer_zero_node);
4210     }
4211
4212   /* Try some transformations of A op B ? A : B.
4213
4214      A == B? A : B    same as B
4215      A != B? A : B    same as A
4216      A >= B? A : B    same as max (A, B)
4217      A > B?  A : B    same as max (B, A)
4218      A <= B? A : B    same as min (A, B)
4219      A < B?  A : B    same as min (B, A)
4220
4221      As above, these transformations don't work in the presence
4222      of signed zeros.  For example, if A and B are zeros of
4223      opposite sign, the first two transformations will change
4224      the sign of the result.  In the last four, the original
4225      expressions give different results for (A=+0, B=-0) and
4226      (A=-0, B=+0), but the transformed expressions do not.
4227
4228      The first two transformations are correct if either A or B
4229      is a NaN.  In the first transformation, the condition will
4230      be false, and B will indeed be chosen.  In the case of the
4231      second transformation, the condition A != B will be true,
4232      and A will be chosen.
4233
4234      The conversions to max() and min() are not correct if B is
4235      a number and A is not.  The conditions in the original
4236      expressions will be false, so all four give B.  The min()
4237      and max() versions would give a NaN instead.  */
4238   if (operand_equal_for_comparison_p (arg01, arg2, arg00))
4239     {
4240       tree comp_op0 = arg00;
4241       tree comp_op1 = arg01;
4242       tree comp_type = TREE_TYPE (comp_op0);
4243
4244       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4245       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4246         {
4247           comp_type = type;
4248           comp_op0 = arg1;
4249           comp_op1 = arg2;
4250         }
4251
4252       switch (comp_code)
4253         {
4254         case EQ_EXPR:
4255           return pedantic_non_lvalue (fold_convert (type, arg2));
4256         case NE_EXPR:
4257           return pedantic_non_lvalue (fold_convert (type, arg1));
4258         case LE_EXPR:
4259         case LT_EXPR:
4260         case UNLE_EXPR:
4261         case UNLT_EXPR:
4262           /* In C++ a ?: expression can be an lvalue, so put the
4263              operand which will be used if they are equal first
4264              so that we can convert this back to the
4265              corresponding COND_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 = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4271                     ? fold (build2 (MIN_EXPR, comp_type, comp_op0, comp_op1))
4272                     : fold (build2 (MIN_EXPR, comp_type, comp_op1, comp_op0));
4273               return pedantic_non_lvalue (fold_convert (type, tem));
4274             }
4275           break;
4276         case GE_EXPR:
4277         case GT_EXPR:
4278         case UNGE_EXPR:
4279         case UNGT_EXPR:
4280           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4281             {
4282               comp_op0 = fold_convert (comp_type, comp_op0);
4283               comp_op1 = fold_convert (comp_type, comp_op1);
4284               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4285                     ? fold (build2 (MAX_EXPR, comp_type, comp_op0, comp_op1))
4286                     : fold (build2 (MAX_EXPR, comp_type, comp_op1, comp_op0));
4287               return pedantic_non_lvalue (fold_convert (type, tem));
4288             }
4289           break;
4290         case UNEQ_EXPR:
4291           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4292             return pedantic_non_lvalue (fold_convert (type, arg2));
4293           break;
4294         case LTGT_EXPR:
4295           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4296             return pedantic_non_lvalue (fold_convert (type, arg1));
4297           break;
4298         default:
4299           gcc_assert (TREE_CODE_CLASS (comp_code) == '<');
4300           break;
4301         }
4302     }
4303
4304   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4305      we might still be able to simplify this.  For example,
4306      if C1 is one less or one more than C2, this might have started
4307      out as a MIN or MAX and been transformed by this function.
4308      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4309
4310   if (INTEGRAL_TYPE_P (type)
4311       && TREE_CODE (arg01) == INTEGER_CST
4312       && TREE_CODE (arg2) == INTEGER_CST)
4313     switch (comp_code)
4314       {
4315       case EQ_EXPR:
4316         /* We can replace A with C1 in this case.  */
4317         arg1 = fold_convert (type, arg01);
4318         return fold (build3 (COND_EXPR, type, arg0, arg1, arg2));
4319
4320       case LT_EXPR:
4321         /* If C1 is C2 + 1, this is min(A, C2).  */
4322         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4323                                OEP_ONLY_CONST)
4324             && operand_equal_p (arg01,
4325                                 const_binop (PLUS_EXPR, arg2,
4326                                              integer_one_node, 0),
4327                                 OEP_ONLY_CONST))
4328           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4329                                                     type, arg1, arg2)));
4330         break;
4331
4332       case LE_EXPR:
4333         /* If C1 is C2 - 1, this is min(A, C2).  */
4334         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4335                                OEP_ONLY_CONST)
4336             && operand_equal_p (arg01,
4337                                 const_binop (MINUS_EXPR, arg2,
4338                                              integer_one_node, 0),
4339                                 OEP_ONLY_CONST))
4340           return pedantic_non_lvalue (fold (build2 (MIN_EXPR,
4341                                                     type, arg1, arg2)));
4342         break;
4343
4344       case GT_EXPR:
4345         /* If C1 is C2 - 1, this is max(A, C2).  */
4346         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4347                                OEP_ONLY_CONST)
4348             && operand_equal_p (arg01,
4349                                 const_binop (MINUS_EXPR, arg2,
4350                                              integer_one_node, 0),
4351                                 OEP_ONLY_CONST))
4352           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4353                                                     type, arg1, arg2)));
4354         break;
4355
4356       case GE_EXPR:
4357         /* If C1 is C2 + 1, this is max(A, C2).  */
4358         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4359                                OEP_ONLY_CONST)
4360             && operand_equal_p (arg01,
4361                                 const_binop (PLUS_EXPR, arg2,
4362                                              integer_one_node, 0),
4363                                 OEP_ONLY_CONST))
4364           return pedantic_non_lvalue (fold (build2 (MAX_EXPR,
4365                                                     type, arg1, arg2)));
4366         break;
4367       case NE_EXPR:
4368         break;
4369       default:
4370         gcc_unreachable ();
4371       }
4372
4373   return NULL_TREE;
4374 }
4375
4376
4377 \f
4378 #ifndef RANGE_TEST_NON_SHORT_CIRCUIT
4379 #define RANGE_TEST_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
4380 #endif
4381
4382 /* EXP is some logical combination of boolean tests.  See if we can
4383    merge it into some range test.  Return the new tree if so.  */
4384
4385 static tree
4386 fold_range_test (tree exp)
4387 {
4388   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
4389                || TREE_CODE (exp) == TRUTH_OR_EXPR);
4390   int in0_p, in1_p, in_p;
4391   tree low0, low1, low, high0, high1, high;
4392   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
4393   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
4394   tree tem;
4395
4396   /* If this is an OR operation, invert both sides; we will invert
4397      again at the end.  */
4398   if (or_op)
4399     in0_p = ! in0_p, in1_p = ! in1_p;
4400
4401   /* If both expressions are the same, if we can merge the ranges, and we
4402      can build the range test, return it or it inverted.  If one of the
4403      ranges is always true or always false, consider it to be the same
4404      expression as the other.  */
4405   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4406       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4407                        in1_p, low1, high1)
4408       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
4409                                          lhs != 0 ? lhs
4410                                          : rhs != 0 ? rhs : integer_zero_node,
4411                                          in_p, low, high))))
4412     return or_op ? invert_truthvalue (tem) : tem;
4413
4414   /* On machines where the branch cost is expensive, if this is a
4415      short-circuited branch and the underlying object on both sides
4416      is the same, make a non-short-circuit operation.  */
4417   else if (RANGE_TEST_NON_SHORT_CIRCUIT
4418            && lhs != 0 && rhs != 0
4419            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4420                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
4421            && operand_equal_p (lhs, rhs, 0))
4422     {
4423       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4424          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4425          which cases we can't do this.  */
4426       if (simple_operand_p (lhs))
4427         return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4428                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4429                        TREE_TYPE (exp), TREE_OPERAND (exp, 0),
4430                        TREE_OPERAND (exp, 1));
4431
4432       else if (lang_hooks.decls.global_bindings_p () == 0
4433                && ! CONTAINS_PLACEHOLDER_P (lhs))
4434         {
4435           tree common = save_expr (lhs);
4436
4437           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
4438                                              or_op ? ! in0_p : in0_p,
4439                                              low0, high0))
4440               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
4441                                                  or_op ? ! in1_p : in1_p,
4442                                                  low1, high1))))
4443             return build2 (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
4444                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4445                            TREE_TYPE (exp), lhs, rhs);
4446         }
4447     }
4448
4449   return 0;
4450 }
4451 \f
4452 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4453    bit value.  Arrange things so the extra bits will be set to zero if and
4454    only if C is signed-extended to its full width.  If MASK is nonzero,
4455    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4456
4457 static tree
4458 unextend (tree c, int p, int unsignedp, tree mask)
4459 {
4460   tree type = TREE_TYPE (c);
4461   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4462   tree temp;
4463
4464   if (p == modesize || unsignedp)
4465     return c;
4466
4467   /* We work by getting just the sign bit into the low-order bit, then
4468      into the high-order bit, then sign-extend.  We then XOR that value
4469      with C.  */
4470   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
4471   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
4472
4473   /* We must use a signed type in order to get an arithmetic right shift.
4474      However, we must also avoid introducing accidental overflows, so that
4475      a subsequent call to integer_zerop will work.  Hence we must
4476      do the type conversion here.  At this point, the constant is either
4477      zero or one, and the conversion to a signed type can never overflow.
4478      We could get an overflow if this conversion is done anywhere else.  */
4479   if (TYPE_UNSIGNED (type))
4480     temp = fold_convert (lang_hooks.types.signed_type (type), temp);
4481
4482   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
4483   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
4484   if (mask != 0)
4485     temp = const_binop (BIT_AND_EXPR, temp,
4486                         fold_convert (TREE_TYPE (c), mask), 0);
4487   /* If necessary, convert the type back to match the type of C.  */
4488   if (TYPE_UNSIGNED (type))
4489     temp = fold_convert (type, temp);
4490
4491   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
4492 }
4493 \f
4494 /* Find ways of folding logical expressions of LHS and RHS:
4495    Try to merge two comparisons to the same innermost item.
4496    Look for range tests like "ch >= '0' && ch <= '9'".
4497    Look for combinations of simple terms on machines with expensive branches
4498    and evaluate the RHS unconditionally.
4499
4500    For example, if we have p->a == 2 && p->b == 4 and we can make an
4501    object large enough to span both A and B, we can do this with a comparison
4502    against the object ANDed with the a mask.
4503
4504    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
4505    operations to do this with one comparison.
4506
4507    We check for both normal comparisons and the BIT_AND_EXPRs made this by
4508    function and the one above.
4509
4510    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
4511    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
4512
4513    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
4514    two operands.
4515
4516    We return the simplified tree or 0 if no optimization is possible.  */
4517
4518 static tree
4519 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
4520 {
4521   /* If this is the "or" of two comparisons, we can do something if
4522      the comparisons are NE_EXPR.  If this is the "and", we can do something
4523      if the comparisons are EQ_EXPR.  I.e.,
4524         (a->b == 2 && a->c == 4) can become (a->new == NEW).
4525
4526      WANTED_CODE is this operation code.  For single bit fields, we can
4527      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
4528      comparison for one-bit fields.  */
4529
4530   enum tree_code wanted_code;
4531   enum tree_code lcode, rcode;
4532   tree ll_arg, lr_arg, rl_arg, rr_arg;
4533   tree ll_inner, lr_inner, rl_inner, rr_inner;
4534   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
4535   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
4536   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
4537   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
4538   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
4539   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
4540   enum machine_mode lnmode, rnmode;
4541   tree ll_mask, lr_mask, rl_mask, rr_mask;
4542   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
4543   tree l_const, r_const;
4544   tree lntype, rntype, result;
4545   int first_bit, end_bit;
4546   int volatilep;
4547
4548   /* Start by getting the comparison codes.  Fail if anything is volatile.
4549      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
4550      it were surrounded with a NE_EXPR.  */
4551
4552   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
4553     return 0;
4554
4555   lcode = TREE_CODE (lhs);
4556   rcode = TREE_CODE (rhs);
4557
4558   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
4559     {
4560       lhs = build2 (NE_EXPR, truth_type, lhs,
4561                     fold_convert (TREE_TYPE (lhs), integer_zero_node));
4562       lcode = NE_EXPR;
4563     }
4564
4565   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
4566     {
4567       rhs = build2 (NE_EXPR, truth_type, rhs,
4568                     fold_convert (TREE_TYPE (rhs), integer_zero_node));
4569       rcode = NE_EXPR;
4570     }
4571
4572   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
4573     return 0;
4574
4575   ll_arg = TREE_OPERAND (lhs, 0);
4576   lr_arg = TREE_OPERAND (lhs, 1);
4577   rl_arg = TREE_OPERAND (rhs, 0);
4578   rr_arg = TREE_OPERAND (rhs, 1);
4579
4580   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
4581   if (simple_operand_p (ll_arg)
4582       && simple_operand_p (lr_arg))
4583     {
4584       tree result;
4585       if (operand_equal_p (ll_arg, rl_arg, 0)
4586           && operand_equal_p (lr_arg, rr_arg, 0))
4587         {
4588           result = combine_comparisons (code, lcode, rcode,
4589                                         truth_type, ll_arg, lr_arg);
4590           if (result)
4591             return result;
4592         }
4593       else if (operand_equal_p (ll_arg, rr_arg, 0)
4594                && operand_equal_p (lr_arg, rl_arg, 0))
4595         {
4596           result = combine_comparisons (code, lcode,
4597                                         swap_tree_comparison (rcode),
4598                                         truth_type, ll_arg, lr_arg);
4599           if (result)
4600             return result;
4601         }
4602     }
4603
4604   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
4605           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
4606
4607   /* If the RHS can be evaluated unconditionally and its operands are
4608      simple, it wins to evaluate the RHS unconditionally on machines
4609      with expensive branches.  In this case, this isn't a comparison
4610      that can be merged.  Avoid doing this if the RHS is a floating-point
4611      comparison since those can trap.  */
4612
4613   if (BRANCH_COST >= 2
4614       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
4615       && simple_operand_p (rl_arg)
4616       && simple_operand_p (rr_arg))
4617     {
4618       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
4619       if (code == TRUTH_OR_EXPR
4620           && lcode == NE_EXPR && integer_zerop (lr_arg)
4621           && rcode == NE_EXPR && integer_zerop (rr_arg)
4622           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4623         return build2 (NE_EXPR, truth_type,
4624                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4625                                ll_arg, rl_arg),
4626                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4627
4628       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
4629       if (code == TRUTH_AND_EXPR
4630           && lcode == EQ_EXPR && integer_zerop (lr_arg)
4631           && rcode == EQ_EXPR && integer_zerop (rr_arg)
4632           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4633         return build2 (EQ_EXPR, truth_type,
4634                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4635                                ll_arg, rl_arg),
4636                        fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
4637
4638       return build2 (code, truth_type, lhs, rhs);
4639     }
4640
4641   /* See if the comparisons can be merged.  Then get all the parameters for
4642      each side.  */
4643
4644   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
4645       || (rcode != EQ_EXPR && rcode != NE_EXPR))
4646     return 0;
4647
4648   volatilep = 0;
4649   ll_inner = decode_field_reference (ll_arg,
4650                                      &ll_bitsize, &ll_bitpos, &ll_mode,
4651                                      &ll_unsignedp, &volatilep, &ll_mask,
4652                                      &ll_and_mask);
4653   lr_inner = decode_field_reference (lr_arg,
4654                                      &lr_bitsize, &lr_bitpos, &lr_mode,
4655                                      &lr_unsignedp, &volatilep, &lr_mask,
4656                                      &lr_and_mask);
4657   rl_inner = decode_field_reference (rl_arg,
4658                                      &rl_bitsize, &rl_bitpos, &rl_mode,
4659                                      &rl_unsignedp, &volatilep, &rl_mask,
4660                                      &rl_and_mask);
4661   rr_inner = decode_field_reference (rr_arg,
4662                                      &rr_bitsize, &rr_bitpos, &rr_mode,
4663                                      &rr_unsignedp, &volatilep, &rr_mask,
4664                                      &rr_and_mask);
4665
4666   /* It must be true that the inner operation on the lhs of each
4667      comparison must be the same if we are to be able to do anything.
4668      Then see if we have constants.  If not, the same must be true for
4669      the rhs's.  */
4670   if (volatilep || ll_inner == 0 || rl_inner == 0
4671       || ! operand_equal_p (ll_inner, rl_inner, 0))
4672     return 0;
4673
4674   if (TREE_CODE (lr_arg) == INTEGER_CST
4675       && TREE_CODE (rr_arg) == INTEGER_CST)
4676     l_const = lr_arg, r_const = rr_arg;
4677   else if (lr_inner == 0 || rr_inner == 0
4678            || ! operand_equal_p (lr_inner, rr_inner, 0))
4679     return 0;
4680   else
4681     l_const = r_const = 0;
4682
4683   /* If either comparison code is not correct for our logical operation,
4684      fail.  However, we can convert a one-bit comparison against zero into
4685      the opposite comparison against that bit being set in the field.  */
4686
4687   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
4688   if (lcode != wanted_code)
4689     {
4690       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
4691         {
4692           /* Make the left operand unsigned, since we are only interested
4693              in the value of one bit.  Otherwise we are doing the wrong
4694              thing below.  */
4695           ll_unsignedp = 1;
4696           l_const = ll_mask;
4697         }
4698       else
4699         return 0;
4700     }
4701
4702   /* This is analogous to the code for l_const above.  */
4703   if (rcode != wanted_code)
4704     {
4705       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
4706         {
4707           rl_unsignedp = 1;
4708           r_const = rl_mask;
4709         }
4710       else
4711         return 0;
4712     }
4713
4714   /* After this point all optimizations will generate bit-field
4715      references, which we might not want.  */
4716   if (! lang_hooks.can_use_bit_fields_p ())
4717     return 0;
4718
4719   /* See if we can find a mode that contains both fields being compared on
4720      the left.  If we can't, fail.  Otherwise, update all constants and masks
4721      to be relative to a field of that size.  */
4722   first_bit = MIN (ll_bitpos, rl_bitpos);
4723   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
4724   lnmode = get_best_mode (end_bit - first_bit, first_bit,
4725                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
4726                           volatilep);
4727   if (lnmode == VOIDmode)
4728     return 0;
4729
4730   lnbitsize = GET_MODE_BITSIZE (lnmode);
4731   lnbitpos = first_bit & ~ (lnbitsize - 1);
4732   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
4733   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
4734
4735   if (BYTES_BIG_ENDIAN)
4736     {
4737       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
4738       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
4739     }
4740
4741   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
4742                          size_int (xll_bitpos), 0);
4743   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
4744                          size_int (xrl_bitpos), 0);
4745
4746   if (l_const)
4747     {
4748       l_const = fold_convert (lntype, l_const);
4749       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
4750       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
4751       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
4752                                         fold (build1 (BIT_NOT_EXPR,
4753                                                       lntype, ll_mask)),
4754                                         0)))
4755         {
4756           warning ("comparison is always %d", wanted_code == NE_EXPR);
4757
4758           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4759         }
4760     }
4761   if (r_const)
4762     {
4763       r_const = fold_convert (lntype, r_const);
4764       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
4765       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
4766       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
4767                                         fold (build1 (BIT_NOT_EXPR,
4768                                                       lntype, rl_mask)),
4769                                         0)))
4770         {
4771           warning ("comparison is always %d", wanted_code == NE_EXPR);
4772
4773           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
4774         }
4775     }
4776
4777   /* If the right sides are not constant, do the same for it.  Also,
4778      disallow this optimization if a size or signedness mismatch occurs
4779      between the left and right sides.  */
4780   if (l_const == 0)
4781     {
4782       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4783           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4784           /* Make sure the two fields on the right
4785              correspond to the left without being swapped.  */
4786           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4787         return 0;
4788
4789       first_bit = MIN (lr_bitpos, rr_bitpos);
4790       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4791       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4792                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4793                               volatilep);
4794       if (rnmode == VOIDmode)
4795         return 0;
4796
4797       rnbitsize = GET_MODE_BITSIZE (rnmode);
4798       rnbitpos = first_bit & ~ (rnbitsize - 1);
4799       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
4800       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4801
4802       if (BYTES_BIG_ENDIAN)
4803         {
4804           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4805           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4806         }
4807
4808       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
4809                              size_int (xlr_bitpos), 0);
4810       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
4811                              size_int (xrr_bitpos), 0);
4812
4813       /* Make a mask that corresponds to both fields being compared.
4814          Do this for both items being compared.  If the operands are the
4815          same size and the bits being compared are in the same position
4816          then we can do this by masking both and comparing the masked
4817          results.  */
4818       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4819       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4820       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4821         {
4822           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4823                                     ll_unsignedp || rl_unsignedp);
4824           if (! all_ones_mask_p (ll_mask, lnbitsize))
4825             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
4826
4827           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4828                                     lr_unsignedp || rr_unsignedp);
4829           if (! all_ones_mask_p (lr_mask, rnbitsize))
4830             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
4831
4832           return build2 (wanted_code, truth_type, lhs, rhs);
4833         }
4834
4835       /* There is still another way we can do something:  If both pairs of
4836          fields being compared are adjacent, we may be able to make a wider
4837          field containing them both.
4838
4839          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4840          the mask must be shifted to account for the shift done by
4841          make_bit_field_ref.  */
4842       if ((ll_bitsize + ll_bitpos == rl_bitpos
4843            && lr_bitsize + lr_bitpos == rr_bitpos)
4844           || (ll_bitpos == rl_bitpos + rl_bitsize
4845               && lr_bitpos == rr_bitpos + rr_bitsize))
4846         {
4847           tree type;
4848
4849           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4850                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4851           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4852                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4853
4854           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4855                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4856           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4857                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4858
4859           /* Convert to the smaller type before masking out unwanted bits.  */
4860           type = lntype;
4861           if (lntype != rntype)
4862             {
4863               if (lnbitsize > rnbitsize)
4864                 {
4865                   lhs = fold_convert (rntype, lhs);
4866                   ll_mask = fold_convert (rntype, ll_mask);
4867                   type = rntype;
4868                 }
4869               else if (lnbitsize < rnbitsize)
4870                 {
4871                   rhs = fold_convert (lntype, rhs);
4872                   lr_mask = fold_convert (lntype, lr_mask);
4873                   type = lntype;
4874                 }
4875             }
4876
4877           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4878             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
4879
4880           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4881             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
4882
4883           return build2 (wanted_code, truth_type, lhs, rhs);
4884         }
4885
4886       return 0;
4887     }
4888
4889   /* Handle the case of comparisons with constants.  If there is something in
4890      common between the masks, those bits of the constants must be the same.
4891      If not, the condition is always false.  Test for this to avoid generating
4892      incorrect code below.  */
4893   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4894   if (! integer_zerop (result)
4895       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4896                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4897     {
4898       if (wanted_code == NE_EXPR)
4899         {
4900           warning ("%<or%> of unmatched not-equal tests is always 1");
4901           return constant_boolean_node (true, truth_type);
4902         }
4903       else
4904         {
4905           warning ("%<and%> of mutually exclusive equal-tests is always 0");
4906           return constant_boolean_node (false, truth_type);
4907         }
4908     }
4909
4910   /* Construct the expression we will return.  First get the component
4911      reference we will make.  Unless the mask is all ones the width of
4912      that field, perform the mask operation.  Then compare with the
4913      merged constant.  */
4914   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4915                                ll_unsignedp || rl_unsignedp);
4916
4917   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4918   if (! all_ones_mask_p (ll_mask, lnbitsize))
4919     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
4920
4921   return build2 (wanted_code, truth_type, result,
4922                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4923 }
4924 \f
4925 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4926    constant.  */
4927
4928 static tree
4929 optimize_minmax_comparison (tree t)
4930 {
4931   tree type = TREE_TYPE (t);
4932   tree arg0 = TREE_OPERAND (t, 0);
4933   enum tree_code op_code;
4934   tree comp_const = TREE_OPERAND (t, 1);
4935   tree minmax_const;
4936   int consts_equal, consts_lt;
4937   tree inner;
4938
4939   STRIP_SIGN_NOPS (arg0);
4940
4941   op_code = TREE_CODE (arg0);
4942   minmax_const = TREE_OPERAND (arg0, 1);
4943   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4944   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4945   inner = TREE_OPERAND (arg0, 0);
4946
4947   /* If something does not permit us to optimize, return the original tree.  */
4948   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4949       || TREE_CODE (comp_const) != INTEGER_CST
4950       || TREE_CONSTANT_OVERFLOW (comp_const)
4951       || TREE_CODE (minmax_const) != INTEGER_CST
4952       || TREE_CONSTANT_OVERFLOW (minmax_const))
4953     return t;
4954
4955   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4956      and GT_EXPR, doing the rest with recursive calls using logical
4957      simplifications.  */
4958   switch (TREE_CODE (t))
4959     {
4960     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4961       return
4962         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4963
4964     case GE_EXPR:
4965       return
4966         fold (build2 (TRUTH_ORIF_EXPR, type,
4967                       optimize_minmax_comparison
4968                       (build2 (EQ_EXPR, type, arg0, comp_const)),
4969                       optimize_minmax_comparison
4970                       (build2 (GT_EXPR, type, arg0, comp_const))));
4971
4972     case EQ_EXPR:
4973       if (op_code == MAX_EXPR && consts_equal)
4974         /* MAX (X, 0) == 0  ->  X <= 0  */
4975         return fold (build2 (LE_EXPR, type, inner, comp_const));
4976
4977       else if (op_code == MAX_EXPR && consts_lt)
4978         /* MAX (X, 0) == 5  ->  X == 5   */
4979         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4980
4981       else if (op_code == MAX_EXPR)
4982         /* MAX (X, 0) == -1  ->  false  */
4983         return omit_one_operand (type, integer_zero_node, inner);
4984
4985       else if (consts_equal)
4986         /* MIN (X, 0) == 0  ->  X >= 0  */
4987         return fold (build2 (GE_EXPR, type, inner, comp_const));
4988
4989       else if (consts_lt)
4990         /* MIN (X, 0) == 5  ->  false  */
4991         return omit_one_operand (type, integer_zero_node, inner);
4992
4993       else
4994         /* MIN (X, 0) == -1  ->  X == -1  */
4995         return fold (build2 (EQ_EXPR, type, inner, comp_const));
4996
4997     case GT_EXPR:
4998       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4999         /* MAX (X, 0) > 0  ->  X > 0
5000            MAX (X, 0) > 5  ->  X > 5  */
5001         return fold (build2 (GT_EXPR, type, inner, comp_const));
5002
5003       else if (op_code == MAX_EXPR)
5004         /* MAX (X, 0) > -1  ->  true  */
5005         return omit_one_operand (type, integer_one_node, inner);
5006
5007       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5008         /* MIN (X, 0) > 0  ->  false
5009            MIN (X, 0) > 5  ->  false  */
5010         return omit_one_operand (type, integer_zero_node, inner);
5011
5012       else
5013         /* MIN (X, 0) > -1  ->  X > -1  */
5014         return fold (build2 (GT_EXPR, type, inner, comp_const));
5015
5016     default:
5017       return t;
5018     }
5019 }
5020 \f
5021 /* T is an integer expression that is being multiplied, divided, or taken a
5022    modulus (CODE says which and what kind of divide or modulus) by a
5023    constant C.  See if we can eliminate that operation by folding it with
5024    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5025    should be used for the computation if wider than our type.
5026
5027    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5028    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5029    expression would not overflow or that overflow is undefined for the type
5030    in the language in question.
5031
5032    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
5033    the machine has a multiply-accumulate insn or that this is part of an
5034    addressing calculation.
5035
5036    If we return a non-null expression, it is an equivalent form of the
5037    original computation, but need not be in the original type.  */
5038
5039 static tree
5040 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type)
5041 {
5042   /* To avoid exponential search depth, refuse to allow recursion past
5043      three levels.  Beyond that (1) it's highly unlikely that we'll find
5044      something interesting and (2) we've probably processed it before
5045      when we built the inner expression.  */
5046
5047   static int depth;
5048   tree ret;
5049
5050   if (depth > 3)
5051     return NULL;
5052
5053   depth++;
5054   ret = extract_muldiv_1 (t, c, code, wide_type);
5055   depth--;
5056
5057   return ret;
5058 }
5059
5060 static tree
5061 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
5062 {
5063   tree type = TREE_TYPE (t);
5064   enum tree_code tcode = TREE_CODE (t);
5065   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5066                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5067                 ? wide_type : type);
5068   tree t1, t2;
5069   int same_p = tcode == code;
5070   tree op0 = NULL_TREE, op1 = NULL_TREE;
5071
5072   /* Don't deal with constants of zero here; they confuse the code below.  */
5073   if (integer_zerop (c))
5074     return NULL_TREE;
5075
5076   if (TREE_CODE_CLASS (tcode) == '1')
5077     op0 = TREE_OPERAND (t, 0);
5078
5079   if (TREE_CODE_CLASS (tcode) == '2')
5080     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5081
5082   /* Note that we need not handle conditional operations here since fold
5083      already handles those cases.  So just do arithmetic here.  */
5084   switch (tcode)
5085     {
5086     case INTEGER_CST:
5087       /* For a constant, we can always simplify if we are a multiply
5088          or (for divide and modulus) if it is a multiple of our constant.  */
5089       if (code == MULT_EXPR
5090           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
5091         return const_binop (code, fold_convert (ctype, t),
5092                             fold_convert (ctype, c), 0);
5093       break;
5094
5095     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
5096       /* If op0 is an expression ...  */
5097       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
5098            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
5099            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
5100            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
5101           /* ... and is unsigned, and its type is smaller than ctype,
5102              then we cannot pass through as widening.  */
5103           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
5104                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5105                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5106                && (GET_MODE_SIZE (TYPE_MODE (ctype))
5107                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
5108               /* ... or this is a truncation (t is narrower than op0),
5109                  then we cannot pass through this narrowing.  */
5110               || (GET_MODE_SIZE (TYPE_MODE (type))
5111                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
5112               /* ... or signedness changes for division or modulus,
5113                  then we cannot pass through this conversion.  */
5114               || (code != MULT_EXPR
5115                   && (TYPE_UNSIGNED (ctype)
5116                       != TYPE_UNSIGNED (TREE_TYPE (op0))))))
5117         break;
5118
5119       /* Pass the constant down and see if we can make a simplification.  If
5120          we can, replace this expression with the inner simplification for
5121          possible later conversion to our or some other type.  */
5122       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5123           && TREE_CODE (t2) == INTEGER_CST
5124           && ! TREE_CONSTANT_OVERFLOW (t2)
5125           && (0 != (t1 = extract_muldiv (op0, t2, code,
5126                                          code == MULT_EXPR
5127                                          ? ctype : NULL_TREE))))
5128         return t1;
5129       break;
5130
5131     case NEGATE_EXPR:  case ABS_EXPR:
5132       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5133         return fold (build1 (tcode, ctype, fold_convert (ctype, t1)));
5134       break;
5135
5136     case MIN_EXPR:  case MAX_EXPR:
5137       /* If widening the type changes the signedness, then we can't perform
5138          this optimization as that changes the result.  */
5139       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5140         break;
5141
5142       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5143       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
5144           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
5145         {
5146           if (tree_int_cst_sgn (c) < 0)
5147             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5148
5149           return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5150                                fold_convert (ctype, t2)));
5151         }
5152       break;
5153
5154     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5155       /* If the second operand is constant, this is a multiplication
5156          or floor division, by a power of two, so we can treat it that
5157          way unless the multiplier or divisor overflows.  Signed
5158          left-shift overflow is implementation-defined rather than
5159          undefined in C90, so do not convert signed left shift into
5160          multiplication.  */
5161       if (TREE_CODE (op1) == INTEGER_CST
5162           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5163           /* const_binop may not detect overflow correctly,
5164              so check for it explicitly here.  */
5165           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5166           && TREE_INT_CST_HIGH (op1) == 0
5167           && 0 != (t1 = fold_convert (ctype,
5168                                       const_binop (LSHIFT_EXPR,
5169                                                    size_one_node,
5170                                                    op1, 0)))
5171           && ! TREE_OVERFLOW (t1))
5172         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5173                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5174                                        ctype, fold_convert (ctype, op0), t1),
5175                                c, code, wide_type);
5176       break;
5177
5178     case PLUS_EXPR:  case MINUS_EXPR:
5179       /* See if we can eliminate the operation on both sides.  If we can, we
5180          can return a new PLUS or MINUS.  If we can't, the only remaining
5181          cases where we can do anything are if the second operand is a
5182          constant.  */
5183       t1 = extract_muldiv (op0, c, code, wide_type);
5184       t2 = extract_muldiv (op1, c, code, wide_type);
5185       if (t1 != 0 && t2 != 0
5186           && (code == MULT_EXPR
5187               /* If not multiplication, we can only do this if both operands
5188                  are divisible by c.  */
5189               || (multiple_of_p (ctype, op0, c)
5190                   && multiple_of_p (ctype, op1, c))))
5191         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5192                              fold_convert (ctype, t2)));
5193
5194       /* If this was a subtraction, negate OP1 and set it to be an addition.
5195          This simplifies the logic below.  */
5196       if (tcode == MINUS_EXPR)
5197         tcode = PLUS_EXPR, op1 = negate_expr (op1);
5198
5199       if (TREE_CODE (op1) != INTEGER_CST)
5200         break;
5201
5202       /* If either OP1 or C are negative, this optimization is not safe for
5203          some of the division and remainder types while for others we need
5204          to change the code.  */
5205       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5206         {
5207           if (code == CEIL_DIV_EXPR)
5208             code = FLOOR_DIV_EXPR;
5209           else if (code == FLOOR_DIV_EXPR)
5210             code = CEIL_DIV_EXPR;
5211           else if (code != MULT_EXPR
5212                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5213             break;
5214         }
5215
5216       /* If it's a multiply or a division/modulus operation of a multiple
5217          of our constant, do the operation and verify it doesn't overflow.  */
5218       if (code == MULT_EXPR
5219           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5220         {
5221           op1 = const_binop (code, fold_convert (ctype, op1),
5222                              fold_convert (ctype, c), 0);
5223           /* We allow the constant to overflow with wrapping semantics.  */
5224           if (op1 == 0
5225               || (TREE_OVERFLOW (op1) && ! flag_wrapv))
5226             break;
5227         }
5228       else
5229         break;
5230
5231       /* If we have an unsigned type is not a sizetype, we cannot widen
5232          the operation since it will change the result if the original
5233          computation overflowed.  */
5234       if (TYPE_UNSIGNED (ctype)
5235           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5236           && ctype != type)
5237         break;
5238
5239       /* If we were able to eliminate our operation from the first side,
5240          apply our operation to the second side and reform the PLUS.  */
5241       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5242         return fold (build2 (tcode, ctype, fold_convert (ctype, t1), op1));
5243
5244       /* The last case is if we are a multiply.  In that case, we can
5245          apply the distributive law to commute the multiply and addition
5246          if the multiplication of the constants doesn't overflow.  */
5247       if (code == MULT_EXPR)
5248         return fold (build2 (tcode, ctype,
5249                              fold (build2 (code, ctype,
5250                                            fold_convert (ctype, op0),
5251                                            fold_convert (ctype, c))),
5252                              op1));
5253
5254       break;
5255
5256     case MULT_EXPR:
5257       /* We have a special case here if we are doing something like
5258          (C * 8) % 4 since we know that's zero.  */
5259       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5260            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5261           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5262           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5263         return omit_one_operand (type, integer_zero_node, op0);
5264
5265       /* ... fall through ...  */
5266
5267     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5268     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5269       /* If we can extract our operation from the LHS, do so and return a
5270          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5271          do something only if the second operand is a constant.  */
5272       if (same_p
5273           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5274         return fold (build2 (tcode, ctype, fold_convert (ctype, t1),
5275                              fold_convert (ctype, op1)));
5276       else if (tcode == MULT_EXPR && code == MULT_EXPR
5277                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
5278         return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5279                              fold_convert (ctype, t1)));
5280       else if (TREE_CODE (op1) != INTEGER_CST)
5281         return 0;
5282
5283       /* If these are the same operation types, we can associate them
5284          assuming no overflow.  */
5285       if (tcode == code
5286           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5287                                      fold_convert (ctype, c), 0))
5288           && ! TREE_OVERFLOW (t1))
5289         return fold (build2 (tcode, ctype, fold_convert (ctype, op0), t1));
5290
5291       /* If these operations "cancel" each other, we have the main
5292          optimizations of this pass, which occur when either constant is a
5293          multiple of the other, in which case we replace this with either an
5294          operation or CODE or TCODE.
5295
5296          If we have an unsigned type that is not a sizetype, we cannot do
5297          this since it will change the result if the original computation
5298          overflowed.  */
5299       if ((! TYPE_UNSIGNED (ctype)
5300            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5301           && ! flag_wrapv
5302           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5303               || (tcode == MULT_EXPR
5304                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5305                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
5306         {
5307           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5308             return fold (build2 (tcode, ctype, fold_convert (ctype, op0),
5309                                  fold_convert (ctype,
5310                                                const_binop (TRUNC_DIV_EXPR,
5311                                                             op1, c, 0))));
5312           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5313             return fold (build2 (code, ctype, fold_convert (ctype, op0),
5314                                  fold_convert (ctype,
5315                                                const_binop (TRUNC_DIV_EXPR,
5316                                                             c, op1, 0))));
5317         }
5318       break;
5319
5320     default:
5321       break;
5322     }
5323
5324   return 0;
5325 }
5326 \f
5327 /* Return a node which has the indicated constant VALUE (either 0 or
5328    1), and is of the indicated TYPE.  */
5329
5330 tree
5331 constant_boolean_node (int value, tree type)
5332 {
5333   if (type == integer_type_node)
5334     return value ? integer_one_node : integer_zero_node;
5335   else if (type == boolean_type_node)
5336     return value ? boolean_true_node : boolean_false_node;
5337   else if (TREE_CODE (type) == BOOLEAN_TYPE)
5338     return lang_hooks.truthvalue_conversion (value ? integer_one_node
5339                                                    : integer_zero_node);
5340   else
5341     return build_int_cst (type, value);
5342 }
5343
5344 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5345    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5346    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5347    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5348    COND is the first argument to CODE; otherwise (as in the example
5349    given here), it is the second argument.  TYPE is the type of the
5350    original expression.  Return NULL_TREE if no simplification is
5351    possible.  */
5352
5353 static tree
5354 fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
5355                                      tree cond, tree arg, int cond_first_p)
5356 {
5357   tree test, true_value, false_value;
5358   tree lhs = NULL_TREE;
5359   tree rhs = NULL_TREE;
5360
5361   /* This transformation is only worthwhile if we don't have to wrap
5362      arg in a SAVE_EXPR, and the operation can be simplified on atleast
5363      one of the branches once its pushed inside the COND_EXPR.  */
5364   if (!TREE_CONSTANT (arg))
5365     return NULL_TREE;
5366
5367   if (TREE_CODE (cond) == COND_EXPR)
5368     {
5369       test = TREE_OPERAND (cond, 0);
5370       true_value = TREE_OPERAND (cond, 1);
5371       false_value = TREE_OPERAND (cond, 2);
5372       /* If this operand throws an expression, then it does not make
5373          sense to try to perform a logical or arithmetic operation
5374          involving it.  */
5375       if (VOID_TYPE_P (TREE_TYPE (true_value)))
5376         lhs = true_value;
5377       if (VOID_TYPE_P (TREE_TYPE (false_value)))
5378         rhs = false_value;
5379     }
5380   else
5381     {
5382       tree testtype = TREE_TYPE (cond);
5383       test = cond;
5384       true_value = constant_boolean_node (true, testtype);
5385       false_value = constant_boolean_node (false, testtype);
5386     }
5387
5388   if (lhs == 0)
5389     lhs = fold (cond_first_p ? build2 (code, type, true_value, arg)
5390                              : build2 (code, type, arg, true_value));
5391   if (rhs == 0)
5392     rhs = fold (cond_first_p ? build2 (code, type, false_value, arg)
5393                              : build2 (code, type, arg, false_value));
5394
5395   test = fold (build3 (COND_EXPR, type, test, lhs, rhs));
5396   return fold_convert (type, test);
5397 }
5398
5399 \f
5400 /* Subroutine of fold() that checks for the addition of +/- 0.0.
5401
5402    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
5403    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
5404    ADDEND is the same as X.
5405
5406    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
5407    and finite.  The problematic cases are when X is zero, and its mode
5408    has signed zeros.  In the case of rounding towards -infinity,
5409    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
5410    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
5411
5412 static bool
5413 fold_real_zero_addition_p (tree type, tree addend, int negate)
5414 {
5415   if (!real_zerop (addend))
5416     return false;
5417
5418   /* Don't allow the fold with -fsignaling-nans.  */
5419   if (HONOR_SNANS (TYPE_MODE (type)))
5420     return false;
5421
5422   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
5423   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
5424     return true;
5425
5426   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
5427   if (TREE_CODE (addend) == REAL_CST
5428       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
5429     negate = !negate;
5430
5431   /* The mode has signed zeros, and we have to honor their sign.
5432      In this situation, there is only one case we can return true for.
5433      X - 0 is the same as X unless rounding towards -infinity is
5434      supported.  */
5435   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
5436 }
5437
5438 /* Subroutine of fold() that checks comparisons of built-in math
5439    functions against real constants.
5440
5441    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
5442    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
5443    is the type of the result and ARG0 and ARG1 are the operands of the
5444    comparison.  ARG1 must be a TREE_REAL_CST.
5445
5446    The function returns the constant folded tree if a simplification
5447    can be made, and NULL_TREE otherwise.  */
5448
5449 static tree
5450 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
5451                      tree type, tree arg0, tree arg1)
5452 {
5453   REAL_VALUE_TYPE c;
5454
5455   if (BUILTIN_SQRT_P (fcode))
5456     {
5457       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
5458       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
5459
5460       c = TREE_REAL_CST (arg1);
5461       if (REAL_VALUE_NEGATIVE (c))
5462         {
5463           /* sqrt(x) < y is always false, if y is negative.  */
5464           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
5465             return omit_one_operand (type, integer_zero_node, arg);
5466
5467           /* sqrt(x) > y is always true, if y is negative and we
5468              don't care about NaNs, i.e. negative values of x.  */
5469           if (code == NE_EXPR || !HONOR_NANS (mode))
5470             return omit_one_operand (type, integer_one_node, arg);
5471
5472           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
5473           return fold (build2 (GE_EXPR, type, arg,
5474                                build_real (TREE_TYPE (arg), dconst0)));
5475         }
5476       else if (code == GT_EXPR || code == GE_EXPR)
5477         {
5478           REAL_VALUE_TYPE c2;
5479
5480           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5481           real_convert (&c2, mode, &c2);
5482
5483           if (REAL_VALUE_ISINF (c2))
5484             {
5485               /* sqrt(x) > y is x == +Inf, when y is very large.  */
5486               if (HONOR_INFINITIES (mode))
5487                 return fold (build2 (EQ_EXPR, type, arg,
5488                                      build_real (TREE_TYPE (arg), c2)));
5489
5490               /* sqrt(x) > y is always false, when y is very large
5491                  and we don't care about infinities.  */
5492               return omit_one_operand (type, integer_zero_node, arg);
5493             }
5494
5495           /* sqrt(x) > c is the same as x > c*c.  */
5496           return fold (build2 (code, type, arg,
5497                                build_real (TREE_TYPE (arg), c2)));
5498         }
5499       else if (code == LT_EXPR || code == LE_EXPR)
5500         {
5501           REAL_VALUE_TYPE c2;
5502
5503           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5504           real_convert (&c2, mode, &c2);
5505
5506           if (REAL_VALUE_ISINF (c2))
5507             {
5508               /* sqrt(x) < y is always true, when y is a very large
5509                  value and we don't care about NaNs or Infinities.  */
5510               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
5511                 return omit_one_operand (type, integer_one_node, arg);
5512
5513               /* sqrt(x) < y is x != +Inf when y is very large and we
5514                  don't care about NaNs.  */
5515               if (! HONOR_NANS (mode))
5516                 return fold (build2 (NE_EXPR, type, arg,
5517                                      build_real (TREE_TYPE (arg), c2)));
5518
5519               /* sqrt(x) < y is x >= 0 when y is very large and we
5520                  don't care about Infinities.  */
5521               if (! HONOR_INFINITIES (mode))
5522                 return fold (build2 (GE_EXPR, type, arg,
5523                                      build_real (TREE_TYPE (arg), dconst0)));
5524
5525               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
5526               if (lang_hooks.decls.global_bindings_p () != 0
5527                   || CONTAINS_PLACEHOLDER_P (arg))
5528                 return NULL_TREE;
5529
5530               arg = save_expr (arg);
5531               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5532                                    fold (build2 (GE_EXPR, type, arg,
5533                                                  build_real (TREE_TYPE (arg),
5534                                                              dconst0))),
5535                                    fold (build2 (NE_EXPR, type, arg,
5536                                                  build_real (TREE_TYPE (arg),
5537                                                              c2)))));
5538             }
5539
5540           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
5541           if (! HONOR_NANS (mode))
5542             return fold (build2 (code, type, arg,
5543                                  build_real (TREE_TYPE (arg), c2)));
5544
5545           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
5546           if (lang_hooks.decls.global_bindings_p () == 0
5547               && ! CONTAINS_PLACEHOLDER_P (arg))
5548             {
5549               arg = save_expr (arg);
5550               return fold (build2 (TRUTH_ANDIF_EXPR, type,
5551                                    fold (build2 (GE_EXPR, type, arg,
5552                                                  build_real (TREE_TYPE (arg),
5553                                                              dconst0))),
5554                                    fold (build2 (code, type, arg,
5555                                                  build_real (TREE_TYPE (arg),
5556                                                              c2)))));
5557             }
5558         }
5559     }
5560
5561   return NULL_TREE;
5562 }
5563
5564 /* Subroutine of fold() that optimizes comparisons against Infinities,
5565    either +Inf or -Inf.
5566
5567    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5568    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5569    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5570
5571    The function returns the constant folded tree if a simplification
5572    can be made, and NULL_TREE otherwise.  */
5573
5574 static tree
5575 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5576 {
5577   enum machine_mode mode;
5578   REAL_VALUE_TYPE max;
5579   tree temp;
5580   bool neg;
5581
5582   mode = TYPE_MODE (TREE_TYPE (arg0));
5583
5584   /* For negative infinity swap the sense of the comparison.  */
5585   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
5586   if (neg)
5587     code = swap_tree_comparison (code);
5588
5589   switch (code)
5590     {
5591     case GT_EXPR:
5592       /* x > +Inf is always false, if with ignore sNANs.  */
5593       if (HONOR_SNANS (mode))
5594         return NULL_TREE;
5595       return omit_one_operand (type, integer_zero_node, arg0);
5596
5597     case LE_EXPR:
5598       /* x <= +Inf is always true, if we don't case about NaNs.  */
5599       if (! HONOR_NANS (mode))
5600         return omit_one_operand (type, integer_one_node, arg0);
5601
5602       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
5603       if (lang_hooks.decls.global_bindings_p () == 0
5604           && ! CONTAINS_PLACEHOLDER_P (arg0))
5605         {
5606           arg0 = save_expr (arg0);
5607           return fold (build2 (EQ_EXPR, type, arg0, arg0));
5608         }
5609       break;
5610
5611     case EQ_EXPR:
5612     case GE_EXPR:
5613       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
5614       real_maxval (&max, neg, mode);
5615       return fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5616                            arg0, build_real (TREE_TYPE (arg0), max)));
5617
5618     case LT_EXPR:
5619       /* x < +Inf is always equal to x <= DBL_MAX.  */
5620       real_maxval (&max, neg, mode);
5621       return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5622                            arg0, build_real (TREE_TYPE (arg0), max)));
5623
5624     case NE_EXPR:
5625       /* x != +Inf is always equal to !(x > DBL_MAX).  */
5626       real_maxval (&max, neg, mode);
5627       if (! HONOR_NANS (mode))
5628         return fold (build2 (neg ? GE_EXPR : LE_EXPR, type,
5629                              arg0, build_real (TREE_TYPE (arg0), max)));
5630
5631       /* The transformation below creates non-gimple code and thus is
5632          not appropriate if we are in gimple form.  */
5633       if (in_gimple_form)
5634         return NULL_TREE;
5635
5636       temp = fold (build2 (neg ? LT_EXPR : GT_EXPR, type,
5637                            arg0, build_real (TREE_TYPE (arg0), max)));
5638       return fold (build1 (TRUTH_NOT_EXPR, type, temp));
5639
5640     default:
5641       break;
5642     }
5643
5644   return NULL_TREE;
5645 }
5646
5647 /* Subroutine of fold() that optimizes comparisons of a division by
5648    a nonzero integer constant against an integer constant, i.e.
5649    X/C1 op C2.
5650
5651    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5652    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
5653    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
5654
5655    The function returns the constant folded tree if a simplification
5656    can be made, and NULL_TREE otherwise.  */
5657
5658 static tree
5659 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
5660 {
5661   tree prod, tmp, hi, lo;
5662   tree arg00 = TREE_OPERAND (arg0, 0);
5663   tree arg01 = TREE_OPERAND (arg0, 1);
5664   unsigned HOST_WIDE_INT lpart;
5665   HOST_WIDE_INT hpart;
5666   int overflow;
5667
5668   /* We have to do this the hard way to detect unsigned overflow.
5669      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
5670   overflow = mul_double (TREE_INT_CST_LOW (arg01),
5671                          TREE_INT_CST_HIGH (arg01),
5672                          TREE_INT_CST_LOW (arg1),
5673                          TREE_INT_CST_HIGH (arg1), &lpart, &hpart);
5674   prod = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
5675   prod = force_fit_type (prod, -1, overflow, false);
5676
5677   if (TYPE_UNSIGNED (TREE_TYPE (arg0)))
5678     {
5679       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5680       lo = prod;
5681
5682       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
5683       overflow = add_double (TREE_INT_CST_LOW (prod),
5684                              TREE_INT_CST_HIGH (prod),
5685                              TREE_INT_CST_LOW (tmp),
5686                              TREE_INT_CST_HIGH (tmp),
5687                              &lpart, &hpart);
5688       hi = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
5689       hi = force_fit_type (hi, -1, overflow | TREE_OVERFLOW (prod),
5690                            TREE_CONSTANT_OVERFLOW (prod));
5691     }
5692   else if (tree_int_cst_sgn (arg01) >= 0)
5693     {
5694       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
5695       switch (tree_int_cst_sgn (arg1))
5696         {
5697         case -1:
5698           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5699           hi = prod;
5700           break;
5701
5702         case  0:
5703           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
5704           hi = tmp;
5705           break;
5706
5707         case  1:
5708           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5709           lo = prod;
5710           break;
5711
5712         default:
5713           gcc_unreachable ();
5714         }
5715     }
5716   else
5717     {
5718       tmp = int_const_binop (PLUS_EXPR, arg01, integer_one_node, 0);
5719       switch (tree_int_cst_sgn (arg1))
5720         {
5721         case -1:
5722           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
5723           lo = prod;
5724           break;
5725
5726         case  0:
5727           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
5728           lo = tmp;
5729           break;
5730
5731         case  1:
5732           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
5733           hi = prod;
5734           break;
5735
5736         default:
5737           gcc_unreachable ();
5738         }
5739     }
5740
5741   switch (code)
5742     {
5743     case EQ_EXPR:
5744       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5745         return omit_one_operand (type, integer_zero_node, arg00);
5746       if (TREE_OVERFLOW (hi))
5747         return fold (build2 (GE_EXPR, type, arg00, lo));
5748       if (TREE_OVERFLOW (lo))
5749         return fold (build2 (LE_EXPR, type, arg00, hi));
5750       return build_range_check (type, arg00, 1, lo, hi);
5751
5752     case NE_EXPR:
5753       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
5754         return omit_one_operand (type, integer_one_node, arg00);
5755       if (TREE_OVERFLOW (hi))
5756         return fold (build2 (LT_EXPR, type, arg00, lo));
5757       if (TREE_OVERFLOW (lo))
5758         return fold (build2 (GT_EXPR, type, arg00, hi));
5759       return build_range_check (type, arg00, 0, lo, hi);
5760
5761     case LT_EXPR:
5762       if (TREE_OVERFLOW (lo))
5763         return omit_one_operand (type, integer_zero_node, arg00);
5764       return fold (build2 (LT_EXPR, type, arg00, lo));
5765
5766     case LE_EXPR:
5767       if (TREE_OVERFLOW (hi))
5768         return omit_one_operand (type, integer_one_node, arg00);
5769       return fold (build2 (LE_EXPR, type, arg00, hi));
5770
5771     case GT_EXPR:
5772       if (TREE_OVERFLOW (hi))
5773         return omit_one_operand (type, integer_zero_node, arg00);
5774       return fold (build2 (GT_EXPR, type, arg00, hi));
5775
5776     case GE_EXPR:
5777       if (TREE_OVERFLOW (lo))
5778         return omit_one_operand (type, integer_one_node, arg00);
5779       return fold (build2 (GE_EXPR, type, arg00, lo));
5780
5781     default:
5782       break;
5783     }
5784
5785   return NULL_TREE;
5786 }
5787
5788
5789 /* If CODE with arguments ARG0 and ARG1 represents a single bit
5790    equality/inequality test, then return a simplified form of
5791    the test using shifts and logical operations.  Otherwise return
5792    NULL.  TYPE is the desired result type.  */
5793
5794 tree
5795 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
5796                       tree result_type)
5797 {
5798   /* If this is a TRUTH_NOT_EXPR, it may have a single bit test inside
5799      operand 0.  */
5800   if (code == TRUTH_NOT_EXPR)
5801     {
5802       code = TREE_CODE (arg0);
5803       if (code != NE_EXPR && code != EQ_EXPR)
5804         return NULL_TREE;
5805
5806       /* Extract the arguments of the EQ/NE.  */
5807       arg1 = TREE_OPERAND (arg0, 1);
5808       arg0 = TREE_OPERAND (arg0, 0);
5809
5810       /* This requires us to invert the code.  */
5811       code = (code == EQ_EXPR ? NE_EXPR : EQ_EXPR);
5812     }
5813
5814   /* If this is testing a single bit, we can optimize the test.  */
5815   if ((code == NE_EXPR || code == EQ_EXPR)
5816       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
5817       && integer_pow2p (TREE_OPERAND (arg0, 1)))
5818     {
5819       tree inner = TREE_OPERAND (arg0, 0);
5820       tree type = TREE_TYPE (arg0);
5821       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
5822       enum machine_mode operand_mode = TYPE_MODE (type);
5823       int ops_unsigned;
5824       tree signed_type, unsigned_type, intermediate_type;
5825       tree arg00;
5826
5827       /* If we have (A & C) != 0 where C is the sign bit of A, convert
5828          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
5829       arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
5830       if (arg00 != NULL_TREE
5831           /* This is only a win if casting to a signed type is cheap,
5832              i.e. when arg00's type is not a partial mode.  */
5833           && TYPE_PRECISION (TREE_TYPE (arg00))
5834              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
5835         {
5836           tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
5837           return fold (build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
5838                                result_type, fold_convert (stype, arg00),
5839                                fold_convert (stype, integer_zero_node)));
5840         }
5841
5842       /* Otherwise we have (A & C) != 0 where C is a single bit,
5843          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
5844          Similarly for (A & C) == 0.  */
5845
5846       /* If INNER is a right shift of a constant and it plus BITNUM does
5847          not overflow, adjust BITNUM and INNER.  */
5848       if (TREE_CODE (inner) == RSHIFT_EXPR
5849           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
5850           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
5851           && bitnum < TYPE_PRECISION (type)
5852           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
5853                                    bitnum - TYPE_PRECISION (type)))
5854         {
5855           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
5856           inner = TREE_OPERAND (inner, 0);
5857         }
5858
5859       /* If we are going to be able to omit the AND below, we must do our
5860          operations as unsigned.  If we must use the AND, we have a choice.
5861          Normally unsigned is faster, but for some machines signed is.  */
5862 #ifdef LOAD_EXTEND_OP
5863       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND ? 0 : 1);
5864 #else
5865       ops_unsigned = 1;
5866 #endif
5867
5868       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
5869       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
5870       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
5871       inner = fold_convert (intermediate_type, inner);
5872
5873       if (bitnum != 0)
5874         inner = build2 (RSHIFT_EXPR, intermediate_type,
5875                         inner, size_int (bitnum));
5876
5877       if (code == EQ_EXPR)
5878         inner = fold (build2 (BIT_XOR_EXPR, intermediate_type,
5879                               inner, integer_one_node));
5880
5881       /* Put the AND last so it can combine with more things.  */
5882       inner = build2 (BIT_AND_EXPR, intermediate_type,
5883                       inner, integer_one_node);
5884
5885       /* Make sure to return the proper type.  */
5886       inner = fold_convert (result_type, inner);
5887
5888       return inner;
5889     }
5890   return NULL_TREE;
5891 }
5892
5893 /* Check whether we are allowed to reorder operands arg0 and arg1,
5894    such that the evaluation of arg1 occurs before arg0.  */
5895
5896 static bool
5897 reorder_operands_p (tree arg0, tree arg1)
5898 {
5899   if (! flag_evaluation_order)
5900     return true;
5901   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
5902     return true;
5903   return ! TREE_SIDE_EFFECTS (arg0)
5904          && ! TREE_SIDE_EFFECTS (arg1);
5905 }
5906
5907 /* Test whether it is preferable two swap two operands, ARG0 and
5908    ARG1, for example because ARG0 is an integer constant and ARG1
5909    isn't.  If REORDER is true, only recommend swapping if we can
5910    evaluate the operands in reverse order.  */
5911
5912 bool
5913 tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
5914 {
5915   STRIP_SIGN_NOPS (arg0);
5916   STRIP_SIGN_NOPS (arg1);
5917
5918   if (TREE_CODE (arg1) == INTEGER_CST)
5919     return 0;
5920   if (TREE_CODE (arg0) == INTEGER_CST)
5921     return 1;
5922
5923   if (TREE_CODE (arg1) == REAL_CST)
5924     return 0;
5925   if (TREE_CODE (arg0) == REAL_CST)
5926     return 1;
5927
5928   if (TREE_CODE (arg1) == COMPLEX_CST)
5929     return 0;
5930   if (TREE_CODE (arg0) == COMPLEX_CST)
5931     return 1;
5932
5933   if (TREE_CONSTANT (arg1))
5934     return 0;
5935   if (TREE_CONSTANT (arg0))
5936     return 1;
5937
5938   if (optimize_size)
5939     return 0;
5940
5941   if (reorder && flag_evaluation_order
5942       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5943     return 0;
5944
5945   if (DECL_P (arg1))
5946     return 0;
5947   if (DECL_P (arg0))
5948     return 1;
5949
5950   if (reorder && flag_evaluation_order
5951       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
5952     return 0;
5953
5954   if (DECL_P (arg1))
5955     return 0;
5956   if (DECL_P (arg0))
5957     return 1;
5958
5959   /* It is preferable to swap two SSA_NAME to ensure a canonical form
5960      for commutative and comparison operators.  Ensuring a canonical
5961      form allows the optimizers to find additional redundancies without
5962      having to explicitly check for both orderings.  */
5963   if (TREE_CODE (arg0) == SSA_NAME
5964       && TREE_CODE (arg1) == SSA_NAME
5965       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
5966     return 1;
5967
5968   return 0;
5969 }
5970
5971 /* Perform constant folding and related simplification of EXPR.
5972    The related simplifications include x*1 => x, x*0 => 0, etc.,
5973    and application of the associative law.
5974    NOP_EXPR conversions may be removed freely (as long as we
5975    are careful not to change the type of the overall expression).
5976    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
5977    but we can constant-fold them if they have constant operands.  */
5978
5979 #ifdef ENABLE_FOLD_CHECKING
5980 # define fold(x) fold_1 (x)
5981 static tree fold_1 (tree);
5982 static
5983 #endif
5984 tree
5985 fold (tree expr)
5986 {
5987   const tree t = expr;
5988   const tree type = TREE_TYPE (expr);
5989   tree t1 = NULL_TREE;
5990   tree tem;
5991   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
5992   enum tree_code code = TREE_CODE (t);
5993   int kind = TREE_CODE_CLASS (code);
5994
5995   /* WINS will be nonzero when the switch is done
5996      if all operands are constant.  */
5997   int wins = 1;
5998
5999   /* Return right away if a constant.  */
6000   if (kind == 'c')
6001     return t;
6002
6003   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
6004     {
6005       tree subop;
6006
6007       /* Special case for conversion ops that can have fixed point args.  */
6008       arg0 = TREE_OPERAND (t, 0);
6009
6010       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
6011       if (arg0 != 0)
6012         STRIP_SIGN_NOPS (arg0);
6013
6014       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
6015         subop = TREE_REALPART (arg0);
6016       else
6017         subop = arg0;
6018
6019       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
6020           && TREE_CODE (subop) != REAL_CST)
6021         /* Note that TREE_CONSTANT isn't enough:
6022            static var addresses are constant but we can't
6023            do arithmetic on them.  */
6024         wins = 0;
6025     }
6026   else if (IS_EXPR_CODE_CLASS (kind))
6027     {
6028       int len = first_rtl_op (code);
6029       int i;
6030       for (i = 0; i < len; i++)
6031         {
6032           tree op = TREE_OPERAND (t, i);
6033           tree subop;
6034
6035           if (op == 0)
6036             continue;           /* Valid for CALL_EXPR, at least.  */
6037
6038           /* Strip any conversions that don't change the mode.  This is
6039              safe for every expression, except for a comparison expression
6040              because its signedness is derived from its operands.  So, in
6041              the latter case, only strip conversions that don't change the
6042              signedness.
6043
6044              Note that this is done as an internal manipulation within the
6045              constant folder, in order to find the simplest representation
6046              of the arguments so that their form can be studied.  In any
6047              cases, the appropriate type conversions should be put back in
6048              the tree that will get out of the constant folder.  */
6049           if (kind == '<')
6050             STRIP_SIGN_NOPS (op);
6051           else
6052             STRIP_NOPS (op);
6053
6054           if (TREE_CODE (op) == COMPLEX_CST)
6055             subop = TREE_REALPART (op);
6056           else
6057             subop = op;
6058
6059           if (TREE_CODE (subop) != INTEGER_CST
6060               && TREE_CODE (subop) != REAL_CST)
6061             /* Note that TREE_CONSTANT isn't enough:
6062                static var addresses are constant but we can't
6063                do arithmetic on them.  */
6064             wins = 0;
6065
6066           if (i == 0)
6067             arg0 = op;
6068           else if (i == 1)
6069             arg1 = op;
6070         }
6071     }
6072
6073   /* If this is a commutative operation, and ARG0 is a constant, move it
6074      to ARG1 to reduce the number of tests below.  */
6075   if (commutative_tree_code (code)
6076       && tree_swap_operands_p (arg0, arg1, true))
6077     return fold (build2 (code, type, TREE_OPERAND (t, 1),
6078                          TREE_OPERAND (t, 0)));
6079
6080   /* Now WINS is set as described above,
6081      ARG0 is the first operand of EXPR,
6082      and ARG1 is the second operand (if it has more than one operand).
6083
6084      First check for cases where an arithmetic operation is applied to a
6085      compound, conditional, or comparison operation.  Push the arithmetic
6086      operation inside the compound or conditional to see if any folding
6087      can then be done.  Convert comparison to conditional for this purpose.
6088      The also optimizes non-constant cases that used to be done in
6089      expand_expr.
6090
6091      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
6092      one of the operands is a comparison and the other is a comparison, a
6093      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
6094      code below would make the expression more complex.  Change it to a
6095      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
6096      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
6097
6098   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
6099        || code == EQ_EXPR || code == NE_EXPR)
6100       && ((truth_value_p (TREE_CODE (arg0))
6101            && (truth_value_p (TREE_CODE (arg1))
6102                || (TREE_CODE (arg1) == BIT_AND_EXPR
6103                    && integer_onep (TREE_OPERAND (arg1, 1)))))
6104           || (truth_value_p (TREE_CODE (arg1))
6105               && (truth_value_p (TREE_CODE (arg0))
6106                   || (TREE_CODE (arg0) == BIT_AND_EXPR
6107                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
6108     {
6109       tem = fold (build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
6110                           : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
6111                           : TRUTH_XOR_EXPR,
6112                           type, fold_convert (boolean_type_node, arg0),
6113                           fold_convert (boolean_type_node, arg1)));
6114
6115       if (code == EQ_EXPR)
6116         tem = invert_truthvalue (tem);
6117
6118       return tem;
6119     }
6120
6121   if (TREE_CODE_CLASS (code) == '1')
6122     {
6123       if (TREE_CODE (arg0) == COMPOUND_EXPR)
6124         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6125                        fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
6126       else if (TREE_CODE (arg0) == COND_EXPR)
6127         {
6128           tree arg01 = TREE_OPERAND (arg0, 1);
6129           tree arg02 = TREE_OPERAND (arg0, 2);
6130           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
6131             arg01 = fold (build1 (code, type, arg01));
6132           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
6133             arg02 = fold (build1 (code, type, arg02));
6134           tem = fold (build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
6135                               arg01, arg02));
6136
6137           /* If this was a conversion, and all we did was to move into
6138              inside the COND_EXPR, bring it back out.  But leave it if
6139              it is a conversion from integer to integer and the
6140              result precision is no wider than a word since such a
6141              conversion is cheap and may be optimized away by combine,
6142              while it couldn't if it were outside the COND_EXPR.  Then return
6143              so we don't get into an infinite recursion loop taking the
6144              conversion out and then back in.  */
6145
6146           if ((code == NOP_EXPR || code == CONVERT_EXPR
6147                || code == NON_LVALUE_EXPR)
6148               && TREE_CODE (tem) == COND_EXPR
6149               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
6150               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
6151               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
6152               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
6153               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
6154                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
6155               && ! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
6156                     && (INTEGRAL_TYPE_P
6157                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
6158                     && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD))
6159             tem = build1 (code, type,
6160                           build3 (COND_EXPR,
6161                                   TREE_TYPE (TREE_OPERAND
6162                                              (TREE_OPERAND (tem, 1), 0)),
6163                                   TREE_OPERAND (tem, 0),
6164                                   TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
6165                                   TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
6166           return tem;
6167         }
6168       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
6169         {
6170           if (TREE_CODE (type) == BOOLEAN_TYPE)
6171             {
6172               arg0 = copy_node (arg0);
6173               TREE_TYPE (arg0) = type;
6174               return arg0;
6175             }
6176           else if (TREE_CODE (type) != INTEGER_TYPE)
6177             return fold (build3 (COND_EXPR, type, arg0,
6178                                  fold (build1 (code, type,
6179                                                integer_one_node)),
6180                                  fold (build1 (code, type,
6181                                                integer_zero_node))));
6182         }
6183    }
6184   else if (TREE_CODE_CLASS (code) == '<'
6185            && TREE_CODE (arg0) == COMPOUND_EXPR)
6186     return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6187                    fold (build2 (code, type, TREE_OPERAND (arg0, 1), arg1)));
6188   else if (TREE_CODE_CLASS (code) == '<'
6189            && TREE_CODE (arg1) == COMPOUND_EXPR)
6190     return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
6191                    fold (build2 (code, type, arg0, TREE_OPERAND (arg1, 1))));
6192   else if (TREE_CODE_CLASS (code) == '2'
6193            || TREE_CODE_CLASS (code) == '<')
6194     {
6195       if (TREE_CODE (arg0) == COMPOUND_EXPR)
6196         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
6197                        fold (build2 (code, type, TREE_OPERAND (arg0, 1),
6198                                      arg1)));
6199       if (TREE_CODE (arg1) == COMPOUND_EXPR
6200           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
6201         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
6202                        fold (build2 (code, type,
6203                                      arg0, TREE_OPERAND (arg1, 1))));
6204
6205       if (TREE_CODE (arg0) == COND_EXPR
6206           || TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
6207         {
6208           tem = fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
6209                                                      /*cond_first_p=*/1);
6210           if (tem != NULL_TREE)
6211             return tem;
6212         }
6213
6214       if (TREE_CODE (arg1) == COND_EXPR
6215           || TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
6216         {
6217           tem = fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
6218                                                      /*cond_first_p=*/0);
6219           if (tem != NULL_TREE)
6220             return tem;
6221         }
6222     }
6223
6224   switch (code)
6225     {
6226     case CONST_DECL:
6227       return fold (DECL_INITIAL (t));
6228
6229     case NOP_EXPR:
6230     case FLOAT_EXPR:
6231     case CONVERT_EXPR:
6232     case FIX_TRUNC_EXPR:
6233     case FIX_CEIL_EXPR:
6234     case FIX_FLOOR_EXPR:
6235     case FIX_ROUND_EXPR:
6236       if (TREE_TYPE (TREE_OPERAND (t, 0)) == type)
6237         return TREE_OPERAND (t, 0);
6238
6239       /* Handle cases of two conversions in a row.  */
6240       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
6241           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
6242         {
6243           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
6244           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
6245           int inside_int = INTEGRAL_TYPE_P (inside_type);
6246           int inside_ptr = POINTER_TYPE_P (inside_type);
6247           int inside_float = FLOAT_TYPE_P (inside_type);
6248           unsigned int inside_prec = TYPE_PRECISION (inside_type);
6249           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
6250           int inter_int = INTEGRAL_TYPE_P (inter_type);
6251           int inter_ptr = POINTER_TYPE_P (inter_type);
6252           int inter_float = FLOAT_TYPE_P (inter_type);
6253           unsigned int inter_prec = TYPE_PRECISION (inter_type);
6254           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
6255           int final_int = INTEGRAL_TYPE_P (type);
6256           int final_ptr = POINTER_TYPE_P (type);
6257           int final_float = FLOAT_TYPE_P (type);
6258           unsigned int final_prec = TYPE_PRECISION (type);
6259           int final_unsignedp = TYPE_UNSIGNED (type);
6260
6261           /* In addition to the cases of two conversions in a row
6262              handled below, if we are converting something to its own
6263              type via an object of identical or wider precision, neither
6264              conversion is needed.  */
6265           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
6266               && ((inter_int && final_int) || (inter_float && final_float))
6267               && inter_prec >= final_prec)
6268             return fold (build1 (code, type,
6269                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6270
6271           /* Likewise, if the intermediate and final types are either both
6272              float or both integer, we don't need the middle conversion if
6273              it is wider than the final type and doesn't change the signedness
6274              (for integers).  Avoid this if the final type is a pointer
6275              since then we sometimes need the inner conversion.  Likewise if
6276              the outer has a precision not equal to the size of its mode.  */
6277           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
6278                || (inter_float && inside_float))
6279               && inter_prec >= inside_prec
6280               && (inter_float || inter_unsignedp == inside_unsignedp)
6281               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
6282                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
6283               && ! final_ptr)
6284             return fold (build1 (code, type,
6285                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6286
6287           /* If we have a sign-extension of a zero-extended value, we can
6288              replace that by a single zero-extension.  */
6289           if (inside_int && inter_int && final_int
6290               && inside_prec < inter_prec && inter_prec < final_prec
6291               && inside_unsignedp && !inter_unsignedp)
6292             return fold (build1 (code, type,
6293                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6294
6295           /* Two conversions in a row are not needed unless:
6296              - some conversion is floating-point (overstrict for now), or
6297              - the intermediate type is narrower than both initial and
6298                final, or
6299              - the intermediate type and innermost type differ in signedness,
6300                and the outermost type is wider than the intermediate, or
6301              - the initial type is a pointer type and the precisions of the
6302                intermediate and final types differ, or
6303              - the final type is a pointer type and the precisions of the
6304                initial and intermediate types differ.  */
6305           if (! inside_float && ! inter_float && ! final_float
6306               && (inter_prec > inside_prec || inter_prec > final_prec)
6307               && ! (inside_int && inter_int
6308                     && inter_unsignedp != inside_unsignedp
6309                     && inter_prec < final_prec)
6310               && ((inter_unsignedp && inter_prec > inside_prec)
6311                   == (final_unsignedp && final_prec > inter_prec))
6312               && ! (inside_ptr && inter_prec != final_prec)
6313               && ! (final_ptr && inside_prec != inter_prec)
6314               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
6315                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
6316               && ! final_ptr)
6317             return fold (build1 (code, type,
6318                                  TREE_OPERAND (TREE_OPERAND (t, 0), 0)));
6319         }
6320
6321       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
6322           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
6323           /* Detect assigning a bitfield.  */
6324           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
6325                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
6326         {
6327           /* Don't leave an assignment inside a conversion
6328              unless assigning a bitfield.  */
6329           tree prev = TREE_OPERAND (t, 0);
6330           tem = copy_node (t);
6331           TREE_OPERAND (tem, 0) = TREE_OPERAND (prev, 1);
6332           /* First do the assignment, then return converted constant.  */
6333           tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), prev, fold (tem));
6334           TREE_NO_WARNING (tem) = 1;
6335           TREE_USED (tem) = 1;
6336           return tem;
6337         }
6338
6339       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
6340          constants (if x has signed type, the sign bit cannot be set
6341          in c).  This folds extension into the BIT_AND_EXPR.  */
6342       if (INTEGRAL_TYPE_P (type)
6343           && TREE_CODE (type) != BOOLEAN_TYPE
6344           && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
6345           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
6346         {
6347           tree and = TREE_OPERAND (t, 0);
6348           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
6349           int change = 0;
6350
6351           if (TYPE_UNSIGNED (TREE_TYPE (and))
6352               || (TYPE_PRECISION (type)
6353                   <= TYPE_PRECISION (TREE_TYPE (and))))
6354             change = 1;
6355           else if (TYPE_PRECISION (TREE_TYPE (and1))
6356                    <= HOST_BITS_PER_WIDE_INT
6357                    && host_integerp (and1, 1))
6358             {
6359               unsigned HOST_WIDE_INT cst;
6360
6361               cst = tree_low_cst (and1, 1);
6362               cst &= (HOST_WIDE_INT) -1
6363                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
6364               change = (cst == 0);
6365 #ifdef LOAD_EXTEND_OP
6366               if (change
6367                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
6368                       == ZERO_EXTEND))
6369                 {
6370                   tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
6371                   and0 = fold_convert (uns, and0);
6372                   and1 = fold_convert (uns, and1);
6373                 }
6374 #endif
6375             }
6376           if (change)
6377             return fold (build2 (BIT_AND_EXPR, type,
6378                                  fold_convert (type, and0),
6379                                  fold_convert (type, and1)));
6380         }
6381
6382       /* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
6383          T2 being pointers to types of the same size.  */
6384       if (POINTER_TYPE_P (TREE_TYPE (t))
6385           && TREE_CODE_CLASS (TREE_CODE (arg0)) == '2'
6386           && TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
6387           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6388         {
6389           tree arg00 = TREE_OPERAND (arg0, 0);
6390           tree t0 = TREE_TYPE (t);
6391           tree t1 = TREE_TYPE (arg00);
6392           tree tt0 = TREE_TYPE (t0);
6393           tree tt1 = TREE_TYPE (t1);
6394           tree s0 = TYPE_SIZE (tt0);
6395           tree s1 = TYPE_SIZE (tt1);
6396
6397           if (s0 && s1 && operand_equal_p (s0, s1, OEP_ONLY_CONST))
6398             return build2 (TREE_CODE (arg0), t0, fold_convert (t0, arg00),
6399                            TREE_OPERAND (arg0, 1));
6400         }
6401
6402       tem = fold_convert_const (code, type, arg0);
6403       return tem ? tem : t;
6404
6405     case VIEW_CONVERT_EXPR:
6406       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
6407         return build1 (VIEW_CONVERT_EXPR, type,
6408                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
6409       return t;
6410
6411     case COMPONENT_REF:
6412       if (TREE_CODE (arg0) == CONSTRUCTOR
6413           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
6414         {
6415           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
6416           if (m)
6417             return TREE_VALUE (m);
6418         }
6419       return t;
6420
6421     case RANGE_EXPR:
6422       if (TREE_CONSTANT (t) != wins)
6423         {
6424           tem = copy_node (t);
6425           TREE_CONSTANT (tem) = wins;
6426           TREE_INVARIANT (tem) = wins;
6427           return tem;
6428         }
6429       return t;
6430
6431     case NEGATE_EXPR:
6432       if (negate_expr_p (arg0))
6433         return fold_convert (type, negate_expr (arg0));
6434       return t;
6435
6436     case ABS_EXPR:
6437       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
6438         return fold_abs_const (arg0, type);
6439       else if (TREE_CODE (arg0) == NEGATE_EXPR)
6440         return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0)));
6441       /* Convert fabs((double)float) into (double)fabsf(float).  */
6442       else if (TREE_CODE (arg0) == NOP_EXPR
6443                && TREE_CODE (type) == REAL_TYPE)
6444         {
6445           tree targ0 = strip_float_extensions (arg0);
6446           if (targ0 != arg0)
6447             return fold_convert (type, fold (build1 (ABS_EXPR,
6448                                                      TREE_TYPE (targ0),
6449                                                      targ0)));
6450         }
6451       else if (tree_expr_nonnegative_p (arg0))
6452         return arg0;
6453       return t;
6454
6455     case CONJ_EXPR:
6456       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6457         return fold_convert (type, arg0);
6458       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6459         return build2 (COMPLEX_EXPR, type,
6460                        TREE_OPERAND (arg0, 0),
6461                        negate_expr (TREE_OPERAND (arg0, 1)));
6462       else if (TREE_CODE (arg0) == COMPLEX_CST)
6463         return build_complex (type, TREE_REALPART (arg0),
6464                               negate_expr (TREE_IMAGPART (arg0)));
6465       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6466         return fold (build2 (TREE_CODE (arg0), type,
6467                              fold (build1 (CONJ_EXPR, type,
6468                                            TREE_OPERAND (arg0, 0))),
6469                              fold (build1 (CONJ_EXPR, type,
6470                                            TREE_OPERAND (arg0, 1)))));
6471       else if (TREE_CODE (arg0) == CONJ_EXPR)
6472         return TREE_OPERAND (arg0, 0);
6473       return t;
6474
6475     case BIT_NOT_EXPR:
6476       if (TREE_CODE (arg0) == INTEGER_CST)
6477         return fold_not_const (arg0, type);
6478       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
6479         return TREE_OPERAND (arg0, 0);
6480       return t;
6481
6482     case PLUS_EXPR:
6483       /* A + (-B) -> A - B */
6484       if (TREE_CODE (arg1) == NEGATE_EXPR)
6485         return fold (build2 (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
6486       /* (-A) + B -> B - A */
6487       if (TREE_CODE (arg0) == NEGATE_EXPR
6488           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
6489         return fold (build2 (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
6490       if (! FLOAT_TYPE_P (type))
6491         {
6492           if (integer_zerop (arg1))
6493             return non_lvalue (fold_convert (type, arg0));
6494
6495           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
6496              with a constant, and the two constants have no bits in common,
6497              we should treat this as a BIT_IOR_EXPR since this may produce more
6498              simplifications.  */
6499           if (TREE_CODE (arg0) == BIT_AND_EXPR
6500               && TREE_CODE (arg1) == BIT_AND_EXPR
6501               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6502               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
6503               && integer_zerop (const_binop (BIT_AND_EXPR,
6504                                              TREE_OPERAND (arg0, 1),
6505                                              TREE_OPERAND (arg1, 1), 0)))
6506             {
6507               code = BIT_IOR_EXPR;
6508               goto bit_ior;
6509             }
6510
6511           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
6512              (plus (plus (mult) (mult)) (foo)) so that we can
6513              take advantage of the factoring cases below.  */
6514           if ((TREE_CODE (arg0) == PLUS_EXPR
6515                && TREE_CODE (arg1) == MULT_EXPR)
6516               || (TREE_CODE (arg1) == PLUS_EXPR
6517                   && TREE_CODE (arg0) == MULT_EXPR))
6518             {
6519               tree parg0, parg1, parg, marg;
6520
6521               if (TREE_CODE (arg0) == PLUS_EXPR)
6522                 parg = arg0, marg = arg1;
6523               else
6524                 parg = arg1, marg = arg0;
6525               parg0 = TREE_OPERAND (parg, 0);
6526               parg1 = TREE_OPERAND (parg, 1);
6527               STRIP_NOPS (parg0);
6528               STRIP_NOPS (parg1);
6529
6530               if (TREE_CODE (parg0) == MULT_EXPR
6531                   && TREE_CODE (parg1) != MULT_EXPR)
6532                 return fold (build2 (PLUS_EXPR, type,
6533                                      fold (build2 (PLUS_EXPR, type,
6534                                                    fold_convert (type, parg0),
6535                                                    fold_convert (type, marg))),
6536                                      fold_convert (type, parg1)));
6537               if (TREE_CODE (parg0) != MULT_EXPR
6538                   && TREE_CODE (parg1) == MULT_EXPR)
6539                 return fold (build2 (PLUS_EXPR, type,
6540                                      fold (build2 (PLUS_EXPR, type,
6541                                                    fold_convert (type, parg1),
6542                                                    fold_convert (type, marg))),
6543                                      fold_convert (type, parg0)));
6544             }
6545
6546           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
6547             {
6548               tree arg00, arg01, arg10, arg11;
6549               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6550
6551               /* (A * C) + (B * C) -> (A+B) * C.
6552                  We are most concerned about the case where C is a constant,
6553                  but other combinations show up during loop reduction.  Since
6554                  it is not difficult, try all four possibilities.  */
6555
6556               arg00 = TREE_OPERAND (arg0, 0);
6557               arg01 = TREE_OPERAND (arg0, 1);
6558               arg10 = TREE_OPERAND (arg1, 0);
6559               arg11 = TREE_OPERAND (arg1, 1);
6560               same = NULL_TREE;
6561
6562               if (operand_equal_p (arg01, arg11, 0))
6563                 same = arg01, alt0 = arg00, alt1 = arg10;
6564               else if (operand_equal_p (arg00, arg10, 0))
6565                 same = arg00, alt0 = arg01, alt1 = arg11;
6566               else if (operand_equal_p (arg00, arg11, 0))
6567                 same = arg00, alt0 = arg01, alt1 = arg10;
6568               else if (operand_equal_p (arg01, arg10, 0))
6569                 same = arg01, alt0 = arg00, alt1 = arg11;
6570
6571               /* No identical multiplicands; see if we can find a common
6572                  power-of-two factor in non-power-of-two multiplies.  This
6573                  can help in multi-dimensional array access.  */
6574               else if (TREE_CODE (arg01) == INTEGER_CST
6575                        && TREE_CODE (arg11) == INTEGER_CST
6576                        && TREE_INT_CST_HIGH (arg01) == 0
6577                        && TREE_INT_CST_HIGH (arg11) == 0)
6578                 {
6579                   HOST_WIDE_INT int01, int11, tmp;
6580                   int01 = TREE_INT_CST_LOW (arg01);
6581                   int11 = TREE_INT_CST_LOW (arg11);
6582
6583                   /* Move min of absolute values to int11.  */
6584                   if ((int01 >= 0 ? int01 : -int01)
6585                       < (int11 >= 0 ? int11 : -int11))
6586                     {
6587                       tmp = int01, int01 = int11, int11 = tmp;
6588                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
6589                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
6590                     }
6591
6592                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
6593                     {
6594                       alt0 = fold (build2 (MULT_EXPR, type, arg00,
6595                                            build_int_cst (NULL_TREE,
6596                                                           int01 / int11)));
6597                       alt1 = arg10;
6598                       same = arg11;
6599                     }
6600                 }
6601
6602               if (same)
6603                 return fold (build2 (MULT_EXPR, type,
6604                                      fold (build2 (PLUS_EXPR, type,
6605                                                    alt0, alt1)),
6606                                      same));
6607             }
6608         }
6609       else
6610         {
6611           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
6612           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
6613             return non_lvalue (fold_convert (type, arg0));
6614
6615           /* Likewise if the operands are reversed.  */
6616           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
6617             return non_lvalue (fold_convert (type, arg1));
6618
6619           /* Convert X + -C into X - C.  */
6620           if (TREE_CODE (arg1) == REAL_CST
6621               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
6622             {
6623               tem = fold_negate_const (arg1, type);
6624               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
6625                 return fold (build2 (MINUS_EXPR, type,
6626                                      fold_convert (type, arg0),
6627                                      fold_convert (type, tem)));
6628             }
6629
6630           /* Convert x+x into x*2.0.  */
6631           if (operand_equal_p (arg0, arg1, 0)
6632               && SCALAR_FLOAT_TYPE_P (type))
6633             return fold (build2 (MULT_EXPR, type, arg0,
6634                                  build_real (type, dconst2)));
6635
6636           /* Convert x*c+x into x*(c+1).  */
6637           if (flag_unsafe_math_optimizations
6638               && TREE_CODE (arg0) == MULT_EXPR
6639               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6640               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6641               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
6642             {
6643               REAL_VALUE_TYPE c;
6644
6645               c = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6646               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6647               return fold (build2 (MULT_EXPR, type, arg1,
6648                                    build_real (type, c)));
6649             }
6650
6651           /* Convert x+x*c into x*(c+1).  */
6652           if (flag_unsafe_math_optimizations
6653               && TREE_CODE (arg1) == MULT_EXPR
6654               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6655               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6656               && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
6657             {
6658               REAL_VALUE_TYPE c;
6659
6660               c = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6661               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6662               return fold (build2 (MULT_EXPR, type, arg0,
6663                                    build_real (type, c)));
6664             }
6665
6666           /* Convert x*c1+x*c2 into x*(c1+c2).  */
6667           if (flag_unsafe_math_optimizations
6668               && TREE_CODE (arg0) == MULT_EXPR
6669               && TREE_CODE (arg1) == MULT_EXPR
6670               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6671               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6672               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6673               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6674               && operand_equal_p (TREE_OPERAND (arg0, 0),
6675                                   TREE_OPERAND (arg1, 0), 0))
6676             {
6677               REAL_VALUE_TYPE c1, c2;
6678
6679               c1 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6680               c2 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6681               real_arithmetic (&c1, PLUS_EXPR, &c1, &c2);
6682               return fold (build2 (MULT_EXPR, type,
6683                                    TREE_OPERAND (arg0, 0),
6684                                    build_real (type, c1)));
6685             }
6686           /* Convert a + (b*c + d*e) into (a + b*c) + d*e */
6687           if (flag_unsafe_math_optimizations
6688               && TREE_CODE (arg1) == PLUS_EXPR
6689               && TREE_CODE (arg0) != MULT_EXPR)
6690             {
6691               tree tree10 = TREE_OPERAND (arg1, 0);
6692               tree tree11 = TREE_OPERAND (arg1, 1);
6693               if (TREE_CODE (tree11) == MULT_EXPR
6694                   && TREE_CODE (tree10) == MULT_EXPR)
6695                 {
6696                   tree tree0;
6697                   tree0 = fold (build2 (PLUS_EXPR, type, arg0, tree10));
6698                   return fold (build2 (PLUS_EXPR, type, tree0, tree11));
6699                 }
6700             }
6701           /* Convert (b*c + d*e) + a into b*c + (d*e +a) */
6702           if (flag_unsafe_math_optimizations
6703               && TREE_CODE (arg0) == PLUS_EXPR
6704               && TREE_CODE (arg1) != MULT_EXPR)
6705             {
6706               tree tree00 = TREE_OPERAND (arg0, 0);
6707               tree tree01 = TREE_OPERAND (arg0, 1);
6708               if (TREE_CODE (tree01) == MULT_EXPR
6709                   && TREE_CODE (tree00) == MULT_EXPR)
6710                 {
6711                   tree tree0;
6712                   tree0 = fold (build2 (PLUS_EXPR, type, tree01, arg1));
6713                   return fold (build2 (PLUS_EXPR, type, tree00, tree0));
6714                 }
6715             }
6716         }
6717
6718      bit_rotate:
6719       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
6720          is a rotate of A by C1 bits.  */
6721       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
6722          is a rotate of A by B bits.  */
6723       {
6724         enum tree_code code0, code1;
6725         code0 = TREE_CODE (arg0);
6726         code1 = TREE_CODE (arg1);
6727         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
6728              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
6729             && operand_equal_p (TREE_OPERAND (arg0, 0),
6730                                 TREE_OPERAND (arg1, 0), 0)
6731             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6732           {
6733             tree tree01, tree11;
6734             enum tree_code code01, code11;
6735
6736             tree01 = TREE_OPERAND (arg0, 1);
6737             tree11 = TREE_OPERAND (arg1, 1);
6738             STRIP_NOPS (tree01);
6739             STRIP_NOPS (tree11);
6740             code01 = TREE_CODE (tree01);
6741             code11 = TREE_CODE (tree11);
6742             if (code01 == INTEGER_CST
6743                 && code11 == INTEGER_CST
6744                 && TREE_INT_CST_HIGH (tree01) == 0
6745                 && TREE_INT_CST_HIGH (tree11) == 0
6746                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
6747                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
6748               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
6749                              code0 == LSHIFT_EXPR ? tree01 : tree11);
6750             else if (code11 == MINUS_EXPR)
6751               {
6752                 tree tree110, tree111;
6753                 tree110 = TREE_OPERAND (tree11, 0);
6754                 tree111 = TREE_OPERAND (tree11, 1);
6755                 STRIP_NOPS (tree110);
6756                 STRIP_NOPS (tree111);
6757                 if (TREE_CODE (tree110) == INTEGER_CST
6758                     && 0 == compare_tree_int (tree110,
6759                                               TYPE_PRECISION
6760                                               (TREE_TYPE (TREE_OPERAND
6761                                                           (arg0, 0))))
6762                     && operand_equal_p (tree01, tree111, 0))
6763                   return build2 ((code0 == LSHIFT_EXPR
6764                                   ? LROTATE_EXPR
6765                                   : RROTATE_EXPR),
6766                                  type, TREE_OPERAND (arg0, 0), tree01);
6767               }
6768             else if (code01 == MINUS_EXPR)
6769               {
6770                 tree tree010, tree011;
6771                 tree010 = TREE_OPERAND (tree01, 0);
6772                 tree011 = TREE_OPERAND (tree01, 1);
6773                 STRIP_NOPS (tree010);
6774                 STRIP_NOPS (tree011);
6775                 if (TREE_CODE (tree010) == INTEGER_CST
6776                     && 0 == compare_tree_int (tree010,
6777                                               TYPE_PRECISION
6778                                               (TREE_TYPE (TREE_OPERAND
6779                                                           (arg0, 0))))
6780                     && operand_equal_p (tree11, tree011, 0))
6781                   return build2 ((code0 != LSHIFT_EXPR
6782                                   ? LROTATE_EXPR
6783                                   : RROTATE_EXPR),
6784                                  type, TREE_OPERAND (arg0, 0), tree11);
6785               }
6786           }
6787       }
6788
6789     associate:
6790       /* In most languages, can't associate operations on floats through
6791          parentheses.  Rather than remember where the parentheses were, we
6792          don't associate floats at all, unless the user has specified
6793          -funsafe-math-optimizations.  */
6794
6795       if (! wins
6796           && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
6797         {
6798           tree var0, con0, lit0, minus_lit0;
6799           tree var1, con1, lit1, minus_lit1;
6800
6801           /* Split both trees into variables, constants, and literals.  Then
6802              associate each group together, the constants with literals,
6803              then the result with variables.  This increases the chances of
6804              literals being recombined later and of generating relocatable
6805              expressions for the sum of a constant and literal.  */
6806           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
6807           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
6808                              code == MINUS_EXPR);
6809
6810           /* Only do something if we found more than two objects.  Otherwise,
6811              nothing has changed and we risk infinite recursion.  */
6812           if (2 < ((var0 != 0) + (var1 != 0)
6813                    + (con0 != 0) + (con1 != 0)
6814                    + (lit0 != 0) + (lit1 != 0)
6815                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
6816             {
6817               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
6818               if (code == MINUS_EXPR)
6819                 code = PLUS_EXPR;
6820
6821               var0 = associate_trees (var0, var1, code, type);
6822               con0 = associate_trees (con0, con1, code, type);
6823               lit0 = associate_trees (lit0, lit1, code, type);
6824               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
6825
6826               /* Preserve the MINUS_EXPR if the negative part of the literal is
6827                  greater than the positive part.  Otherwise, the multiplicative
6828                  folding code (i.e extract_muldiv) may be fooled in case
6829                  unsigned constants are subtracted, like in the following
6830                  example: ((X*2 + 4) - 8U)/2.  */
6831               if (minus_lit0 && lit0)
6832                 {
6833                   if (TREE_CODE (lit0) == INTEGER_CST
6834                       && TREE_CODE (minus_lit0) == INTEGER_CST
6835                       && tree_int_cst_lt (lit0, minus_lit0))
6836                     {
6837                       minus_lit0 = associate_trees (minus_lit0, lit0,
6838                                                     MINUS_EXPR, type);
6839                       lit0 = 0;
6840                     }
6841                   else
6842                     {
6843                       lit0 = associate_trees (lit0, minus_lit0,
6844                                               MINUS_EXPR, type);
6845                       minus_lit0 = 0;
6846                     }
6847                 }
6848               if (minus_lit0)
6849                 {
6850                   if (con0 == 0)
6851                     return fold_convert (type,
6852                                          associate_trees (var0, minus_lit0,
6853                                                           MINUS_EXPR, type));
6854                   else
6855                     {
6856                       con0 = associate_trees (con0, minus_lit0,
6857                                               MINUS_EXPR, type);
6858                       return fold_convert (type,
6859                                            associate_trees (var0, con0,
6860                                                             PLUS_EXPR, type));
6861                     }
6862                 }
6863
6864               con0 = associate_trees (con0, lit0, code, type);
6865               return fold_convert (type, associate_trees (var0, con0,
6866                                                           code, type));
6867             }
6868         }
6869
6870     binary:
6871       if (wins)
6872         t1 = const_binop (code, arg0, arg1, 0);
6873       if (t1 != NULL_TREE)
6874         {
6875           /* The return value should always have
6876              the same type as the original expression.  */
6877           if (TREE_TYPE (t1) != type)
6878             t1 = fold_convert (type, t1);
6879
6880           return t1;
6881         }
6882       return t;
6883
6884     case MINUS_EXPR:
6885       /* A - (-B) -> A + B */
6886       if (TREE_CODE (arg1) == NEGATE_EXPR)
6887         return fold (build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
6888       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
6889       if (TREE_CODE (arg0) == NEGATE_EXPR
6890           && (FLOAT_TYPE_P (type)
6891               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
6892           && negate_expr_p (arg1)
6893           && reorder_operands_p (arg0, arg1))
6894         return fold (build2 (MINUS_EXPR, type, negate_expr (arg1),
6895                              TREE_OPERAND (arg0, 0)));
6896
6897       if (! FLOAT_TYPE_P (type))
6898         {
6899           if (! wins && integer_zerop (arg0))
6900             return negate_expr (fold_convert (type, arg1));
6901           if (integer_zerop (arg1))
6902             return non_lvalue (fold_convert (type, arg0));
6903
6904           /* Fold A - (A & B) into ~B & A.  */
6905           if (!TREE_SIDE_EFFECTS (arg0)
6906               && TREE_CODE (arg1) == BIT_AND_EXPR)
6907             {
6908               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
6909                 return fold (build2 (BIT_AND_EXPR, type,
6910                                      fold (build1 (BIT_NOT_EXPR, type,
6911                                                    TREE_OPERAND (arg1, 0))),
6912                                      arg0));
6913               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
6914                 return fold (build2 (BIT_AND_EXPR, type,
6915                                      fold (build1 (BIT_NOT_EXPR, type,
6916                                                    TREE_OPERAND (arg1, 1))),
6917                                      arg0));
6918             }
6919
6920           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
6921              any power of 2 minus 1.  */
6922           if (TREE_CODE (arg0) == BIT_AND_EXPR
6923               && TREE_CODE (arg1) == BIT_AND_EXPR
6924               && operand_equal_p (TREE_OPERAND (arg0, 0),
6925                                   TREE_OPERAND (arg1, 0), 0))
6926             {
6927               tree mask0 = TREE_OPERAND (arg0, 1);
6928               tree mask1 = TREE_OPERAND (arg1, 1);
6929               tree tem = fold (build1 (BIT_NOT_EXPR, type, mask0));
6930
6931               if (operand_equal_p (tem, mask1, 0))
6932                 {
6933                   tem = fold (build2 (BIT_XOR_EXPR, type,
6934                                       TREE_OPERAND (arg0, 0), mask1));
6935                   return fold (build2 (MINUS_EXPR, type, tem, mask1));
6936                 }
6937             }
6938         }
6939
6940       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
6941       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
6942         return non_lvalue (fold_convert (type, arg0));
6943
6944       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
6945          ARG0 is zero and X + ARG0 reduces to X, since that would mean
6946          (-ARG1 + ARG0) reduces to -ARG1.  */
6947       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
6948         return negate_expr (fold_convert (type, arg1));
6949
6950       /* Fold &x - &x.  This can happen from &x.foo - &x.
6951          This is unsafe for certain floats even in non-IEEE formats.
6952          In IEEE, it is unsafe because it does wrong for NaNs.
6953          Also note that operand_equal_p is always false if an operand
6954          is volatile.  */
6955
6956       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
6957           && operand_equal_p (arg0, arg1, 0))
6958         return fold_convert (type, integer_zero_node);
6959
6960       /* A - B -> A + (-B) if B is easily negatable.  */
6961       if (!wins && negate_expr_p (arg1)
6962           && ((FLOAT_TYPE_P (type)
6963                /* Avoid this transformation if B is a positive REAL_CST.  */
6964                && (TREE_CODE (arg1) != REAL_CST
6965                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
6966               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
6967         return fold (build2 (PLUS_EXPR, type, arg0, negate_expr (arg1)));
6968
6969       /* Try folding difference of addresses.  */
6970       {
6971         HOST_WIDE_INT diff;
6972
6973         if (TREE_CODE (arg0) == ADDR_EXPR
6974             && TREE_CODE (arg1) == ADDR_EXPR
6975             && ptr_difference_const (TREE_OPERAND (arg0, 0),
6976                                      TREE_OPERAND (arg1, 0),
6977                                      &diff))
6978           return build_int_cst_type (type, diff);
6979       }
6980
6981       if (TREE_CODE (arg0) == MULT_EXPR
6982           && TREE_CODE (arg1) == MULT_EXPR
6983           && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
6984         {
6985           /* (A * C) - (B * C) -> (A-B) * C.  */
6986           if (operand_equal_p (TREE_OPERAND (arg0, 1),
6987                                TREE_OPERAND (arg1, 1), 0))
6988             return fold (build2 (MULT_EXPR, type,
6989                                  fold (build2 (MINUS_EXPR, type,
6990                                                TREE_OPERAND (arg0, 0),
6991                                                TREE_OPERAND (arg1, 0))),
6992                                  TREE_OPERAND (arg0, 1)));
6993           /* (A * C1) - (A * C2) -> A * (C1-C2).  */
6994           if (operand_equal_p (TREE_OPERAND (arg0, 0),
6995                                TREE_OPERAND (arg1, 0), 0))
6996             return fold (build2 (MULT_EXPR, type,
6997                                  TREE_OPERAND (arg0, 0),
6998                                  fold (build2 (MINUS_EXPR, type,
6999                                                TREE_OPERAND (arg0, 1),
7000                                                TREE_OPERAND (arg1, 1)))));
7001         }
7002
7003       goto associate;
7004
7005     case MULT_EXPR:
7006       /* (-A) * (-B) -> A * B  */
7007       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7008         return fold (build2 (MULT_EXPR, type,
7009                              TREE_OPERAND (arg0, 0),
7010                              negate_expr (arg1)));
7011       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7012         return fold (build2 (MULT_EXPR, type,
7013                              negate_expr (arg0),
7014                              TREE_OPERAND (arg1, 0)));
7015
7016       if (! FLOAT_TYPE_P (type))
7017         {
7018           if (integer_zerop (arg1))
7019             return omit_one_operand (type, arg1, arg0);
7020           if (integer_onep (arg1))
7021             return non_lvalue (fold_convert (type, arg0));
7022
7023           /* (a * (1 << b)) is (a << b)  */
7024           if (TREE_CODE (arg1) == LSHIFT_EXPR
7025               && integer_onep (TREE_OPERAND (arg1, 0)))
7026             return fold (build2 (LSHIFT_EXPR, type, arg0,
7027                                  TREE_OPERAND (arg1, 1)));
7028           if (TREE_CODE (arg0) == LSHIFT_EXPR
7029               && integer_onep (TREE_OPERAND (arg0, 0)))
7030             return fold (build2 (LSHIFT_EXPR, type, arg1,
7031                                  TREE_OPERAND (arg0, 1)));
7032
7033           if (TREE_CODE (arg1) == INTEGER_CST
7034               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
7035                                              fold_convert (type, arg1),
7036                                              code, NULL_TREE)))
7037             return fold_convert (type, tem);
7038
7039         }
7040       else
7041         {
7042           /* Maybe fold x * 0 to 0.  The expressions aren't the same
7043              when x is NaN, since x * 0 is also NaN.  Nor are they the
7044              same in modes with signed zeros, since multiplying a
7045              negative value by 0 gives -0, not +0.  */
7046           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
7047               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
7048               && real_zerop (arg1))
7049             return omit_one_operand (type, arg1, arg0);
7050           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
7051           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7052               && real_onep (arg1))
7053             return non_lvalue (fold_convert (type, arg0));
7054
7055           /* Transform x * -1.0 into -x.  */
7056           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7057               && real_minus_onep (arg1))
7058             return fold_convert (type, negate_expr (arg0));
7059
7060           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
7061           if (flag_unsafe_math_optimizations
7062               && TREE_CODE (arg0) == RDIV_EXPR
7063               && TREE_CODE (arg1) == REAL_CST
7064               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
7065             {
7066               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
7067                                       arg1, 0);
7068               if (tem)
7069                 return fold (build2 (RDIV_EXPR, type, tem,
7070                                      TREE_OPERAND (arg0, 1)));
7071             }
7072
7073           if (flag_unsafe_math_optimizations)
7074             {
7075               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7076               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7077
7078               /* Optimizations of root(...)*root(...).  */
7079               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
7080                 {
7081                   tree rootfn, arg, arglist;
7082                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7083                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7084
7085                   /* Optimize sqrt(x)*sqrt(x) as x.  */
7086                   if (BUILTIN_SQRT_P (fcode0)
7087                       && operand_equal_p (arg00, arg10, 0)
7088                       && ! HONOR_SNANS (TYPE_MODE (type)))
7089                     return arg00;
7090
7091                   /* Optimize root(x)*root(y) as root(x*y).  */
7092                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7093                   arg = fold (build2 (MULT_EXPR, type, arg00, arg10));
7094                   arglist = build_tree_list (NULL_TREE, arg);
7095                   return build_function_call_expr (rootfn, arglist);
7096                 }
7097
7098               /* Optimize expN(x)*expN(y) as expN(x+y).  */
7099               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
7100                 {
7101                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7102                   tree arg = build2 (PLUS_EXPR, type,
7103                                      TREE_VALUE (TREE_OPERAND (arg0, 1)),
7104                                      TREE_VALUE (TREE_OPERAND (arg1, 1)));
7105                   tree arglist = build_tree_list (NULL_TREE, fold (arg));
7106                   return build_function_call_expr (expfn, arglist);
7107                 }
7108
7109               /* Optimizations of pow(...)*pow(...).  */
7110               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
7111                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
7112                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
7113                 {
7114                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7115                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7116                                                                      1)));
7117                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7118                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7119                                                                      1)));
7120
7121                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
7122                   if (operand_equal_p (arg01, arg11, 0))
7123                     {
7124                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7125                       tree arg = build2 (MULT_EXPR, type, arg00, arg10);
7126                       tree arglist = tree_cons (NULL_TREE, fold (arg),
7127                                                 build_tree_list (NULL_TREE,
7128                                                                  arg01));
7129                       return build_function_call_expr (powfn, arglist);
7130                     }
7131
7132                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
7133                   if (operand_equal_p (arg00, arg10, 0))
7134                     {
7135                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7136                       tree arg = fold (build2 (PLUS_EXPR, type, arg01, arg11));
7137                       tree arglist = tree_cons (NULL_TREE, arg00,
7138                                                 build_tree_list (NULL_TREE,
7139                                                                  arg));
7140                       return build_function_call_expr (powfn, arglist);
7141                     }
7142                 }
7143
7144               /* Optimize tan(x)*cos(x) as sin(x).  */
7145               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
7146                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
7147                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
7148                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
7149                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
7150                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
7151                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7152                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7153                 {
7154                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
7155
7156                   if (sinfn != NULL_TREE)
7157                     return build_function_call_expr (sinfn,
7158                                                      TREE_OPERAND (arg0, 1));
7159                 }
7160
7161               /* Optimize x*pow(x,c) as pow(x,c+1).  */
7162               if (fcode1 == BUILT_IN_POW
7163                   || fcode1 == BUILT_IN_POWF
7164                   || fcode1 == BUILT_IN_POWL)
7165                 {
7166                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7167                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7168                                                                      1)));
7169                   if (TREE_CODE (arg11) == REAL_CST
7170                       && ! TREE_CONSTANT_OVERFLOW (arg11)
7171                       && operand_equal_p (arg0, arg10, 0))
7172                     {
7173                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7174                       REAL_VALUE_TYPE c;
7175                       tree arg, arglist;
7176
7177                       c = TREE_REAL_CST (arg11);
7178                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7179                       arg = build_real (type, c);
7180                       arglist = build_tree_list (NULL_TREE, arg);
7181                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7182                       return build_function_call_expr (powfn, arglist);
7183                     }
7184                 }
7185
7186               /* Optimize pow(x,c)*x as pow(x,c+1).  */
7187               if (fcode0 == BUILT_IN_POW
7188                   || fcode0 == BUILT_IN_POWF
7189                   || fcode0 == BUILT_IN_POWL)
7190                 {
7191                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7192                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7193                                                                      1)));
7194                   if (TREE_CODE (arg01) == REAL_CST
7195                       && ! TREE_CONSTANT_OVERFLOW (arg01)
7196                       && operand_equal_p (arg1, arg00, 0))
7197                     {
7198                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7199                       REAL_VALUE_TYPE c;
7200                       tree arg, arglist;
7201
7202                       c = TREE_REAL_CST (arg01);
7203                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7204                       arg = build_real (type, c);
7205                       arglist = build_tree_list (NULL_TREE, arg);
7206                       arglist = tree_cons (NULL_TREE, arg1, arglist);
7207                       return build_function_call_expr (powfn, arglist);
7208                     }
7209                 }
7210
7211               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
7212               if (! optimize_size
7213                   && operand_equal_p (arg0, arg1, 0))
7214                 {
7215                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7216
7217                   if (powfn)
7218                     {
7219                       tree arg = build_real (type, dconst2);
7220                       tree arglist = build_tree_list (NULL_TREE, arg);
7221                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7222                       return build_function_call_expr (powfn, arglist);
7223                     }
7224                 }
7225             }
7226         }
7227       goto associate;
7228
7229     case BIT_IOR_EXPR:
7230     bit_ior:
7231       if (integer_all_onesp (arg1))
7232         return omit_one_operand (type, arg1, arg0);
7233       if (integer_zerop (arg1))
7234         return non_lvalue (fold_convert (type, arg0));
7235       if (operand_equal_p (arg0, arg1, 0))
7236         return non_lvalue (fold_convert (type, arg0));
7237
7238       /* ~X | X is -1.  */
7239       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7240           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7241         {
7242           t1 = build_int_cst (type, -1);
7243           t1 = force_fit_type (t1, 0, false, false);
7244           return omit_one_operand (type, t1, arg1);
7245         }
7246
7247       /* X | ~X is -1.  */
7248       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7249           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7250         {
7251           t1 = build_int_cst (type, -1);
7252           t1 = force_fit_type (t1, 0, false, false);
7253           return omit_one_operand (type, t1, arg0);
7254         }
7255
7256       t1 = distribute_bit_expr (code, type, arg0, arg1);
7257       if (t1 != NULL_TREE)
7258         return t1;
7259
7260       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
7261
7262          This results in more efficient code for machines without a NAND
7263          instruction.  Combine will canonicalize to the first form
7264          which will allow use of NAND instructions provided by the
7265          backend if they exist.  */
7266       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7267           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7268         {
7269           return fold (build1 (BIT_NOT_EXPR, type,
7270                                build2 (BIT_AND_EXPR, type,
7271                                        TREE_OPERAND (arg0, 0),
7272                                        TREE_OPERAND (arg1, 0))));
7273         }
7274
7275       /* See if this can be simplified into a rotate first.  If that
7276          is unsuccessful continue in the association code.  */
7277       goto bit_rotate;
7278
7279     case BIT_XOR_EXPR:
7280       if (integer_zerop (arg1))
7281         return non_lvalue (fold_convert (type, arg0));
7282       if (integer_all_onesp (arg1))
7283         return fold (build1 (BIT_NOT_EXPR, type, arg0));
7284       if (operand_equal_p (arg0, arg1, 0))
7285         return omit_one_operand (type, integer_zero_node, arg0);
7286
7287       /* ~X ^ X is -1.  */
7288       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7289           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7290         {
7291           t1 = build_int_cst (type, -1);
7292           t1 = force_fit_type (t1, 0, false, false);
7293           return omit_one_operand (type, t1, arg1);
7294         }
7295
7296       /* X ^ ~X is -1.  */
7297       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7298           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7299         {
7300           t1 = build_int_cst (type, -1);
7301           t1 = force_fit_type (t1, 0, false, false);
7302           return omit_one_operand (type, t1, arg0);
7303         }
7304
7305       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
7306          with a constant, and the two constants have no bits in common,
7307          we should treat this as a BIT_IOR_EXPR since this may produce more
7308          simplifications.  */
7309       if (TREE_CODE (arg0) == BIT_AND_EXPR
7310           && TREE_CODE (arg1) == BIT_AND_EXPR
7311           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7312           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7313           && integer_zerop (const_binop (BIT_AND_EXPR,
7314                                          TREE_OPERAND (arg0, 1),
7315                                          TREE_OPERAND (arg1, 1), 0)))
7316         {
7317           code = BIT_IOR_EXPR;
7318           goto bit_ior;
7319         }
7320
7321       /* See if this can be simplified into a rotate first.  If that
7322          is unsuccessful continue in the association code.  */
7323       goto bit_rotate;
7324
7325     case BIT_AND_EXPR:
7326       if (integer_all_onesp (arg1))
7327         return non_lvalue (fold_convert (type, arg0));
7328       if (integer_zerop (arg1))
7329         return omit_one_operand (type, arg1, arg0);
7330       if (operand_equal_p (arg0, arg1, 0))
7331         return non_lvalue (fold_convert (type, arg0));
7332
7333       /* ~X & X is always zero.  */
7334       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7335           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7336         return omit_one_operand (type, integer_zero_node, arg1);
7337
7338       /* X & ~X is always zero.  */
7339       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7340           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7341         return omit_one_operand (type, integer_zero_node, arg0);
7342
7343       t1 = distribute_bit_expr (code, type, arg0, arg1);
7344       if (t1 != NULL_TREE)
7345         return t1;
7346       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
7347       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
7348           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7349         {
7350           unsigned int prec
7351             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
7352
7353           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
7354               && (~TREE_INT_CST_LOW (arg1)
7355                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
7356             return fold_convert (type, TREE_OPERAND (arg0, 0));
7357         }
7358
7359       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
7360
7361          This results in more efficient code for machines without a NOR
7362          instruction.  Combine will canonicalize to the first form
7363          which will allow use of NOR instructions provided by the
7364          backend if they exist.  */
7365       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7366           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7367         {
7368           return fold (build1 (BIT_NOT_EXPR, type,
7369                                build2 (BIT_IOR_EXPR, type,
7370                                        TREE_OPERAND (arg0, 0),
7371                                        TREE_OPERAND (arg1, 0))));
7372         }
7373
7374       goto associate;
7375
7376     case RDIV_EXPR:
7377       /* Don't touch a floating-point divide by zero unless the mode
7378          of the constant can represent infinity.  */
7379       if (TREE_CODE (arg1) == REAL_CST
7380           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
7381           && real_zerop (arg1))
7382         return t;
7383
7384       /* (-A) / (-B) -> A / B  */
7385       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7386         return fold (build2 (RDIV_EXPR, type,
7387                              TREE_OPERAND (arg0, 0),
7388                              negate_expr (arg1)));
7389       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7390         return fold (build2 (RDIV_EXPR, type,
7391                              negate_expr (arg0),
7392                              TREE_OPERAND (arg1, 0)));
7393
7394       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
7395       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7396           && real_onep (arg1))
7397         return non_lvalue (fold_convert (type, arg0));
7398
7399       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
7400       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7401           && real_minus_onep (arg1))
7402         return non_lvalue (fold_convert (type, negate_expr (arg0)));
7403
7404       /* If ARG1 is a constant, we can convert this to a multiply by the
7405          reciprocal.  This does not have the same rounding properties,
7406          so only do this if -funsafe-math-optimizations.  We can actually
7407          always safely do it if ARG1 is a power of two, but it's hard to
7408          tell if it is or not in a portable manner.  */
7409       if (TREE_CODE (arg1) == REAL_CST)
7410         {
7411           if (flag_unsafe_math_optimizations
7412               && 0 != (tem = const_binop (code, build_real (type, dconst1),
7413                                           arg1, 0)))
7414             return fold (build2 (MULT_EXPR, type, arg0, tem));
7415           /* Find the reciprocal if optimizing and the result is exact.  */
7416           if (optimize)
7417             {
7418               REAL_VALUE_TYPE r;
7419               r = TREE_REAL_CST (arg1);
7420               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
7421                 {
7422                   tem = build_real (type, r);
7423                   return fold (build2 (MULT_EXPR, type, arg0, tem));
7424                 }
7425             }
7426         }
7427       /* Convert A/B/C to A/(B*C).  */
7428       if (flag_unsafe_math_optimizations
7429           && TREE_CODE (arg0) == RDIV_EXPR)
7430         return fold (build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
7431                              fold (build2 (MULT_EXPR, type,
7432                                            TREE_OPERAND (arg0, 1), arg1))));
7433
7434       /* Convert A/(B/C) to (A/B)*C.  */
7435       if (flag_unsafe_math_optimizations
7436           && TREE_CODE (arg1) == RDIV_EXPR)
7437         return fold (build2 (MULT_EXPR, type,
7438                              fold (build2 (RDIV_EXPR, type, arg0,
7439                                            TREE_OPERAND (arg1, 0))),
7440                              TREE_OPERAND (arg1, 1)));
7441
7442       /* Convert C1/(X*C2) into (C1/C2)/X.  */
7443       if (flag_unsafe_math_optimizations
7444           && TREE_CODE (arg1) == MULT_EXPR
7445           && TREE_CODE (arg0) == REAL_CST
7446           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
7447         {
7448           tree tem = const_binop (RDIV_EXPR, arg0,
7449                                   TREE_OPERAND (arg1, 1), 0);
7450           if (tem)
7451             return fold (build2 (RDIV_EXPR, type, tem,
7452                                  TREE_OPERAND (arg1, 0)));
7453         }
7454
7455       if (flag_unsafe_math_optimizations)
7456         {
7457           enum built_in_function fcode = builtin_mathfn_code (arg1);
7458           /* Optimize x/expN(y) into x*expN(-y).  */
7459           if (BUILTIN_EXPONENT_P (fcode))
7460             {
7461               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7462               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
7463               tree arglist = build_tree_list (NULL_TREE,
7464                                               fold_convert (type, arg));
7465               arg1 = build_function_call_expr (expfn, arglist);
7466               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7467             }
7468
7469           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
7470           if (fcode == BUILT_IN_POW
7471               || fcode == BUILT_IN_POWF
7472               || fcode == BUILT_IN_POWL)
7473             {
7474               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7475               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7476               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
7477               tree neg11 = fold_convert (type, negate_expr (arg11));
7478               tree arglist = tree_cons(NULL_TREE, arg10,
7479                                        build_tree_list (NULL_TREE, neg11));
7480               arg1 = build_function_call_expr (powfn, arglist);
7481               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7482             }
7483         }
7484
7485       if (flag_unsafe_math_optimizations)
7486         {
7487           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7488           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7489
7490           /* Optimize sin(x)/cos(x) as tan(x).  */
7491           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
7492                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
7493                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
7494               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7495                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7496             {
7497               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7498
7499               if (tanfn != NULL_TREE)
7500                 return build_function_call_expr (tanfn,
7501                                                  TREE_OPERAND (arg0, 1));
7502             }
7503
7504           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
7505           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
7506                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
7507                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
7508               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7509                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7510             {
7511               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7512
7513               if (tanfn != NULL_TREE)
7514                 {
7515                   tree tmp = TREE_OPERAND (arg0, 1);
7516                   tmp = build_function_call_expr (tanfn, tmp);
7517                   return fold (build2 (RDIV_EXPR, type,
7518                                        build_real (type, dconst1), tmp));
7519                 }
7520             }
7521
7522           /* Optimize pow(x,c)/x as pow(x,c-1).  */
7523           if (fcode0 == BUILT_IN_POW
7524               || fcode0 == BUILT_IN_POWF
7525               || fcode0 == BUILT_IN_POWL)
7526             {
7527               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7528               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7529               if (TREE_CODE (arg01) == REAL_CST
7530                   && ! TREE_CONSTANT_OVERFLOW (arg01)
7531                   && operand_equal_p (arg1, arg00, 0))
7532                 {
7533                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7534                   REAL_VALUE_TYPE c;
7535                   tree arg, arglist;
7536
7537                   c = TREE_REAL_CST (arg01);
7538                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
7539                   arg = build_real (type, c);
7540                   arglist = build_tree_list (NULL_TREE, arg);
7541                   arglist = tree_cons (NULL_TREE, arg1, arglist);
7542                   return build_function_call_expr (powfn, arglist);
7543                 }
7544             }
7545         }
7546       goto binary;
7547
7548     case TRUNC_DIV_EXPR:
7549     case ROUND_DIV_EXPR:
7550     case FLOOR_DIV_EXPR:
7551     case CEIL_DIV_EXPR:
7552     case EXACT_DIV_EXPR:
7553       if (integer_onep (arg1))
7554         return non_lvalue (fold_convert (type, arg0));
7555       if (integer_zerop (arg1))
7556         return t;
7557       /* X / -1 is -X.  */
7558       if (!TYPE_UNSIGNED (type)
7559           && TREE_CODE (arg1) == INTEGER_CST
7560           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7561           && TREE_INT_CST_HIGH (arg1) == -1)
7562         return fold_convert (type, negate_expr (arg0));
7563
7564       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
7565          operation, EXACT_DIV_EXPR.
7566
7567          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
7568          At one time others generated faster code, it's not clear if they do
7569          after the last round to changes to the DIV code in expmed.c.  */
7570       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
7571           && multiple_of_p (type, arg0, arg1))
7572         return fold (build2 (EXACT_DIV_EXPR, type, arg0, arg1));
7573
7574       if (TREE_CODE (arg1) == INTEGER_CST
7575           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7576                                          code, NULL_TREE)))
7577         return fold_convert (type, tem);
7578
7579       goto binary;
7580
7581     case CEIL_MOD_EXPR:
7582     case FLOOR_MOD_EXPR:
7583     case ROUND_MOD_EXPR:
7584     case TRUNC_MOD_EXPR:
7585       if (integer_onep (arg1))
7586         return omit_one_operand (type, integer_zero_node, arg0);
7587       if (integer_zerop (arg1))
7588         return t;
7589
7590       /* X % -1 is zero.  */
7591       if (!TYPE_UNSIGNED (type)
7592           && TREE_CODE (arg1) == INTEGER_CST
7593           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7594           && TREE_INT_CST_HIGH (arg1) == -1)
7595         return omit_one_operand (type, integer_zero_node, arg0);
7596
7597       /* Optimize unsigned TRUNC_MOD_EXPR by a power of two into a
7598          BIT_AND_EXPR, i.e. "X % C" into "X & C2".  */
7599       if (code == TRUNC_MOD_EXPR
7600           && TYPE_UNSIGNED (type)
7601           && integer_pow2p (arg1))
7602         {
7603           unsigned HOST_WIDE_INT high, low;
7604           tree mask;
7605           int l;
7606
7607           l = tree_log2 (arg1);
7608           if (l >= HOST_BITS_PER_WIDE_INT)
7609             {
7610               high = ((unsigned HOST_WIDE_INT) 1
7611                       << (l - HOST_BITS_PER_WIDE_INT)) - 1;
7612               low = -1;
7613             }
7614           else
7615             {
7616               high = 0;
7617               low = ((unsigned HOST_WIDE_INT) 1 << l) - 1;
7618             }
7619
7620           mask = build_int_cst_wide (type, low, high);
7621           return fold (build2 (BIT_AND_EXPR, type,
7622                                fold_convert (type, arg0), mask));
7623         }
7624
7625       /* X % -C is the same as X % C.  */
7626       if (code == TRUNC_MOD_EXPR
7627           && !TYPE_UNSIGNED (type)
7628           && TREE_CODE (arg1) == INTEGER_CST
7629           && TREE_INT_CST_HIGH (arg1) < 0
7630           && !flag_trapv
7631           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
7632           && !sign_bit_p (arg1, arg1))
7633         return fold (build2 (code, type, fold_convert (type, arg0),
7634                              fold_convert (type, negate_expr (arg1))));
7635
7636       /* X % -Y is the same as X % Y.  */
7637       if (code == TRUNC_MOD_EXPR
7638           && !TYPE_UNSIGNED (type)
7639           && TREE_CODE (arg1) == NEGATE_EXPR
7640           && !flag_trapv)
7641         return fold (build2 (code, type, fold_convert (type, arg0),
7642                              fold_convert (type, TREE_OPERAND (arg1, 0))));
7643
7644       if (TREE_CODE (arg1) == INTEGER_CST
7645           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7646                                          code, NULL_TREE)))
7647         return fold_convert (type, tem);
7648
7649       goto binary;
7650
7651     case LROTATE_EXPR:
7652     case RROTATE_EXPR:
7653       if (integer_all_onesp (arg0))
7654         return omit_one_operand (type, arg0, arg1);
7655       goto shift;
7656
7657     case RSHIFT_EXPR:
7658       /* Optimize -1 >> x for arithmetic right shifts.  */
7659       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
7660         return omit_one_operand (type, arg0, arg1);
7661       /* ... fall through ...  */
7662
7663     case LSHIFT_EXPR:
7664     shift:
7665       if (integer_zerop (arg1))
7666         return non_lvalue (fold_convert (type, arg0));
7667       if (integer_zerop (arg0))
7668         return omit_one_operand (type, arg0, arg1);
7669
7670       /* Since negative shift count is not well-defined,
7671          don't try to compute it in the compiler.  */
7672       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
7673         return t;
7674       /* Rewrite an LROTATE_EXPR by a constant into an
7675          RROTATE_EXPR by a new constant.  */
7676       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
7677         {
7678           tree tem = build_int_cst (NULL_TREE,
7679                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
7680           tem = fold_convert (TREE_TYPE (arg1), tem);
7681           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
7682           return fold (build2 (RROTATE_EXPR, type, arg0, tem));
7683         }
7684
7685       /* If we have a rotate of a bit operation with the rotate count and
7686          the second operand of the bit operation both constant,
7687          permute the two operations.  */
7688       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7689           && (TREE_CODE (arg0) == BIT_AND_EXPR
7690               || TREE_CODE (arg0) == BIT_IOR_EXPR
7691               || TREE_CODE (arg0) == BIT_XOR_EXPR)
7692           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7693         return fold (build2 (TREE_CODE (arg0), type,
7694                              fold (build2 (code, type,
7695                                            TREE_OPERAND (arg0, 0), arg1)),
7696                              fold (build2 (code, type,
7697                                            TREE_OPERAND (arg0, 1), arg1))));
7698
7699       /* Two consecutive rotates adding up to the width of the mode can
7700          be ignored.  */
7701       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7702           && TREE_CODE (arg0) == RROTATE_EXPR
7703           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7704           && TREE_INT_CST_HIGH (arg1) == 0
7705           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
7706           && ((TREE_INT_CST_LOW (arg1)
7707                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
7708               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
7709         return TREE_OPERAND (arg0, 0);
7710
7711       goto binary;
7712
7713     case MIN_EXPR:
7714       if (operand_equal_p (arg0, arg1, 0))
7715         return omit_one_operand (type, arg0, arg1);
7716       if (INTEGRAL_TYPE_P (type)
7717           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
7718         return omit_one_operand (type, arg1, arg0);
7719       goto associate;
7720
7721     case MAX_EXPR:
7722       if (operand_equal_p (arg0, arg1, 0))
7723         return omit_one_operand (type, arg0, arg1);
7724       if (INTEGRAL_TYPE_P (type)
7725           && TYPE_MAX_VALUE (type)
7726           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
7727         return omit_one_operand (type, arg1, arg0);
7728       goto associate;
7729
7730     case TRUTH_NOT_EXPR:
7731       /* The argument to invert_truthvalue must have Boolean type.  */
7732       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7733           arg0 = fold_convert (boolean_type_node, arg0);
7734
7735       /* Note that the operand of this must be an int
7736          and its values must be 0 or 1.
7737          ("true" is a fixed value perhaps depending on the language,
7738          but we don't handle values other than 1 correctly yet.)  */
7739       tem = invert_truthvalue (arg0);
7740       /* Avoid infinite recursion.  */
7741       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
7742         {
7743           tem = fold_single_bit_test (code, arg0, arg1, type);
7744           if (tem)
7745             return tem;
7746           return t;
7747         }
7748       return fold_convert (type, tem);
7749
7750     case TRUTH_ANDIF_EXPR:
7751       /* Note that the operands of this must be ints
7752          and their values must be 0 or 1.
7753          ("true" is a fixed value perhaps depending on the language.)  */
7754       /* If first arg is constant zero, return it.  */
7755       if (integer_zerop (arg0))
7756         return fold_convert (type, arg0);
7757     case TRUTH_AND_EXPR:
7758       /* If either arg is constant true, drop it.  */
7759       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7760         return non_lvalue (fold_convert (type, arg1));
7761       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
7762           /* Preserve sequence points.  */
7763           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7764         return non_lvalue (fold_convert (type, arg0));
7765       /* If second arg is constant zero, result is zero, but first arg
7766          must be evaluated.  */
7767       if (integer_zerop (arg1))
7768         return omit_one_operand (type, arg1, arg0);
7769       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
7770          case will be handled here.  */
7771       if (integer_zerop (arg0))
7772         return omit_one_operand (type, arg0, arg1);
7773
7774       /* !X && X is always false.  */
7775       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7776           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7777         return omit_one_operand (type, integer_zero_node, arg1);
7778       /* X && !X is always false.  */
7779       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7780           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7781         return omit_one_operand (type, integer_zero_node, arg0);
7782
7783     truth_andor:
7784       /* We only do these simplifications if we are optimizing.  */
7785       if (!optimize)
7786         return t;
7787
7788       /* Check for things like (A || B) && (A || C).  We can convert this
7789          to A || (B && C).  Note that either operator can be any of the four
7790          truth and/or operations and the transformation will still be
7791          valid.   Also note that we only care about order for the
7792          ANDIF and ORIF operators.  If B contains side effects, this
7793          might change the truth-value of A.  */
7794       if (TREE_CODE (arg0) == TREE_CODE (arg1)
7795           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7796               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7797               || TREE_CODE (arg0) == TRUTH_AND_EXPR
7798               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7799           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7800         {
7801           tree a00 = TREE_OPERAND (arg0, 0);
7802           tree a01 = TREE_OPERAND (arg0, 1);
7803           tree a10 = TREE_OPERAND (arg1, 0);
7804           tree a11 = TREE_OPERAND (arg1, 1);
7805           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7806                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7807                              && (code == TRUTH_AND_EXPR
7808                                  || code == TRUTH_OR_EXPR));
7809
7810           if (operand_equal_p (a00, a10, 0))
7811             return fold (build2 (TREE_CODE (arg0), type, a00,
7812                                  fold (build2 (code, type, a01, a11))));
7813           else if (commutative && operand_equal_p (a00, a11, 0))
7814             return fold (build2 (TREE_CODE (arg0), type, a00,
7815                                  fold (build2 (code, type, a01, a10))));
7816           else if (commutative && operand_equal_p (a01, a10, 0))
7817             return fold (build2 (TREE_CODE (arg0), type, a01,
7818                                  fold (build2 (code, type, a00, a11))));
7819
7820           /* This case if tricky because we must either have commutative
7821              operators or else A10 must not have side-effects.  */
7822
7823           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7824                    && operand_equal_p (a01, a11, 0))
7825             return fold (build2 (TREE_CODE (arg0), type,
7826                                  fold (build2 (code, type, a00, a10)),
7827                                  a01));
7828         }
7829
7830       /* See if we can build a range comparison.  */
7831       if (0 != (tem = fold_range_test (t)))
7832         return tem;
7833
7834       /* Check for the possibility of merging component references.  If our
7835          lhs is another similar operation, try to merge its rhs with our
7836          rhs.  Then try to merge our lhs and rhs.  */
7837       if (TREE_CODE (arg0) == code
7838           && 0 != (tem = fold_truthop (code, type,
7839                                        TREE_OPERAND (arg0, 1), arg1)))
7840         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7841
7842       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
7843         return tem;
7844
7845       return t;
7846
7847     case TRUTH_ORIF_EXPR:
7848       /* Note that the operands of this must be ints
7849          and their values must be 0 or true.
7850          ("true" is a fixed value perhaps depending on the language.)  */
7851       /* If first arg is constant true, return it.  */
7852       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7853         return fold_convert (type, arg0);
7854     case TRUTH_OR_EXPR:
7855       /* If either arg is constant zero, drop it.  */
7856       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
7857         return non_lvalue (fold_convert (type, arg1));
7858       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
7859           /* Preserve sequence points.  */
7860           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7861         return non_lvalue (fold_convert (type, arg0));
7862       /* If second arg is constant true, result is true, but we must
7863          evaluate first arg.  */
7864       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
7865         return omit_one_operand (type, arg1, arg0);
7866       /* Likewise for first arg, but note this only occurs here for
7867          TRUTH_OR_EXPR.  */
7868       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7869         return omit_one_operand (type, arg0, arg1);
7870
7871       /* !X || X is always true.  */
7872       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7873           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7874         return omit_one_operand (type, integer_one_node, arg1);
7875       /* X || !X is always true.  */
7876       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7877           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7878         return omit_one_operand (type, integer_one_node, arg0);
7879
7880       goto truth_andor;
7881
7882     case TRUTH_XOR_EXPR:
7883       /* If the second arg is constant zero, drop it.  */
7884       if (integer_zerop (arg1))
7885         return non_lvalue (fold_convert (type, arg0));
7886       /* If the second arg is constant true, this is a logical inversion.  */
7887       if (integer_onep (arg1))
7888         return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
7889       /* Identical arguments cancel to zero.  */
7890       if (operand_equal_p (arg0, arg1, 0))
7891         return omit_one_operand (type, integer_zero_node, arg0);
7892
7893       /* !X ^ X is always true.  */
7894       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7895           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7896         return omit_one_operand (type, integer_one_node, arg1);
7897
7898       /* X ^ !X is always true.  */
7899       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7900           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7901         return omit_one_operand (type, integer_one_node, arg0);
7902
7903       return t;
7904
7905     case EQ_EXPR:
7906     case NE_EXPR:
7907     case LT_EXPR:
7908     case GT_EXPR:
7909     case LE_EXPR:
7910     case GE_EXPR:
7911       /* If one arg is a real or integer constant, put it last.  */
7912       if (tree_swap_operands_p (arg0, arg1, true))
7913         return fold (build2 (swap_tree_comparison (code), type, arg1, arg0));
7914
7915       /* If this is an equality comparison of the address of a non-weak
7916          object against zero, then we know the result.  */
7917       if ((code == EQ_EXPR || code == NE_EXPR)
7918           && TREE_CODE (arg0) == ADDR_EXPR
7919           && DECL_P (TREE_OPERAND (arg0, 0))
7920           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7921           && integer_zerop (arg1))
7922         return constant_boolean_node (code != EQ_EXPR, type);
7923
7924       /* If this is an equality comparison of the address of two non-weak,
7925          unaliased symbols neither of which are extern (since we do not
7926          have access to attributes for externs), then we know the result.  */
7927       if ((code == EQ_EXPR || code == NE_EXPR)
7928           && TREE_CODE (arg0) == ADDR_EXPR
7929           && DECL_P (TREE_OPERAND (arg0, 0))
7930           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7931           && ! lookup_attribute ("alias",
7932                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
7933           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
7934           && TREE_CODE (arg1) == ADDR_EXPR
7935           && DECL_P (TREE_OPERAND (arg1, 0))
7936           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
7937           && ! lookup_attribute ("alias",
7938                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
7939           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
7940         return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
7941                                       ? code == EQ_EXPR : code != EQ_EXPR,
7942                                       type);
7943
7944       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
7945         {
7946           tree targ0 = strip_float_extensions (arg0);
7947           tree targ1 = strip_float_extensions (arg1);
7948           tree newtype = TREE_TYPE (targ0);
7949
7950           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
7951             newtype = TREE_TYPE (targ1);
7952
7953           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
7954           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
7955             return fold (build2 (code, type, fold_convert (newtype, targ0),
7956                                  fold_convert (newtype, targ1)));
7957
7958           /* (-a) CMP (-b) -> b CMP a  */
7959           if (TREE_CODE (arg0) == NEGATE_EXPR
7960               && TREE_CODE (arg1) == NEGATE_EXPR)
7961             return fold (build2 (code, type, TREE_OPERAND (arg1, 0),
7962                                  TREE_OPERAND (arg0, 0)));
7963
7964           if (TREE_CODE (arg1) == REAL_CST)
7965           {
7966             REAL_VALUE_TYPE cst;
7967             cst = TREE_REAL_CST (arg1);
7968
7969             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
7970             if (TREE_CODE (arg0) == NEGATE_EXPR)
7971               return
7972                 fold (build2 (swap_tree_comparison (code), type,
7973                               TREE_OPERAND (arg0, 0),
7974                               build_real (TREE_TYPE (arg1),
7975                                           REAL_VALUE_NEGATE (cst))));
7976
7977             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
7978             /* a CMP (-0) -> a CMP 0  */
7979             if (REAL_VALUE_MINUS_ZERO (cst))
7980               return fold (build2 (code, type, arg0,
7981                                    build_real (TREE_TYPE (arg1), dconst0)));
7982
7983             /* x != NaN is always true, other ops are always false.  */
7984             if (REAL_VALUE_ISNAN (cst)
7985                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
7986               {
7987                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
7988                 return omit_one_operand (type, tem, arg0);
7989               }
7990
7991             /* Fold comparisons against infinity.  */
7992             if (REAL_VALUE_ISINF (cst))
7993               {
7994                 tem = fold_inf_compare (code, type, arg0, arg1);
7995                 if (tem != NULL_TREE)
7996                   return tem;
7997               }
7998           }
7999
8000           /* If this is a comparison of a real constant with a PLUS_EXPR
8001              or a MINUS_EXPR of a real constant, we can convert it into a
8002              comparison with a revised real constant as long as no overflow
8003              occurs when unsafe_math_optimizations are enabled.  */
8004           if (flag_unsafe_math_optimizations
8005               && TREE_CODE (arg1) == REAL_CST
8006               && (TREE_CODE (arg0) == PLUS_EXPR
8007                   || TREE_CODE (arg0) == MINUS_EXPR)
8008               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8009               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8010                                           ? MINUS_EXPR : PLUS_EXPR,
8011                                           arg1, TREE_OPERAND (arg0, 1), 0))
8012               && ! TREE_CONSTANT_OVERFLOW (tem))
8013             return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8014
8015           /* Likewise, we can simplify a comparison of a real constant with
8016              a MINUS_EXPR whose first operand is also a real constant, i.e.
8017              (c1 - x) < c2 becomes x > c1-c2.  */
8018           if (flag_unsafe_math_optimizations
8019               && TREE_CODE (arg1) == REAL_CST
8020               && TREE_CODE (arg0) == MINUS_EXPR
8021               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8022               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8023                                           arg1, 0))
8024               && ! TREE_CONSTANT_OVERFLOW (tem))
8025             return fold (build2 (swap_tree_comparison (code), type,
8026                                  TREE_OPERAND (arg0, 1), tem));
8027
8028           /* Fold comparisons against built-in math functions.  */
8029           if (TREE_CODE (arg1) == REAL_CST
8030               && flag_unsafe_math_optimizations
8031               && ! flag_errno_math)
8032             {
8033               enum built_in_function fcode = builtin_mathfn_code (arg0);
8034
8035               if (fcode != END_BUILTINS)
8036                 {
8037                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8038                   if (tem != NULL_TREE)
8039                     return tem;
8040                 }
8041             }
8042         }
8043
8044       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
8045       if (TREE_CONSTANT (arg1)
8046           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
8047               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
8048           /* This optimization is invalid for ordered comparisons
8049              if CONST+INCR overflows or if foo+incr might overflow.
8050              This optimization is invalid for floating point due to rounding.
8051              For pointer types we assume overflow doesn't happen.  */
8052           && (POINTER_TYPE_P (TREE_TYPE (arg0))
8053               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8054                   && (code == EQ_EXPR || code == NE_EXPR))))
8055         {
8056           tree varop, newconst;
8057
8058           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
8059             {
8060               newconst = fold (build2 (PLUS_EXPR, TREE_TYPE (arg0),
8061                                        arg1, TREE_OPERAND (arg0, 1)));
8062               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
8063                               TREE_OPERAND (arg0, 0),
8064                               TREE_OPERAND (arg0, 1));
8065             }
8066           else
8067             {
8068               newconst = fold (build2 (MINUS_EXPR, TREE_TYPE (arg0),
8069                                        arg1, TREE_OPERAND (arg0, 1)));
8070               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
8071                               TREE_OPERAND (arg0, 0),
8072                               TREE_OPERAND (arg0, 1));
8073             }
8074
8075
8076           /* If VAROP is a reference to a bitfield, we must mask
8077              the constant by the width of the field.  */
8078           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
8079               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
8080               && host_integerp (DECL_SIZE (TREE_OPERAND
8081                                            (TREE_OPERAND (varop, 0), 1)), 1))
8082             {
8083               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
8084               HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
8085               tree folded_compare, shift;
8086
8087               /* First check whether the comparison would come out
8088                  always the same.  If we don't do that we would
8089                  change the meaning with the masking.  */
8090               folded_compare = fold (build2 (code, type,
8091                                              TREE_OPERAND (varop, 0), arg1));
8092               if (integer_zerop (folded_compare)
8093                   || integer_onep (folded_compare))
8094                 return omit_one_operand (type, folded_compare, varop);
8095
8096               shift = build_int_cst (NULL_TREE,
8097                                      TYPE_PRECISION (TREE_TYPE (varop)) - size);
8098               shift = fold_convert (TREE_TYPE (varop), shift);
8099               newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8100                                        newconst, shift));
8101               newconst = fold (build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8102                                        newconst, shift));
8103             }
8104
8105           return fold (build2 (code, type, varop, newconst));
8106         }
8107
8108       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
8109          This transformation affects the cases which are handled in later
8110          optimizations involving comparisons with non-negative constants.  */
8111       if (TREE_CODE (arg1) == INTEGER_CST
8112           && TREE_CODE (arg0) != INTEGER_CST
8113           && tree_int_cst_sgn (arg1) > 0)
8114         {
8115           switch (code)
8116             {
8117             case GE_EXPR:
8118               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8119               return fold (build2 (GT_EXPR, type, arg0, arg1));
8120
8121             case LT_EXPR:
8122               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8123               return fold (build2 (LE_EXPR, type, arg0, arg1));
8124
8125             default:
8126               break;
8127             }
8128         }
8129
8130       /* Comparisons with the highest or lowest possible integer of
8131          the specified size will have known values.
8132
8133          This is quite similar to fold_relational_hi_lo; however, my
8134          attempts to share the code have been nothing but trouble.
8135          I give up for now.  */
8136       {
8137         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
8138
8139         if (TREE_CODE (arg1) == INTEGER_CST
8140             && ! TREE_CONSTANT_OVERFLOW (arg1)
8141             && width <= HOST_BITS_PER_WIDE_INT
8142             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
8143                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
8144           {
8145             unsigned HOST_WIDE_INT signed_max;
8146             unsigned HOST_WIDE_INT max, min;
8147
8148             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
8149
8150             if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
8151               {
8152                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
8153                 min = 0;
8154               }
8155             else
8156               {
8157                 max = signed_max;
8158                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
8159               }
8160
8161             if (TREE_INT_CST_HIGH (arg1) == 0
8162                 && TREE_INT_CST_LOW (arg1) == max)
8163               switch (code)
8164                 {
8165                 case GT_EXPR:
8166                   return omit_one_operand (type, integer_zero_node, arg0);
8167
8168                 case GE_EXPR:
8169                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8170
8171                 case LE_EXPR:
8172                   return omit_one_operand (type, integer_one_node, arg0);
8173
8174                 case LT_EXPR:
8175                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8176
8177                 /* The GE_EXPR and LT_EXPR cases above are not normally
8178                    reached because of previous transformations.  */
8179
8180                 default:
8181                   break;
8182                 }
8183             else if (TREE_INT_CST_HIGH (arg1) == 0
8184                      && TREE_INT_CST_LOW (arg1) == max - 1)
8185               switch (code)
8186                 {
8187                 case GT_EXPR:
8188                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8189                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8190                 case LE_EXPR:
8191                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8192                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8193                 default:
8194                   break;
8195                 }
8196             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8197                      && TREE_INT_CST_LOW (arg1) == min)
8198               switch (code)
8199                 {
8200                 case LT_EXPR:
8201                   return omit_one_operand (type, integer_zero_node, arg0);
8202
8203                 case LE_EXPR:
8204                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8205
8206                 case GE_EXPR:
8207                   return omit_one_operand (type, integer_one_node, arg0);
8208
8209                 case GT_EXPR:
8210                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8211
8212                 default:
8213                   break;
8214                 }
8215             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8216                      && TREE_INT_CST_LOW (arg1) == min + 1)
8217               switch (code)
8218                 {
8219                 case GE_EXPR:
8220                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8221                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8222                 case LT_EXPR:
8223                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8224                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8225                 default:
8226                   break;
8227                 }
8228
8229             else if (!in_gimple_form
8230                      && TREE_INT_CST_HIGH (arg1) == 0
8231                      && TREE_INT_CST_LOW (arg1) == signed_max
8232                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
8233                      /* signed_type does not work on pointer types.  */
8234                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
8235               {
8236                 /* The following case also applies to X < signed_max+1
8237                    and X >= signed_max+1 because previous transformations.  */
8238                 if (code == LE_EXPR || code == GT_EXPR)
8239                   {
8240                     tree st0, st1;
8241                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
8242                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
8243                     return fold
8244                       (build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
8245                                type, fold_convert (st0, arg0),
8246                                fold_convert (st1, integer_zero_node)));
8247                   }
8248               }
8249           }
8250       }
8251
8252       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
8253          a MINUS_EXPR of a constant, we can convert it into a comparison with
8254          a revised constant as long as no overflow occurs.  */
8255       if ((code == EQ_EXPR || code == NE_EXPR)
8256           && TREE_CODE (arg1) == INTEGER_CST
8257           && (TREE_CODE (arg0) == PLUS_EXPR
8258               || TREE_CODE (arg0) == MINUS_EXPR)
8259           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8260           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8261                                       ? MINUS_EXPR : PLUS_EXPR,
8262                                       arg1, TREE_OPERAND (arg0, 1), 0))
8263           && ! TREE_CONSTANT_OVERFLOW (tem))
8264         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8265
8266       /* Similarly for a NEGATE_EXPR.  */
8267       else if ((code == EQ_EXPR || code == NE_EXPR)
8268                && TREE_CODE (arg0) == NEGATE_EXPR
8269                && TREE_CODE (arg1) == INTEGER_CST
8270                && 0 != (tem = negate_expr (arg1))
8271                && TREE_CODE (tem) == INTEGER_CST
8272                && ! TREE_CONSTANT_OVERFLOW (tem))
8273         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8274
8275       /* If we have X - Y == 0, we can convert that to X == Y and similarly
8276          for !=.  Don't do this for ordered comparisons due to overflow.  */
8277       else if ((code == NE_EXPR || code == EQ_EXPR)
8278                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
8279         return fold (build2 (code, type,
8280                              TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
8281
8282       /* If we are widening one operand of an integer comparison,
8283          see if the other operand is similarly being widened.  Perhaps we
8284          can do the comparison in the narrower type.  */
8285       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8286                && TREE_CODE (arg0) == NOP_EXPR
8287                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
8288                && (code == EQ_EXPR || code == NE_EXPR
8289                    || TYPE_UNSIGNED (TREE_TYPE (arg0))
8290                       == TYPE_UNSIGNED (TREE_TYPE (tem)))
8291                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
8292                && (TREE_TYPE (t1) == TREE_TYPE (tem)
8293                    || (TREE_CODE (t1) == INTEGER_CST
8294                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
8295         return fold (build2 (code, type, tem,
8296                              fold_convert (TREE_TYPE (tem), t1)));
8297
8298       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8299          constant, we can simplify it.  */
8300       else if (TREE_CODE (arg1) == INTEGER_CST
8301                && (TREE_CODE (arg0) == MIN_EXPR
8302                    || TREE_CODE (arg0) == MAX_EXPR)
8303                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8304         return optimize_minmax_comparison (t);
8305
8306       /* If we are comparing an ABS_EXPR with a constant, we can
8307          convert all the cases into explicit comparisons, but they may
8308          well not be faster than doing the ABS and one comparison.
8309          But ABS (X) <= C is a range comparison, which becomes a subtraction
8310          and a comparison, and is probably faster.  */
8311       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8312                && TREE_CODE (arg0) == ABS_EXPR
8313                && ! TREE_SIDE_EFFECTS (arg0)
8314                && (0 != (tem = negate_expr (arg1)))
8315                && TREE_CODE (tem) == INTEGER_CST
8316                && ! TREE_CONSTANT_OVERFLOW (tem))
8317         return fold (build2 (TRUTH_ANDIF_EXPR, type,
8318                              build2 (GE_EXPR, type,
8319                                      TREE_OPERAND (arg0, 0), tem),
8320                              build2 (LE_EXPR, type,
8321                                      TREE_OPERAND (arg0, 0), arg1)));
8322
8323       /* If this is an EQ or NE comparison with zero and ARG0 is
8324          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
8325          two operations, but the latter can be done in one less insn
8326          on machines that have only two-operand insns or on which a
8327          constant cannot be the first operand.  */
8328       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
8329           && TREE_CODE (arg0) == BIT_AND_EXPR)
8330         {
8331           tree arg00 = TREE_OPERAND (arg0, 0);
8332           tree arg01 = TREE_OPERAND (arg0, 1);
8333           if (TREE_CODE (arg00) == LSHIFT_EXPR
8334               && integer_onep (TREE_OPERAND (arg00, 0)))
8335             return
8336               fold (build2 (code, type,
8337                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8338                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
8339                                             arg01, TREE_OPERAND (arg00, 1)),
8340                                     fold_convert (TREE_TYPE (arg0),
8341                                                   integer_one_node)),
8342                             arg1));
8343           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
8344                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
8345             return
8346               fold (build2 (code, type,
8347                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8348                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
8349                                             arg00, TREE_OPERAND (arg01, 1)),
8350                                     fold_convert (TREE_TYPE (arg0),
8351                                                   integer_one_node)),
8352                             arg1));
8353         }
8354
8355       /* If this is an NE or EQ comparison of zero against the result of a
8356          signed MOD operation whose second operand is a power of 2, make
8357          the MOD operation unsigned since it is simpler and equivalent.  */
8358       if ((code == NE_EXPR || code == EQ_EXPR)
8359           && integer_zerop (arg1)
8360           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
8361           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
8362               || TREE_CODE (arg0) == CEIL_MOD_EXPR
8363               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
8364               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
8365           && integer_pow2p (TREE_OPERAND (arg0, 1)))
8366         {
8367           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
8368           tree newmod = fold (build2 (TREE_CODE (arg0), newtype,
8369                                       fold_convert (newtype,
8370                                                     TREE_OPERAND (arg0, 0)),
8371                                       fold_convert (newtype,
8372                                                     TREE_OPERAND (arg0, 1))));
8373
8374           return fold (build2 (code, type, newmod,
8375                                fold_convert (newtype, arg1)));
8376         }
8377
8378       /* If this is an NE comparison of zero with an AND of one, remove the
8379          comparison since the AND will give the correct value.  */
8380       if (code == NE_EXPR && integer_zerop (arg1)
8381           && TREE_CODE (arg0) == BIT_AND_EXPR
8382           && integer_onep (TREE_OPERAND (arg0, 1)))
8383         return fold_convert (type, arg0);
8384
8385       /* If we have (A & C) == C where C is a power of 2, convert this into
8386          (A & C) != 0.  Similarly for NE_EXPR.  */
8387       if ((code == EQ_EXPR || code == NE_EXPR)
8388           && TREE_CODE (arg0) == BIT_AND_EXPR
8389           && integer_pow2p (TREE_OPERAND (arg0, 1))
8390           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8391         return fold (build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
8392                              arg0, fold_convert (TREE_TYPE (arg0),
8393                                                  integer_zero_node)));
8394
8395       /* If we have (A & C) != 0 or (A & C) == 0 and C is a power of
8396          2, then fold the expression into shifts and logical operations.  */
8397       tem = fold_single_bit_test (code, arg0, arg1, type);
8398       if (tem)
8399         return tem;
8400
8401       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
8402          Similarly for NE_EXPR.  */
8403       if ((code == EQ_EXPR || code == NE_EXPR)
8404           && TREE_CODE (arg0) == BIT_AND_EXPR
8405           && TREE_CODE (arg1) == INTEGER_CST
8406           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8407         {
8408           tree dandnotc
8409             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8410                             arg1, build1 (BIT_NOT_EXPR,
8411                                           TREE_TYPE (TREE_OPERAND (arg0, 1)),
8412                                           TREE_OPERAND (arg0, 1))));
8413           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8414           if (integer_nonzerop (dandnotc))
8415             return omit_one_operand (type, rslt, arg0);
8416         }
8417
8418       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
8419          Similarly for NE_EXPR.  */
8420       if ((code == EQ_EXPR || code == NE_EXPR)
8421           && TREE_CODE (arg0) == BIT_IOR_EXPR
8422           && TREE_CODE (arg1) == INTEGER_CST
8423           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8424         {
8425           tree candnotd
8426             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8427                             TREE_OPERAND (arg0, 1),
8428                             build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1)));
8429           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8430           if (integer_nonzerop (candnotd))
8431             return omit_one_operand (type, rslt, arg0);
8432         }
8433
8434       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
8435          and similarly for >= into !=.  */
8436       if ((code == LT_EXPR || code == GE_EXPR)
8437           && TYPE_UNSIGNED (TREE_TYPE (arg0))
8438           && TREE_CODE (arg1) == LSHIFT_EXPR
8439           && integer_onep (TREE_OPERAND (arg1, 0)))
8440         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8441                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8442                                TREE_OPERAND (arg1, 1)),
8443                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
8444
8445       else if ((code == LT_EXPR || code == GE_EXPR)
8446                && TYPE_UNSIGNED (TREE_TYPE (arg0))
8447                && (TREE_CODE (arg1) == NOP_EXPR
8448                    || TREE_CODE (arg1) == CONVERT_EXPR)
8449                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
8450                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
8451         return
8452           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8453                   fold_convert (TREE_TYPE (arg0),
8454                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8455                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
8456                                                       1))),
8457                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
8458
8459       /* Simplify comparison of something with itself.  (For IEEE
8460          floating-point, we can only do some of these simplifications.)  */
8461       if (operand_equal_p (arg0, arg1, 0))
8462         {
8463           switch (code)
8464             {
8465             case EQ_EXPR:
8466               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8467                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8468                 return constant_boolean_node (1, type);
8469               break;
8470
8471             case GE_EXPR:
8472             case LE_EXPR:
8473               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8474                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8475                 return constant_boolean_node (1, type);
8476               return fold (build2 (EQ_EXPR, type, arg0, arg1));
8477
8478             case NE_EXPR:
8479               /* For NE, we can only do this simplification if integer
8480                  or we don't honor IEEE floating point NaNs.  */
8481               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8482                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8483                 break;
8484               /* ... fall through ...  */
8485             case GT_EXPR:
8486             case LT_EXPR:
8487               return constant_boolean_node (0, type);
8488             default:
8489               gcc_unreachable ();
8490             }
8491         }
8492
8493       /* If we are comparing an expression that just has comparisons
8494          of two integer values, arithmetic expressions of those comparisons,
8495          and constants, we can simplify it.  There are only three cases
8496          to check: the two values can either be equal, the first can be
8497          greater, or the second can be greater.  Fold the expression for
8498          those three values.  Since each value must be 0 or 1, we have
8499          eight possibilities, each of which corresponds to the constant 0
8500          or 1 or one of the six possible comparisons.
8501
8502          This handles common cases like (a > b) == 0 but also handles
8503          expressions like  ((x > y) - (y > x)) > 0, which supposedly
8504          occur in macroized code.  */
8505
8506       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8507         {
8508           tree cval1 = 0, cval2 = 0;
8509           int save_p = 0;
8510
8511           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8512               /* Don't handle degenerate cases here; they should already
8513                  have been handled anyway.  */
8514               && cval1 != 0 && cval2 != 0
8515               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8516               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8517               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8518               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8519               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8520               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8521                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8522             {
8523               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8524               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8525
8526               /* We can't just pass T to eval_subst in case cval1 or cval2
8527                  was the same as ARG1.  */
8528
8529               tree high_result
8530                 = fold (build2 (code, type,
8531                                 eval_subst (arg0, cval1, maxval,
8532                                             cval2, minval),
8533                                 arg1));
8534               tree equal_result
8535                 = fold (build2 (code, type,
8536                                 eval_subst (arg0, cval1, maxval,
8537                                             cval2, maxval),
8538                                 arg1));
8539               tree low_result
8540                 = fold (build2 (code, type,
8541                                 eval_subst (arg0, cval1, minval,
8542                                             cval2, maxval),
8543                                 arg1));
8544
8545               /* All three of these results should be 0 or 1.  Confirm they
8546                  are.  Then use those values to select the proper code
8547                  to use.  */
8548
8549               if ((integer_zerop (high_result)
8550                    || integer_onep (high_result))
8551                   && (integer_zerop (equal_result)
8552                       || integer_onep (equal_result))
8553                   && (integer_zerop (low_result)
8554                       || integer_onep (low_result)))
8555                 {
8556                   /* Make a 3-bit mask with the high-order bit being the
8557                      value for `>', the next for '=', and the low for '<'.  */
8558                   switch ((integer_onep (high_result) * 4)
8559                           + (integer_onep (equal_result) * 2)
8560                           + integer_onep (low_result))
8561                     {
8562                     case 0:
8563                       /* Always false.  */
8564                       return omit_one_operand (type, integer_zero_node, arg0);
8565                     case 1:
8566                       code = LT_EXPR;
8567                       break;
8568                     case 2:
8569                       code = EQ_EXPR;
8570                       break;
8571                     case 3:
8572                       code = LE_EXPR;
8573                       break;
8574                     case 4:
8575                       code = GT_EXPR;
8576                       break;
8577                     case 5:
8578                       code = NE_EXPR;
8579                       break;
8580                     case 6:
8581                       code = GE_EXPR;
8582                       break;
8583                     case 7:
8584                       /* Always true.  */
8585                       return omit_one_operand (type, integer_one_node, arg0);
8586                     }
8587
8588                   tem = build2 (code, type, cval1, cval2);
8589                   if (save_p)
8590                     return save_expr (tem);
8591                   else
8592                     return fold (tem);
8593                 }
8594             }
8595         }
8596
8597       /* If this is a comparison of a field, we may be able to simplify it.  */
8598       if (((TREE_CODE (arg0) == COMPONENT_REF
8599             && lang_hooks.can_use_bit_fields_p ())
8600            || TREE_CODE (arg0) == BIT_FIELD_REF)
8601           && (code == EQ_EXPR || code == NE_EXPR)
8602           /* Handle the constant case even without -O
8603              to make sure the warnings are given.  */
8604           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
8605         {
8606           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
8607           if (t1)
8608             return t1;
8609         }
8610
8611       /* If this is a comparison of complex values and either or both sides
8612          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
8613          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
8614          This may prevent needless evaluations.  */
8615       if ((code == EQ_EXPR || code == NE_EXPR)
8616           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
8617           && (TREE_CODE (arg0) == COMPLEX_EXPR
8618               || TREE_CODE (arg1) == COMPLEX_EXPR
8619               || TREE_CODE (arg0) == COMPLEX_CST
8620               || TREE_CODE (arg1) == COMPLEX_CST))
8621         {
8622           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
8623           tree real0, imag0, real1, imag1;
8624
8625           arg0 = save_expr (arg0);
8626           arg1 = save_expr (arg1);
8627           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
8628           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
8629           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
8630           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
8631
8632           return fold (build2 ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
8633                                 : TRUTH_ORIF_EXPR),
8634                                type,
8635                                fold (build2 (code, type, real0, real1)),
8636                                fold (build2 (code, type, imag0, imag1))));
8637         }
8638
8639       /* Optimize comparisons of strlen vs zero to a compare of the
8640          first character of the string vs zero.  To wit,
8641                 strlen(ptr) == 0   =>  *ptr == 0
8642                 strlen(ptr) != 0   =>  *ptr != 0
8643          Other cases should reduce to one of these two (or a constant)
8644          due to the return value of strlen being unsigned.  */
8645       if ((code == EQ_EXPR || code == NE_EXPR)
8646           && integer_zerop (arg1)
8647           && TREE_CODE (arg0) == CALL_EXPR)
8648         {
8649           tree fndecl = get_callee_fndecl (arg0);
8650           tree arglist;
8651
8652           if (fndecl
8653               && DECL_BUILT_IN (fndecl)
8654               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
8655               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
8656               && (arglist = TREE_OPERAND (arg0, 1))
8657               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
8658               && ! TREE_CHAIN (arglist))
8659             return fold (build2 (code, type,
8660                                  build1 (INDIRECT_REF, char_type_node,
8661                                          TREE_VALUE (arglist)),
8662                                  fold_convert (char_type_node,
8663                                                integer_zero_node)));
8664         }
8665
8666       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8667          into a single range test.  */
8668       if (TREE_CODE (arg0) == TRUNC_DIV_EXPR
8669           && TREE_CODE (arg1) == INTEGER_CST
8670           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8671           && !integer_zerop (TREE_OPERAND (arg0, 1))
8672           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8673           && !TREE_OVERFLOW (arg1))
8674         {
8675           t1 = fold_div_compare (code, type, arg0, arg1);
8676           if (t1 != NULL_TREE)
8677             return t1;
8678         }
8679
8680       if ((code == EQ_EXPR || code == NE_EXPR)
8681           && !TREE_SIDE_EFFECTS (arg0)
8682           && integer_zerop (arg1)
8683           && tree_expr_nonzero_p (arg0))
8684         return constant_boolean_node (code==NE_EXPR, type);
8685
8686       t1 = fold_relational_const (code, type, arg0, arg1);
8687       return t1 == NULL_TREE ? t : t1;
8688
8689     case UNORDERED_EXPR:
8690     case ORDERED_EXPR:
8691     case UNLT_EXPR:
8692     case UNLE_EXPR:
8693     case UNGT_EXPR:
8694     case UNGE_EXPR:
8695     case UNEQ_EXPR:
8696     case LTGT_EXPR:
8697       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8698         {
8699           t1 = fold_relational_const (code, type, arg0, arg1);
8700           if (t1 != NULL_TREE)
8701             return t1;
8702         }
8703
8704       /* If the first operand is NaN, the result is constant.  */
8705       if (TREE_CODE (arg0) == REAL_CST
8706           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
8707           && (code != LTGT_EXPR || ! flag_trapping_math))
8708         {
8709           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8710                ? integer_zero_node
8711                : integer_one_node;
8712           return omit_one_operand (type, t1, arg1);
8713         }
8714
8715       /* If the second operand is NaN, the result is constant.  */
8716       if (TREE_CODE (arg1) == REAL_CST
8717           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
8718           && (code != LTGT_EXPR || ! flag_trapping_math))
8719         {
8720           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8721                ? integer_zero_node
8722                : integer_one_node;
8723           return omit_one_operand (type, t1, arg0);
8724         }
8725
8726       /* Simplify unordered comparison of something with itself.  */
8727       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
8728           && operand_equal_p (arg0, arg1, 0))
8729         return constant_boolean_node (1, type);
8730
8731       if (code == LTGT_EXPR
8732           && !flag_trapping_math
8733           && operand_equal_p (arg0, arg1, 0))
8734         return constant_boolean_node (0, type);
8735
8736       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8737       {
8738         tree targ0 = strip_float_extensions (arg0);
8739         tree targ1 = strip_float_extensions (arg1);
8740         tree newtype = TREE_TYPE (targ0);
8741
8742         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8743           newtype = TREE_TYPE (targ1);
8744
8745         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8746           return fold (build2 (code, type, fold_convert (newtype, targ0),
8747                                fold_convert (newtype, targ1)));
8748       }
8749
8750       return t;
8751
8752     case COND_EXPR:
8753       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
8754          so all simple results must be passed through pedantic_non_lvalue.  */
8755       if (TREE_CODE (arg0) == INTEGER_CST)
8756         {
8757           tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
8758           /* Only optimize constant conditions when the selected branch
8759              has the same type as the COND_EXPR.  This avoids optimizing
8760              away "c ? x : throw", where the throw has a void type.  */
8761           if (! VOID_TYPE_P (TREE_TYPE (tem))
8762               || VOID_TYPE_P (type))
8763             return pedantic_non_lvalue (tem);
8764           return t;
8765         }
8766       if (operand_equal_p (arg1, TREE_OPERAND (t, 2), 0))
8767         return pedantic_omit_one_operand (type, arg1, arg0);
8768
8769       /* If we have A op B ? A : C, we may be able to convert this to a
8770          simpler expression, depending on the operation and the values
8771          of B and C.  Signed zeros prevent all of these transformations,
8772          for reasons given above each one.
8773
8774          Also try swapping the arguments and inverting the conditional.  */
8775       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8776           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8777                                              arg1, TREE_OPERAND (arg0, 1))
8778           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
8779         {
8780           tem = fold_cond_expr_with_comparison (type, arg0,
8781                                                 TREE_OPERAND (t, 1),
8782                                                 TREE_OPERAND (t, 2));
8783           if (tem)
8784             return tem;
8785         }
8786
8787       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8788           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8789                                              TREE_OPERAND (t, 2),
8790                                              TREE_OPERAND (arg0, 1))
8791           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
8792         {
8793           tem = invert_truthvalue (arg0);
8794           if (TREE_CODE_CLASS (TREE_CODE (tem)) == '<')
8795             {
8796               tem = fold_cond_expr_with_comparison (type, tem,
8797                                                     TREE_OPERAND (t, 2),
8798                                                     TREE_OPERAND (t, 1));
8799               if (tem)
8800                 return tem;
8801             }
8802         }
8803
8804       /* If the second operand is simpler than the third, swap them
8805          since that produces better jump optimization results.  */
8806       if (tree_swap_operands_p (TREE_OPERAND (t, 1),
8807                                 TREE_OPERAND (t, 2), false))
8808         {
8809           /* See if this can be inverted.  If it can't, possibly because
8810              it was a floating-point inequality comparison, don't do
8811              anything.  */
8812           tem = invert_truthvalue (arg0);
8813
8814           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8815             return fold (build3 (code, type, tem,
8816                                  TREE_OPERAND (t, 2), TREE_OPERAND (t, 1)));
8817         }
8818
8819       /* Convert A ? 1 : 0 to simply A.  */
8820       if (integer_onep (TREE_OPERAND (t, 1))
8821           && integer_zerop (TREE_OPERAND (t, 2))
8822           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
8823              call to fold will try to move the conversion inside
8824              a COND, which will recurse.  In that case, the COND_EXPR
8825              is probably the best choice, so leave it alone.  */
8826           && type == TREE_TYPE (arg0))
8827         return pedantic_non_lvalue (arg0);
8828
8829       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
8830          over COND_EXPR in cases such as floating point comparisons.  */
8831       if (integer_zerop (TREE_OPERAND (t, 1))
8832           && integer_onep (TREE_OPERAND (t, 2))
8833           && truth_value_p (TREE_CODE (arg0)))
8834         return pedantic_non_lvalue (fold_convert (type,
8835                                                   invert_truthvalue (arg0)));
8836
8837       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
8838       if (TREE_CODE (arg0) == LT_EXPR
8839           && integer_zerop (TREE_OPERAND (arg0, 1))
8840           && integer_zerop (TREE_OPERAND (t, 2))
8841           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
8842         return fold_convert (type, fold (build2 (BIT_AND_EXPR,
8843                                                  TREE_TYPE (tem), tem, arg1)));
8844
8845       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
8846          already handled above.  */
8847       if (TREE_CODE (arg0) == BIT_AND_EXPR
8848           && integer_onep (TREE_OPERAND (arg0, 1))
8849           && integer_zerop (TREE_OPERAND (t, 2))
8850           && integer_pow2p (arg1))
8851         {
8852           tree tem = TREE_OPERAND (arg0, 0);
8853           STRIP_NOPS (tem);
8854           if (TREE_CODE (tem) == RSHIFT_EXPR
8855               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
8856               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
8857                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
8858             return fold (build2 (BIT_AND_EXPR, type,
8859                                  TREE_OPERAND (tem, 0), arg1));
8860         }
8861
8862       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
8863          is probably obsolete because the first operand should be a
8864          truth value (that's why we have the two cases above), but let's
8865          leave it in until we can confirm this for all front-ends.  */
8866       if (integer_zerop (TREE_OPERAND (t, 2))
8867           && TREE_CODE (arg0) == NE_EXPR
8868           && integer_zerop (TREE_OPERAND (arg0, 1))
8869           && integer_pow2p (arg1)
8870           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
8871           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
8872                               arg1, OEP_ONLY_CONST))
8873         return pedantic_non_lvalue (fold_convert (type,
8874                                                   TREE_OPERAND (arg0, 0)));
8875
8876       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
8877       if (integer_zerop (TREE_OPERAND (t, 2))
8878           && truth_value_p (TREE_CODE (arg0))
8879           && truth_value_p (TREE_CODE (arg1)))
8880         return fold (build2 (TRUTH_ANDIF_EXPR, type, arg0, arg1));
8881
8882       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
8883       if (integer_onep (TREE_OPERAND (t, 2))
8884           && truth_value_p (TREE_CODE (arg0))
8885           && truth_value_p (TREE_CODE (arg1)))
8886         {
8887           /* Only perform transformation if ARG0 is easily inverted.  */
8888           tem = invert_truthvalue (arg0);
8889           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8890             return fold (build2 (TRUTH_ORIF_EXPR, type, tem, arg1));
8891         }
8892
8893       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
8894       if (integer_zerop (arg1)
8895           && truth_value_p (TREE_CODE (arg0))
8896           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8897         {
8898           /* Only perform transformation if ARG0 is easily inverted.  */
8899           tem = invert_truthvalue (arg0);
8900           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8901             return fold (build2 (TRUTH_ANDIF_EXPR, type, tem,
8902                                  TREE_OPERAND (t, 2)));
8903         }
8904
8905       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
8906       if (integer_onep (arg1)
8907           && truth_value_p (TREE_CODE (arg0))
8908           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8909         return fold (build2 (TRUTH_ORIF_EXPR, type, arg0,
8910                              TREE_OPERAND (t, 2)));
8911
8912       return t;
8913
8914     case COMPOUND_EXPR:
8915       /* When pedantic, a compound expression can be neither an lvalue
8916          nor an integer constant expression.  */
8917       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
8918         return t;
8919       /* Don't let (0, 0) be null pointer constant.  */
8920       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
8921                                  : fold_convert (type, arg1);
8922       return pedantic_non_lvalue (tem);
8923
8924     case COMPLEX_EXPR:
8925       if (wins)
8926         return build_complex (type, arg0, arg1);
8927       return t;
8928
8929     case REALPART_EXPR:
8930       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8931         return t;
8932       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8933         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8934                                  TREE_OPERAND (arg0, 1));
8935       else if (TREE_CODE (arg0) == COMPLEX_CST)
8936         return TREE_REALPART (arg0);
8937       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8938         return fold (build2 (TREE_CODE (arg0), type,
8939                              fold (build1 (REALPART_EXPR, type,
8940                                            TREE_OPERAND (arg0, 0))),
8941                              fold (build1 (REALPART_EXPR, type,
8942                                            TREE_OPERAND (arg0, 1)))));
8943       return t;
8944
8945     case IMAGPART_EXPR:
8946       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8947         return fold_convert (type, integer_zero_node);
8948       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8949         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8950                                  TREE_OPERAND (arg0, 0));
8951       else if (TREE_CODE (arg0) == COMPLEX_CST)
8952         return TREE_IMAGPART (arg0);
8953       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8954         return fold (build2 (TREE_CODE (arg0), type,
8955                              fold (build1 (IMAGPART_EXPR, type,
8956                                            TREE_OPERAND (arg0, 0))),
8957                              fold (build1 (IMAGPART_EXPR, type,
8958                                            TREE_OPERAND (arg0, 1)))));
8959       return t;
8960
8961     case CALL_EXPR:
8962       /* Check for a built-in function.  */
8963       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
8964           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
8965               == FUNCTION_DECL)
8966           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
8967         {
8968           tree tmp = fold_builtin (t, false);
8969           if (tmp)
8970             return tmp;
8971         }
8972       return t;
8973
8974     default:
8975       return t;
8976     } /* switch (code) */
8977 }
8978
8979 #ifdef ENABLE_FOLD_CHECKING
8980 #undef fold
8981
8982 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
8983 static void fold_check_failed (tree, tree);
8984 void print_fold_checksum (tree);
8985
8986 /* When --enable-checking=fold, compute a digest of expr before
8987    and after actual fold call to see if fold did not accidentally
8988    change original expr.  */
8989
8990 tree
8991 fold (tree expr)
8992 {
8993   tree ret;
8994   struct md5_ctx ctx;
8995   unsigned char checksum_before[16], checksum_after[16];
8996   htab_t ht;
8997
8998   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
8999   md5_init_ctx (&ctx);
9000   fold_checksum_tree (expr, &ctx, ht);
9001   md5_finish_ctx (&ctx, checksum_before);
9002   htab_empty (ht);
9003
9004   ret = fold_1 (expr);
9005
9006   md5_init_ctx (&ctx);
9007   fold_checksum_tree (expr, &ctx, ht);
9008   md5_finish_ctx (&ctx, checksum_after);
9009   htab_delete (ht);
9010
9011   if (memcmp (checksum_before, checksum_after, 16))
9012     fold_check_failed (expr, ret);
9013
9014   return ret;
9015 }
9016
9017 void
9018 print_fold_checksum (tree expr)
9019 {
9020   struct md5_ctx ctx;
9021   unsigned char checksum[16], cnt;
9022   htab_t ht;
9023
9024   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
9025   md5_init_ctx (&ctx);
9026   fold_checksum_tree (expr, &ctx, ht);
9027   md5_finish_ctx (&ctx, checksum);
9028   htab_delete (ht);
9029   for (cnt = 0; cnt < 16; ++cnt)
9030     fprintf (stderr, "%02x", checksum[cnt]);
9031   putc ('\n', stderr);
9032 }
9033
9034 static void
9035 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
9036 {
9037   internal_error ("fold check: original tree changed by fold");
9038 }
9039
9040 static void
9041 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
9042 {
9043   void **slot;
9044   enum tree_code code;
9045   char buf[sizeof (struct tree_decl)];
9046   int i, len;
9047
9048   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
9049                <= sizeof (struct tree_decl))
9050               && sizeof (struct tree_type) <= sizeof (struct tree_decl));
9051   if (expr == NULL)
9052     return;
9053   slot = htab_find_slot (ht, expr, INSERT);
9054   if (*slot != NULL)
9055     return;
9056   *slot = expr;
9057   code = TREE_CODE (expr);
9058   if (TREE_CODE_CLASS (code) == 'd' && DECL_ASSEMBLER_NAME_SET_P (expr))
9059     {
9060       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
9061       memcpy (buf, expr, tree_size (expr));
9062       expr = (tree) buf;
9063       SET_DECL_ASSEMBLER_NAME (expr, NULL);
9064     }
9065   else if (TREE_CODE_CLASS (code) == 't'
9066            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
9067                || TYPE_CACHED_VALUES_P (expr)))
9068     {
9069       /* Allow these fields to be modified.  */
9070       memcpy (buf, expr, tree_size (expr));
9071       expr = (tree) buf;
9072       TYPE_POINTER_TO (expr) = NULL;
9073       TYPE_REFERENCE_TO (expr) = NULL;
9074       TYPE_CACHED_VALUES_P (expr) = 0;
9075       TYPE_CACHED_VALUES (expr) = NULL;
9076     }
9077   md5_process_bytes (expr, tree_size (expr), ctx);
9078   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
9079   if (TREE_CODE_CLASS (code) != 't' && TREE_CODE_CLASS (code) != 'd')
9080     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
9081   switch (TREE_CODE_CLASS (code))
9082     {
9083     case 'c':
9084       switch (code)
9085         {
9086         case STRING_CST:
9087           md5_process_bytes (TREE_STRING_POINTER (expr),
9088                              TREE_STRING_LENGTH (expr), ctx);
9089           break;
9090         case COMPLEX_CST:
9091           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
9092           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
9093           break;
9094         case VECTOR_CST:
9095           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
9096           break;
9097         default:
9098           break;
9099         }
9100       break;
9101     case 'x':
9102       switch (code)
9103         {
9104         case TREE_LIST:
9105           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
9106           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
9107           break;
9108         case TREE_VEC:
9109           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
9110             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
9111           break;
9112         default:
9113           break;
9114         }
9115       break;
9116     case 'e':
9117     case 'r':
9118     case '<':
9119     case '1':
9120     case '2':
9121     case 's':
9122       len = first_rtl_op (code);
9123       for (i = 0; i < len; ++i)
9124         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
9125       break;
9126     case 'd':
9127       fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
9128       fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
9129       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
9130       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
9131       fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
9132       fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
9133       fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
9134       fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
9135       fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
9136       fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
9137       fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
9138       break;
9139     case 't':
9140       if (TREE_CODE (expr) == ENUMERAL_TYPE)
9141         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
9142       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
9143       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
9144       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
9145       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
9146       if (INTEGRAL_TYPE_P (expr)
9147           || SCALAR_FLOAT_TYPE_P (expr))
9148         {
9149           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
9150           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
9151         }
9152       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
9153       if (TREE_CODE (expr) == RECORD_TYPE
9154           || TREE_CODE (expr) == UNION_TYPE
9155           || TREE_CODE (expr) == QUAL_UNION_TYPE)
9156         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
9157       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
9158       break;
9159     default:
9160       break;
9161     }
9162 }
9163
9164 #endif
9165
9166 /* Perform constant folding and related simplification of initializer
9167    expression EXPR.  This behaves identically to "fold" but ignores
9168    potential run-time traps and exceptions that fold must preserve.  */
9169
9170 tree
9171 fold_initializer (tree expr)
9172 {
9173   int saved_signaling_nans = flag_signaling_nans;
9174   int saved_trapping_math = flag_trapping_math;
9175   int saved_trapv = flag_trapv;
9176   tree result;
9177
9178   flag_signaling_nans = 0;
9179   flag_trapping_math = 0;
9180   flag_trapv = 0;
9181
9182   result = fold (expr);
9183
9184   flag_signaling_nans = saved_signaling_nans;
9185   flag_trapping_math = saved_trapping_math;
9186   flag_trapv = saved_trapv;
9187
9188   return result;
9189 }
9190
9191 /* Determine if first argument is a multiple of second argument.  Return 0 if
9192    it is not, or we cannot easily determined it to be.
9193
9194    An example of the sort of thing we care about (at this point; this routine
9195    could surely be made more general, and expanded to do what the *_DIV_EXPR's
9196    fold cases do now) is discovering that
9197
9198      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9199
9200    is a multiple of
9201
9202      SAVE_EXPR (J * 8)
9203
9204    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
9205
9206    This code also handles discovering that
9207
9208      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9209
9210    is a multiple of 8 so we don't have to worry about dealing with a
9211    possible remainder.
9212
9213    Note that we *look* inside a SAVE_EXPR only to determine how it was
9214    calculated; it is not safe for fold to do much of anything else with the
9215    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
9216    at run time.  For example, the latter example above *cannot* be implemented
9217    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
9218    evaluation time of the original SAVE_EXPR is not necessarily the same at
9219    the time the new expression is evaluated.  The only optimization of this
9220    sort that would be valid is changing
9221
9222      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
9223
9224    divided by 8 to
9225
9226      SAVE_EXPR (I) * SAVE_EXPR (J)
9227
9228    (where the same SAVE_EXPR (J) is used in the original and the
9229    transformed version).  */
9230
9231 static int
9232 multiple_of_p (tree type, tree top, tree bottom)
9233 {
9234   if (operand_equal_p (top, bottom, 0))
9235     return 1;
9236
9237   if (TREE_CODE (type) != INTEGER_TYPE)
9238     return 0;
9239
9240   switch (TREE_CODE (top))
9241     {
9242     case MULT_EXPR:
9243       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9244               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9245
9246     case PLUS_EXPR:
9247     case MINUS_EXPR:
9248       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9249               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9250
9251     case LSHIFT_EXPR:
9252       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
9253         {
9254           tree op1, t1;
9255
9256           op1 = TREE_OPERAND (top, 1);
9257           /* const_binop may not detect overflow correctly,
9258              so check for it explicitly here.  */
9259           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
9260               > TREE_INT_CST_LOW (op1)
9261               && TREE_INT_CST_HIGH (op1) == 0
9262               && 0 != (t1 = fold_convert (type,
9263                                           const_binop (LSHIFT_EXPR,
9264                                                        size_one_node,
9265                                                        op1, 0)))
9266               && ! TREE_OVERFLOW (t1))
9267             return multiple_of_p (type, t1, bottom);
9268         }
9269       return 0;
9270
9271     case NOP_EXPR:
9272       /* Can't handle conversions from non-integral or wider integral type.  */
9273       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
9274           || (TYPE_PRECISION (type)
9275               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
9276         return 0;
9277
9278       /* .. fall through ...  */
9279
9280     case SAVE_EXPR:
9281       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
9282
9283     case INTEGER_CST:
9284       if (TREE_CODE (bottom) != INTEGER_CST
9285           || (TYPE_UNSIGNED (type)
9286               && (tree_int_cst_sgn (top) < 0
9287                   || tree_int_cst_sgn (bottom) < 0)))
9288         return 0;
9289       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
9290                                          top, bottom, 0));
9291
9292     default:
9293       return 0;
9294     }
9295 }
9296
9297 /* Return true if `t' is known to be non-negative.  */
9298
9299 int
9300 tree_expr_nonnegative_p (tree t)
9301 {
9302   switch (TREE_CODE (t))
9303     {
9304     case ABS_EXPR:
9305       return 1;
9306
9307     case INTEGER_CST:
9308       return tree_int_cst_sgn (t) >= 0;
9309
9310     case REAL_CST:
9311       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
9312
9313     case PLUS_EXPR:
9314       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9315         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9316                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9317
9318       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
9319          both unsigned and at least 2 bits shorter than the result.  */
9320       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9321           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9322           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9323         {
9324           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9325           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9326           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9327               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9328             {
9329               unsigned int prec = MAX (TYPE_PRECISION (inner1),
9330                                        TYPE_PRECISION (inner2)) + 1;
9331               return prec < TYPE_PRECISION (TREE_TYPE (t));
9332             }
9333         }
9334       break;
9335
9336     case MULT_EXPR:
9337       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9338         {
9339           /* x * x for floating point x is always non-negative.  */
9340           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
9341             return 1;
9342           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9343                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9344         }
9345
9346       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
9347          both unsigned and their total bits is shorter than the result.  */
9348       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9349           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9350           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9351         {
9352           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9353           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9354           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9355               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9356             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
9357                    < TYPE_PRECISION (TREE_TYPE (t));
9358         }
9359       return 0;
9360
9361     case TRUNC_DIV_EXPR:
9362     case CEIL_DIV_EXPR:
9363     case FLOOR_DIV_EXPR:
9364     case ROUND_DIV_EXPR:
9365       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9366              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9367
9368     case TRUNC_MOD_EXPR:
9369     case CEIL_MOD_EXPR:
9370     case FLOOR_MOD_EXPR:
9371     case ROUND_MOD_EXPR:
9372       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9373
9374     case RDIV_EXPR:
9375       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9376              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9377
9378     case BIT_AND_EXPR:
9379       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9380              || tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9381     case BIT_IOR_EXPR:
9382     case BIT_XOR_EXPR:
9383       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9384              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9385
9386     case NOP_EXPR:
9387       {
9388         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9389         tree outer_type = TREE_TYPE (t);
9390
9391         if (TREE_CODE (outer_type) == REAL_TYPE)
9392           {
9393             if (TREE_CODE (inner_type) == REAL_TYPE)
9394               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9395             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9396               {
9397                 if (TYPE_UNSIGNED (inner_type))
9398                   return 1;
9399                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9400               }
9401           }
9402         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
9403           {
9404             if (TREE_CODE (inner_type) == REAL_TYPE)
9405               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
9406             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9407               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
9408                       && TYPE_UNSIGNED (inner_type);
9409           }
9410       }
9411       break;
9412
9413     case COND_EXPR:
9414       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9415         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
9416     case COMPOUND_EXPR:
9417       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9418     case MIN_EXPR:
9419       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9420         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9421     case MAX_EXPR:
9422       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9423         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9424     case MODIFY_EXPR:
9425       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9426     case BIND_EXPR:
9427       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
9428     case SAVE_EXPR:
9429       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9430     case NON_LVALUE_EXPR:
9431       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9432     case FLOAT_EXPR:
9433       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9434
9435     case TARGET_EXPR:
9436       {
9437         tree temp = TARGET_EXPR_SLOT (t);
9438         t = TARGET_EXPR_INITIAL (t);
9439
9440         /* If the initializer is non-void, then it's a normal expression
9441            that will be assigned to the slot.  */
9442         if (!VOID_TYPE_P (t))
9443           return tree_expr_nonnegative_p (t);
9444
9445         /* Otherwise, the initializer sets the slot in some way.  One common
9446            way is an assignment statement at the end of the initializer.  */
9447         while (1)
9448           {
9449             if (TREE_CODE (t) == BIND_EXPR)
9450               t = expr_last (BIND_EXPR_BODY (t));
9451             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
9452                      || TREE_CODE (t) == TRY_CATCH_EXPR)
9453               t = expr_last (TREE_OPERAND (t, 0));
9454             else if (TREE_CODE (t) == STATEMENT_LIST)
9455               t = expr_last (t);
9456             else
9457               break;
9458           }
9459         if (TREE_CODE (t) == MODIFY_EXPR
9460             && TREE_OPERAND (t, 0) == temp)
9461           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9462
9463         return 0;
9464       }
9465
9466     case CALL_EXPR:
9467       {
9468         tree fndecl = get_callee_fndecl (t);
9469         tree arglist = TREE_OPERAND (t, 1);
9470         if (fndecl
9471             && DECL_BUILT_IN (fndecl)
9472             && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
9473           switch (DECL_FUNCTION_CODE (fndecl))
9474             {
9475 #define CASE_BUILTIN_F(BUILT_IN_FN) \
9476   case BUILT_IN_FN: case BUILT_IN_FN##F: case BUILT_IN_FN##L:
9477 #define CASE_BUILTIN_I(BUILT_IN_FN) \
9478   case BUILT_IN_FN: case BUILT_IN_FN##L: case BUILT_IN_FN##LL:
9479
9480             CASE_BUILTIN_F (BUILT_IN_ACOS)
9481             CASE_BUILTIN_F (BUILT_IN_ACOSH)
9482             CASE_BUILTIN_F (BUILT_IN_CABS)
9483             CASE_BUILTIN_F (BUILT_IN_COSH)
9484             CASE_BUILTIN_F (BUILT_IN_ERFC)
9485             CASE_BUILTIN_F (BUILT_IN_EXP)
9486             CASE_BUILTIN_F (BUILT_IN_EXP10)
9487             CASE_BUILTIN_F (BUILT_IN_EXP2)
9488             CASE_BUILTIN_F (BUILT_IN_FABS)
9489             CASE_BUILTIN_F (BUILT_IN_FDIM)
9490             CASE_BUILTIN_F (BUILT_IN_FREXP)
9491             CASE_BUILTIN_F (BUILT_IN_HYPOT)
9492             CASE_BUILTIN_F (BUILT_IN_POW10)
9493             CASE_BUILTIN_I (BUILT_IN_FFS)
9494             CASE_BUILTIN_I (BUILT_IN_PARITY)
9495             CASE_BUILTIN_I (BUILT_IN_POPCOUNT)
9496               /* Always true.  */
9497               return 1;
9498
9499             CASE_BUILTIN_F (BUILT_IN_SQRT)
9500               /* sqrt(-0.0) is -0.0.  */
9501               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
9502                 return 1;
9503               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9504
9505             CASE_BUILTIN_F (BUILT_IN_ASINH)
9506             CASE_BUILTIN_F (BUILT_IN_ATAN)
9507             CASE_BUILTIN_F (BUILT_IN_ATANH)
9508             CASE_BUILTIN_F (BUILT_IN_CBRT)
9509             CASE_BUILTIN_F (BUILT_IN_CEIL)
9510             CASE_BUILTIN_F (BUILT_IN_ERF)
9511             CASE_BUILTIN_F (BUILT_IN_EXPM1)
9512             CASE_BUILTIN_F (BUILT_IN_FLOOR)
9513             CASE_BUILTIN_F (BUILT_IN_FMOD)
9514             CASE_BUILTIN_F (BUILT_IN_LDEXP)
9515             CASE_BUILTIN_F (BUILT_IN_LLRINT)
9516             CASE_BUILTIN_F (BUILT_IN_LLROUND)
9517             CASE_BUILTIN_F (BUILT_IN_LRINT)
9518             CASE_BUILTIN_F (BUILT_IN_LROUND)
9519             CASE_BUILTIN_F (BUILT_IN_MODF)
9520             CASE_BUILTIN_F (BUILT_IN_NEARBYINT)
9521             CASE_BUILTIN_F (BUILT_IN_POW)
9522             CASE_BUILTIN_F (BUILT_IN_RINT)
9523             CASE_BUILTIN_F (BUILT_IN_ROUND)
9524             CASE_BUILTIN_F (BUILT_IN_SIGNBIT)
9525             CASE_BUILTIN_F (BUILT_IN_SINH)
9526             CASE_BUILTIN_F (BUILT_IN_TANH)
9527             CASE_BUILTIN_F (BUILT_IN_TRUNC)
9528               /* True if the 1st argument is nonnegative.  */
9529               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9530
9531             CASE_BUILTIN_F (BUILT_IN_FMAX)
9532               /* True if the 1st OR 2nd arguments are nonnegative.  */
9533               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9534                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9535
9536             CASE_BUILTIN_F (BUILT_IN_FMIN)
9537               /* True if the 1st AND 2nd arguments are nonnegative.  */
9538               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9539                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9540
9541             CASE_BUILTIN_F (BUILT_IN_COPYSIGN)
9542               /* True if the 2nd argument is nonnegative.  */
9543               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9544
9545             default:
9546               break;
9547 #undef CASE_BUILTIN_F
9548 #undef CASE_BUILTIN_I
9549             }
9550       }
9551
9552       /* ... fall through ...  */
9553
9554     default:
9555       if (truth_value_p (TREE_CODE (t)))
9556         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
9557         return 1;
9558     }
9559
9560   /* We don't know sign of `t', so be conservative and return false.  */
9561   return 0;
9562 }
9563
9564 /* Return true when T is an address and is known to be nonzero.
9565    For floating point we further ensure that T is not denormal.
9566    Similar logic is present in nonzero_address in rtlanal.h  */
9567
9568 static bool
9569 tree_expr_nonzero_p (tree t)
9570 {
9571   tree type = TREE_TYPE (t);
9572
9573   /* Doing something useful for floating point would need more work.  */
9574   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9575     return false;
9576
9577   switch (TREE_CODE (t))
9578     {
9579     case ABS_EXPR:
9580       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9581         return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9582
9583     case INTEGER_CST:
9584       /* We used to test for !integer_zerop here.  This does not work correctly
9585          if TREE_CONSTANT_OVERFLOW (t).  */
9586       return (TREE_INT_CST_LOW (t) != 0
9587               || TREE_INT_CST_HIGH (t) != 0);
9588
9589     case PLUS_EXPR:
9590       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9591         {
9592           /* With the presence of negative values it is hard
9593              to say something.  */
9594           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9595               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9596             return false;
9597           /* One of operands must be positive and the other non-negative.  */
9598           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9599                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9600         }
9601       break;
9602
9603     case MULT_EXPR:
9604       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9605         {
9606           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9607                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9608         }
9609       break;
9610
9611     case NOP_EXPR:
9612       {
9613         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9614         tree outer_type = TREE_TYPE (t);
9615
9616         return (TYPE_PRECISION (inner_type) >= TYPE_PRECISION (outer_type)
9617                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
9618       }
9619       break;
9620
9621    case ADDR_EXPR:
9622       {
9623         tree base = get_base_address (TREE_OPERAND (t, 0));
9624
9625         if (!base)
9626           return false;
9627
9628         /* Weak declarations may link to NULL.  */
9629         if (DECL_P (base))
9630           return !DECL_WEAK (base);
9631
9632         /* Constants are never weak.  */
9633         if (TREE_CODE_CLASS (TREE_CODE (base)) == 'c')
9634           return true;
9635
9636         return false;
9637       }
9638
9639     case COND_EXPR:
9640       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9641               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
9642
9643     case MIN_EXPR:
9644       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9645               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9646
9647     case MAX_EXPR:
9648       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
9649         {
9650           /* When both operands are nonzero, then MAX must be too.  */
9651           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
9652             return true;
9653
9654           /* MAX where operand 0 is positive is positive.  */
9655           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9656         }
9657       /* MAX where operand 1 is positive is positive.  */
9658       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9659                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9660         return true;
9661       break;
9662
9663     case COMPOUND_EXPR:
9664     case MODIFY_EXPR:
9665     case BIND_EXPR:
9666       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
9667
9668     case SAVE_EXPR:
9669     case NON_LVALUE_EXPR:
9670       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9671
9672     case BIT_IOR_EXPR:
9673       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9674              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9675
9676     default:
9677       break;
9678     }
9679   return false;
9680 }
9681
9682 /* See if we are applying CODE, a relational to the highest or lowest
9683    possible integer of TYPE.  If so, then the result is a compile
9684    time constant.  */
9685
9686 static tree
9687 fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
9688                        tree *op1_p)
9689 {
9690   tree op0 = *op0_p;
9691   tree op1 = *op1_p;
9692   enum tree_code code = *code_p;
9693   int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (op1)));
9694
9695   if (TREE_CODE (op1) == INTEGER_CST
9696       && ! TREE_CONSTANT_OVERFLOW (op1)
9697       && width <= HOST_BITS_PER_WIDE_INT
9698       && (INTEGRAL_TYPE_P (TREE_TYPE (op1))
9699           || POINTER_TYPE_P (TREE_TYPE (op1))))
9700     {
9701       unsigned HOST_WIDE_INT signed_max;
9702       unsigned HOST_WIDE_INT max, min;
9703
9704       signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
9705
9706       if (TYPE_UNSIGNED (TREE_TYPE (op1)))
9707         {
9708           max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9709           min = 0;
9710         }
9711       else
9712         {
9713           max = signed_max;
9714           min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9715         }
9716
9717       if (TREE_INT_CST_HIGH (op1) == 0
9718           && TREE_INT_CST_LOW (op1) == max)
9719         switch (code)
9720           {
9721           case GT_EXPR:
9722             return omit_one_operand (type, integer_zero_node, op0);
9723
9724           case GE_EXPR:
9725             *code_p = EQ_EXPR;
9726             break;
9727           case LE_EXPR:
9728             return omit_one_operand (type, integer_one_node, op0);
9729
9730           case LT_EXPR:
9731             *code_p = NE_EXPR;
9732             break;
9733
9734           /* The GE_EXPR and LT_EXPR cases above are not normally
9735              reached because of  previous transformations.  */
9736
9737           default:
9738             break;
9739           }
9740       else if (TREE_INT_CST_HIGH (op1) == 0
9741                && TREE_INT_CST_LOW (op1) == max - 1)
9742         switch (code)
9743           {
9744           case GT_EXPR:
9745             *code_p = EQ_EXPR;
9746             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9747             break;
9748           case LE_EXPR:
9749             *code_p = NE_EXPR;
9750             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9751             break;
9752           default:
9753             break;
9754           }
9755       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9756                && TREE_INT_CST_LOW (op1) == min)
9757        switch (code)
9758           {
9759           case LT_EXPR:
9760             return omit_one_operand (type, integer_zero_node, op0);
9761
9762           case LE_EXPR:
9763             *code_p = EQ_EXPR;
9764             break;
9765
9766           case GE_EXPR:
9767             return omit_one_operand (type, integer_one_node, op0);
9768
9769           case GT_EXPR:
9770             *code_p = NE_EXPR;
9771             break;
9772
9773           default:
9774             break;
9775           }
9776       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9777                && TREE_INT_CST_LOW (op1) == min + 1)
9778         switch (code)
9779           {
9780           case GE_EXPR:
9781             *code_p = NE_EXPR;
9782             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9783             break;
9784           case LT_EXPR:
9785             *code_p = EQ_EXPR;
9786             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9787             break;
9788           default:
9789             break;
9790           }
9791
9792       else if (TREE_INT_CST_HIGH (op1) == 0
9793                && TREE_INT_CST_LOW (op1) == signed_max
9794                && TYPE_UNSIGNED (TREE_TYPE (op1))
9795                /* signed_type does not work on pointer types.  */
9796                && INTEGRAL_TYPE_P (TREE_TYPE (op1)))
9797         {
9798           /* The following case also applies to X < signed_max+1
9799              and X >= signed_max+1 because previous transformations.  */
9800           if (code == LE_EXPR || code == GT_EXPR)
9801             {
9802               tree st0, st1, exp, retval;
9803               st0 = lang_hooks.types.signed_type (TREE_TYPE (op0));
9804               st1 = lang_hooks.types.signed_type (TREE_TYPE (op1));
9805
9806               exp = build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9807                             type,
9808                             fold_convert (st0, op0),
9809                             fold_convert (st1, integer_zero_node));
9810
9811               retval
9812                 = nondestructive_fold_binary_to_constant (TREE_CODE (exp),
9813                                                           TREE_TYPE (exp),
9814                                                           TREE_OPERAND (exp, 0),
9815                                                           TREE_OPERAND (exp, 1));
9816
9817               /* If we are in gimple form, then returning EXP would create
9818                  non-gimple expressions.  Clearing it is safe and insures
9819                  we do not allow a non-gimple expression to escape.  */
9820               if (in_gimple_form)
9821                 exp = NULL;
9822
9823               return (retval ? retval : exp);
9824             }
9825         }
9826     }
9827
9828   return NULL_TREE;
9829 }
9830
9831
9832 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
9833    attempt to fold the expression to a constant without modifying TYPE,
9834    OP0 or OP1.
9835
9836    If the expression could be simplified to a constant, then return
9837    the constant.  If the expression would not be simplified to a
9838    constant, then return NULL_TREE.
9839
9840    Note this is primarily designed to be called after gimplification
9841    of the tree structures and when at least one operand is a constant.
9842    As a result of those simplifying assumptions this routine is far
9843    simpler than the generic fold routine.  */
9844
9845 tree
9846 nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
9847                                         tree op0, tree op1)
9848 {
9849   int wins = 1;
9850   tree subop0;
9851   tree subop1;
9852   tree tem;
9853
9854   /* If this is a commutative operation, and ARG0 is a constant, move it
9855      to ARG1 to reduce the number of tests below.  */
9856   if (commutative_tree_code (code)
9857       && (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST))
9858     {
9859       tem = op0;
9860       op0 = op1;
9861       op1 = tem;
9862     }
9863
9864   /* If either operand is a complex type, extract its real component.  */
9865   if (TREE_CODE (op0) == COMPLEX_CST)
9866     subop0 = TREE_REALPART (op0);
9867   else
9868     subop0 = op0;
9869
9870   if (TREE_CODE (op1) == COMPLEX_CST)
9871     subop1 = TREE_REALPART (op1);
9872   else
9873     subop1 = op1;
9874
9875   /* Note if either argument is not a real or integer constant.
9876      With a few exceptions, simplification is limited to cases
9877      where both arguments are constants.  */
9878   if ((TREE_CODE (subop0) != INTEGER_CST
9879        && TREE_CODE (subop0) != REAL_CST)
9880       || (TREE_CODE (subop1) != INTEGER_CST
9881           && TREE_CODE (subop1) != REAL_CST))
9882     wins = 0;
9883
9884   switch (code)
9885     {
9886     case PLUS_EXPR:
9887       /* (plus (address) (const_int)) is a constant.  */
9888       if (TREE_CODE (op0) == PLUS_EXPR
9889           && TREE_CODE (op1) == INTEGER_CST
9890           && (TREE_CODE (TREE_OPERAND (op0, 0)) == ADDR_EXPR
9891               || (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
9892                   && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (op0, 0), 0))
9893                       == ADDR_EXPR)))
9894           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
9895         {
9896           return build2 (PLUS_EXPR, type, TREE_OPERAND (op0, 0),
9897                          const_binop (PLUS_EXPR, op1,
9898                                       TREE_OPERAND (op0, 1), 0));
9899         }
9900     case BIT_XOR_EXPR:
9901
9902     binary:
9903       if (!wins)
9904         return NULL_TREE;
9905
9906       /* Both arguments are constants.  Simplify.  */
9907       tem = const_binop (code, op0, op1, 0);
9908       if (tem != NULL_TREE)
9909         {
9910           /* The return value should always have the same type as
9911              the original expression.  */
9912           if (TREE_TYPE (tem) != type)
9913             tem = fold_convert (type, tem);
9914
9915           return tem;
9916         }
9917       return NULL_TREE;
9918
9919     case MINUS_EXPR:
9920       /* Fold &x - &x.  This can happen from &x.foo - &x.
9921          This is unsafe for certain floats even in non-IEEE formats.
9922          In IEEE, it is unsafe because it does wrong for NaNs.
9923          Also note that operand_equal_p is always false if an
9924          operand is volatile.  */
9925       if (! FLOAT_TYPE_P (type) && operand_equal_p (op0, op1, 0))
9926         return fold_convert (type, integer_zero_node);
9927
9928       goto binary;
9929
9930     case MULT_EXPR:
9931     case BIT_AND_EXPR:
9932       /* Special case multiplication or bitwise AND where one argument
9933          is zero.  */
9934       if (! FLOAT_TYPE_P (type) && integer_zerop (op1))
9935         return omit_one_operand (type, op1, op0);
9936       else
9937         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (op0)))
9938             && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op0)))
9939             && real_zerop (op1))
9940           return omit_one_operand (type, op1, op0);
9941
9942       goto binary;
9943
9944     case BIT_IOR_EXPR:
9945       /* Special case when we know the result will be all ones.  */
9946       if (integer_all_onesp (op1))
9947         return omit_one_operand (type, op1, op0);
9948
9949       goto binary;
9950
9951     case TRUNC_DIV_EXPR:
9952     case ROUND_DIV_EXPR:
9953     case FLOOR_DIV_EXPR:
9954     case CEIL_DIV_EXPR:
9955     case EXACT_DIV_EXPR:
9956     case TRUNC_MOD_EXPR:
9957     case ROUND_MOD_EXPR:
9958     case FLOOR_MOD_EXPR:
9959     case CEIL_MOD_EXPR:
9960     case RDIV_EXPR:
9961       /* Division by zero is undefined.  */
9962       if (integer_zerop (op1))
9963         return NULL_TREE;
9964
9965       if (TREE_CODE (op1) == REAL_CST
9966           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (op1)))
9967           && real_zerop (op1))
9968         return NULL_TREE;
9969
9970       goto binary;
9971
9972     case MIN_EXPR:
9973       if (INTEGRAL_TYPE_P (type)
9974           && operand_equal_p (op1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
9975         return omit_one_operand (type, op1, op0);
9976
9977       goto binary;
9978
9979     case MAX_EXPR:
9980       if (INTEGRAL_TYPE_P (type)
9981           && TYPE_MAX_VALUE (type)
9982           && operand_equal_p (op1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
9983         return omit_one_operand (type, op1, op0);
9984
9985       goto binary;
9986
9987     case RSHIFT_EXPR:
9988       /* Optimize -1 >> x for arithmetic right shifts.  */
9989       if (integer_all_onesp (op0) && ! TYPE_UNSIGNED (type))
9990         return omit_one_operand (type, op0, op1);
9991       /* ... fall through ...  */
9992
9993     case LSHIFT_EXPR:
9994       if (integer_zerop (op0))
9995         return omit_one_operand (type, op0, op1);
9996
9997       /* Since negative shift count is not well-defined, don't
9998          try to compute it in the compiler.  */
9999       if (TREE_CODE (op1) == INTEGER_CST && tree_int_cst_sgn (op1) < 0)
10000         return NULL_TREE;
10001
10002       goto binary;
10003
10004     case LROTATE_EXPR:
10005     case RROTATE_EXPR:
10006       /* -1 rotated either direction by any amount is still -1.  */
10007       if (integer_all_onesp (op0))
10008         return omit_one_operand (type, op0, op1);
10009
10010       /* 0 rotated either direction by any amount is still zero.  */
10011       if (integer_zerop (op0))
10012         return omit_one_operand (type, op0, op1);
10013
10014       goto binary;
10015
10016     case COMPLEX_EXPR:
10017       if (wins)
10018         return build_complex (type, op0, op1);
10019       return NULL_TREE;
10020
10021     case LT_EXPR:
10022     case LE_EXPR:
10023     case GT_EXPR:
10024     case GE_EXPR:
10025     case EQ_EXPR:
10026     case NE_EXPR:
10027       /* If one arg is a real or integer constant, put it last.  */
10028       if ((TREE_CODE (op0) == INTEGER_CST
10029            && TREE_CODE (op1) != INTEGER_CST)
10030           || (TREE_CODE (op0) == REAL_CST
10031               && TREE_CODE (op0) != REAL_CST))
10032         {
10033           tree temp;
10034
10035           temp = op0;
10036           op0 = op1;
10037           op1 = temp;
10038           code = swap_tree_comparison (code);
10039         }
10040
10041       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
10042          This transformation affects the cases which are handled in later
10043          optimizations involving comparisons with non-negative constants.  */
10044       if (TREE_CODE (op1) == INTEGER_CST
10045           && TREE_CODE (op0) != INTEGER_CST
10046           && tree_int_cst_sgn (op1) > 0)
10047         {
10048           switch (code)
10049             {
10050             case GE_EXPR:
10051               code = GT_EXPR;
10052               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10053               break;
10054
10055             case LT_EXPR:
10056               code = LE_EXPR;
10057               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10058               break;
10059
10060             default:
10061               break;
10062             }
10063         }
10064
10065       tem = fold_relational_hi_lo (&code, type, &op0, &op1);
10066       if (tem)
10067         return tem;
10068
10069       /* Fall through.  */
10070
10071     case ORDERED_EXPR:
10072     case UNORDERED_EXPR:
10073     case UNLT_EXPR:
10074     case UNLE_EXPR:
10075     case UNGT_EXPR:
10076     case UNGE_EXPR:
10077     case UNEQ_EXPR:
10078     case LTGT_EXPR:
10079       if (!wins)
10080         return NULL_TREE;
10081
10082       return fold_relational_const (code, type, op0, op1);
10083
10084     case RANGE_EXPR:
10085       /* This could probably be handled.  */
10086       return NULL_TREE;
10087
10088     case TRUTH_AND_EXPR:
10089       /* If second arg is constant zero, result is zero, but first arg
10090          must be evaluated.  */
10091       if (integer_zerop (op1))
10092         return omit_one_operand (type, op1, op0);
10093       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10094          case will be handled here.  */
10095       if (integer_zerop (op0))
10096         return omit_one_operand (type, op0, op1);
10097       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10098         return constant_boolean_node (true, type);
10099       return NULL_TREE;
10100
10101     case TRUTH_OR_EXPR:
10102       /* If second arg is constant true, result is true, but we must
10103          evaluate first arg.  */
10104       if (TREE_CODE (op1) == INTEGER_CST && ! integer_zerop (op1))
10105         return omit_one_operand (type, op1, op0);
10106       /* Likewise for first arg, but note this only occurs here for
10107          TRUTH_OR_EXPR.  */
10108       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
10109         return omit_one_operand (type, op0, op1);
10110       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10111         return constant_boolean_node (false, type);
10112       return NULL_TREE;
10113
10114     case TRUTH_XOR_EXPR:
10115       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10116         {
10117           int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
10118           return constant_boolean_node (x, type);
10119         }
10120       return NULL_TREE;
10121
10122     default:
10123       return NULL_TREE;
10124     }
10125 }
10126
10127 /* Given the components of a unary expression CODE, TYPE and OP0,
10128    attempt to fold the expression to a constant without modifying
10129    TYPE or OP0.
10130
10131    If the expression could be simplified to a constant, then return
10132    the constant.  If the expression would not be simplified to a
10133    constant, then return NULL_TREE.
10134
10135    Note this is primarily designed to be called after gimplification
10136    of the tree structures and when op0 is a constant.  As a result
10137    of those simplifying assumptions this routine is far simpler than
10138    the generic fold routine.  */
10139
10140 tree
10141 nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
10142                                        tree op0)
10143 {
10144   /* Make sure we have a suitable constant argument.  */
10145   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
10146     {
10147       tree subop;
10148
10149       if (TREE_CODE (op0) == COMPLEX_CST)
10150         subop = TREE_REALPART (op0);
10151       else
10152         subop = op0;
10153
10154       if (TREE_CODE (subop) != INTEGER_CST && TREE_CODE (subop) != REAL_CST)
10155         return NULL_TREE;
10156     }
10157
10158   switch (code)
10159     {
10160     case NOP_EXPR:
10161     case FLOAT_EXPR:
10162     case CONVERT_EXPR:
10163     case FIX_TRUNC_EXPR:
10164     case FIX_FLOOR_EXPR:
10165     case FIX_CEIL_EXPR:
10166       return fold_convert_const (code, type, op0);
10167
10168     case NEGATE_EXPR:
10169       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10170         return fold_negate_const (op0, type);
10171       else
10172         return NULL_TREE;
10173
10174     case ABS_EXPR:
10175       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10176         return fold_abs_const (op0, type);
10177       else
10178         return NULL_TREE;
10179
10180     case BIT_NOT_EXPR:
10181       if (TREE_CODE (op0) == INTEGER_CST)
10182         return fold_not_const (op0, type);
10183       else
10184         return NULL_TREE;
10185
10186     case REALPART_EXPR:
10187       if (TREE_CODE (op0) == COMPLEX_CST)
10188         return TREE_REALPART (op0);
10189       else
10190         return NULL_TREE;
10191
10192     case IMAGPART_EXPR:
10193       if (TREE_CODE (op0) == COMPLEX_CST)
10194         return TREE_IMAGPART (op0);
10195       else
10196         return NULL_TREE;
10197
10198     case CONJ_EXPR:
10199       if (TREE_CODE (op0) == COMPLEX_CST
10200           && TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
10201         return build_complex (type, TREE_REALPART (op0),
10202                               negate_expr (TREE_IMAGPART (op0)));
10203       return NULL_TREE;
10204
10205     default:
10206       return NULL_TREE;
10207     }
10208 }
10209
10210 /* If EXP represents referencing an element in a constant string
10211    (either via pointer arithmetic or array indexing), return the
10212    tree representing the value accessed, otherwise return NULL.  */
10213
10214 tree
10215 fold_read_from_constant_string (tree exp)
10216 {
10217   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
10218     {
10219       tree exp1 = TREE_OPERAND (exp, 0);
10220       tree index;
10221       tree string;
10222
10223       if (TREE_CODE (exp) == INDIRECT_REF)
10224         string = string_constant (exp1, &index);
10225       else
10226         {
10227           tree low_bound = array_ref_low_bound (exp);
10228           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
10229
10230           /* Optimize the special-case of a zero lower bound.
10231
10232              We convert the low_bound to sizetype to avoid some problems
10233              with constant folding.  (E.g. suppose the lower bound is 1,
10234              and its mode is QI.  Without the conversion,l (ARRAY
10235              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
10236              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
10237           if (! integer_zerop (low_bound))
10238             index = size_diffop (index, fold_convert (sizetype, low_bound));
10239
10240           string = exp1;
10241         }
10242
10243       if (string
10244           && TREE_TYPE (exp) == TREE_TYPE (TREE_TYPE (string))
10245           && TREE_CODE (string) == STRING_CST
10246           && TREE_CODE (index) == INTEGER_CST
10247           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
10248           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
10249               == MODE_INT)
10250           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
10251         return fold_convert (TREE_TYPE (exp),
10252                              build_int_cst (NULL_TREE,
10253                                             (TREE_STRING_POINTER (string)
10254                                              [TREE_INT_CST_LOW (index)])));
10255     }
10256   return NULL;
10257 }
10258
10259 /* Return the tree for neg (ARG0) when ARG0 is known to be either
10260    an integer constant or real constant.
10261
10262    TYPE is the type of the result.  */
10263
10264 static tree
10265 fold_negate_const (tree arg0, tree type)
10266 {
10267   tree t = NULL_TREE;
10268
10269   switch (TREE_CODE (arg0))
10270     {
10271     case INTEGER_CST:
10272       {
10273         unsigned HOST_WIDE_INT low;
10274         HOST_WIDE_INT high;
10275         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10276                                    TREE_INT_CST_HIGH (arg0),
10277                                    &low, &high);
10278         t = build_int_cst_wide (type, low, high);
10279         t = force_fit_type (t, 1,
10280                             (overflow | TREE_OVERFLOW (arg0))
10281                             && !TYPE_UNSIGNED (type),
10282                             TREE_CONSTANT_OVERFLOW (arg0));
10283         break;
10284       }
10285
10286     case REAL_CST:
10287       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10288       break;
10289
10290     default:
10291       gcc_unreachable ();
10292     }
10293
10294   return t;
10295 }
10296
10297 /* Return the tree for abs (ARG0) when ARG0 is known to be either
10298    an integer constant or real constant.
10299
10300    TYPE is the type of the result.  */
10301
10302 tree
10303 fold_abs_const (tree arg0, tree type)
10304 {
10305   tree t = NULL_TREE;
10306
10307   switch (TREE_CODE (arg0))
10308     {
10309     case INTEGER_CST:
10310       /* If the value is unsigned, then the absolute value is
10311          the same as the ordinary value.  */
10312       if (TYPE_UNSIGNED (type))
10313         t = arg0;
10314       /* Similarly, if the value is non-negative.  */
10315       else if (INT_CST_LT (integer_minus_one_node, arg0))
10316         t = arg0;
10317       /* If the value is negative, then the absolute value is
10318          its negation.  */
10319       else
10320         {
10321           unsigned HOST_WIDE_INT low;
10322           HOST_WIDE_INT high;
10323           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10324                                      TREE_INT_CST_HIGH (arg0),
10325                                      &low, &high);
10326           t = build_int_cst_wide (type, low, high);
10327           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
10328                               TREE_CONSTANT_OVERFLOW (arg0));
10329         }
10330       break;
10331
10332     case REAL_CST:
10333       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
10334         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10335       else
10336         t =  arg0;
10337       break;
10338
10339     default:
10340       gcc_unreachable ();
10341     }
10342
10343   return t;
10344 }
10345
10346 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
10347    constant.  TYPE is the type of the result.  */
10348
10349 static tree
10350 fold_not_const (tree arg0, tree type)
10351 {
10352   tree t = NULL_TREE;
10353
10354   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
10355
10356   t = build_int_cst_wide (type,
10357                           ~ TREE_INT_CST_LOW (arg0),
10358                           ~ TREE_INT_CST_HIGH (arg0));
10359   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
10360                       TREE_CONSTANT_OVERFLOW (arg0));
10361
10362   return t;
10363 }
10364
10365 /* Given CODE, a relational operator, the target type, TYPE and two
10366    constant operands OP0 and OP1, return the result of the
10367    relational operation.  If the result is not a compile time
10368    constant, then return NULL_TREE.  */
10369
10370 static tree
10371 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
10372 {
10373   int result, invert;
10374
10375   /* From here on, the only cases we handle are when the result is
10376      known to be a constant.  */
10377
10378   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10379     {
10380       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
10381       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
10382
10383       /* Handle the cases where either operand is a NaN.  */
10384       if (real_isnan (c0) || real_isnan (c1))
10385         {
10386           switch (code)
10387             {
10388             case EQ_EXPR:
10389             case ORDERED_EXPR:
10390               result = 0;
10391               break;
10392
10393             case NE_EXPR:
10394             case UNORDERED_EXPR:
10395             case UNLT_EXPR:
10396             case UNLE_EXPR:
10397             case UNGT_EXPR:
10398             case UNGE_EXPR:
10399             case UNEQ_EXPR:
10400               result = 1;
10401               break;
10402
10403             case LT_EXPR:
10404             case LE_EXPR:
10405             case GT_EXPR:
10406             case GE_EXPR:
10407             case LTGT_EXPR:
10408               if (flag_trapping_math)
10409                 return NULL_TREE;
10410               result = 0;
10411               break;
10412
10413             default:
10414               gcc_unreachable ();
10415             }
10416
10417           return constant_boolean_node (result, type);
10418         }
10419
10420       return constant_boolean_node (real_compare (code, c0, c1), type);
10421     }
10422
10423   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
10424
10425      To compute GT, swap the arguments and do LT.
10426      To compute GE, do LT and invert the result.
10427      To compute LE, swap the arguments, do LT and invert the result.
10428      To compute NE, do EQ and invert the result.
10429
10430      Therefore, the code below must handle only EQ and LT.  */
10431
10432   if (code == LE_EXPR || code == GT_EXPR)
10433     {
10434       tree tem = op0;
10435       op0 = op1;
10436       op1 = tem;
10437       code = swap_tree_comparison (code);
10438     }
10439
10440   /* Note that it is safe to invert for real values here because we
10441      have already handled the one case that it matters.  */
10442
10443   invert = 0;
10444   if (code == NE_EXPR || code == GE_EXPR)
10445     {
10446       invert = 1;
10447       code = invert_tree_comparison (code, false);
10448     }
10449
10450   /* Compute a result for LT or EQ if args permit;
10451      Otherwise return T.  */
10452   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10453     {
10454       if (code == EQ_EXPR)
10455         result = tree_int_cst_equal (op0, op1);
10456       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
10457         result = INT_CST_LT_UNSIGNED (op0, op1);
10458       else
10459         result = INT_CST_LT (op0, op1);
10460     }
10461   else
10462     return NULL_TREE;
10463
10464   if (invert)
10465     result ^= 1;
10466   return constant_boolean_node (result, type);
10467 }
10468
10469 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
10470    avoid confusing the gimplify process.  */
10471
10472 tree
10473 build_fold_addr_expr_with_type (tree t, tree ptrtype)
10474 {
10475   /* The size of the object is not relevant when talking about its address.  */
10476   if (TREE_CODE (t) == WITH_SIZE_EXPR)
10477     t = TREE_OPERAND (t, 0);
10478
10479   if (TREE_CODE (t) == INDIRECT_REF)
10480     {
10481       t = TREE_OPERAND (t, 0);
10482       if (TREE_TYPE (t) != ptrtype)
10483         t = build1 (NOP_EXPR, ptrtype, t);
10484     }
10485   else
10486     {
10487       tree base = t;
10488
10489       while (handled_component_p (base)
10490              || TREE_CODE (base) == REALPART_EXPR
10491              || TREE_CODE (base) == IMAGPART_EXPR)
10492         base = TREE_OPERAND (base, 0);
10493       if (DECL_P (base))
10494         TREE_ADDRESSABLE (base) = 1;
10495
10496       t = build1 (ADDR_EXPR, ptrtype, t);
10497     }
10498
10499   return t;
10500 }
10501
10502 tree
10503 build_fold_addr_expr (tree t)
10504 {
10505   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
10506 }
10507
10508 /* Builds an expression for an indirection through T, simplifying some
10509    cases.  */
10510
10511 tree
10512 build_fold_indirect_ref (tree t)
10513 {
10514   tree type = TREE_TYPE (TREE_TYPE (t));
10515   tree sub = t;
10516   tree subtype;
10517
10518   STRIP_NOPS (sub);
10519   if (TREE_CODE (sub) == ADDR_EXPR)
10520     {
10521       tree op = TREE_OPERAND (sub, 0);
10522       tree optype = TREE_TYPE (op);
10523       /* *&p => p */
10524       if (lang_hooks.types_compatible_p (type, optype))
10525         return op;
10526       /* *(foo *)&fooarray => fooarray[0] */
10527       else if (TREE_CODE (optype) == ARRAY_TYPE
10528                && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
10529         return build4 (ARRAY_REF, type, op, size_zero_node, NULL_TREE, NULL_TREE);
10530     }
10531
10532   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
10533   subtype = TREE_TYPE (sub);
10534   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
10535       && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
10536     {
10537       sub = build_fold_indirect_ref (sub);
10538       return build4 (ARRAY_REF, type, sub, size_zero_node, NULL_TREE, NULL_TREE);
10539     }
10540
10541   return build1 (INDIRECT_REF, type, t);
10542 }
10543
10544 /* Strip non-trapping, non-side-effecting tree nodes from an expression
10545    whose result is ignored.  The type of the returned tree need not be
10546    the same as the original expression.  */
10547
10548 tree
10549 fold_ignored_result (tree t)
10550 {
10551   if (!TREE_SIDE_EFFECTS (t))
10552     return integer_zero_node;
10553
10554   for (;;)
10555     switch (TREE_CODE_CLASS (TREE_CODE (t)))
10556       {
10557       case '1':
10558         t = TREE_OPERAND (t, 0);
10559         break;
10560
10561       case '2':
10562       case '<':
10563         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10564           t = TREE_OPERAND (t, 0);
10565         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
10566           t = TREE_OPERAND (t, 1);
10567         else
10568           return t;
10569         break;
10570
10571       case 'e':
10572         switch (TREE_CODE (t))
10573           {
10574           case COMPOUND_EXPR:
10575             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10576               return t;
10577             t = TREE_OPERAND (t, 0);
10578             break;
10579
10580           case COND_EXPR:
10581             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
10582                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
10583               return t;
10584             t = TREE_OPERAND (t, 0);
10585             break;
10586
10587           default:
10588             return t;
10589           }
10590         break;
10591
10592       default:
10593         return t;
10594       }
10595 }
10596
10597 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
10598    This can only be applied to objects of a sizetype.  */
10599
10600 tree
10601 round_up (tree value, int divisor)
10602 {
10603   tree div = NULL_TREE;
10604
10605   gcc_assert (divisor > 0);
10606   if (divisor == 1)
10607     return value;
10608
10609   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10610      have to do anything.  Only do this when we are not given a const,
10611      because in that case, this check is more expensive than just
10612      doing it.  */
10613   if (TREE_CODE (value) != INTEGER_CST)
10614     {
10615       div = build_int_cst (TREE_TYPE (value), divisor);
10616
10617       if (multiple_of_p (TREE_TYPE (value), value, div))
10618         return value;
10619     }
10620
10621   /* If divisor is a power of two, simplify this to bit manipulation.  */
10622   if (divisor == (divisor & -divisor))
10623     {
10624       tree t;
10625
10626       t = build_int_cst (TREE_TYPE (value), divisor - 1);
10627       value = size_binop (PLUS_EXPR, value, t);
10628       t = build_int_cst (TREE_TYPE (value), -divisor);
10629       value = size_binop (BIT_AND_EXPR, value, t);
10630     }
10631   else
10632     {
10633       if (!div)
10634         div = build_int_cst (TREE_TYPE (value), divisor);
10635       value = size_binop (CEIL_DIV_EXPR, value, div);
10636       value = size_binop (MULT_EXPR, value, div);
10637     }
10638
10639   return value;
10640 }
10641
10642 /* Likewise, but round down.  */
10643
10644 tree
10645 round_down (tree value, int divisor)
10646 {
10647   tree div = NULL_TREE;
10648
10649   gcc_assert (divisor > 0);
10650   if (divisor == 1)
10651     return value;
10652
10653   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10654      have to do anything.  Only do this when we are not given a const,
10655      because in that case, this check is more expensive than just
10656      doing it.  */
10657   if (TREE_CODE (value) != INTEGER_CST)
10658     {
10659       div = build_int_cst (TREE_TYPE (value), divisor);
10660
10661       if (multiple_of_p (TREE_TYPE (value), value, div))
10662         return value;
10663     }
10664
10665   /* If divisor is a power of two, simplify this to bit manipulation.  */
10666   if (divisor == (divisor & -divisor))
10667     {
10668       tree t;
10669
10670       t = build_int_cst (TREE_TYPE (value), -divisor);
10671       value = size_binop (BIT_AND_EXPR, value, t);
10672     }
10673   else
10674     {
10675       if (!div)
10676         div = build_int_cst (TREE_TYPE (value), divisor);
10677       value = size_binop (FLOOR_DIV_EXPR, value, div);
10678       value = size_binop (MULT_EXPR, value, div);
10679     }
10680
10681   return value;
10682 }
10683
10684 /* Returns true if addresses of E1 and E2 differ by a constant, false
10685    otherwise.  If they do, &E1 - &E2 is stored in *DIFF.  */
10686
10687 bool
10688 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
10689 {
10690   tree core1, core2;
10691   HOST_WIDE_INT bitsize1, bitsize2;
10692   HOST_WIDE_INT bitpos1, bitpos2;
10693   tree toffset1, toffset2, tdiff, type;
10694   enum machine_mode mode1, mode2;
10695   int unsignedp1, unsignedp2, volatilep1, volatilep2;
10696
10697   core1 = get_inner_reference (e1, &bitsize1, &bitpos1, &toffset1, &mode1,
10698                                &unsignedp1, &volatilep1);
10699   core2 = get_inner_reference (e2, &bitsize2, &bitpos2, &toffset2, &mode2,
10700                                &unsignedp2, &volatilep2);
10701
10702   if (bitpos1 % BITS_PER_UNIT != 0
10703       || bitpos2 % BITS_PER_UNIT != 0
10704       || !operand_equal_p (core1, core2, 0))
10705     return false;
10706
10707   if (toffset1 && toffset2)
10708     {
10709       type = TREE_TYPE (toffset1);
10710       if (type != TREE_TYPE (toffset2))
10711         toffset2 = fold_convert (type, toffset2);
10712
10713       tdiff = fold (build2 (MINUS_EXPR, type, toffset1, toffset2));
10714       if (!host_integerp (tdiff, 0))
10715         return false;
10716
10717       *diff = tree_low_cst (tdiff, 0);
10718     }
10719   else if (toffset1 || toffset2)
10720     {
10721       /* If only one of the offsets is non-constant, the difference cannot
10722          be a constant.  */
10723       return false;
10724     }
10725   else
10726     *diff = 0;
10727
10728   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
10729   return true;
10730 }