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   PTR *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 = (PTR) 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 dereferencing
1972          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         default:
2014           return 0;
2015         }
2016
2017     default:
2018       return 0;
2019     }
2020 }
2021 \f
2022 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2023    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2024
2025    When in doubt, return 0.  */
2026
2027 static int
2028 operand_equal_for_comparison_p (arg0, arg1, other)
2029      tree arg0, arg1;
2030      tree other;
2031 {
2032   int unsignedp1, unsignedpo;
2033   tree primarg0, primarg1, primother;
2034   unsigned int correct_width;
2035
2036   if (operand_equal_p (arg0, arg1, 0))
2037     return 1;
2038
2039   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2040       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2041     return 0;
2042
2043   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2044      and see if the inner values are the same.  This removes any
2045      signedness comparison, which doesn't matter here.  */
2046   primarg0 = arg0, primarg1 = arg1;
2047   STRIP_NOPS (primarg0);
2048   STRIP_NOPS (primarg1);
2049   if (operand_equal_p (primarg0, primarg1, 0))
2050     return 1;
2051
2052   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2053      actual comparison operand, ARG0.
2054
2055      First throw away any conversions to wider types
2056      already present in the operands.  */
2057
2058   primarg1 = get_narrower (arg1, &unsignedp1);
2059   primother = get_narrower (other, &unsignedpo);
2060
2061   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2062   if (unsignedp1 == unsignedpo
2063       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2064       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2065     {
2066       tree type = TREE_TYPE (arg0);
2067
2068       /* Make sure shorter operand is extended the right way
2069          to match the longer operand.  */
2070       primarg1 = convert ((*lang_hooks.types.signed_or_unsigned_type)
2071                           (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2072
2073       if (operand_equal_p (arg0, convert (type, primarg1), 0))
2074         return 1;
2075     }
2076
2077   return 0;
2078 }
2079 \f
2080 /* See if ARG is an expression that is either a comparison or is performing
2081    arithmetic on comparisons.  The comparisons must only be comparing
2082    two different values, which will be stored in *CVAL1 and *CVAL2; if
2083    they are nonzero it means that some operands have already been found.
2084    No variables may be used anywhere else in the expression except in the
2085    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2086    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2087
2088    If this is true, return 1.  Otherwise, return zero.  */
2089
2090 static int
2091 twoval_comparison_p (arg, cval1, cval2, save_p)
2092      tree arg;
2093      tree *cval1, *cval2;
2094      int *save_p;
2095 {
2096   enum tree_code code = TREE_CODE (arg);
2097   char class = TREE_CODE_CLASS (code);
2098
2099   /* We can handle some of the 'e' cases here.  */
2100   if (class == 'e' && code == TRUTH_NOT_EXPR)
2101     class = '1';
2102   else if (class == 'e'
2103            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2104                || code == COMPOUND_EXPR))
2105     class = '2';
2106
2107   else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0
2108            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2109     {
2110       /* If we've already found a CVAL1 or CVAL2, this expression is
2111          two complex to handle.  */
2112       if (*cval1 || *cval2)
2113         return 0;
2114
2115       class = '1';
2116       *save_p = 1;
2117     }
2118
2119   switch (class)
2120     {
2121     case '1':
2122       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2123
2124     case '2':
2125       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2126               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2127                                       cval1, cval2, save_p));
2128
2129     case 'c':
2130       return 1;
2131
2132     case 'e':
2133       if (code == COND_EXPR)
2134         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2135                                      cval1, cval2, save_p)
2136                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2137                                         cval1, cval2, save_p)
2138                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2139                                         cval1, cval2, save_p));
2140       return 0;
2141
2142     case '<':
2143       /* First see if we can handle the first operand, then the second.  For
2144          the second operand, we know *CVAL1 can't be zero.  It must be that
2145          one side of the comparison is each of the values; test for the
2146          case where this isn't true by failing if the two operands
2147          are the same.  */
2148
2149       if (operand_equal_p (TREE_OPERAND (arg, 0),
2150                            TREE_OPERAND (arg, 1), 0))
2151         return 0;
2152
2153       if (*cval1 == 0)
2154         *cval1 = TREE_OPERAND (arg, 0);
2155       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2156         ;
2157       else if (*cval2 == 0)
2158         *cval2 = TREE_OPERAND (arg, 0);
2159       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2160         ;
2161       else
2162         return 0;
2163
2164       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2165         ;
2166       else if (*cval2 == 0)
2167         *cval2 = TREE_OPERAND (arg, 1);
2168       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2169         ;
2170       else
2171         return 0;
2172
2173       return 1;
2174
2175     default:
2176       return 0;
2177     }
2178 }
2179 \f
2180 /* ARG is a tree that is known to contain just arithmetic operations and
2181    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2182    any occurrence of OLD0 as an operand of a comparison and likewise for
2183    NEW1 and OLD1.  */
2184
2185 static tree
2186 eval_subst (arg, old0, new0, old1, new1)
2187      tree arg;
2188      tree old0, new0, old1, new1;
2189 {
2190   tree type = TREE_TYPE (arg);
2191   enum tree_code code = TREE_CODE (arg);
2192   char class = TREE_CODE_CLASS (code);
2193
2194   /* We can handle some of the 'e' cases here.  */
2195   if (class == 'e' && code == TRUTH_NOT_EXPR)
2196     class = '1';
2197   else if (class == 'e'
2198            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2199     class = '2';
2200
2201   switch (class)
2202     {
2203     case '1':
2204       return fold (build1 (code, type,
2205                            eval_subst (TREE_OPERAND (arg, 0),
2206                                        old0, new0, old1, new1)));
2207
2208     case '2':
2209       return fold (build (code, type,
2210                           eval_subst (TREE_OPERAND (arg, 0),
2211                                       old0, new0, old1, new1),
2212                           eval_subst (TREE_OPERAND (arg, 1),
2213                                       old0, new0, old1, new1)));
2214
2215     case 'e':
2216       switch (code)
2217         {
2218         case SAVE_EXPR:
2219           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2220
2221         case COMPOUND_EXPR:
2222           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2223
2224         case COND_EXPR:
2225           return fold (build (code, type,
2226                               eval_subst (TREE_OPERAND (arg, 0),
2227                                           old0, new0, old1, new1),
2228                               eval_subst (TREE_OPERAND (arg, 1),
2229                                           old0, new0, old1, new1),
2230                               eval_subst (TREE_OPERAND (arg, 2),
2231                                           old0, new0, old1, new1)));
2232         default:
2233           break;
2234         }
2235       /* fall through - ??? */
2236
2237     case '<':
2238       {
2239         tree arg0 = TREE_OPERAND (arg, 0);
2240         tree arg1 = TREE_OPERAND (arg, 1);
2241
2242         /* We need to check both for exact equality and tree equality.  The
2243            former will be true if the operand has a side-effect.  In that
2244            case, we know the operand occurred exactly once.  */
2245
2246         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2247           arg0 = new0;
2248         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2249           arg0 = new1;
2250
2251         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2252           arg1 = new0;
2253         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2254           arg1 = new1;
2255
2256         return fold (build (code, type, arg0, arg1));
2257       }
2258
2259     default:
2260       return arg;
2261     }
2262 }
2263 \f
2264 /* Return a tree for the case when the result of an expression is RESULT
2265    converted to TYPE and OMITTED was previously an operand of the expression
2266    but is now not needed (e.g., we folded OMITTED * 0).
2267
2268    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2269    the conversion of RESULT to TYPE.  */
2270
2271 tree
2272 omit_one_operand (type, result, omitted)
2273      tree type, result, omitted;
2274 {
2275   tree t = convert (type, result);
2276
2277   if (TREE_SIDE_EFFECTS (omitted))
2278     return build (COMPOUND_EXPR, type, omitted, t);
2279
2280   return non_lvalue (t);
2281 }
2282
2283 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2284
2285 static tree
2286 pedantic_omit_one_operand (type, result, omitted)
2287      tree type, result, omitted;
2288 {
2289   tree t = convert (type, result);
2290
2291   if (TREE_SIDE_EFFECTS (omitted))
2292     return build (COMPOUND_EXPR, type, omitted, t);
2293
2294   return pedantic_non_lvalue (t);
2295 }
2296 \f
2297 /* Return a simplified tree node for the truth-negation of ARG.  This
2298    never alters ARG itself.  We assume that ARG is an operation that
2299    returns a truth value (0 or 1).  */
2300
2301 tree
2302 invert_truthvalue (arg)
2303      tree arg;
2304 {
2305   tree type = TREE_TYPE (arg);
2306   enum tree_code code = TREE_CODE (arg);
2307
2308   if (code == ERROR_MARK)
2309     return arg;
2310
2311   /* If this is a comparison, we can simply invert it, except for
2312      floating-point non-equality comparisons, in which case we just
2313      enclose a TRUTH_NOT_EXPR around what we have.  */
2314
2315   if (TREE_CODE_CLASS (code) == '<')
2316     {
2317       if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
2318           && !flag_unsafe_math_optimizations
2319           && code != NE_EXPR
2320           && code != EQ_EXPR)
2321         return build1 (TRUTH_NOT_EXPR, type, arg);
2322       else
2323         return build (invert_tree_comparison (code), type,
2324                       TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2325     }
2326
2327   switch (code)
2328     {
2329     case INTEGER_CST:
2330       return convert (type, build_int_2 (integer_zerop (arg), 0));
2331
2332     case TRUTH_AND_EXPR:
2333       return build (TRUTH_OR_EXPR, type,
2334                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2335                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2336
2337     case TRUTH_OR_EXPR:
2338       return build (TRUTH_AND_EXPR, type,
2339                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2340                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2341
2342     case TRUTH_XOR_EXPR:
2343       /* Here we can invert either operand.  We invert the first operand
2344          unless the second operand is a TRUTH_NOT_EXPR in which case our
2345          result is the XOR of the first operand with the inside of the
2346          negation of the second operand.  */
2347
2348       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2349         return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2350                       TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2351       else
2352         return build (TRUTH_XOR_EXPR, type,
2353                       invert_truthvalue (TREE_OPERAND (arg, 0)),
2354                       TREE_OPERAND (arg, 1));
2355
2356     case TRUTH_ANDIF_EXPR:
2357       return build (TRUTH_ORIF_EXPR, type,
2358                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2359                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2360
2361     case TRUTH_ORIF_EXPR:
2362       return build (TRUTH_ANDIF_EXPR, type,
2363                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2364                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2365
2366     case TRUTH_NOT_EXPR:
2367       return TREE_OPERAND (arg, 0);
2368
2369     case COND_EXPR:
2370       return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2371                     invert_truthvalue (TREE_OPERAND (arg, 1)),
2372                     invert_truthvalue (TREE_OPERAND (arg, 2)));
2373
2374     case COMPOUND_EXPR:
2375       return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2376                     invert_truthvalue (TREE_OPERAND (arg, 1)));
2377
2378     case WITH_RECORD_EXPR:
2379       return build (WITH_RECORD_EXPR, type,
2380                     invert_truthvalue (TREE_OPERAND (arg, 0)),
2381                     TREE_OPERAND (arg, 1));
2382
2383     case NON_LVALUE_EXPR:
2384       return invert_truthvalue (TREE_OPERAND (arg, 0));
2385
2386     case NOP_EXPR:
2387     case CONVERT_EXPR:
2388     case FLOAT_EXPR:
2389       return build1 (TREE_CODE (arg), type,
2390                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2391
2392     case BIT_AND_EXPR:
2393       if (!integer_onep (TREE_OPERAND (arg, 1)))
2394         break;
2395       return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2396
2397     case SAVE_EXPR:
2398       return build1 (TRUTH_NOT_EXPR, type, arg);
2399
2400     case CLEANUP_POINT_EXPR:
2401       return build1 (CLEANUP_POINT_EXPR, type,
2402                      invert_truthvalue (TREE_OPERAND (arg, 0)));
2403
2404     default:
2405       break;
2406     }
2407   if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2408     abort ();
2409   return build1 (TRUTH_NOT_EXPR, type, arg);
2410 }
2411
2412 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2413    operands are another bit-wise operation with a common input.  If so,
2414    distribute the bit operations to save an operation and possibly two if
2415    constants are involved.  For example, convert
2416         (A | B) & (A | C) into A | (B & C)
2417    Further simplification will occur if B and C are constants.
2418
2419    If this optimization cannot be done, 0 will be returned.  */
2420
2421 static tree
2422 distribute_bit_expr (code, type, arg0, arg1)
2423      enum tree_code code;
2424      tree type;
2425      tree arg0, arg1;
2426 {
2427   tree common;
2428   tree left, right;
2429
2430   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2431       || TREE_CODE (arg0) == code
2432       || (TREE_CODE (arg0) != BIT_AND_EXPR
2433           && TREE_CODE (arg0) != BIT_IOR_EXPR))
2434     return 0;
2435
2436   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2437     {
2438       common = TREE_OPERAND (arg0, 0);
2439       left = TREE_OPERAND (arg0, 1);
2440       right = TREE_OPERAND (arg1, 1);
2441     }
2442   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2443     {
2444       common = TREE_OPERAND (arg0, 0);
2445       left = TREE_OPERAND (arg0, 1);
2446       right = TREE_OPERAND (arg1, 0);
2447     }
2448   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2449     {
2450       common = TREE_OPERAND (arg0, 1);
2451       left = TREE_OPERAND (arg0, 0);
2452       right = TREE_OPERAND (arg1, 1);
2453     }
2454   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2455     {
2456       common = TREE_OPERAND (arg0, 1);
2457       left = TREE_OPERAND (arg0, 0);
2458       right = TREE_OPERAND (arg1, 0);
2459     }
2460   else
2461     return 0;
2462
2463   return fold (build (TREE_CODE (arg0), type, common,
2464                       fold (build (code, type, left, right))));
2465 }
2466 \f
2467 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2468    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
2469
2470 static tree
2471 make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2472      tree inner;
2473      tree type;
2474      int bitsize, bitpos;
2475      int unsignedp;
2476 {
2477   tree result = build (BIT_FIELD_REF, type, inner,
2478                        size_int (bitsize), bitsize_int (bitpos));
2479
2480   TREE_UNSIGNED (result) = unsignedp;
2481
2482   return result;
2483 }
2484
2485 /* Optimize a bit-field compare.
2486
2487    There are two cases:  First is a compare against a constant and the
2488    second is a comparison of two items where the fields are at the same
2489    bit position relative to the start of a chunk (byte, halfword, word)
2490    large enough to contain it.  In these cases we can avoid the shift
2491    implicit in bitfield extractions.
2492
2493    For constants, we emit a compare of the shifted constant with the
2494    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2495    compared.  For two fields at the same position, we do the ANDs with the
2496    similar mask and compare the result of the ANDs.
2497
2498    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2499    COMPARE_TYPE is the type of the comparison, and LHS and RHS
2500    are the left and right operands of the comparison, respectively.
2501
2502    If the optimization described above can be done, we return the resulting
2503    tree.  Otherwise we return zero.  */
2504
2505 static tree
2506 optimize_bit_field_compare (code, compare_type, lhs, rhs)
2507      enum tree_code code;
2508      tree compare_type;
2509      tree lhs, rhs;
2510 {
2511   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
2512   tree type = TREE_TYPE (lhs);
2513   tree signed_type, unsigned_type;
2514   int const_p = TREE_CODE (rhs) == INTEGER_CST;
2515   enum machine_mode lmode, rmode, nmode;
2516   int lunsignedp, runsignedp;
2517   int lvolatilep = 0, rvolatilep = 0;
2518   tree linner, rinner = NULL_TREE;
2519   tree mask;
2520   tree offset;
2521
2522   /* Get all the information about the extractions being done.  If the bit size
2523      if the same as the size of the underlying object, we aren't doing an
2524      extraction at all and so can do nothing.  We also don't want to
2525      do anything if the inner expression is a PLACEHOLDER_EXPR since we
2526      then will no longer be able to replace it.  */
2527   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2528                                 &lunsignedp, &lvolatilep);
2529   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2530       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
2531     return 0;
2532
2533  if (!const_p)
2534    {
2535      /* If this is not a constant, we can only do something if bit positions,
2536         sizes, and signedness are the same.  */
2537      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2538                                    &runsignedp, &rvolatilep);
2539
2540      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2541          || lunsignedp != runsignedp || offset != 0
2542          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
2543        return 0;
2544    }
2545
2546   /* See if we can find a mode to refer to this field.  We should be able to,
2547      but fail if we can't.  */
2548   nmode = get_best_mode (lbitsize, lbitpos,
2549                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
2550                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
2551                                 TYPE_ALIGN (TREE_TYPE (rinner))),
2552                          word_mode, lvolatilep || rvolatilep);
2553   if (nmode == VOIDmode)
2554     return 0;
2555
2556   /* Set signed and unsigned types of the precision of this mode for the
2557      shifts below.  */
2558   signed_type = (*lang_hooks.types.type_for_mode) (nmode, 0);
2559   unsigned_type = (*lang_hooks.types.type_for_mode) (nmode, 1);
2560
2561   /* Compute the bit position and size for the new reference and our offset
2562      within it. If the new reference is the same size as the original, we
2563      won't optimize anything, so return zero.  */
2564   nbitsize = GET_MODE_BITSIZE (nmode);
2565   nbitpos = lbitpos & ~ (nbitsize - 1);
2566   lbitpos -= nbitpos;
2567   if (nbitsize == lbitsize)
2568     return 0;
2569
2570   if (BYTES_BIG_ENDIAN)
2571     lbitpos = nbitsize - lbitsize - lbitpos;
2572
2573   /* Make the mask to be used against the extracted field.  */
2574   mask = build_int_2 (~0, ~0);
2575   TREE_TYPE (mask) = unsigned_type;
2576   force_fit_type (mask, 0);
2577   mask = convert (unsigned_type, mask);
2578   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
2579   mask = const_binop (RSHIFT_EXPR, mask,
2580                       size_int (nbitsize - lbitsize - lbitpos), 0);
2581
2582   if (! const_p)
2583     /* If not comparing with constant, just rework the comparison
2584        and return.  */
2585     return build (code, compare_type,
2586                   build (BIT_AND_EXPR, unsigned_type,
2587                          make_bit_field_ref (linner, unsigned_type,
2588                                              nbitsize, nbitpos, 1),
2589                          mask),
2590                   build (BIT_AND_EXPR, unsigned_type,
2591                          make_bit_field_ref (rinner, unsigned_type,
2592                                              nbitsize, nbitpos, 1),
2593                          mask));
2594
2595   /* Otherwise, we are handling the constant case. See if the constant is too
2596      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
2597      this not only for its own sake, but to avoid having to test for this
2598      error case below.  If we didn't, we might generate wrong code.
2599
2600      For unsigned fields, the constant shifted right by the field length should
2601      be all zero.  For signed fields, the high-order bits should agree with
2602      the sign bit.  */
2603
2604   if (lunsignedp)
2605     {
2606       if (! integer_zerop (const_binop (RSHIFT_EXPR,
2607                                         convert (unsigned_type, rhs),
2608                                         size_int (lbitsize), 0)))
2609         {
2610           warning ("comparison is always %d due to width of bit-field",
2611                    code == NE_EXPR);
2612           return convert (compare_type,
2613                           (code == NE_EXPR
2614                            ? integer_one_node : integer_zero_node));
2615         }
2616     }
2617   else
2618     {
2619       tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
2620                               size_int (lbitsize - 1), 0);
2621       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2622         {
2623           warning ("comparison is always %d due to width of bit-field",
2624                    code == NE_EXPR);
2625           return convert (compare_type,
2626                           (code == NE_EXPR
2627                            ? integer_one_node : integer_zero_node));
2628         }
2629     }
2630
2631   /* Single-bit compares should always be against zero.  */
2632   if (lbitsize == 1 && ! integer_zerop (rhs))
2633     {
2634       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2635       rhs = convert (type, integer_zero_node);
2636     }
2637
2638   /* Make a new bitfield reference, shift the constant over the
2639      appropriate number of bits and mask it with the computed mask
2640      (in case this was a signed field).  If we changed it, make a new one.  */
2641   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
2642   if (lvolatilep)
2643     {
2644       TREE_SIDE_EFFECTS (lhs) = 1;
2645       TREE_THIS_VOLATILE (lhs) = 1;
2646     }
2647
2648   rhs = fold (const_binop (BIT_AND_EXPR,
2649                            const_binop (LSHIFT_EXPR,
2650                                         convert (unsigned_type, rhs),
2651                                         size_int (lbitpos), 0),
2652                            mask, 0));
2653
2654   return build (code, compare_type,
2655                 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
2656                 rhs);
2657 }
2658 \f
2659 /* Subroutine for fold_truthop: decode a field reference.
2660
2661    If EXP is a comparison reference, we return the innermost reference.
2662
2663    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2664    set to the starting bit number.
2665
2666    If the innermost field can be completely contained in a mode-sized
2667    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
2668
2669    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2670    otherwise it is not changed.
2671
2672    *PUNSIGNEDP is set to the signedness of the field.
2673
2674    *PMASK is set to the mask used.  This is either contained in a
2675    BIT_AND_EXPR or derived from the width of the field.
2676
2677    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
2678
2679    Return 0 if this is not a component reference or is one that we can't
2680    do anything with.  */
2681
2682 static tree
2683 decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
2684                         pvolatilep, pmask, pand_mask)
2685      tree exp;
2686      HOST_WIDE_INT *pbitsize, *pbitpos;
2687      enum machine_mode *pmode;
2688      int *punsignedp, *pvolatilep;
2689      tree *pmask;
2690      tree *pand_mask;
2691 {
2692   tree and_mask = 0;
2693   tree mask, inner, offset;
2694   tree unsigned_type;
2695   unsigned int precision;
2696
2697   /* All the optimizations using this function assume integer fields.
2698      There are problems with FP fields since the type_for_size call
2699      below can fail for, e.g., XFmode.  */
2700   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2701     return 0;
2702
2703   STRIP_NOPS (exp);
2704
2705   if (TREE_CODE (exp) == BIT_AND_EXPR)
2706     {
2707       and_mask = TREE_OPERAND (exp, 1);
2708       exp = TREE_OPERAND (exp, 0);
2709       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
2710       if (TREE_CODE (and_mask) != INTEGER_CST)
2711         return 0;
2712     }
2713
2714   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
2715                                punsignedp, pvolatilep);
2716   if ((inner == exp && and_mask == 0)
2717       || *pbitsize < 0 || offset != 0
2718       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
2719     return 0;
2720
2721   /* Compute the mask to access the bitfield.  */
2722   unsigned_type = (*lang_hooks.types.type_for_size) (*pbitsize, 1);
2723   precision = TYPE_PRECISION (unsigned_type);
2724
2725   mask = build_int_2 (~0, ~0);
2726   TREE_TYPE (mask) = unsigned_type;
2727   force_fit_type (mask, 0);
2728   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2729   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2730
2731   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
2732   if (and_mask != 0)
2733     mask = fold (build (BIT_AND_EXPR, unsigned_type,
2734                         convert (unsigned_type, and_mask), mask));
2735
2736   *pmask = mask;
2737   *pand_mask = and_mask;
2738   return inner;
2739 }
2740
2741 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
2742    bit positions.  */
2743
2744 static int
2745 all_ones_mask_p (mask, size)
2746      tree mask;
2747      int size;
2748 {
2749   tree type = TREE_TYPE (mask);
2750   unsigned int precision = TYPE_PRECISION (type);
2751   tree tmask;
2752
2753   tmask = build_int_2 (~0, ~0);
2754   TREE_TYPE (tmask) = (*lang_hooks.types.signed_type) (type);
2755   force_fit_type (tmask, 0);
2756   return
2757     tree_int_cst_equal (mask,
2758                         const_binop (RSHIFT_EXPR,
2759                                      const_binop (LSHIFT_EXPR, tmask,
2760                                                   size_int (precision - size),
2761                                                   0),
2762                                      size_int (precision - size), 0));
2763 }
2764
2765 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
2766    represents the sign bit of EXP's type.  If EXP represents a sign
2767    or zero extension, also test VAL against the unextended type.
2768    The return value is the (sub)expression whose sign bit is VAL,
2769    or NULL_TREE otherwise.  */
2770
2771 static tree
2772 sign_bit_p (exp, val)
2773      tree exp;
2774      tree val;
2775 {
2776   unsigned HOST_WIDE_INT lo;
2777   HOST_WIDE_INT hi;
2778   int width;
2779   tree t;
2780
2781   /* Tree EXP must have an integral type.  */
2782   t = TREE_TYPE (exp);
2783   if (! INTEGRAL_TYPE_P (t))
2784     return NULL_TREE;
2785
2786   /* Tree VAL must be an integer constant.  */
2787   if (TREE_CODE (val) != INTEGER_CST
2788       || TREE_CONSTANT_OVERFLOW (val))
2789     return NULL_TREE;
2790
2791   width = TYPE_PRECISION (t);
2792   if (width > HOST_BITS_PER_WIDE_INT)
2793     {
2794       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
2795       lo = 0;
2796     }
2797   else
2798     {
2799       hi = 0;
2800       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
2801     }
2802
2803   if (TREE_INT_CST_HIGH (val) == hi && TREE_INT_CST_LOW (val) == lo)
2804     return exp;
2805
2806   /* Handle extension from a narrower type.  */
2807   if (TREE_CODE (exp) == NOP_EXPR
2808       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
2809     return sign_bit_p (TREE_OPERAND (exp, 0), val);
2810
2811   return NULL_TREE;
2812 }
2813
2814 /* Subroutine for fold_truthop: determine if an operand is simple enough
2815    to be evaluated unconditionally.  */
2816
2817 static int
2818 simple_operand_p (exp)
2819      tree exp;
2820 {
2821   /* Strip any conversions that don't change the machine mode.  */
2822   while ((TREE_CODE (exp) == NOP_EXPR
2823           || TREE_CODE (exp) == CONVERT_EXPR)
2824          && (TYPE_MODE (TREE_TYPE (exp))
2825              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2826     exp = TREE_OPERAND (exp, 0);
2827
2828   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2829           || (DECL_P (exp)
2830               && ! TREE_ADDRESSABLE (exp)
2831               && ! TREE_THIS_VOLATILE (exp)
2832               && ! DECL_NONLOCAL (exp)
2833               /* Don't regard global variables as simple.  They may be
2834                  allocated in ways unknown to the compiler (shared memory,
2835                  #pragma weak, etc).  */
2836               && ! TREE_PUBLIC (exp)
2837               && ! DECL_EXTERNAL (exp)
2838               /* Loading a static variable is unduly expensive, but global
2839                  registers aren't expensive.  */
2840               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
2841 }
2842 \f
2843 /* The following functions are subroutines to fold_range_test and allow it to
2844    try to change a logical combination of comparisons into a range test.
2845
2846    For example, both
2847         X == 2 || X == 3 || X == 4 || X == 5
2848    and
2849         X >= 2 && X <= 5
2850    are converted to
2851         (unsigned) (X - 2) <= 3
2852
2853    We describe each set of comparisons as being either inside or outside
2854    a range, using a variable named like IN_P, and then describe the
2855    range with a lower and upper bound.  If one of the bounds is omitted,
2856    it represents either the highest or lowest value of the type.
2857
2858    In the comments below, we represent a range by two numbers in brackets
2859    preceded by a "+" to designate being inside that range, or a "-" to
2860    designate being outside that range, so the condition can be inverted by
2861    flipping the prefix.  An omitted bound is represented by a "-".  For
2862    example, "- [-, 10]" means being outside the range starting at the lowest
2863    possible value and ending at 10, in other words, being greater than 10.
2864    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
2865    always false.
2866
2867    We set up things so that the missing bounds are handled in a consistent
2868    manner so neither a missing bound nor "true" and "false" need to be
2869    handled using a special case.  */
2870
2871 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
2872    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
2873    and UPPER1_P are nonzero if the respective argument is an upper bound
2874    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
2875    must be specified for a comparison.  ARG1 will be converted to ARG0's
2876    type if both are specified.  */
2877
2878 static tree
2879 range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
2880      enum tree_code code;
2881      tree type;
2882      tree arg0, arg1;
2883      int upper0_p, upper1_p;
2884 {
2885   tree tem;
2886   int result;
2887   int sgn0, sgn1;
2888
2889   /* If neither arg represents infinity, do the normal operation.
2890      Else, if not a comparison, return infinity.  Else handle the special
2891      comparison rules. Note that most of the cases below won't occur, but
2892      are handled for consistency.  */
2893
2894   if (arg0 != 0 && arg1 != 0)
2895     {
2896       tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
2897                          arg0, convert (TREE_TYPE (arg0), arg1)));
2898       STRIP_NOPS (tem);
2899       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
2900     }
2901
2902   if (TREE_CODE_CLASS (code) != '<')
2903     return 0;
2904
2905   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
2906      for neither.  In real maths, we cannot assume open ended ranges are
2907      the same. But, this is computer arithmetic, where numbers are finite.
2908      We can therefore make the transformation of any unbounded range with
2909      the value Z, Z being greater than any representable number. This permits
2910      us to treat unbounded ranges as equal.  */
2911   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
2912   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
2913   switch (code)
2914     {
2915     case EQ_EXPR:
2916       result = sgn0 == sgn1;
2917       break;
2918     case NE_EXPR:
2919       result = sgn0 != sgn1;
2920       break;
2921     case LT_EXPR:
2922       result = sgn0 < sgn1;
2923       break;
2924     case LE_EXPR:
2925       result = sgn0 <= sgn1;
2926       break;
2927     case GT_EXPR:
2928       result = sgn0 > sgn1;
2929       break;
2930     case GE_EXPR:
2931       result = sgn0 >= sgn1;
2932       break;
2933     default:
2934       abort ();
2935     }
2936
2937   return convert (type, result ? integer_one_node : integer_zero_node);
2938 }
2939 \f
2940 /* Given EXP, a logical expression, set the range it is testing into
2941    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
2942    actually being tested.  *PLOW and *PHIGH will be made of the same type
2943    as the returned expression.  If EXP is not a comparison, we will most
2944    likely not be returning a useful value and range.  */
2945
2946 static tree
2947 make_range (exp, pin_p, plow, phigh)
2948      tree exp;
2949      int *pin_p;
2950      tree *plow, *phigh;
2951 {
2952   enum tree_code code;
2953   tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
2954   tree orig_type = NULL_TREE;
2955   int in_p, n_in_p;
2956   tree low, high, n_low, n_high;
2957
2958   /* Start with simply saying "EXP != 0" and then look at the code of EXP
2959      and see if we can refine the range.  Some of the cases below may not
2960      happen, but it doesn't seem worth worrying about this.  We "continue"
2961      the outer loop when we've changed something; otherwise we "break"
2962      the switch, which will "break" the while.  */
2963
2964   in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
2965
2966   while (1)
2967     {
2968       code = TREE_CODE (exp);
2969
2970       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
2971         {
2972           arg0 = TREE_OPERAND (exp, 0);
2973           if (TREE_CODE_CLASS (code) == '<'
2974               || TREE_CODE_CLASS (code) == '1'
2975               || TREE_CODE_CLASS (code) == '2')
2976             type = TREE_TYPE (arg0);
2977           if (TREE_CODE_CLASS (code) == '2'
2978               || TREE_CODE_CLASS (code) == '<'
2979               || (TREE_CODE_CLASS (code) == 'e'
2980                   && TREE_CODE_LENGTH (code) > 1))
2981             arg1 = TREE_OPERAND (exp, 1);
2982         }
2983
2984       /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
2985          lose a cast by accident.  */
2986       if (type != NULL_TREE && orig_type == NULL_TREE)
2987         orig_type = type;
2988
2989       switch (code)
2990         {
2991         case TRUTH_NOT_EXPR:
2992           in_p = ! in_p, exp = arg0;
2993           continue;
2994
2995         case EQ_EXPR: case NE_EXPR:
2996         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
2997           /* We can only do something if the range is testing for zero
2998              and if the second operand is an integer constant.  Note that
2999              saying something is "in" the range we make is done by
3000              complementing IN_P since it will set in the initial case of
3001              being not equal to zero; "out" is leaving it alone.  */
3002           if (low == 0 || high == 0
3003               || ! integer_zerop (low) || ! integer_zerop (high)
3004               || TREE_CODE (arg1) != INTEGER_CST)
3005             break;
3006
3007           switch (code)
3008             {
3009             case NE_EXPR:  /* - [c, c]  */
3010               low = high = arg1;
3011               break;
3012             case EQ_EXPR:  /* + [c, c]  */
3013               in_p = ! in_p, low = high = arg1;
3014               break;
3015             case GT_EXPR:  /* - [-, c] */
3016               low = 0, high = arg1;
3017               break;
3018             case GE_EXPR:  /* + [c, -] */
3019               in_p = ! in_p, low = arg1, high = 0;
3020               break;
3021             case LT_EXPR:  /* - [c, -] */
3022               low = arg1, high = 0;
3023               break;
3024             case LE_EXPR:  /* + [-, c] */
3025               in_p = ! in_p, low = 0, high = arg1;
3026               break;
3027             default:
3028               abort ();
3029             }
3030
3031           exp = arg0;
3032
3033           /* If this is an unsigned comparison, we also know that EXP is
3034              greater than or equal to zero.  We base the range tests we make
3035              on that fact, so we record it here so we can parse existing
3036              range tests.  */
3037           if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
3038             {
3039               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3040                                   1, convert (type, integer_zero_node),
3041                                   NULL_TREE))
3042                 break;
3043
3044               in_p = n_in_p, low = n_low, high = n_high;
3045
3046               /* If the high bound is missing, but we
3047                  have a low bound, reverse the range so
3048                  it goes from zero to the low bound minus 1.  */
3049               if (high == 0 && low)
3050                 {
3051                   in_p = ! in_p;
3052                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3053                                       integer_one_node, 0);
3054                   low = convert (type, integer_zero_node);
3055                 }
3056             }
3057           continue;
3058
3059         case NEGATE_EXPR:
3060           /* (-x) IN [a,b] -> x in [-b, -a]  */
3061           n_low = range_binop (MINUS_EXPR, type,
3062                                convert (type, integer_zero_node), 0, high, 1);
3063           n_high = range_binop (MINUS_EXPR, type,
3064                                 convert (type, integer_zero_node), 0, low, 0);
3065           low = n_low, high = n_high;
3066           exp = arg0;
3067           continue;
3068
3069         case BIT_NOT_EXPR:
3070           /* ~ X -> -X - 1  */
3071           exp = build (MINUS_EXPR, type, negate_expr (arg0),
3072                        convert (type, integer_one_node));
3073           continue;
3074
3075         case PLUS_EXPR:  case MINUS_EXPR:
3076           if (TREE_CODE (arg1) != INTEGER_CST)
3077             break;
3078
3079           /* If EXP is signed, any overflow in the computation is undefined,
3080              so we don't worry about it so long as our computations on
3081              the bounds don't overflow.  For unsigned, overflow is defined
3082              and this is exactly the right thing.  */
3083           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3084                                type, low, 0, arg1, 0);
3085           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3086                                 type, high, 1, arg1, 0);
3087           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3088               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3089             break;
3090
3091           /* Check for an unsigned range which has wrapped around the maximum
3092              value thus making n_high < n_low, and normalize it.  */
3093           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3094             {
3095               low = range_binop (PLUS_EXPR, type, n_high, 0,
3096                                  integer_one_node, 0);
3097               high = range_binop (MINUS_EXPR, type, n_low, 0,
3098                                   integer_one_node, 0);
3099
3100               /* If the range is of the form +/- [ x+1, x ], we won't
3101                  be able to normalize it.  But then, it represents the
3102                  whole range or the empty set, so make it
3103                  +/- [ -, - ].  */
3104               if (tree_int_cst_equal (n_low, low)
3105                   && tree_int_cst_equal (n_high, high))
3106                 low = high = 0;
3107               else
3108                 in_p = ! in_p;
3109             }
3110           else
3111             low = n_low, high = n_high;
3112
3113           exp = arg0;
3114           continue;
3115
3116         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3117           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3118             break;
3119
3120           if (! INTEGRAL_TYPE_P (type)
3121               || (low != 0 && ! int_fits_type_p (low, type))
3122               || (high != 0 && ! int_fits_type_p (high, type)))
3123             break;
3124
3125           n_low = low, n_high = high;
3126
3127           if (n_low != 0)
3128             n_low = convert (type, n_low);
3129
3130           if (n_high != 0)
3131             n_high = convert (type, n_high);
3132
3133           /* If we're converting from an unsigned to a signed type,
3134              we will be doing the comparison as unsigned.  The tests above
3135              have already verified that LOW and HIGH are both positive.
3136
3137              So we have to make sure that the original unsigned value will
3138              be interpreted as positive.  */
3139           if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3140             {
3141               tree equiv_type = (*lang_hooks.types.type_for_mode)
3142                 (TYPE_MODE (type), 1);
3143               tree high_positive;
3144
3145               /* A range without an upper bound is, naturally, unbounded.
3146                  Since convert would have cropped a very large value, use
3147                  the max value for the destination type.  */
3148               high_positive
3149                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3150                   : TYPE_MAX_VALUE (type);
3151
3152               if (TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (exp)))
3153                 high_positive = fold (build (RSHIFT_EXPR, type,
3154                                              convert (type, high_positive),
3155                                              convert (type, integer_one_node)));
3156
3157               /* If the low bound is specified, "and" the range with the
3158                  range for which the original unsigned value will be
3159                  positive.  */
3160               if (low != 0)
3161                 {
3162                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3163                                       1, n_low, n_high,
3164                                       1, convert (type, integer_zero_node),
3165                                       high_positive))
3166                     break;
3167
3168                   in_p = (n_in_p == in_p);
3169                 }
3170               else
3171                 {
3172                   /* Otherwise, "or" the range with the range of the input
3173                      that will be interpreted as negative.  */
3174                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3175                                       0, n_low, n_high,
3176                                       1, convert (type, integer_zero_node),
3177                                       high_positive))
3178                     break;
3179
3180                   in_p = (in_p != n_in_p);
3181                 }
3182             }
3183
3184           exp = arg0;
3185           low = n_low, high = n_high;
3186           continue;
3187
3188         default:
3189           break;
3190         }
3191
3192       break;
3193     }
3194
3195   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3196   if (TREE_CODE (exp) == INTEGER_CST)
3197     {
3198       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3199                                                  exp, 0, low, 0))
3200                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3201                                                     exp, 1, high, 1)));
3202       low = high = 0;
3203       exp = 0;
3204     }
3205
3206   *pin_p = in_p, *plow = low, *phigh = high;
3207   return exp;
3208 }
3209 \f
3210 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3211    type, TYPE, return an expression to test if EXP is in (or out of, depending
3212    on IN_P) the range.  */
3213
3214 static tree
3215 build_range_check (type, exp, in_p, low, high)
3216      tree type;
3217      tree exp;
3218      int in_p;
3219      tree low, high;
3220 {
3221   tree etype = TREE_TYPE (exp);
3222   tree value;
3223
3224   if (! in_p
3225       && (0 != (value = build_range_check (type, exp, 1, low, high))))
3226     return invert_truthvalue (value);
3227
3228   if (low == 0 && high == 0)
3229     return convert (type, integer_one_node);
3230
3231   if (low == 0)
3232     return fold (build (LE_EXPR, type, exp, high));
3233
3234   if (high == 0)
3235     return fold (build (GE_EXPR, type, exp, low));
3236
3237   if (operand_equal_p (low, high, 0))
3238     return fold (build (EQ_EXPR, type, exp, low));
3239
3240   if (integer_zerop (low))
3241     {
3242       if (! TREE_UNSIGNED (etype))
3243         {
3244           etype = (*lang_hooks.types.unsigned_type) (etype);
3245           high = convert (etype, high);
3246           exp = convert (etype, exp);
3247         }
3248       return build_range_check (type, exp, 1, 0, high);
3249     }
3250
3251   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
3252   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
3253     {
3254       unsigned HOST_WIDE_INT lo;
3255       HOST_WIDE_INT hi;
3256       int prec;
3257
3258       prec = TYPE_PRECISION (etype);
3259       if (prec <= HOST_BITS_PER_WIDE_INT)
3260         {
3261           hi = 0;
3262           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
3263         }
3264       else
3265         {
3266           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
3267           lo = (unsigned HOST_WIDE_INT) -1;
3268         }
3269
3270       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
3271         {
3272           if (TREE_UNSIGNED (etype))
3273             {
3274               etype = (*lang_hooks.types.signed_type) (etype);
3275               exp = convert (etype, exp);
3276             }
3277           return fold (build (GT_EXPR, type, exp,
3278                               convert (etype, integer_zero_node)));
3279         }
3280     }
3281
3282   if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3283       && ! TREE_OVERFLOW (value))
3284     return build_range_check (type,
3285                               fold (build (MINUS_EXPR, etype, exp, low)),
3286                               1, convert (etype, integer_zero_node), value);
3287
3288   return 0;
3289 }
3290 \f
3291 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3292    can, 0 if we can't.  Set the output range into the specified parameters.  */
3293
3294 static int
3295 merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3296      int *pin_p;
3297      tree *plow, *phigh;
3298      int in0_p, in1_p;
3299      tree low0, high0, low1, high1;
3300 {
3301   int no_overlap;
3302   int subset;
3303   int temp;
3304   tree tem;
3305   int in_p;
3306   tree low, high;
3307   int lowequal = ((low0 == 0 && low1 == 0)
3308                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3309                                                 low0, 0, low1, 0)));
3310   int highequal = ((high0 == 0 && high1 == 0)
3311                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3312                                                  high0, 1, high1, 1)));
3313
3314   /* Make range 0 be the range that starts first, or ends last if they
3315      start at the same value.  Swap them if it isn't.  */
3316   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3317                                  low0, 0, low1, 0))
3318       || (lowequal
3319           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3320                                         high1, 1, high0, 1))))
3321     {
3322       temp = in0_p, in0_p = in1_p, in1_p = temp;
3323       tem = low0, low0 = low1, low1 = tem;
3324       tem = high0, high0 = high1, high1 = tem;
3325     }
3326
3327   /* Now flag two cases, whether the ranges are disjoint or whether the
3328      second range is totally subsumed in the first.  Note that the tests
3329      below are simplified by the ones above.  */
3330   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3331                                           high0, 1, low1, 0));
3332   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3333                                       high1, 1, high0, 1));
3334
3335   /* We now have four cases, depending on whether we are including or
3336      excluding the two ranges.  */
3337   if (in0_p && in1_p)
3338     {
3339       /* If they don't overlap, the result is false.  If the second range
3340          is a subset it is the result.  Otherwise, the range is from the start
3341          of the second to the end of the first.  */
3342       if (no_overlap)
3343         in_p = 0, low = high = 0;
3344       else if (subset)
3345         in_p = 1, low = low1, high = high1;
3346       else
3347         in_p = 1, low = low1, high = high0;
3348     }
3349
3350   else if (in0_p && ! in1_p)
3351     {
3352       /* If they don't overlap, the result is the first range.  If they are
3353          equal, the result is false.  If the second range is a subset of the
3354          first, and the ranges begin at the same place, we go from just after
3355          the end of the first range to the end of the second.  If the second
3356          range is not a subset of the first, or if it is a subset and both
3357          ranges end at the same place, the range starts at the start of the
3358          first range and ends just before the second range.
3359          Otherwise, we can't describe this as a single range.  */
3360       if (no_overlap)
3361         in_p = 1, low = low0, high = high0;
3362       else if (lowequal && highequal)
3363         in_p = 0, low = high = 0;
3364       else if (subset && lowequal)
3365         {
3366           in_p = 1, high = high0;
3367           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3368                              integer_one_node, 0);
3369         }
3370       else if (! subset || highequal)
3371         {
3372           in_p = 1, low = low0;
3373           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3374                               integer_one_node, 0);
3375         }
3376       else
3377         return 0;
3378     }
3379
3380   else if (! in0_p && in1_p)
3381     {
3382       /* If they don't overlap, the result is the second range.  If the second
3383          is a subset of the first, the result is false.  Otherwise,
3384          the range starts just after the first range and ends at the
3385          end of the second.  */
3386       if (no_overlap)
3387         in_p = 1, low = low1, high = high1;
3388       else if (subset || highequal)
3389         in_p = 0, low = high = 0;
3390       else
3391         {
3392           in_p = 1, high = high1;
3393           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3394                              integer_one_node, 0);
3395         }
3396     }
3397
3398   else
3399     {
3400       /* The case where we are excluding both ranges.  Here the complex case
3401          is if they don't overlap.  In that case, the only time we have a
3402          range is if they are adjacent.  If the second is a subset of the
3403          first, the result is the first.  Otherwise, the range to exclude
3404          starts at the beginning of the first range and ends at the end of the
3405          second.  */
3406       if (no_overlap)
3407         {
3408           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3409                                          range_binop (PLUS_EXPR, NULL_TREE,
3410                                                       high0, 1,
3411                                                       integer_one_node, 1),
3412                                          1, low1, 0)))
3413             in_p = 0, low = low0, high = high1;
3414           else
3415             return 0;
3416         }
3417       else if (subset)
3418         in_p = 0, low = low0, high = high0;
3419       else
3420         in_p = 0, low = low0, high = high1;
3421     }
3422
3423   *pin_p = in_p, *plow = low, *phigh = high;
3424   return 1;
3425 }
3426 \f
3427 #ifndef RANGE_TEST_NON_SHORT_CIRCUIT
3428 #define RANGE_TEST_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
3429 #endif
3430
3431 /* EXP is some logical combination of boolean tests.  See if we can
3432    merge it into some range test.  Return the new tree if so.  */
3433
3434 static tree
3435 fold_range_test (exp)
3436      tree exp;
3437 {
3438   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3439                || TREE_CODE (exp) == TRUTH_OR_EXPR);
3440   int in0_p, in1_p, in_p;
3441   tree low0, low1, low, high0, high1, high;
3442   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3443   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3444   tree tem;
3445
3446   /* If this is an OR operation, invert both sides; we will invert
3447      again at the end.  */
3448   if (or_op)
3449     in0_p = ! in0_p, in1_p = ! in1_p;
3450
3451   /* If both expressions are the same, if we can merge the ranges, and we
3452      can build the range test, return it or it inverted.  If one of the
3453      ranges is always true or always false, consider it to be the same
3454      expression as the other.  */
3455   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3456       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3457                        in1_p, low1, high1)
3458       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3459                                          lhs != 0 ? lhs
3460                                          : rhs != 0 ? rhs : integer_zero_node,
3461                                          in_p, low, high))))
3462     return or_op ? invert_truthvalue (tem) : tem;
3463
3464   /* On machines where the branch cost is expensive, if this is a
3465      short-circuited branch and the underlying object on both sides
3466      is the same, make a non-short-circuit operation.  */
3467   else if (RANGE_TEST_NON_SHORT_CIRCUIT
3468            && lhs != 0 && rhs != 0
3469            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3470                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3471            && operand_equal_p (lhs, rhs, 0))
3472     {
3473       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
3474          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3475          which cases we can't do this.  */
3476       if (simple_operand_p (lhs))
3477         return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3478                       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3479                       TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3480                       TREE_OPERAND (exp, 1));
3481
3482       else if ((*lang_hooks.decls.global_bindings_p) () == 0
3483                && ! CONTAINS_PLACEHOLDER_P (lhs))
3484         {
3485           tree common = save_expr (lhs);
3486
3487           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3488                                              or_op ? ! in0_p : in0_p,
3489                                              low0, high0))
3490               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3491                                                  or_op ? ! in1_p : in1_p,
3492                                                  low1, high1))))
3493             return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3494                           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3495                           TREE_TYPE (exp), lhs, rhs);
3496         }
3497     }
3498
3499   return 0;
3500 }
3501 \f
3502 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3503    bit value.  Arrange things so the extra bits will be set to zero if and
3504    only if C is signed-extended to its full width.  If MASK is nonzero,
3505    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
3506
3507 static tree
3508 unextend (c, p, unsignedp, mask)
3509      tree c;
3510      int p;
3511      int unsignedp;
3512      tree mask;
3513 {
3514   tree type = TREE_TYPE (c);
3515   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3516   tree temp;
3517
3518   if (p == modesize || unsignedp)
3519     return c;
3520
3521   /* We work by getting just the sign bit into the low-order bit, then
3522      into the high-order bit, then sign-extend.  We then XOR that value
3523      with C.  */
3524   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3525   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3526
3527   /* We must use a signed type in order to get an arithmetic right shift.
3528      However, we must also avoid introducing accidental overflows, so that
3529      a subsequent call to integer_zerop will work.  Hence we must
3530      do the type conversion here.  At this point, the constant is either
3531      zero or one, and the conversion to a signed type can never overflow.
3532      We could get an overflow if this conversion is done anywhere else.  */
3533   if (TREE_UNSIGNED (type))
3534     temp = convert ((*lang_hooks.types.signed_type) (type), temp);
3535
3536   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3537   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3538   if (mask != 0)
3539     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3540   /* If necessary, convert the type back to match the type of C.  */
3541   if (TREE_UNSIGNED (type))
3542     temp = convert (type, temp);
3543
3544   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3545 }
3546 \f
3547 /* Find ways of folding logical expressions of LHS and RHS:
3548    Try to merge two comparisons to the same innermost item.
3549    Look for range tests like "ch >= '0' && ch <= '9'".
3550    Look for combinations of simple terms on machines with expensive branches
3551    and evaluate the RHS unconditionally.
3552
3553    For example, if we have p->a == 2 && p->b == 4 and we can make an
3554    object large enough to span both A and B, we can do this with a comparison
3555    against the object ANDed with the a mask.
3556
3557    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3558    operations to do this with one comparison.
3559
3560    We check for both normal comparisons and the BIT_AND_EXPRs made this by
3561    function and the one above.
3562
3563    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
3564    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3565
3566    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3567    two operands.
3568
3569    We return the simplified tree or 0 if no optimization is possible.  */
3570
3571 static tree
3572 fold_truthop (code, truth_type, lhs, rhs)
3573      enum tree_code code;
3574      tree truth_type, lhs, rhs;
3575 {
3576   /* If this is the "or" of two comparisons, we can do something if
3577      the comparisons are NE_EXPR.  If this is the "and", we can do something
3578      if the comparisons are EQ_EXPR.  I.e.,
3579         (a->b == 2 && a->c == 4) can become (a->new == NEW).
3580
3581      WANTED_CODE is this operation code.  For single bit fields, we can
3582      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3583      comparison for one-bit fields.  */
3584
3585   enum tree_code wanted_code;
3586   enum tree_code lcode, rcode;
3587   tree ll_arg, lr_arg, rl_arg, rr_arg;
3588   tree ll_inner, lr_inner, rl_inner, rr_inner;
3589   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3590   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3591   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3592   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3593   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3594   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3595   enum machine_mode lnmode, rnmode;
3596   tree ll_mask, lr_mask, rl_mask, rr_mask;
3597   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3598   tree l_const, r_const;
3599   tree lntype, rntype, result;
3600   int first_bit, end_bit;
3601   int volatilep;
3602
3603   /* Start by getting the comparison codes.  Fail if anything is volatile.
3604      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3605      it were surrounded with a NE_EXPR.  */
3606
3607   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3608     return 0;
3609
3610   lcode = TREE_CODE (lhs);
3611   rcode = TREE_CODE (rhs);
3612
3613   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3614     lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3615
3616   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3617     rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3618
3619   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3620     return 0;
3621
3622   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3623           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3624
3625   ll_arg = TREE_OPERAND (lhs, 0);
3626   lr_arg = TREE_OPERAND (lhs, 1);
3627   rl_arg = TREE_OPERAND (rhs, 0);
3628   rr_arg = TREE_OPERAND (rhs, 1);
3629
3630   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
3631   if (simple_operand_p (ll_arg)
3632       && simple_operand_p (lr_arg)
3633       && !FLOAT_TYPE_P (TREE_TYPE (ll_arg)))
3634     {
3635       int compcode;
3636
3637       if (operand_equal_p (ll_arg, rl_arg, 0)
3638           && operand_equal_p (lr_arg, rr_arg, 0))
3639         {
3640           int lcompcode, rcompcode;
3641
3642           lcompcode = comparison_to_compcode (lcode);
3643           rcompcode = comparison_to_compcode (rcode);
3644           compcode = (code == TRUTH_AND_EXPR)
3645                      ? lcompcode & rcompcode
3646                      : lcompcode | rcompcode;
3647         }
3648       else if (operand_equal_p (ll_arg, rr_arg, 0)
3649                && operand_equal_p (lr_arg, rl_arg, 0))
3650         {
3651           int lcompcode, rcompcode;
3652
3653           rcode = swap_tree_comparison (rcode);
3654           lcompcode = comparison_to_compcode (lcode);
3655           rcompcode = comparison_to_compcode (rcode);
3656           compcode = (code == TRUTH_AND_EXPR)
3657                      ? lcompcode & rcompcode
3658                      : lcompcode | rcompcode;
3659         }
3660       else
3661         compcode = -1;
3662
3663       if (compcode == COMPCODE_TRUE)
3664         return convert (truth_type, integer_one_node);
3665       else if (compcode == COMPCODE_FALSE)
3666         return convert (truth_type, integer_zero_node);
3667       else if (compcode != -1)
3668         return build (compcode_to_comparison (compcode),
3669                       truth_type, ll_arg, lr_arg);
3670     }
3671
3672   /* If the RHS can be evaluated unconditionally and its operands are
3673      simple, it wins to evaluate the RHS unconditionally on machines
3674      with expensive branches.  In this case, this isn't a comparison
3675      that can be merged.  Avoid doing this if the RHS is a floating-point
3676      comparison since those can trap.  */
3677
3678   if (BRANCH_COST >= 2
3679       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
3680       && simple_operand_p (rl_arg)
3681       && simple_operand_p (rr_arg))
3682     {
3683       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
3684       if (code == TRUTH_OR_EXPR
3685           && lcode == NE_EXPR && integer_zerop (lr_arg)
3686           && rcode == NE_EXPR && integer_zerop (rr_arg)
3687           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
3688         return build (NE_EXPR, truth_type,
3689                       build (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
3690                              ll_arg, rl_arg),
3691                       integer_zero_node);
3692
3693       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
3694       if (code == TRUTH_AND_EXPR
3695           && lcode == EQ_EXPR && integer_zerop (lr_arg)
3696           && rcode == EQ_EXPR && integer_zerop (rr_arg)
3697           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
3698         return build (EQ_EXPR, truth_type,
3699                       build (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
3700                              ll_arg, rl_arg),
3701                       integer_zero_node);
3702
3703       return build (code, truth_type, lhs, rhs);
3704     }
3705
3706   /* See if the comparisons can be merged.  Then get all the parameters for
3707      each side.  */
3708
3709   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3710       || (rcode != EQ_EXPR && rcode != NE_EXPR))
3711     return 0;
3712
3713   volatilep = 0;
3714   ll_inner = decode_field_reference (ll_arg,
3715                                      &ll_bitsize, &ll_bitpos, &ll_mode,
3716                                      &ll_unsignedp, &volatilep, &ll_mask,
3717                                      &ll_and_mask);
3718   lr_inner = decode_field_reference (lr_arg,
3719                                      &lr_bitsize, &lr_bitpos, &lr_mode,
3720                                      &lr_unsignedp, &volatilep, &lr_mask,
3721                                      &lr_and_mask);
3722   rl_inner = decode_field_reference (rl_arg,
3723                                      &rl_bitsize, &rl_bitpos, &rl_mode,
3724                                      &rl_unsignedp, &volatilep, &rl_mask,
3725                                      &rl_and_mask);
3726   rr_inner = decode_field_reference (rr_arg,
3727                                      &rr_bitsize, &rr_bitpos, &rr_mode,
3728                                      &rr_unsignedp, &volatilep, &rr_mask,
3729                                      &rr_and_mask);
3730
3731   /* It must be true that the inner operation on the lhs of each
3732      comparison must be the same if we are to be able to do anything.
3733      Then see if we have constants.  If not, the same must be true for
3734      the rhs's.  */
3735   if (volatilep || ll_inner == 0 || rl_inner == 0
3736       || ! operand_equal_p (ll_inner, rl_inner, 0))
3737     return 0;
3738
3739   if (TREE_CODE (lr_arg) == INTEGER_CST
3740       && TREE_CODE (rr_arg) == INTEGER_CST)
3741     l_const = lr_arg, r_const = rr_arg;
3742   else if (lr_inner == 0 || rr_inner == 0
3743            || ! operand_equal_p (lr_inner, rr_inner, 0))
3744     return 0;
3745   else
3746     l_const = r_const = 0;
3747
3748   /* If either comparison code is not correct for our logical operation,
3749      fail.  However, we can convert a one-bit comparison against zero into
3750      the opposite comparison against that bit being set in the field.  */
3751
3752   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3753   if (lcode != wanted_code)
3754     {
3755       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3756         {
3757           /* Make the left operand unsigned, since we are only interested
3758              in the value of one bit.  Otherwise we are doing the wrong
3759              thing below.  */
3760           ll_unsignedp = 1;
3761           l_const = ll_mask;
3762         }
3763       else
3764         return 0;
3765     }
3766
3767   /* This is analogous to the code for l_const above.  */
3768   if (rcode != wanted_code)
3769     {
3770       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3771         {
3772           rl_unsignedp = 1;
3773           r_const = rl_mask;
3774         }
3775       else
3776         return 0;
3777     }
3778
3779   /* After this point all optimizations will generate bit-field
3780      references, which we might not want.  */
3781   if (! (*lang_hooks.can_use_bit_fields_p) ())
3782     return 0;
3783
3784   /* See if we can find a mode that contains both fields being compared on
3785      the left.  If we can't, fail.  Otherwise, update all constants and masks
3786      to be relative to a field of that size.  */
3787   first_bit = MIN (ll_bitpos, rl_bitpos);
3788   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3789   lnmode = get_best_mode (end_bit - first_bit, first_bit,
3790                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3791                           volatilep);
3792   if (lnmode == VOIDmode)
3793     return 0;
3794
3795   lnbitsize = GET_MODE_BITSIZE (lnmode);
3796   lnbitpos = first_bit & ~ (lnbitsize - 1);
3797   lntype = (*lang_hooks.types.type_for_size) (lnbitsize, 1);
3798   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3799
3800   if (BYTES_BIG_ENDIAN)
3801     {
3802       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3803       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3804     }
3805
3806   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3807                          size_int (xll_bitpos), 0);
3808   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3809                          size_int (xrl_bitpos), 0);
3810
3811   if (l_const)
3812     {
3813       l_const = convert (lntype, l_const);
3814       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
3815       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3816       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3817                                         fold (build1 (BIT_NOT_EXPR,
3818                                                       lntype, ll_mask)),
3819                                         0)))
3820         {
3821           warning ("comparison is always %d", wanted_code == NE_EXPR);
3822
3823           return convert (truth_type,
3824                           wanted_code == NE_EXPR
3825                           ? integer_one_node : integer_zero_node);
3826         }
3827     }
3828   if (r_const)
3829     {
3830       r_const = convert (lntype, r_const);
3831       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3832       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3833       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3834                                         fold (build1 (BIT_NOT_EXPR,
3835                                                       lntype, rl_mask)),
3836                                         0)))
3837         {
3838           warning ("comparison is always %d", wanted_code == NE_EXPR);
3839
3840           return convert (truth_type,
3841                           wanted_code == NE_EXPR
3842                           ? integer_one_node : integer_zero_node);
3843         }
3844     }
3845
3846   /* If the right sides are not constant, do the same for it.  Also,
3847      disallow this optimization if a size or signedness mismatch occurs
3848      between the left and right sides.  */
3849   if (l_const == 0)
3850     {
3851       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
3852           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
3853           /* Make sure the two fields on the right
3854              correspond to the left without being swapped.  */
3855           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
3856         return 0;
3857
3858       first_bit = MIN (lr_bitpos, rr_bitpos);
3859       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
3860       rnmode = get_best_mode (end_bit - first_bit, first_bit,
3861                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
3862                               volatilep);
3863       if (rnmode == VOIDmode)
3864         return 0;
3865
3866       rnbitsize = GET_MODE_BITSIZE (rnmode);
3867       rnbitpos = first_bit & ~ (rnbitsize - 1);
3868       rntype = (*lang_hooks.types.type_for_size) (rnbitsize, 1);
3869       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
3870
3871       if (BYTES_BIG_ENDIAN)
3872         {
3873           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
3874           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
3875         }
3876
3877       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
3878                              size_int (xlr_bitpos), 0);
3879       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
3880                              size_int (xrr_bitpos), 0);
3881
3882       /* Make a mask that corresponds to both fields being compared.
3883          Do this for both items being compared.  If the operands are the
3884          same size and the bits being compared are in the same position
3885          then we can do this by masking both and comparing the masked
3886          results.  */
3887       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3888       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
3889       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
3890         {
3891           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3892                                     ll_unsignedp || rl_unsignedp);
3893           if (! all_ones_mask_p (ll_mask, lnbitsize))
3894             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
3895
3896           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
3897                                     lr_unsignedp || rr_unsignedp);
3898           if (! all_ones_mask_p (lr_mask, rnbitsize))
3899             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
3900
3901           return build (wanted_code, truth_type, lhs, rhs);
3902         }
3903
3904       /* There is still another way we can do something:  If both pairs of
3905          fields being compared are adjacent, we may be able to make a wider
3906          field containing them both.
3907
3908          Note that we still must mask the lhs/rhs expressions.  Furthermore,
3909          the mask must be shifted to account for the shift done by
3910          make_bit_field_ref.  */
3911       if ((ll_bitsize + ll_bitpos == rl_bitpos
3912            && lr_bitsize + lr_bitpos == rr_bitpos)
3913           || (ll_bitpos == rl_bitpos + rl_bitsize
3914               && lr_bitpos == rr_bitpos + rr_bitsize))
3915         {
3916           tree type;
3917
3918           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
3919                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
3920           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
3921                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
3922
3923           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
3924                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
3925           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
3926                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
3927
3928           /* Convert to the smaller type before masking out unwanted bits.  */
3929           type = lntype;
3930           if (lntype != rntype)
3931             {
3932               if (lnbitsize > rnbitsize)
3933                 {
3934                   lhs = convert (rntype, lhs);
3935                   ll_mask = convert (rntype, ll_mask);
3936                   type = rntype;
3937                 }
3938               else if (lnbitsize < rnbitsize)
3939                 {
3940                   rhs = convert (lntype, rhs);
3941                   lr_mask = convert (lntype, lr_mask);
3942                   type = lntype;
3943                 }
3944             }
3945
3946           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
3947             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3948
3949           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
3950             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
3951
3952           return build (wanted_code, truth_type, lhs, rhs);
3953         }
3954
3955       return 0;
3956     }
3957
3958   /* Handle the case of comparisons with constants.  If there is something in
3959      common between the masks, those bits of the constants must be the same.
3960      If not, the condition is always false.  Test for this to avoid generating
3961      incorrect code below.  */
3962   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
3963   if (! integer_zerop (result)
3964       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
3965                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
3966     {
3967       if (wanted_code == NE_EXPR)
3968         {
3969           warning ("`or' of unmatched not-equal tests is always 1");
3970           return convert (truth_type, integer_one_node);
3971         }
3972       else
3973         {
3974           warning ("`and' of mutually exclusive equal-tests is always 0");
3975           return convert (truth_type, integer_zero_node);
3976         }
3977     }
3978
3979   /* Construct the expression we will return.  First get the component
3980      reference we will make.  Unless the mask is all ones the width of
3981      that field, perform the mask operation.  Then compare with the
3982      merged constant.  */
3983   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3984                                ll_unsignedp || rl_unsignedp);
3985
3986   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3987   if (! all_ones_mask_p (ll_mask, lnbitsize))
3988     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
3989
3990   return build (wanted_code, truth_type, result,
3991                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
3992 }
3993 \f
3994 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
3995    constant.  */
3996
3997 static tree
3998 optimize_minmax_comparison (t)
3999      tree t;
4000 {
4001   tree type = TREE_TYPE (t);
4002   tree arg0 = TREE_OPERAND (t, 0);
4003   enum tree_code op_code;
4004   tree comp_const = TREE_OPERAND (t, 1);
4005   tree minmax_const;
4006   int consts_equal, consts_lt;
4007   tree inner;
4008
4009   STRIP_SIGN_NOPS (arg0);
4010
4011   op_code = TREE_CODE (arg0);
4012   minmax_const = TREE_OPERAND (arg0, 1);
4013   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4014   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4015   inner = TREE_OPERAND (arg0, 0);
4016
4017   /* If something does not permit us to optimize, return the original tree.  */
4018   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4019       || TREE_CODE (comp_const) != INTEGER_CST
4020       || TREE_CONSTANT_OVERFLOW (comp_const)
4021       || TREE_CODE (minmax_const) != INTEGER_CST
4022       || TREE_CONSTANT_OVERFLOW (minmax_const))
4023     return t;
4024
4025   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4026      and GT_EXPR, doing the rest with recursive calls using logical
4027      simplifications.  */
4028   switch (TREE_CODE (t))
4029     {
4030     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4031       return
4032         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4033
4034     case GE_EXPR:
4035       return
4036         fold (build (TRUTH_ORIF_EXPR, type,
4037                      optimize_minmax_comparison
4038                      (build (EQ_EXPR, type, arg0, comp_const)),
4039                      optimize_minmax_comparison
4040                      (build (GT_EXPR, type, arg0, comp_const))));
4041
4042     case EQ_EXPR:
4043       if (op_code == MAX_EXPR && consts_equal)
4044         /* MAX (X, 0) == 0  ->  X <= 0  */
4045         return fold (build (LE_EXPR, type, inner, comp_const));
4046
4047       else if (op_code == MAX_EXPR && consts_lt)
4048         /* MAX (X, 0) == 5  ->  X == 5   */
4049         return fold (build (EQ_EXPR, type, inner, comp_const));
4050
4051       else if (op_code == MAX_EXPR)
4052         /* MAX (X, 0) == -1  ->  false  */
4053         return omit_one_operand (type, integer_zero_node, inner);
4054
4055       else if (consts_equal)
4056         /* MIN (X, 0) == 0  ->  X >= 0  */
4057         return fold (build (GE_EXPR, type, inner, comp_const));
4058
4059       else if (consts_lt)
4060         /* MIN (X, 0) == 5  ->  false  */
4061         return omit_one_operand (type, integer_zero_node, inner);
4062
4063       else
4064         /* MIN (X, 0) == -1  ->  X == -1  */
4065         return fold (build (EQ_EXPR, type, inner, comp_const));
4066
4067     case GT_EXPR:
4068       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4069         /* MAX (X, 0) > 0  ->  X > 0
4070            MAX (X, 0) > 5  ->  X > 5  */
4071         return fold (build (GT_EXPR, type, inner, comp_const));
4072
4073       else if (op_code == MAX_EXPR)
4074         /* MAX (X, 0) > -1  ->  true  */
4075         return omit_one_operand (type, integer_one_node, inner);
4076
4077       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4078         /* MIN (X, 0) > 0  ->  false
4079            MIN (X, 0) > 5  ->  false  */
4080         return omit_one_operand (type, integer_zero_node, inner);
4081
4082       else
4083         /* MIN (X, 0) > -1  ->  X > -1  */
4084         return fold (build (GT_EXPR, type, inner, comp_const));
4085
4086     default:
4087       return t;
4088     }
4089 }
4090 \f
4091 /* T is an integer expression that is being multiplied, divided, or taken a
4092    modulus (CODE says which and what kind of divide or modulus) by a
4093    constant C.  See if we can eliminate that operation by folding it with
4094    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4095    should be used for the computation if wider than our type.
4096
4097    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
4098    (X * 2) + (Y * 4).  We must, however, be assured that either the original
4099    expression would not overflow or that overflow is undefined for the type
4100    in the language in question.
4101
4102    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4103    the machine has a multiply-accumulate insn or that this is part of an
4104    addressing calculation.
4105
4106    If we return a non-null expression, it is an equivalent form of the
4107    original computation, but need not be in the original type.  */
4108
4109 static tree
4110 extract_muldiv (t, c, code, wide_type)
4111      tree t;
4112      tree c;
4113      enum tree_code code;
4114      tree wide_type;
4115 {
4116   /* To avoid exponential search depth, refuse to allow recursion past
4117      three levels.  Beyond that (1) it's highly unlikely that we'll find
4118      something interesting and (2) we've probably processed it before
4119      when we built the inner expression.  */
4120
4121   static int depth;
4122   tree ret;
4123
4124   if (depth > 3)
4125     return NULL;
4126
4127   depth++;
4128   ret = extract_muldiv_1 (t, c, code, wide_type);
4129   depth--;
4130
4131   return ret;
4132 }
4133
4134 static tree
4135 extract_muldiv_1 (t, c, code, wide_type)
4136      tree t;
4137      tree c;
4138      enum tree_code code;
4139      tree wide_type;
4140 {
4141   tree type = TREE_TYPE (t);
4142   enum tree_code tcode = TREE_CODE (t);
4143   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4144                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4145                 ? wide_type : type);
4146   tree t1, t2;
4147   int same_p = tcode == code;
4148   tree op0 = NULL_TREE, op1 = NULL_TREE;
4149
4150   /* Don't deal with constants of zero here; they confuse the code below.  */
4151   if (integer_zerop (c))
4152     return NULL_TREE;
4153
4154   if (TREE_CODE_CLASS (tcode) == '1')
4155     op0 = TREE_OPERAND (t, 0);
4156
4157   if (TREE_CODE_CLASS (tcode) == '2')
4158     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4159
4160   /* Note that we need not handle conditional operations here since fold
4161      already handles those cases.  So just do arithmetic here.  */
4162   switch (tcode)
4163     {
4164     case INTEGER_CST:
4165       /* For a constant, we can always simplify if we are a multiply
4166          or (for divide and modulus) if it is a multiple of our constant.  */
4167       if (code == MULT_EXPR
4168           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4169         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4170       break;
4171
4172     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4173       /* If op0 is an expression ...  */
4174       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
4175            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
4176            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
4177            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
4178           /* ... and is unsigned, and its type is smaller than ctype,
4179              then we cannot pass through as widening.  */
4180           && ((TREE_UNSIGNED (TREE_TYPE (op0))
4181                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
4182                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
4183                && (GET_MODE_SIZE (TYPE_MODE (ctype))
4184                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
4185               /* ... or its type is larger than ctype,
4186                  then we cannot pass through this truncation.  */
4187               || (GET_MODE_SIZE (TYPE_MODE (ctype))
4188                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
4189               /* ... or signedness changes for division or modulus,
4190                  then we cannot pass through this conversion.  */
4191               || (code != MULT_EXPR
4192                   && (TREE_UNSIGNED (ctype)
4193                       != TREE_UNSIGNED (TREE_TYPE (op0))))))
4194         break;
4195
4196       /* Pass the constant down and see if we can make a simplification.  If
4197          we can, replace this expression with the inner simplification for
4198          possible later conversion to our or some other type.  */
4199       if ((t2 = convert (TREE_TYPE (op0), c)) != 0
4200           && TREE_CODE (t2) == INTEGER_CST
4201           && ! TREE_CONSTANT_OVERFLOW (t2)
4202           && (0 != (t1 = extract_muldiv (op0, t2, code,
4203                                          code == MULT_EXPR
4204                                          ? ctype : NULL_TREE))))
4205         return t1;
4206       break;
4207
4208     case NEGATE_EXPR:  case ABS_EXPR:
4209       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4210         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4211       break;
4212
4213     case MIN_EXPR:  case MAX_EXPR:
4214       /* If widening the type changes the signedness, then we can't perform
4215          this optimization as that changes the result.  */
4216       if (TREE_UNSIGNED (ctype) != TREE_UNSIGNED (type))
4217         break;
4218
4219       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4220       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4221           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4222         {
4223           if (tree_int_cst_sgn (c) < 0)
4224             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4225
4226           return fold (build (tcode, ctype, convert (ctype, t1),
4227                               convert (ctype, t2)));
4228         }
4229       break;
4230
4231     case WITH_RECORD_EXPR:
4232       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4233         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4234                       TREE_OPERAND (t, 1));
4235       break;
4236
4237     case SAVE_EXPR:
4238       /* If this has not been evaluated and the operand has no side effects,
4239          we can see if we can do something inside it and make a new one.
4240          Note that this test is overly conservative since we can do this
4241          if the only reason it had side effects is that it was another
4242          similar SAVE_EXPR, but that isn't worth bothering with.  */
4243       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4244           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4245                                         wide_type)))
4246         {
4247           t1 = save_expr (t1);
4248           if (SAVE_EXPR_PERSISTENT_P (t) && TREE_CODE (t1) == SAVE_EXPR)
4249             SAVE_EXPR_PERSISTENT_P (t1) = 1;
4250           if (is_pending_size (t))
4251             put_pending_size (t1);
4252           return t1;
4253         }
4254       break;
4255
4256     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4257       /* If the second operand is constant, this is a multiplication
4258          or floor division, by a power of two, so we can treat it that
4259          way unless the multiplier or divisor overflows.  */
4260       if (TREE_CODE (op1) == INTEGER_CST
4261           /* const_binop may not detect overflow correctly,
4262              so check for it explicitly here.  */
4263           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
4264           && TREE_INT_CST_HIGH (op1) == 0
4265           && 0 != (t1 = convert (ctype,
4266                                  const_binop (LSHIFT_EXPR, size_one_node,
4267                                               op1, 0)))
4268           && ! TREE_OVERFLOW (t1))
4269         return extract_muldiv (build (tcode == LSHIFT_EXPR
4270                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4271                                       ctype, convert (ctype, op0), t1),
4272                                c, code, wide_type);
4273       break;
4274
4275     case PLUS_EXPR:  case MINUS_EXPR:
4276       /* See if we can eliminate the operation on both sides.  If we can, we
4277          can return a new PLUS or MINUS.  If we can't, the only remaining
4278          cases where we can do anything are if the second operand is a
4279          constant.  */
4280       t1 = extract_muldiv (op0, c, code, wide_type);
4281       t2 = extract_muldiv (op1, c, code, wide_type);
4282       if (t1 != 0 && t2 != 0
4283           && (code == MULT_EXPR
4284               /* If not multiplication, we can only do this if both operands
4285                  are divisible by c.  */
4286               || (multiple_of_p (ctype, op0, c)
4287                   && multiple_of_p (ctype, op1, c))))
4288         return fold (build (tcode, ctype, convert (ctype, t1),
4289                             convert (ctype, t2)));
4290
4291       /* If this was a subtraction, negate OP1 and set it to be an addition.
4292          This simplifies the logic below.  */
4293       if (tcode == MINUS_EXPR)
4294         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4295
4296       if (TREE_CODE (op1) != INTEGER_CST)
4297         break;
4298
4299       /* If either OP1 or C are negative, this optimization is not safe for
4300          some of the division and remainder types while for others we need
4301          to change the code.  */
4302       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4303         {
4304           if (code == CEIL_DIV_EXPR)
4305             code = FLOOR_DIV_EXPR;
4306           else if (code == FLOOR_DIV_EXPR)
4307             code = CEIL_DIV_EXPR;
4308           else if (code != MULT_EXPR
4309                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
4310             break;
4311         }
4312
4313       /* If it's a multiply or a division/modulus operation of a multiple
4314          of our constant, do the operation and verify it doesn't overflow.  */
4315       if (code == MULT_EXPR
4316           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4317         {
4318           op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4319           if (op1 == 0 || TREE_OVERFLOW (op1))
4320             break;
4321         }
4322       else
4323         break;
4324
4325       /* If we have an unsigned type is not a sizetype, we cannot widen
4326          the operation since it will change the result if the original
4327          computation overflowed.  */
4328       if (TREE_UNSIGNED (ctype)
4329           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
4330           && ctype != type)
4331         break;
4332
4333       /* If we were able to eliminate our operation from the first side,
4334          apply our operation to the second side and reform the PLUS.  */
4335       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4336         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4337
4338       /* The last case is if we are a multiply.  In that case, we can
4339          apply the distributive law to commute the multiply and addition
4340          if the multiplication of the constants doesn't overflow.  */
4341       if (code == MULT_EXPR)
4342         return fold (build (tcode, ctype, fold (build (code, ctype,
4343                                                        convert (ctype, op0),
4344                                                        convert (ctype, c))),
4345                             op1));
4346
4347       break;
4348
4349     case MULT_EXPR:
4350       /* We have a special case here if we are doing something like
4351          (C * 8) % 4 since we know that's zero.  */
4352       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4353            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4354           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4355           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4356         return omit_one_operand (type, integer_zero_node, op0);
4357
4358       /* ... fall through ...  */
4359
4360     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4361     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4362       /* If we can extract our operation from the LHS, do so and return a
4363          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4364          do something only if the second operand is a constant.  */
4365       if (same_p
4366           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4367         return fold (build (tcode, ctype, convert (ctype, t1),
4368                             convert (ctype, op1)));
4369       else if (tcode == MULT_EXPR && code == MULT_EXPR
4370                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4371         return fold (build (tcode, ctype, convert (ctype, op0),
4372                             convert (ctype, t1)));
4373       else if (TREE_CODE (op1) != INTEGER_CST)
4374         return 0;
4375
4376       /* If these are the same operation types, we can associate them
4377          assuming no overflow.  */
4378       if (tcode == code
4379           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4380                                      convert (ctype, c), 0))
4381           && ! TREE_OVERFLOW (t1))
4382         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4383
4384       /* If these operations "cancel" each other, we have the main
4385          optimizations of this pass, which occur when either constant is a
4386          multiple of the other, in which case we replace this with either an
4387          operation or CODE or TCODE.
4388
4389          If we have an unsigned type that is not a sizetype, we cannot do
4390          this since it will change the result if the original computation
4391          overflowed.  */
4392       if ((! TREE_UNSIGNED (ctype)
4393            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
4394           && ! flag_wrapv
4395           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4396               || (tcode == MULT_EXPR
4397                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4398                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
4399         {
4400           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4401             return fold (build (tcode, ctype, convert (ctype, op0),
4402                                 convert (ctype,
4403                                          const_binop (TRUNC_DIV_EXPR,
4404                                                       op1, c, 0))));
4405           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4406             return fold (build (code, ctype, convert (ctype, op0),
4407                                 convert (ctype,
4408                                          const_binop (TRUNC_DIV_EXPR,
4409                                                       c, op1, 0))));
4410         }
4411       break;
4412
4413     default:
4414       break;
4415     }
4416
4417   return 0;
4418 }
4419 \f
4420 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4421    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4422    that we may sometimes modify the tree.  */
4423
4424 static tree
4425 strip_compound_expr (t, s)
4426      tree t;
4427      tree s;
4428 {
4429   enum tree_code code = TREE_CODE (t);
4430
4431   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4432   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4433       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4434     return TREE_OPERAND (t, 1);
4435
4436   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4437      don't bother handling any other types.  */
4438   else if (code == COND_EXPR)
4439     {
4440       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4441       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4442       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4443     }
4444   else if (TREE_CODE_CLASS (code) == '1')
4445     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4446   else if (TREE_CODE_CLASS (code) == '<'
4447            || TREE_CODE_CLASS (code) == '2')
4448     {
4449       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4450       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4451     }
4452
4453   return t;
4454 }
4455 \f
4456 /* Return a node which has the indicated constant VALUE (either 0 or
4457    1), and is of the indicated TYPE.  */
4458
4459 static tree
4460 constant_boolean_node (value, type)
4461      int value;
4462      tree type;
4463 {
4464   if (type == integer_type_node)
4465     return value ? integer_one_node : integer_zero_node;
4466   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4467     return (*lang_hooks.truthvalue_conversion) (value ? integer_one_node :
4468                                                 integer_zero_node);
4469   else
4470     {
4471       tree t = build_int_2 (value, 0);
4472
4473       TREE_TYPE (t) = type;
4474       return t;
4475     }
4476 }
4477
4478 /* Utility function for the following routine, to see how complex a nesting of
4479    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4480    we don't care (to avoid spending too much time on complex expressions.).  */
4481
4482 static int
4483 count_cond (expr, lim)
4484      tree expr;
4485      int lim;
4486 {
4487   int ctrue, cfalse;
4488
4489   if (TREE_CODE (expr) != COND_EXPR)
4490     return 0;
4491   else if (lim <= 0)
4492     return 0;
4493
4494   ctrue = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4495   cfalse = count_cond (TREE_OPERAND (expr, 2), lim - 1 - ctrue);
4496   return MIN (lim, 1 + ctrue + cfalse);
4497 }
4498
4499 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
4500    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
4501    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
4502    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
4503    COND is the first argument to CODE; otherwise (as in the example
4504    given here), it is the second argument.  TYPE is the type of the
4505    original expression.  */
4506
4507 static tree
4508 fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
4509      enum tree_code code;
4510      tree type;
4511      tree cond;
4512      tree arg;
4513      int cond_first_p;
4514 {
4515   tree test, true_value, false_value;
4516   tree lhs = NULL_TREE;
4517   tree rhs = NULL_TREE;
4518   /* In the end, we'll produce a COND_EXPR.  Both arms of the
4519      conditional expression will be binary operations.  The left-hand
4520      side of the expression to be executed if the condition is true
4521      will be pointed to by TRUE_LHS.  Similarly, the right-hand side
4522      of the expression to be executed if the condition is true will be
4523      pointed to by TRUE_RHS.  FALSE_LHS and FALSE_RHS are analogous --
4524      but apply to the expression to be executed if the conditional is
4525      false.  */
4526   tree *true_lhs;
4527   tree *true_rhs;
4528   tree *false_lhs;
4529   tree *false_rhs;
4530   /* These are the codes to use for the left-hand side and right-hand
4531      side of the COND_EXPR.  Normally, they are the same as CODE.  */
4532   enum tree_code lhs_code = code;
4533   enum tree_code rhs_code = code;
4534   /* And these are the types of the expressions.  */
4535   tree lhs_type = type;
4536   tree rhs_type = type;
4537   int save = 0;
4538
4539   if (cond_first_p)
4540     {
4541       true_rhs = false_rhs = &arg;
4542       true_lhs = &true_value;
4543       false_lhs = &false_value;
4544     }
4545   else
4546     {
4547       true_lhs = false_lhs = &arg;
4548       true_rhs = &true_value;
4549       false_rhs = &false_value;
4550     }
4551
4552   if (TREE_CODE (cond) == COND_EXPR)
4553     {
4554       test = TREE_OPERAND (cond, 0);
4555       true_value = TREE_OPERAND (cond, 1);
4556       false_value = TREE_OPERAND (cond, 2);
4557       /* If this operand throws an expression, then it does not make
4558          sense to try to perform a logical or arithmetic operation
4559          involving it.  Instead of building `a + throw 3' for example,
4560          we simply build `a, throw 3'.  */
4561       if (VOID_TYPE_P (TREE_TYPE (true_value)))
4562         {
4563           if (! cond_first_p)
4564             {
4565               lhs_code = COMPOUND_EXPR;
4566               lhs_type = void_type_node;
4567             }
4568           else
4569             lhs = true_value;
4570         }
4571       if (VOID_TYPE_P (TREE_TYPE (false_value)))
4572         {
4573           if (! cond_first_p)
4574             {
4575               rhs_code = COMPOUND_EXPR;
4576               rhs_type = void_type_node;
4577             }
4578           else
4579             rhs = false_value;
4580         }
4581     }
4582   else
4583     {
4584       tree testtype = TREE_TYPE (cond);
4585       test = cond;
4586       true_value = convert (testtype, integer_one_node);
4587       false_value = convert (testtype, integer_zero_node);
4588     }
4589
4590   /* If ARG is complex we want to make sure we only evaluate it once.  Though
4591      this is only required if it is volatile, it might be more efficient even
4592      if it is not.  However, if we succeed in folding one part to a constant,
4593      we do not need to make this SAVE_EXPR.  Since we do this optimization
4594      primarily to see if we do end up with constant and this SAVE_EXPR
4595      interferes with later optimizations, suppressing it when we can is
4596      important.
4597
4598      If we are not in a function, we can't make a SAVE_EXPR, so don't try to
4599      do so.  Don't try to see if the result is a constant if an arm is a
4600      COND_EXPR since we get exponential behavior in that case.  */
4601
4602   if (saved_expr_p (arg))
4603     save = 1;
4604   else if (lhs == 0 && rhs == 0
4605            && !TREE_CONSTANT (arg)
4606            && (*lang_hooks.decls.global_bindings_p) () == 0
4607            && ((TREE_CODE (arg) != VAR_DECL && TREE_CODE (arg) != PARM_DECL)
4608                || TREE_SIDE_EFFECTS (arg)))
4609     {
4610       if (TREE_CODE (true_value) != COND_EXPR)
4611         lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4612
4613       if (TREE_CODE (false_value) != COND_EXPR)
4614         rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4615
4616       if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4617           && (rhs == 0 || !TREE_CONSTANT (rhs)))
4618         {
4619           arg = save_expr (arg);
4620           lhs = rhs = 0;
4621           save = 1;
4622         }
4623     }
4624
4625   if (lhs == 0)
4626     lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4627   if (rhs == 0)
4628     rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4629
4630   test = fold (build (COND_EXPR, type, test, lhs, rhs));
4631
4632   if (save)
4633     return build (COMPOUND_EXPR, type,
4634                   convert (void_type_node, arg),
4635                   strip_compound_expr (test, arg));
4636   else
4637     return convert (type, test);
4638 }
4639
4640 \f
4641 /* Subroutine of fold() that checks for the addition of +/- 0.0.
4642
4643    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
4644    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
4645    ADDEND is the same as X.
4646
4647    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
4648    and finite.  The problematic cases are when X is zero, and its mode
4649    has signed zeros.  In the case of rounding towards -infinity,
4650    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
4651    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
4652
4653 static bool
4654 fold_real_zero_addition_p (type, addend, negate)
4655      tree type, addend;
4656      int negate;
4657 {
4658   if (!real_zerop (addend))
4659     return false;
4660
4661   /* Don't allow the fold with -fsignaling-nans.  */
4662   if (HONOR_SNANS (TYPE_MODE (type)))
4663     return false;
4664
4665   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
4666   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
4667     return true;
4668
4669   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
4670   if (TREE_CODE (addend) == REAL_CST
4671       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
4672     negate = !negate;
4673
4674   /* The mode has signed zeros, and we have to honor their sign.
4675      In this situation, there is only one case we can return true for.
4676      X - 0 is the same as X unless rounding towards -infinity is
4677      supported.  */
4678   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
4679 }
4680
4681 /* Subroutine of fold() that checks comparisons of built-in math
4682    functions against real constants.
4683
4684    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
4685    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
4686    is the type of the result and ARG0 and ARG1 are the operands of the
4687    comparison.  ARG1 must be a TREE_REAL_CST.
4688
4689    The function returns the constant folded tree if a simplification
4690    can be made, and NULL_TREE otherwise.  */
4691
4692 static tree
4693 fold_mathfn_compare (fcode, code, type, arg0, arg1)
4694      enum built_in_function fcode;
4695      enum tree_code code;
4696      tree type, arg0, arg1;
4697 {
4698   REAL_VALUE_TYPE c;
4699
4700   if (fcode == BUILT_IN_SQRT
4701       || fcode == BUILT_IN_SQRTF
4702       || fcode == BUILT_IN_SQRTL)
4703     {
4704       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
4705       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
4706
4707       c = TREE_REAL_CST (arg1);
4708       if (REAL_VALUE_NEGATIVE (c))
4709         {
4710           /* sqrt(x) < y is always false, if y is negative.  */
4711           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
4712             return omit_one_operand (type,
4713                                      convert (type, integer_zero_node),
4714                                      arg);
4715
4716           /* sqrt(x) > y is always true, if y is negative and we
4717              don't care about NaNs, i.e. negative values of x.  */
4718           if (code == NE_EXPR || !HONOR_NANS (mode))
4719             return omit_one_operand (type,
4720                                      convert (type, integer_one_node),
4721                                      arg);
4722
4723           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
4724           return fold (build (GE_EXPR, type, arg,
4725                               build_real (TREE_TYPE (arg), dconst0)));
4726         }
4727       else if (code == GT_EXPR || code == GE_EXPR)
4728         {
4729           REAL_VALUE_TYPE c2;
4730
4731           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
4732           real_convert (&c2, mode, &c2);
4733
4734           if (REAL_VALUE_ISINF (c2))
4735             {
4736               /* sqrt(x) > y is x == +Inf, when y is very large.  */
4737               if (HONOR_INFINITIES (mode))
4738                 return fold (build (EQ_EXPR, type, arg,
4739                                     build_real (TREE_TYPE (arg), c2)));
4740
4741               /* sqrt(x) > y is always false, when y is very large
4742                  and we don't care about infinities.  */
4743               return omit_one_operand (type,
4744                                        convert (type, integer_zero_node),
4745                                        arg);
4746             }
4747
4748           /* sqrt(x) > c is the same as x > c*c.  */
4749           return fold (build (code, type, arg,
4750                               build_real (TREE_TYPE (arg), c2)));
4751         }
4752       else if (code == LT_EXPR || code == LE_EXPR)
4753         {
4754           REAL_VALUE_TYPE c2;
4755
4756           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
4757           real_convert (&c2, mode, &c2);
4758
4759           if (REAL_VALUE_ISINF (c2))
4760             {
4761               /* sqrt(x) < y is always true, when y is a very large
4762                  value and we don't care about NaNs or Infinities.  */
4763               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
4764                 return omit_one_operand (type,
4765                                          convert (type, integer_one_node),
4766                                          arg);
4767
4768               /* sqrt(x) < y is x != +Inf when y is very large and we
4769                  don't care about NaNs.  */
4770               if (! HONOR_NANS (mode))
4771                 return fold (build (NE_EXPR, type, arg,
4772                                     build_real (TREE_TYPE (arg), c2)));
4773
4774               /* sqrt(x) < y is x >= 0 when y is very large and we
4775                  don't care about Infinities.  */
4776               if (! HONOR_INFINITIES (mode))
4777                 return fold (build (GE_EXPR, type, arg,
4778                                     build_real (TREE_TYPE (arg), dconst0)));
4779
4780               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
4781               if ((*lang_hooks.decls.global_bindings_p) () != 0
4782                   || CONTAINS_PLACEHOLDER_P (arg))
4783                 return NULL_TREE;
4784
4785               arg = save_expr (arg);
4786               return fold (build (TRUTH_ANDIF_EXPR, type,
4787                                   fold (build (GE_EXPR, type, arg,
4788                                                build_real (TREE_TYPE (arg),
4789                                                            dconst0))),
4790                                   fold (build (NE_EXPR, type, arg,
4791                                                build_real (TREE_TYPE (arg),
4792                                                            c2)))));
4793             }
4794
4795           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
4796           if (! HONOR_NANS (mode))
4797             return fold (build (code, type, arg,
4798                                 build_real (TREE_TYPE (arg), c2)));
4799
4800           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
4801           if ((*lang_hooks.decls.global_bindings_p) () == 0
4802               && ! CONTAINS_PLACEHOLDER_P (arg))
4803             {
4804               arg = save_expr (arg);
4805               return fold (build (TRUTH_ANDIF_EXPR, type,
4806                                   fold (build (GE_EXPR, type, arg,
4807                                                build_real (TREE_TYPE (arg),
4808                                                            dconst0))),
4809                                   fold (build (code, type, arg,
4810                                                build_real (TREE_TYPE (arg),
4811                                                            c2)))));
4812             }
4813         }
4814     }
4815
4816   return NULL_TREE;
4817 }
4818
4819 /* Subroutine of fold() that optimizes comparisons against Infinities,
4820    either +Inf or -Inf.
4821
4822    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
4823    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
4824    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
4825
4826    The function returns the constant folded tree if a simplification
4827    can be made, and NULL_TREE otherwise.  */
4828
4829 static tree
4830 fold_inf_compare (code, type, arg0, arg1)
4831      enum tree_code code;
4832      tree type, arg0, arg1;
4833 {
4834   enum machine_mode mode;
4835   REAL_VALUE_TYPE max;
4836   tree temp;
4837   bool neg;
4838
4839   mode = TYPE_MODE (TREE_TYPE (arg0));
4840
4841   /* For negative infinity swap the sense of the comparison.  */
4842   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
4843   if (neg)
4844     code = swap_tree_comparison (code);
4845
4846   switch (code)
4847     {
4848     case GT_EXPR:
4849       /* x > +Inf is always false, if with ignore sNANs.  */
4850       if (HONOR_SNANS (mode))
4851         return NULL_TREE;
4852       return omit_one_operand (type,
4853                                convert (type, integer_zero_node),
4854                                arg0);
4855
4856     case LE_EXPR:
4857       /* x <= +Inf is always true, if we don't case about NaNs.  */
4858       if (! HONOR_NANS (mode))
4859         return omit_one_operand (type,
4860                                  convert (type, integer_one_node),
4861                                  arg0);
4862
4863       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
4864       if ((*lang_hooks.decls.global_bindings_p) () == 0
4865           && ! CONTAINS_PLACEHOLDER_P (arg0))
4866         {
4867           arg0 = save_expr (arg0);
4868           return fold (build (EQ_EXPR, type, arg0, arg0));
4869         }
4870       break;
4871
4872     case EQ_EXPR:
4873     case GE_EXPR:
4874       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
4875       real_maxval (&max, neg, mode);
4876       return fold (build (neg ? LT_EXPR : GT_EXPR, type,
4877                           arg0, build_real (TREE_TYPE (arg0), max)));
4878
4879     case LT_EXPR:
4880       /* x < +Inf is always equal to x <= DBL_MAX.  */
4881       real_maxval (&max, neg, mode);
4882       return fold (build (neg ? GE_EXPR : LE_EXPR, type,
4883                           arg0, build_real (TREE_TYPE (arg0), max)));
4884
4885     case NE_EXPR:
4886       /* x != +Inf is always equal to !(x > DBL_MAX).  */
4887       real_maxval (&max, neg, mode);
4888       if (! HONOR_NANS (mode))
4889         return fold (build (neg ? GE_EXPR : LE_EXPR, type,
4890                             arg0, build_real (TREE_TYPE (arg0), max)));
4891       temp = fold (build (neg ? LT_EXPR : GT_EXPR, type,
4892                           arg0, build_real (TREE_TYPE (arg0), max)));
4893       return fold (build1 (TRUTH_NOT_EXPR, type, temp));
4894
4895     default:
4896       break;
4897     }
4898
4899   return NULL_TREE;
4900 }
4901
4902 /* Perform constant folding and related simplification of EXPR.
4903    The related simplifications include x*1 => x, x*0 => 0, etc.,
4904    and application of the associative law.
4905    NOP_EXPR conversions may be removed freely (as long as we
4906    are careful not to change the C type of the overall expression)
4907    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4908    but we can constant-fold them if they have constant operands.  */
4909
4910 tree
4911 fold (expr)
4912      tree expr;
4913 {
4914   tree t = expr;
4915   tree t1 = NULL_TREE;
4916   tree tem;
4917   tree type = TREE_TYPE (expr);
4918   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4919   enum tree_code code = TREE_CODE (t);
4920   int kind = TREE_CODE_CLASS (code);
4921   int invert;
4922   /* WINS will be nonzero when the switch is done
4923      if all operands are constant.  */
4924   int wins = 1;
4925
4926   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4927      Likewise for a SAVE_EXPR that's already been evaluated.  */
4928   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
4929     return t;
4930
4931   /* Return right away if a constant.  */
4932   if (kind == 'c')
4933     return t;
4934
4935 #ifdef MAX_INTEGER_COMPUTATION_MODE
4936   check_max_integer_computation_mode (expr);
4937 #endif
4938
4939   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4940     {
4941       tree subop;
4942
4943       /* Special case for conversion ops that can have fixed point args.  */
4944       arg0 = TREE_OPERAND (t, 0);
4945
4946       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4947       if (arg0 != 0)
4948         STRIP_SIGN_NOPS (arg0);
4949
4950       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4951         subop = TREE_REALPART (arg0);
4952       else
4953         subop = arg0;
4954
4955       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4956           && TREE_CODE (subop) != REAL_CST
4957           )
4958         /* Note that TREE_CONSTANT isn't enough:
4959            static var addresses are constant but we can't
4960            do arithmetic on them.  */
4961         wins = 0;
4962     }
4963   else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
4964     {
4965       int len = first_rtl_op (code);
4966       int i;
4967       for (i = 0; i < len; i++)
4968         {
4969           tree op = TREE_OPERAND (t, i);
4970           tree subop;
4971
4972           if (op == 0)
4973             continue;           /* Valid for CALL_EXPR, at least.  */
4974
4975           if (kind == '<' || code == RSHIFT_EXPR)
4976             {
4977               /* Signedness matters here.  Perhaps we can refine this
4978                  later.  */
4979               STRIP_SIGN_NOPS (op);
4980             }
4981           else
4982             /* Strip any conversions that don't change the mode.  */
4983             STRIP_NOPS (op);
4984
4985           if (TREE_CODE (op) == COMPLEX_CST)
4986             subop = TREE_REALPART (op);
4987           else
4988             subop = op;
4989
4990           if (TREE_CODE (subop) != INTEGER_CST
4991               && TREE_CODE (subop) != REAL_CST)
4992             /* Note that TREE_CONSTANT isn't enough:
4993                static var addresses are constant but we can't
4994                do arithmetic on them.  */
4995             wins = 0;
4996
4997           if (i == 0)
4998             arg0 = op;
4999           else if (i == 1)
5000             arg1 = op;
5001         }
5002     }
5003
5004   /* If this is a commutative operation, and ARG0 is a constant, move it
5005      to ARG1 to reduce the number of tests below.  */
5006   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
5007        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
5008        || code == BIT_AND_EXPR)
5009       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
5010     {
5011       tem = arg0; arg0 = arg1; arg1 = tem;
5012
5013       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
5014       TREE_OPERAND (t, 1) = tem;
5015     }
5016
5017   /* Now WINS is set as described above,
5018      ARG0 is the first operand of EXPR,
5019      and ARG1 is the second operand (if it has more than one operand).
5020
5021      First check for cases where an arithmetic operation is applied to a
5022      compound, conditional, or comparison operation.  Push the arithmetic
5023      operation inside the compound or conditional to see if any folding
5024      can then be done.  Convert comparison to conditional for this purpose.
5025      The also optimizes non-constant cases that used to be done in
5026      expand_expr.
5027
5028      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
5029      one of the operands is a comparison and the other is a comparison, a
5030      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
5031      code below would make the expression more complex.  Change it to a
5032      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
5033      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
5034
5035   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
5036        || code == EQ_EXPR || code == NE_EXPR)
5037       && ((truth_value_p (TREE_CODE (arg0))
5038            && (truth_value_p (TREE_CODE (arg1))
5039                || (TREE_CODE (arg1) == BIT_AND_EXPR
5040                    && integer_onep (TREE_OPERAND (arg1, 1)))))
5041           || (truth_value_p (TREE_CODE (arg1))
5042               && (truth_value_p (TREE_CODE (arg0))
5043                   || (TREE_CODE (arg0) == BIT_AND_EXPR
5044                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
5045     {
5046       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
5047                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
5048                        : TRUTH_XOR_EXPR,
5049                        type, arg0, arg1));
5050
5051       if (code == EQ_EXPR)
5052         t = invert_truthvalue (t);
5053
5054       return t;
5055     }
5056
5057   if (TREE_CODE_CLASS (code) == '1')
5058     {
5059       if (TREE_CODE (arg0) == COMPOUND_EXPR)
5060         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5061                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
5062       else if (TREE_CODE (arg0) == COND_EXPR)
5063         {
5064           tree arg01 = TREE_OPERAND (arg0, 1);
5065           tree arg02 = TREE_OPERAND (arg0, 2);
5066           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
5067             arg01 = fold (build1 (code, type, arg01));
5068           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
5069             arg02 = fold (build1 (code, type, arg02));
5070           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
5071                            arg01, arg02));
5072
5073           /* If this was a conversion, and all we did was to move into
5074              inside the COND_EXPR, bring it back out.  But leave it if
5075              it is a conversion from integer to integer and the
5076              result precision is no wider than a word since such a
5077              conversion is cheap and may be optimized away by combine,
5078              while it couldn't if it were outside the COND_EXPR.  Then return
5079              so we don't get into an infinite recursion loop taking the
5080              conversion out and then back in.  */
5081
5082           if ((code == NOP_EXPR || code == CONVERT_EXPR
5083                || code == NON_LVALUE_EXPR)
5084               && TREE_CODE (t) == COND_EXPR
5085               && TREE_CODE (TREE_OPERAND (t, 1)) == code
5086               && TREE_CODE (TREE_OPERAND (t, 2)) == code
5087               && ! VOID_TYPE_P (TREE_OPERAND (t, 1))
5088               && ! VOID_TYPE_P (TREE_OPERAND (t, 2))
5089               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
5090                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
5091               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
5092                     && (INTEGRAL_TYPE_P
5093                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
5094                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
5095             t = build1 (code, type,
5096                         build (COND_EXPR,
5097                                TREE_TYPE (TREE_OPERAND
5098                                           (TREE_OPERAND (t, 1), 0)),
5099                                TREE_OPERAND (t, 0),
5100                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
5101                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
5102           return t;
5103         }
5104       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
5105         return fold (build (COND_EXPR, type, arg0,
5106                             fold (build1 (code, type, integer_one_node)),
5107                             fold (build1 (code, type, integer_zero_node))));
5108    }
5109   else if (TREE_CODE_CLASS (code) == '<'
5110            && TREE_CODE (arg0) == COMPOUND_EXPR)
5111     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5112                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
5113   else if (TREE_CODE_CLASS (code) == '<'
5114            && TREE_CODE (arg1) == COMPOUND_EXPR)
5115     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
5116                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
5117   else if (TREE_CODE_CLASS (code) == '2'
5118            || TREE_CODE_CLASS (code) == '<')
5119     {
5120       if (TREE_CODE (arg1) == COMPOUND_EXPR
5121           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg1, 0))
5122           && ! TREE_SIDE_EFFECTS (arg0))
5123         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
5124                       fold (build (code, type,
5125                                    arg0, TREE_OPERAND (arg1, 1))));
5126       else if ((TREE_CODE (arg1) == COND_EXPR
5127                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
5128                     && TREE_CODE_CLASS (code) != '<'))
5129                && (TREE_CODE (arg0) != COND_EXPR
5130                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
5131                && (! TREE_SIDE_EFFECTS (arg0)
5132                    || ((*lang_hooks.decls.global_bindings_p) () == 0
5133                        && ! CONTAINS_PLACEHOLDER_P (arg0))))
5134         return
5135           fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
5136                                                /*cond_first_p=*/0);
5137       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
5138         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5139                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
5140       else if ((TREE_CODE (arg0) == COND_EXPR
5141                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
5142                     && TREE_CODE_CLASS (code) != '<'))
5143                && (TREE_CODE (arg1) != COND_EXPR
5144                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
5145                && (! TREE_SIDE_EFFECTS (arg1)
5146                    || ((*lang_hooks.decls.global_bindings_p) () == 0
5147                        && ! CONTAINS_PLACEHOLDER_P (arg1))))
5148         return
5149           fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
5150                                                /*cond_first_p=*/1);
5151     }
5152
5153   switch (code)
5154     {
5155     case INTEGER_CST:
5156     case REAL_CST:
5157     case VECTOR_CST:
5158     case STRING_CST:
5159     case COMPLEX_CST:
5160     case CONSTRUCTOR:
5161       return t;
5162
5163     case CONST_DECL:
5164       return fold (DECL_INITIAL (t));
5165
5166     case NOP_EXPR:
5167     case FLOAT_EXPR:
5168     case CONVERT_EXPR:
5169     case FIX_TRUNC_EXPR:
5170       /* Other kinds of FIX are not handled properly by fold_convert.  */
5171
5172       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
5173         return TREE_OPERAND (t, 0);
5174
5175       /* Handle cases of two conversions in a row.  */
5176       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
5177           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
5178         {
5179           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5180           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
5181           tree final_type = TREE_TYPE (t);
5182           int inside_int = INTEGRAL_TYPE_P (inside_type);
5183           int inside_ptr = POINTER_TYPE_P (inside_type);
5184           int inside_float = FLOAT_TYPE_P (inside_type);
5185           unsigned int inside_prec = TYPE_PRECISION (inside_type);
5186           int inside_unsignedp = TREE_UNSIGNED (inside_type);
5187           int inter_int = INTEGRAL_TYPE_P (inter_type);
5188           int inter_ptr = POINTER_TYPE_P (inter_type);
5189           int inter_float = FLOAT_TYPE_P (inter_type);
5190           unsigned int inter_prec = TYPE_PRECISION (inter_type);
5191           int inter_unsignedp = TREE_UNSIGNED (inter_type);
5192           int final_int = INTEGRAL_TYPE_P (final_type);
5193           int final_ptr = POINTER_TYPE_P (final_type);
5194           int final_float = FLOAT_TYPE_P (final_type);
5195           unsigned int final_prec = TYPE_PRECISION (final_type);
5196           int final_unsignedp = TREE_UNSIGNED (final_type);
5197
5198           /* In addition to the cases of two conversions in a row
5199              handled below, if we are converting something to its own
5200              type via an object of identical or wider precision, neither
5201              conversion is needed.  */
5202           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
5203               && ((inter_int && final_int) || (inter_float && final_float))
5204               && inter_prec >= final_prec)
5205             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5206
5207           /* Likewise, if the intermediate and final types are either both
5208              float or both integer, we don't need the middle conversion if
5209              it is wider than the final type and doesn't change the signedness
5210              (for integers).  Avoid this if the final type is a pointer
5211              since then we sometimes need the inner conversion.  Likewise if
5212              the outer has a precision not equal to the size of its mode.  */
5213           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
5214                || (inter_float && inside_float))
5215               && inter_prec >= inside_prec
5216               && (inter_float || inter_unsignedp == inside_unsignedp)
5217               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5218                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5219               && ! final_ptr)
5220             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5221
5222           /* If we have a sign-extension of a zero-extended value, we can
5223              replace that by a single zero-extension.  */
5224           if (inside_int && inter_int && final_int
5225               && inside_prec < inter_prec && inter_prec < final_prec
5226               && inside_unsignedp && !inter_unsignedp)
5227             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5228
5229           /* Two conversions in a row are not needed unless:
5230              - some conversion is floating-point (overstrict for now), or
5231              - the intermediate type is narrower than both initial and
5232                final, or
5233              - the intermediate type and innermost type differ in signedness,
5234                and the outermost type is wider than the intermediate, or
5235              - the initial type is a pointer type and the precisions of the
5236                intermediate and final types differ, or
5237              - the final type is a pointer type and the precisions of the
5238                initial and intermediate types differ.  */
5239           if (! inside_float && ! inter_float && ! final_float
5240               && (inter_prec > inside_prec || inter_prec > final_prec)
5241               && ! (inside_int && inter_int
5242                     && inter_unsignedp != inside_unsignedp
5243                     && inter_prec < final_prec)
5244               && ((inter_unsignedp && inter_prec > inside_prec)
5245                   == (final_unsignedp && final_prec > inter_prec))
5246               && ! (inside_ptr && inter_prec != final_prec)
5247               && ! (final_ptr && inside_prec != inter_prec)
5248               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5249                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5250               && ! final_ptr)
5251             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5252         }
5253
5254       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5255           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5256           /* Detect assigning a bitfield.  */
5257           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5258                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5259         {
5260           /* Don't leave an assignment inside a conversion
5261              unless assigning a bitfield.  */
5262           tree prev = TREE_OPERAND (t, 0);
5263           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5264           /* First do the assignment, then return converted constant.  */
5265           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5266           TREE_USED (t) = 1;
5267           return t;
5268         }
5269
5270       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
5271          constants (if x has signed type, the sign bit cannot be set
5272          in c).  This folds extension into the BIT_AND_EXPR.  */
5273       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
5274           && TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE
5275           && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
5276           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
5277         {
5278           tree and = TREE_OPERAND (t, 0);
5279           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
5280           int change = 0;
5281
5282           if (TREE_UNSIGNED (TREE_TYPE (and))
5283               || (TYPE_PRECISION (TREE_TYPE (t))
5284                   <= TYPE_PRECISION (TREE_TYPE (and))))
5285             change = 1;
5286           else if (TYPE_PRECISION (TREE_TYPE (and1))
5287                    <= HOST_BITS_PER_WIDE_INT
5288                    && host_integerp (and1, 1))
5289             {
5290               unsigned HOST_WIDE_INT cst;
5291
5292               cst = tree_low_cst (and1, 1);
5293               cst &= (HOST_WIDE_INT) -1
5294                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
5295               change = (cst == 0);
5296 #ifdef LOAD_EXTEND_OP
5297               if (change
5298                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
5299                       == ZERO_EXTEND))
5300                 {
5301                   tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
5302                   and0 = convert (uns, and0);
5303                   and1 = convert (uns, and1);
5304                 }
5305 #endif
5306             }
5307           if (change)
5308             return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
5309                                 convert (TREE_TYPE (t), and0),
5310                                 convert (TREE_TYPE (t), and1)));
5311         }
5312
5313       if (!wins)
5314         {
5315           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5316           return t;
5317         }
5318       return fold_convert (t, arg0);
5319
5320     case VIEW_CONVERT_EXPR:
5321       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
5322         return build1 (VIEW_CONVERT_EXPR, type,
5323                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5324       return t;
5325
5326     case COMPONENT_REF:
5327       if (TREE_CODE (arg0) == CONSTRUCTOR
5328           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
5329         {
5330           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5331           if (m)
5332             t = TREE_VALUE (m);
5333         }
5334       return t;
5335
5336     case RANGE_EXPR:
5337       TREE_CONSTANT (t) = wins;
5338       return t;
5339
5340     case NEGATE_EXPR:
5341       if (wins)
5342         {
5343           if (TREE_CODE (arg0) == INTEGER_CST)
5344             {
5345               unsigned HOST_WIDE_INT low;
5346               HOST_WIDE_INT high;
5347               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5348                                          TREE_INT_CST_HIGH (arg0),
5349                                          &low, &high);
5350               t = build_int_2 (low, high);
5351               TREE_TYPE (t) = type;
5352               TREE_OVERFLOW (t)
5353                 = (TREE_OVERFLOW (arg0)
5354                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5355               TREE_CONSTANT_OVERFLOW (t)
5356                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5357             }
5358           else if (TREE_CODE (arg0) == REAL_CST)
5359             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5360         }
5361       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5362         return TREE_OPERAND (arg0, 0);
5363       /* Convert -((double)float) into (double)(-float).  */
5364       else if (TREE_CODE (arg0) == NOP_EXPR
5365                && TREE_CODE (type) == REAL_TYPE)
5366         {
5367           tree targ0 = strip_float_extensions (arg0);
5368           if (targ0 != arg0)
5369             return convert (type, build1 (NEGATE_EXPR, TREE_TYPE (targ0), targ0));
5370
5371         }
5372
5373       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5374       else if (TREE_CODE (arg0) == MINUS_EXPR
5375                && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
5376         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5377                       TREE_OPERAND (arg0, 0));
5378
5379       /* Convert -f(x) into f(-x) where f is sin, tan or atan.  */
5380       switch (builtin_mathfn_code (arg0))
5381         {
5382         case BUILT_IN_SIN:
5383         case BUILT_IN_SINF:
5384         case BUILT_IN_SINL:
5385         case BUILT_IN_TAN:
5386         case BUILT_IN_TANF:
5387         case BUILT_IN_TANL:
5388         case BUILT_IN_ATAN:
5389         case BUILT_IN_ATANF:
5390         case BUILT_IN_ATANL:
5391           if (negate_expr_p (TREE_VALUE (TREE_OPERAND (arg0, 1))))
5392             {
5393               tree fndecl, arg, arglist;
5394
5395               fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5396               arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
5397               arg = fold (build1 (NEGATE_EXPR, type, arg));
5398               arglist = build_tree_list (NULL_TREE, arg);
5399               return build_function_call_expr (fndecl, arglist);
5400             }
5401           break;
5402
5403         default:
5404           break;
5405         }
5406       return t;
5407
5408     case ABS_EXPR:
5409       if (wins)
5410         {
5411           if (TREE_CODE (arg0) == INTEGER_CST)
5412             {
5413               /* If the value is unsigned, then the absolute value is
5414                  the same as the ordinary value.  */
5415               if (TREE_UNSIGNED (type))
5416                 return arg0;
5417               /* Similarly, if the value is non-negative.  */
5418               else if (INT_CST_LT (integer_minus_one_node, arg0))
5419                 return arg0;
5420               /* If the value is negative, then the absolute value is
5421                  its negation.  */
5422               else
5423                 {
5424                   unsigned HOST_WIDE_INT low;
5425                   HOST_WIDE_INT high;
5426                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5427                                              TREE_INT_CST_HIGH (arg0),
5428                                              &low, &high);
5429                   t = build_int_2 (low, high);
5430                   TREE_TYPE (t) = type;
5431                   TREE_OVERFLOW (t)
5432                     = (TREE_OVERFLOW (arg0)
5433                        | force_fit_type (t, overflow));
5434                   TREE_CONSTANT_OVERFLOW (t)
5435                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5436                 }
5437             }
5438           else if (TREE_CODE (arg0) == REAL_CST)
5439             {
5440               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5441                 t = build_real (type,
5442                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5443             }
5444         }
5445       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5446         return fold (build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0)));
5447       /* Convert fabs((double)float) into (double)fabsf(float).  */
5448       else if (TREE_CODE (arg0) == NOP_EXPR
5449                && TREE_CODE (type) == REAL_TYPE)
5450         {
5451           tree targ0 = strip_float_extensions (arg0);
5452           if (targ0 != arg0)
5453             return convert (type, fold (build1 (ABS_EXPR, TREE_TYPE (targ0),
5454                                                 targ0)));
5455         }
5456       else if (tree_expr_nonnegative_p (arg0))
5457         return arg0;
5458       return t;
5459
5460     case CONJ_EXPR:
5461       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5462         return convert (type, arg0);
5463       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5464         return build (COMPLEX_EXPR, type,
5465                       TREE_OPERAND (arg0, 0),
5466                       negate_expr (TREE_OPERAND (arg0, 1)));
5467       else if (TREE_CODE (arg0) == COMPLEX_CST)
5468         return build_complex (type, TREE_REALPART (arg0),
5469                               negate_expr (TREE_IMAGPART (arg0)));
5470       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5471         return fold (build (TREE_CODE (arg0), type,
5472                             fold (build1 (CONJ_EXPR, type,
5473                                           TREE_OPERAND (arg0, 0))),
5474                             fold (build1 (CONJ_EXPR,
5475                                           type, TREE_OPERAND (arg0, 1)))));
5476       else if (TREE_CODE (arg0) == CONJ_EXPR)
5477         return TREE_OPERAND (arg0, 0);
5478       return t;
5479
5480     case BIT_NOT_EXPR:
5481       if (wins)
5482         {
5483           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5484                            ~ TREE_INT_CST_HIGH (arg0));
5485           TREE_TYPE (t) = type;
5486           force_fit_type (t, 0);
5487           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5488           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5489         }
5490       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5491         return TREE_OPERAND (arg0, 0);
5492       return t;
5493
5494     case PLUS_EXPR:
5495       /* A + (-B) -> A - B */
5496       if (TREE_CODE (arg1) == NEGATE_EXPR)
5497         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5498       /* (-A) + B -> B - A */
5499       if (TREE_CODE (arg0) == NEGATE_EXPR)
5500         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5501       else if (! FLOAT_TYPE_P (type))
5502         {
5503           if (integer_zerop (arg1))
5504             return non_lvalue (convert (type, arg0));
5505
5506           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5507              with a constant, and the two constants have no bits in common,
5508              we should treat this as a BIT_IOR_EXPR since this may produce more
5509              simplifications.  */
5510           if (TREE_CODE (arg0) == BIT_AND_EXPR
5511               && TREE_CODE (arg1) == BIT_AND_EXPR
5512               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5513               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5514               && integer_zerop (const_binop (BIT_AND_EXPR,
5515                                              TREE_OPERAND (arg0, 1),
5516                                              TREE_OPERAND (arg1, 1), 0)))
5517             {
5518               code = BIT_IOR_EXPR;
5519               goto bit_ior;
5520             }
5521
5522           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5523              (plus (plus (mult) (mult)) (foo)) so that we can
5524              take advantage of the factoring cases below.  */
5525           if ((TREE_CODE (arg0) == PLUS_EXPR
5526                && TREE_CODE (arg1) == MULT_EXPR)
5527               || (TREE_CODE (arg1) == PLUS_EXPR
5528                   && TREE_CODE (arg0) == MULT_EXPR))
5529             {
5530               tree parg0, parg1, parg, marg;
5531
5532               if (TREE_CODE (arg0) == PLUS_EXPR)
5533                 parg = arg0, marg = arg1;
5534               else
5535                 parg = arg1, marg = arg0;
5536               parg0 = TREE_OPERAND (parg, 0);
5537               parg1 = TREE_OPERAND (parg, 1);
5538               STRIP_NOPS (parg0);
5539               STRIP_NOPS (parg1);
5540
5541               if (TREE_CODE (parg0) == MULT_EXPR
5542                   && TREE_CODE (parg1) != MULT_EXPR)
5543                 return fold (build (PLUS_EXPR, type,
5544                                     fold (build (PLUS_EXPR, type,
5545                                                  convert (type, parg0),
5546                                                  convert (type, marg))),
5547                                     convert (type, parg1)));
5548               if (TREE_CODE (parg0) != MULT_EXPR
5549                   && TREE_CODE (parg1) == MULT_EXPR)
5550                 return fold (build (PLUS_EXPR, type,
5551                                     fold (build (PLUS_EXPR, type,
5552                                                  convert (type, parg1),
5553                                                  convert (type, marg))),
5554                                     convert (type, parg0)));
5555             }
5556
5557           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5558             {
5559               tree arg00, arg01, arg10, arg11;
5560               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5561
5562               /* (A * C) + (B * C) -> (A+B) * C.
5563                  We are most concerned about the case where C is a constant,
5564                  but other combinations show up during loop reduction.  Since
5565                  it is not difficult, try all four possibilities.  */
5566
5567               arg00 = TREE_OPERAND (arg0, 0);
5568               arg01 = TREE_OPERAND (arg0, 1);
5569               arg10 = TREE_OPERAND (arg1, 0);
5570               arg11 = TREE_OPERAND (arg1, 1);
5571               same = NULL_TREE;
5572
5573               if (operand_equal_p (arg01, arg11, 0))
5574                 same = arg01, alt0 = arg00, alt1 = arg10;
5575               else if (operand_equal_p (arg00, arg10, 0))
5576                 same = arg00, alt0 = arg01, alt1 = arg11;
5577               else if (operand_equal_p (arg00, arg11, 0))
5578                 same = arg00, alt0 = arg01, alt1 = arg10;
5579               else if (operand_equal_p (arg01, arg10, 0))
5580                 same = arg01, alt0 = arg00, alt1 = arg11;
5581
5582               /* No identical multiplicands; see if we can find a common
5583                  power-of-two factor in non-power-of-two multiplies.  This
5584                  can help in multi-dimensional array access.  */
5585               else if (TREE_CODE (arg01) == INTEGER_CST
5586                        && TREE_CODE (arg11) == INTEGER_CST
5587                        && TREE_INT_CST_HIGH (arg01) == 0
5588                        && TREE_INT_CST_HIGH (arg11) == 0)
5589                 {
5590                   HOST_WIDE_INT int01, int11, tmp;
5591                   int01 = TREE_INT_CST_LOW (arg01);
5592                   int11 = TREE_INT_CST_LOW (arg11);
5593
5594                   /* Move min of absolute values to int11.  */
5595                   if ((int01 >= 0 ? int01 : -int01)
5596                       < (int11 >= 0 ? int11 : -int11))
5597                     {
5598                       tmp = int01, int01 = int11, int11 = tmp;
5599                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5600                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5601                     }
5602
5603                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5604                     {
5605                       alt0 = fold (build (MULT_EXPR, type, arg00,
5606                                           build_int_2 (int01 / int11, 0)));
5607                       alt1 = arg10;
5608                       same = arg11;
5609                     }
5610                 }
5611
5612               if (same)
5613                 return fold (build (MULT_EXPR, type,
5614                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5615                                     same));
5616             }
5617         }
5618
5619       /* See if ARG1 is zero and X + ARG1 reduces to X.  */
5620       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
5621         return non_lvalue (convert (type, arg0));
5622
5623       /* Likewise if the operands are reversed.  */
5624       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5625         return non_lvalue (convert (type, arg1));
5626
5627      bit_rotate:
5628       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5629          is a rotate of A by C1 bits.  */
5630       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5631          is a rotate of A by B bits.  */
5632       {
5633         enum tree_code code0, code1;
5634         code0 = TREE_CODE (arg0);
5635         code1 = TREE_CODE (arg1);
5636         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5637              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5638             && operand_equal_p (TREE_OPERAND (arg0, 0),
5639                                 TREE_OPERAND (arg1, 0), 0)
5640             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5641           {
5642             tree tree01, tree11;
5643             enum tree_code code01, code11;
5644
5645             tree01 = TREE_OPERAND (arg0, 1);
5646             tree11 = TREE_OPERAND (arg1, 1);
5647             STRIP_NOPS (tree01);
5648             STRIP_NOPS (tree11);
5649             code01 = TREE_CODE (tree01);
5650             code11 = TREE_CODE (tree11);
5651             if (code01 == INTEGER_CST
5652                 && code11 == INTEGER_CST
5653                 && TREE_INT_CST_HIGH (tree01) == 0
5654                 && TREE_INT_CST_HIGH (tree11) == 0
5655                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5656                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5657               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5658                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5659             else if (code11 == MINUS_EXPR)
5660               {
5661                 tree tree110, tree111;
5662                 tree110 = TREE_OPERAND (tree11, 0);
5663                 tree111 = TREE_OPERAND (tree11, 1);
5664                 STRIP_NOPS (tree110);
5665                 STRIP_NOPS (tree111);
5666                 if (TREE_CODE (tree110) == INTEGER_CST
5667                     && 0 == compare_tree_int (tree110,
5668                                               TYPE_PRECISION
5669                                               (TREE_TYPE (TREE_OPERAND
5670                                                           (arg0, 0))))
5671                     && operand_equal_p (tree01, tree111, 0))
5672                   return build ((code0 == LSHIFT_EXPR
5673                                  ? LROTATE_EXPR
5674                                  : RROTATE_EXPR),
5675                                 type, TREE_OPERAND (arg0, 0), tree01);
5676               }
5677             else if (code01 == MINUS_EXPR)
5678               {
5679                 tree tree010, tree011;
5680                 tree010 = TREE_OPERAND (tree01, 0);
5681                 tree011 = TREE_OPERAND (tree01, 1);
5682                 STRIP_NOPS (tree010);
5683                 STRIP_NOPS (tree011);
5684                 if (TREE_CODE (tree010) == INTEGER_CST
5685                     && 0 == compare_tree_int (tree010,
5686                                               TYPE_PRECISION
5687                                               (TREE_TYPE (TREE_OPERAND
5688                                                           (arg0, 0))))
5689                     && operand_equal_p (tree11, tree011, 0))
5690                   return build ((code0 != LSHIFT_EXPR
5691                                  ? LROTATE_EXPR
5692                                  : RROTATE_EXPR),
5693                                 type, TREE_OPERAND (arg0, 0), tree11);
5694               }
5695           }
5696       }
5697
5698     associate:
5699       /* In most languages, can't associate operations on floats through
5700          parentheses.  Rather than remember where the parentheses were, we
5701          don't associate floats at all.  It shouldn't matter much.  However,
5702          associating multiplications is only very slightly inaccurate, so do
5703          that if -funsafe-math-optimizations is specified.  */
5704
5705       if (! wins
5706           && (! FLOAT_TYPE_P (type)
5707               || (flag_unsafe_math_optimizations && code == MULT_EXPR)))
5708         {
5709           tree var0, con0, lit0, minus_lit0;
5710           tree var1, con1, lit1, minus_lit1;
5711
5712           /* Split both trees into variables, constants, and literals.  Then
5713              associate each group together, the constants with literals,
5714              then the result with variables.  This increases the chances of
5715              literals being recombined later and of generating relocatable
5716              expressions for the sum of a constant and literal.  */
5717           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
5718           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
5719                              code == MINUS_EXPR);
5720
5721           /* Only do something if we found more than two objects.  Otherwise,
5722              nothing has changed and we risk infinite recursion.  */
5723           if (2 < ((var0 != 0) + (var1 != 0)
5724                    + (con0 != 0) + (con1 != 0)
5725                    + (lit0 != 0) + (lit1 != 0)
5726                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
5727             {
5728               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
5729               if (code == MINUS_EXPR)
5730                 code = PLUS_EXPR;
5731
5732               var0 = associate_trees (var0, var1, code, type);
5733               con0 = associate_trees (con0, con1, code, type);
5734               lit0 = associate_trees (lit0, lit1, code, type);
5735               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
5736
5737               /* Preserve the MINUS_EXPR if the negative part of the literal is
5738                  greater than the positive part.  Otherwise, the multiplicative
5739                  folding code (i.e extract_muldiv) may be fooled in case
5740                  unsigned constants are substracted, like in the following
5741                  example: ((X*2 + 4) - 8U)/2.  */
5742               if (minus_lit0 && lit0)
5743                 {
5744                   if (tree_int_cst_lt (lit0, minus_lit0))
5745                     {
5746                       minus_lit0 = associate_trees (minus_lit0, lit0,
5747                                                     MINUS_EXPR, type);
5748                       lit0 = 0;
5749                     }
5750                   else
5751                     {
5752                       lit0 = associate_trees (lit0, minus_lit0,
5753                                               MINUS_EXPR, type);
5754                       minus_lit0 = 0;
5755                     }
5756                 }
5757               if (minus_lit0)
5758                 {
5759                   if (con0 == 0)
5760                     return convert (type, associate_trees (var0, minus_lit0,
5761                                                            MINUS_EXPR, type));
5762                   else
5763                     {
5764                       con0 = associate_trees (con0, minus_lit0,
5765                                               MINUS_EXPR, type);
5766                       return convert (type, associate_trees (var0, con0,
5767                                                              PLUS_EXPR, type));
5768                     }
5769                 }
5770
5771               con0 = associate_trees (con0, lit0, code, type);
5772               return convert (type, associate_trees (var0, con0, code, type));
5773             }
5774         }
5775
5776     binary:
5777       if (wins)
5778         t1 = const_binop (code, arg0, arg1, 0);
5779       if (t1 != NULL_TREE)
5780         {
5781           /* The return value should always have
5782              the same type as the original expression.  */
5783           if (TREE_TYPE (t1) != TREE_TYPE (t))
5784             t1 = convert (TREE_TYPE (t), t1);
5785
5786           return t1;
5787         }
5788       return t;
5789
5790     case MINUS_EXPR:
5791       /* A - (-B) -> A + B */
5792       if (TREE_CODE (arg1) == NEGATE_EXPR)
5793         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5794       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
5795       if (TREE_CODE (arg0) == NEGATE_EXPR
5796           && (FLOAT_TYPE_P (type)
5797               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
5798           && negate_expr_p (arg1)
5799           && (! TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
5800           && (! TREE_SIDE_EFFECTS (arg1) || TREE_CONSTANT (arg0)))
5801         return fold (build (MINUS_EXPR, type, negate_expr (arg1),
5802                             TREE_OPERAND (arg0, 0)));
5803
5804       if (! FLOAT_TYPE_P (type))
5805         {
5806           if (! wins && integer_zerop (arg0))
5807             return negate_expr (convert (type, arg1));
5808           if (integer_zerop (arg1))
5809             return non_lvalue (convert (type, arg0));
5810
5811           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5812              about the case where C is a constant, just try one of the
5813              four possibilities.  */
5814
5815           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5816               && operand_equal_p (TREE_OPERAND (arg0, 1),
5817                                   TREE_OPERAND (arg1, 1), 0))
5818             return fold (build (MULT_EXPR, type,
5819                                 fold (build (MINUS_EXPR, type,
5820                                              TREE_OPERAND (arg0, 0),
5821                                              TREE_OPERAND (arg1, 0))),
5822                                 TREE_OPERAND (arg0, 1)));
5823
5824           /* Fold A - (A & B) into ~B & A.  */
5825           if (!TREE_SIDE_EFFECTS (arg0)
5826               && TREE_CODE (arg1) == BIT_AND_EXPR)
5827             {
5828               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
5829                 return fold (build (BIT_AND_EXPR, type,
5830                                     fold (build1 (BIT_NOT_EXPR, type,
5831                                                   TREE_OPERAND (arg1, 0))),
5832                                     arg0));
5833               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
5834                 return fold (build (BIT_AND_EXPR, type,
5835                                     fold (build1 (BIT_NOT_EXPR, type,
5836                                                   TREE_OPERAND (arg1, 1))),
5837                                     arg0));
5838             }
5839         }
5840
5841       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
5842       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
5843         return non_lvalue (convert (type, arg0));
5844
5845       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
5846          ARG0 is zero and X + ARG0 reduces to X, since that would mean
5847          (-ARG1 + ARG0) reduces to -ARG1.  */
5848       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5849         return negate_expr (convert (type, arg1));
5850
5851       /* Fold &x - &x.  This can happen from &x.foo - &x.
5852          This is unsafe for certain floats even in non-IEEE formats.
5853          In IEEE, it is unsafe because it does wrong for NaNs.
5854          Also note that operand_equal_p is always false if an operand
5855          is volatile.  */
5856
5857       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
5858           && operand_equal_p (arg0, arg1, 0))
5859         return convert (type, integer_zero_node);
5860
5861       goto associate;
5862
5863     case MULT_EXPR:
5864       /* (-A) * (-B) -> A * B  */
5865       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5866         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5867                             TREE_OPERAND (arg1, 0)));
5868
5869       if (! FLOAT_TYPE_P (type))
5870         {
5871           if (integer_zerop (arg1))
5872             return omit_one_operand (type, arg1, arg0);
5873           if (integer_onep (arg1))
5874             return non_lvalue (convert (type, arg0));
5875
5876           /* (a * (1 << b)) is (a << b)  */
5877           if (TREE_CODE (arg1) == LSHIFT_EXPR
5878               && integer_onep (TREE_OPERAND (arg1, 0)))
5879             return fold (build (LSHIFT_EXPR, type, arg0,
5880                                 TREE_OPERAND (arg1, 1)));
5881           if (TREE_CODE (arg0) == LSHIFT_EXPR
5882               && integer_onep (TREE_OPERAND (arg0, 0)))
5883             return fold (build (LSHIFT_EXPR, type, arg1,
5884                                 TREE_OPERAND (arg0, 1)));
5885
5886           if (TREE_CODE (arg1) == INTEGER_CST
5887               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0),
5888                                              convert (type, arg1),
5889                                              code, NULL_TREE)))
5890             return convert (type, tem);
5891
5892         }
5893       else
5894         {
5895           /* Maybe fold x * 0 to 0.  The expressions aren't the same
5896              when x is NaN, since x * 0 is also NaN.  Nor are they the
5897              same in modes with signed zeros, since multiplying a
5898              negative value by 0 gives -0, not +0.  */
5899           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
5900               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
5901               && real_zerop (arg1))
5902             return omit_one_operand (type, arg1, arg0);
5903           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
5904           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5905               && real_onep (arg1))
5906             return non_lvalue (convert (type, arg0));
5907
5908           /* Transform x * -1.0 into -x.  */
5909           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5910               && real_minus_onep (arg1))
5911             return fold (build1 (NEGATE_EXPR, type, arg0));
5912
5913           /* x*2 is x+x */
5914           if (! wins && real_twop (arg1)
5915               && (*lang_hooks.decls.global_bindings_p) () == 0
5916               && ! CONTAINS_PLACEHOLDER_P (arg0))
5917             {
5918               tree arg = save_expr (arg0);
5919               return fold (build (PLUS_EXPR, type, arg, arg));
5920             }
5921
5922           if (flag_unsafe_math_optimizations)
5923             {
5924               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
5925               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
5926
5927               /* Optimizations of sqrt(...)*sqrt(...).  */
5928               if ((fcode0 == BUILT_IN_SQRT && fcode1 == BUILT_IN_SQRT)
5929                   || (fcode0 == BUILT_IN_SQRTF && fcode1 == BUILT_IN_SQRTF)
5930                   || (fcode0 == BUILT_IN_SQRTL && fcode1 == BUILT_IN_SQRTL))
5931                 {
5932                   tree sqrtfn, arg, arglist;
5933                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
5934                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
5935
5936                   /* Optimize sqrt(x)*sqrt(x) as x.  */
5937                   if (operand_equal_p (arg00, arg10, 0)
5938                       && ! HONOR_SNANS (TYPE_MODE (type)))
5939                     return arg00;
5940
5941                   /* Optimize sqrt(x)*sqrt(y) as sqrt(x*y).  */
5942                   sqrtfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5943                   arg = fold (build (MULT_EXPR, type, arg00, arg10));
5944                   arglist = build_tree_list (NULL_TREE, arg);
5945                   return build_function_call_expr (sqrtfn, arglist);
5946                 }
5947
5948               /* Optimize exp(x)*exp(y) as exp(x+y).  */
5949               if ((fcode0 == BUILT_IN_EXP && fcode1 == BUILT_IN_EXP)
5950                   || (fcode0 == BUILT_IN_EXPF && fcode1 == BUILT_IN_EXPF)
5951                   || (fcode0 == BUILT_IN_EXPL && fcode1 == BUILT_IN_EXPL))
5952                 {
5953                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5954                   tree arg = build (PLUS_EXPR, type,
5955                                     TREE_VALUE (TREE_OPERAND (arg0, 1)),
5956                                     TREE_VALUE (TREE_OPERAND (arg1, 1)));
5957                   tree arglist = build_tree_list (NULL_TREE, fold (arg));
5958                   return build_function_call_expr (expfn, arglist);
5959                 }
5960
5961               /* Optimizations of pow(...)*pow(...).  */
5962               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
5963                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
5964                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
5965                 {
5966                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
5967                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
5968                                                                      1)));
5969                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
5970                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
5971                                                                      1)));
5972
5973                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
5974                   if (operand_equal_p (arg01, arg11, 0))
5975                     {
5976                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5977                       tree arg = build (MULT_EXPR, type, arg00, arg10);
5978                       tree arglist = tree_cons (NULL_TREE, fold (arg),
5979                                                 build_tree_list (NULL_TREE,
5980                                                                  arg01));
5981                       return build_function_call_expr (powfn, arglist);
5982                     }
5983
5984                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
5985                   if (operand_equal_p (arg00, arg10, 0))
5986                     {
5987                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
5988                       tree arg = fold (build (PLUS_EXPR, type, arg01, arg11));
5989                       tree arglist = tree_cons (NULL_TREE, arg00,
5990                                                 build_tree_list (NULL_TREE,
5991                                                                  arg));
5992                       return build_function_call_expr (powfn, arglist);
5993                     }
5994                 }
5995
5996               /* Optimize tan(x)*cos(x) as sin(x).  */
5997               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
5998                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
5999                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
6000                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
6001                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
6002                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
6003                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
6004                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
6005                 {
6006                   tree sinfn;
6007
6008                   switch (fcode0)
6009                     {
6010                     case BUILT_IN_TAN:
6011                     case BUILT_IN_COS:
6012                       sinfn = implicit_built_in_decls[BUILT_IN_SIN];
6013                       break;
6014                     case BUILT_IN_TANF:
6015                     case BUILT_IN_COSF:
6016                       sinfn = implicit_built_in_decls[BUILT_IN_SINF];
6017                       break;
6018                     case BUILT_IN_TANL:
6019                     case BUILT_IN_COSL:
6020                       sinfn = implicit_built_in_decls[BUILT_IN_SINL];
6021                       break;
6022                     default:
6023                       sinfn = NULL_TREE;
6024                     }
6025
6026                   if (sinfn != NULL_TREE)
6027                     return build_function_call_expr (sinfn,
6028                                                      TREE_OPERAND (arg0, 1));
6029                 }
6030             }
6031         }
6032       goto associate;
6033
6034     case BIT_IOR_EXPR:
6035     bit_ior:
6036       if (integer_all_onesp (arg1))
6037         return omit_one_operand (type, arg1, arg0);
6038       if (integer_zerop (arg1))
6039         return non_lvalue (convert (type, arg0));
6040       t1 = distribute_bit_expr (code, type, arg0, arg1);
6041       if (t1 != NULL_TREE)
6042         return t1;
6043
6044       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
6045
6046          This results in more efficient code for machines without a NAND
6047          instruction.  Combine will canonicalize to the first form
6048          which will allow use of NAND instructions provided by the
6049          backend if they exist.  */
6050       if (TREE_CODE (arg0) == BIT_NOT_EXPR
6051           && TREE_CODE (arg1) == BIT_NOT_EXPR)
6052         {
6053           return fold (build1 (BIT_NOT_EXPR, type,
6054                                build (BIT_AND_EXPR, type,
6055                                       TREE_OPERAND (arg0, 0),
6056                                       TREE_OPERAND (arg1, 0))));
6057         }
6058
6059       /* See if this can be simplified into a rotate first.  If that
6060          is unsuccessful continue in the association code.  */
6061       goto bit_rotate;
6062
6063     case BIT_XOR_EXPR:
6064       if (integer_zerop (arg1))
6065         return non_lvalue (convert (type, arg0));
6066       if (integer_all_onesp (arg1))
6067         return fold (build1 (BIT_NOT_EXPR, type, arg0));
6068
6069       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
6070          with a constant, and the two constants have no bits in common,
6071          we should treat this as a BIT_IOR_EXPR since this may produce more
6072          simplifications.  */
6073       if (TREE_CODE (arg0) == BIT_AND_EXPR
6074           && TREE_CODE (arg1) == BIT_AND_EXPR
6075           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6076           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
6077           && integer_zerop (const_binop (BIT_AND_EXPR,
6078                                          TREE_OPERAND (arg0, 1),
6079                                          TREE_OPERAND (arg1, 1), 0)))
6080         {
6081           code = BIT_IOR_EXPR;
6082           goto bit_ior;
6083         }
6084
6085       /* See if this can be simplified into a rotate first.  If that
6086          is unsuccessful continue in the association code.  */
6087       goto bit_rotate;
6088
6089     case BIT_AND_EXPR:
6090     bit_and:
6091       if (integer_all_onesp (arg1))
6092         return non_lvalue (convert (type, arg0));
6093       if (integer_zerop (arg1))
6094         return omit_one_operand (type, arg1, arg0);
6095       t1 = distribute_bit_expr (code, type, arg0, arg1);
6096       if (t1 != NULL_TREE)
6097         return t1;
6098       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
6099       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
6100           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
6101         {
6102           unsigned int prec
6103             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
6104
6105           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
6106               && (~TREE_INT_CST_LOW (arg1)
6107                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
6108             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
6109         }
6110
6111       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
6112
6113          This results in more efficient code for machines without a NOR
6114          instruction.  Combine will canonicalize to the first form
6115          which will allow use of NOR instructions provided by the
6116          backend if they exist.  */
6117       if (TREE_CODE (arg0) == BIT_NOT_EXPR
6118           && TREE_CODE (arg1) == BIT_NOT_EXPR)
6119         {
6120           return fold (build1 (BIT_NOT_EXPR, type,
6121                                build (BIT_IOR_EXPR, type,
6122                                       TREE_OPERAND (arg0, 0),
6123                                       TREE_OPERAND (arg1, 0))));
6124         }
6125
6126       goto associate;
6127
6128     case BIT_ANDTC_EXPR:
6129       if (integer_all_onesp (arg0))
6130         return non_lvalue (convert (type, arg1));
6131       if (integer_zerop (arg0))
6132         return omit_one_operand (type, arg0, arg1);
6133       if (TREE_CODE (arg1) == INTEGER_CST)
6134         {
6135           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
6136           code = BIT_AND_EXPR;
6137           goto bit_and;
6138         }
6139       goto binary;
6140
6141     case RDIV_EXPR:
6142       /* Don't touch a floating-point divide by zero unless the mode
6143          of the constant can represent infinity.  */
6144       if (TREE_CODE (arg1) == REAL_CST
6145           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
6146           && real_zerop (arg1))
6147         return t;
6148
6149       /* (-A) / (-B) -> A / B  */
6150       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
6151         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
6152                             TREE_OPERAND (arg1, 0)));
6153
6154       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
6155       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
6156           && real_onep (arg1))
6157         return non_lvalue (convert (type, arg0));
6158
6159       /* If ARG1 is a constant, we can convert this to a multiply by the
6160          reciprocal.  This does not have the same rounding properties,
6161          so only do this if -funsafe-math-optimizations.  We can actually
6162          always safely do it if ARG1 is a power of two, but it's hard to
6163          tell if it is or not in a portable manner.  */
6164       if (TREE_CODE (arg1) == REAL_CST)
6165         {
6166           if (flag_unsafe_math_optimizations
6167               && 0 != (tem = const_binop (code, build_real (type, dconst1),
6168                                           arg1, 0)))
6169             return fold (build (MULT_EXPR, type, arg0, tem));
6170           /* Find the reciprocal if optimizing and the result is exact.  */
6171           else if (optimize)
6172             {
6173               REAL_VALUE_TYPE r;
6174               r = TREE_REAL_CST (arg1);
6175               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
6176                 {
6177                   tem = build_real (type, r);
6178                   return fold (build (MULT_EXPR, type, arg0, tem));
6179                 }
6180             }
6181         }
6182       /* Convert A/B/C to A/(B*C).  */
6183       if (flag_unsafe_math_optimizations
6184           && TREE_CODE (arg0) == RDIV_EXPR)
6185         {
6186           return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
6187                               build (MULT_EXPR, type, TREE_OPERAND (arg0, 1),
6188                                      arg1)));
6189         }
6190       /* Convert A/(B/C) to (A/B)*C.  */
6191       if (flag_unsafe_math_optimizations
6192           && TREE_CODE (arg1) == RDIV_EXPR)
6193         {
6194           return fold (build (MULT_EXPR, type,
6195                               build (RDIV_EXPR, type, arg0,
6196                                      TREE_OPERAND (arg1, 0)),
6197                               TREE_OPERAND (arg1, 1)));
6198         }
6199
6200       if (flag_unsafe_math_optimizations)
6201         {
6202           enum built_in_function fcode = builtin_mathfn_code (arg1);
6203           /* Optimize x/exp(y) into x*exp(-y).  */
6204           if (fcode == BUILT_IN_EXP
6205               || fcode == BUILT_IN_EXPF
6206               || fcode == BUILT_IN_EXPL)
6207             {
6208               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
6209               tree arg = build1 (NEGATE_EXPR, type,
6210                                  TREE_VALUE (TREE_OPERAND (arg1, 1)));
6211               tree arglist = build_tree_list (NULL_TREE, fold (arg));
6212               arg1 = build_function_call_expr (expfn, arglist);
6213               return fold (build (MULT_EXPR, type, arg0, arg1));
6214             }
6215
6216           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
6217           if (fcode == BUILT_IN_POW
6218               || fcode == BUILT_IN_POWF
6219               || fcode == BUILT_IN_POWL)
6220             {
6221               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
6222               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
6223               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
6224               tree neg11 = fold (build1 (NEGATE_EXPR, type, arg11));
6225               tree arglist = tree_cons(NULL_TREE, arg10,
6226                                        build_tree_list (NULL_TREE, neg11));
6227               arg1 = build_function_call_expr (powfn, arglist);
6228               return fold (build (MULT_EXPR, type, arg0, arg1));
6229             }
6230         }
6231
6232       if (flag_unsafe_math_optimizations)
6233         {
6234           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
6235           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
6236
6237           /* Optimize sin(x)/cos(x) as tan(x).  */
6238           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
6239                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
6240                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
6241               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
6242                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
6243             {
6244               tree tanfn;
6245
6246               if (fcode0 == BUILT_IN_SIN)
6247                 tanfn = implicit_built_in_decls[BUILT_IN_TAN];
6248               else if (fcode0 == BUILT_IN_SINF)
6249                 tanfn = implicit_built_in_decls[BUILT_IN_TANF];
6250               else if (fcode0 == BUILT_IN_SINL)
6251                 tanfn = implicit_built_in_decls[BUILT_IN_TANL];
6252               else
6253                 tanfn = NULL_TREE;
6254
6255               if (tanfn != NULL_TREE)
6256                 return build_function_call_expr (tanfn,
6257                                                  TREE_OPERAND (arg0, 1));
6258             }
6259
6260           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
6261           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
6262                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
6263                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
6264               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
6265                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
6266             {
6267               tree tanfn;
6268
6269               if (fcode0 == BUILT_IN_COS)
6270                 tanfn = implicit_built_in_decls[BUILT_IN_TAN];
6271               else if (fcode0 == BUILT_IN_COSF)
6272                 tanfn = implicit_built_in_decls[BUILT_IN_TANF];
6273               else if (fcode0 == BUILT_IN_COSL)
6274                 tanfn = implicit_built_in_decls[BUILT_IN_TANL];
6275               else
6276                 tanfn = NULL_TREE;
6277
6278               if (tanfn != NULL_TREE)
6279                 {
6280                   tree tmp = TREE_OPERAND (arg0, 1);
6281                   tmp = build_function_call_expr (tanfn, tmp);
6282                   return fold (build (RDIV_EXPR, type,
6283                                       build_real (type, dconst1),
6284                                       tmp));
6285                 }
6286             }
6287         }
6288       goto binary;
6289
6290     case TRUNC_DIV_EXPR:
6291     case ROUND_DIV_EXPR:
6292     case FLOOR_DIV_EXPR:
6293     case CEIL_DIV_EXPR:
6294     case EXACT_DIV_EXPR:
6295       if (integer_onep (arg1))
6296         return non_lvalue (convert (type, arg0));
6297       if (integer_zerop (arg1))
6298         return t;
6299
6300       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
6301          operation, EXACT_DIV_EXPR.
6302
6303          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
6304          At one time others generated faster code, it's not clear if they do
6305          after the last round to changes to the DIV code in expmed.c.  */
6306       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
6307           && multiple_of_p (type, arg0, arg1))
6308         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
6309
6310       if (TREE_CODE (arg1) == INTEGER_CST
6311           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6312                                          code, NULL_TREE)))
6313         return convert (type, tem);
6314
6315       goto binary;
6316
6317     case CEIL_MOD_EXPR:
6318     case FLOOR_MOD_EXPR:
6319     case ROUND_MOD_EXPR:
6320     case TRUNC_MOD_EXPR:
6321       if (integer_onep (arg1))
6322         return omit_one_operand (type, integer_zero_node, arg0);
6323       if (integer_zerop (arg1))
6324         return t;
6325
6326       if (TREE_CODE (arg1) == INTEGER_CST
6327           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6328                                          code, NULL_TREE)))
6329         return convert (type, tem);
6330
6331       goto binary;
6332
6333     case LROTATE_EXPR:
6334     case RROTATE_EXPR:
6335       if (integer_all_onesp (arg0))
6336         return omit_one_operand (type, arg0, arg1);
6337       goto shift;
6338
6339     case RSHIFT_EXPR:
6340       /* Optimize -1 >> x for arithmetic right shifts.  */
6341       if (integer_all_onesp (arg0) && ! TREE_UNSIGNED (type))
6342         return omit_one_operand (type, arg0, arg1);
6343       /* ... fall through ...  */
6344
6345     case LSHIFT_EXPR:
6346     shift:
6347       if (integer_zerop (arg1))
6348         return non_lvalue (convert (type, arg0));
6349       if (integer_zerop (arg0))
6350         return omit_one_operand (type, arg0, arg1);
6351
6352       /* Since negative shift count is not well-defined,
6353          don't try to compute it in the compiler.  */
6354       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
6355         return t;
6356       /* Rewrite an LROTATE_EXPR by a constant into an
6357          RROTATE_EXPR by a new constant.  */
6358       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
6359         {
6360           TREE_SET_CODE (t, RROTATE_EXPR);
6361           code = RROTATE_EXPR;
6362           TREE_OPERAND (t, 1) = arg1
6363             = const_binop
6364               (MINUS_EXPR,
6365                convert (TREE_TYPE (arg1),
6366                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
6367                arg1, 0);
6368           if (tree_int_cst_sgn (arg1) < 0)
6369             return t;
6370         }
6371
6372       /* If we have a rotate of a bit operation with the rotate count and
6373          the second operand of the bit operation both constant,
6374          permute the two operations.  */
6375       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6376           && (TREE_CODE (arg0) == BIT_AND_EXPR
6377               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
6378               || TREE_CODE (arg0) == BIT_IOR_EXPR
6379               || TREE_CODE (arg0) == BIT_XOR_EXPR)
6380           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6381         return fold (build (TREE_CODE (arg0), type,
6382                             fold (build (code, type,
6383                                          TREE_OPERAND (arg0, 0), arg1)),
6384                             fold (build (code, type,
6385                                          TREE_OPERAND (arg0, 1), arg1))));
6386
6387       /* Two consecutive rotates adding up to the width of the mode can
6388          be ignored.  */
6389       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6390           && TREE_CODE (arg0) == RROTATE_EXPR
6391           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6392           && TREE_INT_CST_HIGH (arg1) == 0
6393           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
6394           && ((TREE_INT_CST_LOW (arg1)
6395                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
6396               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
6397         return TREE_OPERAND (arg0, 0);
6398
6399       goto binary;
6400
6401     case MIN_EXPR:
6402       if (operand_equal_p (arg0, arg1, 0))
6403         return omit_one_operand (type, arg0, arg1);
6404       if (INTEGRAL_TYPE_P (type)
6405           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
6406         return omit_one_operand (type, arg1, arg0);
6407       goto associate;
6408
6409     case MAX_EXPR:
6410       if (operand_equal_p (arg0, arg1, 0))
6411         return omit_one_operand (type, arg0, arg1);
6412       if (INTEGRAL_TYPE_P (type)
6413           && TYPE_MAX_VALUE (type)
6414           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
6415         return omit_one_operand (type, arg1, arg0);
6416       goto associate;
6417
6418     case TRUTH_NOT_EXPR:
6419       /* Note that the operand of this must be an int
6420          and its values must be 0 or 1.
6421          ("true" is a fixed value perhaps depending on the language,
6422          but we don't handle values other than 1 correctly yet.)  */
6423       tem = invert_truthvalue (arg0);
6424       /* Avoid infinite recursion.  */
6425       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
6426         return t;
6427       return convert (type, tem);
6428
6429     case TRUTH_ANDIF_EXPR:
6430       /* Note that the operands of this must be ints
6431          and their values must be 0 or 1.
6432          ("true" is a fixed value perhaps depending on the language.)  */
6433       /* If first arg is constant zero, return it.  */
6434       if (integer_zerop (arg0))
6435         return convert (type, arg0);
6436     case TRUTH_AND_EXPR:
6437       /* If either arg is constant true, drop it.  */
6438       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6439         return non_lvalue (convert (type, arg1));
6440       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
6441           /* Preserve sequence points.  */
6442           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6443         return non_lvalue (convert (type, arg0));
6444       /* If second arg is constant zero, result is zero, but first arg
6445          must be evaluated.  */
6446       if (integer_zerop (arg1))
6447         return omit_one_operand (type, arg1, arg0);
6448       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
6449          case will be handled here.  */
6450       if (integer_zerop (arg0))
6451         return omit_one_operand (type, arg0, arg1);
6452
6453     truth_andor:
6454       /* We only do these simplifications if we are optimizing.  */
6455       if (!optimize)
6456         return t;
6457
6458       /* Check for things like (A || B) && (A || C).  We can convert this
6459          to A || (B && C).  Note that either operator can be any of the four
6460          truth and/or operations and the transformation will still be
6461          valid.   Also note that we only care about order for the
6462          ANDIF and ORIF operators.  If B contains side effects, this
6463          might change the truth-value of A.  */
6464       if (TREE_CODE (arg0) == TREE_CODE (arg1)
6465           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
6466               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
6467               || TREE_CODE (arg0) == TRUTH_AND_EXPR
6468               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
6469           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
6470         {
6471           tree a00 = TREE_OPERAND (arg0, 0);
6472           tree a01 = TREE_OPERAND (arg0, 1);
6473           tree a10 = TREE_OPERAND (arg1, 0);
6474           tree a11 = TREE_OPERAND (arg1, 1);
6475           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
6476                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
6477                              && (code == TRUTH_AND_EXPR
6478                                  || code == TRUTH_OR_EXPR));
6479
6480           if (operand_equal_p (a00, a10, 0))
6481             return fold (build (TREE_CODE (arg0), type, a00,
6482                                 fold (build (code, type, a01, a11))));
6483           else if (commutative && operand_equal_p (a00, a11, 0))
6484             return fold (build (TREE_CODE (arg0), type, a00,
6485                                 fold (build (code, type, a01, a10))));
6486           else if (commutative && operand_equal_p (a01, a10, 0))
6487             return fold (build (TREE_CODE (arg0), type, a01,
6488                                 fold (build (code, type, a00, a11))));
6489
6490           /* This case if tricky because we must either have commutative
6491              operators or else A10 must not have side-effects.  */
6492
6493           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
6494                    && operand_equal_p (a01, a11, 0))
6495             return fold (build (TREE_CODE (arg0), type,
6496                                 fold (build (code, type, a00, a10)),
6497                                 a01));
6498         }
6499
6500       /* See if we can build a range comparison.  */
6501       if (0 != (tem = fold_range_test (t)))
6502         return tem;
6503
6504       /* Check for the possibility of merging component references.  If our
6505          lhs is another similar operation, try to merge its rhs with our
6506          rhs.  Then try to merge our lhs and rhs.  */
6507       if (TREE_CODE (arg0) == code
6508           && 0 != (tem = fold_truthop (code, type,
6509                                        TREE_OPERAND (arg0, 1), arg1)))
6510         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6511
6512       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
6513         return tem;
6514
6515       return t;
6516
6517     case TRUTH_ORIF_EXPR:
6518       /* Note that the operands of this must be ints
6519          and their values must be 0 or true.
6520          ("true" is a fixed value perhaps depending on the language.)  */
6521       /* If first arg is constant true, return it.  */
6522       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6523         return convert (type, arg0);
6524     case TRUTH_OR_EXPR:
6525       /* If either arg is constant zero, drop it.  */
6526       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
6527         return non_lvalue (convert (type, arg1));
6528       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
6529           /* Preserve sequence points.  */
6530           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6531         return non_lvalue (convert (type, arg0));
6532       /* If second arg is constant true, result is true, but we must
6533          evaluate first arg.  */
6534       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
6535         return omit_one_operand (type, arg1, arg0);
6536       /* Likewise for first arg, but note this only occurs here for
6537          TRUTH_OR_EXPR.  */
6538       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6539         return omit_one_operand (type, arg0, arg1);
6540       goto truth_andor;
6541
6542     case TRUTH_XOR_EXPR:
6543       /* If either arg is constant zero, drop it.  */
6544       if (integer_zerop (arg0))
6545         return non_lvalue (convert (type, arg1));
6546       if (integer_zerop (arg1))
6547         return non_lvalue (convert (type, arg0));
6548       /* If either arg is constant true, this is a logical inversion.  */
6549       if (integer_onep (arg0))
6550         return non_lvalue (convert (type, invert_truthvalue (arg1)));
6551       if (integer_onep (arg1))
6552         return non_lvalue (convert (type, invert_truthvalue (arg0)));
6553       return t;
6554
6555     case EQ_EXPR:
6556     case NE_EXPR:
6557     case LT_EXPR:
6558     case GT_EXPR:
6559     case LE_EXPR:
6560     case GE_EXPR:
6561       /* If one arg is a real or integer constant, put it last.  */
6562       if ((TREE_CODE (arg0) == INTEGER_CST
6563            && TREE_CODE (arg1) != INTEGER_CST)
6564           || (TREE_CODE (arg0) == REAL_CST
6565               && TREE_CODE (arg0) != REAL_CST))
6566         {
6567           TREE_OPERAND (t, 0) = arg1;
6568           TREE_OPERAND (t, 1) = arg0;
6569           arg0 = TREE_OPERAND (t, 0);
6570           arg1 = TREE_OPERAND (t, 1);
6571           code = swap_tree_comparison (code);
6572           TREE_SET_CODE (t, code);
6573         }
6574
6575       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6576         {
6577           tree targ0 = strip_float_extensions (arg0);
6578           tree targ1 = strip_float_extensions (arg1);
6579           tree newtype = TREE_TYPE (targ0);
6580
6581           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
6582             newtype = TREE_TYPE (targ1);
6583
6584           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
6585           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
6586             return fold (build (code, type, convert (newtype, targ0),
6587                                 convert (newtype, targ1)));
6588
6589           /* (-a) CMP (-b) -> b CMP a  */
6590           if (TREE_CODE (arg0) == NEGATE_EXPR
6591               && TREE_CODE (arg1) == NEGATE_EXPR)
6592             return fold (build (code, type, TREE_OPERAND (arg1, 0),
6593                                 TREE_OPERAND (arg0, 0)));
6594
6595           if (TREE_CODE (arg1) == REAL_CST)
6596           {
6597             REAL_VALUE_TYPE cst;
6598             cst = TREE_REAL_CST (arg1);
6599
6600             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
6601             if (TREE_CODE (arg0) == NEGATE_EXPR)
6602               return
6603                 fold (build (swap_tree_comparison (code), type,
6604                              TREE_OPERAND (arg0, 0),
6605                              build_real (TREE_TYPE (arg1),
6606                                          REAL_VALUE_NEGATE (cst))));
6607
6608             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
6609             /* a CMP (-0) -> a CMP 0  */
6610             if (REAL_VALUE_MINUS_ZERO (cst))
6611               return fold (build (code, type, arg0,
6612                                   build_real (TREE_TYPE (arg1), dconst0)));
6613
6614             /* x != NaN is always true, other ops are always false.  */
6615             if (REAL_VALUE_ISNAN (cst)
6616                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
6617               {
6618                 t = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
6619                 return omit_one_operand (type, convert (type, t), arg0);
6620               }
6621
6622             /* Fold comparisons against infinity.  */
6623             if (REAL_VALUE_ISINF (cst))
6624               {
6625                 tem = fold_inf_compare (code, type, arg0, arg1);
6626                 if (tem != NULL_TREE)
6627                   return tem;
6628               }
6629           }
6630
6631           /* If this is a comparison of a real constant with a PLUS_EXPR
6632              or a MINUS_EXPR of a real constant, we can convert it into a
6633              comparison with a revised real constant as long as no overflow
6634              occurs when unsafe_math_optimizations are enabled.  */
6635           if (flag_unsafe_math_optimizations
6636               && TREE_CODE (arg1) == REAL_CST
6637               && (TREE_CODE (arg0) == PLUS_EXPR
6638                   || TREE_CODE (arg0) == MINUS_EXPR)
6639               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
6640               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6641                                           ? MINUS_EXPR : PLUS_EXPR,
6642                                           arg1, TREE_OPERAND (arg0, 1), 0))
6643               && ! TREE_CONSTANT_OVERFLOW (tem))
6644             return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6645
6646           /* Likewise, we can simplify a comparison of a real constant with
6647              a MINUS_EXPR whose first operand is also a real constant, i.e.
6648              (c1 - x) < c2 becomes x > c1-c2.  */
6649           if (flag_unsafe_math_optimizations
6650               && TREE_CODE (arg1) == REAL_CST
6651               && TREE_CODE (arg0) == MINUS_EXPR
6652               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
6653               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
6654                                           arg1, 0))
6655               && ! TREE_CONSTANT_OVERFLOW (tem))
6656             return fold (build (swap_tree_comparison (code), type,
6657                                 TREE_OPERAND (arg0, 1), tem));
6658
6659           /* Fold comparisons against built-in math functions.  */
6660           if (TREE_CODE (arg1) == REAL_CST
6661               && flag_unsafe_math_optimizations
6662               && ! flag_errno_math)
6663             {
6664               enum built_in_function fcode = builtin_mathfn_code (arg0);
6665
6666               if (fcode != END_BUILTINS)
6667                 {
6668                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
6669                   if (tem != NULL_TREE)
6670                     return tem;
6671                 }
6672             }
6673         }
6674
6675       /* Convert foo++ == CONST into ++foo == CONST + INCR.
6676          First, see if one arg is constant; find the constant arg
6677          and the other one.  */
6678       {
6679         tree constop = 0, varop = NULL_TREE;
6680         int constopnum = -1;
6681
6682         if (TREE_CONSTANT (arg1))
6683           constopnum = 1, constop = arg1, varop = arg0;
6684         if (TREE_CONSTANT (arg0))
6685           constopnum = 0, constop = arg0, varop = arg1;
6686
6687         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
6688           {
6689             /* This optimization is invalid for ordered comparisons
6690                if CONST+INCR overflows or if foo+incr might overflow.
6691                This optimization is invalid for floating point due to rounding.
6692                For pointer types we assume overflow doesn't happen.  */
6693             if (POINTER_TYPE_P (TREE_TYPE (varop))
6694                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6695                     && (code == EQ_EXPR || code == NE_EXPR)))
6696               {
6697                 tree newconst
6698                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6699                                  constop, TREE_OPERAND (varop, 1)));
6700
6701                 /* Do not overwrite the current varop to be a preincrement,
6702                    create a new node so that we won't confuse our caller who
6703                    might create trees and throw them away, reusing the
6704                    arguments that they passed to build.  This shows up in
6705                    the THEN or ELSE parts of ?: being postincrements.  */
6706                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6707                                TREE_OPERAND (varop, 0),
6708                                TREE_OPERAND (varop, 1));
6709
6710                 /* If VAROP is a reference to a bitfield, we must mask
6711                    the constant by the width of the field.  */
6712                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6713                     && DECL_BIT_FIELD(TREE_OPERAND
6714                                       (TREE_OPERAND (varop, 0), 1)))
6715                   {
6716                     int size
6717                       = TREE_INT_CST_LOW (DECL_SIZE
6718                                           (TREE_OPERAND
6719                                            (TREE_OPERAND (varop, 0), 1)));
6720                     tree mask, unsigned_type;
6721                     unsigned int precision;
6722                     tree folded_compare;
6723
6724                     /* First check whether the comparison would come out
6725                        always the same.  If we don't do that we would
6726                        change the meaning with the masking.  */
6727                     if (constopnum == 0)
6728                       folded_compare = fold (build (code, type, constop,
6729                                                     TREE_OPERAND (varop, 0)));
6730                     else
6731                       folded_compare = fold (build (code, type,
6732                                                     TREE_OPERAND (varop, 0),
6733                                                     constop));
6734                     if (integer_zerop (folded_compare)
6735                         || integer_onep (folded_compare))
6736                       return omit_one_operand (type, folded_compare, varop);
6737
6738                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6739                     precision = TYPE_PRECISION (unsigned_type);
6740                     mask = build_int_2 (~0, ~0);
6741                     TREE_TYPE (mask) = unsigned_type;
6742                     force_fit_type (mask, 0);
6743                     mask = const_binop (RSHIFT_EXPR, mask,
6744                                         size_int (precision - size), 0);
6745                     newconst = fold (build (BIT_AND_EXPR,
6746                                             TREE_TYPE (varop), newconst,
6747                                             convert (TREE_TYPE (varop),
6748                                                      mask)));
6749                   }
6750
6751                 t = build (code, type,
6752                            (constopnum == 0) ? newconst : varop,
6753                            (constopnum == 1) ? newconst : varop);
6754                 return t;
6755               }
6756           }
6757         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6758           {
6759             if (POINTER_TYPE_P (TREE_TYPE (varop))
6760                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6761                     && (code == EQ_EXPR || code == NE_EXPR)))
6762               {
6763                 tree newconst
6764                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6765                                  constop, TREE_OPERAND (varop, 1)));
6766
6767                 /* Do not overwrite the current varop to be a predecrement,
6768                    create a new node so that we won't confuse our caller who
6769                    might create trees and throw them away, reusing the
6770                    arguments that they passed to build.  This shows up in
6771                    the THEN or ELSE parts of ?: being postdecrements.  */
6772                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6773                                TREE_OPERAND (varop, 0),
6774                                TREE_OPERAND (varop, 1));
6775
6776                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6777                     && DECL_BIT_FIELD(TREE_OPERAND
6778                                       (TREE_OPERAND (varop, 0), 1)))
6779                   {
6780                     int size
6781                       = TREE_INT_CST_LOW (DECL_SIZE
6782                                           (TREE_OPERAND
6783                                            (TREE_OPERAND (varop, 0), 1)));
6784                     tree mask, unsigned_type;
6785                     unsigned int precision;
6786                     tree folded_compare;
6787
6788                     if (constopnum == 0)
6789                       folded_compare = fold (build (code, type, constop,
6790                                                     TREE_OPERAND (varop, 0)));
6791                     else
6792                       folded_compare = fold (build (code, type,
6793                                                     TREE_OPERAND (varop, 0),
6794                                                     constop));
6795                     if (integer_zerop (folded_compare)
6796                         || integer_onep (folded_compare))
6797                       return omit_one_operand (type, folded_compare, varop);
6798
6799                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6800                     precision = TYPE_PRECISION (unsigned_type);
6801                     mask = build_int_2 (~0, ~0);
6802                     TREE_TYPE (mask) = TREE_TYPE (varop);
6803                     force_fit_type (mask, 0);
6804                     mask = const_binop (RSHIFT_EXPR, mask,
6805                                         size_int (precision - size), 0);
6806                     newconst = fold (build (BIT_AND_EXPR,
6807                                             TREE_TYPE (varop), newconst,
6808                                             convert (TREE_TYPE (varop),
6809                                                      mask)));
6810                   }
6811
6812                 t = build (code, type,
6813                            (constopnum == 0) ? newconst : varop,
6814                            (constopnum == 1) ? newconst : varop);
6815                 return t;
6816               }
6817           }
6818       }
6819
6820       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
6821          This transformation affects the cases which are handled in later
6822          optimizations involving comparisons with non-negative constants.  */
6823       if (TREE_CODE (arg1) == INTEGER_CST
6824           && TREE_CODE (arg0) != INTEGER_CST
6825           && tree_int_cst_sgn (arg1) > 0)
6826         {
6827           switch (code)
6828             {
6829             case GE_EXPR:
6830               code = GT_EXPR;
6831               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6832               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6833               break;
6834
6835             case LT_EXPR:
6836               code = LE_EXPR;
6837               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6838               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6839               break;
6840
6841             default:
6842               break;
6843             }
6844         }
6845
6846       /* Comparisons with the highest or lowest possible integer of
6847          the specified size will have known values.  */
6848       {
6849         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6850
6851         if (TREE_CODE (arg1) == INTEGER_CST
6852             && ! TREE_CONSTANT_OVERFLOW (arg1)
6853             && width <= HOST_BITS_PER_WIDE_INT
6854             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6855                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6856           {
6857             unsigned HOST_WIDE_INT signed_max;
6858             unsigned HOST_WIDE_INT max, min;
6859
6860             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
6861
6862             if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6863               {
6864                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
6865                 min = 0;
6866               }
6867             else
6868               {
6869                 max = signed_max;
6870                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
6871               }
6872
6873             if (TREE_INT_CST_HIGH (arg1) == 0
6874                 && TREE_INT_CST_LOW (arg1) == max)
6875               switch (code)
6876                 {
6877                 case GT_EXPR:
6878                   return omit_one_operand (type,
6879                                            convert (type, integer_zero_node),
6880                                            arg0);
6881                 case GE_EXPR:
6882                   code = EQ_EXPR;
6883                   TREE_SET_CODE (t, EQ_EXPR);
6884                   break;
6885                 case LE_EXPR:
6886                   return omit_one_operand (type,
6887                                            convert (type, integer_one_node),
6888                                            arg0);
6889                 case LT_EXPR:
6890                   code = NE_EXPR;
6891                   TREE_SET_CODE (t, NE_EXPR);
6892                   break;
6893
6894                 /* The GE_EXPR and LT_EXPR cases above are not normally
6895                    reached because of  previous transformations.  */
6896
6897                 default:
6898                   break;
6899                 }
6900             else if (TREE_INT_CST_HIGH (arg1) == 0
6901                      && TREE_INT_CST_LOW (arg1) == max - 1)
6902               switch (code)
6903                 {
6904                 case GT_EXPR:
6905                   code = EQ_EXPR;
6906                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6907                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6908                   break;
6909                 case LE_EXPR:
6910                   code = NE_EXPR;
6911                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6912                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6913                   break;
6914                 default:
6915                   break;
6916                 }
6917             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6918                      && TREE_INT_CST_LOW (arg1) == min)
6919               switch (code)
6920                 {
6921                 case LT_EXPR:
6922                   return omit_one_operand (type,
6923                                            convert (type, integer_zero_node),
6924                                            arg0);
6925                 case LE_EXPR:
6926                   code = EQ_EXPR;
6927                   TREE_SET_CODE (t, EQ_EXPR);
6928                   break;
6929
6930                 case GE_EXPR:
6931                   return omit_one_operand (type,
6932                                            convert (type, integer_one_node),
6933                                            arg0);
6934                 case GT_EXPR:
6935                   code = NE_EXPR;
6936                   TREE_SET_CODE (t, NE_EXPR);
6937                   break;
6938
6939                 default:
6940                   break;
6941                 }
6942             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6943                      && TREE_INT_CST_LOW (arg1) == min + 1)
6944               switch (code)
6945                 {
6946                 case GE_EXPR:
6947                   code = NE_EXPR;
6948                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6949                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6950                   break;
6951                 case LT_EXPR:
6952                   code = EQ_EXPR;
6953                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6954                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6955                   break;
6956                 default:
6957                   break;
6958                 }
6959
6960             else if (TREE_INT_CST_HIGH (arg1) == 0
6961                      && TREE_INT_CST_LOW (arg1) == signed_max
6962                      && TREE_UNSIGNED (TREE_TYPE (arg1))
6963                      /* signed_type does not work on pointer types.  */
6964                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6965               {
6966                 /* The following case also applies to X < signed_max+1
6967                    and X >= signed_max+1 because previous transformations.  */
6968                 if (code == LE_EXPR || code == GT_EXPR)
6969                   {
6970                     tree st0, st1;
6971                     st0 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg0));
6972                     st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
6973                     return fold
6974                       (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
6975                               type, convert (st0, arg0),
6976                               convert (st1, integer_zero_node)));
6977                   }
6978               }
6979           }
6980       }
6981
6982       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6983          a MINUS_EXPR of a constant, we can convert it into a comparison with
6984          a revised constant as long as no overflow occurs.  */
6985       if ((code == EQ_EXPR || code == NE_EXPR)
6986           && TREE_CODE (arg1) == INTEGER_CST
6987           && (TREE_CODE (arg0) == PLUS_EXPR
6988               || TREE_CODE (arg0) == MINUS_EXPR)
6989           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6990           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6991                                       ? MINUS_EXPR : PLUS_EXPR,
6992                                       arg1, TREE_OPERAND (arg0, 1), 0))
6993           && ! TREE_CONSTANT_OVERFLOW (tem))
6994         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6995
6996       /* Similarly for a NEGATE_EXPR.  */
6997       else if ((code == EQ_EXPR || code == NE_EXPR)
6998                && TREE_CODE (arg0) == NEGATE_EXPR
6999                && TREE_CODE (arg1) == INTEGER_CST
7000                && 0 != (tem = negate_expr (arg1))
7001                && TREE_CODE (tem) == INTEGER_CST
7002                && ! TREE_CONSTANT_OVERFLOW (tem))
7003         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
7004
7005       /* If we have X - Y == 0, we can convert that to X == Y and similarly
7006          for !=.  Don't do this for ordered comparisons due to overflow.  */
7007       else if ((code == NE_EXPR || code == EQ_EXPR)
7008                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
7009         return fold (build (code, type,
7010                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
7011
7012       /* If we are widening one operand of an integer comparison,
7013          see if the other operand is similarly being widened.  Perhaps we
7014          can do the comparison in the narrower type.  */
7015       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
7016                && TREE_CODE (arg0) == NOP_EXPR
7017                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
7018                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
7019                && (TREE_TYPE (t1) == TREE_TYPE (tem)
7020                    || (TREE_CODE (t1) == INTEGER_CST
7021                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
7022         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
7023
7024       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
7025          constant, we can simplify it.  */
7026       else if (TREE_CODE (arg1) == INTEGER_CST
7027                && (TREE_CODE (arg0) == MIN_EXPR
7028                    || TREE_CODE (arg0) == MAX_EXPR)
7029                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7030         return optimize_minmax_comparison (t);
7031
7032       /* If we are comparing an ABS_EXPR with a constant, we can
7033          convert all the cases into explicit comparisons, but they may
7034          well not be faster than doing the ABS and one comparison.
7035          But ABS (X) <= C is a range comparison, which becomes a subtraction
7036          and a comparison, and is probably faster.  */
7037       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
7038                && TREE_CODE (arg0) == ABS_EXPR
7039                && ! TREE_SIDE_EFFECTS (arg0)
7040                && (0 != (tem = negate_expr (arg1)))
7041                && TREE_CODE (tem) == INTEGER_CST
7042                && ! TREE_CONSTANT_OVERFLOW (tem))
7043         return fold (build (TRUTH_ANDIF_EXPR, type,
7044                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
7045                             build (LE_EXPR, type,
7046                                    TREE_OPERAND (arg0, 0), arg1)));
7047
7048       /* If this is an EQ or NE comparison with zero and ARG0 is
7049          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
7050          two operations, but the latter can be done in one less insn
7051          on machines that have only two-operand insns or on which a
7052          constant cannot be the first operand.  */
7053       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
7054           && TREE_CODE (arg0) == BIT_AND_EXPR)
7055         {
7056           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
7057               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
7058             return
7059               fold (build (code, type,
7060                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
7061                                   build (RSHIFT_EXPR,
7062                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
7063                                          TREE_OPERAND (arg0, 1),
7064                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
7065                                   convert (TREE_TYPE (arg0),
7066                                            integer_one_node)),
7067                            arg1));
7068           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
7069                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
7070             return
7071               fold (build (code, type,
7072                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
7073                                   build (RSHIFT_EXPR,
7074                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
7075                                          TREE_OPERAND (arg0, 0),
7076                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
7077                                   convert (TREE_TYPE (arg0),
7078                                            integer_one_node)),
7079                            arg1));
7080         }
7081
7082       /* If this is an NE or EQ comparison of zero against the result of a
7083          signed MOD operation whose second operand is a power of 2, make
7084          the MOD operation unsigned since it is simpler and equivalent.  */
7085       if ((code == NE_EXPR || code == EQ_EXPR)
7086           && integer_zerop (arg1)
7087           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
7088           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
7089               || TREE_CODE (arg0) == CEIL_MOD_EXPR
7090               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
7091               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
7092           && integer_pow2p (TREE_OPERAND (arg0, 1)))
7093         {
7094           tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
7095           tree newmod = build (TREE_CODE (arg0), newtype,
7096                                convert (newtype, TREE_OPERAND (arg0, 0)),
7097                                convert (newtype, TREE_OPERAND (arg0, 1)));
7098
7099           return build (code, type, newmod, convert (newtype, arg1));
7100         }
7101
7102       /* If this is an NE comparison of zero with an AND of one, remove the
7103          comparison since the AND will give the correct value.  */
7104       if (code == NE_EXPR && integer_zerop (arg1)
7105           && TREE_CODE (arg0) == BIT_AND_EXPR
7106           && integer_onep (TREE_OPERAND (arg0, 1)))
7107         return convert (type, arg0);
7108
7109       /* If we have (A & C) == C where C is a power of 2, convert this into
7110          (A & C) != 0.  Similarly for NE_EXPR.  */
7111       if ((code == EQ_EXPR || code == NE_EXPR)
7112           && TREE_CODE (arg0) == BIT_AND_EXPR
7113           && integer_pow2p (TREE_OPERAND (arg0, 1))
7114           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
7115         return fold (build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
7116                             arg0, integer_zero_node));
7117
7118       /* If we have (A & C) != 0 where C is the sign bit of A, convert
7119          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
7120       if ((code == EQ_EXPR || code == NE_EXPR)
7121           && TREE_CODE (arg0) == BIT_AND_EXPR
7122           && integer_zerop (arg1))
7123         {
7124           tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0),
7125                                    TREE_OPERAND (arg0, 1));
7126           if (arg00 != NULL_TREE)
7127           {
7128             tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
7129             return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
7130                                 convert (stype, arg00),
7131                                 convert (stype, integer_zero_node)));
7132           }
7133         }
7134
7135       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
7136          and similarly for >= into !=.  */
7137       if ((code == LT_EXPR || code == GE_EXPR)
7138           && TREE_UNSIGNED (TREE_TYPE (arg0))
7139           && TREE_CODE (arg1) == LSHIFT_EXPR
7140           && integer_onep (TREE_OPERAND (arg1, 0)))
7141         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
7142                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
7143                              TREE_OPERAND (arg1, 1)),
7144                       convert (TREE_TYPE (arg0), integer_zero_node));
7145
7146       else if ((code == LT_EXPR || code == GE_EXPR)
7147                && TREE_UNSIGNED (TREE_TYPE (arg0))
7148                && (TREE_CODE (arg1) == NOP_EXPR
7149                    || TREE_CODE (arg1) == CONVERT_EXPR)
7150                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
7151                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
7152         return
7153           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
7154                  convert (TREE_TYPE (arg0),
7155                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
7156                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
7157                  convert (TREE_TYPE (arg0), integer_zero_node));
7158
7159       /* Simplify comparison of something with itself.  (For IEEE
7160          floating-point, we can only do some of these simplifications.)  */
7161       if (operand_equal_p (arg0, arg1, 0))
7162         {
7163           switch (code)
7164             {
7165             case EQ_EXPR:
7166             case GE_EXPR:
7167             case LE_EXPR:
7168               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
7169                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
7170                 return constant_boolean_node (1, type);
7171               code = EQ_EXPR;
7172               TREE_SET_CODE (t, code);
7173               break;
7174
7175             case NE_EXPR:
7176               /* For NE, we can only do this simplification if integer
7177                  or we don't honor IEEE floating point NaNs.  */
7178               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
7179                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
7180                 break;
7181               /* ... fall through ...  */
7182             case GT_EXPR:
7183             case LT_EXPR:
7184               return constant_boolean_node (0, type);
7185             default:
7186               abort ();
7187             }
7188         }
7189
7190       /* If we are comparing an expression that just has comparisons
7191          of two integer values, arithmetic expressions of those comparisons,
7192          and constants, we can simplify it.  There are only three cases
7193          to check: the two values can either be equal, the first can be
7194          greater, or the second can be greater.  Fold the expression for
7195          those three values.  Since each value must be 0 or 1, we have
7196          eight possibilities, each of which corresponds to the constant 0
7197          or 1 or one of the six possible comparisons.
7198
7199          This handles common cases like (a > b) == 0 but also handles
7200          expressions like  ((x > y) - (y > x)) > 0, which supposedly
7201          occur in macroized code.  */
7202
7203       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
7204         {
7205           tree cval1 = 0, cval2 = 0;
7206           int save_p = 0;
7207
7208           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
7209               /* Don't handle degenerate cases here; they should already
7210                  have been handled anyway.  */
7211               && cval1 != 0 && cval2 != 0
7212               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
7213               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
7214               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
7215               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
7216               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
7217               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
7218                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
7219             {
7220               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
7221               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
7222
7223               /* We can't just pass T to eval_subst in case cval1 or cval2
7224                  was the same as ARG1.  */
7225
7226               tree high_result
7227                 = fold (build (code, type,
7228                                eval_subst (arg0, cval1, maxval, cval2, minval),
7229                                arg1));
7230               tree equal_result
7231                 = fold (build (code, type,
7232                                eval_subst (arg0, cval1, maxval, cval2, maxval),
7233                                arg1));
7234               tree low_result
7235                 = fold (build (code, type,
7236                                eval_subst (arg0, cval1, minval, cval2, maxval),
7237                                arg1));
7238
7239               /* All three of these results should be 0 or 1.  Confirm they
7240                  are.  Then use those values to select the proper code
7241                  to use.  */
7242
7243               if ((integer_zerop (high_result)
7244                    || integer_onep (high_result))
7245                   && (integer_zerop (equal_result)
7246                       || integer_onep (equal_result))
7247                   && (integer_zerop (low_result)
7248                       || integer_onep (low_result)))
7249                 {
7250                   /* Make a 3-bit mask with the high-order bit being the
7251                      value for `>', the next for '=', and the low for '<'.  */
7252                   switch ((integer_onep (high_result) * 4)
7253                           + (integer_onep (equal_result) * 2)
7254                           + integer_onep (low_result))
7255                     {
7256                     case 0:
7257                       /* Always false.  */
7258                       return omit_one_operand (type, integer_zero_node, arg0);
7259                     case 1:
7260                       code = LT_EXPR;
7261                       break;
7262                     case 2:
7263                       code = EQ_EXPR;
7264                       break;
7265                     case 3:
7266                       code = LE_EXPR;
7267                       break;
7268                     case 4:
7269                       code = GT_EXPR;
7270                       break;
7271                     case 5:
7272                       code = NE_EXPR;
7273                       break;
7274                     case 6:
7275                       code = GE_EXPR;
7276                       break;
7277                     case 7:
7278                       /* Always true.  */
7279                       return omit_one_operand (type, integer_one_node, arg0);
7280                     }
7281
7282                   t = build (code, type, cval1, cval2);
7283                   if (save_p)
7284                     return save_expr (t);
7285                   else
7286                     return fold (t);
7287                 }
7288             }
7289         }
7290
7291       /* If this is a comparison of a field, we may be able to simplify it.  */
7292       if (((TREE_CODE (arg0) == COMPONENT_REF
7293             && (*lang_hooks.can_use_bit_fields_p) ())
7294            || TREE_CODE (arg0) == BIT_FIELD_REF)
7295           && (code == EQ_EXPR || code == NE_EXPR)
7296           /* Handle the constant case even without -O
7297              to make sure the warnings are given.  */
7298           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
7299         {
7300           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
7301           return t1 ? t1 : t;
7302         }
7303
7304       /* If this is a comparison of complex values and either or both sides
7305          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
7306          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
7307          This may prevent needless evaluations.  */
7308       if ((code == EQ_EXPR || code == NE_EXPR)
7309           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
7310           && (TREE_CODE (arg0) == COMPLEX_EXPR
7311               || TREE_CODE (arg1) == COMPLEX_EXPR
7312               || TREE_CODE (arg0) == COMPLEX_CST
7313               || TREE_CODE (arg1) == COMPLEX_CST))
7314         {
7315           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
7316           tree real0, imag0, real1, imag1;
7317
7318           arg0 = save_expr (arg0);
7319           arg1 = save_expr (arg1);
7320           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
7321           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
7322           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
7323           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
7324
7325           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
7326                                : TRUTH_ORIF_EXPR),
7327                               type,
7328                               fold (build (code, type, real0, real1)),
7329                               fold (build (code, type, imag0, imag1))));
7330         }
7331
7332       /* Optimize comparisons of strlen vs zero to a compare of the
7333          first character of the string vs zero.  To wit,
7334                 strlen(ptr) == 0   =>  *ptr == 0
7335                 strlen(ptr) != 0   =>  *ptr != 0
7336          Other cases should reduce to one of these two (or a constant)
7337          due to the return value of strlen being unsigned.  */
7338       if ((code == EQ_EXPR || code == NE_EXPR)
7339           && integer_zerop (arg1)
7340           && TREE_CODE (arg0) == CALL_EXPR
7341           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR)
7342         {
7343           tree fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7344           tree arglist;
7345
7346           if (TREE_CODE (fndecl) == FUNCTION_DECL
7347               && DECL_BUILT_IN (fndecl)
7348               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
7349               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
7350               && (arglist = TREE_OPERAND (arg0, 1))
7351               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
7352               && ! TREE_CHAIN (arglist))
7353             return fold (build (code, type,
7354                                 build1 (INDIRECT_REF, char_type_node,
7355                                         TREE_VALUE(arglist)),
7356                                 integer_zero_node));
7357         }
7358
7359       /* From here on, the only cases we handle are when the result is
7360          known to be a constant.
7361
7362          To compute GT, swap the arguments and do LT.
7363          To compute GE, do LT and invert the result.
7364          To compute LE, swap the arguments, do LT and invert the result.
7365          To compute NE, do EQ and invert the result.
7366
7367          Therefore, the code below must handle only EQ and LT.  */
7368
7369       if (code == LE_EXPR || code == GT_EXPR)
7370         {
7371           tem = arg0, arg0 = arg1, arg1 = tem;
7372           code = swap_tree_comparison (code);
7373         }
7374
7375       /* Note that it is safe to invert for real values here because we
7376          will check below in the one case that it matters.  */
7377
7378       t1 = NULL_TREE;
7379       invert = 0;
7380       if (code == NE_EXPR || code == GE_EXPR)
7381         {
7382           invert = 1;
7383           code = invert_tree_comparison (code);
7384         }
7385
7386       /* Compute a result for LT or EQ if args permit;
7387          otherwise return T.  */
7388       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
7389         {
7390           if (code == EQ_EXPR)
7391             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
7392           else
7393             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
7394                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
7395                                : INT_CST_LT (arg0, arg1)),
7396                               0);
7397         }
7398
7399 #if 0 /* This is no longer useful, but breaks some real code.  */
7400       /* Assume a nonexplicit constant cannot equal an explicit one,
7401          since such code would be undefined anyway.
7402          Exception: on sysvr4, using #pragma weak,
7403          a label can come out as 0.  */
7404       else if (TREE_CODE (arg1) == INTEGER_CST
7405                && !integer_zerop (arg1)
7406                && TREE_CONSTANT (arg0)
7407                && TREE_CODE (arg0) == ADDR_EXPR
7408                && code == EQ_EXPR)
7409         t1 = build_int_2 (0, 0);
7410 #endif
7411       /* Two real constants can be compared explicitly.  */
7412       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
7413         {
7414           /* If either operand is a NaN, the result is false with two
7415              exceptions: First, an NE_EXPR is true on NaNs, but that case
7416              is already handled correctly since we will be inverting the
7417              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
7418              or a GE_EXPR into a LT_EXPR, we must return true so that it
7419              will be inverted into false.  */
7420
7421           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
7422               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
7423             t1 = build_int_2 (invert && code == LT_EXPR, 0);
7424
7425           else if (code == EQ_EXPR)
7426             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
7427                                                  TREE_REAL_CST (arg1)),
7428                               0);
7429           else
7430             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
7431                                                 TREE_REAL_CST (arg1)),
7432                               0);
7433         }
7434
7435       if (t1 == NULL_TREE)
7436         return t;
7437
7438       if (invert)
7439         TREE_INT_CST_LOW (t1) ^= 1;
7440
7441       TREE_TYPE (t1) = type;
7442       if (TREE_CODE (type) == BOOLEAN_TYPE)
7443         return (*lang_hooks.truthvalue_conversion) (t1);
7444       return t1;
7445
7446     case COND_EXPR:
7447       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
7448          so all simple results must be passed through pedantic_non_lvalue.  */
7449       if (TREE_CODE (arg0) == INTEGER_CST)
7450         return pedantic_non_lvalue
7451           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
7452       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
7453         return pedantic_omit_one_operand (type, arg1, arg0);
7454
7455       /* If the second operand is zero, invert the comparison and swap
7456          the second and third operands.  Likewise if the second operand
7457          is constant and the third is not or if the third operand is
7458          equivalent to the first operand of the comparison.  */
7459
7460       if (integer_zerop (arg1)
7461           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
7462           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7463               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7464                                                  TREE_OPERAND (t, 2),
7465                                                  TREE_OPERAND (arg0, 1))))
7466         {
7467           /* See if this can be inverted.  If it can't, possibly because
7468              it was a floating-point inequality comparison, don't do
7469              anything.  */
7470           tem = invert_truthvalue (arg0);
7471
7472           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7473             {
7474               t = build (code, type, tem,
7475                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7476               arg0 = tem;
7477               /* arg1 should be the first argument of the new T.  */
7478               arg1 = TREE_OPERAND (t, 1);
7479               STRIP_NOPS (arg1);
7480             }
7481         }
7482
7483       /* If we have A op B ? A : C, we may be able to convert this to a
7484          simpler expression, depending on the operation and the values
7485          of B and C.  Signed zeros prevent all of these transformations,
7486          for reasons given above each one.  */
7487
7488       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7489           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7490                                              arg1, TREE_OPERAND (arg0, 1))
7491           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
7492         {
7493           tree arg2 = TREE_OPERAND (t, 2);
7494           enum tree_code comp_code = TREE_CODE (arg0);
7495
7496           STRIP_NOPS (arg2);
7497
7498           /* If we have A op 0 ? A : -A, consider applying the following
7499              transformations:
7500
7501              A == 0? A : -A    same as -A
7502              A != 0? A : -A    same as A
7503              A >= 0? A : -A    same as abs (A)
7504              A > 0?  A : -A    same as abs (A)
7505              A <= 0? A : -A    same as -abs (A)
7506              A < 0?  A : -A    same as -abs (A)
7507
7508              None of these transformations work for modes with signed
7509              zeros.  If A is +/-0, the first two transformations will
7510              change the sign of the result (from +0 to -0, or vice
7511              versa).  The last four will fix the sign of the result,
7512              even though the original expressions could be positive or
7513              negative, depending on the sign of A.
7514
7515              Note that all these transformations are correct if A is
7516              NaN, since the two alternatives (A and -A) are also NaNs.  */
7517           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
7518                ? real_zerop (TREE_OPERAND (arg0, 1))
7519                : integer_zerop (TREE_OPERAND (arg0, 1)))
7520               && TREE_CODE (arg2) == NEGATE_EXPR
7521               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
7522             switch (comp_code)
7523               {
7524               case EQ_EXPR:
7525                 return
7526                   pedantic_non_lvalue
7527                     (convert (type,
7528                               negate_expr
7529                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
7530                                         arg1))));
7531               case NE_EXPR:
7532                 return pedantic_non_lvalue (convert (type, arg1));
7533               case GE_EXPR:
7534               case GT_EXPR:
7535                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7536                   arg1 = convert ((*lang_hooks.types.signed_type)
7537                                   (TREE_TYPE (arg1)), arg1);
7538                 return pedantic_non_lvalue
7539                   (convert (type, fold (build1 (ABS_EXPR,
7540                                                 TREE_TYPE (arg1), arg1))));
7541               case LE_EXPR:
7542               case LT_EXPR:
7543                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7544                   arg1 = convert ((lang_hooks.types.signed_type)
7545                                   (TREE_TYPE (arg1)), arg1);
7546                 return pedantic_non_lvalue
7547                   (negate_expr (convert (type,
7548                                          fold (build1 (ABS_EXPR,
7549                                                        TREE_TYPE (arg1),
7550                                                        arg1)))));
7551               default:
7552                 abort ();
7553               }
7554
7555           /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
7556              A == 0 ? A : 0 is always 0 unless A is -0.  Note that
7557              both transformations are correct when A is NaN: A != 0
7558              is then true, and A == 0 is false.  */
7559
7560           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
7561             {
7562               if (comp_code == NE_EXPR)
7563                 return pedantic_non_lvalue (convert (type, arg1));
7564               else if (comp_code == EQ_EXPR)
7565                 return pedantic_non_lvalue (convert (type, integer_zero_node));
7566             }
7567
7568           /* Try some transformations of A op B ? A : B.
7569
7570              A == B? A : B    same as B
7571              A != B? A : B    same as A
7572              A >= B? A : B    same as max (A, B)
7573              A > B?  A : B    same as max (B, A)
7574              A <= B? A : B    same as min (A, B)
7575              A < B?  A : B    same as min (B, A)
7576
7577              As above, these transformations don't work in the presence
7578              of signed zeros.  For example, if A and B are zeros of
7579              opposite sign, the first two transformations will change
7580              the sign of the result.  In the last four, the original
7581              expressions give different results for (A=+0, B=-0) and
7582              (A=-0, B=+0), but the transformed expressions do not.
7583
7584              The first two transformations are correct if either A or B
7585              is a NaN.  In the first transformation, the condition will
7586              be false, and B will indeed be chosen.  In the case of the
7587              second transformation, the condition A != B will be true,
7588              and A will be chosen.
7589
7590              The conversions to max() and min() are not correct if B is
7591              a number and A is not.  The conditions in the original
7592              expressions will be false, so all four give B.  The min()
7593              and max() versions would give a NaN instead.  */
7594           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
7595                                               arg2, TREE_OPERAND (arg0, 0)))
7596             {
7597               tree comp_op0 = TREE_OPERAND (arg0, 0);
7598               tree comp_op1 = TREE_OPERAND (arg0, 1);
7599               tree comp_type = TREE_TYPE (comp_op0);
7600
7601               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
7602               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
7603                 {
7604                   comp_type = type;
7605                   comp_op0 = arg1;
7606                   comp_op1 = arg2;
7607                 }
7608
7609               switch (comp_code)
7610                 {
7611                 case EQ_EXPR:
7612                   return pedantic_non_lvalue (convert (type, arg2));
7613                 case NE_EXPR:
7614                   return pedantic_non_lvalue (convert (type, arg1));
7615                 case LE_EXPR:
7616                 case LT_EXPR:
7617                   /* In C++ a ?: expression can be an lvalue, so put the
7618                      operand which will be used if they are equal first
7619                      so that we can convert this back to the
7620                      corresponding COND_EXPR.  */
7621                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
7622                     return pedantic_non_lvalue
7623                       (convert (type, fold (build (MIN_EXPR, comp_type,
7624                                                    (comp_code == LE_EXPR
7625                                                     ? comp_op0 : comp_op1),
7626                                                    (comp_code == LE_EXPR
7627                                                     ? comp_op1 : comp_op0)))));
7628                   break;
7629                 case GE_EXPR:
7630                 case GT_EXPR:
7631                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
7632                     return pedantic_non_lvalue
7633                       (convert (type, fold (build (MAX_EXPR, comp_type,
7634                                                    (comp_code == GE_EXPR
7635                                                     ? comp_op0 : comp_op1),
7636                                                    (comp_code == GE_EXPR
7637                                                     ? comp_op1 : comp_op0)))));
7638                   break;
7639                 default:
7640                   abort ();
7641                 }
7642             }
7643
7644           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
7645              we might still be able to simplify this.  For example,
7646              if C1 is one less or one more than C2, this might have started
7647              out as a MIN or MAX and been transformed by this function.
7648              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
7649
7650           if (INTEGRAL_TYPE_P (type)
7651               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7652               && TREE_CODE (arg2) == INTEGER_CST)
7653             switch (comp_code)
7654               {
7655               case EQ_EXPR:
7656                 /* We can replace A with C1 in this case.  */
7657                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
7658                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
7659                            TREE_OPERAND (t, 2));
7660                 break;
7661
7662               case LT_EXPR:
7663                 /* If C1 is C2 + 1, this is min(A, C2).  */
7664                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7665                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7666                                         const_binop (PLUS_EXPR, arg2,
7667                                                      integer_one_node, 0), 1))
7668                   return pedantic_non_lvalue
7669                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7670                 break;
7671
7672               case LE_EXPR:
7673                 /* If C1 is C2 - 1, this is min(A, C2).  */
7674                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7675                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7676                                         const_binop (MINUS_EXPR, arg2,
7677                                                      integer_one_node, 0), 1))
7678                   return pedantic_non_lvalue
7679                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7680                 break;
7681
7682               case GT_EXPR:
7683                 /* If C1 is C2 - 1, this is max(A, C2).  */
7684                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7685                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7686                                         const_binop (MINUS_EXPR, arg2,
7687                                                      integer_one_node, 0), 1))
7688                   return pedantic_non_lvalue
7689                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7690                 break;
7691
7692               case GE_EXPR:
7693                 /* If C1 is C2 + 1, this is max(A, C2).  */
7694                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7695                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7696                                         const_binop (PLUS_EXPR, arg2,
7697                                                      integer_one_node, 0), 1))
7698                   return pedantic_non_lvalue
7699                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7700                 break;
7701               case NE_EXPR:
7702                 break;
7703               default:
7704                 abort ();
7705               }
7706         }
7707
7708       /* If the second operand is simpler than the third, swap them
7709          since that produces better jump optimization results.  */
7710       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7711            || TREE_CODE (arg1) == SAVE_EXPR)
7712           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7713                 || DECL_P (TREE_OPERAND (t, 2))
7714                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7715         {
7716           /* See if this can be inverted.  If it can't, possibly because
7717              it was a floating-point inequality comparison, don't do
7718              anything.  */
7719           tem = invert_truthvalue (arg0);
7720
7721           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7722             {
7723               t = build (code, type, tem,
7724                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7725               arg0 = tem;
7726               /* arg1 should be the first argument of the new T.  */
7727               arg1 = TREE_OPERAND (t, 1);
7728               STRIP_NOPS (arg1);
7729             }
7730         }
7731
7732       /* Convert A ? 1 : 0 to simply A.  */
7733       if (integer_onep (TREE_OPERAND (t, 1))
7734           && integer_zerop (TREE_OPERAND (t, 2))
7735           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7736              call to fold will try to move the conversion inside
7737              a COND, which will recurse.  In that case, the COND_EXPR
7738              is probably the best choice, so leave it alone.  */
7739           && type == TREE_TYPE (arg0))
7740         return pedantic_non_lvalue (arg0);
7741
7742       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
7743          over COND_EXPR in cases such as floating point comparisons.  */
7744       if (integer_zerop (TREE_OPERAND (t, 1))
7745           && integer_onep (TREE_OPERAND (t, 2))
7746           && truth_value_p (TREE_CODE (arg0)))
7747         return pedantic_non_lvalue (convert (type,
7748                                              invert_truthvalue (arg0)));
7749
7750       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7751          operation is simply A & 2.  */
7752
7753       if (integer_zerop (TREE_OPERAND (t, 2))
7754           && TREE_CODE (arg0) == NE_EXPR
7755           && integer_zerop (TREE_OPERAND (arg0, 1))
7756           && integer_pow2p (arg1)
7757           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7758           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7759                               arg1, 1))
7760         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7761
7762       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
7763       if (integer_zerop (TREE_OPERAND (t, 2))
7764           && truth_value_p (TREE_CODE (arg0))
7765           && truth_value_p (TREE_CODE (arg1)))
7766         return pedantic_non_lvalue (fold (build (TRUTH_ANDIF_EXPR, type,
7767                                                  arg0, arg1)));
7768
7769       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
7770       if (integer_onep (TREE_OPERAND (t, 2))
7771           && truth_value_p (TREE_CODE (arg0))
7772           && truth_value_p (TREE_CODE (arg1)))
7773         {
7774           /* Only perform transformation if ARG0 is easily inverted.  */
7775           tem = invert_truthvalue (arg0);
7776           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7777             return pedantic_non_lvalue (fold (build (TRUTH_ORIF_EXPR, type,
7778                                                      tem, arg1)));
7779         }
7780
7781       return t;
7782
7783     case COMPOUND_EXPR:
7784       /* When pedantic, a compound expression can be neither an lvalue
7785          nor an integer constant expression.  */
7786       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7787         return t;
7788       /* Don't let (0, 0) be null pointer constant.  */
7789       if (integer_zerop (arg1))
7790         return build1 (NOP_EXPR, type, arg1);
7791       return convert (type, arg1);
7792
7793     case COMPLEX_EXPR:
7794       if (wins)
7795         return build_complex (type, arg0, arg1);
7796       return t;
7797
7798     case REALPART_EXPR:
7799       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7800         return t;
7801       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7802         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7803                                  TREE_OPERAND (arg0, 1));
7804       else if (TREE_CODE (arg0) == COMPLEX_CST)
7805         return TREE_REALPART (arg0);
7806       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7807         return fold (build (TREE_CODE (arg0), type,
7808                             fold (build1 (REALPART_EXPR, type,
7809                                           TREE_OPERAND (arg0, 0))),
7810                             fold (build1 (REALPART_EXPR,
7811                                           type, TREE_OPERAND (arg0, 1)))));
7812       return t;
7813
7814     case IMAGPART_EXPR:
7815       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7816         return convert (type, integer_zero_node);
7817       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7818         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7819                                  TREE_OPERAND (arg0, 0));
7820       else if (TREE_CODE (arg0) == COMPLEX_CST)
7821         return TREE_IMAGPART (arg0);
7822       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7823         return fold (build (TREE_CODE (arg0), type,
7824                             fold (build1 (IMAGPART_EXPR, type,
7825                                           TREE_OPERAND (arg0, 0))),
7826                             fold (build1 (IMAGPART_EXPR, type,
7827                                           TREE_OPERAND (arg0, 1)))));
7828       return t;
7829
7830       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7831          appropriate.  */
7832     case CLEANUP_POINT_EXPR:
7833       if (! has_cleanups (arg0))
7834         return TREE_OPERAND (t, 0);
7835
7836       {
7837         enum tree_code code0 = TREE_CODE (arg0);
7838         int kind0 = TREE_CODE_CLASS (code0);
7839         tree arg00 = TREE_OPERAND (arg0, 0);
7840         tree arg01;
7841
7842         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7843           return fold (build1 (code0, type,
7844                                fold (build1 (CLEANUP_POINT_EXPR,
7845                                              TREE_TYPE (arg00), arg00))));
7846
7847         if (kind0 == '<' || kind0 == '2'
7848             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7849             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7850             || code0 == TRUTH_XOR_EXPR)
7851           {
7852             arg01 = TREE_OPERAND (arg0, 1);
7853
7854             if (TREE_CONSTANT (arg00)
7855                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7856                     && ! has_cleanups (arg00)))
7857               return fold (build (code0, type, arg00,
7858                                   fold (build1 (CLEANUP_POINT_EXPR,
7859                                                 TREE_TYPE (arg01), arg01))));
7860
7861             if (TREE_CONSTANT (arg01))
7862               return fold (build (code0, type,
7863                                   fold (build1 (CLEANUP_POINT_EXPR,
7864                                                 TREE_TYPE (arg00), arg00)),
7865                                   arg01));
7866           }
7867
7868         return t;
7869       }
7870
7871     case CALL_EXPR:
7872       /* Check for a built-in function.  */
7873       if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
7874           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))
7875               == FUNCTION_DECL)
7876           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)))
7877         {
7878           tree tmp = fold_builtin (expr);
7879           if (tmp)
7880             return tmp;
7881         }
7882       return t;
7883
7884     default:
7885       return t;
7886     } /* switch (code) */
7887 }
7888
7889 /* Determine if first argument is a multiple of second argument.  Return 0 if
7890    it is not, or we cannot easily determined it to be.
7891
7892    An example of the sort of thing we care about (at this point; this routine
7893    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7894    fold cases do now) is discovering that
7895
7896      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7897
7898    is a multiple of
7899
7900      SAVE_EXPR (J * 8)
7901
7902    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7903
7904    This code also handles discovering that
7905
7906      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7907
7908    is a multiple of 8 so we don't have to worry about dealing with a
7909    possible remainder.
7910
7911    Note that we *look* inside a SAVE_EXPR only to determine how it was
7912    calculated; it is not safe for fold to do much of anything else with the
7913    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7914    at run time.  For example, the latter example above *cannot* be implemented
7915    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7916    evaluation time of the original SAVE_EXPR is not necessarily the same at
7917    the time the new expression is evaluated.  The only optimization of this
7918    sort that would be valid is changing
7919
7920      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7921
7922    divided by 8 to
7923
7924      SAVE_EXPR (I) * SAVE_EXPR (J)
7925
7926    (where the same SAVE_EXPR (J) is used in the original and the
7927    transformed version).  */
7928
7929 static int
7930 multiple_of_p (type, top, bottom)
7931      tree type;
7932      tree top;
7933      tree bottom;
7934 {
7935   if (operand_equal_p (top, bottom, 0))
7936     return 1;
7937
7938   if (TREE_CODE (type) != INTEGER_TYPE)
7939     return 0;
7940
7941   switch (TREE_CODE (top))
7942     {
7943     case MULT_EXPR:
7944       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7945               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7946
7947     case PLUS_EXPR:
7948     case MINUS_EXPR:
7949       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7950               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7951
7952     case LSHIFT_EXPR:
7953       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
7954         {
7955           tree op1, t1;
7956
7957           op1 = TREE_OPERAND (top, 1);
7958           /* const_binop may not detect overflow correctly,
7959              so check for it explicitly here.  */
7960           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
7961               > TREE_INT_CST_LOW (op1)
7962               && TREE_INT_CST_HIGH (op1) == 0
7963               && 0 != (t1 = convert (type,
7964                                      const_binop (LSHIFT_EXPR, size_one_node,
7965                                                   op1, 0)))
7966               && ! TREE_OVERFLOW (t1))
7967             return multiple_of_p (type, t1, bottom);
7968         }
7969       return 0;
7970
7971     case NOP_EXPR:
7972       /* Can't handle conversions from non-integral or wider integral type.  */
7973       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7974           || (TYPE_PRECISION (type)
7975               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7976         return 0;
7977
7978       /* .. fall through ...  */
7979
7980     case SAVE_EXPR:
7981       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7982
7983     case INTEGER_CST:
7984       if (TREE_CODE (bottom) != INTEGER_CST
7985           || (TREE_UNSIGNED (type)
7986               && (tree_int_cst_sgn (top) < 0
7987                   || tree_int_cst_sgn (bottom) < 0)))
7988         return 0;
7989       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7990                                          top, bottom, 0));
7991
7992     default:
7993       return 0;
7994     }
7995 }
7996
7997 /* Return true if `t' is known to be non-negative.  */
7998
7999 int
8000 tree_expr_nonnegative_p (t)
8001      tree t;
8002 {
8003   switch (TREE_CODE (t))
8004     {
8005     case ABS_EXPR:
8006     case FFS_EXPR:
8007     case POPCOUNT_EXPR:
8008     case PARITY_EXPR:
8009       return 1;
8010
8011     case CLZ_EXPR:
8012     case CTZ_EXPR:
8013       /* These are undefined at zero.  This is true even if
8014          C[LT]Z_DEFINED_VALUE_AT_ZERO is set, since what we're
8015          computing here is a user-visible property.  */
8016       return 0;
8017
8018     case INTEGER_CST:
8019       return tree_int_cst_sgn (t) >= 0;
8020     case TRUNC_DIV_EXPR:
8021     case CEIL_DIV_EXPR:
8022     case FLOOR_DIV_EXPR:
8023     case ROUND_DIV_EXPR:
8024       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
8025         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8026     case TRUNC_MOD_EXPR:
8027     case CEIL_MOD_EXPR:
8028     case FLOOR_MOD_EXPR:
8029     case ROUND_MOD_EXPR:
8030       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
8031     case COND_EXPR:
8032       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
8033         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
8034     case COMPOUND_EXPR:
8035       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8036     case MIN_EXPR:
8037       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
8038         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8039     case MAX_EXPR:
8040       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
8041         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8042     case MODIFY_EXPR:
8043       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8044     case BIND_EXPR:
8045       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
8046     case SAVE_EXPR:
8047       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
8048     case NON_LVALUE_EXPR:
8049       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
8050     case RTL_EXPR:
8051       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
8052
8053     case CALL_EXPR:
8054       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR)
8055         {
8056           tree fndecl = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
8057           tree arglist = TREE_OPERAND (t, 1);
8058           if (TREE_CODE (fndecl) == FUNCTION_DECL
8059               && DECL_BUILT_IN (fndecl)
8060               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD)
8061             switch (DECL_FUNCTION_CODE (fndecl))
8062               {
8063               case BUILT_IN_CABS:
8064               case BUILT_IN_CABSL:
8065               case BUILT_IN_CABSF:
8066               case BUILT_IN_EXP:
8067               case BUILT_IN_EXPF:
8068               case BUILT_IN_EXPL:
8069               case BUILT_IN_FABS:
8070               case BUILT_IN_FABSF:
8071               case BUILT_IN_FABSL:
8072               case BUILT_IN_SQRT:
8073               case BUILT_IN_SQRTF:
8074               case BUILT_IN_SQRTL:
8075                 return 1;
8076
8077               case BUILT_IN_ATAN:
8078               case BUILT_IN_ATANF:
8079               case BUILT_IN_ATANL:
8080                 return tree_expr_nonnegative_p (TREE_VALUE (arglist));
8081
8082               case BUILT_IN_POW:
8083               case BUILT_IN_POWF:
8084               case BUILT_IN_POWL:
8085                 return tree_expr_nonnegative_p (TREE_VALUE (arglist));
8086
8087               default:
8088                 break;
8089               }
8090         }
8091
8092       /* ... fall through ... */
8093
8094     default:
8095       if (truth_value_p (TREE_CODE (t)))
8096         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
8097         return 1;
8098       else
8099         /* We don't know sign of `t', so be conservative and return false.  */
8100         return 0;
8101     }
8102 }
8103
8104 /* Return true if `r' is known to be non-negative.
8105    Only handles constants at the moment.  */
8106
8107 int
8108 rtl_expr_nonnegative_p (r)
8109      rtx r;
8110 {
8111   switch (GET_CODE (r))
8112     {
8113     case CONST_INT:
8114       return INTVAL (r) >= 0;
8115
8116     case CONST_DOUBLE:
8117       if (GET_MODE (r) == VOIDmode)
8118         return CONST_DOUBLE_HIGH (r) >= 0;
8119       return 0;
8120
8121     case CONST_VECTOR:
8122       {
8123         int units, i;
8124         rtx elt;
8125
8126         units = CONST_VECTOR_NUNITS (r);
8127
8128         for (i = 0; i < units; ++i)
8129           {
8130             elt = CONST_VECTOR_ELT (r, i);
8131             if (!rtl_expr_nonnegative_p (elt))
8132               return 0;
8133           }
8134
8135         return 1;
8136       }
8137
8138     case SYMBOL_REF:
8139     case LABEL_REF:
8140       /* These are always nonnegative.  */
8141       return 1;
8142
8143     default:
8144       return 0;
8145     }
8146 }
8147
8148 #include "gt-fold-const.h"