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