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