gcc/fold-const.c

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