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