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 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 and prior overflow indicator, and
  43    forces the value to fit the type.  It returns an overflow indicator.  */
  44
  45 #include "config.h"
  46 #include "system.h"
  47 #include "coretypes.h"
  48 #include "tm.h"
  49 #include "flags.h"
  50 #include "tree.h"
  51 #include "real.h"
  52 #include "rtl.h"
  53 #include "expr.h"
  54 #include "tm_p.h"
  55 #include "toplev.h"
  56 #include "ggc.h"
  57 #include "hashtab.h"
  58 #include "langhooks.h"
  59
  60 static void encode              PARAMS ((HOST_WIDE_INT *,
  61                                          unsigned HOST_WIDE_INT,
  62                                          HOST_WIDE_INT));
  63 static void decode              PARAMS ((HOST_WIDE_INT *,
  64                                          unsigned HOST_WIDE_INT *,
  65                                          HOST_WIDE_INT *));
  66 static bool negate_expr_p       PARAMS ((tree));
  67 static tree negate_expr         PARAMS ((tree));
  68 static tree split_tree          PARAMS ((tree, enum tree_code, tree *, tree *,
  69                                          tree *, int));
  70 static tree associate_trees     PARAMS ((tree, tree, enum tree_code, tree));
  71 static tree int_const_binop     PARAMS ((enum tree_code, tree, tree, int));
  72 static tree const_binop         PARAMS ((enum tree_code, tree, tree, int));
  73 static hashval_t size_htab_hash PARAMS ((const void *));
  74 static int size_htab_eq         PARAMS ((const void *, const void *));
  75 static tree fold_convert        PARAMS ((tree, tree));
  76 static enum tree_code invert_tree_comparison PARAMS ((enum tree_code));
  77 static enum tree_code swap_tree_comparison PARAMS ((enum tree_code));
  78 static int comparison_to_compcode PARAMS ((enum tree_code));
  79 static enum tree_code compcode_to_comparison PARAMS ((int));
  80 static int truth_value_p        PARAMS ((enum tree_code));
  81 static int operand_equal_for_comparison_p PARAMS ((tree, tree, tree));
  82 static int twoval_comparison_p  PARAMS ((tree, tree *, tree *, int *));
  83 static tree eval_subst          PARAMS ((tree, tree, tree, tree, tree));
  84 static tree omit_one_operand    PARAMS ((tree, tree, tree));
  85 static tree pedantic_omit_one_operand PARAMS ((tree, tree, tree));
  86 static tree distribute_bit_expr PARAMS ((enum tree_code, tree, tree, tree));
  87 static tree make_bit_field_ref  PARAMS ((tree, tree, int, int, int));
  88 static tree optimize_bit_field_compare PARAMS ((enum tree_code, tree,
  89                                                 tree, tree));
  90 static tree decode_field_reference PARAMS ((tree, HOST_WIDE_INT *,
  91                                             HOST_WIDE_INT *,
  92                                             enum machine_mode *, int *,
  93                                             int *, tree *, tree *));
  94 static int all_ones_mask_p      PARAMS ((tree, int));
  95 static tree sign_bit_p          PARAMS ((tree, tree));
  96 static int simple_operand_p     PARAMS ((tree));
  97 static tree range_binop         PARAMS ((enum tree_code, tree, tree, int,
  98                                          tree, int));
  99 static tree make_range          PARAMS ((tree, int *, tree *, tree *));
 100 static tree build_range_check   PARAMS ((tree, tree, int, tree, tree));
 101 static int merge_ranges         PARAMS ((int *, tree *, tree *, int, tree, tree,
 102                                        int, tree, tree));
 103 static tree fold_range_test     PARAMS ((tree));
 104 static tree unextend            PARAMS ((tree, int, int, tree));
 105 static tree fold_truthop        PARAMS ((enum tree_code, tree, tree, tree));
 106 static tree optimize_minmax_comparison PARAMS ((tree));
 107 static tree extract_muldiv      PARAMS ((tree, tree, enum tree_code, tree));
 108 static tree extract_muldiv_1    PARAMS ((tree, tree, enum tree_code, tree));
 109 static tree strip_compound_expr PARAMS ((tree, tree));
 110 static int multiple_of_p        PARAMS ((tree, tree, tree));
 111 static tree constant_boolean_node PARAMS ((int, tree));
 112 static int count_cond           PARAMS ((tree, int));
 113 static tree fold_binary_op_with_conditional_arg
 114   PARAMS ((enum tree_code, tree, tree, tree, int));
 115 static bool fold_real_zero_addition_p   PARAMS ((tree, tree, int));
 116
 117 /* The following constants represent a bit based encoding of GCC's
 118    comparison operators.  This encoding simplifies transformations
 119    on relational comparison operators, such as AND and OR.  */
 120 #define COMPCODE_FALSE   0
 121 #define COMPCODE_LT      1
 122 #define COMPCODE_EQ      2
 123 #define COMPCODE_LE      3
 124 #define COMPCODE_GT      4
 125 #define COMPCODE_NE      5
 126 #define COMPCODE_GE      6
 127 #define COMPCODE_TRUE    7
 128
 129 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 130    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 131    and SUM1.  Then this yields nonzero if overflow occurred during the
 132    addition.
 133
 134    Overflow occurs if A and B have the same sign, but A and SUM differ in
 135    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 136    sign.  */
 137 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 138 \f
 139 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
 140    We do that by representing the two-word integer in 4 words, with only
 141    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
 142    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
 143
 144 #define LOWPART(x) \
 145   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
 146 #define HIGHPART(x) \
 147   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
 148 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
 149
 150 /* Unpack a two-word integer into 4 words.
 151    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
 152    WORDS points to the array of HOST_WIDE_INTs.  */
 153
 154 static void
 155 encode (words, low, hi)
 156      HOST_WIDE_INT *words;
 157      unsigned HOST_WIDE_INT low;
 158      HOST_WIDE_INT hi;
 159 {
 160   words[0] = LOWPART (low);
 161   words[1] = HIGHPART (low);
 162   words[2] = LOWPART (hi);
 163   words[3] = HIGHPART (hi);
 164 }
 165
 166 /* Pack an array of 4 words into a two-word integer.
 167    WORDS points to the array of words.
 168    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
 169
 170 static void
 171 decode (words, low, hi)
 172      HOST_WIDE_INT *words;
 173      unsigned HOST_WIDE_INT *low;
 174      HOST_WIDE_INT *hi;
 175 {
 176   *low = words[0] + words[1] * BASE;
 177   *hi = words[2] + words[3] * BASE;
 178 }
 179 \f
 180 /* Make the integer constant T valid for its type by setting to 0 or 1 all
 181    the bits in the constant that don't belong in the type.
 182
 183    Return 1 if a signed overflow occurs, 0 otherwise.  If OVERFLOW is
 184    nonzero, a signed overflow has already occurred in calculating T, so
 185    propagate it.  */
 186
 187 int
 188 force_fit_type (t, overflow)
 189      tree t;
 190      int overflow;
 191 {
 192   unsigned HOST_WIDE_INT low;
 193   HOST_WIDE_INT high;
 194   unsigned int prec;
 195
 196   if (TREE_CODE (t) == REAL_CST)
 197     {
 198       /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
 199          Consider doing it via real_convert now.  */
 200       return overflow;
 201     }
 202
 203   else if (TREE_CODE (t) != INTEGER_CST)
 204     return overflow;
 205
 206   low = TREE_INT_CST_LOW (t);
 207   high = TREE_INT_CST_HIGH (t);
 208
 209   if (POINTER_TYPE_P (TREE_TYPE (t)))
 210     prec = POINTER_SIZE;
 211   else
 212     prec = TYPE_PRECISION (TREE_TYPE (t));
 213
 214   /* First clear all bits that are beyond the type's precision.  */
 215
 216   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 217     ;
 218   else if (prec > HOST_BITS_PER_WIDE_INT)
 219     TREE_INT_CST_HIGH (t)
 220       &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 221   else
 222     {
 223       TREE_INT_CST_HIGH (t) = 0;
 224       if (prec < HOST_BITS_PER_WIDE_INT)
 225         TREE_INT_CST_LOW (t) &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
 226     }
 227
 228   /* Unsigned types do not suffer sign extension or overflow unless they
 229      are a sizetype.  */
 230   if (TREE_UNSIGNED (TREE_TYPE (t))
 231       && ! (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
 232             && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
 233     return overflow;
 234
 235   /* If the value's sign bit is set, extend the sign.  */
 236   if (prec != 2 * HOST_BITS_PER_WIDE_INT
 237       && (prec > HOST_BITS_PER_WIDE_INT
 238           ? 0 != (TREE_INT_CST_HIGH (t)
 239                   & ((HOST_WIDE_INT) 1
 240                      << (prec - HOST_BITS_PER_WIDE_INT - 1)))
 241           : 0 != (TREE_INT_CST_LOW (t)
 242                   & ((unsigned HOST_WIDE_INT) 1 << (prec - 1)))))
 243     {
 244       /* Value is negative:
 245          set to 1 all the bits that are outside this type's precision.  */
 246       if (prec > HOST_BITS_PER_WIDE_INT)
 247         TREE_INT_CST_HIGH (t)
 248           |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 249       else
 250         {
 251           TREE_INT_CST_HIGH (t) = -1;
 252           if (prec < HOST_BITS_PER_WIDE_INT)
 253             TREE_INT_CST_LOW (t) |= ((unsigned HOST_WIDE_INT) (-1) << prec);
 254         }
 255     }
 256
 257   /* Return nonzero if signed overflow occurred.  */
 258   return
 259     ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
 260      != 0);
 261 }
 262 \f
 263 /* Add two doubleword integers with doubleword result.
 264    Each argument is given as two `HOST_WIDE_INT' pieces.
 265    One argument is L1 and H1; the other, L2 and H2.
 266    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 267
 268 int
 269 add_double (l1, h1, l2, h2, lv, hv)
 270      unsigned HOST_WIDE_INT l1, l2;
 271      HOST_WIDE_INT h1, h2;
 272      unsigned HOST_WIDE_INT *lv;
 273      HOST_WIDE_INT *hv;
 274 {
 275   unsigned HOST_WIDE_INT l;
 276   HOST_WIDE_INT h;
 277
 278   l = l1 + l2;
 279   h = h1 + h2 + (l < l1);
 280
 281   *lv = l;
 282   *hv = h;
 283   return OVERFLOW_SUM_SIGN (h1, h2, h);
 284 }
 285
 286 /* Negate a doubleword integer with doubleword result.
 287    Return nonzero if the operation overflows, assuming it's signed.
 288    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
 289    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 290
 291 int
 292 neg_double (l1, h1, lv, hv)
 293      unsigned HOST_WIDE_INT l1;
 294      HOST_WIDE_INT h1;
 295      unsigned HOST_WIDE_INT *lv;
 296      HOST_WIDE_INT *hv;
 297 {
 298   if (l1 == 0)
 299     {
 300       *lv = 0;
 301       *hv = - h1;
 302       return (*hv & h1) < 0;
 303     }
 304   else
 305     {
 306       *lv = -l1;
 307       *hv = ~h1;
 308       return 0;
 309     }
 310 }
 311 \f
 312 /* Multiply two doubleword integers with doubleword result.
 313    Return nonzero if the operation overflows, assuming it's signed.
 314    Each argument is given as two `HOST_WIDE_INT' pieces.
 315    One argument is L1 and H1; the other, L2 and H2.
 316    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 317
 318 int
 319 mul_double (l1, h1, l2, h2, lv, hv)
 320      unsigned HOST_WIDE_INT l1, l2;
 321      HOST_WIDE_INT h1, h2;
 322      unsigned HOST_WIDE_INT *lv;
 323      HOST_WIDE_INT *hv;
 324 {
 325   HOST_WIDE_INT arg1[4];
 326   HOST_WIDE_INT arg2[4];
 327   HOST_WIDE_INT prod[4 * 2];
 328   unsigned HOST_WIDE_INT carry;
 329   int i, j, k;
 330   unsigned HOST_WIDE_INT toplow, neglow;
 331   HOST_WIDE_INT tophigh, neghigh;
 332
 333   encode (arg1, l1, h1);
 334   encode (arg2, l2, h2);
 335
 336   memset ((char *) prod, 0, sizeof prod);
 337
 338   for (i = 0; i < 4; i++)
 339     {
 340       carry = 0;
 341       for (j = 0; j < 4; j++)
 342         {
 343           k = i + j;
 344           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
 345           carry += arg1[i] * arg2[j];
 346           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
 347           carry += prod[k];
 348           prod[k] = LOWPART (carry);
 349           carry = HIGHPART (carry);
 350         }
 351       prod[i + 4] = carry;
 352     }
 353
 354   decode (prod, lv, hv);        /* This ignores prod[4] through prod[4*2-1] */
 355
 356   /* Check for overflow by calculating the top half of the answer in full;
 357      it should agree with the low half's sign bit.  */
 358   decode (prod + 4, &toplow, &tophigh);
 359   if (h1 < 0)
 360     {
 361       neg_double (l2, h2, &neglow, &neghigh);
 362       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 363     }
 364   if (h2 < 0)
 365     {
 366       neg_double (l1, h1, &neglow, &neghigh);
 367       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 368     }
 369   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
 370 }
 371 \f
 372 /* Shift the doubleword integer in L1, H1 left by COUNT places
 373    keeping only PREC bits of result.
 374    Shift right if COUNT is negative.
 375    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 376    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 377
 378 void
 379 lshift_double (l1, h1, count, prec, lv, hv, arith)
 380      unsigned HOST_WIDE_INT l1;
 381      HOST_WIDE_INT h1, count;
 382      unsigned int prec;
 383      unsigned HOST_WIDE_INT *lv;
 384      HOST_WIDE_INT *hv;
 385      int arith;
 386 {
 387   unsigned HOST_WIDE_INT signmask;
 388
 389   if (count < 0)
 390     {
 391       rshift_double (l1, h1, -count, prec, lv, hv, arith);
 392       return;
 393     }
 394
 395 #ifdef SHIFT_COUNT_TRUNCATED
 396   if (SHIFT_COUNT_TRUNCATED)
 397     count %= prec;
 398 #endif
 399
 400   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 401     {
 402       /* Shifting by the host word size is undefined according to the
 403          ANSI standard, so we must handle this as a special case.  */
 404       *hv = 0;
 405       *lv = 0;
 406     }
 407   else if (count >= HOST_BITS_PER_WIDE_INT)
 408     {
 409       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
 410       *lv = 0;
 411     }
 412   else
 413     {
 414       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
 415              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
 416       *lv = l1 << count;
 417     }
 418
 419   /* Sign extend all bits that are beyond the precision.  */
 420
 421   signmask = -((prec > HOST_BITS_PER_WIDE_INT
 422                 ? ((unsigned HOST_WIDE_INT) *hv
 423                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
 424                 : (*lv >> (prec - 1))) & 1);
 425
 426   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
 427     ;
 428   else if (prec >= HOST_BITS_PER_WIDE_INT)
 429     {
 430       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 431       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
 432     }
 433   else
 434     {
 435       *hv = signmask;
 436       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
 437       *lv |= signmask << prec;
 438     }
 439 }
 440
 441 /* Shift the doubleword integer in L1, H1 right by COUNT places
 442    keeping only PREC bits of result.  COUNT must be positive.
 443    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 444    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 445
 446 void
 447 rshift_double (l1, h1, count, prec, lv, hv, arith)
 448      unsigned HOST_WIDE_INT l1;
 449      HOST_WIDE_INT h1, count;
 450      unsigned int prec;
 451      unsigned HOST_WIDE_INT *lv;
 452      HOST_WIDE_INT *hv;
 453      int arith;
 454 {
 455   unsigned HOST_WIDE_INT signmask;
 456
 457   signmask = (arith
 458               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
 459               : 0);
 460
 461 #ifdef SHIFT_COUNT_TRUNCATED
 462   if (SHIFT_COUNT_TRUNCATED)
 463     count %= prec;
 464 #endif
 465
 466   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 467     {
 468       /* Shifting by the host word size is undefined according to the
 469          ANSI standard, so we must handle this as a special case.  */
 470       *hv = 0;
 471       *lv = 0;
 472     }
 473   else if (count >= HOST_BITS_PER_WIDE_INT)
 474     {
 475       *hv = 0;
 476       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
 477     }
 478   else
 479     {
 480       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
 481       *lv = ((l1 >> count)
 482              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
 483     }
 484
 485   /* Zero / sign extend all bits that are beyond the precision.  */
 486
 487   if (count >= (HOST_WIDE_INT)prec)
 488     {
 489       *hv = signmask;
 490       *lv = signmask;
 491     }
 492   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
 493     ;
 494   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
 495     {
 496       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
 497       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
 498     }
 499   else
 500     {
 501       *hv = signmask;
 502       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
 503       *lv |= signmask << (prec - count);
 504     }
 505 }
 506 \f
 507 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 508    keeping only PREC bits of result.
 509    Rotate right if COUNT is negative.
 510    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 511
 512 void
 513 lrotate_double (l1, h1, count, prec, lv, hv)
 514      unsigned HOST_WIDE_INT l1;
 515      HOST_WIDE_INT h1, count;
 516      unsigned int prec;
 517      unsigned HOST_WIDE_INT *lv;
 518      HOST_WIDE_INT *hv;
 519 {
 520   unsigned HOST_WIDE_INT s1l, s2l;
 521   HOST_WIDE_INT s1h, s2h;
 522
 523   count %= prec;
 524   if (count < 0)
 525     count += prec;
 526
 527   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 528   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 529   *lv = s1l | s2l;
 530   *hv = s1h | s2h;
 531 }
 532
 533 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 534    keeping only PREC bits of result.  COUNT must be positive.
 535    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 536
 537 void
 538 rrotate_double (l1, h1, count, prec, lv, hv)
 539      unsigned HOST_WIDE_INT l1;
 540      HOST_WIDE_INT h1, count;
 541      unsigned int prec;
 542      unsigned HOST_WIDE_INT *lv;
 543      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 (code, uns,
 569                       lnum_orig, hnum_orig, lden_orig, hden_orig,
 570                       lquo, hquo, lrem, hrem)
 571      enum tree_code code;
 572      int uns;
 573      unsigned HOST_WIDE_INT lnum_orig; /* num == numerator == dividend */
 574      HOST_WIDE_INT hnum_orig;
 575      unsigned HOST_WIDE_INT lden_orig; /* den == denominator == divisor */
 576      HOST_WIDE_INT hden_orig;
 577      unsigned HOST_WIDE_INT *lquo, *lrem;
 578      HOST_WIDE_INT *hquo, *hrem;
 579 {
 580   int quo_neg = 0;
 581   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
 582   HOST_WIDE_INT den[4], quo[4];
 583   int i, j;
 584   unsigned HOST_WIDE_INT work;
 585   unsigned HOST_WIDE_INT carry = 0;
 586   unsigned HOST_WIDE_INT lnum = lnum_orig;
 587   HOST_WIDE_INT hnum = hnum_orig;
 588   unsigned HOST_WIDE_INT lden = lden_orig;
 589   HOST_WIDE_INT hden = hden_orig;
 590   int overflow = 0;
 591
 592   if (hden == 0 && lden == 0)
 593     overflow = 1, lden = 1;
 594
 595   /* calculate quotient sign and convert operands to unsigned.  */
 596   if (!uns)
 597     {
 598       if (hnum < 0)
 599         {
 600           quo_neg = ~ quo_neg;
 601           /* (minimum integer) / (-1) is the only overflow case.  */
 602           if (neg_double (lnum, hnum, &lnum, &hnum)
 603               && ((HOST_WIDE_INT) lden & hden) == -1)
 604             overflow = 1;
 605         }
 606       if (hden < 0)
 607         {
 608           quo_neg = ~ quo_neg;
 609           neg_double (lden, hden, &lden, &hden);
 610         }
 611     }
 612
 613   if (hnum == 0 && hden == 0)
 614     {                           /* single precision */
 615       *hquo = *hrem = 0;
 616       /* This unsigned division rounds toward zero.  */
 617       *lquo = lnum / lden;
 618       goto finish_up;
 619     }
 620
 621   if (hnum == 0)
 622     {                           /* trivial case: dividend < divisor */
 623       /* hden != 0 already checked.  */
 624       *hquo = *lquo = 0;
 625       *hrem = hnum;
 626       *lrem = lnum;
 627       goto finish_up;
 628     }
 629
 630   memset ((char *) quo, 0, sizeof quo);
 631
 632   memset ((char *) num, 0, sizeof num); /* to zero 9th element */
 633   memset ((char *) den, 0, sizeof den);
 634
 635   encode (num, lnum, hnum);
 636   encode (den, lden, hden);
 637
 638   /* Special code for when the divisor < BASE.  */
 639   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
 640     {
 641       /* hnum != 0 already checked.  */
 642       for (i = 4 - 1; i >= 0; i--)
 643         {
 644           work = num[i] + carry * BASE;
 645           quo[i] = work / lden;
 646           carry = work % lden;
 647         }
 648     }
 649   else
 650     {
 651       /* Full double precision division,
 652          with thanks to Don Knuth's "Seminumerical Algorithms".  */
 653       int num_hi_sig, den_hi_sig;
 654       unsigned HOST_WIDE_INT quo_est, scale;
 655
 656       /* Find the highest nonzero divisor digit.  */
 657       for (i = 4 - 1;; i--)
 658         if (den[i] != 0)
 659           {
 660             den_hi_sig = i;
 661             break;
 662           }
 663
 664       /* Insure that the first digit of the divisor is at least BASE/2.
 665          This is required by the quotient digit estimation algorithm.  */
 666
 667       scale = BASE / (den[den_hi_sig] + 1);
 668       if (scale > 1)
 669         {               /* scale divisor and dividend */
 670           carry = 0;
 671           for (i = 0; i <= 4 - 1; i++)
 672             {
 673               work = (num[i] * scale) + carry;
 674               num[i] = LOWPART (work);
 675               carry = HIGHPART (work);
 676             }
 677
 678           num[4] = carry;
 679           carry = 0;
 680           for (i = 0; i <= 4 - 1; i++)
 681             {
 682               work = (den[i] * scale) + carry;
 683               den[i] = LOWPART (work);
 684               carry = HIGHPART (work);
 685               if (den[i] != 0) den_hi_sig = i;
 686             }
 687         }
 688
 689       num_hi_sig = 4;
 690
 691       /* Main loop */
 692       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
 693         {
 694           /* Guess the next quotient digit, quo_est, by dividing the first
 695              two remaining dividend digits by the high order quotient digit.
 696              quo_est is never low and is at most 2 high.  */
 697           unsigned HOST_WIDE_INT tmp;
 698
 699           num_hi_sig = i + den_hi_sig + 1;
 700           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
 701           if (num[num_hi_sig] != den[den_hi_sig])
 702             quo_est = work / den[den_hi_sig];
 703           else
 704             quo_est = BASE - 1;
 705
 706           /* Refine quo_est so it's usually correct, and at most one high.  */
 707           tmp = work - quo_est * den[den_hi_sig];
 708           if (tmp < BASE
 709               && (den[den_hi_sig - 1] * quo_est
 710                   > (tmp * BASE + num[num_hi_sig - 2])))
 711             quo_est--;
 712
 713           /* Try QUO_EST as the quotient digit, by multiplying the
 714              divisor by QUO_EST and subtracting from the remaining dividend.
 715              Keep in mind that QUO_EST is the I - 1st digit.  */
 716
 717           carry = 0;
 718           for (j = 0; j <= den_hi_sig; j++)
 719             {
 720               work = quo_est * den[j] + carry;
 721               carry = HIGHPART (work);
 722               work = num[i + j] - LOWPART (work);
 723               num[i + j] = LOWPART (work);
 724               carry += HIGHPART (work) != 0;
 725             }
 726
 727           /* If quo_est was high by one, then num[i] went negative and
 728              we need to correct things.  */
 729           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
 730             {
 731               quo_est--;
 732               carry = 0;                /* add divisor back in */
 733               for (j = 0; j <= den_hi_sig; j++)
 734                 {
 735                   work = num[i + j] + den[j] + carry;
 736                   carry = HIGHPART (work);
 737                   num[i + j] = LOWPART (work);
 738                 }
 739
 740               num [num_hi_sig] += carry;
 741             }
 742
 743           /* Store the quotient digit.  */
 744           quo[i] = quo_est;
 745         }
 746     }
 747
 748   decode (quo, lquo, hquo);
 749
 750  finish_up:
 751   /* if result is negative, make it so.  */
 752   if (quo_neg)
 753     neg_double (*lquo, *hquo, lquo, hquo);
 754
 755   /* compute trial remainder:  rem = num - (quo * den)  */
 756   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 757   neg_double (*lrem, *hrem, lrem, hrem);
 758   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 759
 760   switch (code)
 761     {
 762     case TRUNC_DIV_EXPR:
 763     case TRUNC_MOD_EXPR:        /* round toward zero */
 764     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
 765       return overflow;
 766
 767     case FLOOR_DIV_EXPR:
 768     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
 769       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
 770         {
 771           /* quo = quo - 1;  */
 772           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
 773                       lquo, hquo);
 774         }
 775       else
 776         return overflow;
 777       break;
 778
 779     case CEIL_DIV_EXPR:
 780     case CEIL_MOD_EXPR:         /* round toward positive infinity */
 781       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
 782         {
 783           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 784                       lquo, hquo);
 785         }
 786       else
 787         return overflow;
 788       break;
 789
 790     case ROUND_DIV_EXPR:
 791     case ROUND_MOD_EXPR:        /* round to closest integer */
 792       {
 793         unsigned HOST_WIDE_INT labs_rem = *lrem;
 794         HOST_WIDE_INT habs_rem = *hrem;
 795         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
 796         HOST_WIDE_INT habs_den = hden, htwice;
 797
 798         /* Get absolute values */
 799         if (*hrem < 0)
 800           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
 801         if (hden < 0)
 802           neg_double (lden, hden, &labs_den, &habs_den);
 803
 804         /* If (2 * abs (lrem) >= abs (lden)) */
 805         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
 806                     labs_rem, habs_rem, &ltwice, &htwice);
 807
 808         if (((unsigned HOST_WIDE_INT) habs_den
 809              < (unsigned HOST_WIDE_INT) htwice)
 810             || (((unsigned HOST_WIDE_INT) habs_den
 811                  == (unsigned HOST_WIDE_INT) htwice)
 812                 && (labs_den < ltwice)))
 813           {
 814             if (*hquo < 0)
 815               /* quo = quo - 1;  */
 816               add_double (*lquo, *hquo,
 817                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
 818             else
 819               /* quo = quo + 1; */
 820               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 821                           lquo, hquo);
 822           }
 823         else
 824           return overflow;
 825       }
 826       break;
 827
 828     default:
 829       abort ();
 830     }
 831
 832   /* compute true remainder:  rem = num - (quo * den)  */
 833   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 834   neg_double (*lrem, *hrem, lrem, hrem);
 835   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 836   return overflow;
 837 }
 838 \f
 839 /* Determine whether an expression T can be cheaply negated using
 840    the function negate_expr.  */
 841
 842 static bool
 843 negate_expr_p (t)
 844      tree t;
 845 {
 846   unsigned HOST_WIDE_INT val;
 847   unsigned int prec;
 848   tree type;
 849
 850   if (t == 0)
 851     return false;
 852
 853   type = TREE_TYPE (t);
 854
 855   STRIP_SIGN_NOPS (t);
 856   switch (TREE_CODE (t))
 857     {
 858     case INTEGER_CST:
 859       if (TREE_UNSIGNED (type))
 860         return false;
 861
 862       /* Check that -CST will not overflow type.  */
 863       prec = TYPE_PRECISION (type);
 864       if (prec > HOST_BITS_PER_WIDE_INT)
 865         {
 866           if (TREE_INT_CST_LOW (t) != 0)
 867             return true;
 868           prec -= HOST_BITS_PER_WIDE_INT;
 869           val = TREE_INT_CST_HIGH (t);
 870         }
 871       else
 872         val = TREE_INT_CST_LOW (t);
 873       if (prec < HOST_BITS_PER_WIDE_INT)
 874         val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 875       return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
 876
 877     case REAL_CST:
 878     case NEGATE_EXPR:
 879     case MINUS_EXPR:
 880       return true;
 881
 882     default:
 883       break;
 884     }
 885   return false;
 886 }
 887
 888 /* Given T, an expression, return the negation of T.  Allow for T to be
 889    null, in which case return null.  */
 890
 891 static tree
 892 negate_expr (t)
 893      tree t;
 894 {
 895   tree type;
 896   tree tem;
 897
 898   if (t == 0)
 899     return 0;
 900
 901   type = TREE_TYPE (t);
 902   STRIP_SIGN_NOPS (t);
 903
 904   switch (TREE_CODE (t))
 905     {
 906     case INTEGER_CST:
 907     case REAL_CST:
 908       if (! TREE_UNSIGNED (type)
 909           && 0 != (tem = fold (build1 (NEGATE_EXPR, type, t)))
 910           && ! TREE_OVERFLOW (tem))
 911         return tem;
 912       break;
 913
 914     case NEGATE_EXPR:
 915       return convert (type, TREE_OPERAND (t, 0));
 916
 917     case MINUS_EXPR:
 918       /* - (A - B) -> B - A  */
 919       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
 920         return convert (type,
 921                         fold (build (MINUS_EXPR, TREE_TYPE (t),
 922                                      TREE_OPERAND (t, 1),
 923                                      TREE_OPERAND (t, 0))));
 924       break;
 925
 926     default:
 927       break;
 928     }
 929
 930   return convert (type, fold (build1 (NEGATE_EXPR, TREE_TYPE (t), t)));
 931 }
 932 \f
 933 /* Split a tree IN into a constant, literal and variable parts that could be
 934    combined with CODE to make IN.  "constant" means an expression with
 935    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
 936    commutative arithmetic operation.  Store the constant part into *CONP,
 937    the literal in *LITP and return the variable part.  If a part isn't
 938    present, set it to null.  If the tree does not decompose in this way,
 939    return the entire tree as the variable part and the other parts as null.
 940
 941    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
 942    case, we negate an operand that was subtracted.  Except if it is a
 943    literal for which we use *MINUS_LITP instead.
 944
 945    If NEGATE_P is true, we are negating all of IN, again except a literal
 946    for which we use *MINUS_LITP instead.
 947
 948    If IN is itself a literal or constant, return it as appropriate.
 949
 950    Note that we do not guarantee that any of the three values will be the
 951    same type as IN, but they will have the same signedness and mode.  */
 952
 953 static tree
 954 split_tree (in, code, conp, litp, minus_litp, negate_p)
 955      tree in;
 956      enum tree_code code;
 957      tree *conp, *litp, *minus_litp;
 958      int negate_p;
 959 {
 960   tree var = 0;
 961
 962   *conp = 0;
 963   *litp = 0;
 964   *minus_litp = 0;
 965
 966   /* Strip any conversions that don't change the machine mode or signedness.  */
 967   STRIP_SIGN_NOPS (in);
 968
 969   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
 970     *litp = in;
 971   else if (TREE_CODE (in) == code
 972            || (! FLOAT_TYPE_P (TREE_TYPE (in))
 973                /* We can associate addition and subtraction together (even
 974                   though the C standard doesn't say so) for integers because
 975                   the value is not affected.  For reals, the value might be
 976                   affected, so we can't.  */
 977                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
 978                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
 979     {
 980       tree op0 = TREE_OPERAND (in, 0);
 981       tree op1 = TREE_OPERAND (in, 1);
 982       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
 983       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
 984
 985       /* First see if either of the operands is a literal, then a constant.  */
 986       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
 987         *litp = op0, op0 = 0;
 988       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
 989         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
 990
 991       if (op0 != 0 && TREE_CONSTANT (op0))
 992         *conp = op0, op0 = 0;
 993       else if (op1 != 0 && TREE_CONSTANT (op1))
 994         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
 995
 996       /* If we haven't dealt with either operand, this is not a case we can
 997          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
 998       if (op0 != 0 && op1 != 0)
 999         var = in;
1000       else if (op0 != 0)
1001         var = op0;
1002       else
1003         var = op1, neg_var_p = neg1_p;
1004
1005       /* Now do any needed negations.  */
1006       if (neg_litp_p)
1007         *minus_litp = *litp, *litp = 0;
1008       if (neg_conp_p)
1009         *conp = negate_expr (*conp);
1010       if (neg_var_p)
1011         var = negate_expr (var);
1012     }
1013   else if (TREE_CONSTANT (in))
1014     *conp = in;
1015   else
1016     var = in;
1017
1018   if (negate_p)
1019     {
1020       if (*litp)
1021         *minus_litp = *litp, *litp = 0;
1022       else if (*minus_litp)
1023         *litp = *minus_litp, *minus_litp = 0;
1024       *conp = negate_expr (*conp);
1025       var = negate_expr (var);
1026     }
1027
1028   return var;
1029 }
1030
1031 /* Re-associate trees split by the above function.  T1 and T2 are either
1032    expressions to associate or null.  Return the new expression, if any.  If
1033    we build an operation, do it in TYPE and with CODE.  */
1034
1035 static tree
1036 associate_trees (t1, t2, code, type)
1037      tree t1, t2;
1038      enum tree_code code;
1039      tree type;
1040 {
1041   if (t1 == 0)
1042     return t2;
1043   else if (t2 == 0)
1044     return t1;
1045
1046   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1047      try to fold this since we will have infinite recursion.  But do
1048      deal with any NEGATE_EXPRs.  */
1049   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1050       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1051     {
1052       if (code == PLUS_EXPR)
1053         {
1054           if (TREE_CODE (t1) == NEGATE_EXPR)
1055             return build (MINUS_EXPR, type, convert (type, t2),
1056                           convert (type, TREE_OPERAND (t1, 0)));
1057           else if (TREE_CODE (t2) == NEGATE_EXPR)
1058             return build (MINUS_EXPR, type, convert (type, t1),
1059                           convert (type, TREE_OPERAND (t2, 0)));
1060         }
1061       return build (code, type, convert (type, t1), convert (type, t2));
1062     }
1063
1064   return fold (build (code, type, convert (type, t1), convert (type, t2)));
1065 }
1066 \f
1067 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1068    to produce a new constant.
1069
1070    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1071
1072 static tree
1073 int_const_binop (code, arg1, arg2, notrunc)
1074      enum tree_code code;
1075      tree arg1, arg2;
1076      int notrunc;
1077 {
1078   unsigned HOST_WIDE_INT int1l, int2l;
1079   HOST_WIDE_INT int1h, int2h;
1080   unsigned HOST_WIDE_INT low;
1081   HOST_WIDE_INT hi;
1082   unsigned HOST_WIDE_INT garbagel;
1083   HOST_WIDE_INT garbageh;
1084   tree t;
1085   tree type = TREE_TYPE (arg1);
1086   int uns = TREE_UNSIGNED (type);
1087   int is_sizetype
1088     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1089   int overflow = 0;
1090   int no_overflow = 0;
1091
1092   int1l = TREE_INT_CST_LOW (arg1);
1093   int1h = TREE_INT_CST_HIGH (arg1);
1094   int2l = TREE_INT_CST_LOW (arg2);
1095   int2h = TREE_INT_CST_HIGH (arg2);
1096
1097   switch (code)
1098     {
1099     case BIT_IOR_EXPR:
1100       low = int1l | int2l, hi = int1h | int2h;
1101       break;
1102
1103     case BIT_XOR_EXPR:
1104       low = int1l ^ int2l, hi = int1h ^ int2h;
1105       break;
1106
1107     case BIT_AND_EXPR:
1108       low = int1l & int2l, hi = int1h & int2h;
1109       break;
1110
1111     case BIT_ANDTC_EXPR:
1112       low = int1l & ~int2l, hi = int1h & ~int2h;
1113       break;
1114
1115     case RSHIFT_EXPR:
1116       int2l = -int2l;
1117     case LSHIFT_EXPR:
1118       /* It's unclear from the C standard whether shifts can overflow.
1119          The following code ignores overflow; perhaps a C standard
1120          interpretation ruling is needed.  */
1121       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1122                      &low, &hi, !uns);
1123       no_overflow = 1;
1124       break;
1125
1126     case RROTATE_EXPR:
1127       int2l = - int2l;
1128     case LROTATE_EXPR:
1129       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1130                       &low, &hi);
1131       break;
1132
1133     case PLUS_EXPR:
1134       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1135       break;
1136
1137     case MINUS_EXPR:
1138       neg_double (int2l, int2h, &low, &hi);
1139       add_double (int1l, int1h, low, hi, &low, &hi);
1140       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1141       break;
1142
1143     case MULT_EXPR:
1144       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1145       break;
1146
1147     case TRUNC_DIV_EXPR:
1148     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1149     case EXACT_DIV_EXPR:
1150       /* This is a shortcut for a common special case.  */
1151       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1152           && ! TREE_CONSTANT_OVERFLOW (arg1)
1153           && ! TREE_CONSTANT_OVERFLOW (arg2)
1154           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1155         {
1156           if (code == CEIL_DIV_EXPR)
1157             int1l += int2l - 1;
1158
1159           low = int1l / int2l, hi = 0;
1160           break;
1161         }
1162
1163       /* ... fall through ...  */
1164
1165     case ROUND_DIV_EXPR:
1166       if (int2h == 0 && int2l == 1)
1167         {
1168           low = int1l, hi = int1h;
1169           break;
1170         }
1171       if (int1l == int2l && int1h == int2h
1172           && ! (int1l == 0 && int1h == 0))
1173         {
1174           low = 1, hi = 0;
1175           break;
1176         }
1177       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1178                                        &low, &hi, &garbagel, &garbageh);
1179       break;
1180
1181     case TRUNC_MOD_EXPR:
1182     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1183       /* This is a shortcut for a common special case.  */
1184       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1185           && ! TREE_CONSTANT_OVERFLOW (arg1)
1186           && ! TREE_CONSTANT_OVERFLOW (arg2)
1187           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1188         {
1189           if (code == CEIL_MOD_EXPR)
1190             int1l += int2l - 1;
1191           low = int1l % int2l, hi = 0;
1192           break;
1193         }
1194
1195       /* ... fall through ...  */
1196
1197     case ROUND_MOD_EXPR:
1198       overflow = div_and_round_double (code, uns,
1199                                        int1l, int1h, int2l, int2h,
1200                                        &garbagel, &garbageh, &low, &hi);
1201       break;
1202
1203     case MIN_EXPR:
1204     case MAX_EXPR:
1205       if (uns)
1206         low = (((unsigned HOST_WIDE_INT) int1h
1207                 < (unsigned HOST_WIDE_INT) int2h)
1208                || (((unsigned HOST_WIDE_INT) int1h
1209                     == (unsigned HOST_WIDE_INT) int2h)
1210                    && int1l < int2l));
1211       else
1212         low = (int1h < int2h
1213                || (int1h == int2h && int1l < int2l));
1214
1215       if (low == (code == MIN_EXPR))
1216         low = int1l, hi = int1h;
1217       else
1218         low = int2l, hi = int2h;
1219       break;
1220
1221     default:
1222       abort ();
1223     }
1224
1225   /* If this is for a sizetype, can be represented as one (signed)
1226      HOST_WIDE_INT word, and doesn't overflow, use size_int since it caches
1227      constants.  */
1228   if (is_sizetype
1229       && ((hi == 0 && (HOST_WIDE_INT) low >= 0)
1230           || (hi == -1 && (HOST_WIDE_INT) low < 0))
1231       && overflow == 0 && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
1232     return size_int_type_wide (low, type);
1233   else
1234     {
1235       t = build_int_2 (low, hi);
1236       TREE_TYPE (t) = TREE_TYPE (arg1);
1237     }
1238
1239   TREE_OVERFLOW (t)
1240     = ((notrunc
1241         ? (!uns || is_sizetype) && overflow
1242         : (force_fit_type (t, (!uns || is_sizetype) && overflow)
1243            && ! no_overflow))
1244        | TREE_OVERFLOW (arg1)
1245        | TREE_OVERFLOW (arg2));
1246
1247   /* If we're doing a size calculation, unsigned arithmetic does overflow.
1248      So check if force_fit_type truncated the value.  */
1249   if (is_sizetype
1250       && ! TREE_OVERFLOW (t)
1251       && (TREE_INT_CST_HIGH (t) != hi
1252           || TREE_INT_CST_LOW (t) != low))
1253     TREE_OVERFLOW (t) = 1;
1254
1255   TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1256                                 | TREE_CONSTANT_OVERFLOW (arg1)
1257                                 | TREE_CONSTANT_OVERFLOW (arg2));
1258   return t;
1259 }
1260
1261 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1262    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1263    are the same kind of constant and the same machine mode.
1264
1265    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1266
1267 static tree
1268 const_binop (code, arg1, arg2, notrunc)
1269      enum tree_code code;
1270      tree arg1, arg2;
1271      int notrunc;
1272 {
1273   STRIP_NOPS (arg1);
1274   STRIP_NOPS (arg2);
1275
1276   if (TREE_CODE (arg1) == INTEGER_CST)
1277     return int_const_binop (code, arg1, arg2, notrunc);
1278
1279   if (TREE_CODE (arg1) == REAL_CST)
1280     {
1281       REAL_VALUE_TYPE d1;
1282       REAL_VALUE_TYPE d2;
1283       REAL_VALUE_TYPE value;
1284       tree t;
1285
1286       d1 = TREE_REAL_CST (arg1);
1287       d2 = TREE_REAL_CST (arg2);
1288
1289       /* If either operand is a NaN, just return it.  Otherwise, set up
1290          for floating-point trap; we return an overflow.  */
1291       if (REAL_VALUE_ISNAN (d1))
1292         return arg1;
1293       else if (REAL_VALUE_ISNAN (d2))
1294         return arg2;
1295
1296       REAL_ARITHMETIC (value, code, d1, d2);
1297
1298       t = build_real (TREE_TYPE (arg1),
1299                       real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)),
1300                                            value));
1301
1302       TREE_OVERFLOW (t)
1303         = (force_fit_type (t, 0)
1304            | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1305       TREE_CONSTANT_OVERFLOW (t)
1306         = TREE_OVERFLOW (t)
1307           | TREE_CONSTANT_OVERFLOW (arg1)
1308           | TREE_CONSTANT_OVERFLOW (arg2);
1309       return t;
1310     }
1311   if (TREE_CODE (arg1) == COMPLEX_CST)
1312     {
1313       tree type = TREE_TYPE (arg1);
1314       tree r1 = TREE_REALPART (arg1);
1315       tree i1 = TREE_IMAGPART (arg1);
1316       tree r2 = TREE_REALPART (arg2);
1317       tree i2 = TREE_IMAGPART (arg2);
1318       tree t;
1319
1320       switch (code)
1321         {
1322         case PLUS_EXPR:
1323           t = build_complex (type,
1324                              const_binop (PLUS_EXPR, r1, r2, notrunc),
1325                              const_binop (PLUS_EXPR, i1, i2, notrunc));
1326           break;
1327
1328         case MINUS_EXPR:
1329           t = build_complex (type,
1330                              const_binop (MINUS_EXPR, r1, r2, notrunc),
1331                              const_binop (MINUS_EXPR, i1, i2, notrunc));
1332           break;
1333
1334         case MULT_EXPR:
1335           t = build_complex (type,
1336                              const_binop (MINUS_EXPR,
1337                                           const_binop (MULT_EXPR,
1338                                                        r1, r2, notrunc),
1339                                           const_binop (MULT_EXPR,
1340                                                        i1, i2, notrunc),
1341                                           notrunc),
1342                              const_binop (PLUS_EXPR,
1343                                           const_binop (MULT_EXPR,
1344                                                        r1, i2, notrunc),
1345                                           const_binop (MULT_EXPR,
1346                                                        i1, r2, notrunc),
1347                                           notrunc));
1348           break;
1349
1350         case RDIV_EXPR:
1351           {
1352             tree magsquared
1353               = const_binop (PLUS_EXPR,
1354                              const_binop (MULT_EXPR, r2, r2, notrunc),
1355                              const_binop (MULT_EXPR, i2, i2, notrunc),
1356                              notrunc);
1357
1358             t = build_complex (type,
1359                                const_binop
1360                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1361                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1362                                 const_binop (PLUS_EXPR,
1363                                              const_binop (MULT_EXPR, r1, r2,
1364                                                           notrunc),
1365                                              const_binop (MULT_EXPR, i1, i2,
1366                                                           notrunc),
1367                                              notrunc),
1368                                 magsquared, notrunc),
1369                                const_binop
1370                                (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1371                                 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1372                                 const_binop (MINUS_EXPR,
1373                                              const_binop (MULT_EXPR, i1, r2,
1374                                                           notrunc),
1375                                              const_binop (MULT_EXPR, r1, i2,
1376                                                           notrunc),
1377                                              notrunc),
1378                                 magsquared, notrunc));
1379           }
1380           break;
1381
1382         default:
1383           abort ();
1384         }
1385       return t;
1386     }
1387   return 0;
1388 }
1389
1390 /* These are the hash table functions for the hash table of INTEGER_CST
1391    nodes of a sizetype.  */
1392
1393 /* Return the hash code code X, an INTEGER_CST.  */
1394
1395 static hashval_t
1396 size_htab_hash (x)
1397      const void *x;
1398 {
1399   tree t = (tree) x;
1400
1401   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1402           ^ htab_hash_pointer (TREE_TYPE (t))
1403           ^ (TREE_OVERFLOW (t) << 20));
1404 }
1405
1406 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1407    is the same as that given by *Y, which is the same.  */
1408
1409 static int
1410 size_htab_eq (x, y)
1411      const void *x;
1412      const void *y;
1413 {
1414   tree xt = (tree) x;
1415   tree yt = (tree) y;
1416
1417   return (TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1418           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt)
1419           && TREE_TYPE (xt) == TREE_TYPE (yt)
1420           && TREE_OVERFLOW (xt) == TREE_OVERFLOW (yt));
1421 }
1422 \f
1423 /* Return an INTEGER_CST with value whose low-order HOST_BITS_PER_WIDE_INT
1424    bits are given by NUMBER and of the sizetype represented by KIND.  */
1425
1426 tree
1427 size_int_wide (number, kind)
1428      HOST_WIDE_INT number;
1429      enum size_type_kind kind;
1430 {
1431   return size_int_type_wide (number, sizetype_tab[(int) kind]);
1432 }
1433
1434 /* Likewise, but the desired type is specified explicitly.  */
1435
1436 static GTY (()) tree new_const;
1437 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
1438      htab_t size_htab;
1439
1440 tree
1441 size_int_type_wide (number, type)
1442      HOST_WIDE_INT number;
1443      tree type;
1444 {
1445   PTR *slot;
1446
1447   if (size_htab == 0)
1448     {
1449       size_htab = htab_create_ggc (1024, size_htab_hash, size_htab_eq, NULL);
1450       new_const = make_node (INTEGER_CST);
1451     }
1452
1453   /* Adjust NEW_CONST to be the constant we want.  If it's already in the
1454      hash table, we return the value from the hash table.  Otherwise, we
1455      place that in the hash table and make a new node for the next time.  */
1456   TREE_INT_CST_LOW (new_const) = number;
1457   TREE_INT_CST_HIGH (new_const) = number < 0 ? -1 : 0;
1458   TREE_TYPE (new_const) = type;
1459   TREE_OVERFLOW (new_const) = TREE_CONSTANT_OVERFLOW (new_const)
1460     = force_fit_type (new_const, 0);
1461
1462   slot = htab_find_slot (size_htab, new_const, INSERT);
1463   if (*slot == 0)
1464     {
1465       tree t = new_const;
1466
1467       *slot = (PTR) new_const;
1468       new_const = make_node (INTEGER_CST);
1469       return t;
1470     }
1471   else
1472     return (tree) *slot;
1473 }
1474
1475 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1476    is a tree code.  The type of the result is taken from the operands.
1477    Both must be the same type integer type and it must be a size type.
1478    If the operands are constant, so is the result.  */
1479
1480 tree
1481 size_binop (code, arg0, arg1)
1482      enum tree_code code;
1483      tree arg0, arg1;
1484 {
1485   tree type = TREE_TYPE (arg0);
1486
1487   if (TREE_CODE (type) != INTEGER_TYPE || ! TYPE_IS_SIZETYPE (type)
1488       || type != TREE_TYPE (arg1))
1489     abort ();
1490
1491   /* Handle the special case of two integer constants faster.  */
1492   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1493     {
1494       /* And some specific cases even faster than that.  */
1495       if (code == PLUS_EXPR && integer_zerop (arg0))
1496         return arg1;
1497       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1498                && integer_zerop (arg1))
1499         return arg0;
1500       else if (code == MULT_EXPR && integer_onep (arg0))
1501         return arg1;
1502
1503       /* Handle general case of two integer constants.  */
1504       return int_const_binop (code, arg0, arg1, 0);
1505     }
1506
1507   if (arg0 == error_mark_node || arg1 == error_mark_node)
1508     return error_mark_node;
1509
1510   return fold (build (code, type, arg0, arg1));
1511 }
1512
1513 /* Given two values, either both of sizetype or both of bitsizetype,
1514    compute the difference between the two values.  Return the value
1515    in signed type corresponding to the type of the operands.  */
1516
1517 tree
1518 size_diffop (arg0, arg1)
1519      tree arg0, arg1;
1520 {
1521   tree type = TREE_TYPE (arg0);
1522   tree ctype;
1523
1524   if (TREE_CODE (type) != INTEGER_TYPE || ! TYPE_IS_SIZETYPE (type)
1525       || type != TREE_TYPE (arg1))
1526     abort ();
1527
1528   /* If the type is already signed, just do the simple thing.  */
1529   if (! TREE_UNSIGNED (type))
1530     return size_binop (MINUS_EXPR, arg0, arg1);
1531
1532   ctype = (type == bitsizetype || type == ubitsizetype
1533            ? sbitsizetype : ssizetype);
1534
1535   /* If either operand is not a constant, do the conversions to the signed
1536      type and subtract.  The hardware will do the right thing with any
1537      overflow in the subtraction.  */
1538   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1539     return size_binop (MINUS_EXPR, convert (ctype, arg0),
1540                        convert (ctype, arg1));
1541
1542   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1543      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1544      overflow) and negate (which can't either).  Special-case a result
1545      of zero while we're here.  */
1546   if (tree_int_cst_equal (arg0, arg1))
1547     return convert (ctype, integer_zero_node);
1548   else if (tree_int_cst_lt (arg1, arg0))
1549     return convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
1550   else
1551     return size_binop (MINUS_EXPR, convert (ctype, integer_zero_node),
1552                        convert (ctype, size_binop (MINUS_EXPR, arg1, arg0)));
1553 }
1554 \f
1555
1556 /* Given T, a tree representing type conversion of ARG1, a constant,
1557    return a constant tree representing the result of conversion.  */
1558
1559 static tree
1560 fold_convert (t, arg1)
1561      tree t;
1562      tree arg1;
1563 {
1564   tree type = TREE_TYPE (t);
1565   int overflow = 0;
1566
1567   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1568     {
1569       if (TREE_CODE (arg1) == INTEGER_CST)
1570         {
1571           /* If we would build a constant wider than GCC supports,
1572              leave the conversion unfolded.  */
1573           if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1574             return t;
1575
1576           /* If we are trying to make a sizetype for a small integer, use
1577              size_int to pick up cached types to reduce duplicate nodes.  */
1578           if (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1579               && !TREE_CONSTANT_OVERFLOW (arg1)
1580               && compare_tree_int (arg1, 10000) < 0)
1581             return size_int_type_wide (TREE_INT_CST_LOW (arg1), type);
1582
1583           /* Given an integer constant, make new constant with new type,
1584              appropriately sign-extended or truncated.  */
1585           t = build_int_2 (TREE_INT_CST_LOW (arg1),
1586                            TREE_INT_CST_HIGH (arg1));
1587           TREE_TYPE (t) = type;
1588           /* Indicate an overflow if (1) ARG1 already overflowed,
1589              or (2) force_fit_type indicates an overflow.
1590              Tell force_fit_type that an overflow has already occurred
1591              if ARG1 is a too-large unsigned value and T is signed.
1592              But don't indicate an overflow if converting a pointer.  */
1593           TREE_OVERFLOW (t)
1594             = ((force_fit_type (t,
1595                                 (TREE_INT_CST_HIGH (arg1) < 0
1596                                  && (TREE_UNSIGNED (type)
1597                                     < TREE_UNSIGNED (TREE_TYPE (arg1)))))
1598                 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
1599                || TREE_OVERFLOW (arg1));
1600           TREE_CONSTANT_OVERFLOW (t)
1601             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1602         }
1603       else if (TREE_CODE (arg1) == REAL_CST)
1604         {
1605           /* Don't initialize these, use assignments.
1606              Initialized local aggregates don't work on old compilers.  */
1607           REAL_VALUE_TYPE x;
1608           REAL_VALUE_TYPE l;
1609           REAL_VALUE_TYPE u;
1610           tree type1 = TREE_TYPE (arg1);
1611           int no_upper_bound;
1612
1613           x = TREE_REAL_CST (arg1);
1614           l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
1615
1616           no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
1617           if (!no_upper_bound)
1618             u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
1619
1620           /* See if X will be in range after truncation towards 0.
1621              To compensate for truncation, move the bounds away from 0,
1622              but reject if X exactly equals the adjusted bounds.  */
1623           REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
1624           if (!no_upper_bound)
1625             REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
1626           /* If X is a NaN, use zero instead and show we have an overflow.
1627              Otherwise, range check.  */
1628           if (REAL_VALUE_ISNAN (x))
1629             overflow = 1, x = dconst0;
1630           else if (! (REAL_VALUES_LESS (l, x)
1631                       && !no_upper_bound
1632                       && REAL_VALUES_LESS (x, u)))
1633             overflow = 1;
1634
1635           {
1636             HOST_WIDE_INT low, high;
1637             REAL_VALUE_TO_INT (&low, &high, x);
1638             t = build_int_2 (low, high);
1639           }
1640           TREE_TYPE (t) = type;
1641           TREE_OVERFLOW (t)
1642             = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1643           TREE_CONSTANT_OVERFLOW (t)
1644             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1645         }
1646       TREE_TYPE (t) = type;
1647     }
1648   else if (TREE_CODE (type) == REAL_TYPE)
1649     {
1650       if (TREE_CODE (arg1) == INTEGER_CST)
1651         return build_real_from_int_cst (type, arg1);
1652       if (TREE_CODE (arg1) == REAL_CST)
1653         {
1654           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
1655             {
1656               /* We make a copy of ARG1 so that we don't modify an
1657                  existing constant tree.  */
1658               t = copy_node (arg1);
1659               TREE_TYPE (t) = type;
1660               return t;
1661             }
1662
1663           t = build_real (type,
1664                           real_value_truncate (TYPE_MODE (type),
1665                                                TREE_REAL_CST (arg1)));
1666
1667           TREE_OVERFLOW (t)
1668             = TREE_OVERFLOW (arg1) | force_fit_type (t, 0);
1669           TREE_CONSTANT_OVERFLOW (t)
1670             = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1671           return t;
1672         }
1673     }
1674   TREE_CONSTANT (t) = 1;
1675   return t;
1676 }
1677 \f
1678 /* Return an expr equal to X but certainly not valid as an lvalue.  */
1679
1680 tree
1681 non_lvalue (x)
1682      tree x;
1683 {
1684   tree result;
1685
1686   /* These things are certainly not lvalues.  */
1687   if (TREE_CODE (x) == NON_LVALUE_EXPR
1688       || TREE_CODE (x) == INTEGER_CST
1689       || TREE_CODE (x) == REAL_CST
1690       || TREE_CODE (x) == STRING_CST
1691       || TREE_CODE (x) == ADDR_EXPR)
1692     return x;
1693
1694   result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1695   TREE_CONSTANT (result) = TREE_CONSTANT (x);
1696   return result;
1697 }
1698
1699 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
1700    Zero means allow extended lvalues.  */
1701
1702 int pedantic_lvalues;
1703
1704 /* When pedantic, return an expr equal to X but certainly not valid as a
1705    pedantic lvalue.  Otherwise, return X.  */
1706
1707 tree
1708 pedantic_non_lvalue (x)
1709      tree x;
1710 {
1711   if (pedantic_lvalues)
1712     return non_lvalue (x);
1713   else
1714     return x;
1715 }
1716 \f
1717 /* Given a tree comparison code, return the code that is the logical inverse
1718    of the given code.  It is not safe to do this for floating-point
1719    comparisons, except for NE_EXPR and EQ_EXPR.  */
1720
1721 static enum tree_code
1722 invert_tree_comparison (code)
1723      enum tree_code code;
1724 {
1725   switch (code)
1726     {
1727     case EQ_EXPR:
1728       return NE_EXPR;
1729     case NE_EXPR:
1730       return EQ_EXPR;
1731     case GT_EXPR:
1732       return LE_EXPR;
1733     case GE_EXPR:
1734       return LT_EXPR;
1735     case LT_EXPR:
1736       return GE_EXPR;
1737     case LE_EXPR:
1738       return GT_EXPR;
1739     default:
1740       abort ();
1741     }
1742 }
1743
1744 /* Similar, but return the comparison that results if the operands are
1745    swapped.  This is safe for floating-point.  */
1746
1747 static enum tree_code
1748 swap_tree_comparison (code)
1749      enum tree_code code;
1750 {
1751   switch (code)
1752     {
1753     case EQ_EXPR:
1754     case NE_EXPR:
1755       return code;
1756     case GT_EXPR:
1757       return LT_EXPR;
1758     case GE_EXPR:
1759       return LE_EXPR;
1760     case LT_EXPR:
1761       return GT_EXPR;
1762     case LE_EXPR:
1763       return GE_EXPR;
1764     default:
1765       abort ();
1766     }
1767 }
1768
1769
1770 /* Convert a comparison tree code from an enum tree_code representation
1771    into a compcode bit-based encoding.  This function is the inverse of
1772    compcode_to_comparison.  */
1773
1774 static int
1775 comparison_to_compcode (code)
1776      enum tree_code code;
1777 {
1778   switch (code)
1779     {
1780     case LT_EXPR:
1781       return COMPCODE_LT;
1782     case EQ_EXPR:
1783       return COMPCODE_EQ;
1784     case LE_EXPR:
1785       return COMPCODE_LE;
1786     case GT_EXPR:
1787       return COMPCODE_GT;
1788     case NE_EXPR:
1789       return COMPCODE_NE;
1790     case GE_EXPR:
1791       return COMPCODE_GE;
1792     default:
1793       abort ();
1794     }
1795 }
1796
1797 /* Convert a compcode bit-based encoding of a comparison operator back
1798    to GCC's enum tree_code representation.  This function is the
1799    inverse of comparison_to_compcode.  */
1800
1801 static enum tree_code
1802 compcode_to_comparison (code)
1803      int code;
1804 {
1805   switch (code)
1806     {
1807     case COMPCODE_LT:
1808       return LT_EXPR;
1809     case COMPCODE_EQ:
1810       return EQ_EXPR;
1811     case COMPCODE_LE:
1812       return LE_EXPR;
1813     case COMPCODE_GT:
1814       return GT_EXPR;
1815     case COMPCODE_NE:
1816       return NE_EXPR;
1817     case COMPCODE_GE:
1818       return GE_EXPR;
1819     default:
1820       abort ();
1821     }
1822 }
1823
1824 /* Return nonzero if CODE is a tree code that represents a truth value.  */
1825
1826 static int
1827 truth_value_p (code)
1828      enum tree_code code;
1829 {
1830   return (TREE_CODE_CLASS (code) == '<'
1831           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
1832           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
1833           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
1834 }
1835 \f
1836 /* Return nonzero if two operands are necessarily equal.
1837    If ONLY_CONST is nonzero, only return nonzero for constants.
1838    This function tests whether the operands are indistinguishable;
1839    it does not test whether they are equal using C's == operation.
1840    The distinction is important for IEEE floating point, because
1841    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
1842    (2) two NaNs may be indistinguishable, but NaN!=NaN.  */
1843
1844 int
1845 operand_equal_p (arg0, arg1, only_const)
1846      tree arg0, arg1;
1847      int only_const;
1848 {
1849   /* If both types don't have the same signedness, then we can't consider
1850      them equal.  We must check this before the STRIP_NOPS calls
1851      because they may change the signedness of the arguments.  */
1852   if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
1853     return 0;
1854
1855   STRIP_NOPS (arg0);
1856   STRIP_NOPS (arg1);
1857
1858   if (TREE_CODE (arg0) != TREE_CODE (arg1)
1859       /* This is needed for conversions and for COMPONENT_REF.
1860          Might as well play it safe and always test this.  */
1861       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
1862       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
1863       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
1864     return 0;
1865
1866   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1867      We don't care about side effects in that case because the SAVE_EXPR
1868      takes care of that for us. In all other cases, two expressions are
1869      equal if they have no side effects.  If we have two identical
1870      expressions with side effects that should be treated the same due
1871      to the only side effects being identical SAVE_EXPR's, that will
1872      be detected in the recursive calls below.  */
1873   if (arg0 == arg1 && ! only_const
1874       && (TREE_CODE (arg0) == SAVE_EXPR
1875           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
1876     return 1;
1877
1878   /* Next handle constant cases, those for which we can return 1 even
1879      if ONLY_CONST is set.  */
1880   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
1881     switch (TREE_CODE (arg0))
1882       {
1883       case INTEGER_CST:
1884         return (! TREE_CONSTANT_OVERFLOW (arg0)
1885                 && ! TREE_CONSTANT_OVERFLOW (arg1)
1886                 && tree_int_cst_equal (arg0, arg1));
1887
1888       case REAL_CST:
1889         return (! TREE_CONSTANT_OVERFLOW (arg0)
1890                 && ! TREE_CONSTANT_OVERFLOW (arg1)
1891                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
1892                                           TREE_REAL_CST (arg1)));
1893
1894       case VECTOR_CST:
1895         {
1896           tree v1, v2;
1897
1898           if (TREE_CONSTANT_OVERFLOW (arg0)
1899               || TREE_CONSTANT_OVERFLOW (arg1))
1900             return 0;
1901
1902           v1 = TREE_VECTOR_CST_ELTS (arg0);
1903           v2 = TREE_VECTOR_CST_ELTS (arg1);
1904           while (v1 && v2)
1905             {
1906               if (!operand_equal_p (v1, v2, only_const))
1907                 return 0;
1908               v1 = TREE_CHAIN (v1);
1909               v2 = TREE_CHAIN (v2);
1910             }
1911
1912           return 1;
1913         }
1914
1915       case COMPLEX_CST:
1916         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
1917                                  only_const)
1918                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
1919                                     only_const));
1920
1921       case STRING_CST:
1922         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
1923                 && ! memcmp (TREE_STRING_POINTER (arg0),
1924                               TREE_STRING_POINTER (arg1),
1925                               TREE_STRING_LENGTH (arg0)));
1926
1927       case ADDR_EXPR:
1928         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
1929                                 0);
1930       default:
1931         break;
1932       }
1933
1934   if (only_const)
1935     return 0;
1936
1937   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
1938     {
1939     case '1':
1940       /* Two conversions are equal only if signedness and modes match.  */
1941       if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
1942           && (TREE_UNSIGNED (TREE_TYPE (arg0))
1943               != TREE_UNSIGNED (TREE_TYPE (arg1))))
1944         return 0;
1945
1946       return operand_equal_p (TREE_OPERAND (arg0, 0),
1947                               TREE_OPERAND (arg1, 0), 0);
1948
1949     case '<':
1950     case '2':
1951       if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
1952           && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
1953                               0))
1954         return 1;
1955
1956       /* For commutative ops, allow the other order.  */
1957       return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
1958                || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
1959                || TREE_CODE (arg0) == BIT_IOR_EXPR
1960                || TREE_CODE (arg0) == BIT_XOR_EXPR
1961                || TREE_CODE (arg0) == BIT_AND_EXPR
1962                || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
1963               && operand_equal_p (TREE_OPERAND (arg0, 0),
1964                                   TREE_OPERAND (arg1, 1), 0)
1965               && operand_equal_p (TREE_OPERAND (arg0, 1),
1966                                   TREE_OPERAND (arg1, 0), 0));
1967
1968     case 'r':
1969       /* If either of the pointer (or reference) expressions we are dereferencing
1970          contain a side effect, these cannot be equal.  */
1971       if (TREE_SIDE_EFFECTS (arg0)
1972           || TREE_SIDE_EFFECTS (arg1))
1973         return 0;
1974
1975       switch (TREE_CODE (arg0))
1976         {
1977         case INDIRECT_REF:
1978           return operand_equal_p (TREE_OPERAND (arg0, 0),
1979                                   TREE_OPERAND (arg1, 0), 0);
1980
1981         case COMPONENT_REF:
1982         case ARRAY_REF:
1983         case ARRAY_RANGE_REF:
1984           return (operand_equal_p (TREE_OPERAND (arg0, 0),
1985                                    TREE_OPERAND (arg1, 0), 0)
1986                   && operand_equal_p (TREE_OPERAND (arg0, 1),
1987                                       TREE_OPERAND (arg1, 1), 0));
1988
1989         case BIT_FIELD_REF:
1990           return (operand_equal_p (TREE_OPERAND (arg0, 0),
1991                                    TREE_OPERAND (arg1, 0), 0)
1992                   && operand_equal_p (TREE_OPERAND (arg0, 1),
1993                                       TREE_OPERAND (arg1, 1), 0)
1994                   && operand_equal_p (TREE_OPERAND (arg0, 2),
1995                                       TREE_OPERAND (arg1, 2), 0));
1996         default:
1997           return 0;
1998         }
1999
2000     case 'e':
2001       if (TREE_CODE (arg0) == RTL_EXPR)
2002         return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
2003       return 0;
2004
2005     default:
2006       return 0;
2007     }
2008 }
2009 \f
2010 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2011    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2012
2013    When in doubt, return 0.  */
2014
2015 static int
2016 operand_equal_for_comparison_p (arg0, arg1, other)
2017      tree arg0, arg1;
2018      tree other;
2019 {
2020   int unsignedp1, unsignedpo;
2021   tree primarg0, primarg1, primother;
2022   unsigned int correct_width;
2023
2024   if (operand_equal_p (arg0, arg1, 0))
2025     return 1;
2026
2027   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2028       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2029     return 0;
2030
2031   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2032      and see if the inner values are the same.  This removes any
2033      signedness comparison, which doesn't matter here.  */
2034   primarg0 = arg0, primarg1 = arg1;
2035   STRIP_NOPS (primarg0);
2036   STRIP_NOPS (primarg1);
2037   if (operand_equal_p (primarg0, primarg1, 0))
2038     return 1;
2039
2040   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2041      actual comparison operand, ARG0.
2042
2043      First throw away any conversions to wider types
2044      already present in the operands.  */
2045
2046   primarg1 = get_narrower (arg1, &unsignedp1);
2047   primother = get_narrower (other, &unsignedpo);
2048
2049   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2050   if (unsignedp1 == unsignedpo
2051       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2052       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2053     {
2054       tree type = TREE_TYPE (arg0);
2055
2056       /* Make sure shorter operand is extended the right way
2057          to match the longer operand.  */
2058       primarg1 = convert ((*lang_hooks.types.signed_or_unsigned_type)
2059                           (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2060
2061       if (operand_equal_p (arg0, convert (type, primarg1), 0))
2062         return 1;
2063     }
2064
2065   return 0;
2066 }
2067 \f
2068 /* See if ARG is an expression that is either a comparison or is performing
2069    arithmetic on comparisons.  The comparisons must only be comparing
2070    two different values, which will be stored in *CVAL1 and *CVAL2; if
2071    they are nonzero it means that some operands have already been found.
2072    No variables may be used anywhere else in the expression except in the
2073    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2074    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2075
2076    If this is true, return 1.  Otherwise, return zero.  */
2077
2078 static int
2079 twoval_comparison_p (arg, cval1, cval2, save_p)
2080      tree arg;
2081      tree *cval1, *cval2;
2082      int *save_p;
2083 {
2084   enum tree_code code = TREE_CODE (arg);
2085   char class = TREE_CODE_CLASS (code);
2086
2087   /* We can handle some of the 'e' cases here.  */
2088   if (class == 'e' && code == TRUTH_NOT_EXPR)
2089     class = '1';
2090   else if (class == 'e'
2091            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2092                || code == COMPOUND_EXPR))
2093     class = '2';
2094
2095   else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0
2096            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2097     {
2098       /* If we've already found a CVAL1 or CVAL2, this expression is
2099          two complex to handle.  */
2100       if (*cval1 || *cval2)
2101         return 0;
2102
2103       class = '1';
2104       *save_p = 1;
2105     }
2106
2107   switch (class)
2108     {
2109     case '1':
2110       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2111
2112     case '2':
2113       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2114               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2115                                       cval1, cval2, save_p));
2116
2117     case 'c':
2118       return 1;
2119
2120     case 'e':
2121       if (code == COND_EXPR)
2122         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2123                                      cval1, cval2, save_p)
2124                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2125                                         cval1, cval2, save_p)
2126                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2127                                         cval1, cval2, save_p));
2128       return 0;
2129
2130     case '<':
2131       /* First see if we can handle the first operand, then the second.  For
2132          the second operand, we know *CVAL1 can't be zero.  It must be that
2133          one side of the comparison is each of the values; test for the
2134          case where this isn't true by failing if the two operands
2135          are the same.  */
2136
2137       if (operand_equal_p (TREE_OPERAND (arg, 0),
2138                            TREE_OPERAND (arg, 1), 0))
2139         return 0;
2140
2141       if (*cval1 == 0)
2142         *cval1 = TREE_OPERAND (arg, 0);
2143       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2144         ;
2145       else if (*cval2 == 0)
2146         *cval2 = TREE_OPERAND (arg, 0);
2147       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2148         ;
2149       else
2150         return 0;
2151
2152       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2153         ;
2154       else if (*cval2 == 0)
2155         *cval2 = TREE_OPERAND (arg, 1);
2156       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2157         ;
2158       else
2159         return 0;
2160
2161       return 1;
2162
2163     default:
2164       return 0;
2165     }
2166 }
2167 \f
2168 /* ARG is a tree that is known to contain just arithmetic operations and
2169    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2170    any occurrence of OLD0 as an operand of a comparison and likewise for
2171    NEW1 and OLD1.  */
2172
2173 static tree
2174 eval_subst (arg, old0, new0, old1, new1)
2175      tree arg;
2176      tree old0, new0, old1, new1;
2177 {
2178   tree type = TREE_TYPE (arg);
2179   enum tree_code code = TREE_CODE (arg);
2180   char class = TREE_CODE_CLASS (code);
2181
2182   /* We can handle some of the 'e' cases here.  */
2183   if (class == 'e' && code == TRUTH_NOT_EXPR)
2184     class = '1';
2185   else if (class == 'e'
2186            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2187     class = '2';
2188
2189   switch (class)
2190     {
2191     case '1':
2192       return fold (build1 (code, type,
2193                            eval_subst (TREE_OPERAND (arg, 0),
2194                                        old0, new0, old1, new1)));
2195
2196     case '2':
2197       return fold (build (code, type,
2198                           eval_subst (TREE_OPERAND (arg, 0),
2199                                       old0, new0, old1, new1),
2200                           eval_subst (TREE_OPERAND (arg, 1),
2201                                       old0, new0, old1, new1)));
2202
2203     case 'e':
2204       switch (code)
2205         {
2206         case SAVE_EXPR:
2207           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2208
2209         case COMPOUND_EXPR:
2210           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2211
2212         case COND_EXPR:
2213           return fold (build (code, type,
2214                               eval_subst (TREE_OPERAND (arg, 0),
2215                                           old0, new0, old1, new1),
2216                               eval_subst (TREE_OPERAND (arg, 1),
2217                                           old0, new0, old1, new1),
2218                               eval_subst (TREE_OPERAND (arg, 2),
2219                                           old0, new0, old1, new1)));
2220         default:
2221           break;
2222         }
2223       /* fall through - ??? */
2224
2225     case '<':
2226       {
2227         tree arg0 = TREE_OPERAND (arg, 0);
2228         tree arg1 = TREE_OPERAND (arg, 1);
2229
2230         /* We need to check both for exact equality and tree equality.  The
2231            former will be true if the operand has a side-effect.  In that
2232            case, we know the operand occurred exactly once.  */
2233
2234         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2235           arg0 = new0;
2236         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2237           arg0 = new1;
2238
2239         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2240           arg1 = new0;
2241         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2242           arg1 = new1;
2243
2244         return fold (build (code, type, arg0, arg1));
2245       }
2246
2247     default:
2248       return arg;
2249     }
2250 }
2251 \f
2252 /* Return a tree for the case when the result of an expression is RESULT
2253    converted to TYPE and OMITTED was previously an operand of the expression
2254    but is now not needed (e.g., we folded OMITTED * 0).
2255
2256    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2257    the conversion of RESULT to TYPE.  */
2258
2259 static tree
2260 omit_one_operand (type, result, omitted)
2261      tree type, result, omitted;
2262 {
2263   tree t = convert (type, result);
2264
2265   if (TREE_SIDE_EFFECTS (omitted))
2266     return build (COMPOUND_EXPR, type, omitted, t);
2267
2268   return non_lvalue (t);
2269 }
2270
2271 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2272
2273 static tree
2274 pedantic_omit_one_operand (type, result, omitted)
2275      tree type, result, omitted;
2276 {
2277   tree t = convert (type, result);
2278
2279   if (TREE_SIDE_EFFECTS (omitted))
2280     return build (COMPOUND_EXPR, type, omitted, t);
2281
2282   return pedantic_non_lvalue (t);
2283 }
2284 \f
2285 /* Return a simplified tree node for the truth-negation of ARG.  This
2286    never alters ARG itself.  We assume that ARG is an operation that
2287    returns a truth value (0 or 1).  */
2288
2289 tree
2290 invert_truthvalue (arg)
2291      tree arg;
2292 {
2293   tree type = TREE_TYPE (arg);
2294   enum tree_code code = TREE_CODE (arg);
2295
2296   if (code == ERROR_MARK)
2297     return arg;
2298
2299   /* If this is a comparison, we can simply invert it, except for
2300      floating-point non-equality comparisons, in which case we just
2301      enclose a TRUTH_NOT_EXPR around what we have.  */
2302
2303   if (TREE_CODE_CLASS (code) == '<')
2304     {
2305       if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
2306           && !flag_unsafe_math_optimizations
2307           && code != NE_EXPR
2308           && code != EQ_EXPR)
2309         return build1 (TRUTH_NOT_EXPR, type, arg);
2310       else
2311         return build (invert_tree_comparison (code), type,
2312                       TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2313     }
2314
2315   switch (code)
2316     {
2317     case INTEGER_CST:
2318       return convert (type, build_int_2 (integer_zerop (arg), 0));
2319
2320     case TRUTH_AND_EXPR:
2321       return build (TRUTH_OR_EXPR, type,
2322                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2323                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2324
2325     case TRUTH_OR_EXPR:
2326       return build (TRUTH_AND_EXPR, type,
2327                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2328                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2329
2330     case TRUTH_XOR_EXPR:
2331       /* Here we can invert either operand.  We invert the first operand
2332          unless the second operand is a TRUTH_NOT_EXPR in which case our
2333          result is the XOR of the first operand with the inside of the
2334          negation of the second operand.  */
2335
2336       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2337         return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2338                       TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2339       else
2340         return build (TRUTH_XOR_EXPR, type,
2341                       invert_truthvalue (TREE_OPERAND (arg, 0)),
2342                       TREE_OPERAND (arg, 1));
2343
2344     case TRUTH_ANDIF_EXPR:
2345       return build (TRUTH_ORIF_EXPR, type,
2346                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2347                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2348
2349     case TRUTH_ORIF_EXPR:
2350       return build (TRUTH_ANDIF_EXPR, type,
2351                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2352                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2353
2354     case TRUTH_NOT_EXPR:
2355       return TREE_OPERAND (arg, 0);
2356
2357     case COND_EXPR:
2358       return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2359                     invert_truthvalue (TREE_OPERAND (arg, 1)),
2360                     invert_truthvalue (TREE_OPERAND (arg, 2)));
2361
2362     case COMPOUND_EXPR:
2363       return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2364                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2365
2366     case WITH_RECORD_EXPR:
2367       return build (WITH_RECORD_EXPR, type,
2368                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2369                     TREE_OPERAND (arg, 1));
2370
2371     case NON_LVALUE_EXPR:
2372       return invert_truthvalue (TREE_OPERAND (arg, 0));
2373
2374     case NOP_EXPR:
2375     case CONVERT_EXPR:
2376     case FLOAT_EXPR:
2377       return build1 (TREE_CODE (arg), type,
2378                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2379
2380     case BIT_AND_EXPR:
2381       if (!integer_onep (TREE_OPERAND (arg, 1)))
2382         break;
2383       return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2384
2385     case SAVE_EXPR:
2386       return build1 (TRUTH_NOT_EXPR, type, arg);
2387
2388     case CLEANUP_POINT_EXPR:
2389       return build1 (CLEANUP_POINT_EXPR, type,
2390                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2391
2392     default:
2393       break;
2394     }
2395   if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2396     abort ();
2397   return build1 (TRUTH_NOT_EXPR, type, arg);
2398 }
2399
2400 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2401    operands are another bit-wise operation with a common input.  If so,
2402    distribute the bit operations to save an operation and possibly two if
2403    constants are involved.  For example, convert
2404         (A | B) & (A | C) into A | (B & C)
2405    Further simplification will occur if B and C are constants.
2406
2407    If this optimization cannot be done, 0 will be returned.  */
2408
2409 static tree
2410 distribute_bit_expr (code, type, arg0, arg1)
2411      enum tree_code code;
2412      tree type;
2413      tree arg0, arg1;
2414 {
2415   tree common;
2416   tree left, right;
2417
2418   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2419       || TREE_CODE (arg0) == code
2420       || (TREE_CODE (arg0) != BIT_AND_EXPR
2421           && TREE_CODE (arg0) != BIT_IOR_EXPR))
2422     return 0;
2423
2424   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2425     {
2426       common = TREE_OPERAND (arg0, 0);
2427       left = TREE_OPERAND (arg0, 1);
2428       right = TREE_OPERAND (arg1, 1);
2429     }
2430   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2431     {
2432       common = TREE_OPERAND (arg0, 0);
2433       left = TREE_OPERAND (arg0, 1);
2434       right = TREE_OPERAND (arg1, 0);
2435     }
2436   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2437     {
2438       common = TREE_OPERAND (arg0, 1);
2439       left = TREE_OPERAND (arg0, 0);
2440       right = TREE_OPERAND (arg1, 1);
2441     }
2442   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2443     {
2444       common = TREE_OPERAND (arg0, 1);
2445       left = TREE_OPERAND (arg0, 0);
2446       right = TREE_OPERAND (arg1, 0);
2447     }
2448   else
2449     return 0;
2450
2451   return fold (build (TREE_CODE (arg0), type, common,
2452                       fold (build (code, type, left, right))));
2453 }
2454 \f
2455 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2456    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
2457
2458 static tree
2459 make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2460      tree inner;
2461      tree type;
2462      int bitsize, bitpos;
2463      int unsignedp;
2464 {
2465   tree result = build (BIT_FIELD_REF, type, inner,
2466                        size_int (bitsize), bitsize_int (bitpos));
2467
2468   TREE_UNSIGNED (result) = unsignedp;
2469
2470   return result;
2471 }
2472
2473 /* Optimize a bit-field compare.
2474
2475    There are two cases:  First is a compare against a constant and the
2476    second is a comparison of two items where the fields are at the same
2477    bit position relative to the start of a chunk (byte, halfword, word)
2478    large enough to contain it.  In these cases we can avoid the shift
2479    implicit in bitfield extractions.
2480
2481    For constants, we emit a compare of the shifted constant with the
2482    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2483    compared.  For two fields at the same position, we do the ANDs with the
2484    similar mask and compare the result of the ANDs.
2485
2486    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2487    COMPARE_TYPE is the type of the comparison, and LHS and RHS
2488    are the left and right operands of the comparison, respectively.
2489
2490    If the optimization described above can be done, we return the resulting
2491    tree.  Otherwise we return zero.  */
2492
2493 static tree
2494 optimize_bit_field_compare (code, compare_type, lhs, rhs)
2495      enum tree_code code;
2496      tree compare_type;
2497      tree lhs, rhs;
2498 {
2499   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
2500   tree type = TREE_TYPE (lhs);
2501   tree signed_type, unsigned_type;
2502   int const_p = TREE_CODE (rhs) == INTEGER_CST;
2503   enum machine_mode lmode, rmode, nmode;
2504   int lunsignedp, runsignedp;
2505   int lvolatilep = 0, rvolatilep = 0;
2506   tree linner, rinner = NULL_TREE;
2507   tree mask;
2508   tree offset;
2509
2510   /* Get all the information about the extractions being done.  If the bit size
2511      if the same as the size of the underlying object, we aren't doing an
2512      extraction at all and so can do nothing.  We also don't want to
2513      do anything if the inner expression is a PLACEHOLDER_EXPR since we
2514      then will no longer be able to replace it.  */
2515   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2516                                 &lunsignedp, &lvolatilep);
2517   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2518       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
2519     return 0;
2520
2521  if (!const_p)
2522    {
2523      /* If this is not a constant, we can only do something if bit positions,
2524         sizes, and signedness are the same.  */
2525      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2526                                    &runsignedp, &rvolatilep);
2527
2528      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2529          || lunsignedp != runsignedp || offset != 0
2530          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
2531        return 0;
2532    }
2533
2534   /* See if we can find a mode to refer to this field.  We should be able to,
2535      but fail if we can't.  */
2536   nmode = get_best_mode (lbitsize, lbitpos,
2537                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
2538                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
2539                                 TYPE_ALIGN (TREE_TYPE (rinner))),
2540                          word_mode, lvolatilep || rvolatilep);
2541   if (nmode == VOIDmode)
2542     return 0;
2543
2544   /* Set signed and unsigned types of the precision of this mode for the
2545      shifts below.  */
2546   signed_type = (*lang_hooks.types.type_for_mode) (nmode, 0);
2547   unsigned_type = (*lang_hooks.types.type_for_mode) (nmode, 1);
2548
2549   /* Compute the bit position and size for the new reference and our offset
2550      within it. If the new reference is the same size as the original, we
2551      won't optimize anything, so return zero.  */
2552   nbitsize = GET_MODE_BITSIZE (nmode);
2553   nbitpos = lbitpos & ~ (nbitsize - 1);
2554   lbitpos -= nbitpos;
2555   if (nbitsize == lbitsize)
2556     return 0;
2557
2558   if (BYTES_BIG_ENDIAN)
2559     lbitpos = nbitsize - lbitsize - lbitpos;
2560
2561   /* Make the mask to be used against the extracted field.  */
2562   mask = build_int_2 (~0, ~0);
2563   TREE_TYPE (mask) = unsigned_type;
2564   force_fit_type (mask, 0);
2565   mask = convert (unsigned_type, mask);
2566   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
2567   mask = const_binop (RSHIFT_EXPR, mask,
2568                       size_int (nbitsize - lbitsize - lbitpos), 0);
2569
2570   if (! const_p)
2571     /* If not comparing with constant, just rework the comparison
2572        and return.  */
2573     return build (code, compare_type,
2574                   build (BIT_AND_EXPR, unsigned_type,
2575                          make_bit_field_ref (linner, unsigned_type,
2576                                              nbitsize, nbitpos, 1),
2577                          mask),
2578                   build (BIT_AND_EXPR, unsigned_type,
2579                          make_bit_field_ref (rinner, unsigned_type,
2580                                              nbitsize, nbitpos, 1),
2581                          mask));
2582
2583   /* Otherwise, we are handling the constant case. See if the constant is too
2584      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
2585      this not only for its own sake, but to avoid having to test for this
2586      error case below.  If we didn't, we might generate wrong code.
2587
2588      For unsigned fields, the constant shifted right by the field length should
2589      be all zero.  For signed fields, the high-order bits should agree with
2590      the sign bit.  */
2591
2592   if (lunsignedp)
2593     {
2594       if (! integer_zerop (const_binop (RSHIFT_EXPR,
2595                                         convert (unsigned_type, rhs),
2596                                         size_int (lbitsize), 0)))
2597         {
2598           warning ("comparison is always %d due to width of bit-field",
2599                    code == NE_EXPR);
2600           return convert (compare_type,
2601                           (code == NE_EXPR
2602                            ? integer_one_node : integer_zero_node));
2603         }
2604     }
2605   else
2606     {
2607       tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
2608                               size_int (lbitsize - 1), 0);
2609       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2610         {
2611           warning ("comparison is always %d due to width of bit-field",
2612                    code == NE_EXPR);
2613           return convert (compare_type,
2614                           (code == NE_EXPR
2615                            ? integer_one_node : integer_zero_node));
2616         }
2617     }
2618
2619   /* Single-bit compares should always be against zero.  */
2620   if (lbitsize == 1 && ! integer_zerop (rhs))
2621     {
2622       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2623       rhs = convert (type, integer_zero_node);
2624     }
2625
2626   /* Make a new bitfield reference, shift the constant over the
2627      appropriate number of bits and mask it with the computed mask
2628      (in case this was a signed field).  If we changed it, make a new one.  */
2629   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
2630   if (lvolatilep)
2631     {
2632       TREE_SIDE_EFFECTS (lhs) = 1;
2633       TREE_THIS_VOLATILE (lhs) = 1;
2634     }
2635
2636   rhs = fold (const_binop (BIT_AND_EXPR,
2637                            const_binop (LSHIFT_EXPR,
2638                                         convert (unsigned_type, rhs),
2639                                         size_int (lbitpos), 0),
2640                            mask, 0));
2641
2642   return build (code, compare_type,
2643                 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
2644                 rhs);
2645 }
2646 \f
2647 /* Subroutine for fold_truthop: decode a field reference.
2648
2649    If EXP is a comparison reference, we return the innermost reference.
2650
2651    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2652    set to the starting bit number.
2653
2654    If the innermost field can be completely contained in a mode-sized
2655    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
2656
2657    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2658    otherwise it is not changed.
2659
2660    *PUNSIGNEDP is set to the signedness of the field.
2661
2662    *PMASK is set to the mask used.  This is either contained in a
2663    BIT_AND_EXPR or derived from the width of the field.
2664
2665    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
2666
2667    Return 0 if this is not a component reference or is one that we can't
2668    do anything with.  */
2669
2670 static tree
2671 decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
2672                         pvolatilep, pmask, pand_mask)
2673      tree exp;
2674      HOST_WIDE_INT *pbitsize, *pbitpos;
2675      enum machine_mode *pmode;
2676      int *punsignedp, *pvolatilep;
2677      tree *pmask;
2678      tree *pand_mask;
2679 {
2680   tree and_mask = 0;
2681   tree mask, inner, offset;
2682   tree unsigned_type;
2683   unsigned int precision;
2684
2685   /* All the optimizations using this function assume integer fields.
2686      There are problems with FP fields since the type_for_size call
2687      below can fail for, e.g., XFmode.  */
2688   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2689     return 0;
2690
2691   STRIP_NOPS (exp);
2692
2693   if (TREE_CODE (exp) == BIT_AND_EXPR)
2694     {
2695       and_mask = TREE_OPERAND (exp, 1);
2696       exp = TREE_OPERAND (exp, 0);
2697       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
2698       if (TREE_CODE (and_mask) != INTEGER_CST)
2699         return 0;
2700     }
2701
2702   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
2703                                punsignedp, pvolatilep);
2704   if ((inner == exp && and_mask == 0)
2705       || *pbitsize < 0 || offset != 0
2706       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
2707     return 0;
2708
2709   /* Compute the mask to access the bitfield.  */
2710   unsigned_type = (*lang_hooks.types.type_for_size) (*pbitsize, 1);
2711   precision = TYPE_PRECISION (unsigned_type);
2712
2713   mask = build_int_2 (~0, ~0);
2714   TREE_TYPE (mask) = unsigned_type;
2715   force_fit_type (mask, 0);
2716   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2717   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2718
2719   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
2720   if (and_mask != 0)
2721     mask = fold (build (BIT_AND_EXPR, unsigned_type,
2722                         convert (unsigned_type, and_mask), mask));
2723
2724   *pmask = mask;
2725   *pand_mask = and_mask;
2726   return inner;
2727 }
2728
2729 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
2730    bit positions.  */
2731
2732 static int
2733 all_ones_mask_p (mask, size)
2734      tree mask;
2735      int size;
2736 {
2737   tree type = TREE_TYPE (mask);
2738   unsigned int precision = TYPE_PRECISION (type);
2739   tree tmask;
2740
2741   tmask = build_int_2 (~0, ~0);
2742   TREE_TYPE (tmask) = (*lang_hooks.types.signed_type) (type);
2743   force_fit_type (tmask, 0);
2744   return
2745     tree_int_cst_equal (mask,
2746                         const_binop (RSHIFT_EXPR,
2747                                      const_binop (LSHIFT_EXPR, tmask,
2748                                                   size_int (precision - size),
2749                                                   0),
2750                                      size_int (precision - size), 0));
2751 }
2752
2753 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
2754    represents the sign bit of EXP's type.  If EXP represents a sign
2755    or zero extension, also test VAL against the unextended type.
2756    The return value is the (sub)expression whose sign bit is VAL,
2757    or NULL_TREE otherwise.  */
2758
2759 static tree
2760 sign_bit_p (exp, val)
2761      tree exp;
2762      tree val;
2763 {
2764   unsigned HOST_WIDE_INT lo;
2765   HOST_WIDE_INT hi;
2766   int width;
2767   tree t;
2768
2769   /* Tree EXP must have an integral type.  */
2770   t = TREE_TYPE (exp);
2771   if (! INTEGRAL_TYPE_P (t))
2772     return NULL_TREE;
2773
2774   /* Tree VAL must be an integer constant.  */
2775   if (TREE_CODE (val) != INTEGER_CST
2776       || TREE_CONSTANT_OVERFLOW (val))
2777     return NULL_TREE;
2778
2779   width = TYPE_PRECISION (t);
2780   if (width > HOST_BITS_PER_WIDE_INT)
2781     {
2782       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
2783       lo = 0;
2784     }
2785   else
2786     {
2787       hi = 0;
2788       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
2789     }
2790
2791   if (TREE_INT_CST_HIGH (val) == hi && TREE_INT_CST_LOW (val) == lo)
2792     return exp;
2793
2794   /* Handle extension from a narrower type.  */
2795   if (TREE_CODE (exp) == NOP_EXPR
2796       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
2797     return sign_bit_p (TREE_OPERAND (exp, 0), val);
2798
2799   return NULL_TREE;
2800 }
2801
2802 /* Subroutine for fold_truthop: determine if an operand is simple enough
2803    to be evaluated unconditionally.  */
2804
2805 static int
2806 simple_operand_p (exp)
2807      tree exp;
2808 {
2809   /* Strip any conversions that don't change the machine mode.  */
2810   while ((TREE_CODE (exp) == NOP_EXPR
2811           || TREE_CODE (exp) == CONVERT_EXPR)
2812          && (TYPE_MODE (TREE_TYPE (exp))
2813              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2814     exp = TREE_OPERAND (exp, 0);
2815
2816   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2817           || (DECL_P (exp)
2818               && ! TREE_ADDRESSABLE (exp)
2819               && ! TREE_THIS_VOLATILE (exp)
2820               && ! DECL_NONLOCAL (exp)
2821               /* Don't regard global variables as simple.  They may be
2822                  allocated in ways unknown to the compiler (shared memory,
2823                  #pragma weak, etc).  */
2824               && ! TREE_PUBLIC (exp)
2825               && ! DECL_EXTERNAL (exp)
2826               /* Loading a static variable is unduly expensive, but global
2827                  registers aren't expensive.  */
2828               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
2829 }
2830 \f
2831 /* The following functions are subroutines to fold_range_test and allow it to
2832    try to change a logical combination of comparisons into a range test.
2833
2834    For example, both
2835         X == 2 || X == 3 || X == 4 || X == 5
2836    and
2837         X >= 2 && X <= 5
2838    are converted to
2839         (unsigned) (X - 2) <= 3
2840
2841    We describe each set of comparisons as being either inside or outside
2842    a range, using a variable named like IN_P, and then describe the
2843    range with a lower and upper bound.  If one of the bounds is omitted,
2844    it represents either the highest or lowest value of the type.
2845
2846    In the comments below, we represent a range by two numbers in brackets
2847    preceded by a "+" to designate being inside that range, or a "-" to
2848    designate being outside that range, so the condition can be inverted by
2849    flipping the prefix.  An omitted bound is represented by a "-".  For
2850    example, "- [-, 10]" means being outside the range starting at the lowest
2851    possible value and ending at 10, in other words, being greater than 10.
2852    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
2853    always false.
2854
2855    We set up things so that the missing bounds are handled in a consistent
2856    manner so neither a missing bound nor "true" and "false" need to be
2857    handled using a special case.  */
2858
2859 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
2860    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
2861    and UPPER1_P are nonzero if the respective argument is an upper bound
2862    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
2863    must be specified for a comparison.  ARG1 will be converted to ARG0's
2864    type if both are specified.  */
2865
2866 static tree
2867 range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
2868      enum tree_code code;
2869      tree type;
2870      tree arg0, arg1;
2871      int upper0_p, upper1_p;
2872 {
2873   tree tem;
2874   int result;
2875   int sgn0, sgn1;
2876
2877   /* If neither arg represents infinity, do the normal operation.
2878      Else, if not a comparison, return infinity.  Else handle the special
2879      comparison rules. Note that most of the cases below won't occur, but
2880      are handled for consistency.  */
2881
2882   if (arg0 != 0 && arg1 != 0)
2883     {
2884       tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
2885                          arg0, convert (TREE_TYPE (arg0), arg1)));
2886       STRIP_NOPS (tem);
2887       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
2888     }
2889
2890   if (TREE_CODE_CLASS (code) != '<')
2891     return 0;
2892
2893   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
2894      for neither.  In real maths, we cannot assume open ended ranges are
2895      the same. But, this is computer arithmetic, where numbers are finite.
2896      We can therefore make the transformation of any unbounded range with
2897      the value Z, Z being greater than any representable number. This permits
2898      us to treat unbounded ranges as equal.  */
2899   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
2900   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
2901   switch (code)
2902     {
2903     case EQ_EXPR:
2904       result = sgn0 == sgn1;
2905       break;
2906     case NE_EXPR:
2907       result = sgn0 != sgn1;
2908       break;
2909     case LT_EXPR:
2910       result = sgn0 < sgn1;
2911       break;
2912     case LE_EXPR:
2913       result = sgn0 <= sgn1;
2914       break;
2915     case GT_EXPR:
2916       result = sgn0 > sgn1;
2917       break;
2918     case GE_EXPR:
2919       result = sgn0 >= sgn1;
2920       break;
2921     default:
2922       abort ();
2923     }
2924
2925   return convert (type, result ? integer_one_node : integer_zero_node);
2926 }
2927 \f
2928 /* Given EXP, a logical expression, set the range it is testing into
2929    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
2930    actually being tested.  *PLOW and *PHIGH will be made of the same type
2931    as the returned expression.  If EXP is not a comparison, we will most
2932    likely not be returning a useful value and range.  */
2933
2934 static tree
2935 make_range (exp, pin_p, plow, phigh)
2936      tree exp;
2937      int *pin_p;
2938      tree *plow, *phigh;
2939 {
2940   enum tree_code code;
2941   tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
2942   tree orig_type = NULL_TREE;
2943   int in_p, n_in_p;
2944   tree low, high, n_low, n_high;
2945
2946   /* Start with simply saying "EXP != 0" and then look at the code of EXP
2947      and see if we can refine the range.  Some of the cases below may not
2948      happen, but it doesn't seem worth worrying about this.  We "continue"
2949      the outer loop when we've changed something; otherwise we "break"
2950      the switch, which will "break" the while.  */
2951
2952   in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
2953
2954   while (1)
2955     {
2956       code = TREE_CODE (exp);
2957
2958       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
2959         {
2960           arg0 = TREE_OPERAND (exp, 0);
2961           if (TREE_CODE_CLASS (code) == '<'
2962               || TREE_CODE_CLASS (code) == '1'
2963               || TREE_CODE_CLASS (code) == '2')
2964             type = TREE_TYPE (arg0);
2965           if (TREE_CODE_CLASS (code) == '2'
2966               || TREE_CODE_CLASS (code) == '<'
2967               || (TREE_CODE_CLASS (code) == 'e'
2968                   && TREE_CODE_LENGTH (code) > 1))
2969             arg1 = TREE_OPERAND (exp, 1);
2970         }
2971
2972       /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
2973          lose a cast by accident.  */
2974       if (type != NULL_TREE && orig_type == NULL_TREE)
2975         orig_type = type;
2976
2977       switch (code)
2978         {
2979         case TRUTH_NOT_EXPR:
2980           in_p = ! in_p, exp = arg0;
2981           continue;
2982
2983         case EQ_EXPR: case NE_EXPR:
2984         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
2985           /* We can only do something if the range is testing for zero
2986              and if the second operand is an integer constant.  Note that
2987              saying something is "in" the range we make is done by
2988              complementing IN_P since it will set in the initial case of
2989              being not equal to zero; "out" is leaving it alone.  */
2990           if (low == 0 || high == 0
2991               || ! integer_zerop (low) || ! integer_zerop (high)
2992               || TREE_CODE (arg1) != INTEGER_CST)
2993             break;
2994
2995           switch (code)
2996             {
2997             case NE_EXPR:  /* - [c, c]  */
2998               low = high = arg1;
2999               break;
3000             case EQ_EXPR:  /* + [c, c]  */
3001               in_p = ! in_p, low = high = arg1;
3002               break;
3003             case GT_EXPR:  /* - [-, c] */
3004               low = 0, high = arg1;
3005               break;
3006             case GE_EXPR:  /* + [c, -] */
3007               in_p = ! in_p, low = arg1, high = 0;
3008               break;
3009             case LT_EXPR:  /* - [c, -] */
3010               low = arg1, high = 0;
3011               break;
3012             case LE_EXPR:  /* + [-, c] */
3013               in_p = ! in_p, low = 0, high = arg1;
3014               break;
3015             default:
3016               abort ();
3017             }
3018
3019           exp = arg0;
3020
3021           /* If this is an unsigned comparison, we also know that EXP is
3022              greater than or equal to zero.  We base the range tests we make
3023              on that fact, so we record it here so we can parse existing
3024              range tests.  */
3025           if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
3026             {
3027               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3028                                   1, convert (type, integer_zero_node),
3029                                   NULL_TREE))
3030                 break;
3031
3032               in_p = n_in_p, low = n_low, high = n_high;
3033
3034               /* If the high bound is missing, but we
3035                  have a low bound, reverse the range so
3036                  it goes from zero to the low bound minus 1.  */
3037               if (high == 0 && low)
3038                 {
3039                   in_p = ! in_p;
3040                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3041                                       integer_one_node, 0);
3042                   low = convert (type, integer_zero_node);
3043                 }
3044             }
3045           continue;
3046
3047         case NEGATE_EXPR:
3048           /* (-x) IN [a,b] -> x in [-b, -a]  */
3049           n_low = range_binop (MINUS_EXPR, type,
3050                                convert (type, integer_zero_node), 0, high, 1);
3051           n_high = range_binop (MINUS_EXPR, type,
3052                                 convert (type, integer_zero_node), 0, low, 0);
3053           low = n_low, high = n_high;
3054           exp = arg0;
3055           continue;
3056
3057         case BIT_NOT_EXPR:
3058           /* ~ X -> -X - 1  */
3059           exp = build (MINUS_EXPR, type, negate_expr (arg0),
3060                        convert (type, integer_one_node));
3061           continue;
3062
3063         case PLUS_EXPR:  case MINUS_EXPR:
3064           if (TREE_CODE (arg1) != INTEGER_CST)
3065             break;
3066
3067           /* If EXP is signed, any overflow in the computation is undefined,
3068              so we don't worry about it so long as our computations on
3069              the bounds don't overflow.  For unsigned, overflow is defined
3070              and this is exactly the right thing.  */
3071           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3072                                type, low, 0, arg1, 0);
3073           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3074                                 type, high, 1, arg1, 0);
3075           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3076               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3077             break;
3078
3079           /* Check for an unsigned range which has wrapped around the maximum
3080              value thus making n_high < n_low, and normalize it.  */
3081           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3082             {
3083               low = range_binop (PLUS_EXPR, type, n_high, 0,
3084                                  integer_one_node, 0);
3085               high = range_binop (MINUS_EXPR, type, n_low, 0,
3086                                   integer_one_node, 0);
3087
3088               /* If the range is of the form +/- [ x+1, x ], we won't
3089                  be able to normalize it.  But then, it represents the
3090                  whole range or the empty set, so make it
3091                  +/- [ -, - ].  */
3092               if (tree_int_cst_equal (n_low, low)
3093                   && tree_int_cst_equal (n_high, high))
3094                 low = high = 0;
3095               else
3096                 in_p = ! in_p;
3097             }
3098           else
3099             low = n_low, high = n_high;
3100
3101           exp = arg0;
3102           continue;
3103
3104         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3105           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3106             break;
3107
3108           if (! INTEGRAL_TYPE_P (type)
3109               || (low != 0 && ! int_fits_type_p (low, type))
3110               || (high != 0 && ! int_fits_type_p (high, type)))
3111             break;
3112
3113           n_low = low, n_high = high;
3114
3115           if (n_low != 0)
3116             n_low = convert (type, n_low);
3117
3118           if (n_high != 0)
3119             n_high = convert (type, n_high);
3120
3121           /* If we're converting from an unsigned to a signed type,
3122              we will be doing the comparison as unsigned.  The tests above
3123              have already verified that LOW and HIGH are both positive.
3124
3125              So we have to make sure that the original unsigned value will
3126              be interpreted as positive.  */
3127           if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3128             {
3129               tree equiv_type = (*lang_hooks.types.type_for_mode)
3130                 (TYPE_MODE (type), 1);
3131               tree high_positive;
3132
3133               /* A range without an upper bound is, naturally, unbounded.
3134                  Since convert would have cropped a very large value, use
3135                  the max value for the destination type.  */
3136               high_positive
3137                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3138                   : TYPE_MAX_VALUE (type);
3139
3140               if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
3141                 high_positive = fold (build (RSHIFT_EXPR, type,
3142                                              convert (type, high_positive),
3143                                              convert (type, integer_one_node)));
3144
3145               /* If the low bound is specified, "and" the range with the
3146                  range for which the original unsigned value will be
3147                  positive.  */
3148               if (low != 0)
3149                 {
3150                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3151                                       1, n_low, n_high,
3152                                       1, convert (type, integer_zero_node),
3153                                       high_positive))
3154                     break;
3155
3156                   in_p = (n_in_p == in_p);
3157                 }
3158               else
3159                 {
3160                   /* Otherwise, "or" the range with the range of the input
3161                      that will be interpreted as negative.  */
3162                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3163                                       0, n_low, n_high,
3164                                       1, convert (type, integer_zero_node),
3165                                       high_positive))
3166                     break;
3167
3168                   in_p = (in_p != n_in_p);
3169                 }
3170             }
3171
3172           exp = arg0;
3173           low = n_low, high = n_high;
3174           continue;
3175
3176         default:
3177           break;
3178         }
3179
3180       break;
3181     }
3182
3183   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3184   if (TREE_CODE (exp) == INTEGER_CST)
3185     {
3186       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3187                                                  exp, 0, low, 0))
3188                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3189                                                     exp, 1, high, 1)));
3190       low = high = 0;
3191       exp = 0;
3192     }
3193
3194   *pin_p = in_p, *plow = low, *phigh = high;
3195   return exp;
3196 }
3197 \f
3198 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3199    type, TYPE, return an expression to test if EXP is in (or out of, depending
3200    on IN_P) the range.  */
3201
3202 static tree
3203 build_range_check (type, exp, in_p, low, high)
3204      tree type;
3205      tree exp;
3206      int in_p;
3207      tree low, high;
3208 {
3209   tree etype = TREE_TYPE (exp);
3210   tree value;
3211
3212   if (! in_p
3213       && (0 != (value = build_range_check (type, exp, 1, low, high))))
3214     return invert_truthvalue (value);
3215
3216   if (low == 0 && high == 0)
3217     return convert (type, integer_one_node);
3218
3219   if (low == 0)
3220     return fold (build (LE_EXPR, type, exp, high));
3221
3222   if (high == 0)
3223     return fold (build (GE_EXPR, type, exp, low));
3224
3225   if (operand_equal_p (low, high, 0))
3226     return fold (build (EQ_EXPR, type, exp, low));
3227
3228   if (integer_zerop (low))
3229     {
3230       if (! TREE_UNSIGNED (etype))
3231         {
3232           etype = (*lang_hooks.types.unsigned_type) (etype);
3233           high = convert (etype, high);
3234           exp = convert (etype, exp);
3235         }
3236       return build_range_check (type, exp, 1, 0, high);
3237     }
3238
3239   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
3240   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
3241     {
3242       unsigned HOST_WIDE_INT lo;
3243       HOST_WIDE_INT hi;
3244       int prec;
3245
3246       prec = TYPE_PRECISION (etype);
3247       if (prec <= HOST_BITS_PER_WIDE_INT)
3248         {
3249           hi = 0;
3250           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
3251         }
3252       else
3253         {
3254           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
3255           lo = (unsigned HOST_WIDE_INT) -1;
3256         }
3257
3258       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
3259         {
3260           if (TREE_UNSIGNED (etype))
3261             {
3262               etype = (*lang_hooks.types.signed_type) (etype);
3263               exp = convert (etype, exp);
3264             }
3265           return fold (build (GT_EXPR, type, exp,
3266                               convert (etype, integer_zero_node)));
3267         }
3268     }
3269
3270   if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3271       && ! TREE_OVERFLOW (value))
3272     return build_range_check (type,
3273                               fold (build (MINUS_EXPR, etype, exp, low)),
3274                               1, convert (etype, integer_zero_node), value);
3275
3276   return 0;
3277 }
3278 \f
3279 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3280    can, 0 if we can't.  Set the output range into the specified parameters.  */
3281
3282 static int
3283 merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3284      int *pin_p;
3285      tree *plow, *phigh;
3286      int in0_p, in1_p;
3287      tree low0, high0, low1, high1;
3288 {
3289   int no_overlap;
3290   int subset;
3291   int temp;
3292   tree tem;
3293   int in_p;
3294   tree low, high;
3295   int lowequal = ((low0 == 0 && low1 == 0)
3296                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3297                                                 low0, 0, low1, 0)));
3298   int highequal = ((high0 == 0 && high1 == 0)
3299                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3300                                                  high0, 1, high1, 1)));
3301
3302   /* Make range 0 be the range that starts first, or ends last if they
3303      start at the same value.  Swap them if it isn't.  */
3304   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3305                                  low0, 0, low1, 0))
3306       || (lowequal
3307           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3308                                         high1, 1, high0, 1))))
3309     {
3310       temp = in0_p, in0_p = in1_p, in1_p = temp;
3311       tem = low0, low0 = low1, low1 = tem;
3312       tem = high0, high0 = high1, high1 = tem;
3313     }
3314
3315   /* Now flag two cases, whether the ranges are disjoint or whether the
3316      second range is totally subsumed in the first.  Note that the tests
3317      below are simplified by the ones above.  */
3318   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3319                                           high0, 1, low1, 0));
3320   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3321                                       high1, 1, high0, 1));
3322
3323   /* We now have four cases, depending on whether we are including or
3324      excluding the two ranges.  */
3325   if (in0_p && in1_p)
3326     {
3327       /* If they don't overlap, the result is false.  If the second range
3328          is a subset it is the result.  Otherwise, the range is from the start
3329          of the second to the end of the first.  */
3330       if (no_overlap)
3331         in_p = 0, low = high = 0;
3332       else if (subset)
3333         in_p = 1, low = low1, high = high1;
3334       else
3335         in_p = 1, low = low1, high = high0;
3336     }
3337
3338   else if (in0_p && ! in1_p)
3339     {
3340       /* If they don't overlap, the result is the first range.  If they are
3341          equal, the result is false.  If the second range is a subset of the
3342          first, and the ranges begin at the same place, we go from just after
3343          the end of the first range to the end of the second.  If the second
3344          range is not a subset of the first, or if it is a subset and both
3345          ranges end at the same place, the range starts at the start of the
3346          first range and ends just before the second range.
3347          Otherwise, we can't describe this as a single range.  */
3348       if (no_overlap)
3349         in_p = 1, low = low0, high = high0;
3350       else if (lowequal && highequal)
3351         in_p = 0, low = high = 0;
3352       else if (subset && lowequal)
3353         {
3354           in_p = 1, high = high0;
3355           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3356                              integer_one_node, 0);
3357         }
3358       else if (! subset || highequal)
3359         {
3360           in_p = 1, low = low0;
3361           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3362                               integer_one_node, 0);
3363         }
3364       else
3365         return 0;
3366     }
3367
3368   else if (! in0_p && in1_p)
3369     {
3370       /* If they don't overlap, the result is the second range.  If the second
3371          is a subset of the first, the result is false.  Otherwise,
3372          the range starts just after the first range and ends at the
3373          end of the second.  */
3374       if (no_overlap)
3375         in_p = 1, low = low1, high = high1;
3376       else if (subset || highequal)
3377         in_p = 0, low = high = 0;
3378       else
3379         {
3380           in_p = 1, high = high1;
3381           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3382                              integer_one_node, 0);
3383         }
3384     }
3385
3386   else
3387     {
3388       /* The case where we are excluding both ranges.  Here the complex case
3389          is if they don't overlap.  In that case, the only time we have a
3390          range is if they are adjacent.  If the second is a subset of the
3391          first, the result is the first.  Otherwise, the range to exclude
3392          starts at the beginning of the first range and ends at the end of the
3393          second.  */
3394       if (no_overlap)
3395         {
3396           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3397                                          range_binop (PLUS_EXPR, NULL_TREE,
3398                                                       high0, 1,
3399                                                       integer_one_node, 1),
3400                                          1, low1, 0)))
3401             in_p = 0, low = low0, high = high1;
3402           else
3403             return 0;
3404         }
3405       else if (subset)
3406         in_p = 0, low = low0, high = high0;
3407       else
3408         in_p = 0, low = low0, high = high1;
3409     }
3410
3411   *pin_p = in_p, *plow = low, *phigh = high;
3412   return 1;
3413 }
3414 \f
3415 /* EXP is some logical combination of boolean tests.  See if we can
3416    merge it into some range test.  Return the new tree if so.  */
3417
3418 static tree
3419 fold_range_test (exp)
3420      tree exp;
3421 {
3422   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3423                || TREE_CODE (exp) == TRUTH_OR_EXPR);
3424   int in0_p, in1_p, in_p;
3425   tree low0, low1, low, high0, high1, high;
3426   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3427   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3428   tree tem;
3429
3430   /* If this is an OR operation, invert both sides; we will invert
3431      again at the end.  */
3432   if (or_op)
3433     in0_p = ! in0_p, in1_p = ! in1_p;
3434
3435   /* If both expressions are the same, if we can merge the ranges, and we
3436      can build the range test, return it or it inverted.  If one of the
3437      ranges is always true or always false, consider it to be the same
3438      expression as the other.  */
3439   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3440       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3441                        in1_p, low1, high1)
3442       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3443                                          lhs != 0 ? lhs
3444                                          : rhs != 0 ? rhs : integer_zero_node,
3445                                          in_p, low, high))))
3446     return or_op ? invert_truthvalue (tem) : tem;
3447
3448   /* On machines where the branch cost is expensive, if this is a
3449      short-circuited branch and the underlying object on both sides
3450      is the same, make a non-short-circuit operation.  */
3451   else if (BRANCH_COST >= 2
3452            && lhs != 0 && rhs != 0
3453            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3454                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3455            && operand_equal_p (lhs, rhs, 0))
3456     {
3457       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
3458          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3459          which cases we can't do this.  */
3460       if (simple_operand_p (lhs))
3461         return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3462                       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3463                       TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3464                       TREE_OPERAND (exp, 1));
3465
3466       else if ((*lang_hooks.decls.global_bindings_p) () == 0
3467                && ! contains_placeholder_p (lhs))
3468         {
3469           tree common = save_expr (lhs);
3470
3471           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3472                                              or_op ? ! in0_p : in0_p,
3473                                              low0, high0))
3474               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3475                                                  or_op ? ! in1_p : in1_p,
3476                                                  low1, high1))))
3477             return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3478                           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3479                           TREE_TYPE (exp), lhs, rhs);
3480         }
3481     }
3482
3483   return 0;
3484 }
3485 \f
3486 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3487    bit value.  Arrange things so the extra bits will be set to zero if and
3488    only if C is signed-extended to its full width.  If MASK is nonzero,
3489    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
3490
3491 static tree
3492 unextend (c, p, unsignedp, mask)
3493      tree c;
3494      int p;
3495      int unsignedp;
3496      tree mask;
3497 {
3498   tree type = TREE_TYPE (c);
3499   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3500   tree temp;
3501
3502   if (p == modesize || unsignedp)
3503     return c;
3504
3505   /* We work by getting just the sign bit into the low-order bit, then
3506      into the high-order bit, then sign-extend.  We then XOR that value
3507      with C.  */
3508   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3509   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3510
3511   /* We must use a signed type in order to get an arithmetic right shift.
3512      However, we must also avoid introducing accidental overflows, so that
3513      a subsequent call to integer_zerop will work.  Hence we must
3514      do the type conversion here.  At this point, the constant is either
3515      zero or one, and the conversion to a signed type can never overflow.
3516      We could get an overflow if this conversion is done anywhere else.  */
3517   if (TREE_UNSIGNED (type))
3518     temp = convert ((*lang_hooks.types.signed_type) (type), temp);
3519
3520   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3521   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3522   if (mask != 0)
3523     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3524   /* If necessary, convert the type back to match the type of C.  */
3525   if (TREE_UNSIGNED (type))
3526     temp = convert (type, temp);
3527
3528   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3529 }
3530 \f
3531 /* Find ways of folding logical expressions of LHS and RHS:
3532    Try to merge two comparisons to the same innermost item.
3533    Look for range tests like "ch >= '0' && ch <= '9'".
3534    Look for combinations of simple terms on machines with expensive branches
3535    and evaluate the RHS unconditionally.
3536
3537    For example, if we have p->a == 2 && p->b == 4 and we can make an
3538    object large enough to span both A and B, we can do this with a comparison
3539    against the object ANDed with the a mask.
3540
3541    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3542    operations to do this with one comparison.
3543
3544    We check for both normal comparisons and the BIT_AND_EXPRs made this by
3545    function and the one above.
3546
3547    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
3548    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3549
3550    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3551    two operands.
3552
3553    We return the simplified tree or 0 if no optimization is possible.  */
3554
3555 static tree
3556 fold_truthop (code, truth_type, lhs, rhs)
3557      enum tree_code code;
3558      tree truth_type, lhs, rhs;
3559 {
3560   /* If this is the "or" of two comparisons, we can do something if
3561      the comparisons are NE_EXPR.  If this is the "and", we can do something
3562      if the comparisons are EQ_EXPR.  I.e.,
3563         (a->b == 2 && a->c == 4) can become (a->new == NEW).
3564
3565      WANTED_CODE is this operation code.  For single bit fields, we can
3566      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3567      comparison for one-bit fields.  */
3568
3569   enum tree_code wanted_code;
3570   enum tree_code lcode, rcode;
3571   tree ll_arg, lr_arg, rl_arg, rr_arg;
3572   tree ll_inner, lr_inner, rl_inner, rr_inner;
3573   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3574   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3575   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3576   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3577   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3578   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3579   enum machine_mode lnmode, rnmode;
3580   tree ll_mask, lr_mask, rl_mask, rr_mask;
3581   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3582   tree l_const, r_const;
3583   tree lntype, rntype, result;
3584   int first_bit, end_bit;
3585   int volatilep;
3586
3587   /* Start by getting the comparison codes.  Fail if anything is volatile.
3588      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3589      it were surrounded with a NE_EXPR.  */
3590
3591   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3592     return 0;
3593
3594   lcode = TREE_CODE (lhs);
3595   rcode = TREE_CODE (rhs);
3596
3597   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3598     lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3599
3600   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3601     rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3602
3603   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3604     return 0;
3605
3606   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3607           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3608
3609   ll_arg = TREE_OPERAND (lhs, 0);
3610   lr_arg = TREE_OPERAND (lhs, 1);
3611   rl_arg = TREE_OPERAND (rhs, 0);
3612   rr_arg = TREE_OPERAND (rhs, 1);
3613
3614   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
3615   if (simple_operand_p (ll_arg)
3616       && simple_operand_p (lr_arg)
3617       && !FLOAT_TYPE_P (TREE_TYPE (ll_arg)))
3618     {
3619       int compcode;
3620
3621       if (operand_equal_p (ll_arg, rl_arg, 0)
3622           && operand_equal_p (lr_arg, rr_arg, 0))
3623         {
3624           int lcompcode, rcompcode;
3625
3626           lcompcode = comparison_to_compcode (lcode);
3627           rcompcode = comparison_to_compcode (rcode);
3628           compcode = (code == TRUTH_AND_EXPR)
3629                      ? lcompcode & rcompcode
3630                      : lcompcode | rcompcode;
3631         }
3632       else if (operand_equal_p (ll_arg, rr_arg, 0)
3633                && operand_equal_p (lr_arg, rl_arg, 0))
3634         {
3635           int lcompcode, rcompcode;
3636
3637           rcode = swap_tree_comparison (rcode);
3638           lcompcode = comparison_to_compcode (lcode);
3639           rcompcode = comparison_to_compcode (rcode);
3640           compcode = (code == TRUTH_AND_EXPR)
3641                      ? lcompcode & rcompcode
3642                      : lcompcode | rcompcode;
3643         }
3644       else
3645         compcode = -1;
3646
3647       if (compcode == COMPCODE_TRUE)
3648         return convert (truth_type, integer_one_node);
3649       else if (compcode == COMPCODE_FALSE)
3650         return convert (truth_type, integer_zero_node);
3651       else if (compcode != -1)
3652         return build (compcode_to_comparison (compcode),
3653                       truth_type, ll_arg, lr_arg);
3654     }
3655
3656   /* If the RHS can be evaluated unconditionally and its operands are
3657      simple, it wins to evaluate the RHS unconditionally on machines
3658      with expensive branches.  In this case, this isn't a comparison
3659      that can be merged.  Avoid doing this if the RHS is a floating-point
3660      comparison since those can trap.  */
3661
3662   if (BRANCH_COST >= 2
3663       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
3664       && simple_operand_p (rl_arg)
3665       && simple_operand_p (rr_arg))
3666     {
3667       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
3668       if (code == TRUTH_OR_EXPR
3669           && lcode == NE_EXPR && integer_zerop (lr_arg)
3670           && rcode == NE_EXPR && integer_zerop (rr_arg)
3671           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
3672         return build (NE_EXPR, truth_type,
3673                       build (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
3674                              ll_arg, rl_arg),
3675                       integer_zero_node);
3676
3677       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
3678       if (code == TRUTH_AND_EXPR
3679           && lcode == EQ_EXPR && integer_zerop (lr_arg)
3680           && rcode == EQ_EXPR && integer_zerop (rr_arg)
3681           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
3682         return build (EQ_EXPR, truth_type,
3683                       build (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
3684                              ll_arg, rl_arg),
3685                       integer_zero_node);
3686
3687       return build (code, truth_type, lhs, rhs);
3688     }
3689
3690   /* See if the comparisons can be merged.  Then get all the parameters for
3691      each side.  */
3692
3693   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3694       || (rcode != EQ_EXPR && rcode != NE_EXPR))
3695     return 0;
3696
3697   volatilep = 0;
3698   ll_inner = decode_field_reference (ll_arg,
3699                                      &ll_bitsize, &ll_bitpos, &ll_mode,
3700                                      &ll_unsignedp, &volatilep, &ll_mask,
3701                                      &ll_and_mask);
3702   lr_inner = decode_field_reference (lr_arg,
3703                                      &lr_bitsize, &lr_bitpos, &lr_mode,
3704                                      &lr_unsignedp, &volatilep, &lr_mask,
3705                                      &lr_and_mask);
3706   rl_inner = decode_field_reference (rl_arg,
3707                                      &rl_bitsize, &rl_bitpos, &rl_mode,
3708                                      &rl_unsignedp, &volatilep, &rl_mask,
3709                                      &rl_and_mask);
3710   rr_inner = decode_field_reference (rr_arg,
3711                                      &rr_bitsize, &rr_bitpos, &rr_mode,
3712                                      &rr_unsignedp, &volatilep, &rr_mask,
3713                                      &rr_and_mask);
3714
3715   /* It must be true that the inner operation on the lhs of each
3716      comparison must be the same if we are to be able to do anything.
3717      Then see if we have constants.  If not, the same must be true for
3718      the rhs's.  */
3719   if (volatilep || ll_inner == 0 || rl_inner == 0
3720       || ! operand_equal_p (ll_inner, rl_inner, 0))
3721     return 0;
3722
3723   if (TREE_CODE (lr_arg) == INTEGER_CST
3724       && TREE_CODE (rr_arg) == INTEGER_CST)
3725     l_const = lr_arg, r_const = rr_arg;
3726   else if (lr_inner == 0 || rr_inner == 0
3727            || ! operand_equal_p (lr_inner, rr_inner, 0))
3728     return 0;
3729   else
3730     l_const = r_const = 0;
3731
3732   /* If either comparison code is not correct for our logical operation,
3733      fail.  However, we can convert a one-bit comparison against zero into
3734      the opposite comparison against that bit being set in the field.  */
3735
3736   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3737   if (lcode != wanted_code)
3738     {
3739       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3740         {
3741           /* Make the left operand unsigned, since we are only interested
3742              in the value of one bit.  Otherwise we are doing the wrong
3743              thing below.  */
3744           ll_unsignedp = 1;
3745           l_const = ll_mask;
3746         }
3747       else
3748         return 0;
3749     }
3750
3751   /* This is analogous to the code for l_const above.  */
3752   if (rcode != wanted_code)
3753     {
3754       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3755         {
3756           rl_unsignedp = 1;
3757           r_const = rl_mask;
3758         }
3759       else
3760         return 0;
3761     }
3762
3763   /* After this point all optimizations will generate bit-field
3764      references, which we might not want.  */
3765   if (! (*lang_hooks.can_use_bit_fields_p) ())
3766     return 0;
3767
3768   /* See if we can find a mode that contains both fields being compared on
3769      the left.  If we can't, fail.  Otherwise, update all constants and masks
3770      to be relative to a field of that size.  */
3771   first_bit = MIN (ll_bitpos, rl_bitpos);
3772   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3773   lnmode = get_best_mode (end_bit - first_bit, first_bit,
3774                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3775                           volatilep);
3776   if (lnmode == VOIDmode)
3777     return 0;
3778
3779   lnbitsize = GET_MODE_BITSIZE (lnmode);
3780   lnbitpos = first_bit & ~ (lnbitsize - 1);
3781   lntype = (*lang_hooks.types.type_for_size) (lnbitsize, 1);
3782   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3783
3784   if (BYTES_BIG_ENDIAN)
3785     {
3786       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3787       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3788     }
3789
3790   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3791                          size_int (xll_bitpos), 0);
3792   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3793                          size_int (xrl_bitpos), 0);
3794
3795   if (l_const)
3796     {
3797       l_const = convert (lntype, l_const);
3798       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
3799       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3800       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3801                                         fold (build1 (BIT_NOT_EXPR,
3802                                                       lntype, ll_mask)),
3803                                         0)))
3804         {
3805           warning ("comparison is always %d", wanted_code == NE_EXPR);
3806
3807           return convert (truth_type,
3808                           wanted_code == NE_EXPR
3809                           ? integer_one_node : integer_zero_node);
3810         }
3811     }
3812   if (r_const)
3813     {
3814       r_const = convert (lntype, r_const);
3815       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3816       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3817       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3818                                         fold (build1 (BIT_NOT_EXPR,
3819                                                       lntype, rl_mask)),
3820                                         0)))
3821         {
3822           warning ("comparison is always %d", wanted_code == NE_EXPR);
3823
3824           return convert (truth_type,
3825                           wanted_code == NE_EXPR
3826                           ? integer_one_node : integer_zero_node);
3827         }
3828     }
3829
3830   /* If the right sides are not constant, do the same for it.  Also,
3831      disallow this optimization if a size or signedness mismatch occurs
3832      between the left and right sides.  */
3833   if (l_const == 0)
3834     {
3835       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
3836           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
3837           /* Make sure the two fields on the right
3838              correspond to the left without being swapped.  */
3839           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
3840         return 0;
3841
3842       first_bit = MIN (lr_bitpos, rr_bitpos);
3843       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
3844       rnmode = get_best_mode (end_bit - first_bit, first_bit,
3845                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
3846                               volatilep);
3847       if (rnmode == VOIDmode)
3848         return 0;
3849
3850       rnbitsize = GET_MODE_BITSIZE (rnmode);
3851       rnbitpos = first_bit & ~ (rnbitsize - 1);
3852       rntype = (*lang_hooks.types.type_for_size) (rnbitsize, 1);
3853       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
3854
3855       if (BYTES_BIG_ENDIAN)
3856         {
3857           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
3858           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
3859         }
3860
3861       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
3862                              size_int (xlr_bitpos), 0);
3863       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
3864                              size_int (xrr_bitpos), 0);
3865
3866       /* Make a mask that corresponds to both fields being compared.
3867          Do this for both items being compared.  If the operands are the
3868          same size and the bits being compared are in the same position
3869          then we can do this by masking both and comparing the masked
3870          results.  */
3871       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3872       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
3873       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
3874         {
3875           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3876                                     ll_unsignedp || rl_unsignedp);
3877           if (! all_ones_mask_p (ll_mask, lnbitsize))
3878             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
3879
3880           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
3881                                     lr_unsignedp || rr_unsignedp);
3882           if (! all_ones_mask_p (lr_mask, rnbitsize))
3883             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
3884
3885           return build (wanted_code, truth_type, lhs, rhs);
3886         }
3887
3888       /* There is still another way we can do something:  If both pairs of
3889          fields being compared are adjacent, we may be able to make a wider
3890          field containing them both.
3891
3892          Note that we still must mask the lhs/rhs expressions.  Furthermore,
3893          the mask must be shifted to account for the shift done by
3894          make_bit_field_ref.  */
3895       if ((ll_bitsize + ll_bitpos == rl_bitpos
3896            && lr_bitsize + lr_bitpos == rr_bitpos)
3897           || (ll_bitpos == rl_bitpos + rl_bitsize
3898               && lr_bitpos == rr_bitpos + rr_bitsize))
3899         {
3900           tree type;
3901
3902           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
3903                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
3904           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
3905                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
3906
3907           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
3908                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
3909           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
3910                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
3911
3912           /* Convert to the smaller type before masking out unwanted bits.  */
3913           type = lntype;
3914           if (lntype != rntype)
3915             {
3916               if (lnbitsize > rnbitsize)
3917                 {
3918                   lhs = convert (rntype, lhs);
3919                   ll_mask = convert (rntype, ll_mask);
3920                   type = rntype;
3921                 }
3922               else if (lnbitsize < rnbitsize)
3923                 {
3924                   rhs = convert (lntype, rhs);
3925                   lr_mask = convert (lntype, lr_mask);
3926                   type = lntype;
3927                 }
3928             }
3929
3930           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
3931             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3932
3933           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
3934             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
3935
3936           return build (wanted_code, truth_type, lhs, rhs);
3937         }
3938
3939       return 0;
3940     }
3941
3942   /* Handle the case of comparisons with constants.  If there is something in
3943      common between the masks, those bits of the constants must be the same.
3944      If not, the condition is always false.  Test for this to avoid generating
3945      incorrect code below.  */
3946   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
3947   if (! integer_zerop (result)
3948       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
3949                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
3950     {
3951       if (wanted_code == NE_EXPR)
3952         {
3953           warning ("`or' of unmatched not-equal tests is always 1");
3954           return convert (truth_type, integer_one_node);
3955         }
3956       else
3957         {
3958           warning ("`and' of mutually exclusive equal-tests is always 0");
3959           return convert (truth_type, integer_zero_node);
3960         }
3961     }
3962
3963   /* Construct the expression we will return.  First get the component
3964      reference we will make.  Unless the mask is all ones the width of
3965      that field, perform the mask operation.  Then compare with the
3966      merged constant.  */
3967   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3968                                ll_unsignedp || rl_unsignedp);
3969
3970   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3971   if (! all_ones_mask_p (ll_mask, lnbitsize))
3972     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
3973
3974   return build (wanted_code, truth_type, result,
3975                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
3976 }
3977 \f
3978 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
3979    constant.  */
3980
3981 static tree
3982 optimize_minmax_comparison (t)
3983      tree t;
3984 {
3985   tree type = TREE_TYPE (t);
3986   tree arg0 = TREE_OPERAND (t, 0);
3987   enum tree_code op_code;
3988   tree comp_const = TREE_OPERAND (t, 1);
3989   tree minmax_const;
3990   int consts_equal, consts_lt;
3991   tree inner;
3992
3993   STRIP_SIGN_NOPS (arg0);
3994
3995   op_code = TREE_CODE (arg0);
3996   minmax_const = TREE_OPERAND (arg0, 1);
3997   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
3998   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
3999   inner = TREE_OPERAND (arg0, 0);
4000
4001   /* If something does not permit us to optimize, return the original tree.  */
4002   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4003       || TREE_CODE (comp_const) != INTEGER_CST
4004       || TREE_CONSTANT_OVERFLOW (comp_const)
4005       || TREE_CODE (minmax_const) != INTEGER_CST
4006       || TREE_CONSTANT_OVERFLOW (minmax_const))
4007     return t;
4008
4009   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4010      and GT_EXPR, doing the rest with recursive calls using logical
4011      simplifications.  */
4012   switch (TREE_CODE (t))
4013     {
4014     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4015       return
4016         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4017
4018     case GE_EXPR:
4019       return
4020         fold (build (TRUTH_ORIF_EXPR, type,
4021                      optimize_minmax_comparison
4022                      (build (EQ_EXPR, type, arg0, comp_const)),
4023                      optimize_minmax_comparison
4024                      (build (GT_EXPR, type, arg0, comp_const))));
4025
4026     case EQ_EXPR:
4027       if (op_code == MAX_EXPR && consts_equal)
4028         /* MAX (X, 0) == 0  ->  X <= 0  */
4029         return fold (build (LE_EXPR, type, inner, comp_const));
4030
4031       else if (op_code == MAX_EXPR && consts_lt)
4032         /* MAX (X, 0) == 5  ->  X == 5   */
4033         return fold (build (EQ_EXPR, type, inner, comp_const));
4034
4035       else if (op_code == MAX_EXPR)
4036         /* MAX (X, 0) == -1  ->  false  */
4037         return omit_one_operand (type, integer_zero_node, inner);
4038
4039       else if (consts_equal)
4040         /* MIN (X, 0) == 0  ->  X >= 0  */
4041         return fold (build (GE_EXPR, type, inner, comp_const));
4042
4043       else if (consts_lt)
4044         /* MIN (X, 0) == 5  ->  false  */
4045         return omit_one_operand (type, integer_zero_node, inner);
4046
4047       else
4048         /* MIN (X, 0) == -1  ->  X == -1  */
4049         return fold (build (EQ_EXPR, type, inner, comp_const));
4050
4051     case GT_EXPR:
4052       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4053         /* MAX (X, 0) > 0  ->  X > 0
4054            MAX (X, 0) > 5  ->  X > 5  */
4055         return fold (build (GT_EXPR, type, inner, comp_const));
4056
4057       else if (op_code == MAX_EXPR)
4058         /* MAX (X, 0) > -1  ->  true  */
4059         return omit_one_operand (type, integer_one_node, inner);
4060
4061       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4062         /* MIN (X, 0) > 0  ->  false
4063            MIN (X, 0) > 5  ->  false  */
4064         return omit_one_operand (type, integer_zero_node, inner);
4065
4066       else
4067         /* MIN (X, 0) > -1  ->  X > -1  */
4068         return fold (build (GT_EXPR, type, inner, comp_const));
4069
4070     default:
4071       return t;
4072     }
4073 }
4074 \f
4075 /* T is an integer expression that is being multiplied, divided, or taken a
4076    modulus (CODE says which and what kind of divide or modulus) by a
4077    constant C.  See if we can eliminate that operation by folding it with
4078    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4079    should be used for the computation if wider than our type.
4080
4081    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
4082    (X * 2) + (Y * 4).  We must, however, be assured that either the original
4083    expression would not overflow or that overflow is undefined for the type
4084    in the language in question.
4085
4086    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4087    the machine has a multiply-accumulate insn or that this is part of an
4088    addressing calculation.
4089
4090    If we return a non-null expression, it is an equivalent form of the
4091    original computation, but need not be in the original type.  */
4092
4093 static tree
4094 extract_muldiv (t, c, code, wide_type)
4095      tree t;
4096      tree c;
4097      enum tree_code code;
4098      tree wide_type;
4099 {
4100   /* To avoid exponential search depth, refuse to allow recursion past
4101      three levels.  Beyond that (1) it's highly unlikely that we'll find
4102      something interesting and (2) we've probably processed it before
4103      when we built the inner expression.  */
4104
4105   static int depth;
4106   tree ret;
4107
4108   if (depth > 3)
4109     return NULL;
4110
4111   depth++;
4112   ret = extract_muldiv_1 (t, c, code, wide_type);
4113   depth--;
4114
4115   return ret;
4116 }
4117
4118 static tree
4119 extract_muldiv_1 (t, c, code, wide_type)
4120      tree t;
4121      tree c;
4122      enum tree_code code;
4123      tree wide_type;
4124 {
4125   tree type = TREE_TYPE (t);
4126   enum tree_code tcode = TREE_CODE (t);
4127   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4128                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4129                 ? wide_type : type);
4130   tree t1, t2;
4131   int same_p = tcode == code;
4132   tree op0 = NULL_TREE, op1 = NULL_TREE;
4133
4134   /* Don't deal with constants of zero here; they confuse the code below.  */
4135   if (integer_zerop (c))
4136     return NULL_TREE;
4137
4138   if (TREE_CODE_CLASS (tcode) == '1')
4139     op0 = TREE_OPERAND (t, 0);
4140
4141   if (TREE_CODE_CLASS (tcode) == '2')
4142     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4143
4144   /* Note that we need not handle conditional operations here since fold
4145      already handles those cases.  So just do arithmetic here.  */
4146   switch (tcode)
4147     {
4148     case INTEGER_CST:
4149       /* For a constant, we can always simplify if we are a multiply
4150          or (for divide and modulus) if it is a multiple of our constant.  */
4151       if (code == MULT_EXPR
4152           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4153         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4154       break;
4155
4156     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4157       /* If op0 is an expression ...  */
4158       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
4159            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
4160            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
4161            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
4162           /* ... and is unsigned, and its type is smaller than ctype,
4163              then we cannot pass through as widening.  */
4164           && ((TREE_UNSIGNED (TREE_TYPE (op0))
4165                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
4166                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
4167                && (GET_MODE_SIZE (TYPE_MODE (ctype))
4168                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
4169               /* ... or its type is larger than ctype,
4170                  then we cannot pass through this truncation.  */
4171               || (GET_MODE_SIZE (TYPE_MODE (ctype))
4172                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))))
4173         break;
4174
4175       /* Pass the constant down and see if we can make a simplification.  If
4176          we can, replace this expression with the inner simplification for
4177          possible later conversion to our or some other type.  */
4178       if (0 != (t1 = extract_muldiv (op0, convert (TREE_TYPE (op0), c), code,
4179                                      code == MULT_EXPR ? ctype : NULL_TREE)))
4180         return t1;
4181       break;
4182
4183     case NEGATE_EXPR:  case ABS_EXPR:
4184       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4185         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4186       break;
4187
4188     case MIN_EXPR:  case MAX_EXPR:
4189       /* If widening the type changes the signedness, then we can't perform
4190          this optimization as that changes the result.  */
4191       if (TREE_UNSIGNED (ctype) != TREE_UNSIGNED (type))
4192         break;
4193
4194       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4195       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4196           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4197         {
4198           if (tree_int_cst_sgn (c) < 0)
4199             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4200
4201           return fold (build (tcode, ctype, convert (ctype, t1),
4202                               convert (ctype, t2)));
4203         }
4204       break;
4205
4206     case WITH_RECORD_EXPR:
4207       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4208         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4209                       TREE_OPERAND (t, 1));
4210       break;
4211
4212     case SAVE_EXPR:
4213       /* If this has not been evaluated and the operand has no side effects,
4214          we can see if we can do something inside it and make a new one.
4215          Note that this test is overly conservative since we can do this
4216          if the only reason it had side effects is that it was another
4217          similar SAVE_EXPR, but that isn't worth bothering with.  */
4218       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4219           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4220                                         wide_type)))
4221         {
4222           t1 = save_expr (t1);
4223           if (SAVE_EXPR_PERSISTENT_P (t) && TREE_CODE (t1) == SAVE_EXPR)
4224             SAVE_EXPR_PERSISTENT_P (t1) = 1;
4225           if (is_pending_size (t))
4226             put_pending_size (t1);
4227           return t1;
4228         }
4229       break;
4230
4231     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4232       /* If the second operand is constant, this is a multiplication
4233          or floor division, by a power of two, so we can treat it that
4234          way unless the multiplier or divisor overflows.  */
4235       if (TREE_CODE (op1) == INTEGER_CST
4236           /* const_binop may not detect overflow correctly,
4237              so check for it explicitly here.  */
4238           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
4239           && TREE_INT_CST_HIGH (op1) == 0
4240           && 0 != (t1 = convert (ctype,
4241                                  const_binop (LSHIFT_EXPR, size_one_node,
4242                                               op1, 0)))
4243           && ! TREE_OVERFLOW (t1))
4244         return extract_muldiv (build (tcode == LSHIFT_EXPR
4245                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4246                                       ctype, convert (ctype, op0), t1),
4247                                c, code, wide_type);
4248       break;
4249
4250     case PLUS_EXPR:  case MINUS_EXPR:
4251       /* See if we can eliminate the operation on both sides.  If we can, we
4252          can return a new PLUS or MINUS.  If we can't, the only remaining
4253          cases where we can do anything are if the second operand is a
4254          constant.  */
4255       t1 = extract_muldiv (op0, c, code, wide_type);
4256       t2 = extract_muldiv (op1, c, code, wide_type);
4257       if (t1 != 0 && t2 != 0
4258           && (code == MULT_EXPR
4259               /* If not multiplication, we can only do this if both operands
4260                  are divisible by c.  */
4261               || (multiple_of_p (ctype, op0, c)
4262                   && multiple_of_p (ctype, op1, c))))
4263         return fold (build (tcode, ctype, convert (ctype, t1),
4264                             convert (ctype, t2)));
4265
4266       /* If this was a subtraction, negate OP1 and set it to be an addition.
4267          This simplifies the logic below.  */
4268       if (tcode == MINUS_EXPR)
4269         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4270
4271       if (TREE_CODE (op1) != INTEGER_CST)
4272         break;
4273
4274       /* If either OP1 or C are negative, this optimization is not safe for
4275          some of the division and remainder types while for others we need
4276          to change the code.  */
4277       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4278         {
4279           if (code == CEIL_DIV_EXPR)
4280             code = FLOOR_DIV_EXPR;
4281           else if (code == FLOOR_DIV_EXPR)
4282             code = CEIL_DIV_EXPR;
4283           else if (code != MULT_EXPR
4284                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
4285             break;
4286         }
4287
4288       /* If it's a multiply or a division/modulus operation of a multiple
4289          of our constant, do the operation and verify it doesn't overflow.  */
4290       if (code == MULT_EXPR
4291           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4292         {
4293           op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4294           if (op1 == 0 || TREE_OVERFLOW (op1))
4295             break;
4296         }
4297       else
4298         break;
4299
4300       /* If we have an unsigned type is not a sizetype, we cannot widen
4301          the operation since it will change the result if the original
4302          computation overflowed.  */
4303       if (TREE_UNSIGNED (ctype)
4304           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
4305           && ctype != type)
4306         break;
4307
4308       /* If we were able to eliminate our operation from the first side,
4309          apply our operation to the second side and reform the PLUS.  */
4310       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4311         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4312
4313       /* The last case is if we are a multiply.  In that case, we can
4314          apply the distributive law to commute the multiply and addition
4315          if the multiplication of the constants doesn't overflow.  */
4316       if (code == MULT_EXPR)
4317         return fold (build (tcode, ctype, fold (build (code, ctype,
4318                                                        convert (ctype, op0),
4319                                                        convert (ctype, c))),
4320                             op1));
4321
4322       break;
4323
4324     case MULT_EXPR:
4325       /* We have a special case here if we are doing something like
4326          (C * 8) % 4 since we know that's zero.  */
4327       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4328            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4329           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4330           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4331         return omit_one_operand (type, integer_zero_node, op0);
4332
4333       /* Arrange for the code below to simplify two constants first.  */
4334       if (TREE_CODE (op1) == INTEGER_CST && TREE_CODE (op0) != INTEGER_CST)
4335         {
4336           tree tmp = op0;
4337           op0 = op1;
4338           op1 = tmp;
4339         }
4340
4341       /* ... fall through ...  */
4342
4343     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4344     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4345       /* If we can extract our operation from the LHS, do so and return a
4346          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4347          do something only if the second operand is a constant.  */
4348       if (same_p
4349           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4350         return fold (build (tcode, ctype, convert (ctype, t1),
4351                             convert (ctype, op1)));
4352       else if (tcode == MULT_EXPR && code == MULT_EXPR
4353                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4354         return fold (build (tcode, ctype, convert (ctype, op0),
4355                             convert (ctype, t1)));
4356       else if (TREE_CODE (op1) != INTEGER_CST)
4357         return 0;
4358
4359       /* If these are the same operation types, we can associate them
4360          assuming no overflow.  */
4361       if (tcode == code
4362           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4363                                      convert (ctype, c), 0))
4364           && ! TREE_OVERFLOW (t1))
4365         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4366
4367       /* If these operations "cancel" each other, we have the main
4368          optimizations of this pass, which occur when either constant is a
4369          multiple of the other, in which case we replace this with either an
4370          operation or CODE or TCODE.
4371
4372          If we have an unsigned type that is not a sizetype, we cannot do
4373          this since it will change the result if the original computation
4374          overflowed.  */
4375       if ((! TREE_UNSIGNED (ctype)
4376            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
4377           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4378               || (tcode == MULT_EXPR
4379                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4380                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
4381         {
4382           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4383             return fold (build (tcode, ctype, convert (ctype, op0),
4384                                 convert (ctype,
4385                                          const_binop (TRUNC_DIV_EXPR,
4386                                                       op1, c, 0))));
4387           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4388             return fold (build (code, ctype, convert (ctype, op0),
4389                                 convert (ctype,
4390                                          const_binop (TRUNC_DIV_EXPR,
4391                                                       c, op1, 0))));
4392         }
4393       break;
4394
4395     default:
4396       break;
4397     }
4398
4399   return 0;
4400 }
4401 \f
4402 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4403    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4404    that we may sometimes modify the tree.  */
4405
4406 static tree
4407 strip_compound_expr (t, s)
4408      tree t;
4409      tree s;
4410 {
4411   enum tree_code code = TREE_CODE (t);
4412
4413   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4414   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4415       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4416     return TREE_OPERAND (t, 1);
4417
4418   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4419      don't bother handling any other types.  */
4420   else if (code == COND_EXPR)
4421     {
4422       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4423       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4424       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4425     }
4426   else if (TREE_CODE_CLASS (code) == '1')
4427     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4428   else if (TREE_CODE_CLASS (code) == '<'
4429            || TREE_CODE_CLASS (code) == '2')
4430     {
4431       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4432       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4433     }
4434
4435   return t;
4436 }
4437 \f
4438 /* Return a node which has the indicated constant VALUE (either 0 or
4439    1), and is of the indicated TYPE.  */
4440
4441 static tree
4442 constant_boolean_node (value, type)
4443      int value;
4444      tree type;
4445 {
4446   if (type == integer_type_node)
4447     return value ? integer_one_node : integer_zero_node;
4448   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4449     return (*lang_hooks.truthvalue_conversion) (value ? integer_one_node :
4450                                                 integer_zero_node);
4451   else
4452     {
4453       tree t = build_int_2 (value, 0);
4454
4455       TREE_TYPE (t) = type;
4456       return t;
4457     }
4458 }
4459
4460 /* Utility function for the following routine, to see how complex a nesting of
4461    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4462    we don't care (to avoid spending too much time on complex expressions.).  */
4463
4464 static int
4465 count_cond (expr, lim)
4466      tree expr;
4467      int lim;
4468 {
4469   int ctrue, cfalse;
4470
4471   if (TREE_CODE (expr) != COND_EXPR)
4472     return 0;
4473   else if (lim <= 0)
4474     return 0;
4475
4476   ctrue = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4477   cfalse = count_cond (TREE_OPERAND (expr, 2), lim - 1 - ctrue);
4478   return MIN (lim, 1 + ctrue + cfalse);
4479 }
4480
4481 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
4482    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
4483    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
4484    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
4485    COND is the first argument to CODE; otherwise (as in the example
4486    given here), it is the second argument.  TYPE is the type of the
4487    original expression.  */
4488
4489 static tree
4490 fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
4491      enum tree_code code;
4492      tree type;
4493      tree cond;
4494      tree arg;
4495      int cond_first_p;
4496 {
4497   tree test, true_value, false_value;
4498   tree lhs = NULL_TREE;
4499   tree rhs = NULL_TREE;
4500   /* In the end, we'll produce a COND_EXPR.  Both arms of the
4501      conditional expression will be binary operations.  The left-hand
4502      side of the expression to be executed if the condition is true
4503      will be pointed to by TRUE_LHS.  Similarly, the right-hand side
4504      of the expression to be executed if the condition is true will be
4505      pointed to by TRUE_RHS.  FALSE_LHS and FALSE_RHS are analogous --
4506      but apply to the expression to be executed if the conditional is
4507      false.  */
4508   tree *true_lhs;
4509   tree *true_rhs;
4510   tree *false_lhs;
4511   tree *false_rhs;
4512   /* These are the codes to use for the left-hand side and right-hand
4513      side of the COND_EXPR.  Normally, they are the same as CODE.  */
4514   enum tree_code lhs_code = code;
4515   enum tree_code rhs_code = code;
4516   /* And these are the types of the expressions.  */
4517   tree lhs_type = type;
4518   tree rhs_type = type;
4519   int save = 0;
4520
4521   if (cond_first_p)
4522     {
4523       true_rhs = false_rhs = &arg;
4524       true_lhs = &true_value;
4525       false_lhs = &false_value;
4526     }
4527   else
4528     {
4529       true_lhs = false_lhs = &arg;
4530       true_rhs = &true_value;
4531       false_rhs = &false_value;
4532     }
4533
4534   if (TREE_CODE (cond) == COND_EXPR)
4535     {
4536       test = TREE_OPERAND (cond, 0);
4537       true_value = TREE_OPERAND (cond, 1);
4538       false_value = TREE_OPERAND (cond, 2);
4539       /* If this operand throws an expression, then it does not make
4540          sense to try to perform a logical or arithmetic operation
4541          involving it.  Instead of building `a + throw 3' for example,
4542          we simply build `a, throw 3'.  */
4543       if (VOID_TYPE_P (TREE_TYPE (true_value)))
4544         {
4545           if (! cond_first_p)
4546             {
4547               lhs_code = COMPOUND_EXPR;
4548               lhs_type = void_type_node;
4549             }
4550           else
4551             lhs = true_value;
4552         }
4553       if (VOID_TYPE_P (TREE_TYPE (false_value)))
4554         {
4555           if (! cond_first_p)
4556             {
4557               rhs_code = COMPOUND_EXPR;
4558               rhs_type = void_type_node;
4559             }
4560           else
4561             rhs = false_value;
4562         }
4563     }
4564   else
4565     {
4566       tree testtype = TREE_TYPE (cond);
4567       test = cond;
4568       true_value = convert (testtype, integer_one_node);
4569       false_value = convert (testtype, integer_zero_node);
4570     }
4571
4572   /* If ARG is complex we want to make sure we only evaluate
4573      it once.  Though this is only required if it is volatile, it
4574      might be more efficient even if it is not.  However, if we
4575      succeed in folding one part to a constant, we do not need
4576      to make this SAVE_EXPR.  Since we do this optimization
4577      primarily to see if we do end up with constant and this
4578      SAVE_EXPR interferes with later optimizations, suppressing
4579      it when we can is important.
4580
4581      If we are not in a function, we can't make a SAVE_EXPR, so don't
4582      try to do so.  Don't try to see if the result is a constant
4583      if an arm is a COND_EXPR since we get exponential behavior
4584      in that case.  */
4585
4586   if (TREE_CODE (arg) == SAVE_EXPR)
4587     save = 1;
4588   else if (lhs == 0 && rhs == 0
4589            && !TREE_CONSTANT (arg)
4590            && (*lang_hooks.decls.global_bindings_p) () == 0
4591            && ((TREE_CODE (arg) != VAR_DECL && TREE_CODE (arg) != PARM_DECL)
4592                || TREE_SIDE_EFFECTS (arg)))
4593     {
4594       if (TREE_CODE (true_value) != COND_EXPR)
4595         lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4596
4597       if (TREE_CODE (false_value) != COND_EXPR)
4598         rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4599
4600       if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4601           && (rhs == 0 || !TREE_CONSTANT (rhs)))
4602         {
4603           arg = save_expr (arg);
4604           lhs = rhs = 0;
4605           save = 1;
4606         }
4607     }
4608
4609   if (lhs == 0)
4610     lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4611   if (rhs == 0)
4612     rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4613
4614   test = fold (build (COND_EXPR, type, test, lhs, rhs));
4615
4616   if (save)
4617     return build (COMPOUND_EXPR, type,
4618                   convert (void_type_node, arg),
4619                   strip_compound_expr (test, arg));
4620   else
4621     return convert (type, test);
4622 }
4623
4624 \f
4625 /* Subroutine of fold() that checks for the addition of +/- 0.0.
4626
4627    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
4628    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
4629    ADDEND is the same as X.
4630
4631    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
4632    and finite.  The problematic cases are when X is zero, and its mode
4633    has signed zeros.  In the case of rounding towards -infinity,
4634    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
4635    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
4636
4637 static bool
4638 fold_real_zero_addition_p (type, addend, negate)
4639      tree type, addend;
4640      int negate;
4641 {
4642   if (!real_zerop (addend))
4643     return false;
4644
4645   /* Don't allow the fold with -fsignaling-nans.  */
4646   if (HONOR_SNANS (TYPE_MODE (type)))
4647     return false;
4648
4649   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
4650   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
4651     return true;
4652
4653   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
4654   if (TREE_CODE (addend) == REAL_CST
4655       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
4656     negate = !negate;
4657
4658   /* The mode has signed zeros, and we have to honor their sign.
4659      In this situation, there is only one case we can return true for.
4660      X - 0 is the same as X unless rounding towards -infinity is
4661      supported.  */
4662   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
4663 }
4664
4665
4666 /* Perform constant folding and related simplification of EXPR.
4667    The related simplifications include x*1 => x, x*0 => 0, etc.,
4668    and application of the associative law.
4669    NOP_EXPR conversions may be removed freely (as long as we
4670    are careful not to change the C type of the overall expression)
4671    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4672    but we can constant-fold them if they have constant operands.  */
4673
4674 tree
4675 fold (expr)
4676      tree expr;
4677 {
4678   tree t = expr;
4679   tree t1 = NULL_TREE;
4680   tree tem;
4681   tree type = TREE_TYPE (expr);
4682   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4683   enum tree_code code = TREE_CODE (t);
4684   int kind = TREE_CODE_CLASS (code);
4685   int invert;
4686   /* WINS will be nonzero when the switch is done
4687      if all operands are constant.  */
4688   int wins = 1;
4689
4690   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4691      Likewise for a SAVE_EXPR that's already been evaluated.  */
4692   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
4693     return t;
4694
4695   /* Return right away if a constant.  */
4696   if (kind == 'c')
4697     return t;
4698
4699 #ifdef MAX_INTEGER_COMPUTATION_MODE
4700   check_max_integer_computation_mode (expr);
4701 #endif
4702
4703   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4704     {
4705       tree subop;
4706
4707       /* Special case for conversion ops that can have fixed point args.  */
4708       arg0 = TREE_OPERAND (t, 0);
4709
4710       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4711       if (arg0 != 0)
4712         STRIP_SIGN_NOPS (arg0);
4713
4714       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4715         subop = TREE_REALPART (arg0);
4716       else
4717         subop = arg0;
4718
4719       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4720           && TREE_CODE (subop) != REAL_CST
4721           )
4722         /* Note that TREE_CONSTANT isn't enough:
4723            static var addresses are constant but we can't
4724            do arithmetic on them.  */
4725         wins = 0;
4726     }
4727   else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
4728     {
4729       int len = first_rtl_op (code);
4730       int i;
4731       for (i = 0; i < len; i++)
4732         {
4733           tree op = TREE_OPERAND (t, i);
4734           tree subop;
4735
4736           if (op == 0)
4737             continue;           /* Valid for CALL_EXPR, at least.  */
4738
4739           if (kind == '<' || code == RSHIFT_EXPR)
4740             {
4741               /* Signedness matters here.  Perhaps we can refine this
4742                  later.  */
4743               STRIP_SIGN_NOPS (op);
4744             }
4745           else
4746             /* Strip any conversions that don't change the mode.  */
4747             STRIP_NOPS (op);
4748
4749           if (TREE_CODE (op) == COMPLEX_CST)
4750             subop = TREE_REALPART (op);
4751           else
4752             subop = op;
4753
4754           if (TREE_CODE (subop) != INTEGER_CST
4755               && TREE_CODE (subop) != REAL_CST)
4756             /* Note that TREE_CONSTANT isn't enough:
4757                static var addresses are constant but we can't
4758                do arithmetic on them.  */
4759             wins = 0;
4760
4761           if (i == 0)
4762             arg0 = op;
4763           else if (i == 1)
4764             arg1 = op;
4765         }
4766     }
4767
4768   /* If this is a commutative operation, and ARG0 is a constant, move it
4769      to ARG1 to reduce the number of tests below.  */
4770   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4771        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4772        || code == BIT_AND_EXPR)
4773       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4774     {
4775       tem = arg0; arg0 = arg1; arg1 = tem;
4776
4777       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4778       TREE_OPERAND (t, 1) = tem;
4779     }
4780
4781   /* Now WINS is set as described above,
4782      ARG0 is the first operand of EXPR,
4783      and ARG1 is the second operand (if it has more than one operand).
4784
4785      First check for cases where an arithmetic operation is applied to a
4786      compound, conditional, or comparison operation.  Push the arithmetic
4787      operation inside the compound or conditional to see if any folding
4788      can then be done.  Convert comparison to conditional for this purpose.
4789      The also optimizes non-constant cases that used to be done in
4790      expand_expr.
4791
4792      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
4793      one of the operands is a comparison and the other is a comparison, a
4794      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
4795      code below would make the expression more complex.  Change it to a
4796      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
4797      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
4798
4799   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4800        || code == EQ_EXPR || code == NE_EXPR)
4801       && ((truth_value_p (TREE_CODE (arg0))
4802            && (truth_value_p (TREE_CODE (arg1))
4803                || (TREE_CODE (arg1) == BIT_AND_EXPR
4804                    && integer_onep (TREE_OPERAND (arg1, 1)))))
4805           || (truth_value_p (TREE_CODE (arg1))
4806               && (truth_value_p (TREE_CODE (arg0))
4807                   || (TREE_CODE (arg0) == BIT_AND_EXPR
4808                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
4809     {
4810       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4811                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4812                        : TRUTH_XOR_EXPR,
4813                        type, arg0, arg1));
4814
4815       if (code == EQ_EXPR)
4816         t = invert_truthvalue (t);
4817
4818       return t;
4819     }
4820
4821   if (TREE_CODE_CLASS (code) == '1')
4822     {
4823       if (TREE_CODE (arg0) == COMPOUND_EXPR)
4824         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4825                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4826       else if (TREE_CODE (arg0) == COND_EXPR)
4827         {
4828           tree arg01 = TREE_OPERAND (arg0, 1);
4829           tree arg02 = TREE_OPERAND (arg0, 2);
4830           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
4831             arg01 = fold (build1 (code, type, arg01));
4832           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
4833             arg02 = fold (build1 (code, type, arg02));
4834           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4835                            arg01, arg02));
4836
4837           /* If this was a conversion, and all we did was to move into
4838              inside the COND_EXPR, bring it back out.  But leave it if
4839              it is a conversion from integer to integer and the
4840              result precision is no wider than a word since such a
4841              conversion is cheap and may be optimized away by combine,
4842              while it couldn't if it were outside the COND_EXPR.  Then return
4843              so we don't get into an infinite recursion loop taking the
4844              conversion out and then back in.  */
4845
4846           if ((code == NOP_EXPR || code == CONVERT_EXPR
4847                || code == NON_LVALUE_EXPR)
4848               && TREE_CODE (t) == COND_EXPR
4849               && TREE_CODE (TREE_OPERAND (t, 1)) == code
4850               && TREE_CODE (TREE_OPERAND (t, 2)) == code
4851               && ! VOID_TYPE_P (TREE_OPERAND (t, 1))
4852               && ! VOID_TYPE_P (TREE_OPERAND (t, 2))
4853               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4854                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4855               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4856                     && (INTEGRAL_TYPE_P
4857                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
4858                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4859             t = build1 (code, type,
4860                         build (COND_EXPR,
4861                                TREE_TYPE (TREE_OPERAND
4862                                           (TREE_OPERAND (t, 1), 0)),
4863                                TREE_OPERAND (t, 0),
4864                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4865                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4866           return t;
4867         }
4868       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4869         return fold (build (COND_EXPR, type, arg0,
4870                             fold (build1 (code, type, integer_one_node)),
4871                             fold (build1 (code, type, integer_zero_node))));
4872    }
4873   else if (TREE_CODE_CLASS (code) == '2'
4874            || TREE_CODE_CLASS (code) == '<')
4875     {
4876       if (TREE_CODE (arg1) == COMPOUND_EXPR
4877           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg1, 0))
4878           && ! TREE_SIDE_EFFECTS (arg0))
4879         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4880                       fold (build (code, type,
4881                                    arg0, TREE_OPERAND (arg1, 1))));
4882       else if ((TREE_CODE (arg1) == COND_EXPR
4883                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4884                     && TREE_CODE_CLASS (code) != '<'))
4885                && (TREE_CODE (arg0) != COND_EXPR
4886                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4887                && (! TREE_SIDE_EFFECTS (arg0)
4888                    || ((*lang_hooks.decls.global_bindings_p) () == 0
4889                        && ! contains_placeholder_p (arg0))))
4890         return
4891           fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
4892                                                /*cond_first_p=*/0);
4893       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4894         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4895                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4896       else if ((TREE_CODE (arg0) == COND_EXPR
4897                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4898                     && TREE_CODE_CLASS (code) != '<'))
4899                && (TREE_CODE (arg1) != COND_EXPR
4900                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4901                && (! TREE_SIDE_EFFECTS (arg1)
4902                    || ((*lang_hooks.decls.global_bindings_p) () == 0
4903                        && ! contains_placeholder_p (arg1))))
4904         return
4905           fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
4906                                                /*cond_first_p=*/1);
4907     }
4908   else if (TREE_CODE_CLASS (code) == '<'
4909            && TREE_CODE (arg0) == COMPOUND_EXPR)
4910     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4911                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4912   else if (TREE_CODE_CLASS (code) == '<'
4913            && TREE_CODE (arg1) == COMPOUND_EXPR)
4914     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4915                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4916
4917   switch (code)
4918     {
4919     case INTEGER_CST:
4920     case REAL_CST:
4921     case VECTOR_CST:
4922     case STRING_CST:
4923     case COMPLEX_CST:
4924     case CONSTRUCTOR:
4925       return t;
4926
4927     case CONST_DECL:
4928       return fold (DECL_INITIAL (t));
4929
4930     case NOP_EXPR:
4931     case FLOAT_EXPR:
4932     case CONVERT_EXPR:
4933     case FIX_TRUNC_EXPR:
4934       /* Other kinds of FIX are not handled properly by fold_convert.  */
4935
4936       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4937         return TREE_OPERAND (t, 0);
4938
4939       /* Handle cases of two conversions in a row.  */
4940       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4941           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4942         {
4943           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4944           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4945           tree final_type = TREE_TYPE (t);
4946           int inside_int = INTEGRAL_TYPE_P (inside_type);
4947           int inside_ptr = POINTER_TYPE_P (inside_type);
4948           int inside_float = FLOAT_TYPE_P (inside_type);
4949           unsigned int inside_prec = TYPE_PRECISION (inside_type);
4950           int inside_unsignedp = TREE_UNSIGNED (inside_type);
4951           int inter_int = INTEGRAL_TYPE_P (inter_type);
4952           int inter_ptr = POINTER_TYPE_P (inter_type);
4953           int inter_float = FLOAT_TYPE_P (inter_type);
4954           unsigned int inter_prec = TYPE_PRECISION (inter_type);
4955           int inter_unsignedp = TREE_UNSIGNED (inter_type);
4956           int final_int = INTEGRAL_TYPE_P (final_type);
4957           int final_ptr = POINTER_TYPE_P (final_type);
4958           int final_float = FLOAT_TYPE_P (final_type);
4959           unsigned int final_prec = TYPE_PRECISION (final_type);
4960           int final_unsignedp = TREE_UNSIGNED (final_type);
4961
4962           /* In addition to the cases of two conversions in a row
4963              handled below, if we are converting something to its own
4964              type via an object of identical or wider precision, neither
4965              conversion is needed.  */
4966           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
4967               && ((inter_int && final_int) || (inter_float && final_float))
4968               && inter_prec >= final_prec)
4969             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4970
4971           /* Likewise, if the intermediate and final types are either both
4972              float or both integer, we don't need the middle conversion if
4973              it is wider than the final type and doesn't change the signedness
4974              (for integers).  Avoid this if the final type is a pointer
4975              since then we sometimes need the inner conversion.  Likewise if
4976              the outer has a precision not equal to the size of its mode.  */
4977           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4978                || (inter_float && inside_float))
4979               && inter_prec >= inside_prec
4980               && (inter_float || inter_unsignedp == inside_unsignedp)
4981               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4982                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4983               && ! final_ptr)
4984             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4985
4986           /* If we have a sign-extension of a zero-extended value, we can
4987              replace that by a single zero-extension.  */
4988           if (inside_int && inter_int && final_int
4989               && inside_prec < inter_prec && inter_prec < final_prec
4990               && inside_unsignedp && !inter_unsignedp)
4991             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4992
4993           /* Two conversions in a row are not needed unless:
4994              - some conversion is floating-point (overstrict for now), or
4995              - the intermediate type is narrower than both initial and
4996                final, or
4997              - the intermediate type and innermost type differ in signedness,
4998                and the outermost type is wider than the intermediate, or
4999              - the initial type is a pointer type and the precisions of the
5000                intermediate and final types differ, or
5001              - the final type is a pointer type and the precisions of the
5002                initial and intermediate types differ.  */
5003           if (! inside_float && ! inter_float && ! final_float
5004               && (inter_prec > inside_prec || inter_prec > final_prec)
5005               && ! (inside_int && inter_int
5006                     && inter_unsignedp != inside_unsignedp
5007                     && inter_prec < final_prec)
5008               && ((inter_unsignedp && inter_prec > inside_prec)
5009                   == (final_unsignedp && final_prec > inter_prec))
5010               && ! (inside_ptr && inter_prec != final_prec)
5011               && ! (final_ptr && inside_prec != inter_prec)
5012               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5013                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5014               && ! final_ptr)
5015             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5016         }
5017
5018       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5019           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5020           /* Detect assigning a bitfield.  */
5021           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5022                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5023         {
5024           /* Don't leave an assignment inside a conversion
5025              unless assigning a bitfield.  */
5026           tree prev = TREE_OPERAND (t, 0);
5027           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5028           /* First do the assignment, then return converted constant.  */
5029           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5030           TREE_USED (t) = 1;
5031           return t;
5032         }
5033
5034       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
5035          constants (if x has signed type, the sign bit cannot be set
5036          in c).  This folds extension into the BIT_AND_EXPR.  */
5037       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
5038           && TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE
5039           && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
5040           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
5041         {
5042           tree and = TREE_OPERAND (t, 0);
5043           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
5044           int change = 0;
5045
5046           if (TREE_UNSIGNED (TREE_TYPE (and))
5047               || (TYPE_PRECISION (TREE_TYPE (t))
5048                   <= TYPE_PRECISION (TREE_TYPE (and))))
5049             change = 1;
5050           else if (TYPE_PRECISION (TREE_TYPE (and1))
5051                    <= HOST_BITS_PER_WIDE_INT
5052                    && host_integerp (and1, 1))
5053             {
5054               unsigned HOST_WIDE_INT cst;
5055
5056               cst = tree_low_cst (and1, 1);
5057               cst &= (HOST_WIDE_INT) -1
5058                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
5059               change = (cst == 0);
5060 #ifdef LOAD_EXTEND_OP
5061               if (change
5062                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
5063                       == ZERO_EXTEND))
5064                 {
5065                   tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
5066                   and0 = convert (uns, and0);
5067                   and1 = convert (uns, and1);
5068                 }
5069 #endif
5070             }
5071           if (change)
5072             return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
5073                                 convert (TREE_TYPE (t), and0),
5074                                 convert (TREE_TYPE (t), and1)));
5075         }
5076
5077       if (!wins)
5078         {
5079           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5080           return t;
5081         }
5082       return fold_convert (t, arg0);
5083
5084     case VIEW_CONVERT_EXPR:
5085       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
5086         return build1 (VIEW_CONVERT_EXPR, type,
5087                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5088       return t;
5089
5090     case COMPONENT_REF:
5091       if (TREE_CODE (arg0) == CONSTRUCTOR)
5092         {
5093           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5094           if (m)
5095             t = TREE_VALUE (m);
5096         }
5097       return t;
5098
5099     case RANGE_EXPR:
5100       TREE_CONSTANT (t) = wins;
5101       return t;
5102
5103     case NEGATE_EXPR:
5104       if (wins)
5105         {
5106           if (TREE_CODE (arg0) == INTEGER_CST)
5107             {
5108               unsigned HOST_WIDE_INT low;
5109               HOST_WIDE_INT high;
5110               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5111                                          TREE_INT_CST_HIGH (arg0),
5112                                          &low, &high);
5113               t = build_int_2 (low, high);
5114               TREE_TYPE (t) = type;
5115               TREE_OVERFLOW (t)
5116                 = (TREE_OVERFLOW (arg0)
5117                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5118               TREE_CONSTANT_OVERFLOW (t)
5119                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5120             }
5121           else if (TREE_CODE (arg0) == REAL_CST)
5122             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5123         }
5124       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5125         return TREE_OPERAND (arg0, 0);
5126       /* Convert -((double)float) into (double)(-float).  */
5127       else if (TREE_CODE (arg0) == NOP_EXPR
5128                && TREE_CODE (type) == REAL_TYPE)
5129         {
5130           tree targ0 = strip_float_extensions (arg0);
5131           if (targ0 != arg0)
5132             return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (targ0), targ0));
5133
5134         }
5135
5136       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5137       else if (TREE_CODE (arg0) == MINUS_EXPR
5138                && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
5139         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5140                       TREE_OPERAND (arg0, 0));
5141
5142       return t;
5143
5144     case ABS_EXPR:
5145       if (wins)
5146         {
5147           if (TREE_CODE (arg0) == INTEGER_CST)
5148             {
5149               /* If the value is unsigned, then the absolute value is
5150                  the same as the ordinary value.  */
5151               if (TREE_UNSIGNED (type))
5152                 return arg0;
5153               /* Similarly, if the value is non-negative.  */
5154               else if (INT_CST_LT (integer_minus_one_node, arg0))
5155                 return arg0;
5156               /* If the value is negative, then the absolute value is
5157                  its negation.  */
5158               else
5159                 {
5160                   unsigned HOST_WIDE_INT low;
5161                   HOST_WIDE_INT high;
5162                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5163                                              TREE_INT_CST_HIGH (arg0),
5164                                              &low, &high);
5165                   t = build_int_2 (low, high);
5166                   TREE_TYPE (t) = type;
5167                   TREE_OVERFLOW (t)
5168                     = (TREE_OVERFLOW (arg0)
5169                        | force_fit_type (t, overflow));
5170                   TREE_CONSTANT_OVERFLOW (t)
5171                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5172                 }
5173             }
5174           else if (TREE_CODE (arg0) == REAL_CST)
5175             {
5176               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5177                 t = build_real (type,
5178                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5179             }
5180         }
5181       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5182         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5183       /* Convert fabs((double)float) into (double)fabsf(float).  */
5184       else if (TREE_CODE (arg0) == NOP_EXPR
5185                && TREE_CODE (type) == REAL_TYPE)
5186         {
5187           tree targ0 = strip_float_extensions (arg0);
5188           if (targ0 != arg0)
5189             return convert (type, build1 (ABS_EXPR, TREE_TYPE (targ0), targ0));
5190
5191         }
5192       else
5193         {
5194           /* fabs(sqrt(x)) = sqrt(x) and fabs(exp(x)) = exp(x).  */
5195           enum built_in_function fcode = builtin_mathfn_code (arg0);
5196           if (fcode == BUILT_IN_SQRT
5197               || fcode == BUILT_IN_SQRTF
5198               || fcode == BUILT_IN_SQRTL
5199               || fcode == BUILT_IN_EXP
5200               || fcode == BUILT_IN_EXPF
5201               || fcode == BUILT_IN_EXPL)
5202             t = arg0;
5203         }
5204       return t;
5205
5206     case CONJ_EXPR:
5207       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5208         return convert (type, arg0);
5209       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5210         return build (COMPLEX_EXPR, type,
5211                       TREE_OPERAND (arg0, 0),
5212                       negate_expr (TREE_OPERAND (arg0, 1)));
5213       else if (TREE_CODE (arg0) == COMPLEX_CST)
5214         return build_complex (type, TREE_REALPART (arg0),
5215                               negate_expr (TREE_IMAGPART (arg0)));
5216       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5217         return fold (build (TREE_CODE (arg0), type,
5218                             fold (build1 (CONJ_EXPR, type,
5219                                           TREE_OPERAND (arg0, 0))),
5220                             fold (build1 (CONJ_EXPR,
5221                                           type, TREE_OPERAND (arg0, 1)))));
5222       else if (TREE_CODE (arg0) == CONJ_EXPR)
5223         return TREE_OPERAND (arg0, 0);
5224       return t;
5225
5226     case BIT_NOT_EXPR:
5227       if (wins)
5228         {
5229           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5230                            ~ TREE_INT_CST_HIGH (arg0));
5231           TREE_TYPE (t) = type;
5232           force_fit_type (t, 0);
5233           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5234           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5235         }
5236       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5237         return TREE_OPERAND (arg0, 0);
5238       return t;
5239
5240     case PLUS_EXPR:
5241       /* A + (-B) -> A - B */
5242       if (TREE_CODE (arg1) == NEGATE_EXPR)
5243         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5244       /* (-A) + B -> B - A */
5245       if (TREE_CODE (arg0) == NEGATE_EXPR)
5246         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5247       else if (! FLOAT_TYPE_P (type))
5248         {
5249           if (integer_zerop (arg1))
5250             return non_lvalue (convert (type, arg0));
5251
5252           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5253              with a constant, and the two constants have no bits in common,
5254              we should treat this as a BIT_IOR_EXPR since this may produce more
5255              simplifications.  */
5256           if (TREE_CODE (arg0) == BIT_AND_EXPR
5257               && TREE_CODE (arg1) == BIT_AND_EXPR
5258               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5259               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5260               && integer_zerop (const_binop (BIT_AND_EXPR,
5261                                              TREE_OPERAND (arg0, 1),
5262                                              TREE_OPERAND (arg1, 1), 0)))
5263             {
5264               code = BIT_IOR_EXPR;
5265               goto bit_ior;
5266             }
5267
5268           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5269              (plus (plus (mult) (mult)) (foo)) so that we can
5270              take advantage of the factoring cases below.  */
5271           if ((TREE_CODE (arg0) == PLUS_EXPR
5272                && TREE_CODE (arg1) == MULT_EXPR)
5273               || (TREE_CODE (arg1) == PLUS_EXPR
5274                   && TREE_CODE (arg0) == MULT_EXPR))
5275             {
5276               tree parg0, parg1, parg, marg;
5277
5278               if (TREE_CODE (arg0) == PLUS_EXPR)
5279                 parg = arg0, marg = arg1;
5280               else
5281                 parg = arg1, marg = arg0;
5282               parg0 = TREE_OPERAND (parg, 0);
5283               parg1 = TREE_OPERAND (parg, 1);
5284               STRIP_NOPS (parg0);
5285               STRIP_NOPS (parg1);
5286
5287               if (TREE_CODE (parg0) == MULT_EXPR
5288                   && TREE_CODE (parg1) != MULT_EXPR)
5289                 return fold (build (PLUS_EXPR, type,
5290                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5291                                     parg1));
5292               if (TREE_CODE (parg0) != MULT_EXPR
5293                   && TREE_CODE (parg1) == MULT_EXPR)
5294                 return fold (build (PLUS_EXPR, type,
5295                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5296                                     parg0));
5297             }
5298
5299           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5300             {
5301               tree arg00, arg01, arg10, arg11;
5302               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5303
5304               /* (A * C) + (B * C) -> (A+B) * C.
5305                  We are most concerned about the case where C is a constant,
5306                  but other combinations show up during loop reduction.  Since
5307                  it is not difficult, try all four possibilities.  */
5308
5309               arg00 = TREE_OPERAND (arg0, 0);
5310               arg01 = TREE_OPERAND (arg0, 1);
5311               arg10 = TREE_OPERAND (arg1, 0);
5312               arg11 = TREE_OPERAND (arg1, 1);
5313               same = NULL_TREE;
5314
5315               if (operand_equal_p (arg01, arg11, 0))
5316                 same = arg01, alt0 = arg00, alt1 = arg10;
5317               else if (operand_equal_p (arg00, arg10, 0))
5318                 same = arg00, alt0 = arg01, alt1 = arg11;
5319               else if (operand_equal_p (arg00, arg11, 0))
5320                 same = arg00, alt0 = arg01, alt1 = arg10;
5321               else if (operand_equal_p (arg01, arg10, 0))
5322                 same = arg01, alt0 = arg00, alt1 = arg11;
5323
5324               /* No identical multiplicands; see if we can find a common
5325                  power-of-two factor in non-power-of-two multiplies.  This
5326                  can help in multi-dimensional array access.  */
5327               else if (TREE_CODE (arg01) == INTEGER_CST
5328                        && TREE_CODE (arg11) == INTEGER_CST
5329                        && TREE_INT_CST_HIGH (arg01) == 0
5330                        && TREE_INT_CST_HIGH (arg11) == 0)
5331                 {
5332                   HOST_WIDE_INT int01, int11, tmp;
5333                   int01 = TREE_INT_CST_LOW (arg01);
5334                   int11 = TREE_INT_CST_LOW (arg11);
5335
5336                   /* Move min of absolute values to int11.  */
5337                   if ((int01 >= 0 ? int01 : -int01)
5338                       < (int11 >= 0 ? int11 : -int11))
5339                     {
5340                       tmp = int01, int01 = int11, int11 = tmp;
5341                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5342                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5343                     }
5344
5345                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5346                     {
5347                       alt0 = fold (build (MULT_EXPR, type, arg00,
5348                                           build_int_2 (int01 / int11, 0)));
5349                       alt1 = arg10;
5350                       same = arg11;
5351                     }
5352                 }
5353
5354               if (same)
5355                 return fold (build (MULT_EXPR, type,
5356                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5357                                     same));
5358             }
5359         }
5360
5361       /* See if ARG1 is zero and X + ARG1 reduces to X.  */
5362       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
5363         return non_lvalue (convert (type, arg0));
5364
5365       /* Likewise if the operands are reversed.  */
5366       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5367         return non_lvalue (convert (type, arg1));
5368
5369      bit_rotate:
5370       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5371          is a rotate of A by C1 bits.  */
5372       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5373          is a rotate of A by B bits.  */
5374       {
5375         enum tree_code code0, code1;
5376         code0 = TREE_CODE (arg0);
5377         code1 = TREE_CODE (arg1);
5378         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5379              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5380             && operand_equal_p (TREE_OPERAND (arg0, 0),
5381                                 TREE_OPERAND (arg1, 0), 0)
5382             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5383           {
5384             tree tree01, tree11;
5385             enum tree_code code01, code11;
5386
5387             tree01 = TREE_OPERAND (arg0, 1);
5388             tree11 = TREE_OPERAND (arg1, 1);
5389             STRIP_NOPS (tree01);
5390             STRIP_NOPS (tree11);
5391             code01 = TREE_CODE (tree01);
5392             code11 = TREE_CODE (tree11);
5393             if (code01 == INTEGER_CST
5394                 && code11 == INTEGER_CST
5395                 && TREE_INT_CST_HIGH (tree01) == 0
5396                 && TREE_INT_CST_HIGH (tree11) == 0
5397                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5398                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5399               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5400                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5401             else if (code11 == MINUS_EXPR)
5402               {
5403                 tree tree110, tree111;
5404                 tree110 = TREE_OPERAND (tree11, 0);
5405                 tree111 = TREE_OPERAND (tree11, 1);
5406                 STRIP_NOPS (tree110);
5407                 STRIP_NOPS (tree111);
5408                 if (TREE_CODE (tree110) == INTEGER_CST
5409                     && 0 == compare_tree_int (tree110,
5410                                               TYPE_PRECISION
5411                                               (TREE_TYPE (TREE_OPERAND
5412                                                           (arg0, 0))))
5413                     && operand_equal_p (tree01, tree111, 0))
5414                   return build ((code0 == LSHIFT_EXPR
5415                                  ? LROTATE_EXPR
5416                                  : RROTATE_EXPR),
5417                                 type, TREE_OPERAND (arg0, 0), tree01);
5418               }
5419             else if (code01 == MINUS_EXPR)
5420               {
5421                 tree tree010, tree011;
5422                 tree010 = TREE_OPERAND (tree01, 0);
5423                 tree011 = TREE_OPERAND (tree01, 1);
5424                 STRIP_NOPS (tree010);
5425                 STRIP_NOPS (tree011);
5426                 if (TREE_CODE (tree010) == INTEGER_CST
5427                     && 0 == compare_tree_int (tree010,
5428                                               TYPE_PRECISION
5429                                               (TREE_TYPE (TREE_OPERAND
5430                                                           (arg0, 0))))
5431                     && operand_equal_p (tree11, tree011, 0))
5432                   return build ((code0 != LSHIFT_EXPR
5433                                  ? LROTATE_EXPR
5434                                  : RROTATE_EXPR),
5435                                 type, TREE_OPERAND (arg0, 0), tree11);
5436               }
5437           }
5438       }
5439
5440     associate:
5441       /* In most languages, can't associate operations on floats through
5442          parentheses.  Rather than remember where the parentheses were, we
5443          don't associate floats at all.  It shouldn't matter much.  However,
5444          associating multiplications is only very slightly inaccurate, so do
5445          that if -funsafe-math-optimizations is specified.  */
5446
5447       if (! wins
5448           && (! FLOAT_TYPE_P (type)
5449               || (flag_unsafe_math_optimizations && code == MULT_EXPR)))
5450         {
5451           tree var0, con0, lit0, minus_lit0;
5452           tree var1, con1, lit1, minus_lit1;
5453
5454           /* Split both trees into variables, constants, and literals.  Then
5455              associate each group together, the constants with literals,
5456              then the result with variables.  This increases the chances of
5457              literals being recombined later and of generating relocatable
5458              expressions for the sum of a constant and literal.  */
5459           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
5460           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
5461                              code == MINUS_EXPR);
5462
5463           /* Only do something if we found more than two objects.  Otherwise,
5464              nothing has changed and we risk infinite recursion.  */
5465           if (2 < ((var0 != 0) + (var1 != 0)
5466                    + (con0 != 0) + (con1 != 0)
5467                    + (lit0 != 0) + (lit1 != 0)
5468                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
5469             {
5470               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
5471               if (code == MINUS_EXPR)
5472                 code = PLUS_EXPR;
5473
5474               var0 = associate_trees (var0, var1, code, type);
5475               con0 = associate_trees (con0, con1, code, type);
5476               lit0 = associate_trees (lit0, lit1, code, type);
5477               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
5478
5479               /* Preserve the MINUS_EXPR if the negative part of the literal is
5480                  greater than the positive part.  Otherwise, the multiplicative
5481                  folding code (i.e extract_muldiv) may be fooled in case
5482                  unsigned constants are substracted, like in the following
5483                  example: ((X*2 + 4) - 8U)/2.  */
5484               if (minus_lit0 && lit0)
5485                 {
5486                   if (tree_int_cst_lt (lit0, minus_lit0))
5487                     {
5488                       minus_lit0 = associate_trees (minus_lit0, lit0,
5489                                                     MINUS_EXPR, type);
5490                       lit0 = 0;
5491                     }
5492                   else
5493                     {
5494                       lit0 = associate_trees (lit0, minus_lit0,
5495                                               MINUS_EXPR, type);
5496                       minus_lit0 = 0;
5497                     }
5498                 }
5499               if (minus_lit0)
5500                 {
5501                   if (con0 == 0)
5502                     return convert (type, associate_trees (var0, minus_lit0,
5503                                                            MINUS_EXPR, type));
5504                   else
5505                     {
5506                       con0 = associate_trees (con0, minus_lit0,
5507                                               MINUS_EXPR, type);
5508                       return convert (type, associate_trees (var0, con0,
5509                                                              PLUS_EXPR, type));
5510                     }
5511                 }
5512
5513               con0 = associate_trees (con0, lit0, code, type);
5514               return convert (type, associate_trees (var0, con0, code, type));
5515             }
5516         }
5517
5518     binary:
5519       if (wins)
5520         t1 = const_binop (code, arg0, arg1, 0);
5521       if (t1 != NULL_TREE)
5522         {
5523           /* The return value should always have
5524              the same type as the original expression.  */
5525           if (TREE_TYPE (t1) != TREE_TYPE (t))
5526             t1 = convert (TREE_TYPE (t), t1);
5527
5528           return t1;
5529         }
5530       return t;
5531
5532     case MINUS_EXPR:
5533       /* A - (-B) -> A + B */
5534       if (TREE_CODE (arg1) == NEGATE_EXPR)
5535         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5536       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
5537       if (TREE_CODE (arg0) == NEGATE_EXPR
5538           && FLOAT_TYPE_P (type)
5539           && negate_expr_p (arg1)
5540           && (! TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
5541           && (! TREE_SIDE_EFFECTS (arg1) || TREE_CONSTANT (arg0)))
5542         return fold (build (MINUS_EXPR, type, negate_expr (arg1),
5543                             TREE_OPERAND (arg0, 0)));
5544
5545       if (! FLOAT_TYPE_P (type))
5546         {
5547           if (! wins && integer_zerop (arg0))
5548             return negate_expr (convert (type, arg1));
5549           if (integer_zerop (arg1))
5550             return non_lvalue (convert (type, arg0));
5551
5552           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5553              about the case where C is a constant, just try one of the
5554              four possibilities.  */
5555
5556           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5557               && operand_equal_p (TREE_OPERAND (arg0, 1),
5558                                   TREE_OPERAND (arg1, 1), 0))
5559             return fold (build (MULT_EXPR, type,
5560                                 fold (build (MINUS_EXPR, type,
5561                                              TREE_OPERAND (arg0, 0),
5562                                              TREE_OPERAND (arg1, 0))),
5563                                 TREE_OPERAND (arg0, 1)));
5564         }
5565
5566       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
5567       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
5568         return non_lvalue (convert (type, arg0));
5569
5570       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
5571          ARG0 is zero and X + ARG0 reduces to X, since that would mean
5572          (-ARG1 + ARG0) reduces to -ARG1.  */
5573       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5574         return negate_expr (convert (type, arg1));
5575
5576       /* Fold &x - &x.  This can happen from &x.foo - &x.
5577          This is unsafe for certain floats even in non-IEEE formats.
5578          In IEEE, it is unsafe because it does wrong for NaNs.
5579          Also note that operand_equal_p is always false if an operand
5580          is volatile.  */
5581
5582       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
5583           && operand_equal_p (arg0, arg1, 0))
5584         return convert (type, integer_zero_node);
5585
5586       goto associate;
5587
5588     case MULT_EXPR:
5589       /* (-A) * (-B) -> A * B  */
5590       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5591         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5592                             TREE_OPERAND (arg1, 0)));
5593
5594       if (! FLOAT_TYPE_P (type))
5595         {
5596           if (integer_zerop (arg1))
5597             return omit_one_operand (type, arg1, arg0);
5598           if (integer_onep (arg1))
5599             return non_lvalue (convert (type, arg0));
5600
5601           /* (a * (1 << b)) is (a << b)  */
5602           if (TREE_CODE (arg1) == LSHIFT_EXPR
5603               && integer_onep (TREE_OPERAND (arg1, 0)))
5604             return fold (build (LSHIFT_EXPR, type, arg0,
5605                                 TREE_OPERAND (arg1, 1)));
5606           if (TREE_CODE (arg0) == LSHIFT_EXPR
5607               && integer_onep (TREE_OPERAND (arg0, 0)))
5608             return fold (build (LSHIFT_EXPR, type, arg1,
5609                                 TREE_OPERAND (arg0, 1)));
5610
5611           if (TREE_CODE (arg1) == INTEGER_CST
5612               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5613                                              code, NULL_TREE)))
5614             return convert (type, tem);
5615
5616         }
5617       else
5618         {
5619           /* Maybe fold x * 0 to 0.  The expressions aren't the same
5620              when x is NaN, since x * 0 is also NaN.  Nor are they the
5621              same in modes with signed zeros, since multiplying a
5622              negative value by 0 gives -0, not +0.  */
5623           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
5624               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
5625               && real_zerop (arg1))
5626             return omit_one_operand (type, arg1, arg0);
5627           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
5628           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5629               && real_onep (arg1))
5630             return non_lvalue (convert (type, arg0));
5631
5632           /* Transform x * -1.0 into -x.  */
5633           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5634               && real_minus_onep (arg1))
5635             return fold (build1 (NEGATE_EXPR, type, arg0));
5636
5637           /* x*2 is x+x */
5638           if (! wins && real_twop (arg1)
5639               && (*lang_hooks.decls.global_bindings_p) () == 0
5640               && ! contains_placeholder_p (arg0))
5641             {
5642               tree arg = save_expr (arg0);
5643               return build (PLUS_EXPR, type, arg, arg);
5644             }
5645
5646           if (flag_unsafe_math_optimizations)
5647             {
5648               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
5649               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
5650
5651               /* Optimize sqrt(x)*sqrt(y) as sqrt(x*y).  */
5652               if ((fcode0 == BUILT_IN_SQRT && fcode1 == BUILT_IN_SQRT)
5653                   || (fcode0 == BUILT_IN_SQRTF && fcode1 == BUILT_IN_SQRTF)
5654                   || (fcode0 == BUILT_IN_SQRTL && fcode1 == BUILT_IN_SQRTL))
5655                 {
5656                   tree sqrtfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5657                   tree arg = build (MULT_EXPR, type,
5658                                     TREE_VALUE (TREE_OPERAND (arg0, 1)),
5659                                     TREE_VALUE (TREE_OPERAND (arg1, 1)));
5660                   tree arglist = build_tree_list (NULL_TREE, arg);
5661                   return fold (build_function_call_expr (sqrtfn, arglist));
5662                 }
5663
5664               /* Optimize exp(x)*exp(y) as exp(x+y).  */
5665               if ((fcode0 == BUILT_IN_EXP && fcode1 == BUILT_IN_EXP)
5666                   || (fcode0 == BUILT_IN_EXPF && fcode1 == BUILT_IN_EXPF)
5667                   || (fcode0 == BUILT_IN_EXPL && fcode1 == BUILT_IN_EXPL))
5668                 {
5669                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5670                   tree arg = build (PLUS_EXPR, type,
5671                                     TREE_VALUE (TREE_OPERAND (arg0, 1)),
5672                                     TREE_VALUE (TREE_OPERAND (arg1, 1)));
5673                   tree arglist = build_tree_list (NULL_TREE, arg);
5674                   return fold (build_function_call_expr (expfn, arglist));
5675                 }
5676             }
5677         }
5678       goto associate;
5679
5680     case BIT_IOR_EXPR:
5681     bit_ior:
5682       if (integer_all_onesp (arg1))
5683         return omit_one_operand (type, arg1, arg0);
5684       if (integer_zerop (arg1))
5685         return non_lvalue (convert (type, arg0));
5686       t1 = distribute_bit_expr (code, type, arg0, arg1);
5687       if (t1 != NULL_TREE)
5688         return t1;
5689
5690       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5691
5692          This results in more efficient code for machines without a NAND
5693          instruction.  Combine will canonicalize to the first form
5694          which will allow use of NAND instructions provided by the
5695          backend if they exist.  */
5696       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5697           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5698         {
5699           return fold (build1 (BIT_NOT_EXPR, type,
5700                                build (BIT_AND_EXPR, type,
5701                                       TREE_OPERAND (arg0, 0),
5702                                       TREE_OPERAND (arg1, 0))));
5703         }
5704
5705       /* See if this can be simplified into a rotate first.  If that
5706          is unsuccessful continue in the association code.  */
5707       goto bit_rotate;
5708
5709     case BIT_XOR_EXPR:
5710       if (integer_zerop (arg1))
5711         return non_lvalue (convert (type, arg0));
5712       if (integer_all_onesp (arg1))
5713         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5714
5715       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5716          with a constant, and the two constants have no bits in common,
5717          we should treat this as a BIT_IOR_EXPR since this may produce more
5718          simplifications.  */
5719       if (TREE_CODE (arg0) == BIT_AND_EXPR
5720           && TREE_CODE (arg1) == BIT_AND_EXPR
5721           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5722           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5723           && integer_zerop (const_binop (BIT_AND_EXPR,
5724                                          TREE_OPERAND (arg0, 1),
5725                                          TREE_OPERAND (arg1, 1), 0)))
5726         {
5727           code = BIT_IOR_EXPR;
5728           goto bit_ior;
5729         }
5730
5731       /* See if this can be simplified into a rotate first.  If that
5732          is unsuccessful continue in the association code.  */
5733       goto bit_rotate;
5734
5735     case BIT_AND_EXPR:
5736     bit_and:
5737       if (integer_all_onesp (arg1))
5738         return non_lvalue (convert (type, arg0));
5739       if (integer_zerop (arg1))
5740         return omit_one_operand (type, arg1, arg0);
5741       t1 = distribute_bit_expr (code, type, arg0, arg1);
5742       if (t1 != NULL_TREE)
5743         return t1;
5744       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5745       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5746           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5747         {
5748           unsigned int prec
5749             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5750
5751           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5752               && (~TREE_INT_CST_LOW (arg1)
5753                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5754             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5755         }
5756
5757       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5758
5759          This results in more efficient code for machines without a NOR
5760          instruction.  Combine will canonicalize to the first form
5761          which will allow use of NOR instructions provided by the
5762          backend if they exist.  */
5763       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5764           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5765         {
5766           return fold (build1 (BIT_NOT_EXPR, type,
5767                                build (BIT_IOR_EXPR, type,
5768                                       TREE_OPERAND (arg0, 0),
5769                                       TREE_OPERAND (arg1, 0))));
5770         }
5771
5772       goto associate;
5773
5774     case BIT_ANDTC_EXPR:
5775       if (integer_all_onesp (arg0))
5776         return non_lvalue (convert (type, arg1));
5777       if (integer_zerop (arg0))
5778         return omit_one_operand (type, arg0, arg1);
5779       if (TREE_CODE (arg1) == INTEGER_CST)
5780         {
5781           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5782           code = BIT_AND_EXPR;
5783           goto bit_and;
5784         }
5785       goto binary;
5786
5787     case RDIV_EXPR:
5788       /* Don't touch a floating-point divide by zero unless the mode
5789          of the constant can represent infinity.  */
5790       if (TREE_CODE (arg1) == REAL_CST
5791           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
5792           && real_zerop (arg1))
5793         return t;
5794
5795       /* (-A) / (-B) -> A / B  */
5796       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5797         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5798                             TREE_OPERAND (arg1, 0)));
5799
5800       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
5801       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5802           && real_onep (arg1))
5803         return non_lvalue (convert (type, arg0));
5804
5805       /* If ARG1 is a constant, we can convert this to a multiply by the
5806          reciprocal.  This does not have the same rounding properties,
5807          so only do this if -funsafe-math-optimizations.  We can actually
5808          always safely do it if ARG1 is a power of two, but it's hard to
5809          tell if it is or not in a portable manner.  */
5810       if (TREE_CODE (arg1) == REAL_CST)
5811         {
5812           if (flag_unsafe_math_optimizations
5813               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5814                                           arg1, 0)))
5815             return fold (build (MULT_EXPR, type, arg0, tem));
5816           /* Find the reciprocal if optimizing and the result is exact.  */
5817           else if (optimize)
5818             {
5819               REAL_VALUE_TYPE r;
5820               r = TREE_REAL_CST (arg1);
5821               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5822                 {
5823                   tem = build_real (type, r);
5824                   return fold (build (MULT_EXPR, type, arg0, tem));
5825                 }
5826             }
5827         }
5828       /* Convert A/B/C to A/(B*C).  */
5829       if (flag_unsafe_math_optimizations
5830           && TREE_CODE (arg0) == RDIV_EXPR)
5831         {
5832           return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5833                               build (MULT_EXPR, type, TREE_OPERAND (arg0, 1),
5834                                      arg1)));
5835         }
5836       /* Convert A/(B/C) to (A/B)*C.  */
5837       if (flag_unsafe_math_optimizations
5838           && TREE_CODE (arg1) == RDIV_EXPR)
5839         {
5840           return fold (build (MULT_EXPR, type,
5841                               build (RDIV_EXPR, type, arg0,
5842                                      TREE_OPERAND (arg1, 0)),
5843                               TREE_OPERAND (arg1, 1)));
5844         }
5845
5846       /* Optimize x/exp(y) into x*exp(-y).  */
5847       if (flag_unsafe_math_optimizations)
5848         {
5849           enum built_in_function fcode = builtin_mathfn_code (arg1);
5850           if (fcode == BUILT_IN_EXP
5851               || fcode == BUILT_IN_EXPF
5852               || fcode == BUILT_IN_EXPL)
5853             {
5854               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
5855               tree arg = build1 (NEGATE_EXPR, type,
5856                                  TREE_VALUE (TREE_OPERAND (arg1, 1)));
5857               tree arglist = build_tree_list (NULL_TREE, arg);
5858               arg1 = build_function_call_expr (expfn, arglist);
5859               return fold (build (MULT_EXPR, type, arg0, arg1));
5860             }
5861         }
5862       goto binary;
5863
5864     case TRUNC_DIV_EXPR:
5865     case ROUND_DIV_EXPR:
5866     case FLOOR_DIV_EXPR:
5867     case CEIL_DIV_EXPR:
5868     case EXACT_DIV_EXPR:
5869       if (integer_onep (arg1))
5870         return non_lvalue (convert (type, arg0));
5871       if (integer_zerop (arg1))
5872         return t;
5873
5874       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5875          operation, EXACT_DIV_EXPR.
5876
5877          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5878          At one time others generated faster code, it's not clear if they do
5879          after the last round to changes to the DIV code in expmed.c.  */
5880       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5881           && multiple_of_p (type, arg0, arg1))
5882         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5883
5884       if (TREE_CODE (arg1) == INTEGER_CST
5885           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5886                                          code, NULL_TREE)))
5887         return convert (type, tem);
5888
5889       goto binary;
5890
5891     case CEIL_MOD_EXPR:
5892     case FLOOR_MOD_EXPR:
5893     case ROUND_MOD_EXPR:
5894     case TRUNC_MOD_EXPR:
5895       if (integer_onep (arg1))
5896         return omit_one_operand (type, integer_zero_node, arg0);
5897       if (integer_zerop (arg1))
5898         return t;
5899
5900       if (TREE_CODE (arg1) == INTEGER_CST
5901           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5902                                          code, NULL_TREE)))
5903         return convert (type, tem);
5904
5905       goto binary;
5906
5907     case LROTATE_EXPR:
5908     case RROTATE_EXPR:
5909       if (integer_all_onesp (arg0))
5910         return omit_one_operand (type, arg0, arg1);
5911       goto shift;
5912
5913     case RSHIFT_EXPR:
5914       /* Optimize -1 >> x for arithmetic right shifts.  */
5915       if (integer_all_onesp (arg0) && ! TREE_UNSIGNED (type))
5916         return omit_one_operand (type, arg0, arg1);
5917       /* ... fall through ...  */
5918
5919     case LSHIFT_EXPR:
5920     shift:
5921       if (integer_zerop (arg1))
5922         return non_lvalue (convert (type, arg0));
5923       if (integer_zerop (arg0))
5924         return omit_one_operand (type, arg0, arg1);
5925
5926       /* Since negative shift count is not well-defined,
5927          don't try to compute it in the compiler.  */
5928       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5929         return t;
5930       /* Rewrite an LROTATE_EXPR by a constant into an
5931          RROTATE_EXPR by a new constant.  */
5932       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5933         {
5934           TREE_SET_CODE (t, RROTATE_EXPR);
5935           code = RROTATE_EXPR;
5936           TREE_OPERAND (t, 1) = arg1
5937             = const_binop
5938               (MINUS_EXPR,
5939                convert (TREE_TYPE (arg1),
5940                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5941                arg1, 0);
5942           if (tree_int_cst_sgn (arg1) < 0)
5943             return t;
5944         }
5945
5946       /* If we have a rotate of a bit operation with the rotate count and
5947          the second operand of the bit operation both constant,
5948          permute the two operations.  */
5949       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5950           && (TREE_CODE (arg0) == BIT_AND_EXPR
5951               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5952               || TREE_CODE (arg0) == BIT_IOR_EXPR
5953               || TREE_CODE (arg0) == BIT_XOR_EXPR)
5954           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5955         return fold (build (TREE_CODE (arg0), type,
5956                             fold (build (code, type,
5957                                          TREE_OPERAND (arg0, 0), arg1)),
5958                             fold (build (code, type,
5959                                          TREE_OPERAND (arg0, 1), arg1))));
5960
5961       /* Two consecutive rotates adding up to the width of the mode can
5962          be ignored.  */
5963       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5964           && TREE_CODE (arg0) == RROTATE_EXPR
5965           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5966           && TREE_INT_CST_HIGH (arg1) == 0
5967           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5968           && ((TREE_INT_CST_LOW (arg1)
5969                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5970               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
5971         return TREE_OPERAND (arg0, 0);
5972
5973       goto binary;
5974
5975     case MIN_EXPR:
5976       if (operand_equal_p (arg0, arg1, 0))
5977         return omit_one_operand (type, arg0, arg1);
5978       if (INTEGRAL_TYPE_P (type)
5979           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5980         return omit_one_operand (type, arg1, arg0);
5981       goto associate;
5982
5983     case MAX_EXPR:
5984       if (operand_equal_p (arg0, arg1, 0))
5985         return omit_one_operand (type, arg0, arg1);
5986       if (INTEGRAL_TYPE_P (type)
5987           && TYPE_MAX_VALUE (type)
5988           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5989         return omit_one_operand (type, arg1, arg0);
5990       goto associate;
5991
5992     case TRUTH_NOT_EXPR:
5993       /* Note that the operand of this must be an int
5994          and its values must be 0 or 1.
5995          ("true" is a fixed value perhaps depending on the language,
5996          but we don't handle values other than 1 correctly yet.)  */
5997       tem = invert_truthvalue (arg0);
5998       /* Avoid infinite recursion.  */
5999       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
6000         return t;
6001       return convert (type, tem);
6002
6003     case TRUTH_ANDIF_EXPR:
6004       /* Note that the operands of this must be ints
6005          and their values must be 0 or 1.
6006          ("true" is a fixed value perhaps depending on the language.)  */
6007       /* If first arg is constant zero, return it.  */
6008       if (integer_zerop (arg0))
6009         return convert (type, arg0);
6010     case TRUTH_AND_EXPR:
6011       /* If either arg is constant true, drop it.  */
6012       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6013         return non_lvalue (convert (type, arg1));
6014       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
6015           /* Preserve sequence points.  */
6016           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6017         return non_lvalue (convert (type, arg0));
6018       /* If second arg is constant zero, result is zero, but first arg
6019          must be evaluated.  */
6020       if (integer_zerop (arg1))
6021         return omit_one_operand (type, arg1, arg0);
6022       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
6023          case will be handled here.  */
6024       if (integer_zerop (arg0))
6025         return omit_one_operand (type, arg0, arg1);
6026
6027     truth_andor:
6028       /* We only do these simplifications if we are optimizing.  */
6029       if (!optimize)
6030         return t;
6031
6032       /* Check for things like (A || B) && (A || C).  We can convert this
6033          to A || (B && C).  Note that either operator can be any of the four
6034          truth and/or operations and the transformation will still be
6035          valid.   Also note that we only care about order for the
6036          ANDIF and ORIF operators.  If B contains side effects, this
6037          might change the truth-value of A.  */
6038       if (TREE_CODE (arg0) == TREE_CODE (arg1)
6039           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
6040               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
6041               || TREE_CODE (arg0) == TRUTH_AND_EXPR
6042               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
6043           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
6044         {
6045           tree a00 = TREE_OPERAND (arg0, 0);
6046           tree a01 = TREE_OPERAND (arg0, 1);
6047           tree a10 = TREE_OPERAND (arg1, 0);
6048           tree a11 = TREE_OPERAND (arg1, 1);
6049           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
6050                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
6051                              && (code == TRUTH_AND_EXPR
6052                                  || code == TRUTH_OR_EXPR));
6053
6054           if (operand_equal_p (a00, a10, 0))
6055             return fold (build (TREE_CODE (arg0), type, a00,
6056                                 fold (build (code, type, a01, a11))));
6057           else if (commutative && operand_equal_p (a00, a11, 0))
6058             return fold (build (TREE_CODE (arg0), type, a00,
6059                                 fold (build (code, type, a01, a10))));
6060           else if (commutative && operand_equal_p (a01, a10, 0))
6061             return fold (build (TREE_CODE (arg0), type, a01,
6062                                 fold (build (code, type, a00, a11))));
6063
6064           /* This case if tricky because we must either have commutative
6065              operators or else A10 must not have side-effects.  */
6066
6067           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
6068                    && operand_equal_p (a01, a11, 0))
6069             return fold (build (TREE_CODE (arg0), type,
6070                                 fold (build (code, type, a00, a10)),
6071                                 a01));
6072         }
6073
6074       /* See if we can build a range comparison.  */
6075       if (0 != (tem = fold_range_test (t)))
6076         return tem;
6077
6078       /* Check for the possibility of merging component references.  If our
6079          lhs is another similar operation, try to merge its rhs with our
6080          rhs.  Then try to merge our lhs and rhs.  */
6081       if (TREE_CODE (arg0) == code
6082           && 0 != (tem = fold_truthop (code, type,
6083                                        TREE_OPERAND (arg0, 1), arg1)))
6084         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6085
6086       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
6087         return tem;
6088
6089       return t;
6090
6091     case TRUTH_ORIF_EXPR:
6092       /* Note that the operands of this must be ints
6093          and their values must be 0 or true.
6094          ("true" is a fixed value perhaps depending on the language.)  */
6095       /* If first arg is constant true, return it.  */
6096       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6097         return convert (type, arg0);
6098     case TRUTH_OR_EXPR:
6099       /* If either arg is constant zero, drop it.  */
6100       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
6101         return non_lvalue (convert (type, arg1));
6102       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
6103           /* Preserve sequence points.  */
6104           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6105         return non_lvalue (convert (type, arg0));
6106       /* If second arg is constant true, result is true, but we must
6107          evaluate first arg.  */
6108       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
6109         return omit_one_operand (type, arg1, arg0);
6110       /* Likewise for first arg, but note this only occurs here for
6111          TRUTH_OR_EXPR.  */
6112       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6113         return omit_one_operand (type, arg0, arg1);
6114       goto truth_andor;
6115
6116     case TRUTH_XOR_EXPR:
6117       /* If either arg is constant zero, drop it.  */
6118       if (integer_zerop (arg0))
6119         return non_lvalue (convert (type, arg1));
6120       if (integer_zerop (arg1))
6121         return non_lvalue (convert (type, arg0));
6122       /* If either arg is constant true, this is a logical inversion.  */
6123       if (integer_onep (arg0))
6124         return non_lvalue (convert (type, invert_truthvalue (arg1)));
6125       if (integer_onep (arg1))
6126         return non_lvalue (convert (type, invert_truthvalue (arg0)));
6127       return t;
6128
6129     case EQ_EXPR:
6130     case NE_EXPR:
6131     case LT_EXPR:
6132     case GT_EXPR:
6133     case LE_EXPR:
6134     case GE_EXPR:
6135       /* If one arg is a real or integer constant, put it last.  */
6136       if ((TREE_CODE (arg0) == INTEGER_CST
6137            && TREE_CODE (arg1) != INTEGER_CST)
6138           || (TREE_CODE (arg0) == REAL_CST
6139               && TREE_CODE (arg0) != REAL_CST))
6140         {
6141           TREE_OPERAND (t, 0) = arg1;
6142           TREE_OPERAND (t, 1) = arg0;
6143           arg0 = TREE_OPERAND (t, 0);
6144           arg1 = TREE_OPERAND (t, 1);
6145           code = swap_tree_comparison (code);
6146           TREE_SET_CODE (t, code);
6147         }
6148
6149       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6150         {
6151           tree targ0 = strip_float_extensions (arg0);
6152           tree targ1 = strip_float_extensions (arg1);
6153           tree newtype = TREE_TYPE (targ0);
6154
6155           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
6156             newtype = TREE_TYPE (targ1);
6157
6158           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
6159           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
6160             return fold (build (code, type, convert (newtype, targ0),
6161                                 convert (newtype, targ1)));
6162
6163           /* (-a) CMP (-b) -> b CMP a  */
6164           if (TREE_CODE (arg0) == NEGATE_EXPR
6165               && TREE_CODE (arg1) == NEGATE_EXPR)
6166             return fold (build (code, type, TREE_OPERAND (arg1, 0),
6167                                 TREE_OPERAND (arg0, 0)));
6168           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
6169           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
6170             return
6171               fold (build
6172                     (swap_tree_comparison (code), type,
6173                      TREE_OPERAND (arg0, 0),
6174                      build_real (TREE_TYPE (arg1),
6175                                  REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
6176           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
6177           /* a CMP (-0) -> a CMP 0  */
6178           if (TREE_CODE (arg1) == REAL_CST
6179               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
6180             return fold (build (code, type, arg0,
6181                                 build_real (TREE_TYPE (arg1), dconst0)));
6182
6183           /* If this is a comparison of a real constant with a PLUS_EXPR
6184              or a MINUS_EXPR of a real constant, we can convert it into a
6185              comparison with a revised real constant as long as no overflow
6186              occurs when unsafe_math_optimizations are enabled.  */
6187           if (flag_unsafe_math_optimizations
6188               && TREE_CODE (arg1) == REAL_CST
6189               && (TREE_CODE (arg0) == PLUS_EXPR
6190                   || TREE_CODE (arg0) == MINUS_EXPR)
6191               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6192               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6193                                           ? MINUS_EXPR : PLUS_EXPR,
6194                                           arg1, TREE_OPERAND (arg0, 1), 0))
6195               && ! TREE_CONSTANT_OVERFLOW (tem))
6196             return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6197         }
6198
6199       /* Convert foo++ == CONST into ++foo == CONST + INCR.
6200          First, see if one arg is constant; find the constant arg
6201          and the other one.  */
6202       {
6203         tree constop = 0, varop = NULL_TREE;
6204         int constopnum = -1;
6205
6206         if (TREE_CONSTANT (arg1))
6207           constopnum = 1, constop = arg1, varop = arg0;
6208         if (TREE_CONSTANT (arg0))
6209           constopnum = 0, constop = arg0, varop = arg1;
6210
6211         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
6212           {
6213             /* This optimization is invalid for ordered comparisons
6214                if CONST+INCR overflows or if foo+incr might overflow.
6215                This optimization is invalid for floating point due to rounding.
6216                For pointer types we assume overflow doesn't happen.  */
6217             if (POINTER_TYPE_P (TREE_TYPE (varop))
6218                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6219                     && (code == EQ_EXPR || code == NE_EXPR)))
6220               {
6221                 tree newconst
6222                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6223                                  constop, TREE_OPERAND (varop, 1)));
6224
6225                 /* Do not overwrite the current varop to be a preincrement,
6226                    create a new node so that we won't confuse our caller who
6227                    might create trees and throw them away, reusing the
6228                    arguments that they passed to build.  This shows up in
6229                    the THEN or ELSE parts of ?: being postincrements.  */
6230                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6231                                TREE_OPERAND (varop, 0),
6232                                TREE_OPERAND (varop, 1));
6233
6234                 /* If VAROP is a reference to a bitfield, we must mask
6235                    the constant by the width of the field.  */
6236                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6237                     && DECL_BIT_FIELD(TREE_OPERAND
6238                                       (TREE_OPERAND (varop, 0), 1)))
6239                   {
6240                     int size
6241                       = TREE_INT_CST_LOW (DECL_SIZE
6242                                           (TREE_OPERAND
6243                                            (TREE_OPERAND (varop, 0), 1)));
6244                     tree mask, unsigned_type;
6245                     unsigned int precision;
6246                     tree folded_compare;
6247
6248                     /* First check whether the comparison would come out
6249                        always the same.  If we don't do that we would
6250                        change the meaning with the masking.  */
6251                     if (constopnum == 0)
6252                       folded_compare = fold (build (code, type, constop,
6253                                                     TREE_OPERAND (varop, 0)));
6254                     else
6255                       folded_compare = fold (build (code, type,
6256                                                     TREE_OPERAND (varop, 0),
6257                                                     constop));
6258                     if (integer_zerop (folded_compare)
6259                         || integer_onep (folded_compare))
6260                       return omit_one_operand (type, folded_compare, varop);
6261
6262                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6263                     precision = TYPE_PRECISION (unsigned_type);
6264                     mask = build_int_2 (~0, ~0);
6265                     TREE_TYPE (mask) = unsigned_type;
6266                     force_fit_type (mask, 0);
6267                     mask = const_binop (RSHIFT_EXPR, mask,
6268                                         size_int (precision - size), 0);
6269                     newconst = fold (build (BIT_AND_EXPR,
6270                                             TREE_TYPE (varop), newconst,
6271                                             convert (TREE_TYPE (varop),
6272                                                      mask)));
6273                   }
6274
6275                 t = build (code, type,
6276                            (constopnum == 0) ? newconst : varop,
6277                            (constopnum == 1) ? newconst : varop);
6278                 return t;
6279               }
6280           }
6281         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6282           {
6283             if (POINTER_TYPE_P (TREE_TYPE (varop))
6284                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6285                     && (code == EQ_EXPR || code == NE_EXPR)))
6286               {
6287                 tree newconst
6288                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6289                                  constop, TREE_OPERAND (varop, 1)));
6290
6291                 /* Do not overwrite the current varop to be a predecrement,
6292                    create a new node so that we won't confuse our caller who
6293                    might create trees and throw them away, reusing the
6294                    arguments that they passed to build.  This shows up in
6295                    the THEN or ELSE parts of ?: being postdecrements.  */
6296                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6297                                TREE_OPERAND (varop, 0),
6298                                TREE_OPERAND (varop, 1));
6299
6300                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6301                     && DECL_BIT_FIELD(TREE_OPERAND
6302                                       (TREE_OPERAND (varop, 0), 1)))
6303                   {
6304                     int size
6305                       = TREE_INT_CST_LOW (DECL_SIZE
6306                                           (TREE_OPERAND
6307                                            (TREE_OPERAND (varop, 0), 1)));
6308                     tree mask, unsigned_type;
6309                     unsigned int precision;
6310                     tree folded_compare;
6311
6312                     if (constopnum == 0)
6313                       folded_compare = fold (build (code, type, constop,
6314                                                     TREE_OPERAND (varop, 0)));
6315                     else
6316                       folded_compare = fold (build (code, type,
6317                                                     TREE_OPERAND (varop, 0),
6318                                                     constop));
6319                     if (integer_zerop (folded_compare)
6320                         || integer_onep (folded_compare))
6321                       return omit_one_operand (type, folded_compare, varop);
6322
6323                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6324                     precision = TYPE_PRECISION (unsigned_type);
6325                     mask = build_int_2 (~0, ~0);
6326                     TREE_TYPE (mask) = TREE_TYPE (varop);
6327                     force_fit_type (mask, 0);
6328                     mask = const_binop (RSHIFT_EXPR, mask,
6329                                         size_int (precision - size), 0);
6330                     newconst = fold (build (BIT_AND_EXPR,
6331                                             TREE_TYPE (varop), newconst,
6332                                             convert (TREE_TYPE (varop),
6333                                                      mask)));
6334                   }
6335
6336                 t = build (code, type,
6337                            (constopnum == 0) ? newconst : varop,
6338                            (constopnum == 1) ? newconst : varop);
6339                 return t;
6340               }
6341           }
6342       }
6343
6344       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
6345          This transformation affects the cases which are handled in later
6346          optimizations involving comparisons with non-negative constants.  */
6347       if (TREE_CODE (arg1) == INTEGER_CST
6348           && TREE_CODE (arg0) != INTEGER_CST
6349           && tree_int_cst_sgn (arg1) > 0)
6350         {
6351           switch (code)
6352             {
6353             case GE_EXPR:
6354               code = GT_EXPR;
6355               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6356               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6357               break;
6358
6359             case LT_EXPR:
6360               code = LE_EXPR;
6361               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6362               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6363               break;
6364
6365             default:
6366               break;
6367             }
6368         }
6369
6370       /* Comparisons with the highest or lowest possible integer of
6371          the specified size will have known values.  */
6372       {
6373         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6374
6375         if (TREE_CODE (arg1) == INTEGER_CST
6376             && ! TREE_CONSTANT_OVERFLOW (arg1)
6377             && width <= HOST_BITS_PER_WIDE_INT
6378             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6379                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6380           {
6381             unsigned HOST_WIDE_INT signed_max;
6382             unsigned HOST_WIDE_INT max, min;
6383
6384             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
6385
6386             if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6387               {
6388                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
6389                 min = 0;
6390               }
6391             else
6392               {
6393                 max = signed_max;
6394                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
6395               }
6396
6397             if (TREE_INT_CST_HIGH (arg1) == 0
6398                 && TREE_INT_CST_LOW (arg1) == max)
6399               switch (code)
6400                 {
6401                 case GT_EXPR:
6402                   return omit_one_operand (type,
6403                                            convert (type, integer_zero_node),
6404                                            arg0);
6405                 case GE_EXPR:
6406                   code = EQ_EXPR;
6407                   TREE_SET_CODE (t, EQ_EXPR);
6408                   break;
6409                 case LE_EXPR:
6410                   return omit_one_operand (type,
6411                                            convert (type, integer_one_node),
6412                                            arg0);
6413                 case LT_EXPR:
6414                   code = NE_EXPR;
6415                   TREE_SET_CODE (t, NE_EXPR);
6416                   break;
6417
6418                 /* The GE_EXPR and LT_EXPR cases above are not normally
6419                    reached because of  previous transformations.  */
6420
6421                 default:
6422                   break;
6423                 }
6424             else if (TREE_INT_CST_HIGH (arg1) == 0
6425                      && TREE_INT_CST_LOW (arg1) == max - 1)
6426               switch (code)
6427                 {
6428                 case GT_EXPR:
6429                   code = EQ_EXPR;
6430                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6431                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6432                   break;
6433                 case LE_EXPR:
6434                   code = NE_EXPR;
6435                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6436                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6437                   break;
6438                 default:
6439                   break;
6440                 }
6441             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6442                      && TREE_INT_CST_LOW (arg1) == min)
6443               switch (code)
6444                 {
6445                 case LT_EXPR:
6446                   return omit_one_operand (type,
6447                                            convert (type, integer_zero_node),
6448                                            arg0);
6449                 case LE_EXPR:
6450                   code = EQ_EXPR;
6451                   TREE_SET_CODE (t, EQ_EXPR);
6452                   break;
6453
6454                 case GE_EXPR:
6455                   return omit_one_operand (type,
6456                                            convert (type, integer_one_node),
6457                                            arg0);
6458                 case GT_EXPR:
6459                   code = NE_EXPR;
6460                   TREE_SET_CODE (t, NE_EXPR);
6461                   break;
6462
6463                 default:
6464                   break;
6465                 }
6466             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6467                      && TREE_INT_CST_LOW (arg1) == min + 1)
6468               switch (code)
6469                 {
6470                 case GE_EXPR:
6471                   code = NE_EXPR;
6472                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6473                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6474                   break;
6475                 case LT_EXPR:
6476                   code = EQ_EXPR;
6477                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6478                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6479                   break;
6480                 default:
6481                   break;
6482                 }
6483
6484             else if (TREE_INT_CST_HIGH (arg1) == 0
6485                      && TREE_INT_CST_LOW (arg1) == signed_max
6486                      && TREE_UNSIGNED (TREE_TYPE (arg1))
6487                      /* signed_type does not work on pointer types.  */
6488                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6489               {
6490                 /* The following case also applies to X < signed_max+1
6491                    and X >= signed_max+1 because previous transformations.  */
6492                 if (code == LE_EXPR || code == GT_EXPR)
6493                   {
6494                     tree st0, st1;
6495                     st0 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg0));
6496                     st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
6497                     return fold
6498                       (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
6499                               type, convert (st0, arg0),
6500                               convert (st1, integer_zero_node)));
6501                   }
6502               }
6503           }
6504       }
6505
6506       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6507          a MINUS_EXPR of a constant, we can convert it into a comparison with
6508          a revised constant as long as no overflow occurs.  */
6509       if ((code == EQ_EXPR || code == NE_EXPR)
6510           && TREE_CODE (arg1) == INTEGER_CST
6511           && (TREE_CODE (arg0) == PLUS_EXPR
6512               || TREE_CODE (arg0) == MINUS_EXPR)
6513           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6514           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6515                                       ? MINUS_EXPR : PLUS_EXPR,
6516                                       arg1, TREE_OPERAND (arg0, 1), 0))
6517           && ! TREE_CONSTANT_OVERFLOW (tem))
6518         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6519
6520       /* Similarly for a NEGATE_EXPR.  */
6521       else if ((code == EQ_EXPR || code == NE_EXPR)
6522                && TREE_CODE (arg0) == NEGATE_EXPR
6523                && TREE_CODE (arg1) == INTEGER_CST
6524                && 0 != (tem = negate_expr (arg1))
6525                && TREE_CODE (tem) == INTEGER_CST
6526                && ! TREE_CONSTANT_OVERFLOW (tem))
6527         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6528
6529       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6530          for !=.  Don't do this for ordered comparisons due to overflow.  */
6531       else if ((code == NE_EXPR || code == EQ_EXPR)
6532                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6533         return fold (build (code, type,
6534                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6535
6536       /* If we are widening one operand of an integer comparison,
6537          see if the other operand is similarly being widened.  Perhaps we
6538          can do the comparison in the narrower type.  */
6539       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6540                && TREE_CODE (arg0) == NOP_EXPR
6541                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6542                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6543                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6544                    || (TREE_CODE (t1) == INTEGER_CST
6545                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6546         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6547
6548       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6549          constant, we can simplify it.  */
6550       else if (TREE_CODE (arg1) == INTEGER_CST
6551                && (TREE_CODE (arg0) == MIN_EXPR
6552                    || TREE_CODE (arg0) == MAX_EXPR)
6553                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6554         return optimize_minmax_comparison (t);
6555
6556       /* If we are comparing an ABS_EXPR with a constant, we can
6557          convert all the cases into explicit comparisons, but they may
6558          well not be faster than doing the ABS and one comparison.
6559          But ABS (X) <= C is a range comparison, which becomes a subtraction
6560          and a comparison, and is probably faster.  */
6561       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6562                && TREE_CODE (arg0) == ABS_EXPR
6563                && ! TREE_SIDE_EFFECTS (arg0)
6564                && (0 != (tem = negate_expr (arg1)))
6565                && TREE_CODE (tem) == INTEGER_CST
6566                && ! TREE_CONSTANT_OVERFLOW (tem))
6567         return fold (build (TRUTH_ANDIF_EXPR, type,
6568                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6569                             build (LE_EXPR, type,
6570                                    TREE_OPERAND (arg0, 0), arg1)));
6571
6572       /* If this is an EQ or NE comparison with zero and ARG0 is
6573          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6574          two operations, but the latter can be done in one less insn
6575          on machines that have only two-operand insns or on which a
6576          constant cannot be the first operand.  */
6577       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6578           && TREE_CODE (arg0) == BIT_AND_EXPR)
6579         {
6580           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6581               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6582             return
6583               fold (build (code, type,
6584                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6585                                   build (RSHIFT_EXPR,
6586                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6587                                          TREE_OPERAND (arg0, 1),
6588                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6589                                   convert (TREE_TYPE (arg0),
6590                                            integer_one_node)),
6591                            arg1));
6592           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6593                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6594             return
6595               fold (build (code, type,
6596                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6597                                   build (RSHIFT_EXPR,
6598                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6599                                          TREE_OPERAND (arg0, 0),
6600                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6601                                   convert (TREE_TYPE (arg0),
6602                                            integer_one_node)),
6603                            arg1));
6604         }
6605
6606       /* If this is an NE or EQ comparison of zero against the result of a
6607          signed MOD operation whose second operand is a power of 2, make
6608          the MOD operation unsigned since it is simpler and equivalent.  */
6609       if ((code == NE_EXPR || code == EQ_EXPR)
6610           && integer_zerop (arg1)
6611           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6612           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6613               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6614               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6615               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6616           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6617         {
6618           tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
6619           tree newmod = build (TREE_CODE (arg0), newtype,
6620                                convert (newtype, TREE_OPERAND (arg0, 0)),
6621                                convert (newtype, TREE_OPERAND (arg0, 1)));
6622
6623           return build (code, type, newmod, convert (newtype, arg1));
6624         }
6625
6626       /* If this is an NE comparison of zero with an AND of one, remove the
6627          comparison since the AND will give the correct value.  */
6628       if (code == NE_EXPR && integer_zerop (arg1)
6629           && TREE_CODE (arg0) == BIT_AND_EXPR
6630           && integer_onep (TREE_OPERAND (arg0, 1)))
6631         return convert (type, arg0);
6632
6633       /* If we have (A & C) == C where C is a power of 2, convert this into
6634          (A & C) != 0.  Similarly for NE_EXPR.  */
6635       if ((code == EQ_EXPR || code == NE_EXPR)
6636           && TREE_CODE (arg0) == BIT_AND_EXPR
6637           && integer_pow2p (TREE_OPERAND (arg0, 1))
6638           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6639         return fold (build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6640                             arg0, integer_zero_node));
6641
6642       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6643          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6644       if ((code == EQ_EXPR || code == NE_EXPR)
6645           && TREE_CODE (arg0) == BIT_AND_EXPR
6646           && integer_zerop (arg1))
6647         {
6648           tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0),
6649                                    TREE_OPERAND (arg0, 1));
6650           if (arg00 != NULL_TREE)
6651           {
6652             tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
6653             return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
6654                                 convert (stype, arg00),
6655                                 convert (stype, integer_zero_node)));
6656           }
6657         }
6658
6659       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6660          and similarly for >= into !=.  */
6661       if ((code == LT_EXPR || code == GE_EXPR)
6662           && TREE_UNSIGNED (TREE_TYPE (arg0))
6663           && TREE_CODE (arg1) == LSHIFT_EXPR
6664           && integer_onep (TREE_OPERAND (arg1, 0)))
6665         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6666                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6667                              TREE_OPERAND (arg1, 1)),
6668                       convert (TREE_TYPE (arg0), integer_zero_node));
6669
6670       else if ((code == LT_EXPR || code == GE_EXPR)
6671                && TREE_UNSIGNED (TREE_TYPE (arg0))
6672                && (TREE_CODE (arg1) == NOP_EXPR
6673                    || TREE_CODE (arg1) == CONVERT_EXPR)
6674                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6675                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6676         return
6677           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6678                  convert (TREE_TYPE (arg0),
6679                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6680                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6681                  convert (TREE_TYPE (arg0), integer_zero_node));
6682
6683       /* Simplify comparison of something with itself.  (For IEEE
6684          floating-point, we can only do some of these simplifications.)  */
6685       if (operand_equal_p (arg0, arg1, 0))
6686         {
6687           switch (code)
6688             {
6689             case EQ_EXPR:
6690             case GE_EXPR:
6691             case LE_EXPR:
6692               if (! FLOAT_TYPE_P (TREE_TYPE (arg0)))
6693                 return constant_boolean_node (1, type);
6694               code = EQ_EXPR;
6695               TREE_SET_CODE (t, code);
6696               break;
6697
6698             case NE_EXPR:
6699               /* For NE, we can only do this simplification if integer.  */
6700               if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6701                 break;
6702               /* ... fall through ...  */
6703             case GT_EXPR:
6704             case LT_EXPR:
6705               return constant_boolean_node (0, type);
6706             default:
6707               abort ();
6708             }
6709         }
6710
6711       /* If we are comparing an expression that just has comparisons
6712          of two integer values, arithmetic expressions of those comparisons,
6713          and constants, we can simplify it.  There are only three cases
6714          to check: the two values can either be equal, the first can be
6715          greater, or the second can be greater.  Fold the expression for
6716          those three values.  Since each value must be 0 or 1, we have
6717          eight possibilities, each of which corresponds to the constant 0
6718          or 1 or one of the six possible comparisons.
6719
6720          This handles common cases like (a > b) == 0 but also handles
6721          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6722          occur in macroized code.  */
6723
6724       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6725         {
6726           tree cval1 = 0, cval2 = 0;
6727           int save_p = 0;
6728
6729           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6730               /* Don't handle degenerate cases here; they should already
6731                  have been handled anyway.  */
6732               && cval1 != 0 && cval2 != 0
6733               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6734               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6735               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6736               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6737               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6738               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6739                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6740             {
6741               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6742               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6743
6744               /* We can't just pass T to eval_subst in case cval1 or cval2
6745                  was the same as ARG1.  */
6746
6747               tree high_result
6748                 = fold (build (code, type,
6749                                eval_subst (arg0, cval1, maxval, cval2, minval),
6750                                arg1));
6751               tree equal_result
6752                 = fold (build (code, type,
6753                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6754                                arg1));
6755               tree low_result
6756                 = fold (build (code, type,
6757                                eval_subst (arg0, cval1, minval, cval2, maxval),
6758                                arg1));
6759
6760               /* All three of these results should be 0 or 1.  Confirm they
6761                  are.  Then use those values to select the proper code
6762                  to use.  */
6763
6764               if ((integer_zerop (high_result)
6765                    || integer_onep (high_result))
6766                   && (integer_zerop (equal_result)
6767                       || integer_onep (equal_result))
6768                   && (integer_zerop (low_result)
6769                       || integer_onep (low_result)))
6770                 {
6771                   /* Make a 3-bit mask with the high-order bit being the
6772                      value for `>', the next for '=', and the low for '<'.  */
6773                   switch ((integer_onep (high_result) * 4)
6774                           + (integer_onep (equal_result) * 2)
6775                           + integer_onep (low_result))
6776                     {
6777                     case 0:
6778                       /* Always false.  */
6779                       return omit_one_operand (type, integer_zero_node, arg0);
6780                     case 1:
6781                       code = LT_EXPR;
6782                       break;
6783                     case 2:
6784                       code = EQ_EXPR;
6785                       break;
6786                     case 3:
6787                       code = LE_EXPR;
6788                       break;
6789                     case 4:
6790                       code = GT_EXPR;
6791                       break;
6792                     case 5:
6793                       code = NE_EXPR;
6794                       break;
6795                     case 6:
6796                       code = GE_EXPR;
6797                       break;
6798                     case 7:
6799                       /* Always true.  */
6800                       return omit_one_operand (type, integer_one_node, arg0);
6801                     }
6802
6803                   t = build (code, type, cval1, cval2);
6804                   if (save_p)
6805                     return save_expr (t);
6806                   else
6807                     return fold (t);
6808                 }
6809             }
6810         }
6811
6812       /* If this is a comparison of a field, we may be able to simplify it.  */
6813       if (((TREE_CODE (arg0) == COMPONENT_REF
6814             && (*lang_hooks.can_use_bit_fields_p) ())
6815            || TREE_CODE (arg0) == BIT_FIELD_REF)
6816           && (code == EQ_EXPR || code == NE_EXPR)
6817           /* Handle the constant case even without -O
6818              to make sure the warnings are given.  */
6819           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6820         {
6821           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6822           return t1 ? t1 : t;
6823         }
6824
6825       /* If this is a comparison of complex values and either or both sides
6826          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6827          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6828          This may prevent needless evaluations.  */
6829       if ((code == EQ_EXPR || code == NE_EXPR)
6830           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6831           && (TREE_CODE (arg0) == COMPLEX_EXPR
6832               || TREE_CODE (arg1) == COMPLEX_EXPR
6833               || TREE_CODE (arg0) == COMPLEX_CST
6834               || TREE_CODE (arg1) == COMPLEX_CST))
6835         {
6836           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6837           tree real0, imag0, real1, imag1;
6838
6839           arg0 = save_expr (arg0);
6840           arg1 = save_expr (arg1);
6841           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6842           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6843           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6844           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6845
6846           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6847                                : TRUTH_ORIF_EXPR),
6848                               type,
6849                               fold (build (code, type, real0, real1)),
6850                               fold (build (code, type, imag0, imag1))));
6851         }
6852
6853       /* Optimize comparisons of strlen vs zero to a compare of the
6854          first character of the string vs zero.  To wit,
6855                 strlen(ptr) == 0   =>  *ptr == 0
6856                 strlen(ptr) != 0   =>  *ptr != 0
6857          Other cases should reduce to one of these two (or a constant)
6858          due to the return value of strlen being unsigned.  */
6859       if ((code == EQ_EXPR || code == NE_EXPR)
6860           && integer_zerop (arg1)
6861           && TREE_CODE (arg0) == CALL_EXPR
6862           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR)
6863         {
6864           tree fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6865           tree arglist;
6866
6867           if (TREE_CODE (fndecl) == FUNCTION_DECL
6868               && DECL_BUILT_IN (fndecl)
6869               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
6870               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
6871               && (arglist = TREE_OPERAND (arg0, 1))
6872               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
6873               && ! TREE_CHAIN (arglist))
6874             return fold (build (code, type,
6875                                 build1 (INDIRECT_REF, char_type_node,
6876                                         TREE_VALUE(arglist)),
6877                                 integer_zero_node));
6878         }
6879
6880       /* From here on, the only cases we handle are when the result is
6881          known to be a constant.
6882
6883          To compute GT, swap the arguments and do LT.
6884          To compute GE, do LT and invert the result.
6885          To compute LE, swap the arguments, do LT and invert the result.
6886          To compute NE, do EQ and invert the result.
6887
6888          Therefore, the code below must handle only EQ and LT.  */
6889
6890       if (code == LE_EXPR || code == GT_EXPR)
6891         {
6892           tem = arg0, arg0 = arg1, arg1 = tem;
6893           code = swap_tree_comparison (code);
6894         }
6895
6896       /* Note that it is safe to invert for real values here because we
6897          will check below in the one case that it matters.  */
6898
6899       t1 = NULL_TREE;
6900       invert = 0;
6901       if (code == NE_EXPR || code == GE_EXPR)
6902         {
6903           invert = 1;
6904           code = invert_tree_comparison (code);
6905         }
6906
6907       /* Compute a result for LT or EQ if args permit;
6908          otherwise return T.  */
6909       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6910         {
6911           if (code == EQ_EXPR)
6912             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
6913           else
6914             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6915                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6916                                : INT_CST_LT (arg0, arg1)),
6917                               0);
6918         }
6919
6920 #if 0 /* This is no longer useful, but breaks some real code.  */
6921       /* Assume a nonexplicit constant cannot equal an explicit one,
6922          since such code would be undefined anyway.
6923          Exception: on sysvr4, using #pragma weak,
6924          a label can come out as 0.  */
6925       else if (TREE_CODE (arg1) == INTEGER_CST
6926                && !integer_zerop (arg1)
6927                && TREE_CONSTANT (arg0)
6928                && TREE_CODE (arg0) == ADDR_EXPR
6929                && code == EQ_EXPR)
6930         t1 = build_int_2 (0, 0);
6931 #endif
6932       /* Two real constants can be compared explicitly.  */
6933       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6934         {
6935           /* If either operand is a NaN, the result is false with two
6936              exceptions: First, an NE_EXPR is true on NaNs, but that case
6937              is already handled correctly since we will be inverting the
6938              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6939              or a GE_EXPR into a LT_EXPR, we must return true so that it
6940              will be inverted into false.  */
6941
6942           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6943               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6944             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6945
6946           else if (code == EQ_EXPR)
6947             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6948                                                  TREE_REAL_CST (arg1)),
6949                               0);
6950           else
6951             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6952                                                 TREE_REAL_CST (arg1)),
6953                               0);
6954         }
6955
6956       if (t1 == NULL_TREE)
6957         return t;
6958
6959       if (invert)
6960         TREE_INT_CST_LOW (t1) ^= 1;
6961
6962       TREE_TYPE (t1) = type;
6963       if (TREE_CODE (type) == BOOLEAN_TYPE)
6964         return (*lang_hooks.truthvalue_conversion) (t1);
6965       return t1;
6966
6967     case COND_EXPR:
6968       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6969          so all simple results must be passed through pedantic_non_lvalue.  */
6970       if (TREE_CODE (arg0) == INTEGER_CST)
6971         return pedantic_non_lvalue
6972           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6973       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6974         return pedantic_omit_one_operand (type, arg1, arg0);
6975
6976       /* If the second operand is zero, invert the comparison and swap
6977          the second and third operands.  Likewise if the second operand
6978          is constant and the third is not or if the third operand is
6979          equivalent to the first operand of the comparison.  */
6980
6981       if (integer_zerop (arg1)
6982           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6983           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6984               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6985                                                  TREE_OPERAND (t, 2),
6986                                                  TREE_OPERAND (arg0, 1))))
6987         {
6988           /* See if this can be inverted.  If it can't, possibly because
6989              it was a floating-point inequality comparison, don't do
6990              anything.  */
6991           tem = invert_truthvalue (arg0);
6992
6993           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6994             {
6995               t = build (code, type, tem,
6996                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6997               arg0 = tem;
6998               /* arg1 should be the first argument of the new T.  */
6999               arg1 = TREE_OPERAND (t, 1);
7000               STRIP_NOPS (arg1);
7001             }
7002         }
7003
7004       /* If we have A op B ? A : C, we may be able to convert this to a
7005          simpler expression, depending on the operation and the values
7006          of B and C.  Signed zeros prevent all of these transformations,
7007          for reasons given above each one.  */
7008
7009       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7010           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7011                                              arg1, TREE_OPERAND (arg0, 1))
7012           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
7013         {
7014           tree arg2 = TREE_OPERAND (t, 2);
7015           enum tree_code comp_code = TREE_CODE (arg0);
7016
7017           STRIP_NOPS (arg2);
7018
7019           /* If we have A op 0 ? A : -A, consider applying the following
7020              transformations:
7021
7022              A == 0? A : -A    same as -A
7023              A != 0? A : -A    same as A
7024              A >= 0? A : -A    same as abs (A)
7025              A > 0?  A : -A    same as abs (A)
7026              A <= 0? A : -A    same as -abs (A)
7027              A < 0?  A : -A    same as -abs (A)
7028
7029              None of these transformations work for modes with signed
7030              zeros.  If A is +/-0, the first two transformations will
7031              change the sign of the result (from +0 to -0, or vice
7032              versa).  The last four will fix the sign of the result,
7033              even though the original expressions could be positive or
7034              negative, depending on the sign of A.
7035
7036              Note that all these transformations are correct if A is
7037              NaN, since the two alternatives (A and -A) are also NaNs.  */
7038           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
7039                ? real_zerop (TREE_OPERAND (arg0, 1))
7040                : integer_zerop (TREE_OPERAND (arg0, 1)))
7041               && TREE_CODE (arg2) == NEGATE_EXPR
7042               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
7043             switch (comp_code)
7044               {
7045               case EQ_EXPR:
7046                 return
7047                   pedantic_non_lvalue
7048                     (convert (type,
7049                               negate_expr
7050                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
7051                                         arg1))));
7052               case NE_EXPR:
7053                 return pedantic_non_lvalue (convert (type, arg1));
7054               case GE_EXPR:
7055               case GT_EXPR:
7056                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7057                   arg1 = convert ((*lang_hooks.types.signed_type)
7058                                   (TREE_TYPE (arg1)), arg1);
7059                 return pedantic_non_lvalue
7060                   (convert (type, fold (build1 (ABS_EXPR,
7061                                                 TREE_TYPE (arg1), arg1))));
7062               case LE_EXPR:
7063               case LT_EXPR:
7064                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7065                   arg1 = convert ((lang_hooks.types.signed_type)
7066                                   (TREE_TYPE (arg1)), arg1);
7067                 return pedantic_non_lvalue
7068                   (negate_expr (convert (type,
7069                                          fold (build1 (ABS_EXPR,
7070                                                        TREE_TYPE (arg1),
7071                                                        arg1)))));
7072               default:
7073                 abort ();
7074               }
7075
7076           /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
7077              A == 0 ? A : 0 is always 0 unless A is -0.  Note that
7078              both transformations are correct when A is NaN: A != 0
7079              is then true, and A == 0 is false.  */
7080
7081           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
7082             {
7083               if (comp_code == NE_EXPR)
7084                 return pedantic_non_lvalue (convert (type, arg1));
7085               else if (comp_code == EQ_EXPR)
7086                 return pedantic_non_lvalue (convert (type, integer_zero_node));
7087             }
7088
7089           /* Try some transformations of A op B ? A : B.
7090
7091              A == B? A : B    same as B
7092              A != B? A : B    same as A
7093              A >= B? A : B    same as max (A, B)
7094              A > B?  A : B    same as max (B, A)
7095              A <= B? A : B    same as min (A, B)
7096              A < B?  A : B    same as min (B, A)
7097
7098              As above, these transformations don't work in the presence
7099              of signed zeros.  For example, if A and B are zeros of
7100              opposite sign, the first two transformations will change
7101              the sign of the result.  In the last four, the original
7102              expressions give different results for (A=+0, B=-0) and
7103              (A=-0, B=+0), but the transformed expressions do not.
7104
7105              The first two transformations are correct if either A or B
7106              is a NaN.  In the first transformation, the condition will
7107              be false, and B will indeed be chosen.  In the case of the
7108              second transformation, the condition A != B will be true,
7109              and A will be chosen.
7110
7111              The conversions to max() and min() are not correct if B is
7112              a number and A is not.  The conditions in the original
7113              expressions will be false, so all four give B.  The min()
7114              and max() versions would give a NaN instead.  */
7115           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
7116                                               arg2, TREE_OPERAND (arg0, 0)))
7117             {
7118               tree comp_op0 = TREE_OPERAND (arg0, 0);
7119               tree comp_op1 = TREE_OPERAND (arg0, 1);
7120               tree comp_type = TREE_TYPE (comp_op0);
7121
7122               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
7123               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
7124                 {
7125                   comp_type = type;
7126                   comp_op0 = arg1;
7127                   comp_op1 = arg2;
7128                 }
7129
7130               switch (comp_code)
7131                 {
7132                 case EQ_EXPR:
7133                   return pedantic_non_lvalue (convert (type, arg2));
7134                 case NE_EXPR:
7135                   return pedantic_non_lvalue (convert (type, arg1));
7136                 case LE_EXPR:
7137                 case LT_EXPR:
7138                   /* In C++ a ?: expression can be an lvalue, so put the
7139                      operand which will be used if they are equal first
7140                      so that we can convert this back to the
7141                      corresponding COND_EXPR.  */
7142                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
7143                     return pedantic_non_lvalue
7144                       (convert (type, fold (build (MIN_EXPR, comp_type,
7145                                                    (comp_code == LE_EXPR
7146                                                     ? comp_op0 : comp_op1),
7147                                                    (comp_code == LE_EXPR
7148                                                     ? comp_op1 : comp_op0)))));
7149                   break;
7150                 case GE_EXPR:
7151                 case GT_EXPR:
7152                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
7153                     return pedantic_non_lvalue
7154                       (convert (type, fold (build (MAX_EXPR, comp_type,
7155                                                    (comp_code == GE_EXPR
7156                                                     ? comp_op0 : comp_op1),
7157                                                    (comp_code == GE_EXPR
7158                                                     ? comp_op1 : comp_op0)))));
7159                   break;
7160                 default:
7161                   abort ();
7162                 }
7163             }
7164
7165           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
7166              we might still be able to simplify this.  For example,
7167              if C1 is one less or one more than C2, this might have started
7168              out as a MIN or MAX and been transformed by this function.
7169              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
7170
7171           if (INTEGRAL_TYPE_P (type)
7172               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7173               && TREE_CODE (arg2) == INTEGER_CST)
7174             switch (comp_code)
7175               {
7176               case EQ_EXPR:
7177                 /* We can replace A with C1 in this case.  */
7178                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
7179                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
7180                            TREE_OPERAND (t, 2));
7181                 break;
7182
7183               case LT_EXPR:
7184                 /* If C1 is C2 + 1, this is min(A, C2).  */
7185                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7186                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7187                                         const_binop (PLUS_EXPR, arg2,
7188                                                      integer_one_node, 0), 1))
7189                   return pedantic_non_lvalue
7190                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7191                 break;
7192
7193               case LE_EXPR:
7194                 /* If C1 is C2 - 1, this is min(A, C2).  */
7195                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7196                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7197                                         const_binop (MINUS_EXPR, arg2,
7198                                                      integer_one_node, 0), 1))
7199                   return pedantic_non_lvalue
7200                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7201                 break;
7202
7203               case GT_EXPR:
7204                 /* If C1 is C2 - 1, this is max(A, C2).  */
7205                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7206                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7207                                         const_binop (MINUS_EXPR, arg2,
7208                                                      integer_one_node, 0), 1))
7209                   return pedantic_non_lvalue
7210                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7211                 break;
7212
7213               case GE_EXPR:
7214                 /* If C1 is C2 + 1, this is max(A, C2).  */
7215                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7216                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7217                                         const_binop (PLUS_EXPR, arg2,
7218                                                      integer_one_node, 0), 1))
7219                   return pedantic_non_lvalue
7220                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7221                 break;
7222               case NE_EXPR:
7223                 break;
7224               default:
7225                 abort ();
7226               }
7227         }
7228
7229       /* If the second operand is simpler than the third, swap them
7230          since that produces better jump optimization results.  */
7231       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7232            || TREE_CODE (arg1) == SAVE_EXPR)
7233           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7234                 || DECL_P (TREE_OPERAND (t, 2))
7235                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7236         {
7237           /* See if this can be inverted.  If it can't, possibly because
7238              it was a floating-point inequality comparison, don't do
7239              anything.  */
7240           tem = invert_truthvalue (arg0);
7241
7242           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7243             {
7244               t = build (code, type, tem,
7245                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7246               arg0 = tem;
7247               /* arg1 should be the first argument of the new T.  */
7248               arg1 = TREE_OPERAND (t, 1);
7249               STRIP_NOPS (arg1);
7250             }
7251         }
7252
7253       /* Convert A ? 1 : 0 to simply A.  */
7254       if (integer_onep (TREE_OPERAND (t, 1))
7255           && integer_zerop (TREE_OPERAND (t, 2))
7256           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7257              call to fold will try to move the conversion inside
7258              a COND, which will recurse.  In that case, the COND_EXPR
7259              is probably the best choice, so leave it alone.  */
7260           && type == TREE_TYPE (arg0))
7261         return pedantic_non_lvalue (arg0);
7262
7263       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
7264          over COND_EXPR in cases such as floating point comparisons.  */
7265       if (integer_zerop (TREE_OPERAND (t, 1))
7266           && integer_onep (TREE_OPERAND (t, 2))
7267           && truth_value_p (TREE_CODE (arg0)))
7268         return pedantic_non_lvalue (convert (type,
7269                                              invert_truthvalue (arg0)));
7270
7271       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7272          operation is simply A & 2.  */
7273
7274       if (integer_zerop (TREE_OPERAND (t, 2))
7275           && TREE_CODE (arg0) == NE_EXPR
7276           && integer_zerop (TREE_OPERAND (arg0, 1))
7277           && integer_pow2p (arg1)
7278           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7279           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7280                               arg1, 1))
7281         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7282
7283       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
7284       if (integer_zerop (TREE_OPERAND (t, 2))
7285           && truth_value_p (TREE_CODE (arg0))
7286           && truth_value_p (TREE_CODE (arg1)))
7287         return pedantic_non_lvalue (fold (build (TRUTH_ANDIF_EXPR, type,
7288                                                  arg0, arg1)));
7289
7290       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
7291       if (integer_onep (TREE_OPERAND (t, 2))
7292           && truth_value_p (TREE_CODE (arg0))
7293           && truth_value_p (TREE_CODE (arg1)))
7294         {
7295           /* Only perform transformation if ARG0 is easily inverted.  */
7296           tem = invert_truthvalue (arg0);
7297           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7298             return pedantic_non_lvalue (fold (build (TRUTH_ORIF_EXPR, type,
7299                                                      tem, arg1)));
7300         }
7301
7302       return t;
7303
7304     case COMPOUND_EXPR:
7305       /* When pedantic, a compound expression can be neither an lvalue
7306          nor an integer constant expression.  */
7307       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7308         return t;
7309       /* Don't let (0, 0) be null pointer constant.  */
7310       if (integer_zerop (arg1))
7311         return build1 (NOP_EXPR, type, arg1);
7312       return convert (type, arg1);
7313
7314     case COMPLEX_EXPR:
7315       if (wins)
7316         return build_complex (type, arg0, arg1);
7317       return t;
7318
7319     case REALPART_EXPR:
7320       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7321         return t;
7322       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7323         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7324                                  TREE_OPERAND (arg0, 1));
7325       else if (TREE_CODE (arg0) == COMPLEX_CST)
7326         return TREE_REALPART (arg0);
7327       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7328         return fold (build (TREE_CODE (arg0), type,
7329                             fold (build1 (REALPART_EXPR, type,
7330                                           TREE_OPERAND (arg0, 0))),
7331                             fold (build1 (REALPART_EXPR,
7332                                           type, TREE_OPERAND (arg0, 1)))));
7333       return t;
7334
7335     case IMAGPART_EXPR:
7336       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7337         return convert (type, integer_zero_node);
7338       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7339         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7340                                  TREE_OPERAND (arg0, 0));
7341       else if (TREE_CODE (arg0) == COMPLEX_CST)
7342         return TREE_IMAGPART (arg0);
7343       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7344         return fold (build (TREE_CODE (arg0), type,
7345                             fold (build1 (IMAGPART_EXPR, type,
7346                                           TREE_OPERAND (arg0, 0))),
7347                             fold (build1 (IMAGPART_EXPR, type,
7348                                           TREE_OPERAND (arg0, 1)))));
7349       return t;
7350
7351       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7352          appropriate.  */
7353     case CLEANUP_POINT_EXPR:
7354       if (! has_cleanups (arg0))
7355         return TREE_OPERAND (t, 0);
7356
7357       {
7358         enum tree_code code0 = TREE_CODE (arg0);
7359         int kind0 = TREE_CODE_CLASS (code0);
7360         tree arg00 = TREE_OPERAND (arg0, 0);
7361         tree arg01;
7362
7363         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7364           return fold (build1 (code0, type,
7365                                fold (build1 (CLEANUP_POINT_EXPR,
7366                                              TREE_TYPE (arg00), arg00))));
7367
7368         if (kind0 == '<' || kind0 == '2'
7369             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7370             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7371             || code0 == TRUTH_XOR_EXPR)
7372           {
7373             arg01 = TREE_OPERAND (arg0, 1);
7374
7375             if (TREE_CONSTANT (arg00)
7376                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7377                     && ! has_cleanups (arg00)))
7378               return fold (build (code0, type, arg00,
7379                                   fold (build1 (CLEANUP_POINT_EXPR,
7380                                                 TREE_TYPE (arg01), arg01))));
7381
7382             if (TREE_CONSTANT (arg01))
7383               return fold (build (code0, type,
7384                                   fold (build1 (CLEANUP_POINT_EXPR,
7385                                                 TREE_TYPE (arg00), arg00)),
7386                                   arg01));
7387           }
7388
7389         return t;
7390       }
7391
7392     case CALL_EXPR:
7393       /* Check for a built-in function.  */
7394       if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
7395           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))
7396               == FUNCTION_DECL)
7397           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)))
7398         {
7399           tree tmp = fold_builtin (expr);
7400           if (tmp)
7401             return tmp;
7402         }
7403       return t;
7404
7405     default:
7406       return t;
7407     } /* switch (code) */
7408 }
7409
7410 /* Determine if first argument is a multiple of second argument.  Return 0 if
7411    it is not, or we cannot easily determined it to be.
7412
7413    An example of the sort of thing we care about (at this point; this routine
7414    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7415    fold cases do now) is discovering that
7416
7417      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7418
7419    is a multiple of
7420
7421      SAVE_EXPR (J * 8)
7422
7423    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7424
7425    This code also handles discovering that
7426
7427      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7428
7429    is a multiple of 8 so we don't have to worry about dealing with a
7430    possible remainder.
7431
7432    Note that we *look* inside a SAVE_EXPR only to determine how it was
7433    calculated; it is not safe for fold to do much of anything else with the
7434    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7435    at run time.  For example, the latter example above *cannot* be implemented
7436    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7437    evaluation time of the original SAVE_EXPR is not necessarily the same at
7438    the time the new expression is evaluated.  The only optimization of this
7439    sort that would be valid is changing
7440
7441      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7442
7443    divided by 8 to
7444
7445      SAVE_EXPR (I) * SAVE_EXPR (J)
7446
7447    (where the same SAVE_EXPR (J) is used in the original and the
7448    transformed version).  */
7449
7450 static int
7451 multiple_of_p (type, top, bottom)
7452      tree type;
7453      tree top;
7454      tree bottom;
7455 {
7456   if (operand_equal_p (top, bottom, 0))
7457     return 1;
7458
7459   if (TREE_CODE (type) != INTEGER_TYPE)
7460     return 0;
7461
7462   switch (TREE_CODE (top))
7463     {
7464     case MULT_EXPR:
7465       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7466               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7467
7468     case PLUS_EXPR:
7469     case MINUS_EXPR:
7470       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7471               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7472
7473     case LSHIFT_EXPR:
7474       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
7475         {
7476           tree op1, t1;
7477
7478           op1 = TREE_OPERAND (top, 1);
7479           /* const_binop may not detect overflow correctly,
7480              so check for it explicitly here.  */
7481           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
7482               > TREE_INT_CST_LOW (op1)
7483               && TREE_INT_CST_HIGH (op1) == 0
7484               && 0 != (t1 = convert (type,
7485                                      const_binop (LSHIFT_EXPR, size_one_node,
7486                                                   op1, 0)))
7487               && ! TREE_OVERFLOW (t1))
7488             return multiple_of_p (type, t1, bottom);
7489         }
7490       return 0;
7491
7492     case NOP_EXPR:
7493       /* Can't handle conversions from non-integral or wider integral type.  */
7494       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7495           || (TYPE_PRECISION (type)
7496               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7497         return 0;
7498
7499       /* .. fall through ...  */
7500
7501     case SAVE_EXPR:
7502       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7503
7504     case INTEGER_CST:
7505       if (TREE_CODE (bottom) != INTEGER_CST
7506           || (TREE_UNSIGNED (type)
7507               && (tree_int_cst_sgn (top) < 0
7508                   || tree_int_cst_sgn (bottom) < 0)))
7509         return 0;
7510       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7511                                          top, bottom, 0));
7512
7513     default:
7514       return 0;
7515     }
7516 }
7517
7518 /* Return true if `t' is known to be non-negative.  */
7519
7520 int
7521 tree_expr_nonnegative_p (t)
7522      tree t;
7523 {
7524   switch (TREE_CODE (t))
7525     {
7526     case ABS_EXPR:
7527     case FFS_EXPR:
7528     case POPCOUNT_EXPR:
7529     case PARITY_EXPR:
7530       return 1;
7531
7532     case CLZ_EXPR:
7533     case CTZ_EXPR:
7534       /* These are undefined at zero.  This is true even if
7535          C[LT]Z_DEFINED_VALUE_AT_ZERO is set, since what we're
7536          computing here is a user-visible property.  */
7537       return 0;
7538
7539     case INTEGER_CST:
7540       return tree_int_cst_sgn (t) >= 0;
7541     case TRUNC_DIV_EXPR:
7542     case CEIL_DIV_EXPR:
7543     case FLOOR_DIV_EXPR:
7544     case ROUND_DIV_EXPR:
7545       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7546         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7547     case TRUNC_MOD_EXPR:
7548     case CEIL_MOD_EXPR:
7549     case FLOOR_MOD_EXPR:
7550     case ROUND_MOD_EXPR:
7551       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7552     case COND_EXPR:
7553       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
7554         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
7555     case COMPOUND_EXPR:
7556       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7557     case MIN_EXPR:
7558       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7559         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7560     case MAX_EXPR:
7561       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7562         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7563     case MODIFY_EXPR:
7564       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7565     case BIND_EXPR:
7566       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7567     case SAVE_EXPR:
7568       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7569     case NON_LVALUE_EXPR:
7570       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7571     case RTL_EXPR:
7572       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
7573
7574     default:
7575       if (truth_value_p (TREE_CODE (t)))
7576         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
7577         return 1;
7578       else
7579         /* We don't know sign of `t', so be conservative and return false.  */
7580         return 0;
7581     }
7582 }
7583
7584 /* Return true if `r' is known to be non-negative.
7585    Only handles constants at the moment.  */
7586
7587 int
7588 rtl_expr_nonnegative_p (r)
7589      rtx r;
7590 {
7591   switch (GET_CODE (r))
7592     {
7593     case CONST_INT:
7594       return INTVAL (r) >= 0;
7595
7596     case CONST_DOUBLE:
7597       if (GET_MODE (r) == VOIDmode)
7598         return CONST_DOUBLE_HIGH (r) >= 0;
7599       return 0;
7600
7601     case CONST_VECTOR:
7602       {
7603         int units, i;
7604         rtx elt;
7605
7606         units = CONST_VECTOR_NUNITS (r);
7607
7608         for (i = 0; i < units; ++i)
7609           {
7610             elt = CONST_VECTOR_ELT (r, i);
7611             if (!rtl_expr_nonnegative_p (elt))
7612               return 0;
7613           }
7614
7615         return 1;
7616       }
7617
7618     case SYMBOL_REF:
7619     case LABEL_REF:
7620       /* These are always nonnegative.  */
7621       return 1;
7622
7623     default:
7624       return 0;
7625     }
7626 }
7627
7628 #include "gt-fold-const.h"