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 (arg1) == MULT_EXPR)
6591               || (TREE_CODE (arg1) == PLUS_EXPR
6592                   && TREE_CODE (arg0) == MULT_EXPR))
6593             {
6594               tree parg0, parg1, parg, marg;
6595
6596               if (TREE_CODE (arg0) == PLUS_EXPR)
6597                 parg = arg0, marg = arg1;
6598               else
6599                 parg = arg1, marg = arg0;
6600               parg0 = TREE_OPERAND (parg, 0);
6601               parg1 = TREE_OPERAND (parg, 1);
6602               STRIP_NOPS (parg0);
6603               STRIP_NOPS (parg1);
6604
6605               if (TREE_CODE (parg0) == MULT_EXPR
6606                   && TREE_CODE (parg1) != MULT_EXPR)
6607                 return fold (build2 (PLUS_EXPR, type,
6608                                      fold (build2 (PLUS_EXPR, type,
6609                                                    fold_convert (type, parg0),
6610                                                    fold_convert (type, marg))),
6611                                      fold_convert (type, parg1)));
6612               if (TREE_CODE (parg0) != MULT_EXPR
6613                   && TREE_CODE (parg1) == MULT_EXPR)
6614                 return fold (build2 (PLUS_EXPR, type,
6615                                      fold (build2 (PLUS_EXPR, type,
6616                                                    fold_convert (type, parg1),
6617                                                    fold_convert (type, marg))),
6618                                      fold_convert (type, parg0)));
6619             }
6620
6621           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
6622             {
6623               tree arg00, arg01, arg10, arg11;
6624               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6625
6626               /* (A * C) + (B * C) -> (A+B) * C.
6627                  We are most concerned about the case where C is a constant,
6628                  but other combinations show up during loop reduction.  Since
6629                  it is not difficult, try all four possibilities.  */
6630
6631               arg00 = TREE_OPERAND (arg0, 0);
6632               arg01 = TREE_OPERAND (arg0, 1);
6633               arg10 = TREE_OPERAND (arg1, 0);
6634               arg11 = TREE_OPERAND (arg1, 1);
6635               same = NULL_TREE;
6636
6637               if (operand_equal_p (arg01, arg11, 0))
6638                 same = arg01, alt0 = arg00, alt1 = arg10;
6639               else if (operand_equal_p (arg00, arg10, 0))
6640                 same = arg00, alt0 = arg01, alt1 = arg11;
6641               else if (operand_equal_p (arg00, arg11, 0))
6642                 same = arg00, alt0 = arg01, alt1 = arg10;
6643               else if (operand_equal_p (arg01, arg10, 0))
6644                 same = arg01, alt0 = arg00, alt1 = arg11;
6645
6646               /* No identical multiplicands; see if we can find a common
6647                  power-of-two factor in non-power-of-two multiplies.  This
6648                  can help in multi-dimensional array access.  */
6649               else if (TREE_CODE (arg01) == INTEGER_CST
6650                        && TREE_CODE (arg11) == INTEGER_CST
6651                        && TREE_INT_CST_HIGH (arg01) == 0
6652                        && TREE_INT_CST_HIGH (arg11) == 0)
6653                 {
6654                   HOST_WIDE_INT int01, int11, tmp;
6655                   int01 = TREE_INT_CST_LOW (arg01);
6656                   int11 = TREE_INT_CST_LOW (arg11);
6657
6658                   /* Move min of absolute values to int11.  */
6659                   if ((int01 >= 0 ? int01 : -int01)
6660                       < (int11 >= 0 ? int11 : -int11))
6661                     {
6662                       tmp = int01, int01 = int11, int11 = tmp;
6663                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
6664                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
6665                     }
6666
6667                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
6668                     {
6669                       alt0 = fold (build2 (MULT_EXPR, type, arg00,
6670                                            build_int_cst (NULL_TREE,
6671                                                           int01 / int11)));
6672                       alt1 = arg10;
6673                       same = arg11;
6674                     }
6675                 }
6676
6677               if (same)
6678                 return fold (build2 (MULT_EXPR, type,
6679                                      fold (build2 (PLUS_EXPR, type,
6680                                                    alt0, alt1)),
6681                                      same));
6682             }
6683
6684           /* Try replacing &a[i1] + c * i2 with &a[i1 + i2], if c is step
6685              of the array.  Loop optimizer sometimes produce this type of
6686              expressions.  */
6687           if (TREE_CODE (arg0) == ADDR_EXPR
6688               && TREE_CODE (arg1) == MULT_EXPR)
6689             {
6690               tem = try_move_mult_to_index (type, PLUS_EXPR, arg0, arg1);
6691               if (tem)
6692                 return fold (tem);
6693             }
6694           else if (TREE_CODE (arg1) == ADDR_EXPR
6695                    && TREE_CODE (arg0) == MULT_EXPR)
6696             {
6697               tem = try_move_mult_to_index (type, PLUS_EXPR, arg1, arg0);
6698               if (tem)
6699                 return fold (tem);
6700             }
6701         }
6702       else
6703         {
6704           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
6705           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
6706             return non_lvalue (fold_convert (type, arg0));
6707
6708           /* Likewise if the operands are reversed.  */
6709           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
6710             return non_lvalue (fold_convert (type, arg1));
6711
6712           /* Convert X + -C into X - C.  */
6713           if (TREE_CODE (arg1) == REAL_CST
6714               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
6715             {
6716               tem = fold_negate_const (arg1, type);
6717               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
6718                 return fold (build2 (MINUS_EXPR, type,
6719                                      fold_convert (type, arg0),
6720                                      fold_convert (type, tem)));
6721             }
6722
6723           /* Convert x+x into x*2.0.  */
6724           if (operand_equal_p (arg0, arg1, 0)
6725               && SCALAR_FLOAT_TYPE_P (type))
6726             return fold (build2 (MULT_EXPR, type, arg0,
6727                                  build_real (type, dconst2)));
6728
6729           /* Convert x*c+x into x*(c+1).  */
6730           if (flag_unsafe_math_optimizations
6731               && TREE_CODE (arg0) == MULT_EXPR
6732               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6733               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6734               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
6735             {
6736               REAL_VALUE_TYPE c;
6737
6738               c = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6739               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6740               return fold (build2 (MULT_EXPR, type, arg1,
6741                                    build_real (type, c)));
6742             }
6743
6744           /* Convert x+x*c into x*(c+1).  */
6745           if (flag_unsafe_math_optimizations
6746               && TREE_CODE (arg1) == MULT_EXPR
6747               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6748               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6749               && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
6750             {
6751               REAL_VALUE_TYPE c;
6752
6753               c = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6754               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
6755               return fold (build2 (MULT_EXPR, type, arg0,
6756                                    build_real (type, c)));
6757             }
6758
6759           /* Convert x*c1+x*c2 into x*(c1+c2).  */
6760           if (flag_unsafe_math_optimizations
6761               && TREE_CODE (arg0) == MULT_EXPR
6762               && TREE_CODE (arg1) == MULT_EXPR
6763               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6764               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
6765               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
6766               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
6767               && operand_equal_p (TREE_OPERAND (arg0, 0),
6768                                   TREE_OPERAND (arg1, 0), 0))
6769             {
6770               REAL_VALUE_TYPE c1, c2;
6771
6772               c1 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
6773               c2 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
6774               real_arithmetic (&c1, PLUS_EXPR, &c1, &c2);
6775               return fold (build2 (MULT_EXPR, type,
6776                                    TREE_OPERAND (arg0, 0),
6777                                    build_real (type, c1)));
6778             }
6779           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  */
6780           if (flag_unsafe_math_optimizations
6781               && TREE_CODE (arg1) == PLUS_EXPR
6782               && TREE_CODE (arg0) != MULT_EXPR)
6783             {
6784               tree tree10 = TREE_OPERAND (arg1, 0);
6785               tree tree11 = TREE_OPERAND (arg1, 1);
6786               if (TREE_CODE (tree11) == MULT_EXPR
6787                   && TREE_CODE (tree10) == MULT_EXPR)
6788                 {
6789                   tree tree0;
6790                   tree0 = fold (build2 (PLUS_EXPR, type, arg0, tree10));
6791                   return fold (build2 (PLUS_EXPR, type, tree0, tree11));
6792                 }
6793             }
6794           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  */
6795           if (flag_unsafe_math_optimizations
6796               && TREE_CODE (arg0) == PLUS_EXPR
6797               && TREE_CODE (arg1) != MULT_EXPR)
6798             {
6799               tree tree00 = TREE_OPERAND (arg0, 0);
6800               tree tree01 = TREE_OPERAND (arg0, 1);
6801               if (TREE_CODE (tree01) == MULT_EXPR
6802                   && TREE_CODE (tree00) == MULT_EXPR)
6803                 {
6804                   tree tree0;
6805                   tree0 = fold (build2 (PLUS_EXPR, type, tree01, arg1));
6806                   return fold (build2 (PLUS_EXPR, type, tree00, tree0));
6807                 }
6808             }
6809         }
6810
6811      bit_rotate:
6812       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
6813          is a rotate of A by C1 bits.  */
6814       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
6815          is a rotate of A by B bits.  */
6816       {
6817         enum tree_code code0, code1;
6818         code0 = TREE_CODE (arg0);
6819         code1 = TREE_CODE (arg1);
6820         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
6821              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
6822             && operand_equal_p (TREE_OPERAND (arg0, 0),
6823                                 TREE_OPERAND (arg1, 0), 0)
6824             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6825           {
6826             tree tree01, tree11;
6827             enum tree_code code01, code11;
6828
6829             tree01 = TREE_OPERAND (arg0, 1);
6830             tree11 = TREE_OPERAND (arg1, 1);
6831             STRIP_NOPS (tree01);
6832             STRIP_NOPS (tree11);
6833             code01 = TREE_CODE (tree01);
6834             code11 = TREE_CODE (tree11);
6835             if (code01 == INTEGER_CST
6836                 && code11 == INTEGER_CST
6837                 && TREE_INT_CST_HIGH (tree01) == 0
6838                 && TREE_INT_CST_HIGH (tree11) == 0
6839                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
6840                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
6841               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
6842                              code0 == LSHIFT_EXPR ? tree01 : tree11);
6843             else if (code11 == MINUS_EXPR)
6844               {
6845                 tree tree110, tree111;
6846                 tree110 = TREE_OPERAND (tree11, 0);
6847                 tree111 = TREE_OPERAND (tree11, 1);
6848                 STRIP_NOPS (tree110);
6849                 STRIP_NOPS (tree111);
6850                 if (TREE_CODE (tree110) == INTEGER_CST
6851                     && 0 == compare_tree_int (tree110,
6852                                               TYPE_PRECISION
6853                                               (TREE_TYPE (TREE_OPERAND
6854                                                           (arg0, 0))))
6855                     && operand_equal_p (tree01, tree111, 0))
6856                   return build2 ((code0 == LSHIFT_EXPR
6857                                   ? LROTATE_EXPR
6858                                   : RROTATE_EXPR),
6859                                  type, TREE_OPERAND (arg0, 0), tree01);
6860               }
6861             else if (code01 == MINUS_EXPR)
6862               {
6863                 tree tree010, tree011;
6864                 tree010 = TREE_OPERAND (tree01, 0);
6865                 tree011 = TREE_OPERAND (tree01, 1);
6866                 STRIP_NOPS (tree010);
6867                 STRIP_NOPS (tree011);
6868                 if (TREE_CODE (tree010) == INTEGER_CST
6869                     && 0 == compare_tree_int (tree010,
6870                                               TYPE_PRECISION
6871                                               (TREE_TYPE (TREE_OPERAND
6872                                                           (arg0, 0))))
6873                     && operand_equal_p (tree11, tree011, 0))
6874                   return build2 ((code0 != LSHIFT_EXPR
6875                                   ? LROTATE_EXPR
6876                                   : RROTATE_EXPR),
6877                                  type, TREE_OPERAND (arg0, 0), tree11);
6878               }
6879           }
6880       }
6881
6882     associate:
6883       /* In most languages, can't associate operations on floats through
6884          parentheses.  Rather than remember where the parentheses were, we
6885          don't associate floats at all, unless the user has specified
6886          -funsafe-math-optimizations.  */
6887
6888       if (! wins
6889           && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
6890         {
6891           tree var0, con0, lit0, minus_lit0;
6892           tree var1, con1, lit1, minus_lit1;
6893
6894           /* Split both trees into variables, constants, and literals.  Then
6895              associate each group together, the constants with literals,
6896              then the result with variables.  This increases the chances of
6897              literals being recombined later and of generating relocatable
6898              expressions for the sum of a constant and literal.  */
6899           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
6900           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
6901                              code == MINUS_EXPR);
6902
6903           /* Only do something if we found more than two objects.  Otherwise,
6904              nothing has changed and we risk infinite recursion.  */
6905           if (2 < ((var0 != 0) + (var1 != 0)
6906                    + (con0 != 0) + (con1 != 0)
6907                    + (lit0 != 0) + (lit1 != 0)
6908                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
6909             {
6910               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
6911               if (code == MINUS_EXPR)
6912                 code = PLUS_EXPR;
6913
6914               var0 = associate_trees (var0, var1, code, type);
6915               con0 = associate_trees (con0, con1, code, type);
6916               lit0 = associate_trees (lit0, lit1, code, type);
6917               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
6918
6919               /* Preserve the MINUS_EXPR if the negative part of the literal is
6920                  greater than the positive part.  Otherwise, the multiplicative
6921                  folding code (i.e extract_muldiv) may be fooled in case
6922                  unsigned constants are subtracted, like in the following
6923                  example: ((X*2 + 4) - 8U)/2.  */
6924               if (minus_lit0 && lit0)
6925                 {
6926                   if (TREE_CODE (lit0) == INTEGER_CST
6927                       && TREE_CODE (minus_lit0) == INTEGER_CST
6928                       && tree_int_cst_lt (lit0, minus_lit0))
6929                     {
6930                       minus_lit0 = associate_trees (minus_lit0, lit0,
6931                                                     MINUS_EXPR, type);
6932                       lit0 = 0;
6933                     }
6934                   else
6935                     {
6936                       lit0 = associate_trees (lit0, minus_lit0,
6937                                               MINUS_EXPR, type);
6938                       minus_lit0 = 0;
6939                     }
6940                 }
6941               if (minus_lit0)
6942                 {
6943                   if (con0 == 0)
6944                     return fold_convert (type,
6945                                          associate_trees (var0, minus_lit0,
6946                                                           MINUS_EXPR, type));
6947                   else
6948                     {
6949                       con0 = associate_trees (con0, minus_lit0,
6950                                               MINUS_EXPR, type);
6951                       return fold_convert (type,
6952                                            associate_trees (var0, con0,
6953                                                             PLUS_EXPR, type));
6954                     }
6955                 }
6956
6957               con0 = associate_trees (con0, lit0, code, type);
6958               return fold_convert (type, associate_trees (var0, con0,
6959                                                           code, type));
6960             }
6961         }
6962
6963     binary:
6964       if (wins)
6965         t1 = const_binop (code, arg0, arg1, 0);
6966       if (t1 != NULL_TREE)
6967         {
6968           /* The return value should always have
6969              the same type as the original expression.  */
6970           if (TREE_TYPE (t1) != type)
6971             t1 = fold_convert (type, t1);
6972
6973           return t1;
6974         }
6975       return t;
6976
6977     case MINUS_EXPR:
6978       /* A - (-B) -> A + B */
6979       if (TREE_CODE (arg1) == NEGATE_EXPR)
6980         return fold (build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
6981       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
6982       if (TREE_CODE (arg0) == NEGATE_EXPR
6983           && (FLOAT_TYPE_P (type)
6984               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
6985           && negate_expr_p (arg1)
6986           && reorder_operands_p (arg0, arg1))
6987         return fold (build2 (MINUS_EXPR, type, negate_expr (arg1),
6988                              TREE_OPERAND (arg0, 0)));
6989
6990       if (! FLOAT_TYPE_P (type))
6991         {
6992           if (! wins && integer_zerop (arg0))
6993             return negate_expr (fold_convert (type, arg1));
6994           if (integer_zerop (arg1))
6995             return non_lvalue (fold_convert (type, arg0));
6996
6997           /* Fold A - (A & B) into ~B & A.  */
6998           if (!TREE_SIDE_EFFECTS (arg0)
6999               && TREE_CODE (arg1) == BIT_AND_EXPR)
7000             {
7001               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
7002                 return fold (build2 (BIT_AND_EXPR, type,
7003                                      fold (build1 (BIT_NOT_EXPR, type,
7004                                                    TREE_OPERAND (arg1, 0))),
7005                                      arg0));
7006               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7007                 return fold (build2 (BIT_AND_EXPR, type,
7008                                      fold (build1 (BIT_NOT_EXPR, type,
7009                                                    TREE_OPERAND (arg1, 1))),
7010                                      arg0));
7011             }
7012
7013           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
7014              any power of 2 minus 1.  */
7015           if (TREE_CODE (arg0) == BIT_AND_EXPR
7016               && TREE_CODE (arg1) == BIT_AND_EXPR
7017               && operand_equal_p (TREE_OPERAND (arg0, 0),
7018                                   TREE_OPERAND (arg1, 0), 0))
7019             {
7020               tree mask0 = TREE_OPERAND (arg0, 1);
7021               tree mask1 = TREE_OPERAND (arg1, 1);
7022               tree tem = fold (build1 (BIT_NOT_EXPR, type, mask0));
7023
7024               if (operand_equal_p (tem, mask1, 0))
7025                 {
7026                   tem = fold (build2 (BIT_XOR_EXPR, type,
7027                                       TREE_OPERAND (arg0, 0), mask1));
7028                   return fold (build2 (MINUS_EXPR, type, tem, mask1));
7029                 }
7030             }
7031         }
7032
7033       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
7034       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
7035         return non_lvalue (fold_convert (type, arg0));
7036
7037       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
7038          ARG0 is zero and X + ARG0 reduces to X, since that would mean
7039          (-ARG1 + ARG0) reduces to -ARG1.  */
7040       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
7041         return negate_expr (fold_convert (type, arg1));
7042
7043       /* Fold &x - &x.  This can happen from &x.foo - &x.
7044          This is unsafe for certain floats even in non-IEEE formats.
7045          In IEEE, it is unsafe because it does wrong for NaNs.
7046          Also note that operand_equal_p is always false if an operand
7047          is volatile.  */
7048
7049       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
7050           && operand_equal_p (arg0, arg1, 0))
7051         return fold_convert (type, integer_zero_node);
7052
7053       /* A - B -> A + (-B) if B is easily negatable.  */
7054       if (!wins && negate_expr_p (arg1)
7055           && ((FLOAT_TYPE_P (type)
7056                /* Avoid this transformation if B is a positive REAL_CST.  */
7057                && (TREE_CODE (arg1) != REAL_CST
7058                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
7059               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
7060         return fold (build2 (PLUS_EXPR, type, arg0, negate_expr (arg1)));
7061
7062       /* Try folding difference of addresses.  */
7063       {
7064         HOST_WIDE_INT diff;
7065
7066         if (TREE_CODE (arg0) == ADDR_EXPR
7067             && TREE_CODE (arg1) == ADDR_EXPR
7068             && ptr_difference_const (TREE_OPERAND (arg0, 0),
7069                                      TREE_OPERAND (arg1, 0),
7070                                      &diff))
7071           return build_int_cst_type (type, diff);
7072       }
7073
7074       /* Try replacing &a[i1] - c * i2 with &a[i1 - i2], if c is step
7075          of the array.  Loop optimizer sometimes produce this type of
7076          expressions.  */
7077       if (TREE_CODE (arg0) == ADDR_EXPR
7078           && TREE_CODE (arg1) == MULT_EXPR)
7079         {
7080           tem = try_move_mult_to_index (type, MINUS_EXPR, arg0, arg1);
7081           if (tem)
7082             return fold (tem);
7083         }
7084
7085       if (TREE_CODE (arg0) == MULT_EXPR
7086           && TREE_CODE (arg1) == MULT_EXPR
7087           && (INTEGRAL_TYPE_P (type) || flag_unsafe_math_optimizations))
7088         {
7089           /* (A * C) - (B * C) -> (A-B) * C.  */
7090           if (operand_equal_p (TREE_OPERAND (arg0, 1),
7091                                TREE_OPERAND (arg1, 1), 0))
7092             return fold (build2 (MULT_EXPR, type,
7093                                  fold (build2 (MINUS_EXPR, type,
7094                                                TREE_OPERAND (arg0, 0),
7095                                                TREE_OPERAND (arg1, 0))),
7096                                  TREE_OPERAND (arg0, 1)));
7097           /* (A * C1) - (A * C2) -> A * (C1-C2).  */
7098           if (operand_equal_p (TREE_OPERAND (arg0, 0),
7099                                TREE_OPERAND (arg1, 0), 0))
7100             return fold (build2 (MULT_EXPR, type,
7101                                  TREE_OPERAND (arg0, 0),
7102                                  fold (build2 (MINUS_EXPR, type,
7103                                                TREE_OPERAND (arg0, 1),
7104                                                TREE_OPERAND (arg1, 1)))));
7105         }
7106
7107       goto associate;
7108
7109     case MULT_EXPR:
7110       /* (-A) * (-B) -> A * B  */
7111       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7112         return fold (build2 (MULT_EXPR, type,
7113                              TREE_OPERAND (arg0, 0),
7114                              negate_expr (arg1)));
7115       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7116         return fold (build2 (MULT_EXPR, type,
7117                              negate_expr (arg0),
7118                              TREE_OPERAND (arg1, 0)));
7119
7120       if (! FLOAT_TYPE_P (type))
7121         {
7122           if (integer_zerop (arg1))
7123             return omit_one_operand (type, arg1, arg0);
7124           if (integer_onep (arg1))
7125             return non_lvalue (fold_convert (type, arg0));
7126
7127           /* (a * (1 << b)) is (a << b)  */
7128           if (TREE_CODE (arg1) == LSHIFT_EXPR
7129               && integer_onep (TREE_OPERAND (arg1, 0)))
7130             return fold (build2 (LSHIFT_EXPR, type, arg0,
7131                                  TREE_OPERAND (arg1, 1)));
7132           if (TREE_CODE (arg0) == LSHIFT_EXPR
7133               && integer_onep (TREE_OPERAND (arg0, 0)))
7134             return fold (build2 (LSHIFT_EXPR, type, arg1,
7135                                  TREE_OPERAND (arg0, 1)));
7136
7137           if (TREE_CODE (arg1) == INTEGER_CST
7138               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
7139                                              fold_convert (type, arg1),
7140                                              code, NULL_TREE)))
7141             return fold_convert (type, tem);
7142
7143         }
7144       else
7145         {
7146           /* Maybe fold x * 0 to 0.  The expressions aren't the same
7147              when x is NaN, since x * 0 is also NaN.  Nor are they the
7148              same in modes with signed zeros, since multiplying a
7149              negative value by 0 gives -0, not +0.  */
7150           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
7151               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
7152               && real_zerop (arg1))
7153             return omit_one_operand (type, arg1, arg0);
7154           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
7155           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7156               && real_onep (arg1))
7157             return non_lvalue (fold_convert (type, arg0));
7158
7159           /* Transform x * -1.0 into -x.  */
7160           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7161               && real_minus_onep (arg1))
7162             return fold_convert (type, negate_expr (arg0));
7163
7164           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
7165           if (flag_unsafe_math_optimizations
7166               && TREE_CODE (arg0) == RDIV_EXPR
7167               && TREE_CODE (arg1) == REAL_CST
7168               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
7169             {
7170               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
7171                                       arg1, 0);
7172               if (tem)
7173                 return fold (build2 (RDIV_EXPR, type, tem,
7174                                      TREE_OPERAND (arg0, 1)));
7175             }
7176
7177           if (flag_unsafe_math_optimizations)
7178             {
7179               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7180               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7181
7182               /* Optimizations of root(...)*root(...).  */
7183               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
7184                 {
7185                   tree rootfn, arg, arglist;
7186                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7187                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7188
7189                   /* Optimize sqrt(x)*sqrt(x) as x.  */
7190                   if (BUILTIN_SQRT_P (fcode0)
7191                       && operand_equal_p (arg00, arg10, 0)
7192                       && ! HONOR_SNANS (TYPE_MODE (type)))
7193                     return arg00;
7194
7195                   /* Optimize root(x)*root(y) as root(x*y).  */
7196                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7197                   arg = fold (build2 (MULT_EXPR, type, arg00, arg10));
7198                   arglist = build_tree_list (NULL_TREE, arg);
7199                   return build_function_call_expr (rootfn, arglist);
7200                 }
7201
7202               /* Optimize expN(x)*expN(y) as expN(x+y).  */
7203               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
7204                 {
7205                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7206                   tree arg = build2 (PLUS_EXPR, type,
7207                                      TREE_VALUE (TREE_OPERAND (arg0, 1)),
7208                                      TREE_VALUE (TREE_OPERAND (arg1, 1)));
7209                   tree arglist = build_tree_list (NULL_TREE, fold (arg));
7210                   return build_function_call_expr (expfn, arglist);
7211                 }
7212
7213               /* Optimizations of pow(...)*pow(...).  */
7214               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
7215                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
7216                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
7217                 {
7218                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7219                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7220                                                                      1)));
7221                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7222                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7223                                                                      1)));
7224
7225                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
7226                   if (operand_equal_p (arg01, arg11, 0))
7227                     {
7228                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7229                       tree arg = build2 (MULT_EXPR, type, arg00, arg10);
7230                       tree arglist = tree_cons (NULL_TREE, fold (arg),
7231                                                 build_tree_list (NULL_TREE,
7232                                                                  arg01));
7233                       return build_function_call_expr (powfn, arglist);
7234                     }
7235
7236                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
7237                   if (operand_equal_p (arg00, arg10, 0))
7238                     {
7239                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7240                       tree arg = fold (build2 (PLUS_EXPR, type, arg01, arg11));
7241                       tree arglist = tree_cons (NULL_TREE, arg00,
7242                                                 build_tree_list (NULL_TREE,
7243                                                                  arg));
7244                       return build_function_call_expr (powfn, arglist);
7245                     }
7246                 }
7247
7248               /* Optimize tan(x)*cos(x) as sin(x).  */
7249               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
7250                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
7251                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
7252                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
7253                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
7254                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
7255                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7256                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7257                 {
7258                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
7259
7260                   if (sinfn != NULL_TREE)
7261                     return build_function_call_expr (sinfn,
7262                                                      TREE_OPERAND (arg0, 1));
7263                 }
7264
7265               /* Optimize x*pow(x,c) as pow(x,c+1).  */
7266               if (fcode1 == BUILT_IN_POW
7267                   || fcode1 == BUILT_IN_POWF
7268                   || fcode1 == BUILT_IN_POWL)
7269                 {
7270                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7271                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7272                                                                      1)));
7273                   if (TREE_CODE (arg11) == REAL_CST
7274                       && ! TREE_CONSTANT_OVERFLOW (arg11)
7275                       && operand_equal_p (arg0, arg10, 0))
7276                     {
7277                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7278                       REAL_VALUE_TYPE c;
7279                       tree arg, arglist;
7280
7281                       c = TREE_REAL_CST (arg11);
7282                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7283                       arg = build_real (type, c);
7284                       arglist = build_tree_list (NULL_TREE, arg);
7285                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7286                       return build_function_call_expr (powfn, arglist);
7287                     }
7288                 }
7289
7290               /* Optimize pow(x,c)*x as pow(x,c+1).  */
7291               if (fcode0 == BUILT_IN_POW
7292                   || fcode0 == BUILT_IN_POWF
7293                   || fcode0 == BUILT_IN_POWL)
7294                 {
7295                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7296                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7297                                                                      1)));
7298                   if (TREE_CODE (arg01) == REAL_CST
7299                       && ! TREE_CONSTANT_OVERFLOW (arg01)
7300                       && operand_equal_p (arg1, arg00, 0))
7301                     {
7302                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7303                       REAL_VALUE_TYPE c;
7304                       tree arg, arglist;
7305
7306                       c = TREE_REAL_CST (arg01);
7307                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7308                       arg = build_real (type, c);
7309                       arglist = build_tree_list (NULL_TREE, arg);
7310                       arglist = tree_cons (NULL_TREE, arg1, arglist);
7311                       return build_function_call_expr (powfn, arglist);
7312                     }
7313                 }
7314
7315               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
7316               if (! optimize_size
7317                   && operand_equal_p (arg0, arg1, 0))
7318                 {
7319                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7320
7321                   if (powfn)
7322                     {
7323                       tree arg = build_real (type, dconst2);
7324                       tree arglist = build_tree_list (NULL_TREE, arg);
7325                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7326                       return build_function_call_expr (powfn, arglist);
7327                     }
7328                 }
7329             }
7330         }
7331       goto associate;
7332
7333     case BIT_IOR_EXPR:
7334     bit_ior:
7335       if (integer_all_onesp (arg1))
7336         return omit_one_operand (type, arg1, arg0);
7337       if (integer_zerop (arg1))
7338         return non_lvalue (fold_convert (type, arg0));
7339       if (operand_equal_p (arg0, arg1, 0))
7340         return non_lvalue (fold_convert (type, arg0));
7341
7342       /* ~X | X is -1.  */
7343       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7344           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7345         {
7346           t1 = build_int_cst (type, -1);
7347           t1 = force_fit_type (t1, 0, false, false);
7348           return omit_one_operand (type, t1, arg1);
7349         }
7350
7351       /* X | ~X is -1.  */
7352       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7353           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7354         {
7355           t1 = build_int_cst (type, -1);
7356           t1 = force_fit_type (t1, 0, false, false);
7357           return omit_one_operand (type, t1, arg0);
7358         }
7359
7360       t1 = distribute_bit_expr (code, type, arg0, arg1);
7361       if (t1 != NULL_TREE)
7362         return t1;
7363
7364       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
7365
7366          This results in more efficient code for machines without a NAND
7367          instruction.  Combine will canonicalize to the first form
7368          which will allow use of NAND instructions provided by the
7369          backend if they exist.  */
7370       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7371           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7372         {
7373           return fold (build1 (BIT_NOT_EXPR, type,
7374                                build2 (BIT_AND_EXPR, type,
7375                                        TREE_OPERAND (arg0, 0),
7376                                        TREE_OPERAND (arg1, 0))));
7377         }
7378
7379       /* See if this can be simplified into a rotate first.  If that
7380          is unsuccessful continue in the association code.  */
7381       goto bit_rotate;
7382
7383     case BIT_XOR_EXPR:
7384       if (integer_zerop (arg1))
7385         return non_lvalue (fold_convert (type, arg0));
7386       if (integer_all_onesp (arg1))
7387         return fold (build1 (BIT_NOT_EXPR, type, arg0));
7388       if (operand_equal_p (arg0, arg1, 0))
7389         return omit_one_operand (type, integer_zero_node, arg0);
7390
7391       /* ~X ^ X is -1.  */
7392       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7393           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7394         {
7395           t1 = build_int_cst (type, -1);
7396           t1 = force_fit_type (t1, 0, false, false);
7397           return omit_one_operand (type, t1, arg1);
7398         }
7399
7400       /* X ^ ~X is -1.  */
7401       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7402           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7403         {
7404           t1 = build_int_cst (type, -1);
7405           t1 = force_fit_type (t1, 0, false, false);
7406           return omit_one_operand (type, t1, arg0);
7407         }
7408
7409       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
7410          with a constant, and the two constants have no bits in common,
7411          we should treat this as a BIT_IOR_EXPR since this may produce more
7412          simplifications.  */
7413       if (TREE_CODE (arg0) == BIT_AND_EXPR
7414           && TREE_CODE (arg1) == BIT_AND_EXPR
7415           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7416           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7417           && integer_zerop (const_binop (BIT_AND_EXPR,
7418                                          TREE_OPERAND (arg0, 1),
7419                                          TREE_OPERAND (arg1, 1), 0)))
7420         {
7421           code = BIT_IOR_EXPR;
7422           goto bit_ior;
7423         }
7424
7425       /* See if this can be simplified into a rotate first.  If that
7426          is unsuccessful continue in the association code.  */
7427       goto bit_rotate;
7428
7429     case BIT_AND_EXPR:
7430       if (integer_all_onesp (arg1))
7431         return non_lvalue (fold_convert (type, arg0));
7432       if (integer_zerop (arg1))
7433         return omit_one_operand (type, arg1, arg0);
7434       if (operand_equal_p (arg0, arg1, 0))
7435         return non_lvalue (fold_convert (type, arg0));
7436
7437       /* ~X & X is always zero.  */
7438       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7439           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7440         return omit_one_operand (type, integer_zero_node, arg1);
7441
7442       /* X & ~X is always zero.  */
7443       if (TREE_CODE (arg1) == BIT_NOT_EXPR
7444           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7445         return omit_one_operand (type, integer_zero_node, arg0);
7446
7447       t1 = distribute_bit_expr (code, type, arg0, arg1);
7448       if (t1 != NULL_TREE)
7449         return t1;
7450       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
7451       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
7452           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7453         {
7454           unsigned int prec
7455             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
7456
7457           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
7458               && (~TREE_INT_CST_LOW (arg1)
7459                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
7460             return fold_convert (type, TREE_OPERAND (arg0, 0));
7461         }
7462
7463       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
7464
7465          This results in more efficient code for machines without a NOR
7466          instruction.  Combine will canonicalize to the first form
7467          which will allow use of NOR instructions provided by the
7468          backend if they exist.  */
7469       if (TREE_CODE (arg0) == BIT_NOT_EXPR
7470           && TREE_CODE (arg1) == BIT_NOT_EXPR)
7471         {
7472           return fold (build1 (BIT_NOT_EXPR, type,
7473                                build2 (BIT_IOR_EXPR, type,
7474                                        TREE_OPERAND (arg0, 0),
7475                                        TREE_OPERAND (arg1, 0))));
7476         }
7477
7478       goto associate;
7479
7480     case RDIV_EXPR:
7481       /* Don't touch a floating-point divide by zero unless the mode
7482          of the constant can represent infinity.  */
7483       if (TREE_CODE (arg1) == REAL_CST
7484           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
7485           && real_zerop (arg1))
7486         return t;
7487
7488       /* (-A) / (-B) -> A / B  */
7489       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7490         return fold (build2 (RDIV_EXPR, type,
7491                              TREE_OPERAND (arg0, 0),
7492                              negate_expr (arg1)));
7493       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7494         return fold (build2 (RDIV_EXPR, type,
7495                              negate_expr (arg0),
7496                              TREE_OPERAND (arg1, 0)));
7497
7498       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
7499       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7500           && real_onep (arg1))
7501         return non_lvalue (fold_convert (type, arg0));
7502
7503       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
7504       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7505           && real_minus_onep (arg1))
7506         return non_lvalue (fold_convert (type, negate_expr (arg0)));
7507
7508       /* If ARG1 is a constant, we can convert this to a multiply by the
7509          reciprocal.  This does not have the same rounding properties,
7510          so only do this if -funsafe-math-optimizations.  We can actually
7511          always safely do it if ARG1 is a power of two, but it's hard to
7512          tell if it is or not in a portable manner.  */
7513       if (TREE_CODE (arg1) == REAL_CST)
7514         {
7515           if (flag_unsafe_math_optimizations
7516               && 0 != (tem = const_binop (code, build_real (type, dconst1),
7517                                           arg1, 0)))
7518             return fold (build2 (MULT_EXPR, type, arg0, tem));
7519           /* Find the reciprocal if optimizing and the result is exact.  */
7520           if (optimize)
7521             {
7522               REAL_VALUE_TYPE r;
7523               r = TREE_REAL_CST (arg1);
7524               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
7525                 {
7526                   tem = build_real (type, r);
7527                   return fold (build2 (MULT_EXPR, type, arg0, tem));
7528                 }
7529             }
7530         }
7531       /* Convert A/B/C to A/(B*C).  */
7532       if (flag_unsafe_math_optimizations
7533           && TREE_CODE (arg0) == RDIV_EXPR)
7534         return fold (build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
7535                              fold (build2 (MULT_EXPR, type,
7536                                            TREE_OPERAND (arg0, 1), arg1))));
7537
7538       /* Convert A/(B/C) to (A/B)*C.  */
7539       if (flag_unsafe_math_optimizations
7540           && TREE_CODE (arg1) == RDIV_EXPR)
7541         return fold (build2 (MULT_EXPR, type,
7542                              fold (build2 (RDIV_EXPR, type, arg0,
7543                                            TREE_OPERAND (arg1, 0))),
7544                              TREE_OPERAND (arg1, 1)));
7545
7546       /* Convert C1/(X*C2) into (C1/C2)/X.  */
7547       if (flag_unsafe_math_optimizations
7548           && TREE_CODE (arg1) == MULT_EXPR
7549           && TREE_CODE (arg0) == REAL_CST
7550           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
7551         {
7552           tree tem = const_binop (RDIV_EXPR, arg0,
7553                                   TREE_OPERAND (arg1, 1), 0);
7554           if (tem)
7555             return fold (build2 (RDIV_EXPR, type, tem,
7556                                  TREE_OPERAND (arg1, 0)));
7557         }
7558
7559       if (flag_unsafe_math_optimizations)
7560         {
7561           enum built_in_function fcode = builtin_mathfn_code (arg1);
7562           /* Optimize x/expN(y) into x*expN(-y).  */
7563           if (BUILTIN_EXPONENT_P (fcode))
7564             {
7565               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7566               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
7567               tree arglist = build_tree_list (NULL_TREE,
7568                                               fold_convert (type, arg));
7569               arg1 = build_function_call_expr (expfn, arglist);
7570               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7571             }
7572
7573           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
7574           if (fcode == BUILT_IN_POW
7575               || fcode == BUILT_IN_POWF
7576               || fcode == BUILT_IN_POWL)
7577             {
7578               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7579               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7580               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
7581               tree neg11 = fold_convert (type, negate_expr (arg11));
7582               tree arglist = tree_cons(NULL_TREE, arg10,
7583                                        build_tree_list (NULL_TREE, neg11));
7584               arg1 = build_function_call_expr (powfn, arglist);
7585               return fold (build2 (MULT_EXPR, type, arg0, arg1));
7586             }
7587         }
7588
7589       if (flag_unsafe_math_optimizations)
7590         {
7591           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7592           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7593
7594           /* Optimize sin(x)/cos(x) as tan(x).  */
7595           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
7596                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
7597                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
7598               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7599                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7600             {
7601               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7602
7603               if (tanfn != NULL_TREE)
7604                 return build_function_call_expr (tanfn,
7605                                                  TREE_OPERAND (arg0, 1));
7606             }
7607
7608           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
7609           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
7610                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
7611                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
7612               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7613                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7614             {
7615               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
7616
7617               if (tanfn != NULL_TREE)
7618                 {
7619                   tree tmp = TREE_OPERAND (arg0, 1);
7620                   tmp = build_function_call_expr (tanfn, tmp);
7621                   return fold (build2 (RDIV_EXPR, type,
7622                                        build_real (type, dconst1), tmp));
7623                 }
7624             }
7625
7626           /* Optimize pow(x,c)/x as pow(x,c-1).  */
7627           if (fcode0 == BUILT_IN_POW
7628               || fcode0 == BUILT_IN_POWF
7629               || fcode0 == BUILT_IN_POWL)
7630             {
7631               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7632               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
7633               if (TREE_CODE (arg01) == REAL_CST
7634                   && ! TREE_CONSTANT_OVERFLOW (arg01)
7635                   && operand_equal_p (arg1, arg00, 0))
7636                 {
7637                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7638                   REAL_VALUE_TYPE c;
7639                   tree arg, arglist;
7640
7641                   c = TREE_REAL_CST (arg01);
7642                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
7643                   arg = build_real (type, c);
7644                   arglist = build_tree_list (NULL_TREE, arg);
7645                   arglist = tree_cons (NULL_TREE, arg1, arglist);
7646                   return build_function_call_expr (powfn, arglist);
7647                 }
7648             }
7649         }
7650       goto binary;
7651
7652     case TRUNC_DIV_EXPR:
7653     case ROUND_DIV_EXPR:
7654     case FLOOR_DIV_EXPR:
7655     case CEIL_DIV_EXPR:
7656     case EXACT_DIV_EXPR:
7657       if (integer_onep (arg1))
7658         return non_lvalue (fold_convert (type, arg0));
7659       if (integer_zerop (arg1))
7660         return t;
7661       /* X / -1 is -X.  */
7662       if (!TYPE_UNSIGNED (type)
7663           && TREE_CODE (arg1) == INTEGER_CST
7664           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7665           && TREE_INT_CST_HIGH (arg1) == -1)
7666         return fold_convert (type, negate_expr (arg0));
7667
7668       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
7669          operation, EXACT_DIV_EXPR.
7670
7671          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
7672          At one time others generated faster code, it's not clear if they do
7673          after the last round to changes to the DIV code in expmed.c.  */
7674       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
7675           && multiple_of_p (type, arg0, arg1))
7676         return fold (build2 (EXACT_DIV_EXPR, type, arg0, arg1));
7677
7678       if (TREE_CODE (arg1) == INTEGER_CST
7679           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7680                                          code, NULL_TREE)))
7681         return fold_convert (type, tem);
7682
7683       goto binary;
7684
7685     case CEIL_MOD_EXPR:
7686     case FLOOR_MOD_EXPR:
7687     case ROUND_MOD_EXPR:
7688     case TRUNC_MOD_EXPR:
7689       if (integer_onep (arg1))
7690         return omit_one_operand (type, integer_zero_node, arg0);
7691       if (integer_zerop (arg1))
7692         return t;
7693
7694       /* X % -1 is zero.  */
7695       if (!TYPE_UNSIGNED (type)
7696           && TREE_CODE (arg1) == INTEGER_CST
7697           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
7698           && TREE_INT_CST_HIGH (arg1) == -1)
7699         return omit_one_operand (type, integer_zero_node, arg0);
7700
7701       /* Optimize unsigned TRUNC_MOD_EXPR by a power of two into a
7702          BIT_AND_EXPR, i.e. "X % C" into "X & C2".  */
7703       if (code == TRUNC_MOD_EXPR
7704           && TYPE_UNSIGNED (type)
7705           && integer_pow2p (arg1))
7706         {
7707           unsigned HOST_WIDE_INT high, low;
7708           tree mask;
7709           int l;
7710
7711           l = tree_log2 (arg1);
7712           if (l >= HOST_BITS_PER_WIDE_INT)
7713             {
7714               high = ((unsigned HOST_WIDE_INT) 1
7715                       << (l - HOST_BITS_PER_WIDE_INT)) - 1;
7716               low = -1;
7717             }
7718           else
7719             {
7720               high = 0;
7721               low = ((unsigned HOST_WIDE_INT) 1 << l) - 1;
7722             }
7723
7724           mask = build_int_cst_wide (type, low, high);
7725           return fold (build2 (BIT_AND_EXPR, type,
7726                                fold_convert (type, arg0), mask));
7727         }
7728
7729       /* X % -C is the same as X % C.  */
7730       if (code == TRUNC_MOD_EXPR
7731           && !TYPE_UNSIGNED (type)
7732           && TREE_CODE (arg1) == INTEGER_CST
7733           && TREE_INT_CST_HIGH (arg1) < 0
7734           && !flag_trapv
7735           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
7736           && !sign_bit_p (arg1, arg1))
7737         return fold (build2 (code, type, fold_convert (type, arg0),
7738                              fold_convert (type, negate_expr (arg1))));
7739
7740       /* X % -Y is the same as X % Y.  */
7741       if (code == TRUNC_MOD_EXPR
7742           && !TYPE_UNSIGNED (type)
7743           && TREE_CODE (arg1) == NEGATE_EXPR
7744           && !flag_trapv)
7745         return fold (build2 (code, type, fold_convert (type, arg0),
7746                              fold_convert (type, TREE_OPERAND (arg1, 0))));
7747
7748       if (TREE_CODE (arg1) == INTEGER_CST
7749           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
7750                                          code, NULL_TREE)))
7751         return fold_convert (type, tem);
7752
7753       goto binary;
7754
7755     case LROTATE_EXPR:
7756     case RROTATE_EXPR:
7757       if (integer_all_onesp (arg0))
7758         return omit_one_operand (type, arg0, arg1);
7759       goto shift;
7760
7761     case RSHIFT_EXPR:
7762       /* Optimize -1 >> x for arithmetic right shifts.  */
7763       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
7764         return omit_one_operand (type, arg0, arg1);
7765       /* ... fall through ...  */
7766
7767     case LSHIFT_EXPR:
7768     shift:
7769       if (integer_zerop (arg1))
7770         return non_lvalue (fold_convert (type, arg0));
7771       if (integer_zerop (arg0))
7772         return omit_one_operand (type, arg0, arg1);
7773
7774       /* Since negative shift count is not well-defined,
7775          don't try to compute it in the compiler.  */
7776       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
7777         return t;
7778       /* Rewrite an LROTATE_EXPR by a constant into an
7779          RROTATE_EXPR by a new constant.  */
7780       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
7781         {
7782           tree tem = build_int_cst (NULL_TREE,
7783                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
7784           tem = fold_convert (TREE_TYPE (arg1), tem);
7785           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
7786           return fold (build2 (RROTATE_EXPR, type, arg0, tem));
7787         }
7788
7789       /* If we have a rotate of a bit operation with the rotate count and
7790          the second operand of the bit operation both constant,
7791          permute the two operations.  */
7792       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7793           && (TREE_CODE (arg0) == BIT_AND_EXPR
7794               || TREE_CODE (arg0) == BIT_IOR_EXPR
7795               || TREE_CODE (arg0) == BIT_XOR_EXPR)
7796           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7797         return fold (build2 (TREE_CODE (arg0), type,
7798                              fold (build2 (code, type,
7799                                            TREE_OPERAND (arg0, 0), arg1)),
7800                              fold (build2 (code, type,
7801                                            TREE_OPERAND (arg0, 1), arg1))));
7802
7803       /* Two consecutive rotates adding up to the width of the mode can
7804          be ignored.  */
7805       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7806           && TREE_CODE (arg0) == RROTATE_EXPR
7807           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7808           && TREE_INT_CST_HIGH (arg1) == 0
7809           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
7810           && ((TREE_INT_CST_LOW (arg1)
7811                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
7812               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
7813         return TREE_OPERAND (arg0, 0);
7814
7815       goto binary;
7816
7817     case MIN_EXPR:
7818       if (operand_equal_p (arg0, arg1, 0))
7819         return omit_one_operand (type, arg0, arg1);
7820       if (INTEGRAL_TYPE_P (type)
7821           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
7822         return omit_one_operand (type, arg1, arg0);
7823       goto associate;
7824
7825     case MAX_EXPR:
7826       if (operand_equal_p (arg0, arg1, 0))
7827         return omit_one_operand (type, arg0, arg1);
7828       if (INTEGRAL_TYPE_P (type)
7829           && TYPE_MAX_VALUE (type)
7830           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
7831         return omit_one_operand (type, arg1, arg0);
7832       goto associate;
7833
7834     case TRUTH_NOT_EXPR:
7835       /* The argument to invert_truthvalue must have Boolean type.  */
7836       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7837           arg0 = fold_convert (boolean_type_node, arg0);
7838
7839       /* Note that the operand of this must be an int
7840          and its values must be 0 or 1.
7841          ("true" is a fixed value perhaps depending on the language,
7842          but we don't handle values other than 1 correctly yet.)  */
7843       tem = invert_truthvalue (arg0);
7844       /* Avoid infinite recursion.  */
7845       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
7846         {
7847           tem = fold_single_bit_test (code, arg0, arg1, type);
7848           if (tem)
7849             return tem;
7850           return t;
7851         }
7852       return fold_convert (type, tem);
7853
7854     case TRUTH_ANDIF_EXPR:
7855       /* Note that the operands of this must be ints
7856          and their values must be 0 or 1.
7857          ("true" is a fixed value perhaps depending on the language.)  */
7858       /* If first arg is constant zero, return it.  */
7859       if (integer_zerop (arg0))
7860         return fold_convert (type, arg0);
7861     case TRUTH_AND_EXPR:
7862       /* If either arg is constant true, drop it.  */
7863       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7864         return non_lvalue (fold_convert (type, arg1));
7865       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
7866           /* Preserve sequence points.  */
7867           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7868         return non_lvalue (fold_convert (type, arg0));
7869       /* If second arg is constant zero, result is zero, but first arg
7870          must be evaluated.  */
7871       if (integer_zerop (arg1))
7872         return omit_one_operand (type, arg1, arg0);
7873       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
7874          case will be handled here.  */
7875       if (integer_zerop (arg0))
7876         return omit_one_operand (type, arg0, arg1);
7877
7878       /* !X && X is always false.  */
7879       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7880           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7881         return omit_one_operand (type, integer_zero_node, arg1);
7882       /* X && !X is always false.  */
7883       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7884           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7885         return omit_one_operand (type, integer_zero_node, arg0);
7886
7887     truth_andor:
7888       /* We only do these simplifications if we are optimizing.  */
7889       if (!optimize)
7890         return t;
7891
7892       /* Check for things like (A || B) && (A || C).  We can convert this
7893          to A || (B && C).  Note that either operator can be any of the four
7894          truth and/or operations and the transformation will still be
7895          valid.   Also note that we only care about order for the
7896          ANDIF and ORIF operators.  If B contains side effects, this
7897          might change the truth-value of A.  */
7898       if (TREE_CODE (arg0) == TREE_CODE (arg1)
7899           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7900               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7901               || TREE_CODE (arg0) == TRUTH_AND_EXPR
7902               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7903           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7904         {
7905           tree a00 = TREE_OPERAND (arg0, 0);
7906           tree a01 = TREE_OPERAND (arg0, 1);
7907           tree a10 = TREE_OPERAND (arg1, 0);
7908           tree a11 = TREE_OPERAND (arg1, 1);
7909           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7910                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7911                              && (code == TRUTH_AND_EXPR
7912                                  || code == TRUTH_OR_EXPR));
7913
7914           if (operand_equal_p (a00, a10, 0))
7915             return fold (build2 (TREE_CODE (arg0), type, a00,
7916                                  fold (build2 (code, type, a01, a11))));
7917           else if (commutative && operand_equal_p (a00, a11, 0))
7918             return fold (build2 (TREE_CODE (arg0), type, a00,
7919                                  fold (build2 (code, type, a01, a10))));
7920           else if (commutative && operand_equal_p (a01, a10, 0))
7921             return fold (build2 (TREE_CODE (arg0), type, a01,
7922                                  fold (build2 (code, type, a00, a11))));
7923
7924           /* This case if tricky because we must either have commutative
7925              operators or else A10 must not have side-effects.  */
7926
7927           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7928                    && operand_equal_p (a01, a11, 0))
7929             return fold (build2 (TREE_CODE (arg0), type,
7930                                  fold (build2 (code, type, a00, a10)),
7931                                  a01));
7932         }
7933
7934       /* See if we can build a range comparison.  */
7935       if (0 != (tem = fold_range_test (t)))
7936         return tem;
7937
7938       /* Check for the possibility of merging component references.  If our
7939          lhs is another similar operation, try to merge its rhs with our
7940          rhs.  Then try to merge our lhs and rhs.  */
7941       if (TREE_CODE (arg0) == code
7942           && 0 != (tem = fold_truthop (code, type,
7943                                        TREE_OPERAND (arg0, 1), arg1)))
7944         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
7945
7946       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
7947         return tem;
7948
7949       return t;
7950
7951     case TRUTH_ORIF_EXPR:
7952       /* Note that the operands of this must be ints
7953          and their values must be 0 or true.
7954          ("true" is a fixed value perhaps depending on the language.)  */
7955       /* If first arg is constant true, return it.  */
7956       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7957         return fold_convert (type, arg0);
7958     case TRUTH_OR_EXPR:
7959       /* If either arg is constant zero, drop it.  */
7960       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
7961         return non_lvalue (fold_convert (type, arg1));
7962       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
7963           /* Preserve sequence points.  */
7964           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
7965         return non_lvalue (fold_convert (type, arg0));
7966       /* If second arg is constant true, result is true, but we must
7967          evaluate first arg.  */
7968       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
7969         return omit_one_operand (type, arg1, arg0);
7970       /* Likewise for first arg, but note this only occurs here for
7971          TRUTH_OR_EXPR.  */
7972       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
7973         return omit_one_operand (type, arg0, arg1);
7974
7975       /* !X || X is always true.  */
7976       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7977           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7978         return omit_one_operand (type, integer_one_node, arg1);
7979       /* X || !X is always true.  */
7980       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
7981           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7982         return omit_one_operand (type, integer_one_node, arg0);
7983
7984       goto truth_andor;
7985
7986     case TRUTH_XOR_EXPR:
7987       /* If the second arg is constant zero, drop it.  */
7988       if (integer_zerop (arg1))
7989         return non_lvalue (fold_convert (type, arg0));
7990       /* If the second arg is constant true, this is a logical inversion.  */
7991       if (integer_onep (arg1))
7992         return non_lvalue (fold_convert (type, invert_truthvalue (arg0)));
7993       /* Identical arguments cancel to zero.  */
7994       if (operand_equal_p (arg0, arg1, 0))
7995         return omit_one_operand (type, integer_zero_node, arg0);
7996
7997       /* !X ^ X is always true.  */
7998       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
7999           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8000         return omit_one_operand (type, integer_one_node, arg1);
8001
8002       /* X ^ !X is always true.  */
8003       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
8004           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8005         return omit_one_operand (type, integer_one_node, arg0);
8006
8007       return t;
8008
8009     case EQ_EXPR:
8010     case NE_EXPR:
8011     case LT_EXPR:
8012     case GT_EXPR:
8013     case LE_EXPR:
8014     case GE_EXPR:
8015       /* If one arg is a real or integer constant, put it last.  */
8016       if (tree_swap_operands_p (arg0, arg1, true))
8017         return fold (build2 (swap_tree_comparison (code), type, arg1, arg0));
8018
8019       /* If this is an equality comparison of the address of a non-weak
8020          object against zero, then we know the result.  */
8021       if ((code == EQ_EXPR || code == NE_EXPR)
8022           && TREE_CODE (arg0) == ADDR_EXPR
8023           && DECL_P (TREE_OPERAND (arg0, 0))
8024           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
8025           && integer_zerop (arg1))
8026         return constant_boolean_node (code != EQ_EXPR, type);
8027
8028       /* If this is an equality comparison of the address of two non-weak,
8029          unaliased symbols neither of which are extern (since we do not
8030          have access to attributes for externs), then we know the result.  */
8031       if ((code == EQ_EXPR || code == NE_EXPR)
8032           && TREE_CODE (arg0) == ADDR_EXPR
8033           && DECL_P (TREE_OPERAND (arg0, 0))
8034           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
8035           && ! lookup_attribute ("alias",
8036                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
8037           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
8038           && TREE_CODE (arg1) == ADDR_EXPR
8039           && DECL_P (TREE_OPERAND (arg1, 0))
8040           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
8041           && ! lookup_attribute ("alias",
8042                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
8043           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
8044         return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
8045                                       ? code == EQ_EXPR : code != EQ_EXPR,
8046                                       type);
8047
8048       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
8049         {
8050           tree targ0 = strip_float_extensions (arg0);
8051           tree targ1 = strip_float_extensions (arg1);
8052           tree newtype = TREE_TYPE (targ0);
8053
8054           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8055             newtype = TREE_TYPE (targ1);
8056
8057           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8058           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8059             return fold (build2 (code, type, fold_convert (newtype, targ0),
8060                                  fold_convert (newtype, targ1)));
8061
8062           /* (-a) CMP (-b) -> b CMP a  */
8063           if (TREE_CODE (arg0) == NEGATE_EXPR
8064               && TREE_CODE (arg1) == NEGATE_EXPR)
8065             return fold (build2 (code, type, TREE_OPERAND (arg1, 0),
8066                                  TREE_OPERAND (arg0, 0)));
8067
8068           if (TREE_CODE (arg1) == REAL_CST)
8069           {
8070             REAL_VALUE_TYPE cst;
8071             cst = TREE_REAL_CST (arg1);
8072
8073             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
8074             if (TREE_CODE (arg0) == NEGATE_EXPR)
8075               return
8076                 fold (build2 (swap_tree_comparison (code), type,
8077                               TREE_OPERAND (arg0, 0),
8078                               build_real (TREE_TYPE (arg1),
8079                                           REAL_VALUE_NEGATE (cst))));
8080
8081             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
8082             /* a CMP (-0) -> a CMP 0  */
8083             if (REAL_VALUE_MINUS_ZERO (cst))
8084               return fold (build2 (code, type, arg0,
8085                                    build_real (TREE_TYPE (arg1), dconst0)));
8086
8087             /* x != NaN is always true, other ops are always false.  */
8088             if (REAL_VALUE_ISNAN (cst)
8089                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
8090               {
8091                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8092                 return omit_one_operand (type, tem, arg0);
8093               }
8094
8095             /* Fold comparisons against infinity.  */
8096             if (REAL_VALUE_ISINF (cst))
8097               {
8098                 tem = fold_inf_compare (code, type, arg0, arg1);
8099                 if (tem != NULL_TREE)
8100                   return tem;
8101               }
8102           }
8103
8104           /* If this is a comparison of a real constant with a PLUS_EXPR
8105              or a MINUS_EXPR of a real constant, we can convert it into a
8106              comparison with a revised real constant as long as no overflow
8107              occurs when unsafe_math_optimizations are enabled.  */
8108           if (flag_unsafe_math_optimizations
8109               && TREE_CODE (arg1) == REAL_CST
8110               && (TREE_CODE (arg0) == PLUS_EXPR
8111                   || TREE_CODE (arg0) == MINUS_EXPR)
8112               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8113               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8114                                           ? MINUS_EXPR : PLUS_EXPR,
8115                                           arg1, TREE_OPERAND (arg0, 1), 0))
8116               && ! TREE_CONSTANT_OVERFLOW (tem))
8117             return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8118
8119           /* Likewise, we can simplify a comparison of a real constant with
8120              a MINUS_EXPR whose first operand is also a real constant, i.e.
8121              (c1 - x) < c2 becomes x > c1-c2.  */
8122           if (flag_unsafe_math_optimizations
8123               && TREE_CODE (arg1) == REAL_CST
8124               && TREE_CODE (arg0) == MINUS_EXPR
8125               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8126               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8127                                           arg1, 0))
8128               && ! TREE_CONSTANT_OVERFLOW (tem))
8129             return fold (build2 (swap_tree_comparison (code), type,
8130                                  TREE_OPERAND (arg0, 1), tem));
8131
8132           /* Fold comparisons against built-in math functions.  */
8133           if (TREE_CODE (arg1) == REAL_CST
8134               && flag_unsafe_math_optimizations
8135               && ! flag_errno_math)
8136             {
8137               enum built_in_function fcode = builtin_mathfn_code (arg0);
8138
8139               if (fcode != END_BUILTINS)
8140                 {
8141                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8142                   if (tem != NULL_TREE)
8143                     return tem;
8144                 }
8145             }
8146         }
8147
8148       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
8149       if (TREE_CONSTANT (arg1)
8150           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
8151               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
8152           /* This optimization is invalid for ordered comparisons
8153              if CONST+INCR overflows or if foo+incr might overflow.
8154              This optimization is invalid for floating point due to rounding.
8155              For pointer types we assume overflow doesn't happen.  */
8156           && (POINTER_TYPE_P (TREE_TYPE (arg0))
8157               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8158                   && (code == EQ_EXPR || code == NE_EXPR))))
8159         {
8160           tree varop, newconst;
8161
8162           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
8163             {
8164               newconst = fold (build2 (PLUS_EXPR, TREE_TYPE (arg0),
8165                                        arg1, TREE_OPERAND (arg0, 1)));
8166               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
8167                               TREE_OPERAND (arg0, 0),
8168                               TREE_OPERAND (arg0, 1));
8169             }
8170           else
8171             {
8172               newconst = fold (build2 (MINUS_EXPR, TREE_TYPE (arg0),
8173                                        arg1, TREE_OPERAND (arg0, 1)));
8174               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
8175                               TREE_OPERAND (arg0, 0),
8176                               TREE_OPERAND (arg0, 1));
8177             }
8178
8179
8180           /* If VAROP is a reference to a bitfield, we must mask
8181              the constant by the width of the field.  */
8182           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
8183               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
8184               && host_integerp (DECL_SIZE (TREE_OPERAND
8185                                            (TREE_OPERAND (varop, 0), 1)), 1))
8186             {
8187               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
8188               HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
8189               tree folded_compare, shift;
8190
8191               /* First check whether the comparison would come out
8192                  always the same.  If we don't do that we would
8193                  change the meaning with the masking.  */
8194               folded_compare = fold (build2 (code, type,
8195                                              TREE_OPERAND (varop, 0), arg1));
8196               if (integer_zerop (folded_compare)
8197                   || integer_onep (folded_compare))
8198                 return omit_one_operand (type, folded_compare, varop);
8199
8200               shift = build_int_cst (NULL_TREE,
8201                                      TYPE_PRECISION (TREE_TYPE (varop)) - size);
8202               shift = fold_convert (TREE_TYPE (varop), shift);
8203               newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8204                                        newconst, shift));
8205               newconst = fold (build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8206                                        newconst, shift));
8207             }
8208
8209           return fold (build2 (code, type, varop, newconst));
8210         }
8211
8212       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
8213          This transformation affects the cases which are handled in later
8214          optimizations involving comparisons with non-negative constants.  */
8215       if (TREE_CODE (arg1) == INTEGER_CST
8216           && TREE_CODE (arg0) != INTEGER_CST
8217           && tree_int_cst_sgn (arg1) > 0)
8218         {
8219           switch (code)
8220             {
8221             case GE_EXPR:
8222               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8223               return fold (build2 (GT_EXPR, type, arg0, arg1));
8224
8225             case LT_EXPR:
8226               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8227               return fold (build2 (LE_EXPR, type, arg0, arg1));
8228
8229             default:
8230               break;
8231             }
8232         }
8233
8234       /* Comparisons with the highest or lowest possible integer of
8235          the specified size will have known values.
8236
8237          This is quite similar to fold_relational_hi_lo; however, my
8238          attempts to share the code have been nothing but trouble.
8239          I give up for now.  */
8240       {
8241         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
8242
8243         if (TREE_CODE (arg1) == INTEGER_CST
8244             && ! TREE_CONSTANT_OVERFLOW (arg1)
8245             && width <= HOST_BITS_PER_WIDE_INT
8246             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
8247                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
8248           {
8249             unsigned HOST_WIDE_INT signed_max;
8250             unsigned HOST_WIDE_INT max, min;
8251
8252             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
8253
8254             if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
8255               {
8256                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
8257                 min = 0;
8258               }
8259             else
8260               {
8261                 max = signed_max;
8262                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
8263               }
8264
8265             if (TREE_INT_CST_HIGH (arg1) == 0
8266                 && TREE_INT_CST_LOW (arg1) == max)
8267               switch (code)
8268                 {
8269                 case GT_EXPR:
8270                   return omit_one_operand (type, integer_zero_node, arg0);
8271
8272                 case GE_EXPR:
8273                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8274
8275                 case LE_EXPR:
8276                   return omit_one_operand (type, integer_one_node, arg0);
8277
8278                 case LT_EXPR:
8279                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8280
8281                 /* The GE_EXPR and LT_EXPR cases above are not normally
8282                    reached because of previous transformations.  */
8283
8284                 default:
8285                   break;
8286                 }
8287             else if (TREE_INT_CST_HIGH (arg1) == 0
8288                      && TREE_INT_CST_LOW (arg1) == max - 1)
8289               switch (code)
8290                 {
8291                 case GT_EXPR:
8292                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8293                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8294                 case LE_EXPR:
8295                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
8296                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8297                 default:
8298                   break;
8299                 }
8300             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8301                      && TREE_INT_CST_LOW (arg1) == min)
8302               switch (code)
8303                 {
8304                 case LT_EXPR:
8305                   return omit_one_operand (type, integer_zero_node, arg0);
8306
8307                 case LE_EXPR:
8308                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8309
8310                 case GE_EXPR:
8311                   return omit_one_operand (type, integer_one_node, arg0);
8312
8313                 case GT_EXPR:
8314                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8315
8316                 default:
8317                   break;
8318                 }
8319             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
8320                      && TREE_INT_CST_LOW (arg1) == min + 1)
8321               switch (code)
8322                 {
8323                 case GE_EXPR:
8324                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8325                   return fold (build2 (NE_EXPR, type, arg0, arg1));
8326                 case LT_EXPR:
8327                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
8328                   return fold (build2 (EQ_EXPR, type, arg0, arg1));
8329                 default:
8330                   break;
8331                 }
8332
8333             else if (!in_gimple_form
8334                      && TREE_INT_CST_HIGH (arg1) == 0
8335                      && TREE_INT_CST_LOW (arg1) == signed_max
8336                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
8337                      /* signed_type does not work on pointer types.  */
8338                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
8339               {
8340                 /* The following case also applies to X < signed_max+1
8341                    and X >= signed_max+1 because previous transformations.  */
8342                 if (code == LE_EXPR || code == GT_EXPR)
8343                   {
8344                     tree st0, st1;
8345                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
8346                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
8347                     return fold
8348                       (build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
8349                                type, fold_convert (st0, arg0),
8350                                fold_convert (st1, integer_zero_node)));
8351                   }
8352               }
8353           }
8354       }
8355
8356       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
8357          a MINUS_EXPR of a constant, we can convert it into a comparison with
8358          a revised constant as long as no overflow occurs.  */
8359       if ((code == EQ_EXPR || code == NE_EXPR)
8360           && TREE_CODE (arg1) == INTEGER_CST
8361           && (TREE_CODE (arg0) == PLUS_EXPR
8362               || TREE_CODE (arg0) == MINUS_EXPR)
8363           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8364           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8365                                       ? MINUS_EXPR : PLUS_EXPR,
8366                                       arg1, TREE_OPERAND (arg0, 1), 0))
8367           && ! TREE_CONSTANT_OVERFLOW (tem))
8368         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8369
8370       /* Similarly for a NEGATE_EXPR.  */
8371       else if ((code == EQ_EXPR || code == NE_EXPR)
8372                && TREE_CODE (arg0) == NEGATE_EXPR
8373                && TREE_CODE (arg1) == INTEGER_CST
8374                && 0 != (tem = negate_expr (arg1))
8375                && TREE_CODE (tem) == INTEGER_CST
8376                && ! TREE_CONSTANT_OVERFLOW (tem))
8377         return fold (build2 (code, type, TREE_OPERAND (arg0, 0), tem));
8378
8379       /* If we have X - Y == 0, we can convert that to X == Y and similarly
8380          for !=.  Don't do this for ordered comparisons due to overflow.  */
8381       else if ((code == NE_EXPR || code == EQ_EXPR)
8382                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
8383         return fold (build2 (code, type,
8384                              TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
8385
8386       /* If we are widening one operand of an integer comparison,
8387          see if the other operand is similarly being widened.  Perhaps we
8388          can do the comparison in the narrower type.  */
8389       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8390                && TREE_CODE (arg0) == NOP_EXPR
8391                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
8392                && (code == EQ_EXPR || code == NE_EXPR
8393                    || TYPE_UNSIGNED (TREE_TYPE (arg0))
8394                       == TYPE_UNSIGNED (TREE_TYPE (tem)))
8395                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
8396                && (TREE_TYPE (t1) == TREE_TYPE (tem)
8397                    || (TREE_CODE (t1) == INTEGER_CST
8398                        && TREE_CODE (TREE_TYPE (tem)) == INTEGER_TYPE
8399                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
8400         return fold (build2 (code, type, tem,
8401                              fold_convert (TREE_TYPE (tem), t1)));
8402
8403       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8404          constant, we can simplify it.  */
8405       else if (TREE_CODE (arg1) == INTEGER_CST
8406                && (TREE_CODE (arg0) == MIN_EXPR
8407                    || TREE_CODE (arg0) == MAX_EXPR)
8408                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8409         return optimize_minmax_comparison (t);
8410
8411       /* If we are comparing an ABS_EXPR with a constant, we can
8412          convert all the cases into explicit comparisons, but they may
8413          well not be faster than doing the ABS and one comparison.
8414          But ABS (X) <= C is a range comparison, which becomes a subtraction
8415          and a comparison, and is probably faster.  */
8416       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8417                && TREE_CODE (arg0) == ABS_EXPR
8418                && ! TREE_SIDE_EFFECTS (arg0)
8419                && (0 != (tem = negate_expr (arg1)))
8420                && TREE_CODE (tem) == INTEGER_CST
8421                && ! TREE_CONSTANT_OVERFLOW (tem))
8422         return fold (build2 (TRUTH_ANDIF_EXPR, type,
8423                              build2 (GE_EXPR, type,
8424                                      TREE_OPERAND (arg0, 0), tem),
8425                              build2 (LE_EXPR, type,
8426                                      TREE_OPERAND (arg0, 0), arg1)));
8427
8428       /* If this is an EQ or NE comparison with zero and ARG0 is
8429          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
8430          two operations, but the latter can be done in one less insn
8431          on machines that have only two-operand insns or on which a
8432          constant cannot be the first operand.  */
8433       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
8434           && TREE_CODE (arg0) == BIT_AND_EXPR)
8435         {
8436           tree arg00 = TREE_OPERAND (arg0, 0);
8437           tree arg01 = TREE_OPERAND (arg0, 1);
8438           if (TREE_CODE (arg00) == LSHIFT_EXPR
8439               && integer_onep (TREE_OPERAND (arg00, 0)))
8440             return
8441               fold (build2 (code, type,
8442                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8443                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
8444                                             arg01, TREE_OPERAND (arg00, 1)),
8445                                     fold_convert (TREE_TYPE (arg0),
8446                                                   integer_one_node)),
8447                             arg1));
8448           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
8449                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
8450             return
8451               fold (build2 (code, type,
8452                             build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8453                                     build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
8454                                             arg00, TREE_OPERAND (arg01, 1)),
8455                                     fold_convert (TREE_TYPE (arg0),
8456                                                   integer_one_node)),
8457                             arg1));
8458         }
8459
8460       /* If this is an NE or EQ comparison of zero against the result of a
8461          signed MOD operation whose second operand is a power of 2, make
8462          the MOD operation unsigned since it is simpler and equivalent.  */
8463       if ((code == NE_EXPR || code == EQ_EXPR)
8464           && integer_zerop (arg1)
8465           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
8466           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
8467               || TREE_CODE (arg0) == CEIL_MOD_EXPR
8468               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
8469               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
8470           && integer_pow2p (TREE_OPERAND (arg0, 1)))
8471         {
8472           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
8473           tree newmod = fold (build2 (TREE_CODE (arg0), newtype,
8474                                       fold_convert (newtype,
8475                                                     TREE_OPERAND (arg0, 0)),
8476                                       fold_convert (newtype,
8477                                                     TREE_OPERAND (arg0, 1))));
8478
8479           return fold (build2 (code, type, newmod,
8480                                fold_convert (newtype, arg1)));
8481         }
8482
8483       /* If this is an NE comparison of zero with an AND of one, remove the
8484          comparison since the AND will give the correct value.  */
8485       if (code == NE_EXPR && integer_zerop (arg1)
8486           && TREE_CODE (arg0) == BIT_AND_EXPR
8487           && integer_onep (TREE_OPERAND (arg0, 1)))
8488         return fold_convert (type, arg0);
8489
8490       /* If we have (A & C) == C where C is a power of 2, convert this into
8491          (A & C) != 0.  Similarly for NE_EXPR.  */
8492       if ((code == EQ_EXPR || code == NE_EXPR)
8493           && TREE_CODE (arg0) == BIT_AND_EXPR
8494           && integer_pow2p (TREE_OPERAND (arg0, 1))
8495           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8496         return fold (build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
8497                              arg0, fold_convert (TREE_TYPE (arg0),
8498                                                  integer_zero_node)));
8499
8500       /* If we have (A & C) != 0 or (A & C) == 0 and C is a power of
8501          2, then fold the expression into shifts and logical operations.  */
8502       tem = fold_single_bit_test (code, arg0, arg1, type);
8503       if (tem)
8504         return tem;
8505
8506       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
8507          Similarly for NE_EXPR.  */
8508       if ((code == EQ_EXPR || code == NE_EXPR)
8509           && TREE_CODE (arg0) == BIT_AND_EXPR
8510           && TREE_CODE (arg1) == INTEGER_CST
8511           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8512         {
8513           tree notc = fold (build1 (BIT_NOT_EXPR,
8514                                     TREE_TYPE (TREE_OPERAND (arg0, 1)),
8515                                     TREE_OPERAND (arg0, 1)));
8516           tree dandnotc = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8517                                         arg1, notc));
8518           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8519           if (integer_nonzerop (dandnotc))
8520             return omit_one_operand (type, rslt, arg0);
8521         }
8522
8523       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
8524          Similarly for NE_EXPR.  */
8525       if ((code == EQ_EXPR || code == NE_EXPR)
8526           && TREE_CODE (arg0) == BIT_IOR_EXPR
8527           && TREE_CODE (arg1) == INTEGER_CST
8528           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8529         {
8530           tree notd = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1));
8531           tree candnotd = fold (build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
8532                                         TREE_OPERAND (arg0, 1), notd));
8533           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
8534           if (integer_nonzerop (candnotd))
8535             return omit_one_operand (type, rslt, arg0);
8536         }
8537
8538       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
8539          and similarly for >= into !=.  */
8540       if ((code == LT_EXPR || code == GE_EXPR)
8541           && TYPE_UNSIGNED (TREE_TYPE (arg0))
8542           && TREE_CODE (arg1) == LSHIFT_EXPR
8543           && integer_onep (TREE_OPERAND (arg1, 0)))
8544         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8545                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8546                                TREE_OPERAND (arg1, 1)),
8547                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
8548
8549       else if ((code == LT_EXPR || code == GE_EXPR)
8550                && TYPE_UNSIGNED (TREE_TYPE (arg0))
8551                && (TREE_CODE (arg1) == NOP_EXPR
8552                    || TREE_CODE (arg1) == CONVERT_EXPR)
8553                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
8554                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
8555         return
8556           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
8557                   fold_convert (TREE_TYPE (arg0),
8558                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
8559                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
8560                                                       1))),
8561                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
8562
8563       /* Simplify comparison of something with itself.  (For IEEE
8564          floating-point, we can only do some of these simplifications.)  */
8565       if (operand_equal_p (arg0, arg1, 0))
8566         {
8567           switch (code)
8568             {
8569             case EQ_EXPR:
8570               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8571                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8572                 return constant_boolean_node (1, type);
8573               break;
8574
8575             case GE_EXPR:
8576             case LE_EXPR:
8577               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8578                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8579                 return constant_boolean_node (1, type);
8580               return fold (build2 (EQ_EXPR, type, arg0, arg1));
8581
8582             case NE_EXPR:
8583               /* For NE, we can only do this simplification if integer
8584                  or we don't honor IEEE floating point NaNs.  */
8585               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8586                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8587                 break;
8588               /* ... fall through ...  */
8589             case GT_EXPR:
8590             case LT_EXPR:
8591               return constant_boolean_node (0, type);
8592             default:
8593               gcc_unreachable ();
8594             }
8595         }
8596
8597       /* If we are comparing an expression that just has comparisons
8598          of two integer values, arithmetic expressions of those comparisons,
8599          and constants, we can simplify it.  There are only three cases
8600          to check: the two values can either be equal, the first can be
8601          greater, or the second can be greater.  Fold the expression for
8602          those three values.  Since each value must be 0 or 1, we have
8603          eight possibilities, each of which corresponds to the constant 0
8604          or 1 or one of the six possible comparisons.
8605
8606          This handles common cases like (a > b) == 0 but also handles
8607          expressions like  ((x > y) - (y > x)) > 0, which supposedly
8608          occur in macroized code.  */
8609
8610       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8611         {
8612           tree cval1 = 0, cval2 = 0;
8613           int save_p = 0;
8614
8615           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8616               /* Don't handle degenerate cases here; they should already
8617                  have been handled anyway.  */
8618               && cval1 != 0 && cval2 != 0
8619               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8620               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8621               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8622               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8623               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8624               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8625                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8626             {
8627               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8628               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8629
8630               /* We can't just pass T to eval_subst in case cval1 or cval2
8631                  was the same as ARG1.  */
8632
8633               tree high_result
8634                 = fold (build2 (code, type,
8635                                 eval_subst (arg0, cval1, maxval,
8636                                             cval2, minval),
8637                                 arg1));
8638               tree equal_result
8639                 = fold (build2 (code, type,
8640                                 eval_subst (arg0, cval1, maxval,
8641                                             cval2, maxval),
8642                                 arg1));
8643               tree low_result
8644                 = fold (build2 (code, type,
8645                                 eval_subst (arg0, cval1, minval,
8646                                             cval2, maxval),
8647                                 arg1));
8648
8649               /* All three of these results should be 0 or 1.  Confirm they
8650                  are.  Then use those values to select the proper code
8651                  to use.  */
8652
8653               if ((integer_zerop (high_result)
8654                    || integer_onep (high_result))
8655                   && (integer_zerop (equal_result)
8656                       || integer_onep (equal_result))
8657                   && (integer_zerop (low_result)
8658                       || integer_onep (low_result)))
8659                 {
8660                   /* Make a 3-bit mask with the high-order bit being the
8661                      value for `>', the next for '=', and the low for '<'.  */
8662                   switch ((integer_onep (high_result) * 4)
8663                           + (integer_onep (equal_result) * 2)
8664                           + integer_onep (low_result))
8665                     {
8666                     case 0:
8667                       /* Always false.  */
8668                       return omit_one_operand (type, integer_zero_node, arg0);
8669                     case 1:
8670                       code = LT_EXPR;
8671                       break;
8672                     case 2:
8673                       code = EQ_EXPR;
8674                       break;
8675                     case 3:
8676                       code = LE_EXPR;
8677                       break;
8678                     case 4:
8679                       code = GT_EXPR;
8680                       break;
8681                     case 5:
8682                       code = NE_EXPR;
8683                       break;
8684                     case 6:
8685                       code = GE_EXPR;
8686                       break;
8687                     case 7:
8688                       /* Always true.  */
8689                       return omit_one_operand (type, integer_one_node, arg0);
8690                     }
8691
8692                   tem = build2 (code, type, cval1, cval2);
8693                   if (save_p)
8694                     return save_expr (tem);
8695                   else
8696                     return fold (tem);
8697                 }
8698             }
8699         }
8700
8701       /* If this is a comparison of a field, we may be able to simplify it.  */
8702       if (((TREE_CODE (arg0) == COMPONENT_REF
8703             && lang_hooks.can_use_bit_fields_p ())
8704            || TREE_CODE (arg0) == BIT_FIELD_REF)
8705           && (code == EQ_EXPR || code == NE_EXPR)
8706           /* Handle the constant case even without -O
8707              to make sure the warnings are given.  */
8708           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
8709         {
8710           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
8711           if (t1)
8712             return t1;
8713         }
8714
8715       /* If this is a comparison of complex values and either or both sides
8716          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
8717          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
8718          This may prevent needless evaluations.  */
8719       if ((code == EQ_EXPR || code == NE_EXPR)
8720           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
8721           && (TREE_CODE (arg0) == COMPLEX_EXPR
8722               || TREE_CODE (arg1) == COMPLEX_EXPR
8723               || TREE_CODE (arg0) == COMPLEX_CST
8724               || TREE_CODE (arg1) == COMPLEX_CST))
8725         {
8726           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
8727           tree real0, imag0, real1, imag1;
8728
8729           arg0 = save_expr (arg0);
8730           arg1 = save_expr (arg1);
8731           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
8732           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
8733           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
8734           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
8735
8736           return fold (build2 ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
8737                                 : TRUTH_ORIF_EXPR),
8738                                type,
8739                                fold (build2 (code, type, real0, real1)),
8740                                fold (build2 (code, type, imag0, imag1))));
8741         }
8742
8743       /* Optimize comparisons of strlen vs zero to a compare of the
8744          first character of the string vs zero.  To wit,
8745                 strlen(ptr) == 0   =>  *ptr == 0
8746                 strlen(ptr) != 0   =>  *ptr != 0
8747          Other cases should reduce to one of these two (or a constant)
8748          due to the return value of strlen being unsigned.  */
8749       if ((code == EQ_EXPR || code == NE_EXPR)
8750           && integer_zerop (arg1)
8751           && TREE_CODE (arg0) == CALL_EXPR)
8752         {
8753           tree fndecl = get_callee_fndecl (arg0);
8754           tree arglist;
8755
8756           if (fndecl
8757               && DECL_BUILT_IN (fndecl)
8758               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
8759               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
8760               && (arglist = TREE_OPERAND (arg0, 1))
8761               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
8762               && ! TREE_CHAIN (arglist))
8763             return fold (build2 (code, type,
8764                                  build1 (INDIRECT_REF, char_type_node,
8765                                          TREE_VALUE (arglist)),
8766                                  fold_convert (char_type_node,
8767                                                integer_zero_node)));
8768         }
8769
8770       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8771          into a single range test.  */
8772       if (TREE_CODE (arg0) == TRUNC_DIV_EXPR
8773           && TREE_CODE (arg1) == INTEGER_CST
8774           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8775           && !integer_zerop (TREE_OPERAND (arg0, 1))
8776           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8777           && !TREE_OVERFLOW (arg1))
8778         {
8779           t1 = fold_div_compare (code, type, arg0, arg1);
8780           if (t1 != NULL_TREE)
8781             return t1;
8782         }
8783
8784       if ((code == EQ_EXPR || code == NE_EXPR)
8785           && !TREE_SIDE_EFFECTS (arg0)
8786           && integer_zerop (arg1)
8787           && tree_expr_nonzero_p (arg0))
8788         return constant_boolean_node (code==NE_EXPR, type);
8789
8790       t1 = fold_relational_const (code, type, arg0, arg1);
8791       return t1 == NULL_TREE ? t : t1;
8792
8793     case UNORDERED_EXPR:
8794     case ORDERED_EXPR:
8795     case UNLT_EXPR:
8796     case UNLE_EXPR:
8797     case UNGT_EXPR:
8798     case UNGE_EXPR:
8799     case UNEQ_EXPR:
8800     case LTGT_EXPR:
8801       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8802         {
8803           t1 = fold_relational_const (code, type, arg0, arg1);
8804           if (t1 != NULL_TREE)
8805             return t1;
8806         }
8807
8808       /* If the first operand is NaN, the result is constant.  */
8809       if (TREE_CODE (arg0) == REAL_CST
8810           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
8811           && (code != LTGT_EXPR || ! flag_trapping_math))
8812         {
8813           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8814                ? integer_zero_node
8815                : integer_one_node;
8816           return omit_one_operand (type, t1, arg1);
8817         }
8818
8819       /* If the second operand is NaN, the result is constant.  */
8820       if (TREE_CODE (arg1) == REAL_CST
8821           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
8822           && (code != LTGT_EXPR || ! flag_trapping_math))
8823         {
8824           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
8825                ? integer_zero_node
8826                : integer_one_node;
8827           return omit_one_operand (type, t1, arg0);
8828         }
8829
8830       /* Simplify unordered comparison of something with itself.  */
8831       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
8832           && operand_equal_p (arg0, arg1, 0))
8833         return constant_boolean_node (1, type);
8834
8835       if (code == LTGT_EXPR
8836           && !flag_trapping_math
8837           && operand_equal_p (arg0, arg1, 0))
8838         return constant_boolean_node (0, type);
8839
8840       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8841       {
8842         tree targ0 = strip_float_extensions (arg0);
8843         tree targ1 = strip_float_extensions (arg1);
8844         tree newtype = TREE_TYPE (targ0);
8845
8846         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8847           newtype = TREE_TYPE (targ1);
8848
8849         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8850           return fold (build2 (code, type, fold_convert (newtype, targ0),
8851                                fold_convert (newtype, targ1)));
8852       }
8853
8854       return t;
8855
8856     case COND_EXPR:
8857       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
8858          so all simple results must be passed through pedantic_non_lvalue.  */
8859       if (TREE_CODE (arg0) == INTEGER_CST)
8860         {
8861           tem = TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
8862           /* Only optimize constant conditions when the selected branch
8863              has the same type as the COND_EXPR.  This avoids optimizing
8864              away "c ? x : throw", where the throw has a void type.  */
8865           if (! VOID_TYPE_P (TREE_TYPE (tem))
8866               || VOID_TYPE_P (type))
8867             return pedantic_non_lvalue (tem);
8868           return t;
8869         }
8870       if (operand_equal_p (arg1, TREE_OPERAND (t, 2), 0))
8871         return pedantic_omit_one_operand (type, arg1, arg0);
8872
8873       /* If we have A op B ? A : C, we may be able to convert this to a
8874          simpler expression, depending on the operation and the values
8875          of B and C.  Signed zeros prevent all of these transformations,
8876          for reasons given above each one.
8877
8878          Also try swapping the arguments and inverting the conditional.  */
8879       if (COMPARISON_CLASS_P (arg0)
8880           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8881                                              arg1, TREE_OPERAND (arg0, 1))
8882           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
8883         {
8884           tem = fold_cond_expr_with_comparison (type, arg0,
8885                                                 TREE_OPERAND (t, 1),
8886                                                 TREE_OPERAND (t, 2));
8887           if (tem)
8888             return tem;
8889         }
8890
8891       if (COMPARISON_CLASS_P (arg0)
8892           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
8893                                              TREE_OPERAND (t, 2),
8894                                              TREE_OPERAND (arg0, 1))
8895           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (TREE_OPERAND (t, 2)))))
8896         {
8897           tem = invert_truthvalue (arg0);
8898           if (COMPARISON_CLASS_P (tem))
8899             {
8900               tem = fold_cond_expr_with_comparison (type, tem,
8901                                                     TREE_OPERAND (t, 2),
8902                                                     TREE_OPERAND (t, 1));
8903               if (tem)
8904                 return tem;
8905             }
8906         }
8907
8908       /* If the second operand is simpler than the third, swap them
8909          since that produces better jump optimization results.  */
8910       if (tree_swap_operands_p (TREE_OPERAND (t, 1),
8911                                 TREE_OPERAND (t, 2), false))
8912         {
8913           /* See if this can be inverted.  If it can't, possibly because
8914              it was a floating-point inequality comparison, don't do
8915              anything.  */
8916           tem = invert_truthvalue (arg0);
8917
8918           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8919             return fold (build3 (code, type, tem,
8920                                  TREE_OPERAND (t, 2), TREE_OPERAND (t, 1)));
8921         }
8922
8923       /* Convert A ? 1 : 0 to simply A.  */
8924       if (integer_onep (TREE_OPERAND (t, 1))
8925           && integer_zerop (TREE_OPERAND (t, 2))
8926           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
8927              call to fold will try to move the conversion inside
8928              a COND, which will recurse.  In that case, the COND_EXPR
8929              is probably the best choice, so leave it alone.  */
8930           && type == TREE_TYPE (arg0))
8931         return pedantic_non_lvalue (arg0);
8932
8933       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
8934          over COND_EXPR in cases such as floating point comparisons.  */
8935       if (integer_zerop (TREE_OPERAND (t, 1))
8936           && integer_onep (TREE_OPERAND (t, 2))
8937           && truth_value_p (TREE_CODE (arg0)))
8938         return pedantic_non_lvalue (fold_convert (type,
8939                                                   invert_truthvalue (arg0)));
8940
8941       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
8942       if (TREE_CODE (arg0) == LT_EXPR
8943           && integer_zerop (TREE_OPERAND (arg0, 1))
8944           && integer_zerop (TREE_OPERAND (t, 2))
8945           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
8946         return fold_convert (type, fold (build2 (BIT_AND_EXPR,
8947                                                  TREE_TYPE (tem), tem, arg1)));
8948
8949       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
8950          already handled above.  */
8951       if (TREE_CODE (arg0) == BIT_AND_EXPR
8952           && integer_onep (TREE_OPERAND (arg0, 1))
8953           && integer_zerop (TREE_OPERAND (t, 2))
8954           && integer_pow2p (arg1))
8955         {
8956           tree tem = TREE_OPERAND (arg0, 0);
8957           STRIP_NOPS (tem);
8958           if (TREE_CODE (tem) == RSHIFT_EXPR
8959               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
8960               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
8961                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
8962             return fold (build2 (BIT_AND_EXPR, type,
8963                                  TREE_OPERAND (tem, 0), arg1));
8964         }
8965
8966       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
8967          is probably obsolete because the first operand should be a
8968          truth value (that's why we have the two cases above), but let's
8969          leave it in until we can confirm this for all front-ends.  */
8970       if (integer_zerop (TREE_OPERAND (t, 2))
8971           && TREE_CODE (arg0) == NE_EXPR
8972           && integer_zerop (TREE_OPERAND (arg0, 1))
8973           && integer_pow2p (arg1)
8974           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
8975           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
8976                               arg1, OEP_ONLY_CONST))
8977         return pedantic_non_lvalue (fold_convert (type,
8978                                                   TREE_OPERAND (arg0, 0)));
8979
8980       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
8981       if (integer_zerop (TREE_OPERAND (t, 2))
8982           && truth_value_p (TREE_CODE (arg0))
8983           && truth_value_p (TREE_CODE (arg1)))
8984         return fold (build2 (TRUTH_ANDIF_EXPR, type, arg0, arg1));
8985
8986       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
8987       if (integer_onep (TREE_OPERAND (t, 2))
8988           && truth_value_p (TREE_CODE (arg0))
8989           && truth_value_p (TREE_CODE (arg1)))
8990         {
8991           /* Only perform transformation if ARG0 is easily inverted.  */
8992           tem = invert_truthvalue (arg0);
8993           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
8994             return fold (build2 (TRUTH_ORIF_EXPR, type, tem, arg1));
8995         }
8996
8997       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
8998       if (integer_zerop (arg1)
8999           && truth_value_p (TREE_CODE (arg0))
9000           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
9001         {
9002           /* Only perform transformation if ARG0 is easily inverted.  */
9003           tem = invert_truthvalue (arg0);
9004           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
9005             return fold (build2 (TRUTH_ANDIF_EXPR, type, tem,
9006                                  TREE_OPERAND (t, 2)));
9007         }
9008
9009       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
9010       if (integer_onep (arg1)
9011           && truth_value_p (TREE_CODE (arg0))
9012           && truth_value_p (TREE_CODE (TREE_OPERAND (t, 2))))
9013         return fold (build2 (TRUTH_ORIF_EXPR, type, arg0,
9014                              TREE_OPERAND (t, 2)));
9015
9016       return t;
9017
9018     case COMPOUND_EXPR:
9019       /* When pedantic, a compound expression can be neither an lvalue
9020          nor an integer constant expression.  */
9021       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
9022         return t;
9023       /* Don't let (0, 0) be null pointer constant.  */
9024       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
9025                                  : fold_convert (type, arg1);
9026       return pedantic_non_lvalue (tem);
9027
9028     case COMPLEX_EXPR:
9029       if (wins)
9030         return build_complex (type, arg0, arg1);
9031       return t;
9032
9033     case REALPART_EXPR:
9034       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
9035         return t;
9036       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
9037         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
9038                                  TREE_OPERAND (arg0, 1));
9039       else if (TREE_CODE (arg0) == COMPLEX_CST)
9040         return TREE_REALPART (arg0);
9041       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9042         return fold (build2 (TREE_CODE (arg0), type,
9043                              fold (build1 (REALPART_EXPR, type,
9044                                            TREE_OPERAND (arg0, 0))),
9045                              fold (build1 (REALPART_EXPR, type,
9046                                            TREE_OPERAND (arg0, 1)))));
9047       return t;
9048
9049     case IMAGPART_EXPR:
9050       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
9051         return fold_convert (type, integer_zero_node);
9052       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
9053         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
9054                                  TREE_OPERAND (arg0, 0));
9055       else if (TREE_CODE (arg0) == COMPLEX_CST)
9056         return TREE_IMAGPART (arg0);
9057       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9058         return fold (build2 (TREE_CODE (arg0), type,
9059                              fold (build1 (IMAGPART_EXPR, type,
9060                                            TREE_OPERAND (arg0, 0))),
9061                              fold (build1 (IMAGPART_EXPR, type,
9062                                            TREE_OPERAND (arg0, 1)))));
9063       return t;
9064
9065     case CALL_EXPR:
9066       /* Check for a built-in function.  */
9067       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
9068           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0))
9069               == FUNCTION_DECL)
9070           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
9071         {
9072           tree tmp = fold_builtin (t, false);
9073           if (tmp)
9074             return tmp;
9075         }
9076       return t;
9077
9078     default:
9079       return t;
9080     } /* switch (code) */
9081 }
9082
9083 #ifdef ENABLE_FOLD_CHECKING
9084 #undef fold
9085
9086 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
9087 static void fold_check_failed (tree, tree);
9088 void print_fold_checksum (tree);
9089
9090 /* When --enable-checking=fold, compute a digest of expr before
9091    and after actual fold call to see if fold did not accidentally
9092    change original expr.  */
9093
9094 tree
9095 fold (tree expr)
9096 {
9097   tree ret;
9098   struct md5_ctx ctx;
9099   unsigned char checksum_before[16], checksum_after[16];
9100   htab_t ht;
9101
9102   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
9103   md5_init_ctx (&ctx);
9104   fold_checksum_tree (expr, &ctx, ht);
9105   md5_finish_ctx (&ctx, checksum_before);
9106   htab_empty (ht);
9107
9108   ret = fold_1 (expr);
9109
9110   md5_init_ctx (&ctx);
9111   fold_checksum_tree (expr, &ctx, ht);
9112   md5_finish_ctx (&ctx, checksum_after);
9113   htab_delete (ht);
9114
9115   if (memcmp (checksum_before, checksum_after, 16))
9116     fold_check_failed (expr, ret);
9117
9118   return ret;
9119 }
9120
9121 void
9122 print_fold_checksum (tree expr)
9123 {
9124   struct md5_ctx ctx;
9125   unsigned char checksum[16], cnt;
9126   htab_t ht;
9127
9128   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
9129   md5_init_ctx (&ctx);
9130   fold_checksum_tree (expr, &ctx, ht);
9131   md5_finish_ctx (&ctx, checksum);
9132   htab_delete (ht);
9133   for (cnt = 0; cnt < 16; ++cnt)
9134     fprintf (stderr, "%02x", checksum[cnt]);
9135   putc ('\n', stderr);
9136 }
9137
9138 static void
9139 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
9140 {
9141   internal_error ("fold check: original tree changed by fold");
9142 }
9143
9144 static void
9145 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
9146 {
9147   void **slot;
9148   enum tree_code code;
9149   char buf[sizeof (struct tree_decl)];
9150   int i, len;
9151
9152   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
9153                <= sizeof (struct tree_decl))
9154               && sizeof (struct tree_type) <= sizeof (struct tree_decl));
9155   if (expr == NULL)
9156     return;
9157   slot = htab_find_slot (ht, expr, INSERT);
9158   if (*slot != NULL)
9159     return;
9160   *slot = expr;
9161   code = TREE_CODE (expr);
9162   if (TREE_CODE_CLASS (code) == tcc_declaration
9163       && DECL_ASSEMBLER_NAME_SET_P (expr))
9164     {
9165       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
9166       memcpy (buf, expr, tree_size (expr));
9167       expr = (tree) buf;
9168       SET_DECL_ASSEMBLER_NAME (expr, NULL);
9169     }
9170   else if (TREE_CODE_CLASS (code) == tcc_type
9171            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
9172                || TYPE_CACHED_VALUES_P (expr)))
9173     {
9174       /* Allow these fields to be modified.  */
9175       memcpy (buf, expr, tree_size (expr));
9176       expr = (tree) buf;
9177       TYPE_POINTER_TO (expr) = NULL;
9178       TYPE_REFERENCE_TO (expr) = NULL;
9179       TYPE_CACHED_VALUES_P (expr) = 0;
9180       TYPE_CACHED_VALUES (expr) = NULL;
9181     }
9182   md5_process_bytes (expr, tree_size (expr), ctx);
9183   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
9184   if (TREE_CODE_CLASS (code) != tcc_type
9185       && TREE_CODE_CLASS (code) != tcc_declaration)
9186     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
9187   switch (TREE_CODE_CLASS (code))
9188     {
9189     case tcc_constant:
9190       switch (code)
9191         {
9192         case STRING_CST:
9193           md5_process_bytes (TREE_STRING_POINTER (expr),
9194                              TREE_STRING_LENGTH (expr), ctx);
9195           break;
9196         case COMPLEX_CST:
9197           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
9198           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
9199           break;
9200         case VECTOR_CST:
9201           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
9202           break;
9203         default:
9204           break;
9205         }
9206       break;
9207     case tcc_exceptional:
9208       switch (code)
9209         {
9210         case TREE_LIST:
9211           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
9212           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
9213           break;
9214         case TREE_VEC:
9215           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
9216             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
9217           break;
9218         default:
9219           break;
9220         }
9221       break;
9222     case tcc_expression:
9223     case tcc_reference:
9224     case tcc_comparison:
9225     case tcc_unary:
9226     case tcc_binary:
9227     case tcc_statement:
9228       len = first_rtl_op (code);
9229       for (i = 0; i < len; ++i)
9230         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
9231       break;
9232     case tcc_declaration:
9233       fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
9234       fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
9235       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
9236       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
9237       fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
9238       fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
9239       fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
9240       fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
9241       fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
9242       fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
9243       fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
9244       break;
9245     case tcc_type:
9246       if (TREE_CODE (expr) == ENUMERAL_TYPE)
9247         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
9248       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
9249       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
9250       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
9251       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
9252       if (INTEGRAL_TYPE_P (expr)
9253           || SCALAR_FLOAT_TYPE_P (expr))
9254         {
9255           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
9256           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
9257         }
9258       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
9259       if (TREE_CODE (expr) == RECORD_TYPE
9260           || TREE_CODE (expr) == UNION_TYPE
9261           || TREE_CODE (expr) == QUAL_UNION_TYPE)
9262         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
9263       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
9264       break;
9265     default:
9266       break;
9267     }
9268 }
9269
9270 #endif
9271
9272 /* Perform constant folding and related simplification of initializer
9273    expression EXPR.  This behaves identically to "fold" but ignores
9274    potential run-time traps and exceptions that fold must preserve.  */
9275
9276 tree
9277 fold_initializer (tree expr)
9278 {
9279   int saved_signaling_nans = flag_signaling_nans;
9280   int saved_trapping_math = flag_trapping_math;
9281   int saved_trapv = flag_trapv;
9282   tree result;
9283
9284   flag_signaling_nans = 0;
9285   flag_trapping_math = 0;
9286   flag_trapv = 0;
9287
9288   result = fold (expr);
9289
9290   flag_signaling_nans = saved_signaling_nans;
9291   flag_trapping_math = saved_trapping_math;
9292   flag_trapv = saved_trapv;
9293
9294   return result;
9295 }
9296
9297 /* Determine if first argument is a multiple of second argument.  Return 0 if
9298    it is not, or we cannot easily determined it to be.
9299
9300    An example of the sort of thing we care about (at this point; this routine
9301    could surely be made more general, and expanded to do what the *_DIV_EXPR's
9302    fold cases do now) is discovering that
9303
9304      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9305
9306    is a multiple of
9307
9308      SAVE_EXPR (J * 8)
9309
9310    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
9311
9312    This code also handles discovering that
9313
9314      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
9315
9316    is a multiple of 8 so we don't have to worry about dealing with a
9317    possible remainder.
9318
9319    Note that we *look* inside a SAVE_EXPR only to determine how it was
9320    calculated; it is not safe for fold to do much of anything else with the
9321    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
9322    at run time.  For example, the latter example above *cannot* be implemented
9323    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
9324    evaluation time of the original SAVE_EXPR is not necessarily the same at
9325    the time the new expression is evaluated.  The only optimization of this
9326    sort that would be valid is changing
9327
9328      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
9329
9330    divided by 8 to
9331
9332      SAVE_EXPR (I) * SAVE_EXPR (J)
9333
9334    (where the same SAVE_EXPR (J) is used in the original and the
9335    transformed version).  */
9336
9337 static int
9338 multiple_of_p (tree type, tree top, tree bottom)
9339 {
9340   if (operand_equal_p (top, bottom, 0))
9341     return 1;
9342
9343   if (TREE_CODE (type) != INTEGER_TYPE)
9344     return 0;
9345
9346   switch (TREE_CODE (top))
9347     {
9348     case MULT_EXPR:
9349       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9350               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9351
9352     case PLUS_EXPR:
9353     case MINUS_EXPR:
9354       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
9355               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
9356
9357     case LSHIFT_EXPR:
9358       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
9359         {
9360           tree op1, t1;
9361
9362           op1 = TREE_OPERAND (top, 1);
9363           /* const_binop may not detect overflow correctly,
9364              so check for it explicitly here.  */
9365           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
9366               > TREE_INT_CST_LOW (op1)
9367               && TREE_INT_CST_HIGH (op1) == 0
9368               && 0 != (t1 = fold_convert (type,
9369                                           const_binop (LSHIFT_EXPR,
9370                                                        size_one_node,
9371                                                        op1, 0)))
9372               && ! TREE_OVERFLOW (t1))
9373             return multiple_of_p (type, t1, bottom);
9374         }
9375       return 0;
9376
9377     case NOP_EXPR:
9378       /* Can't handle conversions from non-integral or wider integral type.  */
9379       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
9380           || (TYPE_PRECISION (type)
9381               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
9382         return 0;
9383
9384       /* .. fall through ...  */
9385
9386     case SAVE_EXPR:
9387       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
9388
9389     case INTEGER_CST:
9390       if (TREE_CODE (bottom) != INTEGER_CST
9391           || (TYPE_UNSIGNED (type)
9392               && (tree_int_cst_sgn (top) < 0
9393                   || tree_int_cst_sgn (bottom) < 0)))
9394         return 0;
9395       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
9396                                          top, bottom, 0));
9397
9398     default:
9399       return 0;
9400     }
9401 }
9402
9403 /* Return true if `t' is known to be non-negative.  */
9404
9405 int
9406 tree_expr_nonnegative_p (tree t)
9407 {
9408   switch (TREE_CODE (t))
9409     {
9410     case ABS_EXPR:
9411       return 1;
9412
9413     case INTEGER_CST:
9414       return tree_int_cst_sgn (t) >= 0;
9415
9416     case REAL_CST:
9417       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
9418
9419     case PLUS_EXPR:
9420       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9421         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9422                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9423
9424       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
9425          both unsigned and at least 2 bits shorter than the result.  */
9426       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9427           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9428           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9429         {
9430           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9431           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9432           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9433               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9434             {
9435               unsigned int prec = MAX (TYPE_PRECISION (inner1),
9436                                        TYPE_PRECISION (inner2)) + 1;
9437               return prec < TYPE_PRECISION (TREE_TYPE (t));
9438             }
9439         }
9440       break;
9441
9442     case MULT_EXPR:
9443       if (FLOAT_TYPE_P (TREE_TYPE (t)))
9444         {
9445           /* x * x for floating point x is always non-negative.  */
9446           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
9447             return 1;
9448           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9449                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9450         }
9451
9452       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
9453          both unsigned and their total bits is shorter than the result.  */
9454       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
9455           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
9456           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
9457         {
9458           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
9459           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
9460           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
9461               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
9462             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
9463                    < TYPE_PRECISION (TREE_TYPE (t));
9464         }
9465       return 0;
9466
9467     case TRUNC_DIV_EXPR:
9468     case CEIL_DIV_EXPR:
9469     case FLOOR_DIV_EXPR:
9470     case ROUND_DIV_EXPR:
9471       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9472              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9473
9474     case TRUNC_MOD_EXPR:
9475     case CEIL_MOD_EXPR:
9476     case FLOOR_MOD_EXPR:
9477     case ROUND_MOD_EXPR:
9478       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9479
9480     case RDIV_EXPR:
9481       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9482              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9483
9484     case BIT_AND_EXPR:
9485       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9486              || tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9487     case BIT_IOR_EXPR:
9488     case BIT_XOR_EXPR:
9489       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9490              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9491
9492     case NOP_EXPR:
9493       {
9494         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9495         tree outer_type = TREE_TYPE (t);
9496
9497         if (TREE_CODE (outer_type) == REAL_TYPE)
9498           {
9499             if (TREE_CODE (inner_type) == REAL_TYPE)
9500               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9501             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9502               {
9503                 if (TYPE_UNSIGNED (inner_type))
9504                   return 1;
9505                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9506               }
9507           }
9508         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
9509           {
9510             if (TREE_CODE (inner_type) == REAL_TYPE)
9511               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
9512             if (TREE_CODE (inner_type) == INTEGER_TYPE)
9513               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
9514                       && TYPE_UNSIGNED (inner_type);
9515           }
9516       }
9517       break;
9518
9519     case COND_EXPR:
9520       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
9521         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
9522     case COMPOUND_EXPR:
9523       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9524     case MIN_EXPR:
9525       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9526         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9527     case MAX_EXPR:
9528       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9529         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9530     case MODIFY_EXPR:
9531       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9532     case BIND_EXPR:
9533       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
9534     case SAVE_EXPR:
9535       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9536     case NON_LVALUE_EXPR:
9537       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9538     case FLOAT_EXPR:
9539       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9540
9541     case TARGET_EXPR:
9542       {
9543         tree temp = TARGET_EXPR_SLOT (t);
9544         t = TARGET_EXPR_INITIAL (t);
9545
9546         /* If the initializer is non-void, then it's a normal expression
9547            that will be assigned to the slot.  */
9548         if (!VOID_TYPE_P (t))
9549           return tree_expr_nonnegative_p (t);
9550
9551         /* Otherwise, the initializer sets the slot in some way.  One common
9552            way is an assignment statement at the end of the initializer.  */
9553         while (1)
9554           {
9555             if (TREE_CODE (t) == BIND_EXPR)
9556               t = expr_last (BIND_EXPR_BODY (t));
9557             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
9558                      || TREE_CODE (t) == TRY_CATCH_EXPR)
9559               t = expr_last (TREE_OPERAND (t, 0));
9560             else if (TREE_CODE (t) == STATEMENT_LIST)
9561               t = expr_last (t);
9562             else
9563               break;
9564           }
9565         if (TREE_CODE (t) == MODIFY_EXPR
9566             && TREE_OPERAND (t, 0) == temp)
9567           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
9568
9569         return 0;
9570       }
9571
9572     case CALL_EXPR:
9573       {
9574         tree fndecl = get_callee_fndecl (t);
9575         tree arglist = TREE_OPERAND (t, 1);
9576         if (fndecl
9577             && DECL_BUILT_IN (fndecl)
9578             && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
9579           switch (DECL_FUNCTION_CODE (fndecl))
9580             {
9581 #define CASE_BUILTIN_F(BUILT_IN_FN) \
9582   case BUILT_IN_FN: case BUILT_IN_FN##F: case BUILT_IN_FN##L:
9583 #define CASE_BUILTIN_I(BUILT_IN_FN) \
9584   case BUILT_IN_FN: case BUILT_IN_FN##L: case BUILT_IN_FN##LL:
9585
9586             CASE_BUILTIN_F (BUILT_IN_ACOS)
9587             CASE_BUILTIN_F (BUILT_IN_ACOSH)
9588             CASE_BUILTIN_F (BUILT_IN_CABS)
9589             CASE_BUILTIN_F (BUILT_IN_COSH)
9590             CASE_BUILTIN_F (BUILT_IN_ERFC)
9591             CASE_BUILTIN_F (BUILT_IN_EXP)
9592             CASE_BUILTIN_F (BUILT_IN_EXP10)
9593             CASE_BUILTIN_F (BUILT_IN_EXP2)
9594             CASE_BUILTIN_F (BUILT_IN_FABS)
9595             CASE_BUILTIN_F (BUILT_IN_FDIM)
9596             CASE_BUILTIN_F (BUILT_IN_FREXP)
9597             CASE_BUILTIN_F (BUILT_IN_HYPOT)
9598             CASE_BUILTIN_F (BUILT_IN_POW10)
9599             CASE_BUILTIN_I (BUILT_IN_FFS)
9600             CASE_BUILTIN_I (BUILT_IN_PARITY)
9601             CASE_BUILTIN_I (BUILT_IN_POPCOUNT)
9602               /* Always true.  */
9603               return 1;
9604
9605             CASE_BUILTIN_F (BUILT_IN_SQRT)
9606               /* sqrt(-0.0) is -0.0.  */
9607               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
9608                 return 1;
9609               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9610
9611             CASE_BUILTIN_F (BUILT_IN_ASINH)
9612             CASE_BUILTIN_F (BUILT_IN_ATAN)
9613             CASE_BUILTIN_F (BUILT_IN_ATANH)
9614             CASE_BUILTIN_F (BUILT_IN_CBRT)
9615             CASE_BUILTIN_F (BUILT_IN_CEIL)
9616             CASE_BUILTIN_F (BUILT_IN_ERF)
9617             CASE_BUILTIN_F (BUILT_IN_EXPM1)
9618             CASE_BUILTIN_F (BUILT_IN_FLOOR)
9619             CASE_BUILTIN_F (BUILT_IN_FMOD)
9620             CASE_BUILTIN_F (BUILT_IN_LDEXP)
9621             CASE_BUILTIN_F (BUILT_IN_LLRINT)
9622             CASE_BUILTIN_F (BUILT_IN_LLROUND)
9623             CASE_BUILTIN_F (BUILT_IN_LRINT)
9624             CASE_BUILTIN_F (BUILT_IN_LROUND)
9625             CASE_BUILTIN_F (BUILT_IN_MODF)
9626             CASE_BUILTIN_F (BUILT_IN_NEARBYINT)
9627             CASE_BUILTIN_F (BUILT_IN_POW)
9628             CASE_BUILTIN_F (BUILT_IN_RINT)
9629             CASE_BUILTIN_F (BUILT_IN_ROUND)
9630             CASE_BUILTIN_F (BUILT_IN_SIGNBIT)
9631             CASE_BUILTIN_F (BUILT_IN_SINH)
9632             CASE_BUILTIN_F (BUILT_IN_TANH)
9633             CASE_BUILTIN_F (BUILT_IN_TRUNC)
9634               /* True if the 1st argument is nonnegative.  */
9635               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
9636
9637             CASE_BUILTIN_F (BUILT_IN_FMAX)
9638               /* True if the 1st OR 2nd arguments are nonnegative.  */
9639               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9640                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9641
9642             CASE_BUILTIN_F (BUILT_IN_FMIN)
9643               /* True if the 1st AND 2nd arguments are nonnegative.  */
9644               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
9645                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9646
9647             CASE_BUILTIN_F (BUILT_IN_COPYSIGN)
9648               /* True if the 2nd argument is nonnegative.  */
9649               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
9650
9651             default:
9652               break;
9653 #undef CASE_BUILTIN_F
9654 #undef CASE_BUILTIN_I
9655             }
9656       }
9657
9658       /* ... fall through ...  */
9659
9660     default:
9661       if (truth_value_p (TREE_CODE (t)))
9662         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
9663         return 1;
9664     }
9665
9666   /* We don't know sign of `t', so be conservative and return false.  */
9667   return 0;
9668 }
9669
9670 /* Return true when T is an address and is known to be nonzero.
9671    For floating point we further ensure that T is not denormal.
9672    Similar logic is present in nonzero_address in rtlanal.h.  */
9673
9674 static bool
9675 tree_expr_nonzero_p (tree t)
9676 {
9677   tree type = TREE_TYPE (t);
9678
9679   /* Doing something useful for floating point would need more work.  */
9680   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9681     return false;
9682
9683   switch (TREE_CODE (t))
9684     {
9685     case ABS_EXPR:
9686       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9687         return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9688
9689     case INTEGER_CST:
9690       /* We used to test for !integer_zerop here.  This does not work correctly
9691          if TREE_CONSTANT_OVERFLOW (t).  */
9692       return (TREE_INT_CST_LOW (t) != 0
9693               || TREE_INT_CST_HIGH (t) != 0);
9694
9695     case PLUS_EXPR:
9696       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9697         {
9698           /* With the presence of negative values it is hard
9699              to say something.  */
9700           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
9701               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9702             return false;
9703           /* One of operands must be positive and the other non-negative.  */
9704           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9705                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9706         }
9707       break;
9708
9709     case MULT_EXPR:
9710       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
9711         {
9712           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9713                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9714         }
9715       break;
9716
9717     case NOP_EXPR:
9718       {
9719         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
9720         tree outer_type = TREE_TYPE (t);
9721
9722         return (TYPE_PRECISION (inner_type) >= TYPE_PRECISION (outer_type)
9723                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
9724       }
9725       break;
9726
9727    case ADDR_EXPR:
9728       {
9729         tree base = get_base_address (TREE_OPERAND (t, 0));
9730
9731         if (!base)
9732           return false;
9733
9734         /* Weak declarations may link to NULL.  */
9735         if (DECL_P (base))
9736           return !DECL_WEAK (base);
9737
9738         /* Constants are never weak.  */
9739         if (CONSTANT_CLASS_P (base))
9740           return true;
9741
9742         return false;
9743       }
9744
9745     case COND_EXPR:
9746       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9747               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
9748
9749     case MIN_EXPR:
9750       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
9751               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
9752
9753     case MAX_EXPR:
9754       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
9755         {
9756           /* When both operands are nonzero, then MAX must be too.  */
9757           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
9758             return true;
9759
9760           /* MAX where operand 0 is positive is positive.  */
9761           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
9762         }
9763       /* MAX where operand 1 is positive is positive.  */
9764       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9765                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
9766         return true;
9767       break;
9768
9769     case COMPOUND_EXPR:
9770     case MODIFY_EXPR:
9771     case BIND_EXPR:
9772       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
9773
9774     case SAVE_EXPR:
9775     case NON_LVALUE_EXPR:
9776       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9777
9778     case BIT_IOR_EXPR:
9779       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
9780              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
9781
9782     default:
9783       break;
9784     }
9785   return false;
9786 }
9787
9788 /* See if we are applying CODE, a relational to the highest or lowest
9789    possible integer of TYPE.  If so, then the result is a compile
9790    time constant.  */
9791
9792 static tree
9793 fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
9794                        tree *op1_p)
9795 {
9796   tree op0 = *op0_p;
9797   tree op1 = *op1_p;
9798   enum tree_code code = *code_p;
9799   int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (op1)));
9800
9801   if (TREE_CODE (op1) == INTEGER_CST
9802       && ! TREE_CONSTANT_OVERFLOW (op1)
9803       && width <= HOST_BITS_PER_WIDE_INT
9804       && (INTEGRAL_TYPE_P (TREE_TYPE (op1))
9805           || POINTER_TYPE_P (TREE_TYPE (op1))))
9806     {
9807       unsigned HOST_WIDE_INT signed_max;
9808       unsigned HOST_WIDE_INT max, min;
9809
9810       signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
9811
9812       if (TYPE_UNSIGNED (TREE_TYPE (op1)))
9813         {
9814           max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9815           min = 0;
9816         }
9817       else
9818         {
9819           max = signed_max;
9820           min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9821         }
9822
9823       if (TREE_INT_CST_HIGH (op1) == 0
9824           && TREE_INT_CST_LOW (op1) == max)
9825         switch (code)
9826           {
9827           case GT_EXPR:
9828             return omit_one_operand (type, integer_zero_node, op0);
9829
9830           case GE_EXPR:
9831             *code_p = EQ_EXPR;
9832             break;
9833           case LE_EXPR:
9834             return omit_one_operand (type, integer_one_node, op0);
9835
9836           case LT_EXPR:
9837             *code_p = NE_EXPR;
9838             break;
9839
9840           /* The GE_EXPR and LT_EXPR cases above are not normally
9841              reached because of  previous transformations.  */
9842
9843           default:
9844             break;
9845           }
9846       else if (TREE_INT_CST_HIGH (op1) == 0
9847                && TREE_INT_CST_LOW (op1) == max - 1)
9848         switch (code)
9849           {
9850           case GT_EXPR:
9851             *code_p = EQ_EXPR;
9852             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9853             break;
9854           case LE_EXPR:
9855             *code_p = NE_EXPR;
9856             *op1_p = const_binop (PLUS_EXPR, op1, integer_one_node, 0);
9857             break;
9858           default:
9859             break;
9860           }
9861       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9862                && TREE_INT_CST_LOW (op1) == min)
9863        switch (code)
9864           {
9865           case LT_EXPR:
9866             return omit_one_operand (type, integer_zero_node, op0);
9867
9868           case LE_EXPR:
9869             *code_p = EQ_EXPR;
9870             break;
9871
9872           case GE_EXPR:
9873             return omit_one_operand (type, integer_one_node, op0);
9874
9875           case GT_EXPR:
9876             *code_p = NE_EXPR;
9877             break;
9878
9879           default:
9880             break;
9881           }
9882       else if (TREE_INT_CST_HIGH (op1) == (min ? -1 : 0)
9883                && TREE_INT_CST_LOW (op1) == min + 1)
9884         switch (code)
9885           {
9886           case GE_EXPR:
9887             *code_p = NE_EXPR;
9888             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9889             break;
9890           case LT_EXPR:
9891             *code_p = EQ_EXPR;
9892             *op1_p = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
9893             break;
9894           default:
9895             break;
9896           }
9897
9898       else if (TREE_INT_CST_HIGH (op1) == 0
9899                && TREE_INT_CST_LOW (op1) == signed_max
9900                && TYPE_UNSIGNED (TREE_TYPE (op1))
9901                /* signed_type does not work on pointer types.  */
9902                && INTEGRAL_TYPE_P (TREE_TYPE (op1)))
9903         {
9904           /* The following case also applies to X < signed_max+1
9905              and X >= signed_max+1 because previous transformations.  */
9906           if (code == LE_EXPR || code == GT_EXPR)
9907             {
9908               tree st0, st1, exp, retval;
9909               st0 = lang_hooks.types.signed_type (TREE_TYPE (op0));
9910               st1 = lang_hooks.types.signed_type (TREE_TYPE (op1));
9911
9912               exp = build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9913                             type,
9914                             fold_convert (st0, op0),
9915                             fold_convert (st1, integer_zero_node));
9916
9917               retval
9918                 = nondestructive_fold_binary_to_constant (TREE_CODE (exp),
9919                                                           TREE_TYPE (exp),
9920                                                           TREE_OPERAND (exp, 0),
9921                                                           TREE_OPERAND (exp, 1));
9922
9923               /* If we are in gimple form, then returning EXP would create
9924                  non-gimple expressions.  Clearing it is safe and insures
9925                  we do not allow a non-gimple expression to escape.  */
9926               if (in_gimple_form)
9927                 exp = NULL;
9928
9929               return (retval ? retval : exp);
9930             }
9931         }
9932     }
9933
9934   return NULL_TREE;
9935 }
9936
9937
9938 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
9939    attempt to fold the expression to a constant without modifying TYPE,
9940    OP0 or OP1.
9941
9942    If the expression could be simplified to a constant, then return
9943    the constant.  If the expression would not be simplified to a
9944    constant, then return NULL_TREE.
9945
9946    Note this is primarily designed to be called after gimplification
9947    of the tree structures and when at least one operand is a constant.
9948    As a result of those simplifying assumptions this routine is far
9949    simpler than the generic fold routine.  */
9950
9951 tree
9952 nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
9953                                         tree op0, tree op1)
9954 {
9955   int wins = 1;
9956   tree subop0;
9957   tree subop1;
9958   tree tem;
9959
9960   /* If this is a commutative operation, and ARG0 is a constant, move it
9961      to ARG1 to reduce the number of tests below.  */
9962   if (commutative_tree_code (code)
9963       && (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST))
9964     {
9965       tem = op0;
9966       op0 = op1;
9967       op1 = tem;
9968     }
9969
9970   /* If either operand is a complex type, extract its real component.  */
9971   if (TREE_CODE (op0) == COMPLEX_CST)
9972     subop0 = TREE_REALPART (op0);
9973   else
9974     subop0 = op0;
9975
9976   if (TREE_CODE (op1) == COMPLEX_CST)
9977     subop1 = TREE_REALPART (op1);
9978   else
9979     subop1 = op1;
9980
9981   /* Note if either argument is not a real or integer constant.
9982      With a few exceptions, simplification is limited to cases
9983      where both arguments are constants.  */
9984   if ((TREE_CODE (subop0) != INTEGER_CST
9985        && TREE_CODE (subop0) != REAL_CST)
9986       || (TREE_CODE (subop1) != INTEGER_CST
9987           && TREE_CODE (subop1) != REAL_CST))
9988     wins = 0;
9989
9990   switch (code)
9991     {
9992     case PLUS_EXPR:
9993       /* (plus (address) (const_int)) is a constant.  */
9994       if (TREE_CODE (op0) == PLUS_EXPR
9995           && TREE_CODE (op1) == INTEGER_CST
9996           && (TREE_CODE (TREE_OPERAND (op0, 0)) == ADDR_EXPR
9997               || (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
9998                   && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (op0, 0), 0))
9999                       == ADDR_EXPR)))
10000           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
10001         {
10002           return build2 (PLUS_EXPR, type, TREE_OPERAND (op0, 0),
10003                          const_binop (PLUS_EXPR, op1,
10004                                       TREE_OPERAND (op0, 1), 0));
10005         }
10006     case BIT_XOR_EXPR:
10007
10008     binary:
10009       if (!wins)
10010         return NULL_TREE;
10011
10012       /* Both arguments are constants.  Simplify.  */
10013       tem = const_binop (code, op0, op1, 0);
10014       if (tem != NULL_TREE)
10015         {
10016           /* The return value should always have the same type as
10017              the original expression.  */
10018           if (TREE_TYPE (tem) != type)
10019             tem = fold_convert (type, tem);
10020
10021           return tem;
10022         }
10023       return NULL_TREE;
10024
10025     case MINUS_EXPR:
10026       /* Fold &x - &x.  This can happen from &x.foo - &x.
10027          This is unsafe for certain floats even in non-IEEE formats.
10028          In IEEE, it is unsafe because it does wrong for NaNs.
10029          Also note that operand_equal_p is always false if an
10030          operand is volatile.  */
10031       if (! FLOAT_TYPE_P (type) && operand_equal_p (op0, op1, 0))
10032         return fold_convert (type, integer_zero_node);
10033
10034       goto binary;
10035
10036     case MULT_EXPR:
10037     case BIT_AND_EXPR:
10038       /* Special case multiplication or bitwise AND where one argument
10039          is zero.  */
10040       if (! FLOAT_TYPE_P (type) && integer_zerop (op1))
10041         return omit_one_operand (type, op1, op0);
10042       else
10043         if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (op0)))
10044             && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op0)))
10045             && real_zerop (op1))
10046           return omit_one_operand (type, op1, op0);
10047
10048       goto binary;
10049
10050     case BIT_IOR_EXPR:
10051       /* Special case when we know the result will be all ones.  */
10052       if (integer_all_onesp (op1))
10053         return omit_one_operand (type, op1, op0);
10054
10055       goto binary;
10056
10057     case TRUNC_DIV_EXPR:
10058     case ROUND_DIV_EXPR:
10059     case FLOOR_DIV_EXPR:
10060     case CEIL_DIV_EXPR:
10061     case EXACT_DIV_EXPR:
10062     case TRUNC_MOD_EXPR:
10063     case ROUND_MOD_EXPR:
10064     case FLOOR_MOD_EXPR:
10065     case CEIL_MOD_EXPR:
10066     case RDIV_EXPR:
10067       /* Division by zero is undefined.  */
10068       if (integer_zerop (op1))
10069         return NULL_TREE;
10070
10071       if (TREE_CODE (op1) == REAL_CST
10072           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (op1)))
10073           && real_zerop (op1))
10074         return NULL_TREE;
10075
10076       goto binary;
10077
10078     case MIN_EXPR:
10079       if (INTEGRAL_TYPE_P (type)
10080           && operand_equal_p (op1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
10081         return omit_one_operand (type, op1, op0);
10082
10083       goto binary;
10084
10085     case MAX_EXPR:
10086       if (INTEGRAL_TYPE_P (type)
10087           && TYPE_MAX_VALUE (type)
10088           && operand_equal_p (op1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
10089         return omit_one_operand (type, op1, op0);
10090
10091       goto binary;
10092
10093     case RSHIFT_EXPR:
10094       /* Optimize -1 >> x for arithmetic right shifts.  */
10095       if (integer_all_onesp (op0) && ! TYPE_UNSIGNED (type))
10096         return omit_one_operand (type, op0, op1);
10097       /* ... fall through ...  */
10098
10099     case LSHIFT_EXPR:
10100       if (integer_zerop (op0))
10101         return omit_one_operand (type, op0, op1);
10102
10103       /* Since negative shift count is not well-defined, don't
10104          try to compute it in the compiler.  */
10105       if (TREE_CODE (op1) == INTEGER_CST && tree_int_cst_sgn (op1) < 0)
10106         return NULL_TREE;
10107
10108       goto binary;
10109
10110     case LROTATE_EXPR:
10111     case RROTATE_EXPR:
10112       /* -1 rotated either direction by any amount is still -1.  */
10113       if (integer_all_onesp (op0))
10114         return omit_one_operand (type, op0, op1);
10115
10116       /* 0 rotated either direction by any amount is still zero.  */
10117       if (integer_zerop (op0))
10118         return omit_one_operand (type, op0, op1);
10119
10120       goto binary;
10121
10122     case COMPLEX_EXPR:
10123       if (wins)
10124         return build_complex (type, op0, op1);
10125       return NULL_TREE;
10126
10127     case LT_EXPR:
10128     case LE_EXPR:
10129     case GT_EXPR:
10130     case GE_EXPR:
10131     case EQ_EXPR:
10132     case NE_EXPR:
10133       /* If one arg is a real or integer constant, put it last.  */
10134       if ((TREE_CODE (op0) == INTEGER_CST
10135            && TREE_CODE (op1) != INTEGER_CST)
10136           || (TREE_CODE (op0) == REAL_CST
10137               && TREE_CODE (op0) != REAL_CST))
10138         {
10139           tree temp;
10140
10141           temp = op0;
10142           op0 = op1;
10143           op1 = temp;
10144           code = swap_tree_comparison (code);
10145         }
10146
10147       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
10148          This transformation affects the cases which are handled in later
10149          optimizations involving comparisons with non-negative constants.  */
10150       if (TREE_CODE (op1) == INTEGER_CST
10151           && TREE_CODE (op0) != INTEGER_CST
10152           && tree_int_cst_sgn (op1) > 0)
10153         {
10154           switch (code)
10155             {
10156             case GE_EXPR:
10157               code = GT_EXPR;
10158               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10159               break;
10160
10161             case LT_EXPR:
10162               code = LE_EXPR;
10163               op1 = const_binop (MINUS_EXPR, op1, integer_one_node, 0);
10164               break;
10165
10166             default:
10167               break;
10168             }
10169         }
10170
10171       tem = fold_relational_hi_lo (&code, type, &op0, &op1);
10172       if (tem)
10173         return tem;
10174
10175       /* Fall through.  */
10176
10177     case ORDERED_EXPR:
10178     case UNORDERED_EXPR:
10179     case UNLT_EXPR:
10180     case UNLE_EXPR:
10181     case UNGT_EXPR:
10182     case UNGE_EXPR:
10183     case UNEQ_EXPR:
10184     case LTGT_EXPR:
10185       if (!wins)
10186         return NULL_TREE;
10187
10188       return fold_relational_const (code, type, op0, op1);
10189
10190     case RANGE_EXPR:
10191       /* This could probably be handled.  */
10192       return NULL_TREE;
10193
10194     case TRUTH_AND_EXPR:
10195       /* If second arg is constant zero, result is zero, but first arg
10196          must be evaluated.  */
10197       if (integer_zerop (op1))
10198         return omit_one_operand (type, op1, op0);
10199       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10200          case will be handled here.  */
10201       if (integer_zerop (op0))
10202         return omit_one_operand (type, op0, op1);
10203       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10204         return constant_boolean_node (true, type);
10205       return NULL_TREE;
10206
10207     case TRUTH_OR_EXPR:
10208       /* If second arg is constant true, result is true, but we must
10209          evaluate first arg.  */
10210       if (TREE_CODE (op1) == INTEGER_CST && ! integer_zerop (op1))
10211         return omit_one_operand (type, op1, op0);
10212       /* Likewise for first arg, but note this only occurs here for
10213          TRUTH_OR_EXPR.  */
10214       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
10215         return omit_one_operand (type, op0, op1);
10216       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10217         return constant_boolean_node (false, type);
10218       return NULL_TREE;
10219
10220     case TRUTH_XOR_EXPR:
10221       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10222         {
10223           int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
10224           return constant_boolean_node (x, type);
10225         }
10226       return NULL_TREE;
10227
10228     default:
10229       return NULL_TREE;
10230     }
10231 }
10232
10233 /* Given the components of a unary expression CODE, TYPE and OP0,
10234    attempt to fold the expression to a constant without modifying
10235    TYPE or OP0.
10236
10237    If the expression could be simplified to a constant, then return
10238    the constant.  If the expression would not be simplified to a
10239    constant, then return NULL_TREE.
10240
10241    Note this is primarily designed to be called after gimplification
10242    of the tree structures and when op0 is a constant.  As a result
10243    of those simplifying assumptions this routine is far simpler than
10244    the generic fold routine.  */
10245
10246 tree
10247 nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
10248                                        tree op0)
10249 {
10250   /* Make sure we have a suitable constant argument.  */
10251   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
10252     {
10253       tree subop;
10254
10255       if (TREE_CODE (op0) == COMPLEX_CST)
10256         subop = TREE_REALPART (op0);
10257       else
10258         subop = op0;
10259
10260       if (TREE_CODE (subop) != INTEGER_CST && TREE_CODE (subop) != REAL_CST)
10261         return NULL_TREE;
10262     }
10263
10264   switch (code)
10265     {
10266     case NOP_EXPR:
10267     case FLOAT_EXPR:
10268     case CONVERT_EXPR:
10269     case FIX_TRUNC_EXPR:
10270     case FIX_FLOOR_EXPR:
10271     case FIX_CEIL_EXPR:
10272       return fold_convert_const (code, type, op0);
10273
10274     case NEGATE_EXPR:
10275       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10276         return fold_negate_const (op0, type);
10277       else
10278         return NULL_TREE;
10279
10280     case ABS_EXPR:
10281       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
10282         return fold_abs_const (op0, type);
10283       else
10284         return NULL_TREE;
10285
10286     case BIT_NOT_EXPR:
10287       if (TREE_CODE (op0) == INTEGER_CST)
10288         return fold_not_const (op0, type);
10289       else
10290         return NULL_TREE;
10291
10292     case REALPART_EXPR:
10293       if (TREE_CODE (op0) == COMPLEX_CST)
10294         return TREE_REALPART (op0);
10295       else
10296         return NULL_TREE;
10297
10298     case IMAGPART_EXPR:
10299       if (TREE_CODE (op0) == COMPLEX_CST)
10300         return TREE_IMAGPART (op0);
10301       else
10302         return NULL_TREE;
10303
10304     case CONJ_EXPR:
10305       if (TREE_CODE (op0) == COMPLEX_CST
10306           && TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
10307         return build_complex (type, TREE_REALPART (op0),
10308                               negate_expr (TREE_IMAGPART (op0)));
10309       return NULL_TREE;
10310
10311     default:
10312       return NULL_TREE;
10313     }
10314 }
10315
10316 /* If EXP represents referencing an element in a constant string
10317    (either via pointer arithmetic or array indexing), return the
10318    tree representing the value accessed, otherwise return NULL.  */
10319
10320 tree
10321 fold_read_from_constant_string (tree exp)
10322 {
10323   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
10324     {
10325       tree exp1 = TREE_OPERAND (exp, 0);
10326       tree index;
10327       tree string;
10328
10329       if (TREE_CODE (exp) == INDIRECT_REF)
10330         string = string_constant (exp1, &index);
10331       else
10332         {
10333           tree low_bound = array_ref_low_bound (exp);
10334           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
10335
10336           /* Optimize the special-case of a zero lower bound.
10337
10338              We convert the low_bound to sizetype to avoid some problems
10339              with constant folding.  (E.g. suppose the lower bound is 1,
10340              and its mode is QI.  Without the conversion,l (ARRAY
10341              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
10342              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
10343           if (! integer_zerop (low_bound))
10344             index = size_diffop (index, fold_convert (sizetype, low_bound));
10345
10346           string = exp1;
10347         }
10348
10349       if (string
10350           && TREE_TYPE (exp) == TREE_TYPE (TREE_TYPE (string))
10351           && TREE_CODE (string) == STRING_CST
10352           && TREE_CODE (index) == INTEGER_CST
10353           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
10354           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
10355               == MODE_INT)
10356           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
10357         return fold_convert (TREE_TYPE (exp),
10358                              build_int_cst (NULL_TREE,
10359                                             (TREE_STRING_POINTER (string)
10360                                              [TREE_INT_CST_LOW (index)])));
10361     }
10362   return NULL;
10363 }
10364
10365 /* Return the tree for neg (ARG0) when ARG0 is known to be either
10366    an integer constant or real constant.
10367
10368    TYPE is the type of the result.  */
10369
10370 static tree
10371 fold_negate_const (tree arg0, tree type)
10372 {
10373   tree t = NULL_TREE;
10374
10375   switch (TREE_CODE (arg0))
10376     {
10377     case INTEGER_CST:
10378       {
10379         unsigned HOST_WIDE_INT low;
10380         HOST_WIDE_INT high;
10381         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10382                                    TREE_INT_CST_HIGH (arg0),
10383                                    &low, &high);
10384         t = build_int_cst_wide (type, low, high);
10385         t = force_fit_type (t, 1,
10386                             (overflow | TREE_OVERFLOW (arg0))
10387                             && !TYPE_UNSIGNED (type),
10388                             TREE_CONSTANT_OVERFLOW (arg0));
10389         break;
10390       }
10391
10392     case REAL_CST:
10393       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10394       break;
10395
10396     default:
10397       gcc_unreachable ();
10398     }
10399
10400   return t;
10401 }
10402
10403 /* Return the tree for abs (ARG0) when ARG0 is known to be either
10404    an integer constant or real constant.
10405
10406    TYPE is the type of the result.  */
10407
10408 tree
10409 fold_abs_const (tree arg0, tree type)
10410 {
10411   tree t = NULL_TREE;
10412
10413   switch (TREE_CODE (arg0))
10414     {
10415     case INTEGER_CST:
10416       /* If the value is unsigned, then the absolute value is
10417          the same as the ordinary value.  */
10418       if (TYPE_UNSIGNED (type))
10419         t = arg0;
10420       /* Similarly, if the value is non-negative.  */
10421       else if (INT_CST_LT (integer_minus_one_node, arg0))
10422         t = arg0;
10423       /* If the value is negative, then the absolute value is
10424          its negation.  */
10425       else
10426         {
10427           unsigned HOST_WIDE_INT low;
10428           HOST_WIDE_INT high;
10429           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
10430                                      TREE_INT_CST_HIGH (arg0),
10431                                      &low, &high);
10432           t = build_int_cst_wide (type, low, high);
10433           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
10434                               TREE_CONSTANT_OVERFLOW (arg0));
10435         }
10436       break;
10437
10438     case REAL_CST:
10439       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
10440         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
10441       else
10442         t =  arg0;
10443       break;
10444
10445     default:
10446       gcc_unreachable ();
10447     }
10448
10449   return t;
10450 }
10451
10452 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
10453    constant.  TYPE is the type of the result.  */
10454
10455 static tree
10456 fold_not_const (tree arg0, tree type)
10457 {
10458   tree t = NULL_TREE;
10459
10460   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
10461
10462   t = build_int_cst_wide (type,
10463                           ~ TREE_INT_CST_LOW (arg0),
10464                           ~ TREE_INT_CST_HIGH (arg0));
10465   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
10466                       TREE_CONSTANT_OVERFLOW (arg0));
10467
10468   return t;
10469 }
10470
10471 /* Given CODE, a relational operator, the target type, TYPE and two
10472    constant operands OP0 and OP1, return the result of the
10473    relational operation.  If the result is not a compile time
10474    constant, then return NULL_TREE.  */
10475
10476 static tree
10477 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
10478 {
10479   int result, invert;
10480
10481   /* From here on, the only cases we handle are when the result is
10482      known to be a constant.  */
10483
10484   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
10485     {
10486       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
10487       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
10488
10489       /* Handle the cases where either operand is a NaN.  */
10490       if (real_isnan (c0) || real_isnan (c1))
10491         {
10492           switch (code)
10493             {
10494             case EQ_EXPR:
10495             case ORDERED_EXPR:
10496               result = 0;
10497               break;
10498
10499             case NE_EXPR:
10500             case UNORDERED_EXPR:
10501             case UNLT_EXPR:
10502             case UNLE_EXPR:
10503             case UNGT_EXPR:
10504             case UNGE_EXPR:
10505             case UNEQ_EXPR:
10506               result = 1;
10507               break;
10508
10509             case LT_EXPR:
10510             case LE_EXPR:
10511             case GT_EXPR:
10512             case GE_EXPR:
10513             case LTGT_EXPR:
10514               if (flag_trapping_math)
10515                 return NULL_TREE;
10516               result = 0;
10517               break;
10518
10519             default:
10520               gcc_unreachable ();
10521             }
10522
10523           return constant_boolean_node (result, type);
10524         }
10525
10526       return constant_boolean_node (real_compare (code, c0, c1), type);
10527     }
10528
10529   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
10530
10531      To compute GT, swap the arguments and do LT.
10532      To compute GE, do LT and invert the result.
10533      To compute LE, swap the arguments, do LT and invert the result.
10534      To compute NE, do EQ and invert the result.
10535
10536      Therefore, the code below must handle only EQ and LT.  */
10537
10538   if (code == LE_EXPR || code == GT_EXPR)
10539     {
10540       tree tem = op0;
10541       op0 = op1;
10542       op1 = tem;
10543       code = swap_tree_comparison (code);
10544     }
10545
10546   /* Note that it is safe to invert for real values here because we
10547      have already handled the one case that it matters.  */
10548
10549   invert = 0;
10550   if (code == NE_EXPR || code == GE_EXPR)
10551     {
10552       invert = 1;
10553       code = invert_tree_comparison (code, false);
10554     }
10555
10556   /* Compute a result for LT or EQ if args permit;
10557      Otherwise return T.  */
10558   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
10559     {
10560       if (code == EQ_EXPR)
10561         result = tree_int_cst_equal (op0, op1);
10562       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
10563         result = INT_CST_LT_UNSIGNED (op0, op1);
10564       else
10565         result = INT_CST_LT (op0, op1);
10566     }
10567   else
10568     return NULL_TREE;
10569
10570   if (invert)
10571     result ^= 1;
10572   return constant_boolean_node (result, type);
10573 }
10574
10575 /* Build an expression for the a clean point containing EXPR with type TYPE.
10576    Don't build a cleanup point expression for EXPR which don't have side
10577    effects.  */
10578
10579 tree
10580 fold_build_cleanup_point_expr (tree type, tree expr)
10581 {
10582   /* If the expression does not have side effects then we don't have to wrap
10583      it with a cleanup point expression.  */
10584   if (!TREE_SIDE_EFFECTS (expr))
10585     return expr;
10586
10587   return build1 (CLEANUP_POINT_EXPR, type, expr);
10588 }
10589
10590 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
10591    avoid confusing the gimplify process.  */
10592
10593 tree
10594 build_fold_addr_expr_with_type (tree t, tree ptrtype)
10595 {
10596   /* The size of the object is not relevant when talking about its address.  */
10597   if (TREE_CODE (t) == WITH_SIZE_EXPR)
10598     t = TREE_OPERAND (t, 0);
10599
10600   /* Note: doesn't apply to ALIGN_INDIRECT_REF */
10601   if (TREE_CODE (t) == INDIRECT_REF
10602       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
10603     {
10604       t = TREE_OPERAND (t, 0);
10605       if (TREE_TYPE (t) != ptrtype)
10606         t = build1 (NOP_EXPR, ptrtype, t);
10607     }
10608   else
10609     {
10610       tree base = t;
10611
10612       while (handled_component_p (base)
10613              || TREE_CODE (base) == REALPART_EXPR
10614              || TREE_CODE (base) == IMAGPART_EXPR)
10615         base = TREE_OPERAND (base, 0);
10616       if (DECL_P (base))
10617         TREE_ADDRESSABLE (base) = 1;
10618
10619       t = build1 (ADDR_EXPR, ptrtype, t);
10620     }
10621
10622   return t;
10623 }
10624
10625 tree
10626 build_fold_addr_expr (tree t)
10627 {
10628   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
10629 }
10630
10631 /* Builds an expression for an indirection through T, simplifying some
10632    cases.  */
10633
10634 tree
10635 build_fold_indirect_ref (tree t)
10636 {
10637   tree type = TREE_TYPE (TREE_TYPE (t));
10638   tree sub = t;
10639   tree subtype;
10640
10641   STRIP_NOPS (sub);
10642   if (TREE_CODE (sub) == ADDR_EXPR)
10643     {
10644       tree op = TREE_OPERAND (sub, 0);
10645       tree optype = TREE_TYPE (op);
10646       /* *&p => p */
10647       if (lang_hooks.types_compatible_p (type, optype))
10648         return op;
10649       /* *(foo *)&fooarray => fooarray[0] */
10650       else if (TREE_CODE (optype) == ARRAY_TYPE
10651                && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
10652         return build4 (ARRAY_REF, type, op, size_zero_node, NULL_TREE, NULL_TREE);
10653     }
10654
10655   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
10656   subtype = TREE_TYPE (sub);
10657   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
10658       && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
10659     {
10660       sub = build_fold_indirect_ref (sub);
10661       return build4 (ARRAY_REF, type, sub, size_zero_node, NULL_TREE, NULL_TREE);
10662     }
10663
10664   return build1 (INDIRECT_REF, type, t);
10665 }
10666
10667 /* Strip non-trapping, non-side-effecting tree nodes from an expression
10668    whose result is ignored.  The type of the returned tree need not be
10669    the same as the original expression.  */
10670
10671 tree
10672 fold_ignored_result (tree t)
10673 {
10674   if (!TREE_SIDE_EFFECTS (t))
10675     return integer_zero_node;
10676
10677   for (;;)
10678     switch (TREE_CODE_CLASS (TREE_CODE (t)))
10679       {
10680       case tcc_unary:
10681         t = TREE_OPERAND (t, 0);
10682         break;
10683
10684       case tcc_binary:
10685       case tcc_comparison:
10686         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10687           t = TREE_OPERAND (t, 0);
10688         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
10689           t = TREE_OPERAND (t, 1);
10690         else
10691           return t;
10692         break;
10693
10694       case tcc_expression:
10695         switch (TREE_CODE (t))
10696           {
10697           case COMPOUND_EXPR:
10698             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
10699               return t;
10700             t = TREE_OPERAND (t, 0);
10701             break;
10702
10703           case COND_EXPR:
10704             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
10705                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
10706               return t;
10707             t = TREE_OPERAND (t, 0);
10708             break;
10709
10710           default:
10711             return t;
10712           }
10713         break;
10714
10715       default:
10716         return t;
10717       }
10718 }
10719
10720 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
10721    This can only be applied to objects of a sizetype.  */
10722
10723 tree
10724 round_up (tree value, int divisor)
10725 {
10726   tree div = NULL_TREE;
10727
10728   gcc_assert (divisor > 0);
10729   if (divisor == 1)
10730     return value;
10731
10732   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10733      have to do anything.  Only do this when we are not given a const,
10734      because in that case, this check is more expensive than just
10735      doing it.  */
10736   if (TREE_CODE (value) != INTEGER_CST)
10737     {
10738       div = build_int_cst (TREE_TYPE (value), divisor);
10739
10740       if (multiple_of_p (TREE_TYPE (value), value, div))
10741         return value;
10742     }
10743
10744   /* If divisor is a power of two, simplify this to bit manipulation.  */
10745   if (divisor == (divisor & -divisor))
10746     {
10747       tree t;
10748
10749       t = build_int_cst (TREE_TYPE (value), divisor - 1);
10750       value = size_binop (PLUS_EXPR, value, t);
10751       t = build_int_cst (TREE_TYPE (value), -divisor);
10752       value = size_binop (BIT_AND_EXPR, value, t);
10753     }
10754   else
10755     {
10756       if (!div)
10757         div = build_int_cst (TREE_TYPE (value), divisor);
10758       value = size_binop (CEIL_DIV_EXPR, value, div);
10759       value = size_binop (MULT_EXPR, value, div);
10760     }
10761
10762   return value;
10763 }
10764
10765 /* Likewise, but round down.  */
10766
10767 tree
10768 round_down (tree value, int divisor)
10769 {
10770   tree div = NULL_TREE;
10771
10772   gcc_assert (divisor > 0);
10773   if (divisor == 1)
10774     return value;
10775
10776   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
10777      have to do anything.  Only do this when we are not given a const,
10778      because in that case, this check is more expensive than just
10779      doing it.  */
10780   if (TREE_CODE (value) != INTEGER_CST)
10781     {
10782       div = build_int_cst (TREE_TYPE (value), divisor);
10783
10784       if (multiple_of_p (TREE_TYPE (value), value, div))
10785         return value;
10786     }
10787
10788   /* If divisor is a power of two, simplify this to bit manipulation.  */
10789   if (divisor == (divisor & -divisor))
10790     {
10791       tree t;
10792
10793       t = build_int_cst (TREE_TYPE (value), -divisor);
10794       value = size_binop (BIT_AND_EXPR, value, t);
10795     }
10796   else
10797     {
10798       if (!div)
10799         div = build_int_cst (TREE_TYPE (value), divisor);
10800       value = size_binop (FLOOR_DIV_EXPR, value, div);
10801       value = size_binop (MULT_EXPR, value, div);
10802     }
10803
10804   return value;
10805 }
10806
10807 /* Returns true if addresses of E1 and E2 differ by a constant, false
10808    otherwise.  If they do, &E1 - &E2 is stored in *DIFF.  */
10809
10810 bool
10811 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
10812 {
10813   tree core1, core2;
10814   HOST_WIDE_INT bitsize1, bitsize2;
10815   HOST_WIDE_INT bitpos1, bitpos2;
10816   tree toffset1, toffset2, tdiff, type;
10817   enum machine_mode mode1, mode2;
10818   int unsignedp1, unsignedp2, volatilep1, volatilep2;
10819
10820   core1 = get_inner_reference (e1, &bitsize1, &bitpos1, &toffset1, &mode1,
10821                                &unsignedp1, &volatilep1);
10822   core2 = get_inner_reference (e2, &bitsize2, &bitpos2, &toffset2, &mode2,
10823                                &unsignedp2, &volatilep2);
10824
10825   if (bitpos1 % BITS_PER_UNIT != 0
10826       || bitpos2 % BITS_PER_UNIT != 0
10827       || !operand_equal_p (core1, core2, 0))
10828     return false;
10829
10830   if (toffset1 && toffset2)
10831     {
10832       type = TREE_TYPE (toffset1);
10833       if (type != TREE_TYPE (toffset2))
10834         toffset2 = fold_convert (type, toffset2);
10835
10836       tdiff = fold (build2 (MINUS_EXPR, type, toffset1, toffset2));
10837       if (!host_integerp (tdiff, 0))
10838         return false;
10839
10840       *diff = tree_low_cst (tdiff, 0);
10841     }
10842   else if (toffset1 || toffset2)
10843     {
10844       /* If only one of the offsets is non-constant, the difference cannot
10845          be a constant.  */
10846       return false;
10847     }
10848   else
10849     *diff = 0;
10850
10851   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
10852   return true;
10853 }