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