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