gcc/fold-const.c

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