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