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