gcc/fold-const.c

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