gcc/fold-const.c

   1 /* Fold a constant sub-tree into a single node for C-compiler
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /*@@ This file should be rewritten to use an arbitrary precision
  23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  25   @@ The routines that translate from the ap rep should
  26   @@ warn if precision et. al. is lost.
  27   @@ This would also make life easier when this technology is used
  28   @@ for cross-compilers.  */
  29
  30 /* The entry points in this file are fold, size_int_wide, size_binop
  31    and force_fit_type.
  32
  33    fold takes a tree as argument and returns a simplified tree.
  34
  35    size_binop takes a tree code for an arithmetic operation
  36    and two operands that are trees, and produces a tree for the
  37    result, assuming the type comes from `sizetype'.
  38
  39    size_int takes an integer value, and creates a tree constant
  40    with type from `sizetype'.
  41
  42    force_fit_type takes a constant, an overflowable flag and prior
  43    overflow indicators.  It forces the value to fit the type and sets
  44    TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.  */
  45
  46 #include "config.h"
  47 #include "system.h"
  48 #include "coretypes.h"
  49 #include "tm.h"
  50 #include "flags.h"
  51 #include "tree.h"
  52 #include "real.h"
  53 #include "rtl.h"
  54 #include "expr.h"
  55 #include "tm_p.h"
  56 #include "toplev.h"
  57 #include "ggc.h"
  58 #include "hashtab.h"
  59 #include "langhooks.h"
  60 #include "md5.h"
  61
  62 /* The following constants represent a bit based encoding of GCC's
  63    comparison operators.  This encoding simplifies transformations
  64    on relational comparison operators, such as AND and OR.  */
  65 enum comparison_code {
  66   COMPCODE_FALSE = 0,
  67   COMPCODE_LT = 1,
  68   COMPCODE_EQ = 2,
  69   COMPCODE_LE = 3,
  70   COMPCODE_GT = 4,
  71   COMPCODE_LTGT = 5,
  72   COMPCODE_GE = 6,
  73   COMPCODE_ORD = 7,
  74   COMPCODE_UNORD = 8,
  75   COMPCODE_UNLT = 9,
  76   COMPCODE_UNEQ = 10,
  77   COMPCODE_UNLE = 11,
  78   COMPCODE_UNGT = 12,
  79   COMPCODE_NE = 13,
  80   COMPCODE_UNGE = 14,
  81   COMPCODE_TRUE = 15
  82 };
  83
  84 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
  85 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
  86 static bool negate_mathfn_p (enum built_in_function);
  87 static bool negate_expr_p (tree);
  88 static tree negate_expr (tree);
  89 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
  90 static tree associate_trees (tree, tree, enum tree_code, tree);
  91 static tree const_binop (enum tree_code, tree, tree, int);
  92 static tree build_zero_vector (tree);
  93 static tree fold_convert_const (enum tree_code, tree, tree);
  94 static enum tree_code invert_tree_comparison (enum tree_code, bool);
  95 static enum comparison_code comparison_to_compcode (enum tree_code);
  96 static enum tree_code compcode_to_comparison (enum comparison_code);
  97 static tree combine_comparisons (enum tree_code, enum tree_code,
  98                                  enum tree_code, tree, tree, tree);
  99 static int truth_value_p (enum tree_code);
 100 static int operand_equal_for_comparison_p (tree, tree, tree);
 101 static int twoval_comparison_p (tree, tree *, tree *, int *);
 102 static tree eval_subst (tree, tree, tree, tree, tree);
 103 static tree pedantic_omit_one_operand (tree, tree, tree);
 104 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
 105 static tree make_bit_field_ref (tree, tree, int, int, int);
 106 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
 107 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
 108                                     enum machine_mode *, int *, int *,
 109                                     tree *, tree *);
 110 static int all_ones_mask_p (tree, int);
 111 static tree sign_bit_p (tree, tree);
 112 static int simple_operand_p (tree);
 113 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 114 static tree make_range (tree, int *, tree *, tree *);
 115 static tree build_range_check (tree, tree, int, tree, tree);
 116 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
 117                          tree);
 118 static tree fold_range_test (tree);
 119 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
 120 static tree unextend (tree, int, int, tree);
 121 static tree fold_truthop (enum tree_code, tree, tree, tree);
 122 static tree optimize_minmax_comparison (tree);
 123 static tree extract_muldiv (tree, tree, enum tree_code, tree);
 124 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree);
 125 static int multiple_of_p (tree, tree, tree);
 126 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree, tree,
 127                                                  tree, int);
 128 static bool fold_real_zero_addition_p (tree, tree, int);
 129 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
 130                                  tree, tree, tree);
 131 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
 132 static tree fold_div_compare (enum tree_code, tree, tree, tree);
 133 static bool reorder_operands_p (tree, tree);
 134 static tree fold_negate_const (tree, tree);
 135 static tree fold_not_const (tree, tree);
 136 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 137 static tree fold_relational_hi_lo (enum tree_code *, const tree,
 138                                    tree *, tree *);
 139 static bool tree_expr_nonzero_p (tree);
 140
 141 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 142    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 143    and SUM1.  Then this yields nonzero if overflow occurred during the
 144    addition.
 145
 146    Overflow occurs if A and B have the same sign, but A and SUM differ in
 147    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 148    sign.  */
 149 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 150 \f
 151 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
 152    We do that by representing the two-word integer in 4 words, with only
 153    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
 154    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
 155
 156 #define LOWPART(x) \
 157   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
 158 #define HIGHPART(x) \
 159   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
 160 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
 161
 162 /* Unpack a two-word integer into 4 words.
 163    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
 164    WORDS points to the array of HOST_WIDE_INTs.  */
 165
 166 static void
 167 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
 168 {
 169   words[0] = LOWPART (low);
 170   words[1] = HIGHPART (low);
 171   words[2] = LOWPART (hi);
 172   words[3] = HIGHPART (hi);
 173 }
 174
 175 /* Pack an array of 4 words into a two-word integer.
 176    WORDS points to the array of words.
 177    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
 178
 179 static void
 180 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
 181         HOST_WIDE_INT *hi)
 182 {
 183   *low = words[0] + words[1] * BASE;
 184   *hi = words[2] + words[3] * BASE;
 185 }
 186 \f
 187 /* T is an INT_CST node.  OVERFLOWABLE indicates if we are interested
 188    in overflow of the value, when >0 we are only interested in signed
 189    overflow, for <0 we are interested in any overflow.  OVERFLOWED
 190    indicates whether overflow has already occurred.  CONST_OVERFLOWED
 191    indicates whether constant overflow has already occurred.  We force
 192    T's value to be within range of T's type (by setting to 0 or 1 all
 193    the bits outside the type's range).  We set TREE_OVERFLOWED if,
 194         OVERFLOWED is non-zero,
 195         or OVERFLOWABLE is >0 and signed overflow occurs
 196         or OVERFLOWABLE is <0 and any overflow occurs
 197    We set TREE_CONSTANT_OVERFLOWED if,
 198         CONST_OVERFLOWED is non-zero
 199         or we set TREE_OVERFLOWED.
 200   We return either the original T, or a copy.  */
 201
 202 tree
 203 force_fit_type (tree t, int overflowable,
 204                 bool overflowed, bool overflowed_const)
 205 {
 206   unsigned HOST_WIDE_INT low;
 207   HOST_WIDE_INT high;
 208   unsigned int prec;
 209   int sign_extended_type;
 210
 211   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 212
 213   low = TREE_INT_CST_LOW (t);
 214   high = TREE_INT_CST_HIGH (t);
 215
 216   if (POINTER_TYPE_P (TREE_TYPE (t))
 217       || TREE_CODE (TREE_TYPE (t)) == OFFSET_TYPE)
 218     prec = POINTER_SIZE;
 219   else
 220     prec = TYPE_PRECISION (TREE_TYPE (t));
 221   /* Size types *are* sign extended.  */
 222   sign_extended_type = (!TYPE_UNSIGNED (TREE_TYPE (t))
 223                         || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
 224                             && TYPE_IS_SIZETYPE (TREE_TYPE (t))));
 225
 226   /* First clear all bits that are beyond the type's precision.  */
 227
 228   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 229     ;
 230   else if (prec > HOST_BITS_PER_WIDE_INT)
 231     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 232   else
 233     {
 234       high = 0;
 235       if (prec < HOST_BITS_PER_WIDE_INT)
 236         low &= ~((HOST_WIDE_INT) (-1) << prec);
 237     }
 238
 239   if (!sign_extended_type)
 240     /* No sign extension */;
 241   else if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 242     /* Correct width already.  */;
 243   else if (prec > HOST_BITS_PER_WIDE_INT)
 244     {
 245       /* Sign extend top half? */
 246       if (high & ((unsigned HOST_WIDE_INT)1
 247                   << (prec - HOST_BITS_PER_WIDE_INT - 1)))
 248         high |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
 249     }
 250   else if (prec == HOST_BITS_PER_WIDE_INT)
 251     {
 252       if ((HOST_WIDE_INT)low < 0)
 253         high = -1;
 254     }
 255   else
 256     {
 257       /* Sign extend bottom half? */
 258       if (low & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
 259         {
 260           high = -1;
 261           low |= (HOST_WIDE_INT)(-1) << prec;
 262         }
 263     }
 264
 265   /* If the value changed, return a new node.  */
 266   if (overflowed || overflowed_const
 267       || low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
 268     {
 269       t = build_int_cst_wide (TREE_TYPE (t), low, high);
 270
 271       if (overflowed
 272           || overflowable < 0
 273           || (overflowable > 0 && sign_extended_type))
 274         {
 275           t = copy_node (t);
 276           TREE_OVERFLOW (t) = 1;
 277           TREE_CONSTANT_OVERFLOW (t) = 1;
 278         }
 279       else if (overflowed_const)
 280         {
 281           t = copy_node (t);
 282           TREE_CONSTANT_OVERFLOW (t) = 1;
 283         }
 284     }
 285
 286   return t;
 287 }
 288 \f
 289 /* Add two doubleword integers with doubleword result.
 290    Each argument is given as two `HOST_WIDE_INT' pieces.
 291    One argument is L1 and H1; the other, L2 and H2.
 292    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 293
 294 int
 295 add_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 296             unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
 297             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 298 {
 299   unsigned HOST_WIDE_INT l;
 300   HOST_WIDE_INT h;
 301
 302   l = l1 + l2;
 303   h = h1 + h2 + (l < l1);
 304
 305   *lv = l;
 306   *hv = h;
 307   return OVERFLOW_SUM_SIGN (h1, h2, h);
 308 }
 309
 310 /* Negate a doubleword integer with doubleword result.
 311    Return nonzero if the operation overflows, assuming it's signed.
 312    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
 313    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 314
 315 int
 316 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 317             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 318 {
 319   if (l1 == 0)
 320     {
 321       *lv = 0;
 322       *hv = - h1;
 323       return (*hv & h1) < 0;
 324     }
 325   else
 326     {
 327       *lv = -l1;
 328       *hv = ~h1;
 329       return 0;
 330     }
 331 }
 332 \f
 333 /* Multiply two doubleword integers with doubleword result.
 334    Return nonzero if the operation overflows, assuming it's signed.
 335    Each argument is given as two `HOST_WIDE_INT' pieces.
 336    One argument is L1 and H1; the other, L2 and H2.
 337    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 338
 339 int
 340 mul_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 341             unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
 342             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 343 {
 344   HOST_WIDE_INT arg1[4];
 345   HOST_WIDE_INT arg2[4];
 346   HOST_WIDE_INT prod[4 * 2];
 347   unsigned HOST_WIDE_INT carry;
 348   int i, j, k;
 349   unsigned HOST_WIDE_INT toplow, neglow;
 350   HOST_WIDE_INT tophigh, neghigh;
 351
 352   encode (arg1, l1, h1);
 353   encode (arg2, l2, h2);
 354
 355   memset (prod, 0, sizeof prod);
 356
 357   for (i = 0; i < 4; i++)
 358     {
 359       carry = 0;
 360       for (j = 0; j < 4; j++)
 361         {
 362           k = i + j;
 363           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
 364           carry += arg1[i] * arg2[j];
 365           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
 366           carry += prod[k];
 367           prod[k] = LOWPART (carry);
 368           carry = HIGHPART (carry);
 369         }
 370       prod[i + 4] = carry;
 371     }
 372
 373   decode (prod, lv, hv);        /* This ignores prod[4] through prod[4*2-1] */
 374
 375   /* Check for overflow by calculating the top half of the answer in full;
 376      it should agree with the low half's sign bit.  */
 377   decode (prod + 4, &toplow, &tophigh);
 378   if (h1 < 0)
 379     {
 380       neg_double (l2, h2, &neglow, &neghigh);
 381       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 382     }
 383   if (h2 < 0)
 384     {
 385       neg_double (l1, h1, &neglow, &neghigh);
 386       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 387     }
 388   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
 389 }
 390 \f
 391 /* Shift the doubleword integer in L1, H1 left by COUNT places
 392    keeping only PREC bits of result.
 393    Shift right if COUNT is negative.
 394    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 395    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 396
 397 void
 398 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 399                HOST_WIDE_INT count, unsigned int prec,
 400                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
 401 {
 402   unsigned HOST_WIDE_INT signmask;
 403
 404   if (count < 0)
 405     {
 406       rshift_double (l1, h1, -count, prec, lv, hv, arith);
 407       return;
 408     }
 409
 410   if (SHIFT_COUNT_TRUNCATED)
 411     count %= prec;
 412
 413   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 414     {
 415       /* Shifting by the host word size is undefined according to the
 416          ANSI standard, so we must handle this as a special case.  */
 417       *hv = 0;
 418       *lv = 0;
 419     }
 420   else if (count >= HOST_BITS_PER_WIDE_INT)
 421     {
 422       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
 423       *lv = 0;
 424     }
 425   else
 426     {
 427       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
 428              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
 429       *lv = l1 << count;
 430     }
 431
 432   /* Sign extend all bits that are beyond the precision.  */
 433
 434   signmask = -((prec > HOST_BITS_PER_WIDE_INT
 435                 ? ((unsigned HOST_WIDE_INT) *hv
 436                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
 437                 : (*lv >> (prec - 1))) & 1);
 438
 439   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
 440     ;
 441   else if (prec >= HOST_BITS_PER_WIDE_INT)
 442     {
 443       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 444       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
 445     }
 446   else
 447     {
 448       *hv = signmask;
 449       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
 450       *lv |= signmask << prec;
 451     }
 452 }
 453
 454 /* Shift the doubleword integer in L1, H1 right by COUNT places
 455    keeping only PREC bits of result.  COUNT must be positive.
 456    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 457    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 458
 459 void
 460 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 461                HOST_WIDE_INT count, unsigned int prec,
 462                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
 463                int arith)
 464 {
 465   unsigned HOST_WIDE_INT signmask;
 466
 467   signmask = (arith
 468               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
 469               : 0);
 470
 471   if (SHIFT_COUNT_TRUNCATED)
 472     count %= prec;
 473
 474   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 475     {
 476       /* Shifting by the host word size is undefined according to the
 477          ANSI standard, so we must handle this as a special case.  */
 478       *hv = 0;
 479       *lv = 0;
 480     }
 481   else if (count >= HOST_BITS_PER_WIDE_INT)
 482     {
 483       *hv = 0;
 484       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
 485     }
 486   else
 487     {
 488       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
 489       *lv = ((l1 >> count)
 490              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
 491     }
 492
 493   /* Zero / sign extend all bits that are beyond the precision.  */
 494
 495   if (count >= (HOST_WIDE_INT)prec)
 496     {
 497       *hv = signmask;
 498       *lv = signmask;
 499     }
 500   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
 501     ;
 502   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
 503     {
 504       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
 505       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
 506     }
 507   else
 508     {
 509       *hv = signmask;
 510       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
 511       *lv |= signmask << (prec - count);
 512     }
 513 }
 514 \f
 515 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 516    keeping only PREC bits of result.
 517    Rotate right if COUNT is negative.
 518    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 519
 520 void
 521 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 522                 HOST_WIDE_INT count, unsigned int prec,
 523                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 524 {
 525   unsigned HOST_WIDE_INT s1l, s2l;
 526   HOST_WIDE_INT s1h, s2h;
 527
 528   count %= prec;
 529   if (count < 0)
 530     count += prec;
 531
 532   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 533   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 534   *lv = s1l | s2l;
 535   *hv = s1h | s2h;
 536 }
 537
 538 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 539    keeping only PREC bits of result.  COUNT must be positive.
 540    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 541
 542 void
 543 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 544                 HOST_WIDE_INT count, unsigned int prec,
 545                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 546 {
 547   unsigned HOST_WIDE_INT s1l, s2l;
 548   HOST_WIDE_INT s1h, s2h;
 549
 550   count %= prec;
 551   if (count < 0)
 552     count += prec;
 553
 554   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 555   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 556   *lv = s1l | s2l;
 557   *hv = s1h | s2h;
 558 }
 559 \f
 560 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
 561    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
 562    CODE is a tree code for a kind of division, one of
 563    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
 564    or EXACT_DIV_EXPR
 565    It controls how the quotient is rounded to an integer.
 566    Return nonzero if the operation overflows.
 567    UNS nonzero says do unsigned division.  */
 568
 569 int
 570 div_and_round_double (enum tree_code code, int uns,
 571                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
 572                       HOST_WIDE_INT hnum_orig,
 573                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
 574                       HOST_WIDE_INT hden_orig,
 575                       unsigned HOST_WIDE_INT *lquo,
 576                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
 577                       HOST_WIDE_INT *hrem)
 578 {
 579   int quo_neg = 0;
 580   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
 581   HOST_WIDE_INT den[4], quo[4];
 582   int i, j;
 583   unsigned HOST_WIDE_INT work;
 584   unsigned HOST_WIDE_INT carry = 0;
 585   unsigned HOST_WIDE_INT lnum = lnum_orig;
 586   HOST_WIDE_INT hnum = hnum_orig;
 587   unsigned HOST_WIDE_INT lden = lden_orig;
 588   HOST_WIDE_INT hden = hden_orig;
 589   int overflow = 0;
 590
 591   if (hden == 0 && lden == 0)
 592     overflow = 1, lden = 1;
 593
 594   /* Calculate quotient sign and convert operands to unsigned.  */
 595   if (!uns)
 596     {
 597       if (hnum < 0)
 598         {
 599           quo_neg = ~ quo_neg;
 600           /* (minimum integer) / (-1) is the only overflow case.  */
 601           if (neg_double (lnum, hnum, &lnum, &hnum)
 602               && ((HOST_WIDE_INT) lden & hden) == -1)
 603             overflow = 1;
 604         }
 605       if (hden < 0)
 606         {
 607           quo_neg = ~ quo_neg;
 608           neg_double (lden, hden, &lden, &hden);
 609         }
 610     }
 611
 612   if (hnum == 0 && hden == 0)
 613     {                           /* single precision */
 614       *hquo = *hrem = 0;
 615       /* This unsigned division rounds toward zero.  */
 616       *lquo = lnum / lden;
 617       goto finish_up;
 618     }
 619
 620   if (hnum == 0)
 621     {                           /* trivial case: dividend < divisor */
 622       /* hden != 0 already checked.  */
 623       *hquo = *lquo = 0;
 624       *hrem = hnum;
 625       *lrem = lnum;
 626       goto finish_up;
 627     }
 628
 629   memset (quo, 0, sizeof quo);
 630
 631   memset (num, 0, sizeof num);  /* to zero 9th element */
 632   memset (den, 0, sizeof den);
 633
 634   encode (num, lnum, hnum);
 635   encode (den, lden, hden);
 636
 637   /* Special code for when the divisor < BASE.  */
 638   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
 639     {
 640       /* hnum != 0 already checked.  */
 641       for (i = 4 - 1; i >= 0; i--)
 642         {
 643           work = num[i] + carry * BASE;
 644           quo[i] = work / lden;
 645           carry = work % lden;
 646         }
 647     }
 648   else
 649     {
 650       /* Full double precision division,
 651          with thanks to Don Knuth's "Seminumerical Algorithms".  */
 652       int num_hi_sig, den_hi_sig;
 653       unsigned HOST_WIDE_INT quo_est, scale;
 654
 655       /* Find the highest nonzero divisor digit.  */
 656       for (i = 4 - 1;; i--)
 657         if (den[i] != 0)
 658           {
 659             den_hi_sig = i;
 660             break;
 661           }
 662
 663       /* Insure that the first digit of the divisor is at least BASE/2.
 664          This is required by the quotient digit estimation algorithm.  */
 665
 666       scale = BASE / (den[den_hi_sig] + 1);
 667       if (scale > 1)
 668         {               /* scale divisor and dividend */
 669           carry = 0;
 670           for (i = 0; i <= 4 - 1; i++)
 671             {
 672               work = (num[i] * scale) + carry;
 673               num[i] = LOWPART (work);
 674               carry = HIGHPART (work);
 675             }
 676
 677           num[4] = carry;
 678           carry = 0;
 679           for (i = 0; i <= 4 - 1; i++)
 680             {
 681               work = (den[i] * scale) + carry;
 682               den[i] = LOWPART (work);
 683               carry = HIGHPART (work);
 684               if (den[i] != 0) den_hi_sig = i;
 685             }
 686         }
 687
 688       num_hi_sig = 4;
 689
 690       /* Main loop */
 691       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
 692         {
 693           /* Guess the next quotient digit, quo_est, by dividing the first
 694              two remaining dividend digits by the high order quotient digit.
 695              quo_est is never low and is at most 2 high.  */
 696           unsigned HOST_WIDE_INT tmp;
 697
 698           num_hi_sig = i + den_hi_sig + 1;
 699           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
 700           if (num[num_hi_sig] != den[den_hi_sig])
 701             quo_est = work / den[den_hi_sig];
 702           else
 703             quo_est = BASE - 1;
 704
 705           /* Refine quo_est so it's usually correct, and at most one high.  */
 706           tmp = work - quo_est * den[den_hi_sig];
 707           if (tmp < BASE
 708               && (den[den_hi_sig - 1] * quo_est
 709                   > (tmp * BASE + num[num_hi_sig - 2])))
 710             quo_est--;
 711
 712           /* Try QUO_EST as the quotient digit, by multiplying the
 713              divisor by QUO_EST and subtracting from the remaining dividend.
 714              Keep in mind that QUO_EST is the I - 1st digit.  */
 715
 716           carry = 0;
 717           for (j = 0; j <= den_hi_sig; j++)
 718             {
 719               work = quo_est * den[j] + carry;
 720               carry = HIGHPART (work);
 721               work = num[i + j] - LOWPART (work);
 722               num[i + j] = LOWPART (work);
 723               carry += HIGHPART (work) != 0;
 724             }
 725
 726           /* If quo_est was high by one, then num[i] went negative and
 727              we need to correct things.  */
 728           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
 729             {
 730               quo_est--;
 731               carry = 0;                /* add divisor back in */
 732               for (j = 0; j <= den_hi_sig; j++)
 733                 {
 734                   work = num[i + j] + den[j] + carry;
 735                   carry = HIGHPART (work);
 736                   num[i + j] = LOWPART (work);
 737                 }
 738
 739               num [num_hi_sig] += carry;
 740             }
 741
 742           /* Store the quotient digit.  */
 743           quo[i] = quo_est;
 744         }
 745     }
 746
 747   decode (quo, lquo, hquo);
 748
 749  finish_up:
 750   /* If result is negative, make it so.  */
 751   if (quo_neg)
 752     neg_double (*lquo, *hquo, lquo, hquo);
 753
 754   /* Compute trial remainder:  rem = num - (quo * den)  */
 755   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 756   neg_double (*lrem, *hrem, lrem, hrem);
 757   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 758
 759   switch (code)
 760     {
 761     case TRUNC_DIV_EXPR:
 762     case TRUNC_MOD_EXPR:        /* round toward zero */
 763     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
 764       return overflow;
 765
 766     case FLOOR_DIV_EXPR:
 767     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
 768       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
 769         {
 770           /* quo = quo - 1;  */
 771           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
 772                       lquo, hquo);
 773         }
 774       else
 775         return overflow;
 776       break;
 777
 778     case CEIL_DIV_EXPR:
 779     case CEIL_MOD_EXPR:         /* round toward positive infinity */
 780       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
 781         {
 782           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 783                       lquo, hquo);
 784         }
 785       else
 786         return overflow;
 787       break;
 788
 789     case ROUND_DIV_EXPR:
 790     case ROUND_MOD_EXPR:        /* round to closest integer */
 791       {
 792         unsigned HOST_WIDE_INT labs_rem = *lrem;
 793         HOST_WIDE_INT habs_rem = *hrem;
 794         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
 795         HOST_WIDE_INT habs_den = hden, htwice;
 796
 797         /* Get absolute values.  */
 798         if (*hrem < 0)
 799           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
 800         if (hden < 0)
 801           neg_double (lden, hden, &labs_den, &habs_den);
 802
 803         /* If (2 * abs (lrem) >= abs (lden)) */
 804         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
 805                     labs_rem, habs_rem, &ltwice, &htwice);
 806
 807         if (((unsigned HOST_WIDE_INT) habs_den
 808              < (unsigned HOST_WIDE_INT) htwice)
 809             || (((unsigned HOST_WIDE_INT) habs_den
 810                  == (unsigned HOST_WIDE_INT) htwice)
 811                 && (labs_den < ltwice)))
 812           {
 813             if (*hquo < 0)
 814               /* quo = quo - 1;  */
 815               add_double (*lquo, *hquo,
 816                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
 817             else
 818               /* quo = quo + 1; */
 819               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 820                           lquo, hquo);
 821           }
 822         else
 823           return overflow;
 824       }
 825       break;
 826
 827     default:
 828       gcc_unreachable ();
 829     }
 830
 831   /* Compute true remainder:  rem = num - (quo * den)  */
 832   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 833   neg_double (*lrem, *hrem, lrem, hrem);
 834   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 835   return overflow;
 836 }
 837 \f
 838 /* Return true if built-in mathematical function specified by CODE
 839    preserves the sign of it argument, i.e. -f(x) == f(-x).  */
 840
 841 static bool
 842 negate_mathfn_p (enum built_in_function code)
 843 {
 844   switch (code)
 845     {
 846     case BUILT_IN_ASIN:
 847     case BUILT_IN_ASINF:
 848     case BUILT_IN_ASINL:
 849     case BUILT_IN_ATAN:
 850     case BUILT_IN_ATANF:
 851     case BUILT_IN_ATANL:
 852     case BUILT_IN_SIN:
 853     case BUILT_IN_SINF:
 854     case BUILT_IN_SINL:
 855     case BUILT_IN_TAN:
 856     case BUILT_IN_TANF:
 857     case BUILT_IN_TANL:
 858       return true;
 859
 860     default:
 861       break;
 862     }
 863   return false;
 864 }
 865
 866 /* Check whether we may negate an integer constant T without causing
 867    overflow.  */
 868
 869 bool
 870 may_negate_without_overflow_p (tree t)
 871 {
 872   unsigned HOST_WIDE_INT val;
 873   unsigned int prec;
 874   tree type;
 875
 876   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 877
 878   type = TREE_TYPE (t);
 879   if (TYPE_UNSIGNED (type))
 880     return false;
 881
 882   prec = TYPE_PRECISION (type);
 883   if (prec > HOST_BITS_PER_WIDE_INT)
 884     {
 885       if (TREE_INT_CST_LOW (t) != 0)
 886         return true;
 887       prec -= HOST_BITS_PER_WIDE_INT;
 888       val = TREE_INT_CST_HIGH (t);
 889     }
 890   else
 891     val = TREE_INT_CST_LOW (t);
 892   if (prec < HOST_BITS_PER_WIDE_INT)
 893     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 894   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
 895 }
 896
 897 /* Determine whether an expression T can be cheaply negated using
 898    the function negate_expr.  */
 899
 900 static bool
 901 negate_expr_p (tree t)
 902 {
 903   tree type;
 904
 905   if (t == 0)
 906     return false;
 907
 908   type = TREE_TYPE (t);
 909
 910   STRIP_SIGN_NOPS (t);
 911   switch (TREE_CODE (t))
 912     {
 913     case INTEGER_CST:
 914       if (TYPE_UNSIGNED (type) || ! flag_trapv)
 915         return true;
 916
 917       /* Check that -CST will not overflow type.  */
 918       return may_negate_without_overflow_p (t);
 919
 920     case REAL_CST:
 921     case NEGATE_EXPR:
 922       return true;
 923
 924     case COMPLEX_CST:
 925       return negate_expr_p (TREE_REALPART (t))
 926              && negate_expr_p (TREE_IMAGPART (t));
 927
 928     case PLUS_EXPR:
 929       if (FLOAT_TYPE_P (type) && !flag_unsafe_math_optimizations)
 930         return false;
 931       /* -(A + B) -> (-B) - A.  */
 932       if (negate_expr_p (TREE_OPERAND (t, 1))
 933           && reorder_operands_p (TREE_OPERAND (t, 0),
 934                                  TREE_OPERAND (t, 1)))
 935         return true;
 936       /* -(A + B) -> (-A) - B.  */
 937       return negate_expr_p (TREE_OPERAND (t, 0));
 938
 939     case MINUS_EXPR:
 940       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
 941       return (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
 942              && reorder_operands_p (TREE_OPERAND (t, 0),
 943                                     TREE_OPERAND (t, 1));
 944
 945     case MULT_EXPR:
 946       if (TYPE_UNSIGNED (TREE_TYPE (t)))
 947         break;
 948
 949       /* Fall through.  */
 950
 951     case RDIV_EXPR:
 952       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
 953         return negate_expr_p (TREE_OPERAND (t, 1))
 954                || negate_expr_p (TREE_OPERAND (t, 0));
 955       break;
 956
 957     case NOP_EXPR:
 958       /* Negate -((double)float) as (double)(-float).  */
 959       if (TREE_CODE (type) == REAL_TYPE)
 960         {
 961           tree tem = strip_float_extensions (t);
 962           if (tem != t)
 963             return negate_expr_p (tem);
 964         }
 965       break;
 966
 967     case CALL_EXPR:
 968       /* Negate -f(x) as f(-x).  */
 969       if (negate_mathfn_p (builtin_mathfn_code (t)))
 970         return negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1)));
 971       break;
 972
 973     case RSHIFT_EXPR:
 974       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 975       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 976         {
 977           tree op1 = TREE_OPERAND (t, 1);
 978           if (TREE_INT_CST_HIGH (op1) == 0
 979               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
 980                  == TREE_INT_CST_LOW (op1))
 981             return true;
 982         }
 983       break;
 984
 985     default:
 986       break;
 987     }
 988   return false;
 989 }
 990
 991 /* Given T, an expression, return the negation of T.  Allow for T to be
 992    null, in which case return null.  */
 993
 994 static tree
 995 negate_expr (tree t)
 996 {
 997   tree type;
 998   tree tem;
 999
1000   if (t == 0)
1001     return 0;
1002
1003   type = TREE_TYPE (t);
1004   STRIP_SIGN_NOPS (t);
1005
1006   switch (TREE_CODE (t))
1007     {
1008     case INTEGER_CST:
1009       tem = fold_negate_const (t, type);
1010       if (! TREE_OVERFLOW (tem)
1011           || TYPE_UNSIGNED (type)
1012           || ! flag_trapv)
1013         return tem;
1014       break;
1015
1016     case REAL_CST:
1017       tem = fold_negate_const (t, type);
1018       /* Two's complement FP formats, such as c4x, may overflow.  */
1019       if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
1020         return fold_convert (type, tem);
1021       break;
1022
1023     case COMPLEX_CST:
1024       {
1025         tree rpart = negate_expr (TREE_REALPART (t));
1026         tree ipart = negate_expr (TREE_IMAGPART (t));
1027
1028         if ((TREE_CODE (rpart) == REAL_CST
1029              && TREE_CODE (ipart) == REAL_CST)
1030             || (TREE_CODE (rpart) == INTEGER_CST
1031                 && TREE_CODE (ipart) == INTEGER_CST))
1032           return build_complex (type, rpart, ipart);
1033       }
1034       break;
1035
1036     case NEGATE_EXPR:
1037       return fold_convert (type, TREE_OPERAND (t, 0));
1038
1039     case PLUS_EXPR:
1040       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1041         {
1042           /* -(A + B) -> (-B) - A.  */
1043           if (negate_expr_p (TREE_OPERAND (t, 1))
1044               && reorder_operands_p (TREE_OPERAND (t, 0),
1045                                      TREE_OPERAND (t, 1)))
1046             {
1047               tem = negate_expr (TREE_OPERAND (t, 1));
1048               tem = fold (build2 (MINUS_EXPR, TREE_TYPE (t),
1049                                   tem, TREE_OPERAND (t, 0)));
1050               return fold_convert (type, tem);
1051             }
1052
1053           /* -(A + B) -> (-A) - B.  */
1054           if (negate_expr_p (TREE_OPERAND (t, 0)))
1055             {
1056               tem = negate_expr (TREE_OPERAND (t, 0));
1057               tem = fold (build2 (MINUS_EXPR, TREE_TYPE (t),
1058                                   tem, TREE_OPERAND (t, 1)));
1059               return fold_convert (type, tem);
1060             }
1061         }
1062       break;
1063
1064     case MINUS_EXPR:
1065       /* - (A - B) -> B - A  */
1066       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1067           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1068         return fold_convert (type,
1069                              fold (build2 (MINUS_EXPR, TREE_TYPE (t),
1070                                            TREE_OPERAND (t, 1),
1071                                            TREE_OPERAND (t, 0))));
1072       break;
1073
1074     case MULT_EXPR:
1075       if (TYPE_UNSIGNED (TREE_TYPE (t)))
1076         break;
1077
1078       /* Fall through.  */
1079
1080     case RDIV_EXPR:
1081       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
1082         {
1083           tem = TREE_OPERAND (t, 1);
1084           if (negate_expr_p (tem))
1085             return fold_convert (type,
1086                                  fold (build2 (TREE_CODE (t), TREE_TYPE (t),
1087                                                TREE_OPERAND (t, 0),
1088                                                negate_expr (tem))));
1089           tem = TREE_OPERAND (t, 0);
1090           if (negate_expr_p (tem))
1091             return fold_convert (type,
1092                                  fold (build2 (TREE_CODE (t), TREE_TYPE (t),
1093                                                negate_expr (tem),
1094                                                TREE_OPERAND (t, 1))));
1095         }
1096       break;
1097
1098     case NOP_EXPR:
1099       /* Convert -((double)float) into (double)(-float).  */
1100       if (TREE_CODE (type) == REAL_TYPE)
1101         {
1102           tem = strip_float_extensions (t);
1103           if (tem != t && negate_expr_p (tem))
1104             return fold_convert (type, negate_expr (tem));
1105         }
1106       break;
1107
1108     case CALL_EXPR:
1109       /* Negate -f(x) as f(-x).  */
1110       if (negate_mathfn_p (builtin_mathfn_code (t))
1111           && negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1))))
1112         {
1113           tree fndecl, arg, arglist;
1114
1115           fndecl = get_callee_fndecl (t);
1116           arg = negate_expr (TREE_VALUE (TREE_OPERAND (t, 1)));
1117           arglist = build_tree_list (NULL_TREE, arg);
1118           return build_function_call_expr (fndecl, arglist);
1119         }
1120       break;
1121
1122     case RSHIFT_EXPR:
1123       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1124       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1125         {
1126           tree op1 = TREE_OPERAND (t, 1);
1127           if (TREE_INT_CST_HIGH (op1) == 0
1128               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1129                  == TREE_INT_CST_LOW (op1))
1130             {
1131               tree ntype = TYPE_UNSIGNED (type)
1132                            ? lang_hooks.types.signed_type (type)
1133                            : lang_hooks.types.unsigned_type (type);
1134               tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1135               temp = fold (build2 (RSHIFT_EXPR, ntype, temp, op1));
1136               return fold_convert (type, temp);
1137             }
1138         }
1139       break;
1140
1141     default:
1142       break;
1143     }
1144
1145   tem = fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t));
1146   return fold_convert (type, tem);
1147 }
1148 \f
1149 /* Split a tree IN into a constant, literal and variable parts that could be
1150    combined with CODE to make IN.  "constant" means an expression with
1151    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1152    commutative arithmetic operation.  Store the constant part into *CONP,
1153    the literal in *LITP and return the variable part.  If a part isn't
1154    present, set it to null.  If the tree does not decompose in this way,
1155    return the entire tree as the variable part and the other parts as null.
1156
1157    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1158    case, we negate an operand that was subtracted.  Except if it is a
1159    literal for which we use *MINUS_LITP instead.
1160
1161    If NEGATE_P is true, we are negating all of IN, again except a literal
1162    for which we use *MINUS_LITP instead.
1163
1164    If IN is itself a literal or constant, return it as appropriate.
1165
1166    Note that we do not guarantee that any of the three values will be the
1167    same type as IN, but they will have the same signedness and mode.  */
1168
1169 static tree
1170 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1171             tree *minus_litp, int negate_p)
1172 {
1173   tree var = 0;
1174
1175   *conp = 0;
1176   *litp = 0;
1177   *minus_litp = 0;
1178
1179   /* Strip any conversions that don't change the machine mode or signedness.  */
1180   STRIP_SIGN_NOPS (in);
1181
1182   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
1183     *litp = in;
1184   else if (TREE_CODE (in) == code
1185            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1186                /* We can associate addition and subtraction together (even
1187                   though the C standard doesn't say so) for integers because
1188                   the value is not affected.  For reals, the value might be
1189                   affected, so we can't.  */
1190                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1191                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1192     {
1193       tree op0 = TREE_OPERAND (in, 0);
1194       tree op1 = TREE_OPERAND (in, 1);
1195       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1196       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1197
1198       /* First see if either of the operands is a literal, then a constant.  */
1199       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
1200         *litp = op0, op0 = 0;
1201       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1202         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1203
1204       if (op0 != 0 && TREE_CONSTANT (op0))
1205         *conp = op0, op0 = 0;
1206       else if (op1 != 0 && TREE_CONSTANT (op1))
1207         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1208
1209       /* If we haven't dealt with either operand, this is not a case we can
1210          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
1211       if (op0 != 0 && op1 != 0)
1212         var = in;
1213       else if (op0 != 0)
1214         var = op0;
1215       else
1216         var = op1, neg_var_p = neg1_p;
1217
1218       /* Now do any needed negations.  */
1219       if (neg_litp_p)
1220         *minus_litp = *litp, *litp = 0;
1221       if (neg_conp_p)
1222         *conp = negate_expr (*conp);
1223       if (neg_var_p)
1224         var = negate_expr (var);
1225     }
1226   else if (TREE_CONSTANT (in))
1227     *conp = in;
1228   else
1229     var = in;
1230
1231   if (negate_p)
1232     {
1233       if (*litp)
1234         *minus_litp = *litp, *litp = 0;
1235       else if (*minus_litp)
1236         *litp = *minus_litp, *minus_litp = 0;
1237       *conp = negate_expr (*conp);
1238       var = negate_expr (var);
1239     }
1240
1241   return var;
1242 }
1243
1244 /* Re-associate trees split by the above function.  T1 and T2 are either
1245    expressions to associate or null.  Return the new expression, if any.  If
1246    we build an operation, do it in TYPE and with CODE.  */
1247
1248 static tree
1249 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1250 {
1251   if (t1 == 0)
1252     return t2;
1253   else if (t2 == 0)
1254     return t1;
1255
1256   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1257      try to fold this since we will have infinite recursion.  But do
1258      deal with any NEGATE_EXPRs.  */
1259   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1260       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1261     {
1262       if (code == PLUS_EXPR)
1263         {
1264           if (TREE_CODE (t1) == NEGATE_EXPR)
1265             return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1266                            fold_convert (type, TREE_OPERAND (t1, 0)));
1267           else if (TREE_CODE (t2) == NEGATE_EXPR)
1268             return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1269                            fold_convert (type, TREE_OPERAND (t2, 0)));
1270         }
1271       return build2 (code, type, fold_convert (type, t1),
1272                      fold_convert (type, t2));
1273     }
1274
1275   return fold (build2 (code, type, fold_convert (type, t1),
1276                        fold_convert (type, t2)));
1277 }
1278 \f
1279 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1280    to produce a new constant.
1281
1282    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1283
1284 tree
1285 int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1286 {
1287   unsigned HOST_WIDE_INT int1l, int2l;
1288   HOST_WIDE_INT int1h, int2h;
1289   unsigned HOST_WIDE_INT low;
1290   HOST_WIDE_INT hi;
1291   unsigned HOST_WIDE_INT garbagel;
1292   HOST_WIDE_INT garbageh;
1293   tree t;
1294   tree type = TREE_TYPE (arg1);
1295   int uns = TYPE_UNSIGNED (type);
1296   int is_sizetype
1297     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1298   int overflow = 0;
1299   int no_overflow = 0;
1300
1301   int1l = TREE_INT_CST_LOW (arg1);
1302   int1h = TREE_INT_CST_HIGH (arg1);
1303   int2l = TREE_INT_CST_LOW (arg2);
1304   int2h = TREE_INT_CST_HIGH (arg2);
1305
1306   switch (code)
1307     {
1308     case BIT_IOR_EXPR:
1309       low = int1l | int2l, hi = int1h | int2h;
1310       break;
1311
1312     case BIT_XOR_EXPR:
1313       low = int1l ^ int2l, hi = int1h ^ int2h;
1314       break;
1315
1316     case BIT_AND_EXPR:
1317       low = int1l & int2l, hi = int1h & int2h;
1318       break;
1319
1320     case RSHIFT_EXPR:
1321       int2l = -int2l;
1322     case LSHIFT_EXPR:
1323       /* It's unclear from the C standard whether shifts can overflow.
1324          The following code ignores overflow; perhaps a C standard
1325          interpretation ruling is needed.  */
1326       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1327                      &low, &hi, !uns);
1328       no_overflow = 1;
1329       break;
1330
1331     case RROTATE_EXPR:
1332       int2l = - int2l;
1333     case LROTATE_EXPR:
1334       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1335                       &low, &hi);
1336       break;
1337
1338     case PLUS_EXPR:
1339       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1340       break;
1341
1342     case MINUS_EXPR:
1343       neg_double (int2l, int2h, &low, &hi);
1344       add_double (int1l, int1h, low, hi, &low, &hi);
1345       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1346       break;
1347
1348     case MULT_EXPR:
1349       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1350       break;
1351
1352     case TRUNC_DIV_EXPR:
1353     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1354     case EXACT_DIV_EXPR:
1355       /* This is a shortcut for a common special case.  */
1356       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1357           && ! TREE_CONSTANT_OVERFLOW (arg1)
1358           && ! TREE_CONSTANT_OVERFLOW (arg2)
1359           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1360         {
1361           if (code == CEIL_DIV_EXPR)
1362             int1l += int2l - 1;
1363
1364           low = int1l / int2l, hi = 0;
1365           break;
1366         }
1367
1368       /* ... fall through ...  */
1369
1370     case ROUND_DIV_EXPR:
1371       if (int2h == 0 && int2l == 1)
1372         {
1373           low = int1l, hi = int1h;
1374           break;
1375         }
1376       if (int1l == int2l && int1h == int2h
1377           && ! (int1l == 0 && int1h == 0))
1378         {
1379           low = 1, hi = 0;
1380           break;
1381         }
1382       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1383                                        &low, &hi, &garbagel, &garbageh);
1384       break;
1385
1386     case TRUNC_MOD_EXPR:
1387     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1388       /* This is a shortcut for a common special case.  */
1389       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1390           && ! TREE_CONSTANT_OVERFLOW (arg1)
1391           && ! TREE_CONSTANT_OVERFLOW (arg2)
1392           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1393         {
1394           if (code == CEIL_MOD_EXPR)
1395             int1l += int2l - 1;
1396           low = int1l % int2l, hi = 0;
1397           break;
1398         }
1399
1400       /* ... fall through ...  */
1401
1402     case ROUND_MOD_EXPR:
1403       overflow = div_and_round_double (code, uns,
1404                                        int1l, int1h, int2l, int2h,
1405                                        &garbagel, &garbageh, &low, &hi);
1406       break;
1407
1408     case MIN_EXPR:
1409     case MAX_EXPR:
1410       if (uns)
1411         low = (((unsigned HOST_WIDE_INT) int1h
1412                 < (unsigned HOST_WIDE_INT) int2h)
1413                || (((unsigned HOST_WIDE_INT) int1h
1414                     == (unsigned HOST_WIDE_INT) int2h)
1415                    && int1l < int2l));
1416       else
1417         low = (int1h < int2h
1418                || (int1h == int2h && int1l < int2l));
1419
1420       if (low == (code == MIN_EXPR))
1421         low = int1l, hi = int1h;
1422       else
1423         low = int2l, hi = int2h;
1424       break;
1425
1426     default:
1427       gcc_unreachable ();
1428     }
1429
1430   t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1431
1432   if (notrunc)
1433     {
1434       /* Propagate overflow flags ourselves.  */
1435       if (((!uns || is_sizetype) && overflow)
1436           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1437         {
1438           t = copy_node (t);
1439           TREE_OVERFLOW (t) = 1;
1440           TREE_CONSTANT_OVERFLOW (t) = 1;
1441         }
1442       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1443         {
1444           t = copy_node (t);
1445           TREE_CONSTANT_OVERFLOW (t) = 1;
1446         }
1447     }
1448   else
1449     t = force_fit_type (t, 1,
1450                         ((!uns || is_sizetype) && overflow)
1451                         | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2),
1452                         TREE_CONSTANT_OVERFLOW (arg1)
1453                         | TREE_CONSTANT_OVERFLOW (arg2));
1454
1455   return t;
1456 }
1457
1458 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1459    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1460    are the same kind of constant and the same machine mode.
1461
1462    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1463
1464 static tree
1465 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1466 {
1467   STRIP_NOPS (arg1);
1468   STRIP_NOPS (arg2);
1469
1470   if (TREE_CODE (arg1) == INTEGER_CST)
1471     return int_const_binop (code, arg1, arg2, notrunc);
1472
1473   if (TREE_CODE (arg1) == REAL_CST)
1474     {
1475       enum machine_mode mode;
1476       REAL_VALUE_TYPE d1;
1477       REAL_VALUE_TYPE d2;
1478       REAL_VALUE_TYPE value;
1479       tree t, type;
1480
1481       d1 = TREE_REAL_CST (arg1);
1482       d2 = TREE_REAL_CST (arg2);
1483
1484       type = TREE_TYPE (arg1);
1485       mode = TYPE_MODE (type);
1486
1487       /* Don't perform operation if we honor signaling NaNs and
1488          either operand is a NaN.  */
1489       if (HONOR_SNANS (mode)
1490           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1491         return NULL_TREE;
1492
1493       /* Don't perform operation if it would raise a division
1494          by zero exception.  */
1495       if (code == RDIV_EXPR
1496           && REAL_VALUES_EQUAL (d2, dconst0)
1497           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1498         return NULL_TREE;
1499
1500       /* If either operand is a NaN, just return it.  Otherwise, set up
1501          for floating-point trap; we return an overflow.  */
1502       if (REAL_VALUE_ISNAN (d1))
1503         return arg1;
1504       else if (REAL_VALUE_ISNAN (d2))
1505         return arg2;
1506
1507       REAL_ARITHMETIC (value, code, d1, d2);
1508
1509       t = build_real (type, real_value_truncate (mode, value));
1510
1511       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1512       TREE_CONSTANT_OVERFLOW (t)
1513         = TREE_OVERFLOW (t)
1514           | TREE_CONSTANT_OVERFLOW (arg1)
1515           | TREE_CONSTANT_OVERFLOW (arg2);
1516       return t;
1517     }
1518   if (TREE_CODE (arg1) == COMPLEX_CST)
1519     {
1520       tree type = TREE_TYPE (arg1);
1521       tree r1 = TREE_REALPART (arg1);
1522       tree i1 = TREE_IMAGPART (arg1);
1523       tree r2 = TREE_REALPART (arg2);
1524       tree i2 = TREE_IMAGPART (arg2);
1525       tree t;
1526
1527       switch (code)
1528         {
1529         case PLUS_EXPR:
1530           t = build_complex (type,
1531                              const_binop (PLUS_EXPR, r1, r2, notrunc),
1532                              const_binop (PLUS_EXPR, i1, i2, notrunc));
1533           break;
1534
1535         case MINUS_EXPR:
1536           t = build_complex (type,
1537                              const_binop (MINUS_EXPR, r1, r2, notrunc),
1538                              const_binop (MINUS_EXPR, i1, i2, notrunc));
1539           break;
1540
1541         case MULT_EXPR:
1542           t = build_complex (type,
1543                              const_binop (MINUS_EXPR,
1544                                           const_binop (MULT_EXPR,
1545                                                        r1, r2, notrunc),
1546                                           const_binop (MULT_EXPR,
1547                                                        i1, i2, notrunc),
1548                                           notrunc),
1549                              const_binop (PLUS_EXPR,
1550                                           const_binop (MULT_EXPR,
1551                                                        r1, i2, notrunc),
1552                                           const_binop (MULT_EXPR,
1553                                                        i1, r2, notrunc),
1554                                           notrunc));
1555           break;
1556
1557         case RDIV_EXPR:
1558           {
1559             tree magsquared
1560               = const_binop (PLUS_EXPR,
1561                              const_binop (MULT_EXPR, r2, r2, notrunc),
1562                              const_binop (MULT_EXPR, i2, i2, notrunc),
1563                              notrunc);
1564
1565             t = build_complex (type,
1566                                const_binop
1567                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1568                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1569                                 const_binop (PLUS_EXPR,
1570                                              const_binop (MULT_EXPR, r1, r2,
1571                                                           notrunc),
1572                                              const_binop (MULT_EXPR, i1, i2,
1573                                                           notrunc),
1574                                              notrunc),
1575                                 magsquared, notrunc),
1576                                const_binop
1577                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1578                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1579                                 const_binop (MINUS_EXPR,
1580                                              const_binop (MULT_EXPR, i1, r2,
1581                                                           notrunc),
1582                                              const_binop (MULT_EXPR, r1, i2,
1583                                                           notrunc),
1584                                              notrunc),
1585                                 magsquared, notrunc));
1586           }
1587           break;
1588
1589         default:
1590           gcc_unreachable ();
1591         }
1592       return t;
1593     }
1594   return 0;
1595 }
1596
1597 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
1598    indicates which particular sizetype to create.  */
1599
1600 tree
1601 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1602 {
1603   return build_int_cst (sizetype_tab[(int) kind], number);
1604 }
1605 \f
1606 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1607    is a tree code.  The type of the result is taken from the operands.
1608    Both must be the same type integer type and it must be a size type.
1609    If the operands are constant, so is the result.  */
1610
1611 tree
1612 size_binop (enum tree_code code, tree arg0, tree arg1)
1613 {
1614   tree type = TREE_TYPE (arg0);
1615
1616   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1617               && type == TREE_TYPE (arg1));
1618
1619   /* Handle the special case of two integer constants faster.  */
1620   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1621     {
1622       /* And some specific cases even faster than that.  */
1623       if (code == PLUS_EXPR && integer_zerop (arg0))
1624         return arg1;
1625       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1626                && integer_zerop (arg1))
1627         return arg0;
1628       else if (code == MULT_EXPR && integer_onep (arg0))
1629         return arg1;
1630
1631       /* Handle general case of two integer constants.  */
1632       return int_const_binop (code, arg0, arg1, 0);
1633     }
1634
1635   if (arg0 == error_mark_node || arg1 == error_mark_node)
1636     return error_mark_node;
1637
1638   return fold (build2 (code, type, arg0, arg1));
1639 }
1640
1641 /* Given two values, either both of sizetype or both of bitsizetype,
1642    compute the difference between the two values.  Return the value
1643    in signed type corresponding to the type of the operands.  */
1644
1645 tree
1646 size_diffop (tree arg0, tree arg1)
1647 {
1648   tree type = TREE_TYPE (arg0);
1649   tree ctype;
1650
1651   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1652               && type == TREE_TYPE (arg1));
1653
1654   /* If the type is already signed, just do the simple thing.  */
1655   if (!TYPE_UNSIGNED (type))
1656     return size_binop (MINUS_EXPR, arg0, arg1);
1657
1658   ctype = type == bitsizetype ? sbitsizetype : ssizetype;
1659
1660   /* If either operand is not a constant, do the conversions to the signed
1661      type and subtract.  The hardware will do the right thing with any
1662      overflow in the subtraction.  */
1663   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1664     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
1665                        fold_convert (ctype, arg1));
1666
1667   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1668      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1669      overflow) and negate (which can't either).  Special-case a result
1670      of zero while we're here.  */
1671   if (tree_int_cst_equal (arg0, arg1))
1672     return fold_convert (ctype, integer_zero_node);
1673   else if (tree_int_cst_lt (arg1, arg0))
1674     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
1675   else
1676     return size_binop (MINUS_EXPR, fold_convert (ctype, integer_zero_node),
1677                        fold_convert (ctype, size_binop (MINUS_EXPR,
1678                                                         arg1, arg0)));
1679 }
1680 \f
1681 /* Construct a vector of zero elements of vector type TYPE.  */
1682
1683 static tree
1684 build_zero_vector (tree type)
1685 {
1686   tree elem, list;
1687   int i, units;
1688
1689   elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1690   units = TYPE_VECTOR_SUBPARTS (type);
1691
1692   list = NULL_TREE;
1693   for (i = 0; i < units; i++)
1694     list = tree_cons (NULL_TREE, elem, list);
1695   return build_vector (type, list);
1696 }
1697
1698
1699 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1700    type TYPE.  If no simplification can be done return NULL_TREE.  */
1701
1702 static tree
1703 fold_convert_const (enum tree_code code, tree type, tree arg1)
1704 {
1705   int overflow = 0;
1706   tree t;
1707
1708   if (TREE_TYPE (arg1) == type)
1709     return arg1;
1710
1711   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1712     {
1713       if (TREE_CODE (arg1) == INTEGER_CST)
1714         {
1715           /* If we would build a constant wider than GCC supports,
1716              leave the conversion unfolded.  */
1717           if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1718             return NULL_TREE;
1719
1720           /* Given an integer constant, make new constant with new type,
1721              appropriately sign-extended or truncated.  */
1722           t = build_int_cst_wide (type, TREE_INT_CST_LOW (arg1),
1723                                   TREE_INT_CST_HIGH (arg1));
1724
1725           t = force_fit_type (t,
1726                               /* Don't set the overflow when
1727                                  converting a pointer  */
1728                               !POINTER_TYPE_P (TREE_TYPE (arg1)),
1729                               (TREE_INT_CST_HIGH (arg1) < 0
1730                                && (TYPE_UNSIGNED (type)
1731                                    < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1732                               | TREE_OVERFLOW (arg1),
1733                               TREE_CONSTANT_OVERFLOW (arg1));
1734           return t;
1735         }
1736       else if (TREE_CODE (arg1) == REAL_CST)
1737         {
1738           /* The following code implements the floating point to integer
1739              conversion rules required by the Java Language Specification,
1740              that IEEE NaNs are mapped to zero and values that overflow
1741              the target precision saturate, i.e. values greater than
1742              INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1743              are mapped to INT_MIN.  These semantics are allowed by the
1744              C and C++ standards that simply state that the behavior of
1745              FP-to-integer conversion is unspecified upon overflow.  */
1746
1747           HOST_WIDE_INT high, low;
1748           REAL_VALUE_TYPE r;
1749           REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1750
1751           switch (code)
1752             {
1753             case FIX_TRUNC_EXPR:
1754               real_trunc (&r, VOIDmode, &x);
1755               break;
1756
1757             case FIX_CEIL_EXPR:
1758               real_ceil (&r, VOIDmode, &x);
1759               break;
1760
1761             case FIX_FLOOR_EXPR:
1762               real_floor (&r, VOIDmode, &x);
1763               break;
1764
1765             case FIX_ROUND_EXPR:
1766               real_round (&r, VOIDmode, &x);
1767               break;
1768
1769             default:
1770               gcc_unreachable ();
1771             }
1772
1773           /* If R is NaN, return zero and show we have an overflow.  */
1774           if (REAL_VALUE_ISNAN (r))
1775             {
1776               overflow = 1;
1777               high = 0;
1778               low = 0;
1779             }
1780
1781           /* See if R is less than the lower bound or greater than the
1782              upper bound.  */
1783
1784           if (! overflow)
1785             {
1786               tree lt = TYPE_MIN_VALUE (type);
1787               REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1788               if (REAL_VALUES_LESS (r, l))
1789                 {
1790                   overflow = 1;
1791                   high = TREE_INT_CST_HIGH (lt);
1792                   low = TREE_INT_CST_LOW (lt);
1793                 }
1794             }
1795
1796           if (! overflow)
1797             {
1798               tree ut = TYPE_MAX_VALUE (type);
1799               if (ut)
1800                 {
1801                   REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1802                   if (REAL_VALUES_LESS (u, r))
1803                     {
1804                       overflow = 1;
1805                       high = TREE_INT_CST_HIGH (ut);
1806                       low = TREE_INT_CST_LOW (ut);
1807                     }
1808                 }
1809             }
1810
1811           if (! overflow)
1812             REAL_VALUE_TO_INT (&low, &high, r);
1813
1814           t = build_int_cst_wide (type, low, high);
1815
1816           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg1),
1817                               TREE_CONSTANT_OVERFLOW (arg1));
1818           return t;
1819         }
1820     }
1821   else if (TREE_CODE (type) == REAL_TYPE)
1822     {
1823       if (TREE_CODE (arg1) == INTEGER_CST)
1824         return build_real_from_int_cst (type, arg1);
1825       if (TREE_CODE (arg1) == REAL_CST)
1826         {
1827           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
1828             {
1829               /* We make a copy of ARG1 so that we don't modify an
1830                  existing constant tree.  */
1831               t = copy_node (arg1);
1832               TREE_TYPE (t) = type;
1833               return t;
1834             }
1835
1836           t = build_real (type,
1837                           real_value_truncate (TYPE_MODE (type),
1838                                                TREE_REAL_CST (arg1)));
1839
1840           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1841           TREE_CONSTANT_OVERFLOW (t)
1842             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1843           return t;
1844         }
1845     }
1846   return NULL_TREE;
1847 }
1848
1849 /* Convert expression ARG to type TYPE.  Used by the middle-end for
1850    simple conversions in preference to calling the front-end's convert.  */
1851
1852 tree
1853 fold_convert (tree type, tree arg)
1854 {
1855   tree orig = TREE_TYPE (arg);
1856   tree tem;
1857
1858   if (type == orig)
1859     return arg;
1860
1861   if (TREE_CODE (arg) == ERROR_MARK
1862       || TREE_CODE (type) == ERROR_MARK
1863       || TREE_CODE (orig) == ERROR_MARK)
1864     return error_mark_node;
1865
1866   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig)
1867       || lang_hooks.types_compatible_p (TYPE_MAIN_VARIANT (type),
1868                                         TYPE_MAIN_VARIANT (orig)))
1869     return fold (build1 (NOP_EXPR, type, arg));
1870
1871   switch (TREE_CODE (type))
1872     {
1873     case INTEGER_TYPE: case CHAR_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1874     case POINTER_TYPE: case REFERENCE_TYPE:
1875     case OFFSET_TYPE:
1876       if (TREE_CODE (arg) == INTEGER_CST)
1877         {
1878           tem = fold_convert_const (NOP_EXPR, type, arg);
1879           if (tem != NULL_TREE)
1880             return tem;
1881         }
1882       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1883           || TREE_CODE (orig) == OFFSET_TYPE)
1884         return fold (build1 (NOP_EXPR, type, arg));
1885       if (TREE_CODE (orig) == COMPLEX_TYPE)
1886         {
1887           tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1888           return fold_convert (type, tem);
1889         }
1890       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
1891                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1892       return fold (build1 (NOP_EXPR, type, arg));
1893
1894     case REAL_TYPE:
1895       if (TREE_CODE (arg) == INTEGER_CST)
1896         {
1897           tem = fold_convert_const (FLOAT_EXPR, type, arg);
1898           if (tem != NULL_TREE)
1899             return tem;
1900         }
1901       else if (TREE_CODE (arg) == REAL_CST)
1902         {
1903           tem = fold_convert_const (NOP_EXPR, type, arg);
1904           if (tem != NULL_TREE)
1905             return tem;
1906         }
1907
1908       switch (TREE_CODE (orig))
1909         {
1910         case INTEGER_TYPE: case CHAR_TYPE:
1911         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1912         case POINTER_TYPE: case REFERENCE_TYPE:
1913           return fold (build1 (FLOAT_EXPR, type, arg));
1914
1915         case REAL_TYPE:
1916           return fold (build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
1917                                type, arg));
1918
1919         case COMPLEX_TYPE:
1920           tem = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1921           return fold_convert (type, tem);
1922
1923         default:
1924           gcc_unreachable ();
1925         }
1926
1927     case COMPLEX_TYPE:
1928       switch (TREE_CODE (orig))
1929         {
1930         case INTEGER_TYPE: case CHAR_TYPE:
1931         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1932         case POINTER_TYPE: case REFERENCE_TYPE:
1933         case REAL_TYPE:
1934           return build2 (COMPLEX_EXPR, type,
1935                          fold_convert (TREE_TYPE (type), arg),
1936                          fold_convert (TREE_TYPE (type), integer_zero_node));
1937         case COMPLEX_TYPE:
1938           {
1939             tree rpart, ipart;
1940
1941             if (TREE_CODE (arg) == COMPLEX_EXPR)
1942               {
1943                 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
1944                 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
1945                 return fold (build2 (COMPLEX_EXPR, type, rpart, ipart));
1946               }
1947
1948             arg = save_expr (arg);
1949             rpart = fold (build1 (REALPART_EXPR, TREE_TYPE (orig), arg));
1950             ipart = fold (build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg));
1951             rpart = fold_convert (TREE_TYPE (type), rpart);
1952             ipart = fold_convert (TREE_TYPE (type), ipart);
1953             return fold (build2 (COMPLEX_EXPR, type, rpart, ipart));
1954           }
1955
1956         default:
1957           gcc_unreachable ();
1958         }
1959
1960     case VECTOR_TYPE:
1961       if (integer_zerop (arg))
1962         return build_zero_vector (type);
1963       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1964       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1965                   || TREE_CODE (orig) == VECTOR_TYPE);
1966       return fold (build1 (NOP_EXPR, type, arg));
1967
1968     case VOID_TYPE:
1969       return fold (build1 (CONVERT_EXPR, type, fold_ignored_result (arg)));
1970
1971     default:
1972       gcc_unreachable ();
1973     }
1974 }
1975 \f
1976 /* Return an expr equal to X but certainly not valid as an lvalue.  */
1977
1978 tree
1979 non_lvalue (tree x)
1980 {
1981   /* We only need to wrap lvalue tree codes.  */
1982   switch (TREE_CODE (x))
1983   {
1984   case VAR_DECL:
1985   case PARM_DECL:
1986   case RESULT_DECL:
1987   case LABEL_DECL:
1988   case FUNCTION_DECL:
1989   case SSA_NAME:
1990
1991   case COMPONENT_REF:
1992   case INDIRECT_REF:
1993   case ARRAY_REF:
1994   case ARRAY_RANGE_REF:
1995   case BIT_FIELD_REF:
1996   case OBJ_TYPE_REF:
1997
1998   case REALPART_EXPR:
1999   case IMAGPART_EXPR:
2000   case PREINCREMENT_EXPR:
2001   case PREDECREMENT_EXPR:
2002   case SAVE_EXPR:
2003   case TRY_CATCH_EXPR:
2004   case WITH_CLEANUP_EXPR:
2005   case COMPOUND_EXPR:
2006   case MODIFY_EXPR:
2007   case TARGET_EXPR:
2008   case COND_EXPR:
2009   case BIND_EXPR:
2010   case MIN_EXPR:
2011   case MAX_EXPR:
2012     break;
2013
2014   default:
2015     /* Assume the worst for front-end tree codes.  */
2016     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2017       break;
2018     return x;
2019   }
2020   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2021 }
2022
2023 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2024    Zero means allow extended lvalues.  */
2025
2026 int pedantic_lvalues;
2027
2028 /* When pedantic, return an expr equal to X but certainly not valid as a
2029    pedantic lvalue.  Otherwise, return X.  */
2030
2031 tree
2032 pedantic_non_lvalue (tree x)
2033 {
2034   if (pedantic_lvalues)
2035     return non_lvalue (x);
2036   else
2037     return x;
2038 }
2039 \f
2040 /* Given a tree comparison code, return the code that is the logical inverse
2041    of the given code.  It is not safe to do this for floating-point
2042    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2043    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2044
2045 static enum tree_code
2046 invert_tree_comparison (enum tree_code code, bool honor_nans)
2047 {
2048   if (honor_nans && flag_trapping_math)
2049     return ERROR_MARK;
2050
2051   switch (code)
2052     {
2053     case EQ_EXPR:
2054       return NE_EXPR;
2055     case NE_EXPR:
2056       return EQ_EXPR;
2057     case GT_EXPR:
2058       return honor_nans ? UNLE_EXPR : LE_EXPR;
2059     case GE_EXPR:
2060       return honor_nans ? UNLT_EXPR : LT_EXPR;
2061     case LT_EXPR:
2062       return honor_nans ? UNGE_EXPR : GE_EXPR;
2063     case LE_EXPR:
2064       return honor_nans ? UNGT_EXPR : GT_EXPR;
2065     case LTGT_EXPR:
2066       return UNEQ_EXPR;
2067     case UNEQ_EXPR:
2068       return LTGT_EXPR;
2069     case UNGT_EXPR:
2070       return LE_EXPR;
2071     case UNGE_EXPR:
2072       return LT_EXPR;
2073     case UNLT_EXPR:
2074       return GE_EXPR;
2075     case UNLE_EXPR:
2076       return GT_EXPR;
2077     case ORDERED_EXPR:
2078       return UNORDERED_EXPR;
2079     case UNORDERED_EXPR:
2080       return ORDERED_EXPR;
2081     default:
2082       gcc_unreachable ();
2083     }
2084 }
2085
2086 /* Similar, but return the comparison that results if the operands are
2087    swapped.  This is safe for floating-point.  */
2088
2089 enum tree_code
2090 swap_tree_comparison (enum tree_code code)
2091 {
2092   switch (code)
2093     {
2094     case EQ_EXPR:
2095     case NE_EXPR:
2096       return code;
2097     case GT_EXPR:
2098       return LT_EXPR;
2099     case GE_EXPR:
2100       return LE_EXPR;
2101     case LT_EXPR:
2102       return GT_EXPR;
2103     case LE_EXPR:
2104       return GE_EXPR;
2105     default:
2106       gcc_unreachable ();
2107     }
2108 }
2109
2110
2111 /* Convert a comparison tree code from an enum tree_code representation
2112    into a compcode bit-based encoding.  This function is the inverse of
2113    compcode_to_comparison.  */
2114
2115 static enum comparison_code
2116 comparison_to_compcode (enum tree_code code)
2117 {
2118   switch (code)
2119     {
2120     case LT_EXPR:
2121       return COMPCODE_LT;
2122     case EQ_EXPR:
2123       return COMPCODE_EQ;
2124     case LE_EXPR:
2125       return COMPCODE_LE;
2126     case GT_EXPR:
2127       return COMPCODE_GT;
2128     case NE_EXPR:
2129       return COMPCODE_NE;
2130     case GE_EXPR:
2131       return COMPCODE_GE;
2132     case ORDERED_EXPR:
2133       return COMPCODE_ORD;
2134     case UNORDERED_EXPR:
2135       return COMPCODE_UNORD;
2136     case UNLT_EXPR:
2137       return COMPCODE_UNLT;
2138     case UNEQ_EXPR:
2139       return COMPCODE_UNEQ;
2140     case UNLE_EXPR:
2141       return COMPCODE_UNLE;
2142     case UNGT_EXPR:
2143       return COMPCODE_UNGT;
2144     case LTGT_EXPR:
2145       return COMPCODE_LTGT;
2146     case UNGE_EXPR:
2147       return COMPCODE_UNGE;
2148     default:
2149       gcc_unreachable ();
2150     }
2151 }
2152
2153 /* Convert a compcode bit-based encoding of a comparison operator back
2154    to GCC's enum tree_code representation.  This function is the
2155    inverse of comparison_to_compcode.  */
2156
2157 static enum tree_code
2158 compcode_to_comparison (enum comparison_code code)
2159 {
2160   switch (code)
2161     {
2162     case COMPCODE_LT:
2163       return LT_EXPR;
2164     case COMPCODE_EQ:
2165       return EQ_EXPR;
2166     case COMPCODE_LE:
2167       return LE_EXPR;
2168     case COMPCODE_GT:
2169       return GT_EXPR;
2170     case COMPCODE_NE:
2171       return NE_EXPR;
2172     case COMPCODE_GE:
2173       return GE_EXPR;
2174     case COMPCODE_ORD:
2175       return ORDERED_EXPR;
2176     case COMPCODE_UNORD:
2177       return UNORDERED_EXPR;
2178     case COMPCODE_UNLT:
2179       return UNLT_EXPR;
2180     case COMPCODE_UNEQ:
2181       return UNEQ_EXPR;
2182     case COMPCODE_UNLE:
2183       return UNLE_EXPR;
2184     case COMPCODE_UNGT:
2185       return UNGT_EXPR;
2186     case COMPCODE_LTGT:
2187       return LTGT_EXPR;
2188     case COMPCODE_UNGE:
2189       return UNGE_EXPR;
2190     default:
2191       gcc_unreachable ();
2192     }
2193 }
2194
2195 /* Return a tree for the comparison which is the combination of
2196    doing the AND or OR (depending on CODE) of the two operations LCODE
2197    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2198    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2199    if this makes the transformation invalid.  */
2200
2201 tree
2202 combine_comparisons (enum tree_code code, enum tree_code lcode,
2203                      enum tree_code rcode, tree truth_type,
2204                      tree ll_arg, tree lr_arg)
2205 {
2206   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2207   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2208   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2209   enum comparison_code compcode;
2210
2211   switch (code)
2212     {
2213     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2214       compcode = lcompcode & rcompcode;
2215       break;
2216
2217     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2218       compcode = lcompcode | rcompcode;
2219       break;
2220
2221     default:
2222       return NULL_TREE;
2223     }
2224
2225   if (!honor_nans)
2226     {
2227       /* Eliminate unordered comparisons, as well as LTGT and ORD
2228          which are not used unless the mode has NaNs.  */
2229       compcode &= ~COMPCODE_UNORD;
2230       if (compcode == COMPCODE_LTGT)
2231         compcode = COMPCODE_NE;
2232       else if (compcode == COMPCODE_ORD)
2233         compcode = COMPCODE_TRUE;
2234     }
2235    else if (flag_trapping_math)
2236      {
2237         /* Check that the original operation and the optimized ones will trap
2238            under the same condition.  */
2239         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2240                      && (lcompcode != COMPCODE_EQ)
2241                      && (lcompcode != COMPCODE_ORD);
2242         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2243                      && (rcompcode != COMPCODE_EQ)
2244                      && (rcompcode != COMPCODE_ORD);
2245         bool trap = (compcode & COMPCODE_UNORD) == 0
2246                     && (compcode != COMPCODE_EQ)
2247                     && (compcode != COMPCODE_ORD);
2248
2249         /* In a short-circuited boolean expression the LHS might be
2250            such that the RHS, if evaluated, will never trap.  For
2251            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2252            if neither x nor y is NaN.  (This is a mixed blessing: for
2253            example, the expression above will never trap, hence
2254            optimizing it to x < y would be invalid).  */
2255         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2256             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2257           rtrap = false;
2258
2259         /* If the comparison was short-circuited, and only the RHS
2260            trapped, we may now generate a spurious trap.  */
2261         if (rtrap && !ltrap
2262             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2263           return NULL_TREE;
2264
2265         /* If we changed the conditions that cause a trap, we lose.  */
2266         if ((ltrap || rtrap) != trap)
2267           return NULL_TREE;
2268       }
2269
2270   if (compcode == COMPCODE_TRUE)
2271     return constant_boolean_node (true, truth_type);
2272   else if (compcode == COMPCODE_FALSE)
2273     return constant_boolean_node (false, truth_type);
2274   else
2275     return fold (build2 (compcode_to_comparison (compcode),
2276                          truth_type, ll_arg, lr_arg));
2277 }
2278
2279 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2280
2281 static int
2282 truth_value_p (enum tree_code code)
2283 {
2284   return (TREE_CODE_CLASS (code) == '<'
2285           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2286           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2287           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2288 }
2289 \f
2290 /* Return nonzero if two operands (typically of the same tree node)
2291    are necessarily equal.  If either argument has side-effects this
2292    function returns zero.  FLAGS modifies behavior as follows:
2293
2294    If OEP_ONLY_CONST is set, only return nonzero for constants.
2295    This function tests whether the operands are indistinguishable;
2296    it does not test whether they are equal using C's == operation.
2297    The distinction is important for IEEE floating point, because
2298    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2299    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2300
2301    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2302    even though it may hold multiple values during a function.
2303    This is because a GCC tree node guarantees that nothing else is
2304    executed between the evaluation of its "operands" (which may often
2305    be evaluated in arbitrary order).  Hence if the operands themselves
2306    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2307    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2308    unset means assuming isochronic (or instantaneous) tree equivalence.
2309    Unless comparing arbitrary expression trees, such as from different
2310    statements, this flag can usually be left unset.
2311
2312    If OEP_PURE_SAME is set, then pure functions with identical arguments
2313    are considered the same.  It is used when the caller has other ways
2314    to ensure that global memory is unchanged in between.  */
2315
2316 int
2317 operand_equal_p (tree arg0, tree arg1, unsigned int flags)
2318 {
2319   /* If one is specified and the other isn't, they aren't equal and if
2320      neither is specified, they are.
2321
2322      ??? This is temporary and is meant only to handle the cases of the
2323      optional operands for COMPONENT_REF and ARRAY_REF.  */
2324   if ((arg0 && !arg1) || (!arg0 && arg1))
2325     return 0;
2326   else if (!arg0 && !arg1)
2327     return 1;
2328   /* If either is ERROR_MARK, they aren't equal.  */
2329   else if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
2330     return 0;
2331
2332   /* If both types don't have the same signedness, then we can't consider
2333      them equal.  We must check this before the STRIP_NOPS calls
2334      because they may change the signedness of the arguments.  */
2335   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2336     return 0;
2337
2338   STRIP_NOPS (arg0);
2339   STRIP_NOPS (arg1);
2340
2341   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2342       /* This is needed for conversions and for COMPONENT_REF.
2343          Might as well play it safe and always test this.  */
2344       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2345       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2346       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2347     return 0;
2348
2349   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2350      We don't care about side effects in that case because the SAVE_EXPR
2351      takes care of that for us. In all other cases, two expressions are
2352      equal if they have no side effects.  If we have two identical
2353      expressions with side effects that should be treated the same due
2354      to the only side effects being identical SAVE_EXPR's, that will
2355      be detected in the recursive calls below.  */
2356   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2357       && (TREE_CODE (arg0) == SAVE_EXPR
2358           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2359     return 1;
2360
2361   /* Next handle constant cases, those for which we can return 1 even
2362      if ONLY_CONST is set.  */
2363   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2364     switch (TREE_CODE (arg0))
2365       {
2366       case INTEGER_CST:
2367         return (! TREE_CONSTANT_OVERFLOW (arg0)
2368                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2369                 && tree_int_cst_equal (arg0, arg1));
2370
2371       case REAL_CST:
2372         return (! TREE_CONSTANT_OVERFLOW (arg0)
2373                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2374                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2375                                           TREE_REAL_CST (arg1)));
2376
2377       case VECTOR_CST:
2378         {
2379           tree v1, v2;
2380
2381           if (TREE_CONSTANT_OVERFLOW (arg0)
2382               || TREE_CONSTANT_OVERFLOW (arg1))
2383             return 0;
2384
2385           v1 = TREE_VECTOR_CST_ELTS (arg0);
2386           v2 = TREE_VECTOR_CST_ELTS (arg1);
2387           while (v1 && v2)
2388             {
2389               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2390                                     flags))
2391                 return 0;
2392               v1 = TREE_CHAIN (v1);
2393               v2 = TREE_CHAIN (v2);
2394             }
2395
2396           return 1;
2397         }
2398
2399       case COMPLEX_CST:
2400         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2401                                  flags)
2402                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2403                                     flags));
2404
2405       case STRING_CST:
2406         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2407                 && ! memcmp (TREE_STRING_POINTER (arg0),
2408                               TREE_STRING_POINTER (arg1),
2409                               TREE_STRING_LENGTH (arg0)));
2410
2411       case ADDR_EXPR:
2412         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2413                                 0);
2414       default:
2415         break;
2416       }
2417
2418   if (flags & OEP_ONLY_CONST)
2419     return 0;
2420
2421   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2422     {
2423     case '1':
2424       /* Two conversions are equal only if signedness and modes match.  */
2425       switch (TREE_CODE (arg0))
2426         {
2427         case NOP_EXPR:
2428         case CONVERT_EXPR:
2429         case FIX_CEIL_EXPR:
2430         case FIX_TRUNC_EXPR:
2431         case FIX_FLOOR_EXPR:
2432         case FIX_ROUND_EXPR:
2433           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2434               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2435             return 0;
2436           break;
2437         default:
2438           break;
2439         }
2440
2441       return operand_equal_p (TREE_OPERAND (arg0, 0),
2442                               TREE_OPERAND (arg1, 0), flags);
2443
2444     case '<':
2445     case '2':
2446       if (operand_equal_p (TREE_OPERAND (arg0, 0),
2447                            TREE_OPERAND (arg1, 0), flags)
2448           && operand_equal_p (TREE_OPERAND (arg0, 1),
2449                               TREE_OPERAND (arg1, 1), flags))
2450         return 1;
2451
2452       /* For commutative ops, allow the other order.  */
2453       return (commutative_tree_code (TREE_CODE (arg0))
2454               && operand_equal_p (TREE_OPERAND (arg0, 0),
2455                                   TREE_OPERAND (arg1, 1), flags)
2456               && operand_equal_p (TREE_OPERAND (arg0, 1),
2457                                   TREE_OPERAND (arg1, 0), flags));
2458
2459     case 'r':
2460       /* If either of the pointer (or reference) expressions we are
2461          dereferencing contain a side effect, these cannot be equal.  */
2462       if (TREE_SIDE_EFFECTS (arg0)
2463           || TREE_SIDE_EFFECTS (arg1))
2464         return 0;
2465
2466       switch (TREE_CODE (arg0))
2467         {
2468         case INDIRECT_REF:
2469         case REALPART_EXPR:
2470         case IMAGPART_EXPR:
2471           return operand_equal_p (TREE_OPERAND (arg0, 0),
2472                                   TREE_OPERAND (arg1, 0), flags);
2473
2474         case ARRAY_REF:
2475         case ARRAY_RANGE_REF:
2476           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2477                                    TREE_OPERAND (arg1, 0), flags)
2478                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2479                                       TREE_OPERAND (arg1, 1), flags)
2480                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2481                                       TREE_OPERAND (arg1, 2), flags)
2482                   && operand_equal_p (TREE_OPERAND (arg0, 3),
2483                                       TREE_OPERAND (arg1, 3), flags));
2484
2485
2486         case COMPONENT_REF:
2487           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2488                                    TREE_OPERAND (arg1, 0), flags)
2489                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2490                                       TREE_OPERAND (arg1, 1), flags)
2491                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2492                                       TREE_OPERAND (arg1, 2), flags));
2493
2494
2495         case BIT_FIELD_REF:
2496           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2497                                    TREE_OPERAND (arg1, 0), flags)
2498                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2499                                       TREE_OPERAND (arg1, 1), flags)
2500                   && operand_equal_p (TREE_OPERAND (arg0, 2),
2501                                       TREE_OPERAND (arg1, 2), flags));
2502         default:
2503           return 0;
2504         }
2505
2506     case 'e':
2507       switch (TREE_CODE (arg0))
2508         {
2509         case ADDR_EXPR:
2510         case TRUTH_NOT_EXPR:
2511           return operand_equal_p (TREE_OPERAND (arg0, 0),
2512                                   TREE_OPERAND (arg1, 0), flags);
2513
2514         case TRUTH_ANDIF_EXPR:
2515         case TRUTH_ORIF_EXPR:
2516           return operand_equal_p (TREE_OPERAND (arg0, 0),
2517                                   TREE_OPERAND (arg1, 0), flags)
2518                  && operand_equal_p (TREE_OPERAND (arg0, 1),
2519                                      TREE_OPERAND (arg1, 1), flags);
2520
2521         case TRUTH_AND_EXPR:
2522         case TRUTH_OR_EXPR:
2523         case TRUTH_XOR_EXPR:
2524           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2525                                    TREE_OPERAND (arg1, 0), flags)
2526                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2527                                       TREE_OPERAND (arg1, 1), flags))
2528                  || (operand_equal_p (TREE_OPERAND (arg0, 0),
2529                                       TREE_OPERAND (arg1, 1), flags)
2530                      && operand_equal_p (TREE_OPERAND (arg0, 1),
2531                                          TREE_OPERAND (arg1, 0), flags));
2532
2533         case CALL_EXPR:
2534           /* If the CALL_EXPRs call different functions, then they
2535              clearly can not be equal.  */
2536           if (! operand_equal_p (TREE_OPERAND (arg0, 0),
2537                                  TREE_OPERAND (arg1, 0), flags))
2538             return 0;
2539
2540           {
2541             unsigned int cef = call_expr_flags (arg0);
2542             if (flags & OEP_PURE_SAME)
2543               cef &= ECF_CONST | ECF_PURE;
2544             else
2545               cef &= ECF_CONST;
2546             if (!cef)
2547               return 0;
2548           }
2549
2550           /* Now see if all the arguments are the same.  operand_equal_p
2551              does not handle TREE_LIST, so we walk the operands here
2552              feeding them to operand_equal_p.  */
2553           arg0 = TREE_OPERAND (arg0, 1);
2554           arg1 = TREE_OPERAND (arg1, 1);
2555           while (arg0 && arg1)
2556             {
2557               if (! operand_equal_p (TREE_VALUE (arg0), TREE_VALUE (arg1),
2558                                      flags))
2559                 return 0;
2560
2561               arg0 = TREE_CHAIN (arg0);
2562               arg1 = TREE_CHAIN (arg1);
2563             }
2564
2565           /* If we get here and both argument lists are exhausted
2566              then the CALL_EXPRs are equal.  */
2567           return ! (arg0 || arg1);
2568
2569         default:
2570           return 0;
2571         }
2572
2573     case 'd':
2574       /* Consider __builtin_sqrt equal to sqrt.  */
2575       return (TREE_CODE (arg0) == FUNCTION_DECL
2576               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2577               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2578               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2579
2580     default:
2581       return 0;
2582     }
2583 }
2584 \f
2585 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2586    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2587
2588    When in doubt, return 0.  */
2589
2590 static int
2591 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2592 {
2593   int unsignedp1, unsignedpo;
2594   tree primarg0, primarg1, primother;
2595   unsigned int correct_width;
2596
2597   if (operand_equal_p (arg0, arg1, 0))
2598     return 1;
2599
2600   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2601       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2602     return 0;
2603
2604   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2605      and see if the inner values are the same.  This removes any
2606      signedness comparison, which doesn't matter here.  */
2607   primarg0 = arg0, primarg1 = arg1;
2608   STRIP_NOPS (primarg0);
2609   STRIP_NOPS (primarg1);
2610   if (operand_equal_p (primarg0, primarg1, 0))
2611     return 1;
2612
2613   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2614      actual comparison operand, ARG0.
2615
2616      First throw away any conversions to wider types
2617      already present in the operands.  */
2618
2619   primarg1 = get_narrower (arg1, &unsignedp1);
2620   primother = get_narrower (other, &unsignedpo);
2621
2622   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2623   if (unsignedp1 == unsignedpo
2624       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2625       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2626     {
2627       tree type = TREE_TYPE (arg0);
2628
2629       /* Make sure shorter operand is extended the right way
2630          to match the longer operand.  */
2631       primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
2632                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2633
2634       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2635         return 1;
2636     }
2637
2638   return 0;
2639 }
2640 \f
2641 /* See if ARG is an expression that is either a comparison or is performing
2642    arithmetic on comparisons.  The comparisons must only be comparing
2643    two different values, which will be stored in *CVAL1 and *CVAL2; if
2644    they are nonzero it means that some operands have already been found.
2645    No variables may be used anywhere else in the expression except in the
2646    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2647    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2648
2649    If this is true, return 1.  Otherwise, return zero.  */
2650
2651 static int
2652 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2653 {
2654   enum tree_code code = TREE_CODE (arg);
2655   char class = TREE_CODE_CLASS (code);
2656
2657   /* We can handle some of the 'e' cases here.  */
2658   if (class == 'e' && code == TRUTH_NOT_EXPR)
2659     class = '1';
2660   else if (class == 'e'
2661            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2662                || code == COMPOUND_EXPR))
2663     class = '2';
2664
2665   else if (class == 'e' && code == SAVE_EXPR
2666            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2667     {
2668       /* If we've already found a CVAL1 or CVAL2, this expression is
2669          two complex to handle.  */
2670       if (*cval1 || *cval2)
2671         return 0;
2672
2673       class = '1';
2674       *save_p = 1;
2675     }
2676
2677   switch (class)
2678     {
2679     case '1':
2680       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2681
2682     case '2':
2683       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2684               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2685                                       cval1, cval2, save_p));
2686
2687     case 'c':
2688       return 1;
2689
2690     case 'e':
2691       if (code == COND_EXPR)
2692         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2693                                      cval1, cval2, save_p)
2694                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2695                                         cval1, cval2, save_p)
2696                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2697                                         cval1, cval2, save_p));
2698       return 0;
2699
2700     case '<':
2701       /* First see if we can handle the first operand, then the second.  For
2702          the second operand, we know *CVAL1 can't be zero.  It must be that
2703          one side of the comparison is each of the values; test for the
2704          case where this isn't true by failing if the two operands
2705          are the same.  */
2706
2707       if (operand_equal_p (TREE_OPERAND (arg, 0),
2708                            TREE_OPERAND (arg, 1), 0))
2709         return 0;
2710
2711       if (*cval1 == 0)
2712         *cval1 = TREE_OPERAND (arg, 0);
2713       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2714         ;
2715       else if (*cval2 == 0)
2716         *cval2 = TREE_OPERAND (arg, 0);
2717       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2718         ;
2719       else
2720         return 0;
2721
2722       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2723         ;
2724       else if (*cval2 == 0)
2725         *cval2 = TREE_OPERAND (arg, 1);
2726       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2727         ;
2728       else
2729         return 0;
2730
2731       return 1;
2732
2733     default:
2734       return 0;
2735     }
2736 }
2737 \f
2738 /* ARG is a tree that is known to contain just arithmetic operations and
2739    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2740    any occurrence of OLD0 as an operand of a comparison and likewise for
2741    NEW1 and OLD1.  */
2742
2743 static tree
2744 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
2745 {
2746   tree type = TREE_TYPE (arg);
2747   enum tree_code code = TREE_CODE (arg);
2748   char class = TREE_CODE_CLASS (code);
2749
2750   /* We can handle some of the 'e' cases here.  */
2751   if (class == 'e' && code == TRUTH_NOT_EXPR)
2752     class = '1';
2753   else if (class == 'e'
2754            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2755     class = '2';
2756
2757   switch (class)
2758     {
2759     case '1':
2760       return fold (build1 (code, type,
2761                            eval_subst (TREE_OPERAND (arg, 0),
2762                                        old0, new0, old1, new1)));
2763
2764     case '2':
2765       return fold (build2 (code, type,
2766                            eval_subst (TREE_OPERAND (arg, 0),
2767                                        old0, new0, old1, new1),
2768                            eval_subst (TREE_OPERAND (arg, 1),
2769                                        old0, new0, old1, new1)));
2770
2771     case 'e':
2772       switch (code)
2773         {
2774         case SAVE_EXPR:
2775           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2776
2777         case COMPOUND_EXPR:
2778           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2779
2780         case COND_EXPR:
2781           return fold (build3 (code, type,
2782                                eval_subst (TREE_OPERAND (arg, 0),
2783                                            old0, new0, old1, new1),
2784                                eval_subst (TREE_OPERAND (arg, 1),
2785                                            old0, new0, old1, new1),
2786                                eval_subst (TREE_OPERAND (arg, 2),
2787                                            old0, new0, old1, new1)));
2788         default:
2789           break;
2790         }
2791       /* Fall through - ???  */
2792
2793     case '<':
2794       {
2795         tree arg0 = TREE_OPERAND (arg, 0);
2796         tree arg1 = TREE_OPERAND (arg, 1);
2797
2798         /* We need to check both for exact equality and tree equality.  The
2799            former will be true if the operand has a side-effect.  In that
2800            case, we know the operand occurred exactly once.  */
2801
2802         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2803           arg0 = new0;
2804         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2805           arg0 = new1;
2806
2807         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2808           arg1 = new0;
2809         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2810           arg1 = new1;
2811
2812         return fold (build2 (code, type, arg0, arg1));
2813       }
2814
2815     default:
2816       return arg;
2817     }
2818 }
2819 \f
2820 /* Return a tree for the case when the result of an expression is RESULT
2821    converted to TYPE and OMITTED was previously an operand of the expression
2822    but is now not needed (e.g., we folded OMITTED * 0).
2823
2824    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2825    the conversion of RESULT to TYPE.  */
2826
2827 tree
2828 omit_one_operand (tree type, tree result, tree omitted)
2829 {
2830   tree t = fold_convert (type, result);
2831
2832   if (TREE_SIDE_EFFECTS (omitted))
2833     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
2834
2835   return non_lvalue (t);
2836 }
2837
2838 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2839
2840 static tree
2841 pedantic_omit_one_operand (tree type, tree result, tree omitted)
2842 {
2843   tree t = fold_convert (type, result);
2844
2845   if (TREE_SIDE_EFFECTS (omitted))
2846     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
2847
2848   return pedantic_non_lvalue (t);
2849 }
2850
2851 /* Return a tree for the case when the result of an expression is RESULT
2852    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
2853    of the expression but are now not needed.
2854
2855    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
2856    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
2857    evaluated before OMITTED2.  Otherwise, if neither has side effects,
2858    just do the conversion of RESULT to TYPE.  */
2859
2860 tree
2861 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
2862 {
2863   tree t = fold_convert (type, result);
2864
2865   if (TREE_SIDE_EFFECTS (omitted2))
2866     t = build2 (COMPOUND_EXPR, type, omitted2, t);
2867   if (TREE_SIDE_EFFECTS (omitted1))
2868     t = build2 (COMPOUND_EXPR, type, omitted1, t);
2869
2870   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
2871 }
2872
2873 \f
2874 /* Return a simplified tree node for the truth-negation of ARG.  This
2875    never alters ARG itself.  We assume that ARG is an operation that
2876    returns a truth value (0 or 1).
2877
2878    FIXME: one would think we would fold the result, but it causes
2879    problems with the dominator optimizer.  */
2880 tree
2881 invert_truthvalue (tree arg)
2882 {
2883   tree type = TREE_TYPE (arg);
2884   enum tree_code code = TREE_CODE (arg);
2885
2886   if (code == ERROR_MARK)
2887     return arg;
2888
2889   /* If this is a comparison, we can simply invert it, except for
2890      floating-point non-equality comparisons, in which case we just
2891      enclose a TRUTH_NOT_EXPR around what we have.  */
2892
2893   if (TREE_CODE_CLASS (code) == '<')
2894     {
2895       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
2896       if (FLOAT_TYPE_P (op_type)
2897           && flag_trapping_math
2898           && code != ORDERED_EXPR && code != UNORDERED_EXPR
2899           && code != NE_EXPR && code != EQ_EXPR)
2900         return build1 (TRUTH_NOT_EXPR, type, arg);
2901       else
2902         {
2903           code = invert_tree_comparison (code,
2904                                          HONOR_NANS (TYPE_MODE (op_type)));
2905           if (code == ERROR_MARK)
2906             return build1 (TRUTH_NOT_EXPR, type, arg);
2907           else
2908             return build2 (code, type,
2909                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2910         }
2911     }
2912
2913   switch (code)
2914     {
2915     case INTEGER_CST:
2916       return fold_convert (type,
2917                            build_int_cst (NULL_TREE, integer_zerop (arg)));
2918
2919     case TRUTH_AND_EXPR:
2920       return build2 (TRUTH_OR_EXPR, type,
2921                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2922                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2923
2924     case TRUTH_OR_EXPR:
2925       return build2 (TRUTH_AND_EXPR, type,
2926                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2927                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2928
2929     case TRUTH_XOR_EXPR:
2930       /* Here we can invert either operand.  We invert the first operand
2931          unless the second operand is a TRUTH_NOT_EXPR in which case our
2932          result is the XOR of the first operand with the inside of the
2933          negation of the second operand.  */
2934
2935       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2936         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2937                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2938       else
2939         return build2 (TRUTH_XOR_EXPR, type,
2940                        invert_truthvalue (TREE_OPERAND (arg, 0)),
2941                        TREE_OPERAND (arg, 1));
2942
2943     case TRUTH_ANDIF_EXPR:
2944       return build2 (TRUTH_ORIF_EXPR, type,
2945                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2946                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2947
2948     case TRUTH_ORIF_EXPR:
2949       return build2 (TRUTH_ANDIF_EXPR, type,
2950                      invert_truthvalue (TREE_OPERAND (arg, 0)),
2951                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2952
2953     case TRUTH_NOT_EXPR:
2954       return TREE_OPERAND (arg, 0);
2955
2956     case COND_EXPR:
2957       return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
2958                      invert_truthvalue (TREE_OPERAND (arg, 1)),
2959                      invert_truthvalue (TREE_OPERAND (arg, 2)));
2960
2961     case COMPOUND_EXPR:
2962       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2963                      invert_truthvalue (TREE_OPERAND (arg, 1)));
2964
2965     case NON_LVALUE_EXPR:
2966       return invert_truthvalue (TREE_OPERAND (arg, 0));
2967
2968     case NOP_EXPR:
2969       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2970         break;
2971
2972     case CONVERT_EXPR:
2973     case FLOAT_EXPR:
2974       return build1 (TREE_CODE (arg), type,
2975                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2976
2977     case BIT_AND_EXPR:
2978       if (!integer_onep (TREE_OPERAND (arg, 1)))
2979         break;
2980       return build2 (EQ_EXPR, type, arg,
2981                      fold_convert (type, integer_zero_node));
2982
2983     case SAVE_EXPR:
2984       return build1 (TRUTH_NOT_EXPR, type, arg);
2985
2986     case CLEANUP_POINT_EXPR:
2987       return build1 (CLEANUP_POINT_EXPR, type,
2988                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2989
2990     default:
2991       break;
2992     }
2993   gcc_assert (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE);
2994   return build1 (TRUTH_NOT_EXPR, type, arg);
2995 }
2996
2997 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2998    operands are another bit-wise operation with a common input.  If so,
2999    distribute the bit operations to save an operation and possibly two if
3000    constants are involved.  For example, convert
3001         (A | B) & (A | C) into A | (B & C)
3002    Further simplification will occur if B and C are constants.
3003
3004    If this optimization cannot be done, 0 will be returned.  */
3005
3006 static tree
3007 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3008 {
3009   tree common;
3010   tree left, right;
3011
3012   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3013       || TREE_CODE (arg0) == code
3014       || (TREE_CODE (arg0) != BIT_AND_EXPR
3015           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3016     return 0;
3017
3018   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3019     {
3020       common = TREE_OPERAND (arg0, 0);
3021       left = TREE_OPERAND (arg0, 1);
3022       right = TREE_OPERAND (arg1, 1);
3023     }
3024   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3025     {
3026       common = TREE_OPERAND (arg0, 0);
3027       left = TREE_OPERAND (arg0, 1);
3028       right = TREE_OPERAND (arg1, 0);
3029     }
3030   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3031     {
3032       common = TREE_OPERAND (arg0, 1);
3033       left = TREE_OPERAND (arg0, 0);
3034       right = TREE_OPERAND (arg1, 1);
3035     }
3036   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3037     {
3038       common = TREE_OPERAND (arg0, 1);
3039       left = TREE_OPERAND (arg0, 0);
3040       right = TREE_OPERAND (arg1, 0);
3041     }
3042   else
3043     return 0;
3044
3045   return fold (build2 (TREE_CODE (arg0), type, common,
3046                        fold (build2 (code, type, left, right))));
3047 }
3048 \f
3049 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3050    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3051
3052 static tree
3053 make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos,
3054                     int unsignedp)
3055 {
3056   tree result = build3 (BIT_FIELD_REF, type, inner,
3057                         size_int (bitsize), bitsize_int (bitpos));
3058
3059   BIT_FIELD_REF_UNSIGNED (result) = unsignedp;
3060
3061   return result;
3062 }
3063
3064 /* Optimize a bit-field compare.
3065
3066    There are two cases:  First is a compare against a constant and the
3067    second is a comparison of two items where the fields are at the same
3068    bit position relative to the start of a chunk (byte, halfword, word)
3069    large enough to contain it.  In these cases we can avoid the shift
3070    implicit in bitfield extractions.
3071
3072    For constants, we emit a compare of the shifted constant with the
3073    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3074    compared.  For two fields at the same position, we do the ANDs with the
3075    similar mask and compare the result of the ANDs.
3076
3077    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3078    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3079    are the left and right operands of the comparison, respectively.
3080
3081    If the optimization described above can be done, we return the resulting
3082    tree.  Otherwise we return zero.  */
3083
3084 static tree
3085 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3086                             tree lhs, tree rhs)
3087 {
3088   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3089   tree type = TREE_TYPE (lhs);
3090   tree signed_type, unsigned_type;
3091   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3092   enum machine_mode lmode, rmode, nmode;
3093   int lunsignedp, runsignedp;
3094   int lvolatilep = 0, rvolatilep = 0;
3095   tree linner, rinner = NULL_TREE;
3096   tree mask;
3097   tree offset;
3098
3099   /* Get all the information about the extractions being done.  If the bit size
3100      if the same as the size of the underlying object, we aren't doing an
3101      extraction at all and so can do nothing.  We also don't want to
3102      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3103      then will no longer be able to replace it.  */
3104   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3105                                 &lunsignedp, &lvolatilep);
3106   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3107       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3108     return 0;
3109
3110  if (!const_p)
3111    {
3112      /* If this is not a constant, we can only do something if bit positions,
3113         sizes, and signedness are the same.  */
3114      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3115                                    &runsignedp, &rvolatilep);
3116
3117      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3118          || lunsignedp != runsignedp || offset != 0
3119          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3120        return 0;
3121    }
3122
3123   /* See if we can find a mode to refer to this field.  We should be able to,
3124      but fail if we can't.  */
3125   nmode = get_best_mode (lbitsize, lbitpos,
3126                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3127                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3128                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3129                          word_mode, lvolatilep || rvolatilep);
3130   if (nmode == VOIDmode)
3131     return 0;
3132
3133   /* Set signed and unsigned types of the precision of this mode for the
3134      shifts below.  */
3135   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3136   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3137
3138   /* Compute the bit position and size for the new reference and our offset
3139      within it. If the new reference is the same size as the original, we
3140      won't optimize anything, so return zero.  */
3141   nbitsize = GET_MODE_BITSIZE (nmode);
3142   nbitpos = lbitpos & ~ (nbitsize - 1);
3143   lbitpos -= nbitpos;
3144   if (nbitsize == lbitsize)
3145     return 0;
3146
3147   if (BYTES_BIG_ENDIAN)
3148     lbitpos = nbitsize - lbitsize - lbitpos;
3149
3150   /* Make the mask to be used against the extracted field.  */
3151   mask = build_int_cst (unsigned_type, -1);
3152   mask = force_fit_type (mask, 0, false, false);
3153   mask = fold_convert (unsigned_type, mask);
3154   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3155   mask = const_binop (RSHIFT_EXPR, mask,
3156                       size_int (nbitsize - lbitsize - lbitpos), 0);
3157
3158   if (! const_p)
3159     /* If not comparing with constant, just rework the comparison
3160        and return.  */
3161     return build2 (code, compare_type,
3162                    build2 (BIT_AND_EXPR, unsigned_type,
3163                            make_bit_field_ref (linner, unsigned_type,
3164                                                nbitsize, nbitpos, 1),
3165                            mask),
3166                    build2 (BIT_AND_EXPR, unsigned_type,
3167                            make_bit_field_ref (rinner, unsigned_type,
3168                                                nbitsize, nbitpos, 1),
3169                            mask));
3170
3171   /* Otherwise, we are handling the constant case. See if the constant is too
3172      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3173      this not only for its own sake, but to avoid having to test for this
3174      error case below.  If we didn't, we might generate wrong code.
3175
3176      For unsigned fields, the constant shifted right by the field length should
3177      be all zero.  For signed fields, the high-order bits should agree with
3178      the sign bit.  */
3179
3180   if (lunsignedp)
3181     {
3182       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3183                                         fold_convert (unsigned_type, rhs),
3184                                         size_int (lbitsize), 0)))
3185         {
3186           warning ("comparison is always %d due to width of bit-field",
3187                    code == NE_EXPR);
3188           return constant_boolean_node (code == NE_EXPR, compare_type);
3189         }
3190     }
3191   else
3192     {
3193       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3194                               size_int (lbitsize - 1), 0);
3195       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3196         {
3197           warning ("comparison is always %d due to width of bit-field",
3198                    code == NE_EXPR);
3199           return constant_boolean_node (code == NE_EXPR, compare_type);
3200         }
3201     }
3202
3203   /* Single-bit compares should always be against zero.  */
3204   if (lbitsize == 1 && ! integer_zerop (rhs))
3205     {
3206       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3207       rhs = fold_convert (type, integer_zero_node);
3208     }
3209
3210   /* Make a new bitfield reference, shift the constant over the
3211      appropriate number of bits and mask it with the computed mask
3212      (in case this was a signed field).  If we changed it, make a new one.  */
3213   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3214   if (lvolatilep)
3215     {
3216       TREE_SIDE_EFFECTS (lhs) = 1;
3217       TREE_THIS_VOLATILE (lhs) = 1;
3218     }
3219
3220   rhs = fold (const_binop (BIT_AND_EXPR,
3221                            const_binop (LSHIFT_EXPR,
3222                                         fold_convert (unsigned_type, rhs),
3223                                         size_int (lbitpos), 0),
3224                            mask, 0));
3225
3226   return build2 (code, compare_type,
3227                  build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
3228                  rhs);
3229 }
3230 \f
3231 /* Subroutine for fold_truthop: decode a field reference.
3232
3233    If EXP is a comparison reference, we return the innermost reference.
3234
3235    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3236    set to the starting bit number.
3237
3238    If the innermost field can be completely contained in a mode-sized
3239    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3240
3241    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3242    otherwise it is not changed.
3243
3244    *PUNSIGNEDP is set to the signedness of the field.
3245
3246    *PMASK is set to the mask used.  This is either contained in a
3247    BIT_AND_EXPR or derived from the width of the field.
3248
3249    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3250
3251    Return 0 if this is not a component reference or is one that we can't
3252    do anything with.  */
3253
3254 static tree
3255 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
3256                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3257                         int *punsignedp, int *pvolatilep,
3258                         tree *pmask, tree *pand_mask)
3259 {
3260   tree outer_type = 0;
3261   tree and_mask = 0;
3262   tree mask, inner, offset;
3263   tree unsigned_type;
3264   unsigned int precision;
3265
3266   /* All the optimizations using this function assume integer fields.
3267      There are problems with FP fields since the type_for_size call
3268      below can fail for, e.g., XFmode.  */
3269   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3270     return 0;
3271
3272   /* We are interested in the bare arrangement of bits, so strip everything
3273      that doesn't affect the machine mode.  However, record the type of the
3274      outermost expression if it may matter below.  */
3275   if (TREE_CODE (exp) == NOP_EXPR
3276       || TREE_CODE (exp) == CONVERT_EXPR
3277       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3278     outer_type = TREE_TYPE (exp);
3279   STRIP_NOPS (exp);
3280
3281   if (TREE_CODE (exp) == BIT_AND_EXPR)
3282     {
3283       and_mask = TREE_OPERAND (exp, 1);
3284       exp = TREE_OPERAND (exp, 0);
3285       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3286       if (TREE_CODE (and_mask) != INTEGER_CST)
3287         return 0;
3288     }
3289
3290   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3291                                punsignedp, pvolatilep);
3292   if ((inner == exp && and_mask == 0)
3293       || *pbitsize < 0 || offset != 0
3294       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3295     return 0;
3296
3297   /* If the number of bits in the reference is the same as the bitsize of
3298      the outer type, then the outer type gives the signedness. Otherwise
3299      (in case of a small bitfield) the signedness is unchanged.  */
3300   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3301     *punsignedp = TYPE_UNSIGNED (outer_type);
3302
3303   /* Compute the mask to access the bitfield.  */
3304   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3305   precision = TYPE_PRECISION (unsigned_type);
3306
3307   mask = build_int_cst (unsigned_type, -1);
3308   mask = force_fit_type (mask, 0, false, false);
3309
3310   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3311   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3312
3313   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3314   if (and_mask != 0)
3315     mask = fold (build2 (BIT_AND_EXPR, unsigned_type,
3316                          fold_convert (unsigned_type, and_mask), mask));
3317
3318   *pmask = mask;
3319   *pand_mask = and_mask;
3320   return inner;
3321 }
3322
3323 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3324    bit positions.  */
3325
3326 static int
3327 all_ones_mask_p (tree mask, int size)
3328 {
3329   tree type = TREE_TYPE (mask);
3330   unsigned int precision = TYPE_PRECISION (type);
3331   tree tmask;
3332
3333   tmask = build_int_cst (lang_hooks.types.signed_type (type), -1);
3334   tmask = force_fit_type (tmask, 0, false, false);
3335
3336   return
3337     tree_int_cst_equal (mask,
3338                         const_binop (RSHIFT_EXPR,
3339                                      const_binop (LSHIFT_EXPR, tmask,
3340                                                   size_int (precision - size),
3341                                                   0),
3342                                      size_int (precision - size), 0));
3343 }
3344
3345 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3346    represents the sign bit of EXP's type.  If EXP represents a sign
3347    or zero extension, also test VAL against the unextended type.
3348    The return value is the (sub)expression whose sign bit is VAL,
3349    or NULL_TREE otherwise.  */
3350
3351 static tree
3352 sign_bit_p (tree exp, tree val)
3353 {
3354   unsigned HOST_WIDE_INT mask_lo, lo;
3355   HOST_WIDE_INT mask_hi, hi;
3356   int width;
3357   tree t;
3358
3359   /* Tree EXP must have an integral type.  */
3360   t = TREE_TYPE (exp);
3361   if (! INTEGRAL_TYPE_P (t))
3362     return NULL_TREE;
3363
3364   /* Tree VAL must be an integer constant.  */
3365   if (TREE_CODE (val) != INTEGER_CST
3366       || TREE_CONSTANT_OVERFLOW (val))
3367     return NULL_TREE;
3368
3369   width = TYPE_PRECISION (t);
3370   if (width > HOST_BITS_PER_WIDE_INT)
3371     {
3372       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3373       lo = 0;
3374
3375       mask_hi = ((unsigned HOST_WIDE_INT) -1
3376                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3377       mask_lo = -1;
3378     }
3379   else
3380     {
3381       hi = 0;
3382       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3383
3384       mask_hi = 0;
3385       mask_lo = ((unsigned HOST_WIDE_INT) -1
3386                  >> (HOST_BITS_PER_WIDE_INT - width));
3387     }
3388
3389   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3390      treat VAL as if it were unsigned.  */
3391   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3392       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3393     return exp;
3394
3395   /* Handle extension from a narrower type.  */
3396   if (TREE_CODE (exp) == NOP_EXPR
3397       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3398     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3399
3400   return NULL_TREE;
3401 }
3402
3403 /* Subroutine for fold_truthop: determine if an operand is simple enough
3404    to be evaluated unconditionally.  */
3405
3406 static int
3407 simple_operand_p (tree exp)
3408 {
3409   /* Strip any conversions that don't change the machine mode.  */
3410   while ((TREE_CODE (exp) == NOP_EXPR
3411           || TREE_CODE (exp) == CONVERT_EXPR)
3412          && (TYPE_MODE (TREE_TYPE (exp))
3413              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
3414     exp = TREE_OPERAND (exp, 0);
3415
3416   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
3417           || (DECL_P (exp)
3418               && ! TREE_ADDRESSABLE (exp)
3419               && ! TREE_THIS_VOLATILE (exp)
3420               && ! DECL_NONLOCAL (exp)
3421               /* Don't regard global variables as simple.  They may be
3422                  allocated in ways unknown to the compiler (shared memory,
3423                  #pragma weak, etc).  */
3424               && ! TREE_PUBLIC (exp)
3425               && ! DECL_EXTERNAL (exp)
3426               /* Loading a static variable is unduly expensive, but global
3427                  registers aren't expensive.  */
3428               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3429 }
3430 \f
3431 /* The following functions are subroutines to fold_range_test and allow it to
3432    try to change a logical combination of comparisons into a range test.
3433
3434    For example, both
3435         X == 2 || X == 3 || X == 4 || X == 5
3436    and
3437         X >= 2 && X <= 5
3438    are converted to
3439         (unsigned) (X - 2) <= 3
3440
3441    We describe each set of comparisons as being either inside or outside
3442    a range, using a variable named like IN_P, and then describe the
3443    range with a lower and upper bound.  If one of the bounds is omitted,
3444    it represents either the highest or lowest value of the type.
3445
3446    In the comments below, we represent a range by two numbers in brackets
3447    preceded by a "+" to designate being inside that range, or a "-" to
3448    designate being outside that range, so the condition can be inverted by
3449    flipping the prefix.  An omitted bound is represented by a "-".  For
3450    example, "- [-, 10]" means being outside the range starting at the lowest
3451    possible value and ending at 10, in other words, being greater than 10.
3452    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3453    always false.
3454
3455    We set up things so that the missing bounds are handled in a consistent
3456    manner so neither a missing bound nor "true" and "false" need to be
3457    handled using a special case.  */
3458
3459 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3460    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3461    and UPPER1_P are nonzero if the respective argument is an upper bound
3462    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3463    must be specified for a comparison.  ARG1 will be converted to ARG0's
3464    type if both are specified.  */
3465
3466 static tree
3467 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3468              tree arg1, int upper1_p)
3469 {
3470   tree tem;
3471   int result;
3472   int sgn0, sgn1;
3473
3474   /* If neither arg represents infinity, do the normal operation.
3475      Else, if not a comparison, return infinity.  Else handle the special
3476      comparison rules. Note that most of the cases below won't occur, but
3477      are handled for consistency.  */
3478
3479   if (arg0 != 0 && arg1 != 0)
3480     {
3481       tem = fold (build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3482                           arg0, fold_convert (TREE_TYPE (arg0), arg1)));
3483       STRIP_NOPS (tem);
3484       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3485     }
3486
3487   if (TREE_CODE_CLASS (code) != '<')
3488     return 0;
3489
3490   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3491      for neither.  In real maths, we cannot assume open ended ranges are
3492      the same. But, this is computer arithmetic, where numbers are finite.
3493      We can therefore make the transformation of any unbounded range with
3494      the value Z, Z being greater than any representable number. This permits
3495      us to treat unbounded ranges as equal.  */
3496   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3497   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3498   switch (code)
3499     {
3500     case EQ_EXPR:
3501       result = sgn0 == sgn1;
3502       break;
3503     case NE_EXPR:
3504       result = sgn0 != sgn1;
3505       break;
3506     case LT_EXPR:
3507       result = sgn0 < sgn1;
3508       break;
3509     case LE_EXPR:
3510       result = sgn0 <= sgn1;
3511       break;
3512     case GT_EXPR:
3513       result = sgn0 > sgn1;
3514       break;
3515     case GE_EXPR:
3516       result = sgn0 >= sgn1;
3517       break;
3518     default:
3519       gcc_unreachable ();
3520     }
3521
3522   return constant_boolean_node (result, type);
3523 }
3524 \f
3525 /* Given EXP, a logical expression, set the range it is testing into
3526    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3527    actually being tested.  *PLOW and *PHIGH will be made of the same type
3528    as the returned expression.  If EXP is not a comparison, we will most
3529    likely not be returning a useful value and range.  */
3530
3531 static tree
3532 make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
3533 {
3534   enum tree_code code;
3535   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
3536   tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
3537   int in_p, n_in_p;
3538   tree low, high, n_low, n_high;
3539
3540   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3541      and see if we can refine the range.  Some of the cases below may not
3542      happen, but it doesn't seem worth worrying about this.  We "continue"
3543      the outer loop when we've changed something; otherwise we "break"
3544      the switch, which will "break" the while.  */
3545
3546   in_p = 0;
3547   low = high = fold_convert (TREE_TYPE (exp), integer_zero_node);
3548
3549   while (1)
3550     {
3551       code = TREE_CODE (exp);
3552       exp_type = TREE_TYPE (exp);
3553
3554       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3555         {
3556           if (first_rtl_op (code) > 0)
3557             arg0 = TREE_OPERAND (exp, 0);
3558           if (TREE_CODE_CLASS (code) == '<'
3559               || TREE_CODE_CLASS (code) == '1'
3560               || TREE_CODE_CLASS (code) == '2')
3561             arg0_type = TREE_TYPE (arg0);
3562           if (TREE_CODE_CLASS (code) == '2'
3563               || TREE_CODE_CLASS (code) == '<'
3564               || (TREE_CODE_CLASS (code) == 'e'
3565                   && TREE_CODE_LENGTH (code) > 1))
3566             arg1 = TREE_OPERAND (exp, 1);
3567         }
3568
3569       switch (code)
3570         {
3571         case TRUTH_NOT_EXPR:
3572           in_p = ! in_p, exp = arg0;
3573           continue;
3574
3575         case EQ_EXPR: case NE_EXPR:
3576         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3577           /* We can only do something if the range is testing for zero
3578              and if the second operand is an integer constant.  Note that
3579              saying something is "in" the range we make is done by
3580              complementing IN_P since it will set in the initial case of
3581              being not equal to zero; "out" is leaving it alone.  */
3582           if (low == 0 || high == 0
3583               || ! integer_zerop (low) || ! integer_zerop (high)
3584               || TREE_CODE (arg1) != INTEGER_CST)
3585             break;
3586
3587           switch (code)
3588             {
3589             case NE_EXPR:  /* - [c, c]  */
3590               low = high = arg1;
3591               break;
3592             case EQ_EXPR:  /* + [c, c]  */
3593               in_p = ! in_p, low = high = arg1;
3594               break;
3595             case GT_EXPR:  /* - [-, c] */
3596               low = 0, high = arg1;
3597               break;
3598             case GE_EXPR:  /* + [c, -] */
3599               in_p = ! in_p, low = arg1, high = 0;
3600               break;
3601             case LT_EXPR:  /* - [c, -] */
3602               low = arg1, high = 0;
3603               break;
3604             case LE_EXPR:  /* + [-, c] */
3605               in_p = ! in_p, low = 0, high = arg1;
3606               break;
3607             default:
3608               gcc_unreachable ();
3609             }
3610
3611           /* If this is an unsigned comparison, we also know that EXP is
3612              greater than or equal to zero.  We base the range tests we make
3613              on that fact, so we record it here so we can parse existing
3614              range tests.  We test arg0_type since often the return type
3615              of, e.g. EQ_EXPR, is boolean.  */
3616           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3617             {
3618               if (! merge_ranges (&n_in_p, &n_low, &n_high,
3619                                   in_p, low, high, 1,
3620                                   fold_convert (arg0_type, integer_zero_node),
3621                                   NULL_TREE))
3622                 break;
3623
3624               in_p = n_in_p, low = n_low, high = n_high;
3625
3626               /* If the high bound is missing, but we have a nonzero low
3627                  bound, reverse the range so it goes from zero to the low bound
3628                  minus 1.  */
3629               if (high == 0 && low && ! integer_zerop (low))
3630                 {
3631                   in_p = ! in_p;
3632                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3633                                       integer_one_node, 0);
3634                   low = fold_convert (arg0_type, integer_zero_node);
3635                 }
3636             }
3637
3638           exp = arg0;
3639           continue;
3640
3641         case NEGATE_EXPR:
3642           /* (-x) IN [a,b] -> x in [-b, -a]  */
3643           n_low = range_binop (MINUS_EXPR, exp_type,
3644                                fold_convert (exp_type, integer_zero_node),
3645                                0, high, 1);
3646           n_high = range_binop (MINUS_EXPR, exp_type,
3647                                 fold_convert (exp_type, integer_zero_node),
3648                                 0, low, 0);
3649           low = n_low, high = n_high;
3650           exp = arg0;
3651           continue;
3652
3653         case BIT_NOT_EXPR:
3654           /* ~ X -> -X - 1  */
3655           exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
3656                         fold_convert (exp_type, integer_one_node));
3657           continue;
3658
3659         case PLUS_EXPR:  case MINUS_EXPR:
3660           if (TREE_CODE (arg1) != INTEGER_CST)
3661             break;
3662
3663           /* If EXP is signed, any overflow in the computation is undefined,
3664              so we don't worry about it so long as our computations on
3665              the bounds don't overflow.  For unsigned, overflow is defined
3666              and this is exactly the right thing.  */
3667           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3668                                arg0_type, low, 0, arg1, 0);
3669           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3670                                 arg0_type, high, 1, arg1, 0);
3671           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3672               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3673             break;
3674
3675           /* Check for an unsigned range which has wrapped around the maximum
3676              value thus making n_high < n_low, and normalize it.  */
3677           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3678             {
3679               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
3680                                  integer_one_node, 0);
3681               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
3682                                   integer_one_node, 0);
3683
3684               /* If the range is of the form +/- [ x+1, x ], we won't
3685                  be able to normalize it.  But then, it represents the
3686                  whole range or the empty set, so make it
3687                  +/- [ -, - ].  */
3688               if (tree_int_cst_equal (n_low, low)
3689                   && tree_int_cst_equal (n_high, high))
3690                 low = high = 0;
3691               else
3692                 in_p = ! in_p;
3693             }
3694           else
3695             low = n_low, high = n_high;
3696
3697           exp = arg0;
3698           continue;
3699
3700         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3701           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
3702             break;
3703
3704           if (! INTEGRAL_TYPE_P (arg0_type)
3705               || (low != 0 && ! int_fits_type_p (low, arg0_type))
3706               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
3707             break;
3708
3709           n_low = low, n_high = high;
3710
3711           if (n_low != 0)
3712             n_low = fold_convert (arg0_type, n_low);
3713
3714           if (n_high != 0)
3715             n_high = fold_convert (arg0_type, n_high);
3716
3717
3718           /* If we're converting arg0 from an unsigned type, to exp,
3719              a signed type,  we will be doing the comparison as unsigned.
3720              The tests above have already verified that LOW and HIGH
3721              are both positive.
3722
3723              So we have to ensure that we will handle large unsigned
3724              values the same way that the current signed bounds treat
3725              negative values.  */
3726
3727           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
3728             {
3729               tree high_positive;
3730               tree equiv_type = lang_hooks.types.type_for_mode
3731                 (TYPE_MODE (arg0_type), 1);
3732
3733               /* A range without an upper bound is, naturally, unbounded.
3734                  Since convert would have cropped a very large value, use
3735                  the max value for the destination type.  */
3736               high_positive
3737                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3738                 : TYPE_MAX_VALUE (arg0_type);
3739
3740               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
3741                 high_positive = fold (build2 (RSHIFT_EXPR, arg0_type,
3742                                               fold_convert (arg0_type,
3743                                                             high_positive),
3744                                               fold_convert (arg0_type,
3745                                                             integer_one_node)));
3746
3747               /* If the low bound is specified, "and" the range with the
3748                  range for which the original unsigned value will be
3749                  positive.  */
3750               if (low != 0)
3751                 {
3752                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3753                                       1, n_low, n_high, 1,
3754                                       fold_convert (arg0_type,
3755                                                     integer_zero_node),
3756                                       high_positive))
3757                     break;
3758
3759                   in_p = (n_in_p == in_p);
3760                 }
3761               else
3762                 {
3763                   /* Otherwise, "or" the range with the range of the input
3764                      that will be interpreted as negative.  */
3765                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3766                                       0, n_low, n_high, 1,
3767                                       fold_convert (arg0_type,
3768                                                     integer_zero_node),
3769                                       high_positive))
3770                     break;
3771
3772                   in_p = (in_p != n_in_p);
3773                 }
3774             }
3775
3776           exp = arg0;
3777           low = n_low, high = n_high;
3778           continue;
3779
3780         default:
3781           break;
3782         }
3783
3784       break;
3785     }
3786
3787   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3788   if (TREE_CODE (exp) == INTEGER_CST)
3789     {
3790       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3791                                                  exp, 0, low, 0))
3792                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3793                                                     exp, 1, high, 1)));
3794       low = high = 0;
3795       exp = 0;
3796     }
3797
3798   *pin_p = in_p, *plow = low, *phigh = high;
3799   return exp;
3800 }
3801 \f
3802 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3803    type, TYPE, return an expression to test if EXP is in (or out of, depending
3804    on IN_P) the range.  Return 0 if the test couldn't be created.  */
3805
3806 static tree
3807 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
3808 {
3809   tree etype = TREE_TYPE (exp);
3810   tree value;
3811
3812   if (! in_p)
3813     {
3814       value = build_range_check (type, exp, 1, low, high);
3815       if (value != 0)
3816         return invert_truthvalue (value);
3817
3818       return 0;
3819     }
3820
3821   if (low == 0 && high == 0)
3822     return fold_convert (type, integer_one_node);
3823
3824   if (low == 0)
3825     return fold (build2 (LE_EXPR, type, exp, high));
3826
3827   if (high == 0)
3828     return fold (build2 (GE_EXPR, type, exp, low));
3829
3830   if (operand_equal_p (low, high, 0))
3831     return fold (build2 (EQ_EXPR, type, exp, low));
3832
3833   if (integer_zerop (low))
3834     {
3835       if (! TYPE_UNSIGNED (etype))
3836         {
3837           etype = lang_hooks.types.unsigned_type (etype);
3838           high = fold_convert (etype, high);
3839           exp = fold_convert (etype, exp);
3840         }
3841       return build_range_check (type, exp, 1, 0, high);
3842     }
3843
3844   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
3845   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
3846     {
3847       unsigned HOST_WIDE_INT lo;
3848       HOST_WIDE_INT hi;
3849       int prec;
3850
3851       prec = TYPE_PRECISION (etype);
3852       if (prec <= HOST_BITS_PER_WIDE_INT)
3853         {
3854           hi = 0;
3855           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
3856         }
3857       else
3858         {
3859           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
3860           lo = (unsigned HOST_WIDE_INT) -1;
3861         }
3862
3863       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
3864         {
3865           if (TYPE_UNSIGNED (etype))
3866             {
3867               etype = lang_hooks.types.signed_type (etype);
3868               exp = fold_convert (etype, exp);
3869             }
3870           return fold (build2 (GT_EXPR, type, exp,
3871                                fold_convert (etype, integer_zero_node)));
3872         }
3873     }
3874
3875   value = const_binop (MINUS_EXPR, high, low, 0);
3876   if (value != 0 && TREE_OVERFLOW (value) && ! TYPE_UNSIGNED (etype))
3877     {
3878       tree utype, minv, maxv;
3879
3880       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
3881          for the type in question, as we rely on this here.  */
3882       switch (TREE_CODE (etype))
3883         {
3884         case INTEGER_TYPE:
3885         case ENUMERAL_TYPE:
3886         case CHAR_TYPE:
3887           utype = lang_hooks.types.unsigned_type (etype);
3888           maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
3889           maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
3890                               integer_one_node, 1);
3891           minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
3892           if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
3893                                           minv, 1, maxv, 1)))
3894             {
3895               etype = utype;
3896               high = fold_convert (etype, high);
3897               low = fold_convert (etype, low);
3898               exp = fold_convert (etype, exp);
3899               value = const_binop (MINUS_EXPR, high, low, 0);
3900             }
3901           break;
3902         default:
3903           break;
3904         }
3905     }
3906
3907   if (value != 0 && ! TREE_OVERFLOW (value))
3908     return build_range_check (type,
3909                               fold (build2 (MINUS_EXPR, etype, exp, low)),
3910                               1, fold_convert (etype, integer_zero_node),
3911                               value);
3912
3913   return 0;
3914 }
3915 \f
3916 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3917    can, 0 if we can't.  Set the output range into the specified parameters.  */
3918
3919 static int
3920 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
3921               tree high0, int in1_p, tree low1, tree high1)
3922 {
3923   int no_overlap;
3924   int subset;
3925   int temp;
3926   tree tem;
3927   int in_p;
3928   tree low, high;
3929   int lowequal = ((low0 == 0 && low1 == 0)
3930                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3931                                                 low0, 0, low1, 0)));
3932   int highequal = ((high0 == 0 && high1 == 0)
3933                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3934                                                  high0, 1, high1, 1)));
3935
3936   /* Make range 0 be the range that starts first, or ends last if they
3937      start at the same value.  Swap them if it isn't.  */
3938   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3939                                  low0, 0, low1, 0))
3940       || (lowequal
3941           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3942                                         high1, 1, high0, 1))))
3943     {
3944       temp = in0_p, in0_p = in1_p, in1_p = temp;
3945       tem = low0, low0 = low1, low1 = tem;
3946       tem = high0, high0 = high1, high1 = tem;
3947     }
3948
3949   /* Now flag two cases, whether the ranges are disjoint or whether the
3950      second range is totally subsumed in the first.  Note that the tests
3951      below are simplified by the ones above.  */
3952   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3953                                           high0, 1, low1, 0));
3954   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3955                                       high1, 1, high0, 1));
3956
3957   /* We now have four cases, depending on whether we are including or
3958      excluding the two ranges.  */
3959   if (in0_p && in1_p)
3960     {
3961       /* If they don't overlap, the result is false.  If the second range
3962          is a subset it is the result.  Otherwise, the range is from the start
3963          of the second to the end of the first.  */
3964       if (no_overlap)
3965         in_p = 0, low = high = 0;
3966       else if (subset)
3967         in_p = 1, low = low1, high = high1;
3968       else
3969         in_p = 1, low = low1, high = high0;
3970     }
3971
3972   else if (in0_p && ! in1_p)
3973     {
3974       /* If they don't overlap, the result is the first range.  If they are
3975          equal, the result is false.  If the second range is a subset of the
3976          first, and the ranges begin at the same place, we go from just after
3977          the end of the first range to the end of the second.  If the second
3978          range is not a subset of the first, or if it is a subset and both
3979          ranges end at the same place, the range starts at the start of the
3980          first range and ends just before the second range.
3981          Otherwise, we can't describe this as a single range.  */
3982       if (no_overlap)
3983         in_p = 1, low = low0, high = high0;
3984       else if (lowequal && highequal)
3985         in_p = 0, low = high = 0;
3986       else if (subset && lowequal)
3987         {
3988           in_p = 1, high = high0;
3989           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3990                              integer_one_node, 0);
3991         }
3992       else if (! subset || highequal)
3993         {
3994           in_p = 1, low = low0;
3995           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3996                               integer_one_node, 0);
3997         }
3998       else
3999         return 0;
4000     }
4001
4002   else if (! in0_p && in1_p)
4003     {
4004       /* If they don't overlap, the result is the second range.  If the second
4005          is a subset of the first, the result is false.  Otherwise,
4006          the range starts just after the first range and ends at the
4007          end of the second.  */
4008       if (no_overlap)
4009         in_p = 1, low = low1, high = high1;
4010       else if (subset || highequal)
4011         in_p = 0, low = high = 0;
4012       else
4013         {
4014           in_p = 1, high = high1;
4015           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4016                              integer_one_node, 0);
4017         }
4018     }
4019
4020   else
4021     {
4022       /* The case where we are excluding both ranges.  Here the complex case
4023          is if they don't overlap.  In that case, the only time we have a
4024          range is if they are adjacent.  If the second is a subset of the
4025          first, the result is the first.  Otherwise, the range to exclude
4026          starts at the beginning of the first range and ends at the end of the
4027          second.  */
4028       if (no_overlap)
4029         {
4030           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4031                                          range_binop (PLUS_EXPR, NULL_TREE,
4032                                                       high0, 1,
4033                                                       integer_one_node, 1),
4034                                          1, low1, 0)))
4035             in_p = 0, low = low0, high = high1;
4036           else
4037             {
4038               /* Canonicalize - [min, x] into - [-, x].  */
4039               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4040                 switch (TREE_CODE (TREE_TYPE (low0)))
4041                   {
4042                   case ENUMERAL_TYPE:
4043                     if (TYPE_PRECISION (TREE_TYPE (low0))
4044                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4045                       break;
4046                     /* FALLTHROUGH */
4047                   case INTEGER_TYPE:
4048                   case CHAR_TYPE:
4049                     if (tree_int_cst_equal (low0,
4050                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4051                       low0 = 0;
4052                     break;
4053                   case POINTER_TYPE:
4054                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4055                         && integer_zerop (low0))
4056                       low0 = 0;
4057                     break;
4058                   default:
4059                     break;
4060                   }
4061
4062               /* Canonicalize - [x, max] into - [x, -].  */
4063               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4064                 switch (TREE_CODE (TREE_TYPE (high1)))
4065                   {
4066                   case ENUMERAL_TYPE:
4067                     if (TYPE_PRECISION (TREE_TYPE (high1))
4068                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4069                       break;
4070                     /* FALLTHROUGH */
4071                   case INTEGER_TYPE:
4072                   case CHAR_TYPE:
4073                     if (tree_int_cst_equal (high1,
4074                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4075                       high1 = 0;
4076                     break;
4077                   case POINTER_TYPE:
4078                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4079                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4080                                                        high1, 1,
4081                                                        integer_one_node, 1)))
4082                       high1 = 0;
4083                     break;
4084                   default:
4085                     break;
4086                   }
4087
4088               /* The ranges might be also adjacent between the maximum and
4089                  minimum values of the given type.  For
4090                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4091                  return + [x + 1, y - 1].  */
4092               if (low0 == 0 && high1 == 0)
4093                 {
4094                   low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
4095                                      integer_one_node, 1);
4096                   high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
4097                                       integer_one_node, 0);
4098                   if (low == 0 || high == 0)
4099                     return 0;
4100
4101                   in_p = 1;
4102                 }
4103               else
4104                 return 0;
4105             }
4106         }
4107       else if (subset)
4108         in_p = 0, low = low0, high = high0;
4109       else
4110         in_p = 0, low = low0, high = high1;
4111     }
4112
4113   *pin_p = in_p, *plow = low, *phigh = high;
4114   return 1;
4115 }
4116 \f
4117
4118 /* Subroutine of fold, looking inside expressions of the form
4119    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4120    of the COND_EXPR.  This function is being used also to optimize
4121    A op B ? C : A, by reversing the comparison first.
4122
4123    Return a folded expression whose code is not a COND_EXPR
4124    anymore, or NULL_TREE if no folding opportunity is found.  */
4125
4126 static tree
4127 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
4128 {
4129   enum tree_code comp_code = TREE_CODE (arg0);
4130   tree arg00 = TREE_OPERAND (arg0, 0);
4131   tree arg01 = TREE_OPERAND (arg0, 1);
4132   tree arg1_type = TREE_TYPE (arg1);
4133   tree tem;
4134
4135   STRIP_NOPS (arg1);
4136   STRIP_NOPS (arg2);
4137
4138   /* If we have A op 0 ? A : -A, consider applying the following
4139      transformations:
4140
4141      A == 0? A : -A    same as -A
4142      A != 0? A : -A    same as A
4143      A >= 0? A : -A    same as abs (A)
4144      A > 0?  A : -A    same as abs (A)
4145      A <= 0? A : -A    same as -abs (A)
4146      A < 0?  A : -A    same as -abs (A)
4147
4148      None of these transformations work for modes with signed
4149      zeros.  If A is +/-0, the first two transformations will
4150      change the sign of the result (from +0 to -0, or vice
4151      versa).  The last four will fix the sign of the result,
4152      even though the original expressions could be positive or
4153      negative, depending on the sign of A.
4154
4155      Note that all these transformations are correct if A is
4156      NaN, since the two alternatives (A and -A) are also NaNs.  */
4157   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
4158        ? real_zerop (arg01)
4159        : integer_zerop (arg01))
4160       && TREE_CODE (arg2) == NEGATE_EXPR
4161       && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4162     switch (comp_code)
4163       {
4164       case EQ_EXPR:
4165       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       if (TREE_CODE (arg0) == MULT_EXPR
6970           && TREE_CODE (arg1) == MULT_EXPR
6971           && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
6972         {
6973           /* (A * C) - (B * C) -> (A-B) * C.  */
6974           if (operand_equal_p (TREE_OPERAND (arg0, 1),
6975                                TREE_OPERAND (arg1, 1), 0))
6976             return fold (build2 (MULT_EXPR, type,
6977                                  fold (build2 (MINUS_EXPR, type,
6978                                                TREE_OPERAND (arg0, 0),
6979                                                TREE_OPERAND (arg1, 0))),
6980                                  TREE_OPERAND (arg0, 1)));
6981           /* (A * C1) - (A * C2) -> A * (C1-C2).  */
6982           if (operand_equal_p (TREE_OPERAND (arg0, 0),
6983                                TREE_OPERAND (arg1, 0), 0))
6984             return fold (build2 (MULT_EXPR, type,
6985                                  TREE_OPERAND (arg0, 0),
6986                                  fold (build2 (MINUS_EXPR, type,
6987                                                TREE_OPERAND (arg0, 1),
6988                                                TREE_OPERAND (arg1, 1)))));
6989         }
6990
6991       goto associate;
6992
6993     case MULT_EXPR:
6994       /* (-A) * (-B) -> A * B  */
6995       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
6996         return fold (build2 (MULT_EXPR, type,
6997                              TREE_OPERAND (arg0, 0),
6998                              negate_expr (arg1)));
6999       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7000         return fold (build2 (MULT_EXPR, type,
7001                              negate_expr (arg0),
7002                              TREE_OPERAND (arg1, 0)));
7003
7004       if (! FLOAT_TYPE_P (type))
7005         {
7006           if (integer_zerop (arg1))
7007             return omit_one_operand (type, arg1, arg0);
7008           if (integer_onep (arg1))
7009             return non_lvalue (fold_convert (type, arg0));
7010
7011           /* (a * (1 << b)) is (a << b)  */
7012           if (TREE_CODE (arg1) == LSHIFT_EXPR
7013               && integer_onep (TREE_OPERAND (arg1, 0)))
7014             return fold (build2 (LSHIFT_EXPR, type, arg0,
7015                                  TREE_OPERAND (arg1, 1)));
7016           if (TREE_CODE (arg0) == LSHIFT_EXPR
7017               && integer_onep (TREE_OPERAND (arg0, 0)))
7018             return fold (build2 (LSHIFT_EXPR, type, arg1,
7019                                  TREE_OPERAND (arg0, 1)));
7020
7021           if (TREE_CODE (arg1) == INTEGER_CST
7022               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
7023                                              fold_convert (type, arg1),
7024                                              code, NULL_TREE)))
7025             return fold_convert (type, tem);
7026
7027         }
7028       else
7029         {
7030           /* Maybe fold x * 0 to 0.  The expressions aren't the same
7031              when x is NaN, since x * 0 is also NaN.  Nor are they the
7032              same in modes with signed zeros, since multiplying a
7033              negative value by 0 gives -0, not +0.  */
7034           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
7035               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
7036               && real_zerop (arg1))
7037             return omit_one_operand (type, arg1, arg0);
7038           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
7039           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7040               && real_onep (arg1))
7041             return non_lvalue (fold_convert (type, arg0));
7042
7043           /* Transform x * -1.0 into -x.  */
7044           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7045               && real_minus_onep (arg1))
7046             return fold_convert (type, negate_expr (arg0));
7047
7048           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
7049           if (flag_unsafe_math_optimizations
7050               && TREE_CODE (arg0) == RDIV_EXPR
7051               && TREE_CODE (arg1) == REAL_CST
7052               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
7053             {
7054               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
7055                                       arg1, 0);
7056               if (tem)
7057                 return fold (build2 (RDIV_EXPR, type, tem,
7058                                      TREE_OPERAND (arg0, 1)));
7059             }
7060
7061           if (flag_unsafe_math_optimizations)
7062             {
7063               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7064               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7065
7066               /* Optimizations of root(...)*root(...).  */
7067               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
7068                 {
7069                   tree rootfn, arg, arglist;
7070                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7071                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7072
7073                   /* Optimize sqrt(x)*sqrt(x) as x.  */
7074                   if (BUILTIN_SQRT_P (fcode0)
7075                       && operand_equal_p (arg00, arg10, 0)
7076                       && ! HONOR_SNANS (TYPE_MODE (type)))
7077                     return arg00;
7078
7079                   /* Optimize root(x)*root(y) as root(x*y).  */
7080                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7081                   arg = fold (build2 (MULT_EXPR, type, arg00, arg10));
7082                   arglist = build_tree_list (NULL_TREE, arg);
7083                   return build_function_call_expr (rootfn, arglist);
7084                 }
7085
7086               /* Optimize expN(x)*expN(y) as expN(x+y).  */
7087               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
7088                 {
7089                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7090                   tree arg = build2 (PLUS_EXPR, type,
7091                                      TREE_VALUE (TREE_OPERAND (arg0, 1)),
7092                                      TREE_VALUE (TREE_OPERAND (arg1, 1)));
7093                   tree arglist = build_tree_list (NULL_TREE, fold (arg));
7094                   return build_function_call_expr (expfn, arglist);
7095                 }
7096
7097               /* Optimizations of pow(...)*pow(...).  */
7098               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
7099                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
7100                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
7101                 {
7102                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7103                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7104                                                                      1)));
7105                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7106                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7107                                                                      1)));
7108
7109                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
7110                   if (operand_equal_p (arg01, arg11, 0))
7111                     {
7112                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7113                       tree arg = build2 (MULT_EXPR, type, arg00, arg10);
7114                       tree arglist = tree_cons (NULL_TREE, fold (arg),
7115                                                 build_tree_list (NULL_TREE,
7116                                                                  arg01));
7117                       return build_function_call_expr (powfn, arglist);
7118                     }
7119
7120                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
7121                   if (operand_equal_p (arg00, arg10, 0))
7122                     {
7123                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7124                       tree arg = fold (build2 (PLUS_EXPR, type, arg01, arg11));
7125                       tree arglist = tree_cons (NULL_TREE, arg00,
7126                                                 build_tree_list (NULL_TREE,
7127                                                                  arg));
7128                       return build_function_call_expr (powfn, arglist);
7129                     }
7130                 }
7131
7132               /* Optimize tan(x)*cos(x) as sin(x).  */
7133               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
7134                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
7135                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
7136                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
7137                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
7138                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
7139                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7140                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7141                 {
7142                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
7143
7144                   if (sinfn != NULL_TREE)
7145                     return build_function_call_expr (sinfn,
7146                                                      TREE_OPERAND (arg0, 1));
7147                 }
7148
7149               /* Optimize x*pow(x,c) as pow(x,c+1).  */
7150               if (fcode1 == BUILT_IN_POW
7151                   || fcode1 == BUILT_IN_POWF
7152                   || fcode1 == BUILT_IN_POWL)
7153                 {
7154                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7155                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7156                                                                      1)));
7157                   if (TREE_CODE (arg11) == REAL_CST
7158                       && ! TREE_CONSTANT_OVERFLOW (arg11)
7159                       && operand_equal_p (arg0, arg10, 0))
7160                     {
7161                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7162                       REAL_VALUE_TYPE c;
7163                       tree arg, arglist;
7164
7165                       c = TREE_REAL_CST (arg11);
7166                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7167                       arg = build_real (type, c);
7168                       arglist = build_tree_list (NULL_TREE, arg);
7169                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7170                       return build_function_call_expr (powfn, arglist);
7171                     }
7172                 }
7173
7174               /* Optimize pow(x,c)*x as pow(x,c+1).  */
7175               if (fcode0 == BUILT_IN_POW
7176                   || fcode0 == BUILT_IN_POWF
7177                   || fcode0 == BUILT_IN_POWL)
7178                 {
7179                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7180                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7181                                                                      1)));
7182                   if (TREE_CODE (arg01) == REAL_CST
7183                       && ! TREE_CONSTANT_OVERFLOW (arg01)
7184                       && operand_equal_p (arg1, arg00, 0))
7185                     {
7186                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7187                       REAL_VALUE_TYPE c;
7188                       tree arg, arglist;
7189
7190                       c = TREE_REAL_CST (arg01);
7191                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7192                       arg = build_real (type, c);
7193                       arglist = build_tree_list (NULL_TREE, arg);
7194                       arglist = tree_cons (NULL_TREE, arg1, arglist);
7195                       return build_function_call_expr (powfn, arglist);
7196                     }
7197                 }
7198
7199               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
7200               if (! optimize_size
7201                   && operand_equal_p (arg0, arg1, 0))
7202                 {
7203                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7204
7205                   if (powfn)
7206                     {
7207                       tree arg = build_real (type, dconst2);
7208                       tree arglist = build_tree_list (NULL_TREE, arg);
7209                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7210                       return build_function_call_expr (powfn, arglist);
7211                     }
7212                 }
7213             }
7214         }
7215       goto associate;
7216
7217     case BIT_IOR_EXPR:
7218     bit_ior:
7219       if (integer_all_onesp (arg1))
7220         return omit_one_operand (type, arg1, arg0);
7221       if (integer_zerop (arg1))
7222         return non_lvalue (fold_convert (type, arg0));
7223       if (operand_equal_p (arg0, arg1, 0))
7224         return non_lvalue (fold_convert (type, arg0));
7225
7226       /* ~X | X is -1.  */
7227       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7228           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7229         {
7230           t1 = build_int_cst (type, -1);
7231           t1 = force_fit_type (t1, 0, false, false);
7232           return omit_one_operand (type, t1, arg1);
7233         }
7234
7235       /* X | ~X is -1.  */
7236       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7237           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7238         {
7239           t1 = build_int_cst (type, -1);
7240           t1 = force_fit_type (t1, 0, false, false);
7241           return omit_one_operand (type, t1, arg0);
7242         }
7243
7244       t1 = distribute_bit_expr (code, type, arg0, arg1);
7245       if (t1 != NULL_TREE)
7246         return t1;
7247
7248       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
7249
7250          This results in more efficient code for machines without a NAND
7251          instruction.  Combine will canonicalize to the first form
7252          which will allow use of NAND instructions provided by the
7253          backend if they exist.  */
7254       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7255           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7256         {
7257           return fold (build1 (BIT_NOT_EXPR, type,
7258                                build2 (BIT_AND_EXPR, type,
7259                                        TREE_OPERAND (arg0, 0),
7260                                        TREE_OPERAND (arg1, 0))));
7261         }
7262
7263       /* See if this can be simplified into a rotate first.  If that
7264          is unsuccessful continue in the association code.  */
7265       goto bit_rotate;
7266
7267     case BIT_XOR_EXPR:
7268       if (integer_zerop (arg1))
7269         return non_lvalue (fold_convert (type, arg0));
7270       if (integer_all_onesp (arg1))
7271         return fold (build1 (BIT_NOT_EXPR, type, arg0));
7272       if (operand_equal_p (arg0, arg1, 0))
7273         return omit_one_operand (type, integer_zero_node, arg0);
7274
7275       /* ~X ^ X is -1.  */
7276       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7277           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7278         {
7279           t1 = build_int_cst (type, -1);
7280           t1 = force_fit_type (t1, 0, false, false);
7281           return omit_one_operand (type, t1, arg1);
7282         }
7283
7284       /* X ^ ~X is -1.  */
7285       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7286           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7287         {
7288           t1 = build_int_cst (type, -1);
7289           t1 = force_fit_type (t1, 0, false, false);
7290           return omit_one_operand (type, t1, arg0);
7291         }
7292
7293       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
7294          with a constant, and the two constants have no bits in common,
7295          we should treat this as a BIT_IOR_EXPR since this may produce more
7296          simplifications.  */
7297       if (TREE_CODE (arg0) == BIT_AND_EXPR
7298           && TREE_CODE (arg1) == BIT_AND_EXPR
7299           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7300           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7301           && integer_zerop (const_binop (BIT_AND_EXPR,
7302                                          TREE_OPERAND (arg0, 1),
7303                                          TREE_OPERAND (arg1, 1), 0)))
7304         {
7305           code = BIT_IOR_EXPR;
7306           goto bit_ior;
7307         }
7308
7309       /* See if this can be simplified into a rotate first.  If that
7310          is unsuccessful continue in the association code.  */
7311       goto bit_rotate;
7312
7313     case BIT_AND_EXPR:
7314       if (integer_all_onesp (arg1))
7315         return non_lvalue (fold_convert (type, arg0));
7316       if (integer_zerop (arg1))
7317         return omit_one_operand (type, arg1, arg0);
7318       if (operand_equal_p (arg0, arg1, 0))
7319         return non_lvalue (fold_convert (type, arg0));
7320
7321       /* ~X & X is always zero.  */
7322       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7323           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7324         return omit_one_operand (type, integer_zero_node, arg1);
7325
7326       /* X & ~X is always zero.  */
7327       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7328           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7329         return omit_one_operand (type, integer_zero_node, arg0);
7330
7331       t1 = distribute_bit_expr (code, type, arg0, arg1);
7332       if (t1 != NULL_TREE)
7333         return t1;
7334       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
7335       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
7336           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7337         {
7338           unsigned int prec
7339             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
7340
7341           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
7342               && (~TREE_INT_CST_LOW (arg1)
7343                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
7344             return fold_convert (type, TREE_OPERAND (arg0, 0));
7345         }
7346
7347       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
7348
7349          This results in more efficient code for machines without a NOR
7350          instruction.  Combine will canonicalize to the first form
7351          which will allow use of NOR instructions provided by the
7352          backend if they exist.  */
7353       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7354           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7355         {
7356           return fold (build1 (BIT_NOT_EXPR, type,
7357                                build2 (BIT_IOR_EXPR, type,
7358                                        TREE_OPERAND (arg0, 0),
7359                                        TREE_OPERAND (arg1, 0))));
7360         }
7361
7362       goto associate;
7363
7364     case RDIV_EXPR:
7365       /* Don't touch a floating-point divide by zero unless the mode
7366          of the constant can represent infinity.  */
7367       if (TREE_CODE (arg1) == REAL_CST
7368           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
7369           && real_zerop (arg1))
7370         return t;
7371
7372       /* (-A) / (-B) -> A / B  */
7373       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7374         return fold (build2 (RDIV_EXPR, type,
7375                              TREE_OPERAND (arg0, 0),
7376                              negate_expr (arg1)));
7377       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7378         return fold (build2 (RDIV_EXPR, type,
7379                              negate_expr (arg0),
7380                              TREE_OPERAND (arg1, 0)));
7381
7382       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
7383       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7384           && real_onep (arg1))
7385         return non_lvalue (fold_convert (type, arg0));
7386
7387       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
7388       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7389           && real_minus_onep (arg1))
7390         return non_lvalue (fold_convert (type, negate_expr (arg0)));
7391
7392       /* If ARG1 is a constant, we can convert this to a multiply by the
7393          reciprocal.  This does not have the same rounding properties,
7394          so only do this if -funsafe-math-optimizations.  We can actually
7395          always safely do it if ARG1 is a power of two, but it's hard to
7396          tell if it is or not in a portable manner.  */
7397       if (TREE_CODE (arg1) == REAL_CST)
7398         {
7399           if (flag_unsafe_math_optimizations
7400               && 0 != (tem = const_binop (code, build_real (type, dconst1),
7401                                           arg1, 0)))
7402             return fold (build2 (MULT_EXPR, type, arg0, tem));
7403           /* Find the reciprocal if optimizing and the result is exact.  */
7404           if (optimize)
7405             {
7406               REAL_VALUE_TYPE r;
7407               r = TREE_REAL_CST (arg1);
7408               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
7409                 {
7410                   tem = build_real (type, r);
7411                   return fold (build2 (MULT_EXPR, type, arg0, tem));
7412                 }
7413             }
7414         }
7415       /* Convert A/B/C to A/(B*C).  */
7416       if (flag_unsafe_math_optimizations
7417           && TREE_CODE (arg0) == RDIV_EXPR)
7418         return fold (build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
7419                              fold (build2 (MULT_EXPR, type,
7420                                            TREE_OPERAND (arg0, 1), arg1))));
7421
7422       /* Convert A/(B/C) to (A/B)*C.  */
7423       if (flag_unsafe_math_optimizations
7424           && TREE_CODE (arg1) == RDIV_EXPR)
7425         return fold (build2 (MULT_EXPR, type,
7426                              fold (build2 (RDIV_EXPR, type, arg0,
7427                                            TREE_OPERAND (arg1, 0))),
7428                              TREE_OPERAND (arg1, 1)));
7429
7430       /* Convert C1/(X*C2) into (C1/C2)/X.  */
7431       if (flag_unsafe_math_optimizations
7432           && TREE_CODE (arg1) == MULT_EXPR
7433           && TREE_CODE (arg0) == REAL_CST
7434           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
7435         {
7436           tree tem = const_binop (RDIV_EXPR, arg0,
7437                                   TREE_OPERAND (arg1, 1), 0);
7438           if (tem)
7439             return fold (build2 (RDIV_EXPR, type, tem,
7440                                  TREE_OPERAND (arg1, 0)));
7441         }
7442
7443       if (flag_unsafe_math_optimizations)
7444         {
7445           enum built_in_function fcode = builtin_mathfn_code (arg1);
7446           /* Optimize x/expN(y) into x*expN(-y).  */
7447           if (BUILTIN_EXPONENT_P (fcode))
7448             {
7449               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7450               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
7451               tree arglist = build_tree_list (NULL_TREE,
7452                                               fold_convert (type, arg));
7453               arg1 = build_function_call_expr (expfn, arglist);
7454               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7455             }
7456
7457           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
7458           if (fcode == BUILT_IN_POW
7459               || fcode == BUILT_IN_POWF
7460               || fcode == BUILT_IN_POWL)
7461             {
7462               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7463               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7464               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
7465               tree neg11 = fold_convert (type, negate_expr (arg11));
7466               tree arglist = tree_cons(NULL_TREE, arg10,
7467                                        build_tree_list (NULL_TREE, neg11));
7468               arg1 = build_function_call_expr (powfn, arglist);
7469               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7470             }
7471         }
7472
7473       if (flag_unsafe_math_optimizations)
7474         {
7475           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7476           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7477
7478           /* Optimize sin(x)/cos(x) as tan(x).  */
7479           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
7480                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
7481                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
7482               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7483                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7484             {
7485               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7486
7487               if (tanfn != NULL_TREE)
7488                 return build_function_call_expr (tanfn,
7489                                                  TREE_OPERAND (arg0, 1));
7490             }
7491
7492           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
7493           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
7494                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
7495                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
7496               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7497                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7498             {
7499               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7500
7501               if (tanfn != NULL_TREE)
7502                 {
7503                   tree tmp = TREE_OPERAND (arg0, 1);
7504                   tmp = build_function_call_expr (tanfn, tmp);
7505                   return fold (build2 (RDIV_EXPR, type,
7506                                        build_real (type, dconst1), tmp));
7507                 }
7508             }
7509
7510           /* Optimize pow(x,c)/x as pow(x,c-1).  */
7511           if (fcode0 == BUILT_IN_POW
7512               || fcode0 == BUILT_IN_POWF
7513               || fcode0 == BUILT_IN_POWL)
7514             {
7515               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7516               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7517               if (TREE_CODE (arg01) == REAL_CST
7518                   && ! TREE_CONSTANT_OVERFLOW (arg01)
7519                   && operand_equal_p (arg1, arg00, 0))
7520                 {
7521                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7522                   REAL_VALUE_TYPE c;
7523                   tree arg, arglist;
7524
7525                   c = TREE_REAL_CST (arg01);
7526                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
7527                   arg = build_real (type, c);
7528                   arglist = build_tree_list (NULL_TREE, arg);
7529                   arglist = tree_cons (NULL_TREE, arg1, arglist);
7530                   return build_function_call_expr (powfn, arglist);
7531                 }
7532             }
7533         }
7534       goto binary;
7535
7536     case TRUNC_DIV_EXPR:
7537     case ROUND_DIV_EXPR:
7538     case FLOOR_DIV_EXPR:
7539     case CEIL_DIV_EXPR:
7540     case EXACT_DIV_EXPR:
7541       if (integer_onep (arg1))
7542         return non_lvalue (fold_convert (type, arg0));
7543       if (integer_zerop (arg1))
7544         return t;
7545       /* X / -1 is -X.  */
7546       if (!TYPE_UNSIGNED (type)
7547           && TREE_CODE (arg1) == INTEGER_CST
7548           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7549           && TREE_INT_CST_HIGH (arg1) == -1)
7550         return fold_convert (type, negate_expr (arg0));
7551
7552       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
7553          operation, EXACT_DIV_EXPR.
7554
7555          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
7556          At one time others generated faster code, it's not clear if they do
7557          after the last round to changes to the DIV code in expmed.c.  */
7558       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
7559           && multiple_of_p (type, arg0, arg1))
7560         return fold (build2 (EXACT_DIV_EXPR, type, arg0, arg1));
7561
7562       if (TREE_CODE (arg1) == INTEGER_CST
7563           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7564                                          code, NULL_TREE)))
7565         return fold_convert (type, tem);
7566
7567       goto binary;
7568
7569     case CEIL_MOD_EXPR:
7570     case FLOOR_MOD_EXPR:
7571     case ROUND_MOD_EXPR:
7572     case TRUNC_MOD_EXPR:
7573       if (integer_onep (arg1))
7574         return omit_one_operand (type, integer_zero_node, arg0);
7575       if (integer_zerop (arg1))
7576         return t;
7577
7578       /* X % -1 is zero.  */
7579       if (!TYPE_UNSIGNED (type)
7580           && TREE_CODE (arg1) == INTEGER_CST
7581           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7582           && TREE_INT_CST_HIGH (arg1) == -1)
7583         return omit_one_operand (type, integer_zero_node, arg0);
7584
7585       /* Optimize unsigned TRUNC_MOD_EXPR by a power of two into a
7586          BIT_AND_EXPR, i.e. "X % C" into "X & C2".  */
7587       if (code == TRUNC_MOD_EXPR
7588           && TYPE_UNSIGNED (type)
7589           && integer_pow2p (arg1))
7590         {
7591           unsigned HOST_WIDE_INT high, low;
7592           tree mask;
7593           int l;
7594
7595           l = tree_log2 (arg1);
7596           if (l >= HOST_BITS_PER_WIDE_INT)
7597             {
7598               high = ((unsigned HOST_WIDE_INT) 1
7599                       << (l - HOST_BITS_PER_WIDE_INT)) - 1;
7600               low = -1;
7601             }
7602           else
7603             {
7604               high = 0;
7605               low = ((unsigned HOST_WIDE_INT) 1 << l) - 1;
7606             }
7607
7608           mask = build_int_cst_wide (type, low, high);
7609           return fold (build2 (BIT_AND_EXPR, type,
7610                                fold_convert (type, arg0), mask));
7611         }
7612
7613       /* X % -C is the same as X % C.  */
7614       if (code == TRUNC_MOD_EXPR
7615           && !TYPE_UNSIGNED (type)
7616           && TREE_CODE (arg1) == INTEGER_CST
7617           && TREE_INT_CST_HIGH (arg1) < 0
7618           && !flag_trapv
7619           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
7620           && !sign_bit_p (arg1, arg1))
7621         return fold (build2 (code, type, fold_convert (type, arg0),
7622                              fold_convert (type, negate_expr (arg1))));
7623
7624       /* X % -Y is the same as X % Y.  */
7625       if (code == TRUNC_MOD_EXPR
7626           && !TYPE_UNSIGNED (type)
7627           && TREE_CODE (arg1) == NEGATE_EXPR
7628           && !flag_trapv)
7629         return fold (build2 (code, type, fold_convert (type, arg0),
7630                              fold_convert (type, TREE_OPERAND (arg1, 0))));
7631
7632       if (TREE_CODE (arg1) == INTEGER_CST
7633           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7634                                          code, NULL_TREE)))
7635         return fold_convert (type, tem);
7636
7637       goto binary;
7638
7639     case LROTATE_EXPR:
7640     case RROTATE_EXPR:
7641       if (integer_all_onesp (arg0))
7642         return omit_one_operand (type, arg0, arg1);
7643       goto shift;
7644
7645     case RSHIFT_EXPR:
7646       /* Optimize -1 >> x for arithmetic right shifts.  */
7647       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
7648         return omit_one_operand (type, arg0, arg1);
7649       /* ... fall through ...  */
7650
7651     case LSHIFT_EXPR:
7652     shift:
7653       if (integer_zerop (arg1))
7654         return non_lvalue (fold_convert (type, arg0));
7655       if (integer_zerop (arg0))
7656         return omit_one_operand (type, arg0, arg1);
7657
7658       /* Since negative shift count is not well-defined,
7659          don't try to compute it in the compiler.  */
7660       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
7661         return t;
7662       /* Rewrite an LROTATE_EXPR by a constant into an
7663          RROTATE_EXPR by a new constant.  */
7664       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
7665         {
7666           tree tem = build_int_cst (NULL_TREE,
7667                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
7668           tem = fold_convert (TREE_TYPE (arg1), tem);
7669           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
7670           return fold (build2 (RROTATE_EXPR, type, arg0, tem));
7671         }
7672
7673       /* If we have a rotate of a bit operation with the rotate count and
7674          the second operand of the bit operation both constant,
7675          permute the two operations.  */
7676       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7677           && (TREE_CODE (arg0) == BIT_AND_EXPR
7678               || TREE_CODE (arg0) == BIT_IOR_EXPR
7679               || TREE_CODE (arg0) == BIT_XOR_EXPR)
7680           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7681         return fold (build2 (TREE_CODE (arg0), type,
7682                              fold (build2 (code, type,
7683                                            TREE_OPERAND (arg0, 0), arg1)),
7684                              fold (build2 (code, type,
7685                                            TREE_OPERAND (arg0, 1), arg1))));
7686
7687       /* Two consecutive rotates adding up to the width of the mode can
7688          be ignored.  */
7689       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7690           && TREE_CODE (arg0) == RROTATE_EXPR
7691           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7692           && TREE_INT_CST_HIGH (arg1) == 0
7693           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
7694           && ((TREE_INT_CST_LOW (arg1)
7695                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
7696               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
7697         return TREE_OPERAND (arg0, 0);
7698
7699       goto binary;
7700
7701     case MIN_EXPR:
7702       if (operand_equal_p (arg0, arg1, 0))
7703         return omit_one_operand (type, arg0, arg1);
7704       if (INTEGRAL_TYPE_P (type)
7705           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
7706         return omit_one_operand (type, arg1, arg0);
7707       goto associate;
7708
7709     case MAX_EXPR:
7710       if (operand_equal_p (arg0, arg1, 0))
7711         return omit_one_operand (type, arg0, arg1);
7712       if (INTEGRAL_TYPE_P (type)
7713           && TYPE_MAX_VALUE (type)
7714           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
7715         return omit_one_operand (type, arg1, arg0);
7716       goto associate;
7717
7718     case TRUTH_NOT_EXPR:
7719       /* The argument to invert_truthvalue must have Boolean type.  */
7720       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7721           arg0 = fold_convert (boolean_type_node, arg0);
7722
7723       /* Note that the operand of this must be an int
7724          and its values must be 0 or 1.
7725          ("true" is a fixed value perhaps depending on the language,
7726          but we don't handle values other than 1 correctly yet.)  */
7727       tem = invert_truthvalue (arg0);
7728       /* Avoid infinite recursion.  */
7729       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
7730         {
7731           tem = fold_single_bit_test (code, arg0, arg1, type);
7732           if (tem)
7733             return tem;
7734           return t;
7735         }
7736       return fold_convert (type, tem);
7737
7738     case TRUTH_ANDIF_EXPR:
7739       /* Note that the operands of this must be ints
7740          and their values must be 0 or 1.
7741          ("true" is a fixed value perhaps depending on the language.)  */
7742       /* If first arg is constant zero, return it.  */
7743       if (integer_zerop (arg0))
7744         return fold_convert (type, arg0);
7745     case TRUTH_AND_EXPR:
7746       /* If either arg is constant true, drop it.  */
7747       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7748         return non_lvalue (fold_convert (type, arg1));
7749       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
7750           /* Preserve sequence points.  */
7751           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7752         return non_lvalue (fold_convert (type, arg0));
7753       /* If second arg is constant zero, result is zero, but first arg
7754          must be evaluated.  */
7755       if (integer_zerop (arg1))
7756         return omit_one_operand (type, arg1, arg0);
7757       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
7758          case will be handled here.  */
7759       if (integer_zerop (arg0))
7760         return omit_one_operand (type, arg0, arg1);
7761
7762       /* !X && X is always false.  */
7763       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7764           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7765         return omit_one_operand (type, integer_zero_node, arg1);
7766       /* X && !X is always false.  */
7767       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7768           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7769         return omit_one_operand (type, integer_zero_node, arg0);
7770
7771     truth_andor:
7772       /* We only do these simplifications if we are optimizing.  */
7773       if (!optimize)
7774         return t;
7775
7776       /* Check for things like (A || B) && (A || C).  We can convert this
7777          to A || (B && C).  Note that either operator can be any of the four
7778          truth and/or operations and the transformation will still be
7779          valid.   Also note that we only care about order for the
7780          ANDIF and ORIF operators.  If B contains side effects, this
7781          might change the truth-value of A.  */
7782       if (TREE_CODE (arg0) == TREE_CODE (arg1)
7783           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7784               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7785               || TREE_CODE (arg0) == TRUTH_AND_EXPR
7786               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7787           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7788         {
7789           tree a00 = TREE_OPERAND (arg0, 0);
7790           tree a01 = TREE_OPERAND (arg0, 1);
7791           tree a10 = TREE_OPERAND (arg1, 0);
7792           tree a11 = TREE_OPERAND (arg1, 1);
7793           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7794                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7795                              && (code == TRUTH_AND_EXPR
7796                                  || code == TRUTH_OR_EXPR));
7797
7798           if (operand_equal_p (a00, a10, 0))
7799             return fold (build2 (TREE_CODE (arg0), type, a00,
7800                                  fold (build2 (code, type, a01, a11))));
7801           else if (commutative && operand_equal_p (a00, a11, 0))
7802             return fold (build2 (TREE_CODE (arg0), type, a00,
7803                                  fold (build2 (code, type, a01, a10))));
7804           else if (commutative && operand_equal_p (a01, a10, 0))
7805             return fold (build2 (TREE_CODE (arg0), type, a01,
7806                                  fold (build2 (code, type, a00, a11))));
7807
7808           /* This case if tricky because we must either have commutative
7809              operators or else A10 must not have side-effects.  */
7810
7811           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7812                    && operand_equal_p (a01, a11, 0))
7813             return fold (build2 (TREE_CODE (arg0), type,
7814                                  fold (build2 (code, type, a00, a10)),
7815                                  a01));
7816         }
7817
7818       /* See if we can build a range comparison.  */
7819       if (0 != (tem = fold_range_test (t)))
7820         return tem;
7821
7822       /* Check for the possibility of merging component references.  If our
7823          lhs is another similar operation, try to merge its rhs with our
7824          rhs.  Then try to merge our lhs and rhs.  */
7825       if (TREE_CODE (arg0) == code
7826           && 0 != (tem = fold_truthop (code, type,
7827                                        TREE_OPERAND (arg0, 1), arg1)))
7828         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7829
7830       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
7831         return tem;
7832
7833       return t;
7834
7835     case TRUTH_ORIF_EXPR:
7836       /* Note that the operands of this must be ints
7837          and their values must be 0 or true.
7838          ("true" is a fixed value perhaps depending on the language.)  */
7839       /* If first arg is constant true, return it.  */
7840       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7841         return fold_convert (type, arg0);
7842     case TRUTH_OR_EXPR:
7843       /* If either arg is constant zero, drop it.  */
7844       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
7845         return non_lvalue (fold_convert (type, arg1));
7846       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
7847           /* Preserve sequence points.  */
7848           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7849         return non_lvalue (fold_convert (type, arg0));
7850       /* If second arg is constant true, result is true, but we must
7851          evaluate first arg.  */
7852       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
7853         return omit_one_operand (type, arg1, arg0);
7854       /* Likewise for first arg, but note this only occurs here for
7855          TRUTH_OR_EXPR.  */
7856       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7857         return omit_one_operand (type, arg0, arg1);
7858
7859       /* !X || X is always true.  */
7860       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7861           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7862         return omit_one_operand (type, integer_one_node, arg1);
7863       /* X || !X is always true.  */
7864       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7865           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7866         return omit_one_operand (type, integer_one_node, arg0);
7867
7868       goto truth_andor;
7869
7870     case TRUTH_XOR_EXPR:
7871       /* If the second arg is constant zero, drop it.  */
7872       if (integer_zerop (arg1))
7873         return non_lvalue (fold_convert (type, arg0));
7874       /* If the second arg is constant true, this is a logical inversion.  */
7875       if (integer_onep (arg1))
7876         return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
7877       /* Identical arguments cancel to zero.  */
7878       if (operand_equal_p (arg0, arg1, 0))
7879         return omit_one_operand (type, integer_zero_node, arg0);
7880
7881       /* !X ^ X is always true.  */
7882       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7883           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7884         return omit_one_operand (type, integer_one_node, arg1);
7885
7886       /* X ^ !X is always true.  */
7887       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7888           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7889         return omit_one_operand (type, integer_one_node, arg0);
7890
7891       return t;
7892
7893     case EQ_EXPR:
7894     case NE_EXPR:
7895     case LT_EXPR:
7896     case GT_EXPR:
7897     case LE_EXPR:
7898     case GE_EXPR:
7899       /* If one arg is a real or integer constant, put it last.  */
7900       if (tree_swap_operands_p (arg0, arg1, true))
7901         return fold (build2 (swap_tree_comparison (code), type, arg1, arg0));
7902
7903       /* If this is an equality comparison of the address of a non-weak
7904          object against zero, then we know the result.  */
7905       if ((code == EQ_EXPR || code == NE_EXPR)
7906           && TREE_CODE (arg0) == ADDR_EXPR
7907           && DECL_P (TREE_OPERAND (arg0, 0))
7908           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7909           && integer_zerop (arg1))
7910         return constant_boolean_node (code != EQ_EXPR, type);
7911
7912       /* If this is an equality comparison of the address of two non-weak,
7913          unaliased symbols neither of which are extern (since we do not
7914          have access to attributes for externs), then we know the result.  */
7915       if ((code == EQ_EXPR || code == NE_EXPR)
7916           && TREE_CODE (arg0) == ADDR_EXPR
7917           && DECL_P (TREE_OPERAND (arg0, 0))
7918           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
7919           && ! lookup_attribute ("alias",
7920                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
7921           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
7922           && TREE_CODE (arg1) == ADDR_EXPR
7923           && DECL_P (TREE_OPERAND (arg1, 0))
7924           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
7925           && ! lookup_attribute ("alias",
7926                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
7927           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
7928         return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
7929                                       ? code == EQ_EXPR : code != EQ_EXPR,
7930                                       type);
7931
7932       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
7933         {
7934           tree targ0 = strip_float_extensions (arg0);
7935           tree targ1 = strip_float_extensions (arg1);
7936           tree newtype = TREE_TYPE (targ0);
7937
7938           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
7939             newtype = TREE_TYPE (targ1);
7940
7941           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
7942           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
7943             return fold (build2 (code, type, fold_convert (newtype, targ0),
7944                                  fold_convert (newtype, targ1)));
7945
7946           /* (-a) CMP (-b) -> b CMP a  */
7947           if (TREE_CODE (arg0) == NEGATE_EXPR
7948               && TREE_CODE (arg1) == NEGATE_EXPR)
7949             return fold (build2 (code, type, TREE_OPERAND (arg1, 0),
7950                                  TREE_OPERAND (arg0, 0)));
7951
7952           if (TREE_CODE (arg1) == REAL_CST)
7953           {
7954             REAL_VALUE_TYPE cst;
7955             cst = TREE_REAL_CST (arg1);
7956
7957             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
7958             if (TREE_CODE (arg0) == NEGATE_EXPR)
7959               return
7960                 fold (build2 (swap_tree_comparison (code), type,
7961                               TREE_OPERAND (arg0, 0),
7962                               build_real (TREE_TYPE (arg1),
7963                                           REAL_VALUE_NEGATE (cst))));
7964
7965             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
7966             /* a CMP (-0) -> a CMP 0  */
7967             if (REAL_VALUE_MINUS_ZERO (cst))
7968               return fold (build2 (code, type, arg0,
7969                                    build_real (TREE_TYPE (arg1), dconst0)));
7970
7971             /* x != NaN is always true, other ops are always false.  */
7972             if (REAL_VALUE_ISNAN (cst)
7973                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
7974               {
7975                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
7976                 return omit_one_operand (type, tem, arg0);
7977               }
7978
7979             /* Fold comparisons against infinity.  */
7980             if (REAL_VALUE_ISINF (cst))
7981               {
7982                 tem = fold_inf_compare (code, type, arg0, arg1);
7983                 if (tem != NULL_TREE)
7984                   return tem;
7985               }
7986           }
7987
7988           /* If this is a comparison of a real constant with a PLUS_EXPR
7989              or a MINUS_EXPR of a real constant, we can convert it into a
7990              comparison with a revised real constant as long as no overflow
7991              occurs when unsafe_math_optimizations are enabled.  */
7992           if (flag_unsafe_math_optimizations
7993               && TREE_CODE (arg1) == REAL_CST
7994               && (TREE_CODE (arg0) == PLUS_EXPR
7995                   || TREE_CODE (arg0) == MINUS_EXPR)
7996               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7997               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
7998                                           ? MINUS_EXPR : PLUS_EXPR,
7999                                           arg1, TREE_OPERAND (arg0, 1), 0))
8000               && ! TREE_CONSTANT_OVERFLOW (tem))
8001             return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8002
8003           /* Likewise, we can simplify a comparison of a real constant with
8004              a MINUS_EXPR whose first operand is also a real constant, i.e.
8005              (c1 - x) < c2 becomes x > c1-c2.  */
8006           if (flag_unsafe_math_optimizations
8007               && TREE_CODE (arg1) == REAL_CST
8008               && TREE_CODE (arg0) == MINUS_EXPR
8009               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8010               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8011                                           arg1, 0))
8012               && ! TREE_CONSTANT_OVERFLOW (tem))
8013             return fold (build2 (swap_tree_comparison (code), type,
8014                                  TREE_OPERAND (arg0, 1), tem));
8015
8016           /* Fold comparisons against built-in math functions.  */
8017           if (TREE_CODE (arg1) == REAL_CST
8018               && flag_unsafe_math_optimizations
8019               && ! flag_errno_math)
8020             {
8021               enum built_in_function fcode = builtin_mathfn_code (arg0);
8022
8023               if (fcode != END_BUILTINS)
8024                 {
8025                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8026                   if (tem != NULL_TREE)
8027                     return tem;
8028                 }
8029             }
8030         }
8031
8032       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
8033       if (TREE_CONSTANT (arg1)
8034           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
8035               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
8036           /* This optimization is invalid for ordered comparisons
8037              if CONST+INCR overflows or if foo+incr might overflow.
8038              This optimization is invalid for floating point due to rounding.
8039              For pointer types we assume overflow doesn't happen.  */
8040           && (POINTER_TYPE_P (TREE_TYPE (arg0))
8041               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8042                   && (code == EQ_EXPR || code == NE_EXPR))))
8043         {
8044           tree varop, newconst;
8045
8046           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
8047             {
8048               newconst = fold (build2 (PLUS_EXPR, TREE_TYPE (arg0),
8049                                        arg1, TREE_OPERAND (arg0, 1)));
8050               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
8051                               TREE_OPERAND (arg0, 0),
8052                               TREE_OPERAND (arg0, 1));
8053             }
8054           else
8055             {
8056               newconst = fold (build2 (MINUS_EXPR, TREE_TYPE (arg0),
8057                                        arg1, TREE_OPERAND (arg0, 1)));
8058               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
8059                               TREE_OPERAND (arg0, 0),
8060                               TREE_OPERAND (arg0, 1));
8061             }
8062
8063
8064           /* If VAROP is a reference to a bitfield, we must mask
8065              the constant by the width of the field.  */
8066           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
8067               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
8068               && host_integerp (DECL_SIZE (TREE_OPERAND
8069                                            (TREE_OPERAND (varop, 0), 1)), 1))
8070             {
8071               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
8072               HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
8073               tree folded_compare, shift;
8074
8075               /* First check whether the comparison would come out
8076                  always the same.  If we don't do that we would
8077                  change the meaning with the masking.  */
8078               folded_compare = fold (build2 (code, type,
8079                                              TREE_OPERAND (varop, 0), arg1));
8080               if (integer_zerop (folded_compare)
8081                   || integer_onep (folded_compare))
8082                 return omit_one_operand (type, folded_compare, varop);
8083
8084               shift = build_int_cst (NULL_TREE,
8085                                      TYPE_PRECISION (TREE_TYPE (varop)) - size);
8086               shift = fold_convert (TREE_TYPE (varop), shift);
8087               newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8088                                        newconst, shift));
8089               newconst = fold (build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8090                                        newconst, shift));
8091             }
8092
8093           return fold (build2 (code, type, varop, newconst));
8094         }
8095
8096       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
8097          This transformation affects the cases which are handled in later
8098          optimizations involving comparisons with non-negative constants.  */
8099       if (TREE_CODE (arg1) == INTEGER_CST
8100           && TREE_CODE (arg0) != INTEGER_CST
8101           && tree_int_cst_sgn (arg1) > 0)
8102         {
8103           switch (code)
8104             {
8105             case GE_EXPR:
8106               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8107               return fold (build2 (GT_EXPR, type, arg0, arg1));
8108
8109             case LT_EXPR:
8110               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8111               return fold (build2 (LE_EXPR, type, arg0, arg1));
8112
8113             default:
8114               break;
8115             }
8116         }
8117
8118       /* Comparisons with the highest or lowest possible integer of
8119          the specified size will have known values.
8120
8121          This is quite similar to fold_relational_hi_lo; however, my
8122          attempts to share the code have been nothing but trouble.
8123          I give up for now.  */
8124       {
8125         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
8126
8127         if (TREE_CODE (arg1) == INTEGER_CST
8128             && ! TREE_CONSTANT_OVERFLOW (arg1)
8129             && width <= HOST_BITS_PER_WIDE_INT
8130             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
8131                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
8132           {
8133             unsigned HOST_WIDE_INT signed_max;
8134             unsigned HOST_WIDE_INT max, min;
8135
8136             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
8137
8138             if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
8139               {
8140                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
8141                 min = 0;
8142               }
8143             else
8144               {
8145                 max = signed_max;
8146                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
8147               }
8148
8149             if (TREE_INT_CST_HIGH (arg1) == 0
8150                 && TREE_INT_CST_LOW (arg1) == max)
8151               switch (code)
8152                 {
8153                 case GT_EXPR:
8154                   return omit_one_operand (type, integer_zero_node, arg0);
8155
8156                 case GE_EXPR:
8157                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8158
8159                 case LE_EXPR:
8160                   return omit_one_operand (type, integer_one_node, arg0);
8161
8162                 case LT_EXPR:
8163                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8164
8165                 /* The GE_EXPR and LT_EXPR cases above are not normally
8166                    reached because of previous transformations.  */
8167
8168                 default:
8169                   break;
8170                 }
8171             else if (TREE_INT_CST_HIGH (arg1) == 0
8172                      && TREE_INT_CST_LOW (arg1) == max - 1)
8173               switch (code)
8174                 {
8175                 case GT_EXPR:
8176                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8177                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8178                 case LE_EXPR:
8179                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8180                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8181                 default:
8182                   break;
8183                 }
8184             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8185                      && TREE_INT_CST_LOW (arg1) == min)
8186               switch (code)
8187                 {
8188                 case LT_EXPR:
8189                   return omit_one_operand (type, integer_zero_node, arg0);
8190
8191                 case LE_EXPR:
8192                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8193
8194                 case GE_EXPR:
8195                   return omit_one_operand (type, integer_one_node, arg0);
8196
8197                 case GT_EXPR:
8198                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8199
8200                 default:
8201                   break;
8202                 }
8203             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8204                      && TREE_INT_CST_LOW (arg1) == min + 1)
8205               switch (code)
8206                 {
8207                 case GE_EXPR:
8208                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8209                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8210                 case LT_EXPR:
8211                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8212                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8213                 default:
8214                   break;
8215                 }
8216
8217             else if (!in_gimple_form
8218                      && TREE_INT_CST_HIGH (arg1) == 0
8219                      && TREE_INT_CST_LOW (arg1) == signed_max
8220                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
8221                      /* signed_type does not work on pointer types.  */
8222                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
8223               {
8224                 /* The following case also applies to X < signed_max+1
8225                    and X >= signed_max+1 because previous transformations.  */
8226                 if (code == LE_EXPR || code == GT_EXPR)
8227                   {
8228                     tree st0, st1;
8229                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
8230                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
8231                     return fold
8232                       (build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
8233                                type, fold_convert (st0, arg0),
8234                                fold_convert (st1, integer_zero_node)));
8235                   }
8236               }
8237           }
8238       }
8239
8240       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
8241          a MINUS_EXPR of a constant, we can convert it into a comparison with
8242          a revised constant as long as no overflow occurs.  */
8243       if ((code == EQ_EXPR || code == NE_EXPR)
8244           && TREE_CODE (arg1) == INTEGER_CST
8245           && (TREE_CODE (arg0) == PLUS_EXPR
8246               || TREE_CODE (arg0) == MINUS_EXPR)
8247           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8248           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8249                                       ? MINUS_EXPR : PLUS_EXPR,
8250                                       arg1, TREE_OPERAND (arg0, 1), 0))
8251           && ! TREE_CONSTANT_OVERFLOW (tem))
8252         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8253
8254       /* Similarly for a NEGATE_EXPR.  */
8255       else if ((code == EQ_EXPR || code == NE_EXPR)
8256                && TREE_CODE (arg0) == NEGATE_EXPR
8257                && TREE_CODE (arg1) == INTEGER_CST
8258                && 0 != (tem = negate_expr (arg1))
8259                && TREE_CODE (tem) == INTEGER_CST
8260                && ! TREE_CONSTANT_OVERFLOW (tem))
8261         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8262
8263       /* If we have X - Y == 0, we can convert that to X == Y and similarly
8264          for !=.  Don't do this for ordered comparisons due to overflow.  */
8265       else if ((code == NE_EXPR || code == EQ_EXPR)
8266                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
8267         return fold (build2 (code, type,
8268                              TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
8269
8270       /* If we are widening one operand of an integer comparison,
8271          see if the other operand is similarly being widened.  Perhaps we
8272          can do the comparison in the narrower type.  */
8273       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8274                && TREE_CODE (arg0) == NOP_EXPR
8275                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
8276                && (code == EQ_EXPR || code == NE_EXPR
8277                    || TYPE_UNSIGNED (TREE_TYPE (arg0))
8278                       == TYPE_UNSIGNED (TREE_TYPE (tem)))
8279                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
8280                && (TREE_TYPE (t1) == TREE_TYPE (tem)
8281                    || (TREE_CODE (t1) == INTEGER_CST
8282                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
8283         return fold (build2 (code, type, tem,
8284                              fold_convert (TREE_TYPE (tem), t1)));
8285
8286       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8287          constant, we can simplify it.  */
8288       else if (TREE_CODE (arg1) == INTEGER_CST
8289                && (TREE_CODE (arg0) == MIN_EXPR
8290                    || TREE_CODE (arg0) == MAX_EXPR)
8291                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8292         return optimize_minmax_comparison (t);
8293
8294       /* If we are comparing an ABS_EXPR with a constant, we can
8295          convert all the cases into explicit comparisons, but they may
8296          well not be faster than doing the ABS and one comparison.
8297          But ABS (X) <= C is a range comparison, which becomes a subtraction
8298          and a comparison, and is probably faster.  */
8299       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8300                && TREE_CODE (arg0) == ABS_EXPR
8301                && ! TREE_SIDE_EFFECTS (arg0)
8302                && (0 != (tem = negate_expr (arg1)))
8303                && TREE_CODE (tem) == INTEGER_CST
8304                && ! TREE_CONSTANT_OVERFLOW (tem))
8305         return fold (build2 (TRUTH_ANDIF_EXPR, type,
8306                              build2 (GE_EXPR, type,
8307                                      TREE_OPERAND (arg0, 0), tem),
8308                              build2 (LE_EXPR, type,
8309                                      TREE_OPERAND (arg0, 0), arg1)));
8310
8311       /* If this is an EQ or NE comparison with zero and ARG0 is
8312          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
8313          two operations, but the latter can be done in one less insn
8314          on machines that have only two-operand insns or on which a
8315          constant cannot be the first operand.  */
8316       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
8317           && TREE_CODE (arg0) == BIT_AND_EXPR)
8318         {
8319           tree arg00 = TREE_OPERAND (arg0, 0);
8320           tree arg01 = TREE_OPERAND (arg0, 1);
8321           if (TREE_CODE (arg00) == LSHIFT_EXPR
8322               && integer_onep (TREE_OPERAND (arg00, 0)))
8323             return
8324               fold (build2 (code, type,
8325                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8326                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
8327                                             arg01, TREE_OPERAND (arg00, 1)),
8328                                     fold_convert (TREE_TYPE (arg0),
8329                                                   integer_one_node)),
8330                             arg1));
8331           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
8332                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
8333             return
8334               fold (build2 (code, type,
8335                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8336                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
8337                                             arg00, TREE_OPERAND (arg01, 1)),
8338                                     fold_convert (TREE_TYPE (arg0),
8339                                                   integer_one_node)),
8340                             arg1));
8341         }
8342
8343       /* If this is an NE or EQ comparison of zero against the result of a
8344          signed MOD operation whose second operand is a power of 2, make
8345          the MOD operation unsigned since it is simpler and equivalent.  */
8346       if ((code == NE_EXPR || code == EQ_EXPR)
8347           && integer_zerop (arg1)
8348           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
8349           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
8350               || TREE_CODE (arg0) == CEIL_MOD_EXPR
8351               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
8352               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
8353           && integer_pow2p (TREE_OPERAND (arg0, 1)))
8354         {
8355           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
8356           tree newmod = fold (build2 (TREE_CODE (arg0), newtype,
8357                                       fold_convert (newtype,
8358                                                     TREE_OPERAND (arg0, 0)),
8359                                       fold_convert (newtype,
8360                                                     TREE_OPERAND (arg0, 1))));
8361
8362           return fold (build2 (code, type, newmod,
8363                                fold_convert (newtype, arg1)));
8364         }
8365
8366       /* If this is an NE comparison of zero with an AND of one, remove the
8367          comparison since the AND will give the correct value.  */
8368       if (code == NE_EXPR && integer_zerop (arg1)
8369           && TREE_CODE (arg0) == BIT_AND_EXPR
8370           && integer_onep (TREE_OPERAND (arg0, 1)))
8371         return fold_convert (type, arg0);
8372
8373       /* If we have (A & C) == C where C is a power of 2, convert this into
8374          (A & C) != 0.  Similarly for NE_EXPR.  */
8375       if ((code == EQ_EXPR || code == NE_EXPR)
8376           && TREE_CODE (arg0) == BIT_AND_EXPR
8377           && integer_pow2p (TREE_OPERAND (arg0, 1))
8378           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8379         return fold (build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
8380                              arg0, fold_convert (TREE_TYPE (arg0),
8381                                                  integer_zero_node)));
8382
8383       /* If we have (A & C) != 0 or (A & C) == 0 and C is a power of
8384          2, then fold the expression into shifts and logical operations.  */
8385       tem = fold_single_bit_test (code, arg0, arg1, type);
8386       if (tem)
8387         return tem;
8388
8389       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
8390          Similarly for NE_EXPR.  */
8391       if ((code == EQ_EXPR || code == NE_EXPR)
8392           && TREE_CODE (arg0) == BIT_AND_EXPR
8393           && TREE_CODE (arg1) == INTEGER_CST
8394           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8395         {
8396           tree dandnotc
8397             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8398                             arg1, build1 (BIT_NOT_EXPR,
8399                                           TREE_TYPE (TREE_OPERAND (arg0, 1)),
8400                                           TREE_OPERAND (arg0, 1))));
8401           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8402           if (integer_nonzerop (dandnotc))
8403             return omit_one_operand (type, rslt, arg0);
8404         }
8405
8406       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
8407          Similarly for NE_EXPR.  */
8408       if ((code == EQ_EXPR || code == NE_EXPR)
8409           && TREE_CODE (arg0) == BIT_IOR_EXPR
8410           && TREE_CODE (arg1) == INTEGER_CST
8411           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8412         {
8413           tree candnotd
8414             = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8415                             TREE_OPERAND (arg0, 1),
8416                             build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1)));
8417           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8418           if (integer_nonzerop (candnotd))
8419             return omit_one_operand (type, rslt, arg0);
8420         }
8421
8422       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
8423          and similarly for >= into !=.  */
8424       if ((code == LT_EXPR || code == GE_EXPR)
8425           && TYPE_UNSIGNED (TREE_TYPE (arg0))
8426           && TREE_CODE (arg1) == LSHIFT_EXPR
8427           && integer_onep (TREE_OPERAND (arg1, 0)))
8428         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8429                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8430                                TREE_OPERAND (arg1, 1)),
8431                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
8432
8433       else if ((code == LT_EXPR || code == GE_EXPR)
8434                && TYPE_UNSIGNED (TREE_TYPE (arg0))
8435                && (TREE_CODE (arg1) == NOP_EXPR
8436                    || TREE_CODE (arg1) == CONVERT_EXPR)
8437                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
8438                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
8439         return
8440           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8441                   fold_convert (TREE_TYPE (arg0),
8442                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8443                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
8444                                                       1))),
8445                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
8446
8447       /* Simplify comparison of something with itself.  (For IEEE
8448          floating-point, we can only do some of these simplifications.)  */
8449       if (operand_equal_p (arg0, arg1, 0))
8450         {
8451           switch (code)
8452             {
8453             case EQ_EXPR:
8454               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8455                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8456                 return constant_boolean_node (1, type);
8457               break;
8458
8459             case GE_EXPR:
8460             case LE_EXPR:
8461               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8462                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8463                 return constant_boolean_node (1, type);
8464               return fold (build2 (EQ_EXPR, type, arg0, arg1));
8465
8466             case NE_EXPR:
8467               /* For NE, we can only do this simplification if integer
8468                  or we don't honor IEEE floating point NaNs.  */
8469               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8470                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8471                 break;
8472               /* ... fall through ...  */
8473             case GT_EXPR:
8474             case LT_EXPR:
8475               return constant_boolean_node (0, type);
8476             default:
8477               gcc_unreachable ();
8478             }
8479         }
8480
8481       /* If we are comparing an expression that just has comparisons
8482          of two integer values, arithmetic expressions of those comparisons,
8483          and constants, we can simplify it.  There are only three cases
8484          to check: the two values can either be equal, the first can be
8485          greater, or the second can be greater.  Fold the expression for
8486          those three values.  Since each value must be 0 or 1, we have
8487          eight possibilities, each of which corresponds to the constant 0
8488          or 1 or one of the six possible comparisons.
8489
8490          This handles common cases like (a > b) == 0 but also handles
8491          expressions like  ((x > y) - (y > x)) > 0, which supposedly
8492          occur in macroized code.  */
8493
8494       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8495         {
8496           tree cval1 = 0, cval2 = 0;
8497           int save_p = 0;
8498
8499           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8500               /* Don't handle degenerate cases here; they should already
8501                  have been handled anyway.  */
8502               && cval1 != 0 && cval2 != 0
8503               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8504               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8505               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8506               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8507               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8508               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8509                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8510             {
8511               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8512               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8513
8514               /* We can't just pass T to eval_subst in case cval1 or cval2
8515                  was the same as ARG1.  */
8516
8517               tree high_result
8518                 = fold (build2 (code, type,
8519                                 eval_subst (arg0, cval1, maxval,
8520                                             cval2, minval),
8521                                 arg1));
8522               tree equal_result
8523                 = fold (build2 (code, type,
8524                                 eval_subst (arg0, cval1, maxval,
8525                                             cval2, maxval),
8526                                 arg1));
8527               tree low_result
8528                 = fold (build2 (code, type,
8529                                 eval_subst (arg0, cval1, minval,
8530                                             cval2, maxval),
8531                                 arg1));
8532
8533               /* All three of these results should be 0 or 1.  Confirm they
8534                  are.  Then use those values to select the proper code
8535                  to use.  */
8536
8537               if ((integer_zerop (high_result)
8538                    || integer_onep (high_result))
8539                   && (integer_zerop (equal_result)
8540                       || integer_onep (equal_result))
8541                   && (integer_zerop (low_result)
8542                       || integer_onep (low_result)))
8543                 {
8544                   /* Make a 3-bit mask with the high-order bit being the
8545                      value for `>', the next for '=', and the low for '<'.  */
8546                   switch ((integer_onep (high_result) * 4)
8547                           + (integer_onep (equal_result) * 2)
8548                           + integer_onep (low_result))
8549                     {
8550                     case 0:
8551                       /* Always false.  */
8552                       return omit_one_operand (type, integer_zero_node, arg0);
8553                     case 1:
8554                       code = LT_EXPR;
8555                       break;
8556                     case 2:
8557                       code = EQ_EXPR;
8558                       break;
8559                     case 3:
8560                       code = LE_EXPR;
8561                       break;
8562                     case 4:
8563                       code = GT_EXPR;
8564                       break;
8565                     case 5:
8566                       code = NE_EXPR;
8567                       break;
8568                     case 6:
8569                       code = GE_EXPR;
8570                       break;
8571                     case 7:
8572                       /* Always true.  */
8573                       return omit_one_operand (type, integer_one_node, arg0);
8574                     }
8575
8576                   tem = build2 (code, type, cval1, cval2);
8577                   if (save_p)
8578                     return save_expr (tem);
8579                   else
8580                     return fold (tem);
8581                 }
8582             }
8583         }
8584
8585       /* If this is a comparison of a field, we may be able to simplify it.  */
8586       if (((TREE_CODE (arg0) == COMPONENT_REF
8587             && lang_hooks.can_use_bit_fields_p ())
8588            || TREE_CODE (arg0) == BIT_FIELD_REF)
8589           && (code == EQ_EXPR || code == NE_EXPR)
8590           /* Handle the constant case even without -O
8591              to make sure the warnings are given.  */
8592           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
8593         {
8594           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
8595           if (t1)
8596             return t1;
8597         }
8598
8599       /* If this is a comparison of complex values and either or both sides
8600          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
8601          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
8602          This may prevent needless evaluations.  */
8603       if ((code == EQ_EXPR || code == NE_EXPR)
8604           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
8605           && (TREE_CODE (arg0) == COMPLEX_EXPR
8606               || TREE_CODE (arg1) == COMPLEX_EXPR
8607               || TREE_CODE (arg0) == COMPLEX_CST
8608               || TREE_CODE (arg1) == COMPLEX_CST))
8609         {
8610           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
8611           tree real0, imag0, real1, imag1;
8612
8613           arg0 = save_expr (arg0);
8614           arg1 = save_expr (arg1);
8615           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
8616           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
8617           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
8618           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
8619
8620           return fold (build2 ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
8621                                 : TRUTH_ORIF_EXPR),
8622                                type,
8623                                fold (build2 (code, type, real0, real1)),
8624                                fold (build2 (code, type, imag0, imag1))));
8625         }
8626
8627       /* Optimize comparisons of strlen vs zero to a compare of the
8628          first character of the string vs zero.  To wit,
8629                 strlen(ptr) == 0   =>  *ptr == 0
8630                 strlen(ptr) != 0   =>  *ptr != 0
8631          Other cases should reduce to one of these two (or a constant)
8632          due to the return value of strlen being unsigned.  */
8633       if ((code == EQ_EXPR || code == NE_EXPR)
8634           && integer_zerop (arg1)
8635           && TREE_CODE (arg0) == CALL_EXPR)
8636         {
8637           tree fndecl = get_callee_fndecl (arg0);
8638           tree arglist;
8639
8640           if (fndecl
8641               && DECL_BUILT_IN (fndecl)
8642               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
8643               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
8644               && (arglist = TREE_OPERAND (arg0, 1))
8645               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
8646               && ! TREE_CHAIN (arglist))
8647             return fold (build2 (code, type,
8648                                  build1 (INDIRECT_REF, char_type_node,
8649                                          TREE_VALUE (arglist)),
8650                                  fold_convert (char_type_node,
8651                                                integer_zero_node)));
8652         }
8653
8654       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8655          into a single range test.  */
8656       if (TREE_CODE (arg0) == TRUNC_DIV_EXPR
8657           && TREE_CODE (arg1) == INTEGER_CST
8658           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8659           && !integer_zerop (TREE_OPERAND (arg0, 1))
8660           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8661           && !TREE_OVERFLOW (arg1))
8662         {
8663           t1 = fold_div_compare (code, type, arg0, arg1);
8664           if (t1 != NULL_TREE)
8665             return t1;
8666         }
8667
8668       if ((code == EQ_EXPR || code == NE_EXPR)
8669           && !TREE_SIDE_EFFECTS (arg0)
8670           && integer_zerop (arg1)
8671           && tree_expr_nonzero_p (arg0))
8672         return constant_boolean_node (code==NE_EXPR, type);
8673
8674       t1 = fold_relational_const (code, type, arg0, arg1);
8675       return t1 == NULL_TREE ? t : t1;
8676
8677     case UNORDERED_EXPR:
8678     case ORDERED_EXPR:
8679     case UNLT_EXPR:
8680     case UNLE_EXPR:
8681     case UNGT_EXPR:
8682     case UNGE_EXPR:
8683     case UNEQ_EXPR:
8684     case LTGT_EXPR:
8685       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8686         {
8687           t1 = fold_relational_const (code, type, arg0, arg1);
8688           if (t1 != NULL_TREE)
8689             return t1;
8690         }
8691
8692       /* If the first operand is NaN, the result is constant.  */
8693       if (TREE_CODE (arg0) == REAL_CST
8694           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
8695           && (code != LTGT_EXPR || ! flag_trapping_math))
8696         {
8697           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8698                ? integer_zero_node
8699                : integer_one_node;
8700           return omit_one_operand (type, t1, arg1);
8701         }
8702
8703       /* If the second operand is NaN, the result is constant.  */
8704       if (TREE_CODE (arg1) == REAL_CST
8705           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
8706           && (code != LTGT_EXPR || ! flag_trapping_math))
8707         {
8708           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8709                ? integer_zero_node
8710                : integer_one_node;
8711           return omit_one_operand (type, t1, arg0);
8712         }
8713
8714       /* Simplify unordered comparison of something with itself.  */
8715       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
8716           && operand_equal_p (arg0, arg1, 0))
8717         return constant_boolean_node (1, type);
8718
8719       if (code == LTGT_EXPR
8720           && !flag_trapping_math
8721           && operand_equal_p (arg0, arg1, 0))
8722         return constant_boolean_node (0, type);
8723
8724       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8725       {
8726         tree targ0 = strip_float_extensions (arg0);
8727         tree targ1 = strip_float_extensions (arg1);
8728         tree newtype = TREE_TYPE (targ0);
8729
8730         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8731           newtype = TREE_TYPE (targ1);
8732
8733         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8734           return fold (build2 (code, type, fold_convert (newtype, targ0),
8735                                fold_convert (newtype, targ1)));
8736       }
8737
8738       return t;
8739
8740     case COND_EXPR:
8741       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
8742          so all simple results must be passed through pedantic_non_lvalue.  */
8743       if (TREE_CODE (arg0) == INTEGER_CST)
8744         {
8745           tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
8746           /* Only optimize constant conditions when the selected branch
8747              has the same type as the COND_EXPR.  This avoids optimizing
8748              away "c ? x : throw", where the throw has a void type.  */
8749           if (! VOID_TYPE_P (TREE_TYPE (tem))
8750               || VOID_TYPE_P (type))
8751             return pedantic_non_lvalue (tem);
8752           return t;
8753         }
8754       if (operand_equal_p (arg1, TREE_OPERAND (t, 2), 0))
8755         return pedantic_omit_one_operand (type, arg1, arg0);
8756
8757       /* If we have A op B ? A : C, we may be able to convert this to a
8758          simpler expression, depending on the operation and the values
8759          of B and C.  Signed zeros prevent all of these transformations,
8760          for reasons given above each one.
8761
8762          Also try swapping the arguments and inverting the conditional.  */
8763       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8764           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8765                                              arg1, TREE_OPERAND (arg0, 1))
8766           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
8767         {
8768           tem = fold_cond_expr_with_comparison (type, arg0,
8769                                                 TREE_OPERAND (t, 1),
8770                                                 TREE_OPERAND (t, 2));
8771           if (tem)
8772             return tem;
8773         }
8774
8775       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
8776           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8777                                              TREE_OPERAND (t, 2),
8778                                              TREE_OPERAND (arg0, 1))
8779           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
8780         {
8781           tem = invert_truthvalue (arg0);
8782           if (TREE_CODE_CLASS (TREE_CODE (tem)) == '<')
8783             {
8784               tem = fold_cond_expr_with_comparison (type, tem,
8785                                                     TREE_OPERAND (t, 2),
8786                                                     TREE_OPERAND (t, 1));
8787               if (tem)
8788                 return tem;
8789             }
8790         }
8791
8792       /* If the second operand is simpler than the third, swap them
8793          since that produces better jump optimization results.  */
8794       if (tree_swap_operands_p (TREE_OPERAND (t, 1),
8795                                 TREE_OPERAND (t, 2), false))
8796         {
8797           /* See if this can be inverted.  If it can't, possibly because
8798              it was a floating-point inequality comparison, don't do
8799              anything.  */
8800           tem = invert_truthvalue (arg0);
8801
8802           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8803             return fold (build3 (code, type, tem,
8804                                  TREE_OPERAND (t, 2), TREE_OPERAND (t, 1)));
8805         }
8806
8807       /* Convert A ? 1 : 0 to simply A.  */
8808       if (integer_onep (TREE_OPERAND (t, 1))
8809           && integer_zerop (TREE_OPERAND (t, 2))
8810           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
8811              call to fold will try to move the conversion inside
8812              a COND, which will recurse.  In that case, the COND_EXPR
8813              is probably the best choice, so leave it alone.  */
8814           && type == TREE_TYPE (arg0))
8815         return pedantic_non_lvalue (arg0);
8816
8817       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
8818          over COND_EXPR in cases such as floating point comparisons.  */
8819       if (integer_zerop (TREE_OPERAND (t, 1))
8820           && integer_onep (TREE_OPERAND (t, 2))
8821           && truth_value_p (TREE_CODE (arg0)))
8822         return pedantic_non_lvalue (fold_convert (type,
8823                                                   invert_truthvalue (arg0)));
8824
8825       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
8826       if (TREE_CODE (arg0) == LT_EXPR
8827           && integer_zerop (TREE_OPERAND (arg0, 1))
8828           && integer_zerop (TREE_OPERAND (t, 2))
8829           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
8830         return fold_convert (type, fold (build2 (BIT_AND_EXPR,
8831                                                  TREE_TYPE (tem), tem, arg1)));
8832
8833       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
8834          already handled above.  */
8835       if (TREE_CODE (arg0) == BIT_AND_EXPR
8836           && integer_onep (TREE_OPERAND (arg0, 1))
8837           && integer_zerop (TREE_OPERAND (t, 2))
8838           && integer_pow2p (arg1))
8839         {
8840           tree tem = TREE_OPERAND (arg0, 0);
8841           STRIP_NOPS (tem);
8842           if (TREE_CODE (tem) == RSHIFT_EXPR
8843               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
8844               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
8845                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
8846             return fold (build2 (BIT_AND_EXPR, type,
8847                                  TREE_OPERAND (tem, 0), arg1));
8848         }
8849
8850       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
8851          is probably obsolete because the first operand should be a
8852          truth value (that's why we have the two cases above), but let's
8853          leave it in until we can confirm this for all front-ends.  */
8854       if (integer_zerop (TREE_OPERAND (t, 2))
8855           && TREE_CODE (arg0) == NE_EXPR
8856           && integer_zerop (TREE_OPERAND (arg0, 1))
8857           && integer_pow2p (arg1)
8858           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
8859           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
8860                               arg1, OEP_ONLY_CONST))
8861         return pedantic_non_lvalue (fold_convert (type,
8862                                                   TREE_OPERAND (arg0, 0)));
8863
8864       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
8865       if (integer_zerop (TREE_OPERAND (t, 2))
8866           && truth_value_p (TREE_CODE (arg0))
8867           && truth_value_p (TREE_CODE (arg1)))
8868         return fold (build2 (TRUTH_ANDIF_EXPR, type, arg0, arg1));
8869
8870       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
8871       if (integer_onep (TREE_OPERAND (t, 2))
8872           && truth_value_p (TREE_CODE (arg0))
8873           && truth_value_p (TREE_CODE (arg1)))
8874         {
8875           /* Only perform transformation if ARG0 is easily inverted.  */
8876           tem = invert_truthvalue (arg0);
8877           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8878             return fold (build2 (TRUTH_ORIF_EXPR, type, tem, arg1));
8879         }
8880
8881       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
8882       if (integer_zerop (arg1)
8883           && truth_value_p (TREE_CODE (arg0))
8884           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8885         {
8886           /* Only perform transformation if ARG0 is easily inverted.  */
8887           tem = invert_truthvalue (arg0);
8888           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8889             return fold (build2 (TRUTH_ANDIF_EXPR, type, tem,
8890                                  TREE_OPERAND (t, 2)));
8891         }
8892
8893       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
8894       if (integer_onep (arg1)
8895           && truth_value_p (TREE_CODE (arg0))
8896           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
8897         return fold (build2 (TRUTH_ORIF_EXPR, type, arg0,
8898                              TREE_OPERAND (t, 2)));
8899
8900       return t;
8901
8902     case COMPOUND_EXPR:
8903       /* When pedantic, a compound expression can be neither an lvalue
8904          nor an integer constant expression.  */
8905       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
8906         return t;
8907       /* Don't let (0, 0) be null pointer constant.  */
8908       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
8909                                  : fold_convert (type, arg1);
8910       return pedantic_non_lvalue (tem);
8911
8912     case COMPLEX_EXPR:
8913       if (wins)
8914         return build_complex (type, arg0, arg1);
8915       return t;
8916
8917     case REALPART_EXPR:
8918       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8919         return t;
8920       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8921         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8922                                  TREE_OPERAND (arg0, 1));
8923       else if (TREE_CODE (arg0) == COMPLEX_CST)
8924         return TREE_REALPART (arg0);
8925       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8926         return fold (build2 (TREE_CODE (arg0), type,
8927                              fold (build1 (REALPART_EXPR, type,
8928                                            TREE_OPERAND (arg0, 0))),
8929                              fold (build1 (REALPART_EXPR, type,
8930                                            TREE_OPERAND (arg0, 1)))));
8931       return t;
8932
8933     case IMAGPART_EXPR:
8934       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8935         return fold_convert (type, integer_zero_node);
8936       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
8937         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8938                                  TREE_OPERAND (arg0, 0));
8939       else if (TREE_CODE (arg0) == COMPLEX_CST)
8940         return TREE_IMAGPART (arg0);
8941       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8942         return fold (build2 (TREE_CODE (arg0), type,
8943                              fold (build1 (IMAGPART_EXPR, type,
8944                                            TREE_OPERAND (arg0, 0))),
8945                              fold (build1 (IMAGPART_EXPR, type,
8946                                            TREE_OPERAND (arg0, 1)))));
8947       return t;
8948
8949     case CLEANUP_POINT_EXPR:
8950       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
8951          appropriate.  */
8952       if (! has_cleanups (arg0))
8953         return TREE_OPERAND (t, 0);
8954
8955       {
8956         enum tree_code code0 = TREE_CODE (arg0);
8957         int kind0 = TREE_CODE_CLASS (code0);
8958
8959         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
8960           {
8961             tree arg00 = TREE_OPERAND (arg0, 0);
8962             return fold (build1 (code0, type,
8963                                  fold (build1 (CLEANUP_POINT_EXPR,
8964                                                TREE_TYPE (arg00), arg00))));
8965           }
8966
8967         if (kind0 == '<' || kind0 == '2'
8968             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
8969             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
8970             || code0 == TRUTH_XOR_EXPR)
8971           {
8972             tree arg00 = TREE_OPERAND (arg0, 0);
8973             tree arg01 = TREE_OPERAND (arg0, 1);
8974
8975             if (TREE_CONSTANT (arg00)
8976                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
8977                     && ! has_cleanups (arg00)))
8978               return fold (build2 (code0, type, arg00,
8979                                    fold (build1 (CLEANUP_POINT_EXPR,
8980                                                  TREE_TYPE (arg01), arg01))));
8981
8982             if (TREE_CONSTANT (arg01))
8983               return fold (build2 (code0, type,
8984                                    fold (build1 (CLEANUP_POINT_EXPR,
8985                                                  TREE_TYPE (arg00), arg00)),
8986                                    arg01));
8987           }
8988
8989         return t;
8990       }
8991
8992     case CALL_EXPR:
8993       /* Check for a built-in function.  */
8994       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
8995           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
8996               == FUNCTION_DECL)
8997           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
8998         {
8999           tree tmp = fold_builtin (t, false);
9000           if (tmp)
9001             return tmp;
9002         }
9003       return t;
9004
9005     default:
9006       return t;
9007     } /* switch (code) */
9008 }
9009
9010 #ifdef ENABLE_FOLD_CHECKING
9011 #undef fold
9012
9013 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
9014 static void fold_check_failed (tree, tree);
9015 void print_fold_checksum (tree);
9016
9017 /* When --enable-checking=fold, compute a digest of expr before
9018    and after actual fold call to see if fold did not accidentally
9019    change original expr.  */
9020
9021 tree
9022 fold (tree expr)
9023 {
9024   tree ret;
9025   struct md5_ctx ctx;
9026   unsigned char checksum_before[16], checksum_after[16];
9027   htab_t ht;
9028
9029   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
9030   md5_init_ctx (&ctx);
9031   fold_checksum_tree (expr, &ctx, ht);
9032   md5_finish_ctx (&ctx, checksum_before);
9033   htab_empty (ht);
9034
9035   ret = fold_1 (expr);
9036
9037   md5_init_ctx (&ctx);
9038   fold_checksum_tree (expr, &ctx, ht);
9039   md5_finish_ctx (&ctx, checksum_after);
9040   htab_delete (ht);
9041
9042   if (memcmp (checksum_before, checksum_after, 16))
9043     fold_check_failed (expr, ret);
9044
9045   return ret;
9046 }
9047
9048 void
9049 print_fold_checksum (tree expr)
9050 {
9051   struct md5_ctx ctx;
9052   unsigned char checksum[16], cnt;
9053   htab_t ht;
9054
9055   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
9056   md5_init_ctx (&ctx);
9057   fold_checksum_tree (expr, &ctx, ht);
9058   md5_finish_ctx (&ctx, checksum);
9059   htab_delete (ht);
9060   for (cnt = 0; cnt < 16; ++cnt)
9061     fprintf (stderr, "%02x", checksum[cnt]);
9062   putc ('\n', stderr);
9063 }
9064
9065 static void
9066 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
9067 {
9068   internal_error ("fold check: original tree changed by fold");
9069 }
9070
9071 static void
9072 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
9073 {
9074   void **slot;
9075   enum tree_code code;
9076   char buf[sizeof (struct tree_decl)];
9077   int i, len;
9078
9079   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
9080                <= sizeof (struct tree_decl))
9081               && sizeof (struct tree_type) <= sizeof (struct tree_decl));
9082   if (expr == NULL)
9083     return;
9084   slot = htab_find_slot (ht, expr, INSERT);
9085   if (*slot != NULL)
9086     return;
9087   *slot = expr;
9088   code = TREE_CODE (expr);
9089   if (TREE_CODE_CLASS (code) == 'd' && DECL_ASSEMBLER_NAME_SET_P (expr))
9090     {
9091       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
9092       memcpy (buf, expr, tree_size (expr));
9093       expr = (tree) buf;
9094       SET_DECL_ASSEMBLER_NAME (expr, NULL);
9095     }
9096   else if (TREE_CODE_CLASS (code) == 't'
9097            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)))
9098     {
9099       /* Allow TYPE_POINTER_TO and TYPE_REFERENCE_TO to be modified.  */
9100       memcpy (buf, expr, tree_size (expr));
9101       expr = (tree) buf;
9102       TYPE_POINTER_TO (expr) = NULL;
9103       TYPE_REFERENCE_TO (expr) = NULL;
9104     }
9105   md5_process_bytes (expr, tree_size (expr), ctx);
9106   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
9107   if (TREE_CODE_CLASS (code) != 't' && TREE_CODE_CLASS (code) != 'd')
9108     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
9109   switch (TREE_CODE_CLASS (code))
9110     {
9111     case 'c':
9112       switch (code)
9113         {
9114         case STRING_CST:
9115           md5_process_bytes (TREE_STRING_POINTER (expr),
9116                              TREE_STRING_LENGTH (expr), ctx);
9117           break;
9118         case COMPLEX_CST:
9119           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
9120           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
9121           break;
9122         case VECTOR_CST:
9123           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
9124           break;
9125         default:
9126           break;
9127         }
9128       break;
9129     case 'x':
9130       switch (code)
9131         {
9132         case TREE_LIST:
9133           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
9134           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
9135           break;
9136         case TREE_VEC:
9137           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
9138             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
9139           break;
9140         default:
9141           break;
9142         }
9143       break;
9144     case 'e':
9145     case 'r':
9146     case '<':
9147     case '1':
9148     case '2':
9149     case 's':
9150       len = first_rtl_op (code);
9151       for (i = 0; i < len; ++i)
9152         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
9153       break;
9154     case 'd':
9155       fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
9156       fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
9157       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
9158       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
9159       fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
9160       fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
9161       fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
9162       fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
9163       fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
9164       fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
9165       fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
9166       break;
9167     case 't':
9168       if (TREE_CODE (expr) == ENUMERAL_TYPE)
9169         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
9170       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
9171       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
9172       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
9173       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
9174       if (INTEGRAL_TYPE_P (expr)
9175           || SCALAR_FLOAT_TYPE_P (expr))
9176         {
9177           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
9178           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
9179         }
9180       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
9181       fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
9182       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
9183       break;
9184     default:
9185       break;
9186     }
9187 }
9188
9189 #endif
9190
9191 /* Perform constant folding and related simplification of initializer
9192    expression EXPR.  This behaves identically to "fold" but ignores
9193    potential run-time traps and exceptions that fold must preserve.  */
9194
9195 tree
9196 fold_initializer (tree expr)
9197 {
9198   int saved_signaling_nans = flag_signaling_nans;
9199   int saved_trapping_math = flag_trapping_math;
9200   int saved_trapv = flag_trapv;
9201   tree result;
9202
9203   flag_signaling_nans = 0;
9204   flag_trapping_math = 0;
9205   flag_trapv = 0;
9206
9207   result = fold (expr);
9208
9209   flag_signaling_nans = saved_signaling_nans;
9210   flag_trapping_math = saved_trapping_math;
9211   flag_trapv = saved_trapv;
9212
9213   return result;
9214 }
9215
9216 /* Determine if first argument is a multiple of second argument.  Return 0 if
9217    it is not, or we cannot easily determined it to be.
9218
9219    An example of the sort of thing we care about (at this point; this routine
9220    could surely be made more general, and expanded to do what the *_DIV_EXPR's
9221    fold cases do now) is discovering that
9222
9223      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9224
9225    is a multiple of
9226
9227      SAVE_EXPR (J * 8)
9228
9229    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
9230
9231    This code also handles discovering that
9232
9233      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9234
9235    is a multiple of 8 so we don't have to worry about dealing with a
9236    possible remainder.
9237
9238    Note that we *look* inside a SAVE_EXPR only to determine how it was
9239    calculated; it is not safe for fold to do much of anything else with the
9240    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
9241    at run time.  For example, the latter example above *cannot* be implemented
9242    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
9243    evaluation time of the original SAVE_EXPR is not necessarily the same at
9244    the time the new expression is evaluated.  The only optimization of this
9245    sort that would be valid is changing
9246
9247      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
9248
9249    divided by 8 to
9250
9251      SAVE_EXPR (I) * SAVE_EXPR (J)
9252
9253    (where the same SAVE_EXPR (J) is used in the original and the
9254    transformed version).  */
9255
9256 static int
9257 multiple_of_p (tree type, tree top, tree bottom)
9258 {
9259   if (operand_equal_p (top, bottom, 0))
9260     return 1;
9261
9262   if (TREE_CODE (type) != INTEGER_TYPE)
9263     return 0;
9264
9265   switch (TREE_CODE (top))
9266     {
9267     case MULT_EXPR:
9268       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9269               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9270
9271     case PLUS_EXPR:
9272     case MINUS_EXPR:
9273       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9274               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9275
9276     case LSHIFT_EXPR:
9277       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
9278         {
9279           tree op1, t1;
9280
9281           op1 = TREE_OPERAND (top, 1);
9282           /* const_binop may not detect overflow correctly,
9283              so check for it explicitly here.  */
9284           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
9285               > TREE_INT_CST_LOW (op1)
9286               && TREE_INT_CST_HIGH (op1) == 0
9287               && 0 != (t1 = fold_convert (type,
9288                                           const_binop (LSHIFT_EXPR,
9289                                                        size_one_node,
9290                                                        op1, 0)))
9291               && ! TREE_OVERFLOW (t1))
9292             return multiple_of_p (type, t1, bottom);
9293         }
9294       return 0;
9295
9296     case NOP_EXPR:
9297       /* Can't handle conversions from non-integral or wider integral type.  */
9298       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
9299           || (TYPE_PRECISION (type)
9300               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
9301         return 0;
9302
9303       /* .. fall through ...  */
9304
9305     case SAVE_EXPR:
9306       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
9307
9308     case INTEGER_CST:
9309       if (TREE_CODE (bottom) != INTEGER_CST
9310           || (TYPE_UNSIGNED (type)
9311               && (tree_int_cst_sgn (top) < 0
9312                   || tree_int_cst_sgn (bottom) < 0)))
9313         return 0;
9314       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
9315                                          top, bottom, 0));
9316
9317     default:
9318       return 0;
9319     }
9320 }
9321
9322 /* Return true if `t' is known to be non-negative.  */
9323
9324 int
9325 tree_expr_nonnegative_p (tree t)
9326 {
9327   switch (TREE_CODE (t))
9328     {
9329     case ABS_EXPR:
9330       return 1;
9331
9332     case INTEGER_CST:
9333       return tree_int_cst_sgn (t) >= 0;
9334
9335     case REAL_CST:
9336       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
9337
9338     case PLUS_EXPR:
9339       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9340         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9341                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9342
9343       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
9344          both unsigned and at least 2 bits shorter than the result.  */
9345       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9346           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9347           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9348         {
9349           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9350           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9351           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9352               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9353             {
9354               unsigned int prec = MAX (TYPE_PRECISION (inner1),
9355                                        TYPE_PRECISION (inner2)) + 1;
9356               return prec < TYPE_PRECISION (TREE_TYPE (t));
9357             }
9358         }
9359       break;
9360
9361     case MULT_EXPR:
9362       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9363         {
9364           /* x * x for floating point x is always non-negative.  */
9365           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
9366             return 1;
9367           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9368                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9369         }
9370
9371       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
9372          both unsigned and their total bits is shorter than the result.  */
9373       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9374           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9375           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9376         {
9377           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9378           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9379           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9380               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9381             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
9382                    < TYPE_PRECISION (TREE_TYPE (t));
9383         }
9384       return 0;
9385
9386     case TRUNC_DIV_EXPR:
9387     case CEIL_DIV_EXPR:
9388     case FLOOR_DIV_EXPR:
9389     case ROUND_DIV_EXPR:
9390       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9391              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9392
9393     case TRUNC_MOD_EXPR:
9394     case CEIL_MOD_EXPR:
9395     case FLOOR_MOD_EXPR:
9396     case ROUND_MOD_EXPR:
9397       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9398
9399     case RDIV_EXPR:
9400       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9401              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9402
9403     case BIT_AND_EXPR:
9404       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9405              || tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9406     case BIT_IOR_EXPR:
9407     case BIT_XOR_EXPR:
9408       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9409              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9410
9411     case NOP_EXPR:
9412       {
9413         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9414         tree outer_type = TREE_TYPE (t);
9415
9416         if (TREE_CODE (outer_type) == REAL_TYPE)
9417           {
9418             if (TREE_CODE (inner_type) == REAL_TYPE)
9419               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9420             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9421               {
9422                 if (TYPE_UNSIGNED (inner_type))
9423                   return 1;
9424                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9425               }
9426           }
9427         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
9428           {
9429             if (TREE_CODE (inner_type) == REAL_TYPE)
9430               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
9431             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9432               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
9433                       && TYPE_UNSIGNED (inner_type);
9434           }
9435       }
9436       break;
9437
9438     case COND_EXPR:
9439       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9440         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
9441     case COMPOUND_EXPR:
9442       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9443     case MIN_EXPR:
9444       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9445         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9446     case MAX_EXPR:
9447       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9448         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9449     case MODIFY_EXPR:
9450       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9451     case BIND_EXPR:
9452       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
9453     case SAVE_EXPR:
9454       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9455     case NON_LVALUE_EXPR:
9456       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9457     case FLOAT_EXPR:
9458       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9459
9460     case TARGET_EXPR:
9461       {
9462         tree temp = TARGET_EXPR_SLOT (t);
9463         t = TARGET_EXPR_INITIAL (t);
9464
9465         /* If the initializer is non-void, then it's a normal expression
9466            that will be assigned to the slot.  */
9467         if (!VOID_TYPE_P (t))
9468           return tree_expr_nonnegative_p (t);
9469
9470         /* Otherwise, the initializer sets the slot in some way.  One common
9471            way is an assignment statement at the end of the initializer.  */
9472         while (1)
9473           {
9474             if (TREE_CODE (t) == BIND_EXPR)
9475               t = expr_last (BIND_EXPR_BODY (t));
9476             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
9477                      || TREE_CODE (t) == TRY_CATCH_EXPR)
9478               t = expr_last (TREE_OPERAND (t, 0));
9479             else if (TREE_CODE (t) == STATEMENT_LIST)
9480               t = expr_last (t);
9481             else
9482               break;
9483           }
9484         if (TREE_CODE (t) == MODIFY_EXPR
9485             && TREE_OPERAND (t, 0) == temp)
9486           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9487
9488         return 0;
9489       }
9490
9491     case CALL_EXPR:
9492       {
9493         tree fndecl = get_callee_fndecl (t);
9494         tree arglist = TREE_OPERAND (t, 1);
9495         if (fndecl
9496             && DECL_BUILT_IN (fndecl)
9497             && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
9498           switch (DECL_FUNCTION_CODE (fndecl))
9499             {
9500 #define CASE_BUILTIN_F(BUILT_IN_FN) \
9501   case BUILT_IN_FN: case BUILT_IN_FN##F: case BUILT_IN_FN##L:
9502 #define CASE_BUILTIN_I(BUILT_IN_FN) \
9503   case BUILT_IN_FN: case BUILT_IN_FN##L: case BUILT_IN_FN##LL:
9504
9505             CASE_BUILTIN_F (BUILT_IN_ACOS)
9506             CASE_BUILTIN_F (BUILT_IN_ACOSH)
9507             CASE_BUILTIN_F (BUILT_IN_CABS)
9508             CASE_BUILTIN_F (BUILT_IN_COSH)
9509             CASE_BUILTIN_F (BUILT_IN_ERFC)
9510             CASE_BUILTIN_F (BUILT_IN_EXP)
9511             CASE_BUILTIN_F (BUILT_IN_EXP10)
9512             CASE_BUILTIN_F (BUILT_IN_EXP2)
9513             CASE_BUILTIN_F (BUILT_IN_FABS)
9514             CASE_BUILTIN_F (BUILT_IN_FDIM)
9515             CASE_BUILTIN_F (BUILT_IN_FREXP)
9516             CASE_BUILTIN_F (BUILT_IN_HYPOT)
9517             CASE_BUILTIN_F (BUILT_IN_POW10)
9518             CASE_BUILTIN_I (BUILT_IN_FFS)
9519             CASE_BUILTIN_I (BUILT_IN_PARITY)
9520             CASE_BUILTIN_I (BUILT_IN_POPCOUNT)
9521               /* Always true.  */
9522               return 1;
9523
9524             CASE_BUILTIN_F (BUILT_IN_SQRT)
9525               /* sqrt(-0.0) is -0.0.  */
9526               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
9527                 return 1;
9528               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9529
9530             CASE_BUILTIN_F (BUILT_IN_ASINH)
9531             CASE_BUILTIN_F (BUILT_IN_ATAN)
9532             CASE_BUILTIN_F (BUILT_IN_ATANH)
9533             CASE_BUILTIN_F (BUILT_IN_CBRT)
9534             CASE_BUILTIN_F (BUILT_IN_CEIL)
9535             CASE_BUILTIN_F (BUILT_IN_ERF)
9536             CASE_BUILTIN_F (BUILT_IN_EXPM1)
9537             CASE_BUILTIN_F (BUILT_IN_FLOOR)
9538             CASE_BUILTIN_F (BUILT_IN_FMOD)
9539             CASE_BUILTIN_F (BUILT_IN_LDEXP)
9540             CASE_BUILTIN_F (BUILT_IN_LLRINT)
9541             CASE_BUILTIN_F (BUILT_IN_LLROUND)
9542             CASE_BUILTIN_F (BUILT_IN_LRINT)
9543             CASE_BUILTIN_F (BUILT_IN_LROUND)
9544             CASE_BUILTIN_F (BUILT_IN_MODF)
9545             CASE_BUILTIN_F (BUILT_IN_NEARBYINT)
9546             CASE_BUILTIN_F (BUILT_IN_POW)
9547             CASE_BUILTIN_F (BUILT_IN_RINT)
9548             CASE_BUILTIN_F (BUILT_IN_ROUND)
9549             CASE_BUILTIN_F (BUILT_IN_SIGNBIT)
9550             CASE_BUILTIN_F (BUILT_IN_SINH)
9551             CASE_BUILTIN_F (BUILT_IN_TANH)
9552             CASE_BUILTIN_F (BUILT_IN_TRUNC)
9553               /* True if the 1st argument is nonnegative.  */
9554               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9555
9556             CASE_BUILTIN_F (BUILT_IN_FMAX)
9557               /* True if the 1st OR 2nd arguments are nonnegative.  */
9558               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9559                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9560
9561             CASE_BUILTIN_F (BUILT_IN_FMIN)
9562               /* True if the 1st AND 2nd arguments are nonnegative.  */
9563               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9564                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9565
9566             CASE_BUILTIN_F (BUILT_IN_COPYSIGN)
9567               /* True if the 2nd argument is nonnegative.  */
9568               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9569
9570             default:
9571               break;
9572 #undef CASE_BUILTIN_F
9573 #undef CASE_BUILTIN_I
9574             }
9575       }
9576
9577       /* ... fall through ...  */
9578
9579     default:
9580       if (truth_value_p (TREE_CODE (t)))
9581         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
9582         return 1;
9583     }
9584
9585   /* We don't know sign of `t', so be conservative and return false.  */
9586   return 0;
9587 }
9588
9589 /* Return true when T is an address and is known to be nonzero.
9590    For floating point we further ensure that T is not denormal.
9591    Similar logic is present in nonzero_address in rtlanal.h  */
9592
9593 static bool
9594 tree_expr_nonzero_p (tree t)
9595 {
9596   tree type = TREE_TYPE (t);
9597
9598   /* Doing something useful for floating point would need more work.  */
9599   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9600     return false;
9601
9602   switch (TREE_CODE (t))
9603     {
9604     case ABS_EXPR:
9605       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9606         return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9607
9608     case INTEGER_CST:
9609       /* We used to test for !integer_zerop here.  This does not work correctly
9610          if TREE_CONSTANT_OVERFLOW (t).  */
9611       return (TREE_INT_CST_LOW (t) != 0
9612               || TREE_INT_CST_HIGH (t) != 0);
9613
9614     case PLUS_EXPR:
9615       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9616         {
9617           /* With the presence of negative values it is hard
9618              to say something.  */
9619           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9620               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9621             return false;
9622           /* One of operands must be positive and the other non-negative.  */
9623           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9624                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9625         }
9626       break;
9627
9628     case MULT_EXPR:
9629       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9630         {
9631           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9632                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9633         }
9634       break;
9635
9636     case NOP_EXPR:
9637       {
9638         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9639         tree outer_type = TREE_TYPE (t);
9640
9641         return (TYPE_PRECISION (inner_type) >= TYPE_PRECISION (outer_type)
9642                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
9643       }
9644       break;
9645
9646    case ADDR_EXPR:
9647       {
9648         tree base = get_base_address (TREE_OPERAND (t, 0));
9649
9650         if (!base)
9651           return false;
9652
9653         /* Weak declarations may link to NULL.  */
9654         if (DECL_P (base))
9655           return !DECL_WEAK (base);
9656
9657         /* Constants are never weak.  */
9658         if (TREE_CODE_CLASS (TREE_CODE (base)) == 'c')
9659           return true;
9660
9661         return false;
9662       }
9663
9664     case COND_EXPR:
9665       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9666               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
9667
9668     case MIN_EXPR:
9669       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9670               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9671
9672     case MAX_EXPR:
9673       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
9674         {
9675           /* When both operands are nonzero, then MAX must be too.  */
9676           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
9677             return true;
9678
9679           /* MAX where operand 0 is positive is positive.  */
9680           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9681         }
9682       /* MAX where operand 1 is positive is positive.  */
9683       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9684                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9685         return true;
9686       break;
9687
9688     case COMPOUND_EXPR:
9689     case MODIFY_EXPR:
9690     case BIND_EXPR:
9691       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
9692
9693     case SAVE_EXPR:
9694     case NON_LVALUE_EXPR:
9695       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9696
9697     case BIT_IOR_EXPR:
9698       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9699              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9700
9701     default:
9702       break;
9703     }
9704   return false;
9705 }
9706
9707 /* See if we are applying CODE, a relational to the highest or lowest
9708    possible integer of TYPE.  If so, then the result is a compile
9709    time constant.  */
9710
9711 static tree
9712 fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
9713                        tree *op1_p)
9714 {
9715   tree op0 = *op0_p;
9716   tree op1 = *op1_p;
9717   enum tree_code code = *code_p;
9718   int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (op1)));
9719
9720   if (TREE_CODE (op1) == INTEGER_CST
9721       && ! TREE_CONSTANT_OVERFLOW (op1)
9722       && width <= HOST_BITS_PER_WIDE_INT
9723       && (INTEGRAL_TYPE_P (TREE_TYPE (op1))
9724           || POINTER_TYPE_P (TREE_TYPE (op1))))
9725     {
9726       unsigned HOST_WIDE_INT signed_max;
9727       unsigned HOST_WIDE_INT max, min;
9728
9729       signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
9730
9731       if (TYPE_UNSIGNED (TREE_TYPE (op1)))
9732         {
9733           max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9734           min = 0;
9735         }
9736       else
9737         {
9738           max = signed_max;
9739           min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9740         }
9741
9742       if (TREE_INT_CST_HIGH (op1) == 0
9743           && TREE_INT_CST_LOW (op1) == max)
9744         switch (code)
9745           {
9746           case GT_EXPR:
9747             return omit_one_operand (type, integer_zero_node, op0);
9748
9749           case GE_EXPR:
9750             *code_p = EQ_EXPR;
9751             break;
9752           case LE_EXPR:
9753             return omit_one_operand (type, integer_one_node, op0);
9754
9755           case LT_EXPR:
9756             *code_p = NE_EXPR;
9757             break;
9758
9759           /* The GE_EXPR and LT_EXPR cases above are not normally
9760              reached because of  previous transformations.  */
9761
9762           default:
9763             break;
9764           }
9765       else if (TREE_INT_CST_HIGH (op1) == 0
9766                && TREE_INT_CST_LOW (op1) == max - 1)
9767         switch (code)
9768           {
9769           case GT_EXPR:
9770             *code_p = EQ_EXPR;
9771             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9772             break;
9773           case LE_EXPR:
9774             *code_p = NE_EXPR;
9775             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9776             break;
9777           default:
9778             break;
9779           }
9780       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9781                && TREE_INT_CST_LOW (op1) == min)
9782        switch (code)
9783           {
9784           case LT_EXPR:
9785             return omit_one_operand (type, integer_zero_node, op0);
9786
9787           case LE_EXPR:
9788             *code_p = EQ_EXPR;
9789             break;
9790
9791           case GE_EXPR:
9792             return omit_one_operand (type, integer_one_node, op0);
9793
9794           case GT_EXPR:
9795             *code_p = NE_EXPR;
9796             break;
9797
9798           default:
9799             break;
9800           }
9801       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9802                && TREE_INT_CST_LOW (op1) == min + 1)
9803         switch (code)
9804           {
9805           case GE_EXPR:
9806             *code_p = NE_EXPR;
9807             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9808             break;
9809           case LT_EXPR:
9810             *code_p = EQ_EXPR;
9811             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9812             break;
9813           default:
9814             break;
9815           }
9816
9817       else if (TREE_INT_CST_HIGH (op1) == 0
9818                && TREE_INT_CST_LOW (op1) == signed_max
9819                && TYPE_UNSIGNED (TREE_TYPE (op1))
9820                /* signed_type does not work on pointer types.  */
9821                && INTEGRAL_TYPE_P (TREE_TYPE (op1)))
9822         {
9823           /* The following case also applies to X < signed_max+1
9824              and X >= signed_max+1 because previous transformations.  */
9825           if (code == LE_EXPR || code == GT_EXPR)
9826             {
9827               tree st0, st1, exp, retval;
9828               st0 = lang_hooks.types.signed_type (TREE_TYPE (op0));
9829               st1 = lang_hooks.types.signed_type (TREE_TYPE (op1));
9830
9831               exp = build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9832                             type,
9833                             fold_convert (st0, op0),
9834                             fold_convert (st1, integer_zero_node));
9835
9836               retval
9837                 = nondestructive_fold_binary_to_constant (TREE_CODE (exp),
9838                                                           TREE_TYPE (exp),
9839                                                           TREE_OPERAND (exp, 0),
9840                                                           TREE_OPERAND (exp, 1));
9841
9842               /* If we are in gimple form, then returning EXP would create
9843                  non-gimple expressions.  Clearing it is safe and insures
9844                  we do not allow a non-gimple expression to escape.  */
9845               if (in_gimple_form)
9846                 exp = NULL;
9847
9848               return (retval ? retval : exp);
9849             }
9850         }
9851     }
9852
9853   return NULL_TREE;
9854 }
9855
9856
9857 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
9858    attempt to fold the expression to a constant without modifying TYPE,
9859    OP0 or OP1.
9860
9861    If the expression could be simplified to a constant, then return
9862    the constant.  If the expression would not be simplified to a
9863    constant, then return NULL_TREE.
9864
9865    Note this is primarily designed to be called after gimplification
9866    of the tree structures and when at least one operand is a constant.
9867    As a result of those simplifying assumptions this routine is far
9868    simpler than the generic fold routine.  */
9869
9870 tree
9871 nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
9872                                         tree op0, tree op1)
9873 {
9874   int wins = 1;
9875   tree subop0;
9876   tree subop1;
9877   tree tem;
9878
9879   /* If this is a commutative operation, and ARG0 is a constant, move it
9880      to ARG1 to reduce the number of tests below.  */
9881   if (commutative_tree_code (code)
9882       && (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST))
9883     {
9884       tem = op0;
9885       op0 = op1;
9886       op1 = tem;
9887     }
9888
9889   /* If either operand is a complex type, extract its real component.  */
9890   if (TREE_CODE (op0) == COMPLEX_CST)
9891     subop0 = TREE_REALPART (op0);
9892   else
9893     subop0 = op0;
9894
9895   if (TREE_CODE (op1) == COMPLEX_CST)
9896     subop1 = TREE_REALPART (op1);
9897   else
9898     subop1 = op1;
9899
9900   /* Note if either argument is not a real or integer constant.
9901      With a few exceptions, simplification is limited to cases
9902      where both arguments are constants.  */
9903   if ((TREE_CODE (subop0) != INTEGER_CST
9904        && TREE_CODE (subop0) != REAL_CST)
9905       || (TREE_CODE (subop1) != INTEGER_CST
9906           && TREE_CODE (subop1) != REAL_CST))
9907     wins = 0;
9908
9909   switch (code)
9910     {
9911     case PLUS_EXPR:
9912       /* (plus (address) (const_int)) is a constant.  */
9913       if (TREE_CODE (op0) == PLUS_EXPR
9914           && TREE_CODE (op1) == INTEGER_CST
9915           && (TREE_CODE (TREE_OPERAND (op0, 0)) == ADDR_EXPR
9916               || (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
9917                   && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (op0, 0), 0))
9918                       == ADDR_EXPR)))
9919           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
9920         {
9921           return build2 (PLUS_EXPR, type, TREE_OPERAND (op0, 0),
9922                          const_binop (PLUS_EXPR, op1,
9923                                       TREE_OPERAND (op0, 1), 0));
9924         }
9925     case BIT_XOR_EXPR:
9926
9927     binary:
9928       if (!wins)
9929         return NULL_TREE;
9930
9931       /* Both arguments are constants.  Simplify.  */
9932       tem = const_binop (code, op0, op1, 0);
9933       if (tem != NULL_TREE)
9934         {
9935           /* The return value should always have the same type as
9936              the original expression.  */
9937           if (TREE_TYPE (tem) != type)
9938             tem = fold_convert (type, tem);
9939
9940           return tem;
9941         }
9942       return NULL_TREE;
9943
9944     case MINUS_EXPR:
9945       /* Fold &x - &x.  This can happen from &x.foo - &x.
9946          This is unsafe for certain floats even in non-IEEE formats.
9947          In IEEE, it is unsafe because it does wrong for NaNs.
9948          Also note that operand_equal_p is always false if an
9949          operand is volatile.  */
9950       if (! FLOAT_TYPE_P (type) && operand_equal_p (op0, op1, 0))
9951         return fold_convert (type, integer_zero_node);
9952
9953       goto binary;
9954
9955     case MULT_EXPR:
9956     case BIT_AND_EXPR:
9957       /* Special case multiplication or bitwise AND where one argument
9958          is zero.  */
9959       if (! FLOAT_TYPE_P (type) && integer_zerop (op1))
9960         return omit_one_operand (type, op1, op0);
9961       else
9962         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (op0)))
9963             && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op0)))
9964             && real_zerop (op1))
9965           return omit_one_operand (type, op1, op0);
9966
9967       goto binary;
9968
9969     case BIT_IOR_EXPR:
9970       /* Special case when we know the result will be all ones.  */
9971       if (integer_all_onesp (op1))
9972         return omit_one_operand (type, op1, op0);
9973
9974       goto binary;
9975
9976     case TRUNC_DIV_EXPR:
9977     case ROUND_DIV_EXPR:
9978     case FLOOR_DIV_EXPR:
9979     case CEIL_DIV_EXPR:
9980     case EXACT_DIV_EXPR:
9981     case TRUNC_MOD_EXPR:
9982     case ROUND_MOD_EXPR:
9983     case FLOOR_MOD_EXPR:
9984     case CEIL_MOD_EXPR:
9985     case RDIV_EXPR:
9986       /* Division by zero is undefined.  */
9987       if (integer_zerop (op1))
9988         return NULL_TREE;
9989
9990       if (TREE_CODE (op1) == REAL_CST
9991           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (op1)))
9992           && real_zerop (op1))
9993         return NULL_TREE;
9994
9995       goto binary;
9996
9997     case MIN_EXPR:
9998       if (INTEGRAL_TYPE_P (type)
9999           && operand_equal_p (op1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
10000         return omit_one_operand (type, op1, op0);
10001
10002       goto binary;
10003
10004     case MAX_EXPR:
10005       if (INTEGRAL_TYPE_P (type)
10006           && TYPE_MAX_VALUE (type)
10007           && operand_equal_p (op1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
10008         return omit_one_operand (type, op1, op0);
10009
10010       goto binary;
10011
10012     case RSHIFT_EXPR:
10013       /* Optimize -1 >> x for arithmetic right shifts.  */
10014       if (integer_all_onesp (op0) && ! TYPE_UNSIGNED (type))
10015         return omit_one_operand (type, op0, op1);
10016       /* ... fall through ...  */
10017
10018     case LSHIFT_EXPR:
10019       if (integer_zerop (op0))
10020         return omit_one_operand (type, op0, op1);
10021
10022       /* Since negative shift count is not well-defined, don't
10023          try to compute it in the compiler.  */
10024       if (TREE_CODE (op1) == INTEGER_CST && tree_int_cst_sgn (op1) < 0)
10025         return NULL_TREE;
10026
10027       goto binary;
10028
10029     case LROTATE_EXPR:
10030     case RROTATE_EXPR:
10031       /* -1 rotated either direction by any amount is still -1.  */
10032       if (integer_all_onesp (op0))
10033         return omit_one_operand (type, op0, op1);
10034
10035       /* 0 rotated either direction by any amount is still zero.  */
10036       if (integer_zerop (op0))
10037         return omit_one_operand (type, op0, op1);
10038
10039       goto binary;
10040
10041     case COMPLEX_EXPR:
10042       if (wins)
10043         return build_complex (type, op0, op1);
10044       return NULL_TREE;
10045
10046     case LT_EXPR:
10047     case LE_EXPR:
10048     case GT_EXPR:
10049     case GE_EXPR:
10050     case EQ_EXPR:
10051     case NE_EXPR:
10052       /* If one arg is a real or integer constant, put it last.  */
10053       if ((TREE_CODE (op0) == INTEGER_CST
10054            && TREE_CODE (op1) != INTEGER_CST)
10055           || (TREE_CODE (op0) == REAL_CST
10056               && TREE_CODE (op0) != REAL_CST))
10057         {
10058           tree temp;
10059
10060           temp = op0;
10061           op0 = op1;
10062           op1 = temp;
10063           code = swap_tree_comparison (code);
10064         }
10065
10066       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
10067          This transformation affects the cases which are handled in later
10068          optimizations involving comparisons with non-negative constants.  */
10069       if (TREE_CODE (op1) == INTEGER_CST
10070           && TREE_CODE (op0) != INTEGER_CST
10071           && tree_int_cst_sgn (op1) > 0)
10072         {
10073           switch (code)
10074             {
10075             case GE_EXPR:
10076               code = GT_EXPR;
10077               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10078               break;
10079
10080             case LT_EXPR:
10081               code = LE_EXPR;
10082               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10083               break;
10084
10085             default:
10086               break;
10087             }
10088         }
10089
10090       tem = fold_relational_hi_lo (&code, type, &op0, &op1);
10091       if (tem)
10092         return tem;
10093
10094       /* Fall through.  */
10095
10096     case ORDERED_EXPR:
10097     case UNORDERED_EXPR:
10098     case UNLT_EXPR:
10099     case UNLE_EXPR:
10100     case UNGT_EXPR:
10101     case UNGE_EXPR:
10102     case UNEQ_EXPR:
10103     case LTGT_EXPR:
10104       if (!wins)
10105         return NULL_TREE;
10106
10107       return fold_relational_const (code, type, op0, op1);
10108
10109     case RANGE_EXPR:
10110       /* This could probably be handled.  */
10111       return NULL_TREE;
10112
10113     case TRUTH_AND_EXPR:
10114       /* If second arg is constant zero, result is zero, but first arg
10115          must be evaluated.  */
10116       if (integer_zerop (op1))
10117         return omit_one_operand (type, op1, op0);
10118       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10119          case will be handled here.  */
10120       if (integer_zerop (op0))
10121         return omit_one_operand (type, op0, op1);
10122       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10123         return constant_boolean_node (true, type);
10124       return NULL_TREE;
10125
10126     case TRUTH_OR_EXPR:
10127       /* If second arg is constant true, result is true, but we must
10128          evaluate first arg.  */
10129       if (TREE_CODE (op1) == INTEGER_CST && ! integer_zerop (op1))
10130         return omit_one_operand (type, op1, op0);
10131       /* Likewise for first arg, but note this only occurs here for
10132          TRUTH_OR_EXPR.  */
10133       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
10134         return omit_one_operand (type, op0, op1);
10135       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10136         return constant_boolean_node (false, type);
10137       return NULL_TREE;
10138
10139     case TRUTH_XOR_EXPR:
10140       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10141         {
10142           int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
10143           return constant_boolean_node (x, type);
10144         }
10145       return NULL_TREE;
10146
10147     default:
10148       return NULL_TREE;
10149     }
10150 }
10151
10152 /* Given the components of a unary expression CODE, TYPE and OP0,
10153    attempt to fold the expression to a constant without modifying
10154    TYPE or OP0.
10155
10156    If the expression could be simplified to a constant, then return
10157    the constant.  If the expression would not be simplified to a
10158    constant, then return NULL_TREE.
10159
10160    Note this is primarily designed to be called after gimplification
10161    of the tree structures and when op0 is a constant.  As a result
10162    of those simplifying assumptions this routine is far simpler than
10163    the generic fold routine.  */
10164
10165 tree
10166 nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
10167                                        tree op0)
10168 {
10169   /* Make sure we have a suitable constant argument.  */
10170   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
10171     {
10172       tree subop;
10173
10174       if (TREE_CODE (op0) == COMPLEX_CST)
10175         subop = TREE_REALPART (op0);
10176       else
10177         subop = op0;
10178
10179       if (TREE_CODE (subop) != INTEGER_CST && TREE_CODE (subop) != REAL_CST)
10180         return NULL_TREE;
10181     }
10182
10183   switch (code)
10184     {
10185     case NOP_EXPR:
10186     case FLOAT_EXPR:
10187     case CONVERT_EXPR:
10188     case FIX_TRUNC_EXPR:
10189     case FIX_FLOOR_EXPR:
10190     case FIX_CEIL_EXPR:
10191       return fold_convert_const (code, type, op0);
10192
10193     case NEGATE_EXPR:
10194       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10195         return fold_negate_const (op0, type);
10196       else
10197         return NULL_TREE;
10198
10199     case ABS_EXPR:
10200       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10201         return fold_abs_const (op0, type);
10202       else
10203         return NULL_TREE;
10204
10205     case BIT_NOT_EXPR:
10206       if (TREE_CODE (op0) == INTEGER_CST)
10207         return fold_not_const (op0, type);
10208       else
10209         return NULL_TREE;
10210
10211     case REALPART_EXPR:
10212       if (TREE_CODE (op0) == COMPLEX_CST)
10213         return TREE_REALPART (op0);
10214       else
10215         return NULL_TREE;
10216
10217     case IMAGPART_EXPR:
10218       if (TREE_CODE (op0) == COMPLEX_CST)
10219         return TREE_IMAGPART (op0);
10220       else
10221         return NULL_TREE;
10222
10223     case CONJ_EXPR:
10224       if (TREE_CODE (op0) == COMPLEX_CST
10225           && TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
10226         return build_complex (type, TREE_REALPART (op0),
10227                               negate_expr (TREE_IMAGPART (op0)));
10228       return NULL_TREE;
10229
10230     default:
10231       return NULL_TREE;
10232     }
10233 }
10234
10235 /* If EXP represents referencing an element in a constant string
10236    (either via pointer arithmetic or array indexing), return the
10237    tree representing the value accessed, otherwise return NULL.  */
10238
10239 tree
10240 fold_read_from_constant_string (tree exp)
10241 {
10242   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
10243     {
10244       tree exp1 = TREE_OPERAND (exp, 0);
10245       tree index;
10246       tree string;
10247
10248       if (TREE_CODE (exp) == INDIRECT_REF)
10249         string = string_constant (exp1, &index);
10250       else
10251         {
10252           tree low_bound = array_ref_low_bound (exp);
10253           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
10254
10255           /* Optimize the special-case of a zero lower bound.
10256
10257              We convert the low_bound to sizetype to avoid some problems
10258              with constant folding.  (E.g. suppose the lower bound is 1,
10259              and its mode is QI.  Without the conversion,l (ARRAY
10260              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
10261              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
10262           if (! integer_zerop (low_bound))
10263             index = size_diffop (index, fold_convert (sizetype, low_bound));
10264
10265           string = exp1;
10266         }
10267
10268       if (string
10269           && TREE_TYPE (exp) == TREE_TYPE (TREE_TYPE (string))
10270           && TREE_CODE (string) == STRING_CST
10271           && TREE_CODE (index) == INTEGER_CST
10272           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
10273           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
10274               == MODE_INT)
10275           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
10276         return fold_convert (TREE_TYPE (exp),
10277                              build_int_cst (NULL_TREE,
10278                                             (TREE_STRING_POINTER (string)
10279                                              [TREE_INT_CST_LOW (index)])));
10280     }
10281   return NULL;
10282 }
10283
10284 /* Return the tree for neg (ARG0) when ARG0 is known to be either
10285    an integer constant or real constant.
10286
10287    TYPE is the type of the result.  */
10288
10289 static tree
10290 fold_negate_const (tree arg0, tree type)
10291 {
10292   tree t = NULL_TREE;
10293
10294   switch (TREE_CODE (arg0))
10295     {
10296     case INTEGER_CST:
10297       {
10298         unsigned HOST_WIDE_INT low;
10299         HOST_WIDE_INT high;
10300         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10301                                    TREE_INT_CST_HIGH (arg0),
10302                                    &low, &high);
10303         t = build_int_cst_wide (type, low, high);
10304         t = force_fit_type (t, 1,
10305                             (overflow | TREE_OVERFLOW (arg0))
10306                             && !TYPE_UNSIGNED (type),
10307                             TREE_CONSTANT_OVERFLOW (arg0));
10308         break;
10309       }
10310
10311     case REAL_CST:
10312       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10313       break;
10314
10315     default:
10316       gcc_unreachable ();
10317     }
10318
10319   return t;
10320 }
10321
10322 /* Return the tree for abs (ARG0) when ARG0 is known to be either
10323    an integer constant or real constant.
10324
10325    TYPE is the type of the result.  */
10326
10327 tree
10328 fold_abs_const (tree arg0, tree type)
10329 {
10330   tree t = NULL_TREE;
10331
10332   switch (TREE_CODE (arg0))
10333     {
10334     case INTEGER_CST:
10335       /* If the value is unsigned, then the absolute value is
10336          the same as the ordinary value.  */
10337       if (TYPE_UNSIGNED (type))
10338         t = arg0;
10339       /* Similarly, if the value is non-negative.  */
10340       else if (INT_CST_LT (integer_minus_one_node, arg0))
10341         t = arg0;
10342       /* If the value is negative, then the absolute value is
10343          its negation.  */
10344       else
10345         {
10346           unsigned HOST_WIDE_INT low;
10347           HOST_WIDE_INT high;
10348           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10349                                      TREE_INT_CST_HIGH (arg0),
10350                                      &low, &high);
10351           t = build_int_cst_wide (type, low, high);
10352           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
10353                               TREE_CONSTANT_OVERFLOW (arg0));
10354         }
10355       break;
10356
10357     case REAL_CST:
10358       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
10359         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10360       else
10361         t =  arg0;
10362       break;
10363
10364     default:
10365       gcc_unreachable ();
10366     }
10367
10368   return t;
10369 }
10370
10371 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
10372    constant.  TYPE is the type of the result.  */
10373
10374 static tree
10375 fold_not_const (tree arg0, tree type)
10376 {
10377   tree t = NULL_TREE;
10378
10379   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
10380
10381   t = build_int_cst_wide (type,
10382                           ~ TREE_INT_CST_LOW (arg0),
10383                           ~ TREE_INT_CST_HIGH (arg0));
10384   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
10385                       TREE_CONSTANT_OVERFLOW (arg0));
10386
10387   return t;
10388 }
10389
10390 /* Given CODE, a relational operator, the target type, TYPE and two
10391    constant operands OP0 and OP1, return the result of the
10392    relational operation.  If the result is not a compile time
10393    constant, then return NULL_TREE.  */
10394
10395 static tree
10396 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
10397 {
10398   int result, invert;
10399
10400   /* From here on, the only cases we handle are when the result is
10401      known to be a constant.  */
10402
10403   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10404     {
10405       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
10406       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
10407
10408       /* Handle the cases where either operand is a NaN.  */
10409       if (real_isnan (c0) || real_isnan (c1))
10410         {
10411           switch (code)
10412             {
10413             case EQ_EXPR:
10414             case ORDERED_EXPR:
10415               result = 0;
10416               break;
10417
10418             case NE_EXPR:
10419             case UNORDERED_EXPR:
10420             case UNLT_EXPR:
10421             case UNLE_EXPR:
10422             case UNGT_EXPR:
10423             case UNGE_EXPR:
10424             case UNEQ_EXPR:
10425               result = 1;
10426               break;
10427
10428             case LT_EXPR:
10429             case LE_EXPR:
10430             case GT_EXPR:
10431             case GE_EXPR:
10432             case LTGT_EXPR:
10433               if (flag_trapping_math)
10434                 return NULL_TREE;
10435               result = 0;
10436               break;
10437
10438             default:
10439               gcc_unreachable ();
10440             }
10441
10442           return constant_boolean_node (result, type);
10443         }
10444
10445       return constant_boolean_node (real_compare (code, c0, c1), type);
10446     }
10447
10448   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
10449
10450      To compute GT, swap the arguments and do LT.
10451      To compute GE, do LT and invert the result.
10452      To compute LE, swap the arguments, do LT and invert the result.
10453      To compute NE, do EQ and invert the result.
10454
10455      Therefore, the code below must handle only EQ and LT.  */
10456
10457   if (code == LE_EXPR || code == GT_EXPR)
10458     {
10459       tree tem = op0;
10460       op0 = op1;
10461       op1 = tem;
10462       code = swap_tree_comparison (code);
10463     }
10464
10465   /* Note that it is safe to invert for real values here because we
10466      have already handled the one case that it matters.  */
10467
10468   invert = 0;
10469   if (code == NE_EXPR || code == GE_EXPR)
10470     {
10471       invert = 1;
10472       code = invert_tree_comparison (code, false);
10473     }
10474
10475   /* Compute a result for LT or EQ if args permit;
10476      Otherwise return T.  */
10477   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10478     {
10479       if (code == EQ_EXPR)
10480         result = tree_int_cst_equal (op0, op1);
10481       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
10482         result = INT_CST_LT_UNSIGNED (op0, op1);
10483       else
10484         result = INT_CST_LT (op0, op1);
10485     }
10486   else
10487     return NULL_TREE;
10488
10489   if (invert)
10490     result ^= 1;
10491   return constant_boolean_node (result, type);
10492 }
10493
10494 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
10495    avoid confusing the gimplify process.  */
10496
10497 tree
10498 build_fold_addr_expr_with_type (tree t, tree ptrtype)
10499 {
10500   /* The size of the object is not relevant when talking about its address.  */
10501   if (TREE_CODE (t) == WITH_SIZE_EXPR)
10502     t = TREE_OPERAND (t, 0);
10503
10504   if (TREE_CODE (t) == INDIRECT_REF)
10505     {
10506       t = TREE_OPERAND (t, 0);
10507       if (TREE_TYPE (t) != ptrtype)
10508         t = build1 (NOP_EXPR, ptrtype, t);
10509     }
10510   else
10511     {
10512       tree base = t;
10513
10514       while (handled_component_p (base)
10515              || TREE_CODE (base) == REALPART_EXPR
10516              || TREE_CODE (base) == IMAGPART_EXPR)
10517         base = TREE_OPERAND (base, 0);
10518       if (DECL_P (base))
10519         TREE_ADDRESSABLE (base) = 1;
10520
10521       t = build1 (ADDR_EXPR, ptrtype, t);
10522     }
10523
10524   return t;
10525 }
10526
10527 tree
10528 build_fold_addr_expr (tree t)
10529 {
10530   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
10531 }
10532
10533 /* Builds an expression for an indirection through T, simplifying some
10534    cases.  */
10535
10536 tree
10537 build_fold_indirect_ref (tree t)
10538 {
10539   tree type = TREE_TYPE (TREE_TYPE (t));
10540   tree sub = t;
10541   tree subtype;
10542
10543   STRIP_NOPS (sub);
10544   if (TREE_CODE (sub) == ADDR_EXPR)
10545     {
10546       tree op = TREE_OPERAND (sub, 0);
10547       tree optype = TREE_TYPE (op);
10548       /* *&p => p */
10549       if (lang_hooks.types_compatible_p (type, optype))
10550         return op;
10551       /* *(foo *)&fooarray => fooarray[0] */
10552       else if (TREE_CODE (optype) == ARRAY_TYPE
10553                && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
10554         return build4 (ARRAY_REF, type, op, size_zero_node, NULL_TREE, NULL_TREE);
10555     }
10556
10557   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
10558   subtype = TREE_TYPE (sub);
10559   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
10560       && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
10561     {
10562       sub = build_fold_indirect_ref (sub);
10563       return build4 (ARRAY_REF, type, sub, size_zero_node, NULL_TREE, NULL_TREE);
10564     }
10565
10566   return build1 (INDIRECT_REF, type, t);
10567 }
10568
10569 /* Strip non-trapping, non-side-effecting tree nodes from an expression
10570    whose result is ignored.  The type of the returned tree need not be
10571    the same as the original expression.  */
10572
10573 tree
10574 fold_ignored_result (tree t)
10575 {
10576   if (!TREE_SIDE_EFFECTS (t))
10577     return integer_zero_node;
10578
10579   for (;;)
10580     switch (TREE_CODE_CLASS (TREE_CODE (t)))
10581       {
10582       case '1':
10583         t = TREE_OPERAND (t, 0);
10584         break;
10585
10586       case '2':
10587       case '<':
10588         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10589           t = TREE_OPERAND (t, 0);
10590         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
10591           t = TREE_OPERAND (t, 1);
10592         else
10593           return t;
10594         break;
10595
10596       case 'e':
10597         switch (TREE_CODE (t))
10598           {
10599           case COMPOUND_EXPR:
10600             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10601               return t;
10602             t = TREE_OPERAND (t, 0);
10603             break;
10604
10605           case COND_EXPR:
10606             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
10607                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
10608               return t;
10609             t = TREE_OPERAND (t, 0);
10610             break;
10611
10612           default:
10613             return t;
10614           }
10615         break;
10616
10617       default:
10618         return t;
10619       }
10620 }
10621
10622 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
10623    This can only be applied to objects of a sizetype.  */
10624
10625 tree
10626 round_up (tree value, int divisor)
10627 {
10628   tree div = NULL_TREE;
10629
10630   gcc_assert (divisor > 0);
10631   if (divisor == 1)
10632     return value;
10633
10634   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10635      have to do anything.  Only do this when we are not given a const,
10636      because in that case, this check is more expensive than just
10637      doing it.  */
10638   if (TREE_CODE (value) != INTEGER_CST)
10639     {
10640       div = build_int_cst (TREE_TYPE (value), divisor);
10641
10642       if (multiple_of_p (TREE_TYPE (value), value, div))
10643         return value;
10644     }
10645
10646   /* If divisor is a power of two, simplify this to bit manipulation.  */
10647   if (divisor == (divisor & -divisor))
10648     {
10649       tree t;
10650
10651       t = build_int_cst (TREE_TYPE (value), divisor - 1);
10652       value = size_binop (PLUS_EXPR, value, t);
10653       t = build_int_cst (TREE_TYPE (value), -divisor);
10654       value = size_binop (BIT_AND_EXPR, value, t);
10655     }
10656   else
10657     {
10658       if (!div)
10659         div = build_int_cst (TREE_TYPE (value), divisor);
10660       value = size_binop (CEIL_DIV_EXPR, value, div);
10661       value = size_binop (MULT_EXPR, value, div);
10662     }
10663
10664   return value;
10665 }
10666
10667 /* Likewise, but round down.  */
10668
10669 tree
10670 round_down (tree value, int divisor)
10671 {
10672   tree div = NULL_TREE;
10673
10674   gcc_assert (divisor > 0);
10675   if (divisor == 1)
10676     return value;
10677
10678   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10679      have to do anything.  Only do this when we are not given a const,
10680      because in that case, this check is more expensive than just
10681      doing it.  */
10682   if (TREE_CODE (value) != INTEGER_CST)
10683     {
10684       div = build_int_cst (TREE_TYPE (value), divisor);
10685
10686       if (multiple_of_p (TREE_TYPE (value), value, div))
10687         return value;
10688     }
10689
10690   /* If divisor is a power of two, simplify this to bit manipulation.  */
10691   if (divisor == (divisor & -divisor))
10692     {
10693       tree t;
10694
10695       t = build_int_cst (TREE_TYPE (value), -divisor);
10696       value = size_binop (BIT_AND_EXPR, value, t);
10697     }
10698   else
10699     {
10700       if (!div)
10701         div = build_int_cst (TREE_TYPE (value), divisor);
10702       value = size_binop (FLOOR_DIV_EXPR, value, div);
10703       value = size_binop (MULT_EXPR, value, div);
10704     }
10705
10706   return value;
10707 }