gcc/fold-const.c

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