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   tree linner, rinner = NULL_TREE;
3029   tree mask;
3030   tree offset;
3031
3032   /* Get all the information about the extractions being done.  If the bit size
3033      if the same as the size of the underlying object, we aren't doing an
3034      extraction at all and so can do nothing.  We also don't want to
3035      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3036      then will no longer be able to replace it.  */
3037   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3038                                 &lunsignedp, &lvolatilep);
3039   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3040       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3041     return 0;
3042
3043  if (!const_p)
3044    {
3045      /* If this is not a constant, we can only do something if bit positions,
3046         sizes, and signedness are the same.  */
3047      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3048                                    &runsignedp, &rvolatilep);
3049
3050      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3051          || lunsignedp != runsignedp || offset != 0
3052          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3053        return 0;
3054    }
3055
3056   /* See if we can find a mode to refer to this field.  We should be able to,
3057      but fail if we can't.  */
3058   nmode = get_best_mode (lbitsize, lbitpos,
3059                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3060                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3061                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3062                          word_mode, lvolatilep || rvolatilep);
3063   if (nmode == VOIDmode)
3064     return 0;
3065
3066   /* Set signed and unsigned types of the precision of this mode for the
3067      shifts below.  */
3068   signed_type = type_for_mode (nmode, 0);
3069   unsigned_type = type_for_mode (nmode, 1);
3070
3071   /* Compute the bit position and size for the new reference and our offset
3072      within it. If the new reference is the same size as the original, we
3073      won't optimize anything, so return zero.  */
3074   nbitsize = GET_MODE_BITSIZE (nmode);
3075   nbitpos = lbitpos & ~ (nbitsize - 1);
3076   lbitpos -= nbitpos;
3077   if (nbitsize == lbitsize)
3078     return 0;
3079
3080   if (BYTES_BIG_ENDIAN)
3081     lbitpos = nbitsize - lbitsize - lbitpos;
3082
3083   /* Make the mask to be used against the extracted field.  */
3084   mask = build_int_2 (~0, ~0);
3085   TREE_TYPE (mask) = unsigned_type;
3086   force_fit_type (mask, 0);
3087   mask = convert (unsigned_type, mask);
3088   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3089   mask = const_binop (RSHIFT_EXPR, mask,
3090                       size_int (nbitsize - lbitsize - lbitpos), 0);
3091
3092   if (! const_p)
3093     /* If not comparing with constant, just rework the comparison
3094        and return.  */
3095     return build (code, compare_type,
3096                   build (BIT_AND_EXPR, unsigned_type,
3097                          make_bit_field_ref (linner, unsigned_type,
3098                                              nbitsize, nbitpos, 1),
3099                          mask),
3100                   build (BIT_AND_EXPR, unsigned_type,
3101                          make_bit_field_ref (rinner, unsigned_type,
3102                                              nbitsize, nbitpos, 1),
3103                          mask));
3104
3105   /* Otherwise, we are handling the constant case. See if the constant is too
3106      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3107      this not only for its own sake, but to avoid having to test for this
3108      error case below.  If we didn't, we might generate wrong code.
3109
3110      For unsigned fields, the constant shifted right by the field length should
3111      be all zero.  For signed fields, the high-order bits should agree with
3112      the sign bit.  */
3113
3114   if (lunsignedp)
3115     {
3116       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3117                                         convert (unsigned_type, rhs),
3118                                         size_int (lbitsize), 0)))
3119         {
3120           warning ("comparison is always %d due to width of bitfield",
3121                    code == NE_EXPR);
3122           return convert (compare_type,
3123                           (code == NE_EXPR
3124                            ? integer_one_node : integer_zero_node));
3125         }
3126     }
3127   else
3128     {
3129       tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
3130                               size_int (lbitsize - 1), 0);
3131       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3132         {
3133           warning ("comparison is always %d due to width of bitfield",
3134                    code == NE_EXPR);
3135           return convert (compare_type,
3136                           (code == NE_EXPR
3137                            ? integer_one_node : integer_zero_node));
3138         }
3139     }
3140
3141   /* Single-bit compares should always be against zero.  */
3142   if (lbitsize == 1 && ! integer_zerop (rhs))
3143     {
3144       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3145       rhs = convert (type, integer_zero_node);
3146     }
3147
3148   /* Make a new bitfield reference, shift the constant over the
3149      appropriate number of bits and mask it with the computed mask
3150      (in case this was a signed field).  If we changed it, make a new one.  */
3151   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3152   if (lvolatilep)
3153     {
3154       TREE_SIDE_EFFECTS (lhs) = 1;
3155       TREE_THIS_VOLATILE (lhs) = 1;
3156     }
3157
3158   rhs = fold (const_binop (BIT_AND_EXPR,
3159                            const_binop (LSHIFT_EXPR,
3160                                         convert (unsigned_type, rhs),
3161                                         size_int (lbitpos), 0),
3162                            mask, 0));
3163
3164   return build (code, compare_type,
3165                 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
3166                 rhs);
3167 }
3168 \f
3169 /* Subroutine for fold_truthop: decode a field reference.
3170
3171    If EXP is a comparison reference, we return the innermost reference.
3172
3173    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3174    set to the starting bit number.
3175
3176    If the innermost field can be completely contained in a mode-sized
3177    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3178
3179    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3180    otherwise it is not changed.
3181
3182    *PUNSIGNEDP is set to the signedness of the field.
3183
3184    *PMASK is set to the mask used.  This is either contained in a
3185    BIT_AND_EXPR or derived from the width of the field.
3186
3187    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3188
3189    Return 0 if this is not a component reference or is one that we can't
3190    do anything with.  */
3191
3192 static tree
3193 decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
3194                         pvolatilep, pmask, pand_mask)
3195      tree exp;
3196      HOST_WIDE_INT *pbitsize, *pbitpos;
3197      enum machine_mode *pmode;
3198      int *punsignedp, *pvolatilep;
3199      tree *pmask;
3200      tree *pand_mask;
3201 {
3202   tree and_mask = 0;
3203   tree mask, inner, offset;
3204   tree unsigned_type;
3205   unsigned int precision;
3206
3207   /* All the optimizations using this function assume integer fields.
3208      There are problems with FP fields since the type_for_size call
3209      below can fail for, e.g., XFmode.  */
3210   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3211     return 0;
3212
3213   STRIP_NOPS (exp);
3214
3215   if (TREE_CODE (exp) == BIT_AND_EXPR)
3216     {
3217       and_mask = TREE_OPERAND (exp, 1);
3218       exp = TREE_OPERAND (exp, 0);
3219       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3220       if (TREE_CODE (and_mask) != INTEGER_CST)
3221         return 0;
3222     }
3223
3224   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3225                                punsignedp, pvolatilep);
3226   if ((inner == exp && and_mask == 0)
3227       || *pbitsize < 0 || offset != 0
3228       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3229     return 0;
3230
3231   /* Compute the mask to access the bitfield.  */
3232   unsigned_type = type_for_size (*pbitsize, 1);
3233   precision = TYPE_PRECISION (unsigned_type);
3234
3235   mask = build_int_2 (~0, ~0);
3236   TREE_TYPE (mask) = unsigned_type;
3237   force_fit_type (mask, 0);
3238   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3239   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3240
3241   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3242   if (and_mask != 0)
3243     mask = fold (build (BIT_AND_EXPR, unsigned_type,
3244                         convert (unsigned_type, and_mask), mask));
3245
3246   *pmask = mask;
3247   *pand_mask = and_mask;
3248   return inner;
3249 }
3250
3251 /* Return non-zero if MASK represents a mask of SIZE ones in the low-order
3252    bit positions.  */
3253
3254 static int
3255 all_ones_mask_p (mask, size)
3256      tree mask;
3257      int size;
3258 {
3259   tree type = TREE_TYPE (mask);
3260   unsigned int precision = TYPE_PRECISION (type);
3261   tree tmask;
3262
3263   tmask = build_int_2 (~0, ~0);
3264   TREE_TYPE (tmask) = signed_type (type);
3265   force_fit_type (tmask, 0);
3266   return
3267     tree_int_cst_equal (mask,
3268                         const_binop (RSHIFT_EXPR,
3269                                      const_binop (LSHIFT_EXPR, tmask,
3270                                                   size_int (precision - size),
3271                                                   0),
3272                                      size_int (precision - size), 0));
3273 }
3274
3275 /* Subroutine for fold_truthop: determine if an operand is simple enough
3276    to be evaluated unconditionally.  */
3277
3278 static int
3279 simple_operand_p (exp)
3280      tree exp;
3281 {
3282   /* Strip any conversions that don't change the machine mode.  */
3283   while ((TREE_CODE (exp) == NOP_EXPR
3284           || TREE_CODE (exp) == CONVERT_EXPR)
3285          && (TYPE_MODE (TREE_TYPE (exp))
3286              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
3287     exp = TREE_OPERAND (exp, 0);
3288
3289   return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
3290           || (DECL_P (exp)
3291               && ! TREE_ADDRESSABLE (exp)
3292               && ! TREE_THIS_VOLATILE (exp)
3293               && ! DECL_NONLOCAL (exp)
3294               /* Don't regard global variables as simple.  They may be
3295                  allocated in ways unknown to the compiler (shared memory,
3296                  #pragma weak, etc).  */
3297               && ! TREE_PUBLIC (exp)
3298               && ! DECL_EXTERNAL (exp)
3299               /* Loading a static variable is unduly expensive, but global
3300                  registers aren't expensive.  */
3301               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3302 }
3303 \f
3304 /* The following functions are subroutines to fold_range_test and allow it to
3305    try to change a logical combination of comparisons into a range test.
3306
3307    For example, both
3308         X == 2 || X == 3 || X == 4 || X == 5
3309    and
3310         X >= 2 && X <= 5
3311    are converted to
3312         (unsigned) (X - 2) <= 3
3313
3314    We describe each set of comparisons as being either inside or outside
3315    a range, using a variable named like IN_P, and then describe the
3316    range with a lower and upper bound.  If one of the bounds is omitted,
3317    it represents either the highest or lowest value of the type.
3318
3319    In the comments below, we represent a range by two numbers in brackets
3320    preceded by a "+" to designate being inside that range, or a "-" to
3321    designate being outside that range, so the condition can be inverted by
3322    flipping the prefix.  An omitted bound is represented by a "-".  For
3323    example, "- [-, 10]" means being outside the range starting at the lowest
3324    possible value and ending at 10, in other words, being greater than 10.
3325    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3326    always false.
3327
3328    We set up things so that the missing bounds are handled in a consistent
3329    manner so neither a missing bound nor "true" and "false" need to be
3330    handled using a special case.  */
3331
3332 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3333    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3334    and UPPER1_P are nonzero if the respective argument is an upper bound
3335    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3336    must be specified for a comparison.  ARG1 will be converted to ARG0's
3337    type if both are specified.  */
3338
3339 static tree
3340 range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
3341      enum tree_code code;
3342      tree type;
3343      tree arg0, arg1;
3344      int upper0_p, upper1_p;
3345 {
3346   tree tem;
3347   int result;
3348   int sgn0, sgn1;
3349
3350   /* If neither arg represents infinity, do the normal operation.
3351      Else, if not a comparison, return infinity.  Else handle the special
3352      comparison rules. Note that most of the cases below won't occur, but
3353      are handled for consistency.  */
3354
3355   if (arg0 != 0 && arg1 != 0)
3356     {
3357       tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
3358                          arg0, convert (TREE_TYPE (arg0), arg1)));
3359       STRIP_NOPS (tem);
3360       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3361     }
3362
3363   if (TREE_CODE_CLASS (code) != '<')
3364     return 0;
3365
3366   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3367      for neither.  In real maths, we cannot assume open ended ranges are
3368      the same. But, this is computer arithmetic, where numbers are finite.
3369      We can therefore make the transformation of any unbounded range with
3370      the value Z, Z being greater than any representable number. This permits
3371      us to treat unbounded ranges as equal.  */
3372   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3373   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3374   switch (code)
3375     {
3376     case EQ_EXPR:
3377       result = sgn0 == sgn1;
3378       break;
3379     case NE_EXPR:
3380       result = sgn0 != sgn1;
3381       break;
3382     case LT_EXPR:
3383       result = sgn0 < sgn1;
3384       break;
3385     case LE_EXPR:
3386       result = sgn0 <= sgn1;
3387       break;
3388     case GT_EXPR:
3389       result = sgn0 > sgn1;
3390       break;
3391     case GE_EXPR:
3392       result = sgn0 >= sgn1;
3393       break;
3394     default:
3395       abort ();
3396     }
3397
3398   return convert (type, result ? integer_one_node : integer_zero_node);
3399 }
3400 \f
3401 /* Given EXP, a logical expression, set the range it is testing into
3402    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3403    actually being tested.  *PLOW and *PHIGH will be made of the same type
3404    as the returned expression.  If EXP is not a comparison, we will most
3405    likely not be returning a useful value and range.  */
3406
3407 static tree
3408 make_range (exp, pin_p, plow, phigh)
3409      tree exp;
3410      int *pin_p;
3411      tree *plow, *phigh;
3412 {
3413   enum tree_code code;
3414   tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
3415   tree orig_type = NULL_TREE;
3416   int in_p, n_in_p;
3417   tree low, high, n_low, n_high;
3418
3419   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3420      and see if we can refine the range.  Some of the cases below may not
3421      happen, but it doesn't seem worth worrying about this.  We "continue"
3422      the outer loop when we've changed something; otherwise we "break"
3423      the switch, which will "break" the while.  */
3424
3425   in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
3426
3427   while (1)
3428     {
3429       code = TREE_CODE (exp);
3430
3431       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3432         {
3433           arg0 = TREE_OPERAND (exp, 0);
3434           if (TREE_CODE_CLASS (code) == '<'
3435               || TREE_CODE_CLASS (code) == '1'
3436               || TREE_CODE_CLASS (code) == '2')
3437             type = TREE_TYPE (arg0);
3438           if (TREE_CODE_CLASS (code) == '2'
3439               || TREE_CODE_CLASS (code) == '<'
3440               || (TREE_CODE_CLASS (code) == 'e'
3441                   && TREE_CODE_LENGTH (code) > 1))
3442             arg1 = TREE_OPERAND (exp, 1);
3443         }
3444
3445       /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
3446          lose a cast by accident.  */
3447       if (type != NULL_TREE && orig_type == NULL_TREE)
3448         orig_type = type;
3449
3450       switch (code)
3451         {
3452         case TRUTH_NOT_EXPR:
3453           in_p = ! in_p, exp = arg0;
3454           continue;
3455
3456         case EQ_EXPR: case NE_EXPR:
3457         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3458           /* We can only do something if the range is testing for zero
3459              and if the second operand is an integer constant.  Note that
3460              saying something is "in" the range we make is done by
3461              complementing IN_P since it will set in the initial case of
3462              being not equal to zero; "out" is leaving it alone.  */
3463           if (low == 0 || high == 0
3464               || ! integer_zerop (low) || ! integer_zerop (high)
3465               || TREE_CODE (arg1) != INTEGER_CST)
3466             break;
3467
3468           switch (code)
3469             {
3470             case NE_EXPR:  /* - [c, c]  */
3471               low = high = arg1;
3472               break;
3473             case EQ_EXPR:  /* + [c, c]  */
3474               in_p = ! in_p, low = high = arg1;
3475               break;
3476             case GT_EXPR:  /* - [-, c] */
3477               low = 0, high = arg1;
3478               break;
3479             case GE_EXPR:  /* + [c, -] */
3480               in_p = ! in_p, low = arg1, high = 0;
3481               break;
3482             case LT_EXPR:  /* - [c, -] */
3483               low = arg1, high = 0;
3484               break;
3485             case LE_EXPR:  /* + [-, c] */
3486               in_p = ! in_p, low = 0, high = arg1;
3487               break;
3488             default:
3489               abort ();
3490             }
3491
3492           exp = arg0;
3493
3494           /* If this is an unsigned comparison, we also know that EXP is
3495              greater than or equal to zero.  We base the range tests we make
3496              on that fact, so we record it here so we can parse existing
3497              range tests.  */
3498           if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
3499             {
3500               if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3501                                   1, convert (type, integer_zero_node),
3502                                   NULL_TREE))
3503                 break;
3504
3505               in_p = n_in_p, low = n_low, high = n_high;
3506
3507               /* If the high bound is missing, but we
3508                  have a low bound, reverse the range so
3509                  it goes from zero to the low bound minus 1.  */
3510               if (high == 0 && low)
3511                 {
3512                   in_p = ! in_p;
3513                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3514                                       integer_one_node, 0);
3515                   low = convert (type, integer_zero_node);
3516                 }
3517             }
3518           continue;
3519
3520         case NEGATE_EXPR:
3521           /* (-x) IN [a,b] -> x in [-b, -a]  */
3522           n_low = range_binop (MINUS_EXPR, type,
3523                                convert (type, integer_zero_node), 0, high, 1);
3524           n_high = range_binop (MINUS_EXPR, type,
3525                                 convert (type, integer_zero_node), 0, low, 0);
3526           low = n_low, high = n_high;
3527           exp = arg0;
3528           continue;
3529
3530         case BIT_NOT_EXPR:
3531           /* ~ X -> -X - 1  */
3532           exp = build (MINUS_EXPR, type, negate_expr (arg0),
3533                        convert (type, integer_one_node));
3534           continue;
3535
3536         case PLUS_EXPR:  case MINUS_EXPR:
3537           if (TREE_CODE (arg1) != INTEGER_CST)
3538             break;
3539
3540           /* If EXP is signed, any overflow in the computation is undefined,
3541              so we don't worry about it so long as our computations on
3542              the bounds don't overflow.  For unsigned, overflow is defined
3543              and this is exactly the right thing.  */
3544           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3545                                type, low, 0, arg1, 0);
3546           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3547                                 type, high, 1, arg1, 0);
3548           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3549               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3550             break;
3551
3552           /* Check for an unsigned range which has wrapped around the maximum
3553              value thus making n_high < n_low, and normalize it.  */
3554           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3555             {
3556               low = range_binop (PLUS_EXPR, type, n_high, 0,
3557                                  integer_one_node, 0);
3558               high = range_binop (MINUS_EXPR, type, n_low, 0,
3559                                   integer_one_node, 0);
3560
3561               /* If the range is of the form +/- [ x+1, x ], we won't
3562                  be able to normalize it.  But then, it represents the
3563                  whole range or the empty set, so make it
3564                  +/- [ -, - ].  */
3565               if (tree_int_cst_equal (n_low, low)
3566                   && tree_int_cst_equal (n_high, high))
3567                 low = high = 0;
3568               else
3569                 in_p = ! in_p;
3570             }
3571           else
3572             low = n_low, high = n_high;
3573
3574           exp = arg0;
3575           continue;
3576
3577         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3578           if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3579             break;
3580
3581           if (! INTEGRAL_TYPE_P (type)
3582               || (low != 0 && ! int_fits_type_p (low, type))
3583               || (high != 0 && ! int_fits_type_p (high, type)))
3584             break;
3585
3586           n_low = low, n_high = high;
3587
3588           if (n_low != 0)
3589             n_low = convert (type, n_low);
3590
3591           if (n_high != 0)
3592             n_high = convert (type, n_high);
3593
3594           /* If we're converting from an unsigned to a signed type,
3595              we will be doing the comparison as unsigned.  The tests above
3596              have already verified that LOW and HIGH are both positive.
3597
3598              So we have to make sure that the original unsigned value will
3599              be interpreted as positive.  */
3600           if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3601             {
3602               tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
3603               tree high_positive;
3604
3605               /* A range without an upper bound is, naturally, unbounded.
3606                  Since convert would have cropped a very large value, use
3607                  the max value for the destination type.  */
3608               high_positive
3609                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3610                   : TYPE_MAX_VALUE (type);
3611
3612               high_positive = fold (build (RSHIFT_EXPR, type,
3613                                            convert (type, high_positive),
3614                                            convert (type, integer_one_node)));
3615
3616               /* If the low bound is specified, "and" the range with the
3617                  range for which the original unsigned value will be
3618                  positive.  */
3619               if (low != 0)
3620                 {
3621                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3622                                       1, n_low, n_high,
3623                                       1, convert (type, integer_zero_node),
3624                                       high_positive))
3625                     break;
3626
3627                   in_p = (n_in_p == in_p);
3628                 }
3629               else
3630                 {
3631                   /* Otherwise, "or" the range with the range of the input
3632                      that will be interpreted as negative.  */
3633                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
3634                                       0, n_low, n_high,
3635                                       1, convert (type, integer_zero_node),
3636                                       high_positive))
3637                     break;
3638
3639                   in_p = (in_p != n_in_p);
3640                 }
3641             }
3642
3643           exp = arg0;
3644           low = n_low, high = n_high;
3645           continue;
3646
3647         default:
3648           break;
3649         }
3650
3651       break;
3652     }
3653
3654   /* If EXP is a constant, we can evaluate whether this is true or false.  */
3655   if (TREE_CODE (exp) == INTEGER_CST)
3656     {
3657       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3658                                                  exp, 0, low, 0))
3659                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
3660                                                     exp, 1, high, 1)));
3661       low = high = 0;
3662       exp = 0;
3663     }
3664
3665   *pin_p = in_p, *plow = low, *phigh = high;
3666   return exp;
3667 }
3668 \f
3669 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3670    type, TYPE, return an expression to test if EXP is in (or out of, depending
3671    on IN_P) the range.  */
3672
3673 static tree
3674 build_range_check (type, exp, in_p, low, high)
3675      tree type;
3676      tree exp;
3677      int in_p;
3678      tree low, high;
3679 {
3680   tree etype = TREE_TYPE (exp);
3681   tree utype, value;
3682
3683   if (! in_p
3684       && (0 != (value = build_range_check (type, exp, 1, low, high))))
3685     return invert_truthvalue (value);
3686
3687   else if (low == 0 && high == 0)
3688     return convert (type, integer_one_node);
3689
3690   else if (low == 0)
3691     return fold (build (LE_EXPR, type, exp, high));
3692
3693   else if (high == 0)
3694     return fold (build (GE_EXPR, type, exp, low));
3695
3696   else if (operand_equal_p (low, high, 0))
3697     return fold (build (EQ_EXPR, type, exp, low));
3698
3699   else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3700     return build_range_check (type, exp, 1, 0, high);
3701
3702   else if (integer_zerop (low))
3703     {
3704       utype = unsigned_type (etype);
3705       return build_range_check (type, convert (utype, exp), 1, 0,
3706                                 convert (utype, high));
3707     }
3708
3709   else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3710            && ! TREE_OVERFLOW (value))
3711     return build_range_check (type,
3712                               fold (build (MINUS_EXPR, etype, exp, low)),
3713                               1, convert (etype, integer_zero_node), value);
3714   else
3715     return 0;
3716 }
3717 \f
3718 /* Given two ranges, see if we can merge them into one.  Return 1 if we
3719    can, 0 if we can't.  Set the output range into the specified parameters.  */
3720
3721 static int
3722 merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3723      int *pin_p;
3724      tree *plow, *phigh;
3725      int in0_p, in1_p;
3726      tree low0, high0, low1, high1;
3727 {
3728   int no_overlap;
3729   int subset;
3730   int temp;
3731   tree tem;
3732   int in_p;
3733   tree low, high;
3734   int lowequal = ((low0 == 0 && low1 == 0)
3735                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3736                                                 low0, 0, low1, 0)));
3737   int highequal = ((high0 == 0 && high1 == 0)
3738                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3739                                                  high0, 1, high1, 1)));
3740
3741   /* Make range 0 be the range that starts first, or ends last if they
3742      start at the same value.  Swap them if it isn't.  */
3743   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3744                                  low0, 0, low1, 0))
3745       || (lowequal
3746           && integer_onep (range_binop (GT_EXPR, integer_type_node,
3747                                         high1, 1, high0, 1))))
3748     {
3749       temp = in0_p, in0_p = in1_p, in1_p = temp;
3750       tem = low0, low0 = low1, low1 = tem;
3751       tem = high0, high0 = high1, high1 = tem;
3752     }
3753
3754   /* Now flag two cases, whether the ranges are disjoint or whether the
3755      second range is totally subsumed in the first.  Note that the tests
3756      below are simplified by the ones above.  */
3757   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3758                                           high0, 1, low1, 0));
3759   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3760                                       high1, 1, high0, 1));
3761
3762   /* We now have four cases, depending on whether we are including or
3763      excluding the two ranges.  */
3764   if (in0_p && in1_p)
3765     {
3766       /* If they don't overlap, the result is false.  If the second range
3767          is a subset it is the result.  Otherwise, the range is from the start
3768          of the second to the end of the first.  */
3769       if (no_overlap)
3770         in_p = 0, low = high = 0;
3771       else if (subset)
3772         in_p = 1, low = low1, high = high1;
3773       else
3774         in_p = 1, low = low1, high = high0;
3775     }
3776
3777   else if (in0_p && ! in1_p)
3778     {
3779       /* If they don't overlap, the result is the first range.  If they are
3780          equal, the result is false.  If the second range is a subset of the
3781          first, and the ranges begin at the same place, we go from just after
3782          the end of the first range to the end of the second.  If the second
3783          range is not a subset of the first, or if it is a subset and both
3784          ranges end at the same place, the range starts at the start of the
3785          first range and ends just before the second range.
3786          Otherwise, we can't describe this as a single range.  */
3787       if (no_overlap)
3788         in_p = 1, low = low0, high = high0;
3789       else if (lowequal && highequal)
3790         in_p = 0, low = high = 0;
3791       else if (subset && lowequal)
3792         {
3793           in_p = 1, high = high0;
3794           low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3795                              integer_one_node, 0);
3796         }
3797       else if (! subset || highequal)
3798         {
3799           in_p = 1, low = low0;
3800           high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3801                               integer_one_node, 0);
3802         }
3803       else
3804         return 0;
3805     }
3806
3807   else if (! in0_p && in1_p)
3808     {
3809       /* If they don't overlap, the result is the second range.  If the second
3810          is a subset of the first, the result is false.  Otherwise,
3811          the range starts just after the first range and ends at the
3812          end of the second.  */
3813       if (no_overlap)
3814         in_p = 1, low = low1, high = high1;
3815       else if (subset || highequal)
3816         in_p = 0, low = high = 0;
3817       else
3818         {
3819           in_p = 1, high = high1;
3820           low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3821                              integer_one_node, 0);
3822         }
3823     }
3824
3825   else
3826     {
3827       /* The case where we are excluding both ranges.  Here the complex case
3828          is if they don't overlap.  In that case, the only time we have a
3829          range is if they are adjacent.  If the second is a subset of the
3830          first, the result is the first.  Otherwise, the range to exclude
3831          starts at the beginning of the first range and ends at the end of the
3832          second.  */
3833       if (no_overlap)
3834         {
3835           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3836                                          range_binop (PLUS_EXPR, NULL_TREE,
3837                                                       high0, 1,
3838                                                       integer_one_node, 1),
3839                                          1, low1, 0)))
3840             in_p = 0, low = low0, high = high1;
3841           else
3842             return 0;
3843         }
3844       else if (subset)
3845         in_p = 0, low = low0, high = high0;
3846       else
3847         in_p = 0, low = low0, high = high1;
3848     }
3849
3850   *pin_p = in_p, *plow = low, *phigh = high;
3851   return 1;
3852 }
3853 \f
3854 /* EXP is some logical combination of boolean tests.  See if we can
3855    merge it into some range test.  Return the new tree if so.  */
3856
3857 static tree
3858 fold_range_test (exp)
3859      tree exp;
3860 {
3861   int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3862                || TREE_CODE (exp) == TRUTH_OR_EXPR);
3863   int in0_p, in1_p, in_p;
3864   tree low0, low1, low, high0, high1, high;
3865   tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3866   tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3867   tree tem;
3868
3869   /* If this is an OR operation, invert both sides; we will invert
3870      again at the end.  */
3871   if (or_op)
3872     in0_p = ! in0_p, in1_p = ! in1_p;
3873
3874   /* If both expressions are the same, if we can merge the ranges, and we
3875      can build the range test, return it or it inverted.  If one of the
3876      ranges is always true or always false, consider it to be the same
3877      expression as the other.  */
3878   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3879       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3880                        in1_p, low1, high1)
3881       && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3882                                          lhs != 0 ? lhs
3883                                          : rhs != 0 ? rhs : integer_zero_node,
3884                                          in_p, low, high))))
3885     return or_op ? invert_truthvalue (tem) : tem;
3886
3887   /* On machines where the branch cost is expensive, if this is a
3888      short-circuited branch and the underlying object on both sides
3889      is the same, make a non-short-circuit operation.  */
3890   else if (BRANCH_COST >= 2
3891            && lhs != 0 && rhs != 0
3892            && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3893                || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3894            && operand_equal_p (lhs, rhs, 0))
3895     {
3896       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
3897          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3898          which cases we can't do this.  */
3899       if (simple_operand_p (lhs))
3900         return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3901                       ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3902                       TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3903                       TREE_OPERAND (exp, 1));
3904
3905       else if (global_bindings_p () == 0
3906                && ! contains_placeholder_p (lhs))
3907         {
3908           tree common = save_expr (lhs);
3909
3910           if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3911                                              or_op ? ! in0_p : in0_p,
3912                                              low0, high0))
3913               && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3914                                                  or_op ? ! in1_p : in1_p,
3915                                                  low1, high1))))
3916             return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3917                           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3918                           TREE_TYPE (exp), lhs, rhs);
3919         }
3920     }
3921
3922   return 0;
3923 }
3924 \f
3925 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3926    bit value.  Arrange things so the extra bits will be set to zero if and
3927    only if C is signed-extended to its full width.  If MASK is nonzero,
3928    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
3929
3930 static tree
3931 unextend (c, p, unsignedp, mask)
3932      tree c;
3933      int p;
3934      int unsignedp;
3935      tree mask;
3936 {
3937   tree type = TREE_TYPE (c);
3938   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3939   tree temp;
3940
3941   if (p == modesize || unsignedp)
3942     return c;
3943
3944   /* We work by getting just the sign bit into the low-order bit, then
3945      into the high-order bit, then sign-extend.  We then XOR that value
3946      with C.  */
3947   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3948   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3949
3950   /* We must use a signed type in order to get an arithmetic right shift.
3951      However, we must also avoid introducing accidental overflows, so that
3952      a subsequent call to integer_zerop will work.  Hence we must
3953      do the type conversion here.  At this point, the constant is either
3954      zero or one, and the conversion to a signed type can never overflow.
3955      We could get an overflow if this conversion is done anywhere else.  */
3956   if (TREE_UNSIGNED (type))
3957     temp = convert (signed_type (type), temp);
3958
3959   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3960   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3961   if (mask != 0)
3962     temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3963   /* If necessary, convert the type back to match the type of C.  */
3964   if (TREE_UNSIGNED (type))
3965     temp = convert (type, temp);
3966
3967   return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3968 }
3969 \f
3970 /* Find ways of folding logical expressions of LHS and RHS:
3971    Try to merge two comparisons to the same innermost item.
3972    Look for range tests like "ch >= '0' && ch <= '9'".
3973    Look for combinations of simple terms on machines with expensive branches
3974    and evaluate the RHS unconditionally.
3975
3976    For example, if we have p->a == 2 && p->b == 4 and we can make an
3977    object large enough to span both A and B, we can do this with a comparison
3978    against the object ANDed with the a mask.
3979
3980    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3981    operations to do this with one comparison.
3982
3983    We check for both normal comparisons and the BIT_AND_EXPRs made this by
3984    function and the one above.
3985
3986    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
3987    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3988
3989    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3990    two operands.
3991
3992    We return the simplified tree or 0 if no optimization is possible.  */
3993
3994 static tree
3995 fold_truthop (code, truth_type, lhs, rhs)
3996      enum tree_code code;
3997      tree truth_type, lhs, rhs;
3998 {
3999   /* If this is the "or" of two comparisons, we can do something if
4000      the comparisons are NE_EXPR.  If this is the "and", we can do something
4001      if the comparisons are EQ_EXPR.  I.e.,
4002         (a->b == 2 && a->c == 4) can become (a->new == NEW).
4003
4004      WANTED_CODE is this operation code.  For single bit fields, we can
4005      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
4006      comparison for one-bit fields.  */
4007
4008   enum tree_code wanted_code;
4009   enum tree_code lcode, rcode;
4010   tree ll_arg, lr_arg, rl_arg, rr_arg;
4011   tree ll_inner, lr_inner, rl_inner, rr_inner;
4012   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
4013   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
4014   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
4015   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
4016   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
4017   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
4018   enum machine_mode lnmode, rnmode;
4019   tree ll_mask, lr_mask, rl_mask, rr_mask;
4020   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
4021   tree l_const, r_const;
4022   tree lntype, rntype, result;
4023   int first_bit, end_bit;
4024   int volatilep;
4025
4026   /* Start by getting the comparison codes.  Fail if anything is volatile.
4027      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
4028      it were surrounded with a NE_EXPR.  */
4029
4030   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
4031     return 0;
4032
4033   lcode = TREE_CODE (lhs);
4034   rcode = TREE_CODE (rhs);
4035
4036   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
4037     lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
4038
4039   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
4040     rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
4041
4042   if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
4043     return 0;
4044
4045   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
4046           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
4047
4048   ll_arg = TREE_OPERAND (lhs, 0);
4049   lr_arg = TREE_OPERAND (lhs, 1);
4050   rl_arg = TREE_OPERAND (rhs, 0);
4051   rr_arg = TREE_OPERAND (rhs, 1);
4052
4053   /* If the RHS can be evaluated unconditionally and its operands are
4054      simple, it wins to evaluate the RHS unconditionally on machines
4055      with expensive branches.  In this case, this isn't a comparison
4056      that can be merged.  Avoid doing this if the RHS is a floating-point
4057      comparison since those can trap.  */
4058
4059   if (BRANCH_COST >= 2
4060       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
4061       && simple_operand_p (rl_arg)
4062       && simple_operand_p (rr_arg))
4063     return build (code, truth_type, lhs, rhs);
4064
4065   /* See if the comparisons can be merged.  Then get all the parameters for
4066      each side.  */
4067
4068   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
4069       || (rcode != EQ_EXPR && rcode != NE_EXPR))
4070     return 0;
4071
4072   volatilep = 0;
4073   ll_inner = decode_field_reference (ll_arg,
4074                                      &ll_bitsize, &ll_bitpos, &ll_mode,
4075                                      &ll_unsignedp, &volatilep, &ll_mask,
4076                                      &ll_and_mask);
4077   lr_inner = decode_field_reference (lr_arg,
4078                                      &lr_bitsize, &lr_bitpos, &lr_mode,
4079                                      &lr_unsignedp, &volatilep, &lr_mask,
4080                                      &lr_and_mask);
4081   rl_inner = decode_field_reference (rl_arg,
4082                                      &rl_bitsize, &rl_bitpos, &rl_mode,
4083                                      &rl_unsignedp, &volatilep, &rl_mask,
4084                                      &rl_and_mask);
4085   rr_inner = decode_field_reference (rr_arg,
4086                                      &rr_bitsize, &rr_bitpos, &rr_mode,
4087                                      &rr_unsignedp, &volatilep, &rr_mask,
4088                                      &rr_and_mask);
4089
4090   /* It must be true that the inner operation on the lhs of each
4091      comparison must be the same if we are to be able to do anything.
4092      Then see if we have constants.  If not, the same must be true for
4093      the rhs's.  */
4094   if (volatilep || ll_inner == 0 || rl_inner == 0
4095       || ! operand_equal_p (ll_inner, rl_inner, 0))
4096     return 0;
4097
4098   if (TREE_CODE (lr_arg) == INTEGER_CST
4099       && TREE_CODE (rr_arg) == INTEGER_CST)
4100     l_const = lr_arg, r_const = rr_arg;
4101   else if (lr_inner == 0 || rr_inner == 0
4102            || ! operand_equal_p (lr_inner, rr_inner, 0))
4103     return 0;
4104   else
4105     l_const = r_const = 0;
4106
4107   /* If either comparison code is not correct for our logical operation,
4108      fail.  However, we can convert a one-bit comparison against zero into
4109      the opposite comparison against that bit being set in the field.  */
4110
4111   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
4112   if (lcode != wanted_code)
4113     {
4114       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
4115         {
4116           /* Make the left operand unsigned, since we are only interested
4117              in the value of one bit.  Otherwise we are doing the wrong
4118              thing below.  */
4119           ll_unsignedp = 1;
4120           l_const = ll_mask;
4121         }
4122       else
4123         return 0;
4124     }
4125
4126   /* This is analogous to the code for l_const above.  */
4127   if (rcode != wanted_code)
4128     {
4129       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
4130         {
4131           rl_unsignedp = 1;
4132           r_const = rl_mask;
4133         }
4134       else
4135         return 0;
4136     }
4137
4138   /* See if we can find a mode that contains both fields being compared on
4139      the left.  If we can't, fail.  Otherwise, update all constants and masks
4140      to be relative to a field of that size.  */
4141   first_bit = MIN (ll_bitpos, rl_bitpos);
4142   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
4143   lnmode = get_best_mode (end_bit - first_bit, first_bit,
4144                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
4145                           volatilep);
4146   if (lnmode == VOIDmode)
4147     return 0;
4148
4149   lnbitsize = GET_MODE_BITSIZE (lnmode);
4150   lnbitpos = first_bit & ~ (lnbitsize - 1);
4151   lntype = type_for_size (lnbitsize, 1);
4152   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
4153
4154   if (BYTES_BIG_ENDIAN)
4155     {
4156       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
4157       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
4158     }
4159
4160   ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
4161                          size_int (xll_bitpos), 0);
4162   rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
4163                          size_int (xrl_bitpos), 0);
4164
4165   if (l_const)
4166     {
4167       l_const = convert (lntype, l_const);
4168       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
4169       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
4170       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
4171                                         fold (build1 (BIT_NOT_EXPR,
4172                                                       lntype, ll_mask)),
4173                                         0)))
4174         {
4175           warning ("comparison is always %d", wanted_code == NE_EXPR);
4176
4177           return convert (truth_type,
4178                           wanted_code == NE_EXPR
4179                           ? integer_one_node : integer_zero_node);
4180         }
4181     }
4182   if (r_const)
4183     {
4184       r_const = convert (lntype, r_const);
4185       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
4186       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
4187       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
4188                                         fold (build1 (BIT_NOT_EXPR,
4189                                                       lntype, rl_mask)),
4190                                         0)))
4191         {
4192           warning ("comparison is always %d", wanted_code == NE_EXPR);
4193
4194           return convert (truth_type,
4195                           wanted_code == NE_EXPR
4196                           ? integer_one_node : integer_zero_node);
4197         }
4198     }
4199
4200   /* If the right sides are not constant, do the same for it.  Also,
4201      disallow this optimization if a size or signedness mismatch occurs
4202      between the left and right sides.  */
4203   if (l_const == 0)
4204     {
4205       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
4206           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
4207           /* Make sure the two fields on the right
4208              correspond to the left without being swapped.  */
4209           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
4210         return 0;
4211
4212       first_bit = MIN (lr_bitpos, rr_bitpos);
4213       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
4214       rnmode = get_best_mode (end_bit - first_bit, first_bit,
4215                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
4216                               volatilep);
4217       if (rnmode == VOIDmode)
4218         return 0;
4219
4220       rnbitsize = GET_MODE_BITSIZE (rnmode);
4221       rnbitpos = first_bit & ~ (rnbitsize - 1);
4222       rntype = type_for_size (rnbitsize, 1);
4223       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
4224
4225       if (BYTES_BIG_ENDIAN)
4226         {
4227           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
4228           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
4229         }
4230
4231       lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
4232                              size_int (xlr_bitpos), 0);
4233       rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
4234                              size_int (xrr_bitpos), 0);
4235
4236       /* Make a mask that corresponds to both fields being compared.
4237          Do this for both items being compared.  If the operands are the
4238          same size and the bits being compared are in the same position
4239          then we can do this by masking both and comparing the masked
4240          results.  */
4241       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4242       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
4243       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
4244         {
4245           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4246                                     ll_unsignedp || rl_unsignedp);
4247           if (! all_ones_mask_p (ll_mask, lnbitsize))
4248             lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
4249
4250           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
4251                                     lr_unsignedp || rr_unsignedp);
4252           if (! all_ones_mask_p (lr_mask, rnbitsize))
4253             rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
4254
4255           return build (wanted_code, truth_type, lhs, rhs);
4256         }
4257
4258       /* There is still another way we can do something:  If both pairs of
4259          fields being compared are adjacent, we may be able to make a wider
4260          field containing them both.
4261
4262          Note that we still must mask the lhs/rhs expressions.  Furthermore,
4263          the mask must be shifted to account for the shift done by
4264          make_bit_field_ref.  */
4265       if ((ll_bitsize + ll_bitpos == rl_bitpos
4266            && lr_bitsize + lr_bitpos == rr_bitpos)
4267           || (ll_bitpos == rl_bitpos + rl_bitsize
4268               && lr_bitpos == rr_bitpos + rr_bitsize))
4269         {
4270           tree type;
4271
4272           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
4273                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
4274           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
4275                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
4276
4277           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
4278                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
4279           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
4280                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
4281
4282           /* Convert to the smaller type before masking out unwanted bits.  */
4283           type = lntype;
4284           if (lntype != rntype)
4285             {
4286               if (lnbitsize > rnbitsize)
4287                 {
4288                   lhs = convert (rntype, lhs);
4289                   ll_mask = convert (rntype, ll_mask);
4290                   type = rntype;
4291                 }
4292               else if (lnbitsize < rnbitsize)
4293                 {
4294                   rhs = convert (lntype, rhs);
4295                   lr_mask = convert (lntype, lr_mask);
4296                   type = lntype;
4297                 }
4298             }
4299
4300           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
4301             lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
4302
4303           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
4304             rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
4305
4306           return build (wanted_code, truth_type, lhs, rhs);
4307         }
4308
4309       return 0;
4310     }
4311
4312   /* Handle the case of comparisons with constants.  If there is something in
4313      common between the masks, those bits of the constants must be the same.
4314      If not, the condition is always false.  Test for this to avoid generating
4315      incorrect code below.  */
4316   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4317   if (! integer_zerop (result)
4318       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4319                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4320     {
4321       if (wanted_code == NE_EXPR)
4322         {
4323           warning ("`or' of unmatched not-equal tests is always 1");
4324           return convert (truth_type, integer_one_node);
4325         }
4326       else
4327         {
4328           warning ("`and' of mutually exclusive equal-tests is always 0");
4329           return convert (truth_type, integer_zero_node);
4330         }
4331     }
4332
4333   /* Construct the expression we will return.  First get the component
4334      reference we will make.  Unless the mask is all ones the width of
4335      that field, perform the mask operation.  Then compare with the
4336      merged constant.  */
4337   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
4338                                ll_unsignedp || rl_unsignedp);
4339
4340   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4341   if (! all_ones_mask_p (ll_mask, lnbitsize))
4342     result = build (BIT_AND_EXPR, lntype, result, ll_mask);
4343
4344   return build (wanted_code, truth_type, result,
4345                 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4346 }
4347 \f
4348 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
4349    constant.  */
4350
4351 static tree
4352 optimize_minmax_comparison (t)
4353      tree t;
4354 {
4355   tree type = TREE_TYPE (t);
4356   tree arg0 = TREE_OPERAND (t, 0);
4357   enum tree_code op_code;
4358   tree comp_const = TREE_OPERAND (t, 1);
4359   tree minmax_const;
4360   int consts_equal, consts_lt;
4361   tree inner;
4362
4363   STRIP_SIGN_NOPS (arg0);
4364
4365   op_code = TREE_CODE (arg0);
4366   minmax_const = TREE_OPERAND (arg0, 1);
4367   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
4368   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
4369   inner = TREE_OPERAND (arg0, 0);
4370
4371   /* If something does not permit us to optimize, return the original tree.  */
4372   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
4373       || TREE_CODE (comp_const) != INTEGER_CST
4374       || TREE_CONSTANT_OVERFLOW (comp_const)
4375       || TREE_CODE (minmax_const) != INTEGER_CST
4376       || TREE_CONSTANT_OVERFLOW (minmax_const))
4377     return t;
4378
4379   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
4380      and GT_EXPR, doing the rest with recursive calls using logical
4381      simplifications.  */
4382   switch (TREE_CODE (t))
4383     {
4384     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
4385       return
4386         invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t)));
4387
4388     case GE_EXPR:
4389       return
4390         fold (build (TRUTH_ORIF_EXPR, type,
4391                      optimize_minmax_comparison
4392                      (build (EQ_EXPR, type, arg0, comp_const)),
4393                      optimize_minmax_comparison
4394                      (build (GT_EXPR, type, arg0, comp_const))));
4395
4396     case EQ_EXPR:
4397       if (op_code == MAX_EXPR && consts_equal)
4398         /* MAX (X, 0) == 0  ->  X <= 0  */
4399         return fold (build (LE_EXPR, type, inner, comp_const));
4400
4401       else if (op_code == MAX_EXPR && consts_lt)
4402         /* MAX (X, 0) == 5  ->  X == 5   */
4403         return fold (build (EQ_EXPR, type, inner, comp_const));
4404
4405       else if (op_code == MAX_EXPR)
4406         /* MAX (X, 0) == -1  ->  false  */
4407         return omit_one_operand (type, integer_zero_node, inner);
4408
4409       else if (consts_equal)
4410         /* MIN (X, 0) == 0  ->  X >= 0  */
4411         return fold (build (GE_EXPR, type, inner, comp_const));
4412
4413       else if (consts_lt)
4414         /* MIN (X, 0) == 5  ->  false  */
4415         return omit_one_operand (type, integer_zero_node, inner);
4416
4417       else
4418         /* MIN (X, 0) == -1  ->  X == -1  */
4419         return fold (build (EQ_EXPR, type, inner, comp_const));
4420
4421     case GT_EXPR:
4422       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
4423         /* MAX (X, 0) > 0  ->  X > 0
4424            MAX (X, 0) > 5  ->  X > 5  */
4425         return fold (build (GT_EXPR, type, inner, comp_const));
4426
4427       else if (op_code == MAX_EXPR)
4428         /* MAX (X, 0) > -1  ->  true  */
4429         return omit_one_operand (type, integer_one_node, inner);
4430
4431       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
4432         /* MIN (X, 0) > 0  ->  false
4433            MIN (X, 0) > 5  ->  false  */
4434         return omit_one_operand (type, integer_zero_node, inner);
4435
4436       else
4437         /* MIN (X, 0) > -1  ->  X > -1  */
4438         return fold (build (GT_EXPR, type, inner, comp_const));
4439
4440     default:
4441       return t;
4442     }
4443 }
4444 \f
4445 /* T is an integer expression that is being multiplied, divided, or taken a
4446    modulus (CODE says which and what kind of divide or modulus) by a
4447    constant C.  See if we can eliminate that operation by folding it with
4448    other operations already in T.  WIDE_TYPE, if non-null, is a type that
4449    should be used for the computation if wider than our type.
4450
4451    For example, if we are dividing (X * 8) + (Y + 16) by 4, we can return
4452    (X * 2) + (Y + 4).  We must, however, be assured that either the original
4453    expression would not overflow or that overflow is undefined for the type
4454    in the language in question.
4455
4456    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
4457    the machine has a multiply-accumulate insn or that this is part of an
4458    addressing calculation.
4459
4460    If we return a non-null expression, it is an equivalent form of the
4461    original computation, but need not be in the original type.  */
4462
4463 static tree
4464 extract_muldiv (t, c, code, wide_type)
4465      tree t;
4466      tree c;
4467      enum tree_code code;
4468      tree wide_type;
4469 {
4470   tree type = TREE_TYPE (t);
4471   enum tree_code tcode = TREE_CODE (t);
4472   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
4473                                    > GET_MODE_SIZE (TYPE_MODE (type)))
4474                 ? wide_type : type);
4475   tree t1, t2;
4476   int same_p = tcode == code;
4477   tree op0 = NULL_TREE, op1 = NULL_TREE;
4478
4479   /* Don't deal with constants of zero here; they confuse the code below.  */
4480   if (integer_zerop (c))
4481     return NULL_TREE;
4482
4483   if (TREE_CODE_CLASS (tcode) == '1')
4484     op0 = TREE_OPERAND (t, 0);
4485
4486   if (TREE_CODE_CLASS (tcode) == '2')
4487     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
4488
4489   /* Note that we need not handle conditional operations here since fold
4490      already handles those cases.  So just do arithmetic here.  */
4491   switch (tcode)
4492     {
4493     case INTEGER_CST:
4494       /* For a constant, we can always simplify if we are a multiply
4495          or (for divide and modulus) if it is a multiple of our constant.  */
4496       if (code == MULT_EXPR
4497           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
4498         return const_binop (code, convert (ctype, t), convert (ctype, c), 0);
4499       break;
4500
4501     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
4502       /* If op0 is an expression, and is unsigned, and the type is
4503          smaller than ctype, then we cannot widen the expression.  */
4504       if ((TREE_CODE_CLASS (TREE_CODE (op0)) == '<'
4505            || TREE_CODE_CLASS (TREE_CODE (op0)) == '1'
4506            || TREE_CODE_CLASS (TREE_CODE (op0)) == '2'
4507            || TREE_CODE_CLASS (TREE_CODE (op0)) == 'e')
4508           && TREE_UNSIGNED (TREE_TYPE (op0))
4509           && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
4510                 && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
4511           && (GET_MODE_SIZE (TYPE_MODE (ctype))
4512               > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
4513         break;
4514
4515       /* Pass the constant down and see if we can make a simplification.  If
4516          we can, replace this expression with the inner simplification for
4517          possible later conversion to our or some other type.  */
4518       if (0 != (t1 = extract_muldiv (op0, convert (TREE_TYPE (op0), c), code,
4519                                      code == MULT_EXPR ? ctype : NULL_TREE)))
4520         return t1;
4521       break;
4522
4523     case NEGATE_EXPR:  case ABS_EXPR:
4524       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4525         return fold (build1 (tcode, ctype, convert (ctype, t1)));
4526       break;
4527
4528     case MIN_EXPR:  case MAX_EXPR:
4529       /* If widening the type changes the signedness, then we can't perform
4530          this optimization as that changes the result.  */
4531       if (TREE_UNSIGNED (ctype) != TREE_UNSIGNED (type))
4532         break;
4533
4534       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
4535       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
4536           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
4537         {
4538           if (tree_int_cst_sgn (c) < 0)
4539             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
4540
4541           return fold (build (tcode, ctype, convert (ctype, t1),
4542                               convert (ctype, t2)));
4543         }
4544       break;
4545
4546     case WITH_RECORD_EXPR:
4547       if ((t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code, wide_type)) != 0)
4548         return build (WITH_RECORD_EXPR, TREE_TYPE (t1), t1,
4549                       TREE_OPERAND (t, 1));
4550       break;
4551
4552     case SAVE_EXPR:
4553       /* If this has not been evaluated and the operand has no side effects,
4554          we can see if we can do something inside it and make a new one.
4555          Note that this test is overly conservative since we can do this
4556          if the only reason it had side effects is that it was another
4557          similar SAVE_EXPR, but that isn't worth bothering with.  */
4558       if (SAVE_EXPR_RTL (t) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0))
4559           && 0 != (t1 = extract_muldiv (TREE_OPERAND (t, 0), c, code,
4560                                         wide_type)))
4561         {
4562           t1 = save_expr (t1);
4563           if (SAVE_EXPR_PERSISTENT_P (t) && TREE_CODE (t1) == SAVE_EXPR)
4564             SAVE_EXPR_PERSISTENT_P (t1) = 1;
4565           if (is_pending_size (t))
4566             put_pending_size (t1);
4567           return t1;
4568         }
4569       break;
4570
4571     case LSHIFT_EXPR:  case RSHIFT_EXPR:
4572       /* If the second operand is constant, this is a multiplication
4573          or floor division, by a power of two, so we can treat it that
4574          way unless the multiplier or divisor overflows.  */
4575       if (TREE_CODE (op1) == INTEGER_CST
4576           /* const_binop may not detect overflow correctly,
4577              so check for it explicitly here.  */
4578           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
4579           && TREE_INT_CST_HIGH (op1) == 0
4580           && 0 != (t1 = convert (ctype,
4581                                  const_binop (LSHIFT_EXPR, size_one_node,
4582                                               op1, 0)))
4583           && ! TREE_OVERFLOW (t1))
4584         return extract_muldiv (build (tcode == LSHIFT_EXPR
4585                                       ? MULT_EXPR : FLOOR_DIV_EXPR,
4586                                       ctype, convert (ctype, op0), t1),
4587                                c, code, wide_type);
4588       break;
4589
4590     case PLUS_EXPR:  case MINUS_EXPR:
4591       /* See if we can eliminate the operation on both sides.  If we can, we
4592          can return a new PLUS or MINUS.  If we can't, the only remaining
4593          cases where we can do anything are if the second operand is a
4594          constant.  */
4595       t1 = extract_muldiv (op0, c, code, wide_type);
4596       t2 = extract_muldiv (op1, c, code, wide_type);
4597       if (t1 != 0 && t2 != 0
4598           && (code == MULT_EXPR
4599               /* If not multiplication, we can only do this if either operand
4600                  is divisible by c.  */
4601               || multiple_of_p (ctype, op0, c)
4602               || multiple_of_p (ctype, op1, c)))
4603         return fold (build (tcode, ctype, convert (ctype, t1),
4604                             convert (ctype, t2)));
4605
4606       /* If this was a subtraction, negate OP1 and set it to be an addition.
4607          This simplifies the logic below.  */
4608       if (tcode == MINUS_EXPR)
4609         tcode = PLUS_EXPR, op1 = negate_expr (op1);
4610
4611       if (TREE_CODE (op1) != INTEGER_CST)
4612         break;
4613
4614       /* If either OP1 or C are negative, this optimization is not safe for
4615          some of the division and remainder types while for others we need
4616          to change the code.  */
4617       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
4618         {
4619           if (code == CEIL_DIV_EXPR)
4620             code = FLOOR_DIV_EXPR;
4621           else if (code == FLOOR_DIV_EXPR)
4622             code = CEIL_DIV_EXPR;
4623           else if (code != MULT_EXPR
4624                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
4625             break;
4626         }
4627
4628       /* If it's a multiply or a division/modulus operation of a multiple
4629          of our constant, do the operation and verify it doesn't overflow.  */
4630       if (code == MULT_EXPR
4631           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4632         {
4633           op1 = const_binop (code, convert (ctype, op1), convert (ctype, c), 0);
4634           if (op1 == 0 || TREE_OVERFLOW (op1))
4635             break;
4636         }
4637       else
4638         break;
4639
4640       /* If we have an unsigned type is not a sizetype, we cannot widen
4641          the operation since it will change the result if the original
4642          computation overflowed.  */
4643       if (TREE_UNSIGNED (ctype)
4644           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
4645           && ctype != type)
4646         break;
4647
4648       /* If we were able to eliminate our operation from the first side,
4649          apply our operation to the second side and reform the PLUS.  */
4650       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
4651         return fold (build (tcode, ctype, convert (ctype, t1), op1));
4652
4653       /* The last case is if we are a multiply.  In that case, we can
4654          apply the distributive law to commute the multiply and addition
4655          if the multiplication of the constants doesn't overflow.  */
4656       if (code == MULT_EXPR)
4657         return fold (build (tcode, ctype, fold (build (code, ctype,
4658                                                        convert (ctype, op0),
4659                                                        convert (ctype, c))),
4660                             op1));
4661
4662       break;
4663
4664     case MULT_EXPR:
4665       /* We have a special case here if we are doing something like
4666          (C * 8) % 4 since we know that's zero.  */
4667       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
4668            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
4669           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
4670           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4671         return omit_one_operand (type, integer_zero_node, op0);
4672
4673       /* ... fall through ...  */
4674
4675     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
4676     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
4677       /* If we can extract our operation from the LHS, do so and return a
4678          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
4679          do something only if the second operand is a constant.  */
4680       if (same_p
4681           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
4682         return fold (build (tcode, ctype, convert (ctype, t1),
4683                             convert (ctype, op1)));
4684       else if (tcode == MULT_EXPR && code == MULT_EXPR
4685                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
4686         return fold (build (tcode, ctype, convert (ctype, op0),
4687                             convert (ctype, t1)));
4688       else if (TREE_CODE (op1) != INTEGER_CST)
4689         return 0;
4690
4691       /* If these are the same operation types, we can associate them
4692          assuming no overflow.  */
4693       if (tcode == code
4694           && 0 != (t1 = const_binop (MULT_EXPR, convert (ctype, op1),
4695                                      convert (ctype, c), 0))
4696           && ! TREE_OVERFLOW (t1))
4697         return fold (build (tcode, ctype, convert (ctype, op0), t1));
4698
4699       /* If these operations "cancel" each other, we have the main
4700          optimizations of this pass, which occur when either constant is a
4701          multiple of the other, in which case we replace this with either an
4702          operation or CODE or TCODE.
4703
4704          If we have an unsigned type that is not a sizetype, we cannot do
4705          this since it will change the result if the original computation
4706          overflowed.  */
4707       if ((! TREE_UNSIGNED (ctype)
4708            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
4709           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
4710               || (tcode == MULT_EXPR
4711                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
4712                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
4713         {
4714           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
4715             return fold (build (tcode, ctype, convert (ctype, op0),
4716                                 convert (ctype,
4717                                          const_binop (TRUNC_DIV_EXPR,
4718                                                       op1, c, 0))));
4719           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
4720             return fold (build (code, ctype, convert (ctype, op0),
4721                                 convert (ctype,
4722                                          const_binop (TRUNC_DIV_EXPR,
4723                                                       c, op1, 0))));
4724         }
4725       break;
4726
4727     default:
4728       break;
4729     }
4730
4731   return 0;
4732 }
4733 \f
4734 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4735    S, a SAVE_EXPR, return the expression actually being evaluated.   Note
4736    that we may sometimes modify the tree.  */
4737
4738 static tree
4739 strip_compound_expr (t, s)
4740      tree t;
4741      tree s;
4742 {
4743   enum tree_code code = TREE_CODE (t);
4744
4745   /* See if this is the COMPOUND_EXPR we want to eliminate.  */
4746   if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4747       && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4748     return TREE_OPERAND (t, 1);
4749
4750   /* See if this is a COND_EXPR or a simple arithmetic operator.   We
4751      don't bother handling any other types.  */
4752   else if (code == COND_EXPR)
4753     {
4754       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4755       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4756       TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4757     }
4758   else if (TREE_CODE_CLASS (code) == '1')
4759     TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4760   else if (TREE_CODE_CLASS (code) == '<'
4761            || TREE_CODE_CLASS (code) == '2')
4762     {
4763       TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4764       TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4765     }
4766
4767   return t;
4768 }
4769 \f
4770 /* Return a node which has the indicated constant VALUE (either 0 or
4771    1), and is of the indicated TYPE.  */
4772
4773 static tree
4774 constant_boolean_node (value, type)
4775      int value;
4776      tree type;
4777 {
4778   if (type == integer_type_node)
4779     return value ? integer_one_node : integer_zero_node;
4780   else if (TREE_CODE (type) == BOOLEAN_TYPE)
4781     return truthvalue_conversion (value ? integer_one_node :
4782                                   integer_zero_node);
4783   else
4784     {
4785       tree t = build_int_2 (value, 0);
4786
4787       TREE_TYPE (t) = type;
4788       return t;
4789     }
4790 }
4791
4792 /* Utility function for the following routine, to see how complex a nesting of
4793    COND_EXPRs can be.  EXPR is the expression and LIMIT is a count beyond which
4794    we don't care (to avoid spending too much time on complex expressions.).  */
4795
4796 static int
4797 count_cond (expr, lim)
4798      tree expr;
4799      int lim;
4800 {
4801   int ctrue, cfalse;
4802
4803   if (TREE_CODE (expr) != COND_EXPR)
4804     return 0;
4805   else if (lim <= 0)
4806     return 0;
4807
4808   ctrue = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4809   cfalse = count_cond (TREE_OPERAND (expr, 2), lim - 1 - ctrue);
4810   return MIN (lim, 1 + ctrue + cfalse);
4811 }
4812
4813 /* Transform `a + (b ? x : y)' into `x ? (a + b) : (a + y)'.
4814    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
4815    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
4816    expression, and ARG to `a'.  If COND_FIRST_P is non-zero, then the
4817    COND is the first argument to CODE; otherwise (as in the example
4818    given here), it is the second argument.  TYPE is the type of the
4819    original expression.  */
4820
4821 static tree
4822 fold_binary_op_with_conditional_arg (code, type, cond, arg, cond_first_p)
4823      enum tree_code code;
4824      tree type;
4825      tree cond;
4826      tree arg;
4827      int cond_first_p;
4828 {
4829   tree test, true_value, false_value;
4830   tree lhs = NULL_TREE;
4831   tree rhs = NULL_TREE;
4832   /* In the end, we'll produce a COND_EXPR.  Both arms of the
4833      conditional expression will be binary operations.  The left-hand
4834      side of the expression to be executed if the condition is true
4835      will be pointed to by TRUE_LHS.  Similarly, the right-hand side
4836      of the expression to be executed if the condition is true will be
4837      pointed to by TRUE_RHS.  FALSE_LHS and FALSE_RHS are analagous --
4838      but apply to the expression to be executed if the conditional is
4839      false.  */
4840   tree *true_lhs;
4841   tree *true_rhs;
4842   tree *false_lhs;
4843   tree *false_rhs;
4844   /* These are the codes to use for the left-hand side and right-hand
4845      side of the COND_EXPR.  Normally, they are the same as CODE.  */
4846   enum tree_code lhs_code = code;
4847   enum tree_code rhs_code = code;
4848   /* And these are the types of the expressions.  */
4849   tree lhs_type = type;
4850   tree rhs_type = type;
4851
4852   if (cond_first_p)
4853     {
4854       true_rhs = false_rhs = &arg;
4855       true_lhs = &true_value;
4856       false_lhs = &false_value;
4857     }
4858   else
4859     {
4860       true_lhs = false_lhs = &arg;
4861       true_rhs = &true_value;
4862       false_rhs = &false_value;
4863     }
4864
4865   if (TREE_CODE (cond) == COND_EXPR)
4866     {
4867       test = TREE_OPERAND (cond, 0);
4868       true_value = TREE_OPERAND (cond, 1);
4869       false_value = TREE_OPERAND (cond, 2);
4870       /* If this operand throws an expression, then it does not make
4871          sense to try to perform a logical or arithmetic operation
4872          involving it.  Instead of building `a + throw 3' for example,
4873          we simply build `a, throw 3'.  */
4874       if (VOID_TYPE_P (TREE_TYPE (true_value)))
4875         {
4876           lhs_code = COMPOUND_EXPR;
4877           if (!cond_first_p)
4878             lhs_type = void_type_node;
4879         }
4880       if (VOID_TYPE_P (TREE_TYPE (false_value)))
4881         {
4882           rhs_code = COMPOUND_EXPR;
4883           if (!cond_first_p)
4884             rhs_type = void_type_node;
4885         }
4886     }
4887   else
4888     {
4889       tree testtype = TREE_TYPE (cond);
4890       test = cond;
4891       true_value = convert (testtype, integer_one_node);
4892       false_value = convert (testtype, integer_zero_node);
4893     }
4894
4895   /* If ARG is complex we want to make sure we only evaluate
4896      it once.  Though this is only required if it is volatile, it
4897      might be more efficient even if it is not.  However, if we
4898      succeed in folding one part to a constant, we do not need
4899      to make this SAVE_EXPR.  Since we do this optimization
4900      primarily to see if we do end up with constant and this
4901      SAVE_EXPR interferes with later optimizations, suppressing
4902      it when we can is important.
4903
4904      If we are not in a function, we can't make a SAVE_EXPR, so don't
4905      try to do so.  Don't try to see if the result is a constant
4906      if an arm is a COND_EXPR since we get exponential behavior
4907      in that case.  */
4908
4909   if (TREE_CODE (arg) != SAVE_EXPR && ! TREE_CONSTANT (arg)
4910       && global_bindings_p () == 0
4911       && ((TREE_CODE (arg) != VAR_DECL
4912            && TREE_CODE (arg) != PARM_DECL)
4913           || TREE_SIDE_EFFECTS (arg)))
4914     {
4915       if (TREE_CODE (true_value) != COND_EXPR)
4916         lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4917
4918       if (TREE_CODE (false_value) != COND_EXPR)
4919         rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4920
4921       if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4922           && (rhs == 0 || !TREE_CONSTANT (rhs)))
4923         arg = save_expr (arg), lhs = rhs = 0;
4924     }
4925
4926   if (lhs == 0)
4927     lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4928   if (rhs == 0)
4929     rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4930
4931   test = fold (build (COND_EXPR, type, test, lhs, rhs));
4932
4933   if (TREE_CODE (arg) == SAVE_EXPR)
4934     return build (COMPOUND_EXPR, type,
4935                   convert (void_type_node, arg),
4936                   strip_compound_expr (test, arg));
4937   else
4938     return convert (type, test);
4939 }
4940
4941 \f
4942 /* Perform constant folding and related simplification of EXPR.
4943    The related simplifications include x*1 => x, x*0 => 0, etc.,
4944    and application of the associative law.
4945    NOP_EXPR conversions may be removed freely (as long as we
4946    are careful not to change the C type of the overall expression)
4947    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4948    but we can constant-fold them if they have constant operands.  */
4949
4950 tree
4951 fold (expr)
4952      tree expr;
4953 {
4954   tree t = expr;
4955   tree t1 = NULL_TREE;
4956   tree tem;
4957   tree type = TREE_TYPE (expr);
4958   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4959   enum tree_code code = TREE_CODE (t);
4960   int kind = TREE_CODE_CLASS (code);
4961   int invert;
4962   /* WINS will be nonzero when the switch is done
4963      if all operands are constant.  */
4964   int wins = 1;
4965
4966   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4967      Likewise for a SAVE_EXPR that's already been evaluated.  */
4968   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
4969     return t;
4970
4971   /* Return right away if a constant.  */
4972   if (kind == 'c')
4973     return t;
4974
4975 #ifdef MAX_INTEGER_COMPUTATION_MODE
4976   check_max_integer_computation_mode (expr);
4977 #endif
4978
4979   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4980     {
4981       tree subop;
4982
4983       /* Special case for conversion ops that can have fixed point args.  */
4984       arg0 = TREE_OPERAND (t, 0);
4985
4986       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4987       if (arg0 != 0)
4988         STRIP_SIGN_NOPS (arg0);
4989
4990       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4991         subop = TREE_REALPART (arg0);
4992       else
4993         subop = arg0;
4994
4995       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4996 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4997           && TREE_CODE (subop) != REAL_CST
4998 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4999           )
5000         /* Note that TREE_CONSTANT isn't enough:
5001            static var addresses are constant but we can't
5002            do arithmetic on them.  */
5003         wins = 0;
5004     }
5005   else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
5006     {
5007       int len = first_rtl_op (code);
5008       int i;
5009       for (i = 0; i < len; i++)
5010         {
5011           tree op = TREE_OPERAND (t, i);
5012           tree subop;
5013
5014           if (op == 0)
5015             continue;           /* Valid for CALL_EXPR, at least.  */
5016
5017           if (kind == '<' || code == RSHIFT_EXPR)
5018             {
5019               /* Signedness matters here.  Perhaps we can refine this
5020                  later.  */
5021               STRIP_SIGN_NOPS (op);
5022             }
5023           else
5024             /* Strip any conversions that don't change the mode.  */
5025             STRIP_NOPS (op);
5026
5027           if (TREE_CODE (op) == COMPLEX_CST)
5028             subop = TREE_REALPART (op);
5029           else
5030             subop = op;
5031
5032           if (TREE_CODE (subop) != INTEGER_CST
5033 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5034               && TREE_CODE (subop) != REAL_CST
5035 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5036               )
5037             /* Note that TREE_CONSTANT isn't enough:
5038                static var addresses are constant but we can't
5039                do arithmetic on them.  */
5040             wins = 0;
5041
5042           if (i == 0)
5043             arg0 = op;
5044           else if (i == 1)
5045             arg1 = op;
5046         }
5047     }
5048
5049   /* If this is a commutative operation, and ARG0 is a constant, move it
5050      to ARG1 to reduce the number of tests below.  */
5051   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
5052        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
5053        || code == BIT_AND_EXPR)
5054       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
5055     {
5056       tem = arg0; arg0 = arg1; arg1 = tem;
5057
5058       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
5059       TREE_OPERAND (t, 1) = tem;
5060     }
5061
5062   /* Now WINS is set as described above,
5063      ARG0 is the first operand of EXPR,
5064      and ARG1 is the second operand (if it has more than one operand).
5065
5066      First check for cases where an arithmetic operation is applied to a
5067      compound, conditional, or comparison operation.  Push the arithmetic
5068      operation inside the compound or conditional to see if any folding
5069      can then be done.  Convert comparison to conditional for this purpose.
5070      The also optimizes non-constant cases that used to be done in
5071      expand_expr.
5072
5073      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
5074      one of the operands is a comparison and the other is a comparison, a
5075      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
5076      code below would make the expression more complex.  Change it to a
5077      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
5078      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
5079
5080   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
5081        || code == EQ_EXPR || code == NE_EXPR)
5082       && ((truth_value_p (TREE_CODE (arg0))
5083            && (truth_value_p (TREE_CODE (arg1))
5084                || (TREE_CODE (arg1) == BIT_AND_EXPR
5085                    && integer_onep (TREE_OPERAND (arg1, 1)))))
5086           || (truth_value_p (TREE_CODE (arg1))
5087               && (truth_value_p (TREE_CODE (arg0))
5088                   || (TREE_CODE (arg0) == BIT_AND_EXPR
5089                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
5090     {
5091       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
5092                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
5093                        : TRUTH_XOR_EXPR,
5094                        type, arg0, arg1));
5095
5096       if (code == EQ_EXPR)
5097         t = invert_truthvalue (t);
5098
5099       return t;
5100     }
5101
5102   if (TREE_CODE_CLASS (code) == '1')
5103     {
5104       if (TREE_CODE (arg0) == COMPOUND_EXPR)
5105         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5106                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
5107       else if (TREE_CODE (arg0) == COND_EXPR)
5108         {
5109           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
5110                            fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
5111                            fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
5112
5113           /* If this was a conversion, and all we did was to move into
5114              inside the COND_EXPR, bring it back out.  But leave it if
5115              it is a conversion from integer to integer and the
5116              result precision is no wider than a word since such a
5117              conversion is cheap and may be optimized away by combine,
5118              while it couldn't if it were outside the COND_EXPR.  Then return
5119              so we don't get into an infinite recursion loop taking the
5120              conversion out and then back in.  */
5121
5122           if ((code == NOP_EXPR || code == CONVERT_EXPR
5123                || code == NON_LVALUE_EXPR)
5124               && TREE_CODE (t) == COND_EXPR
5125               && TREE_CODE (TREE_OPERAND (t, 1)) == code
5126               && TREE_CODE (TREE_OPERAND (t, 2)) == code
5127               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
5128                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
5129               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
5130                     && (INTEGRAL_TYPE_P
5131                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
5132                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
5133             t = build1 (code, type,
5134                         build (COND_EXPR,
5135                                TREE_TYPE (TREE_OPERAND
5136                                           (TREE_OPERAND (t, 1), 0)),
5137                                TREE_OPERAND (t, 0),
5138                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
5139                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
5140           return t;
5141         }
5142       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
5143         return fold (build (COND_EXPR, type, arg0,
5144                             fold (build1 (code, type, integer_one_node)),
5145                             fold (build1 (code, type, integer_zero_node))));
5146    }
5147   else if (TREE_CODE_CLASS (code) == '2'
5148            || TREE_CODE_CLASS (code) == '<')
5149     {
5150       if (TREE_CODE (arg1) == COMPOUND_EXPR)
5151         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
5152                       fold (build (code, type,
5153                                    arg0, TREE_OPERAND (arg1, 1))));
5154       else if ((TREE_CODE (arg1) == COND_EXPR
5155                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
5156                     && TREE_CODE_CLASS (code) != '<'))
5157                && (TREE_CODE (arg0) != COND_EXPR
5158                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
5159                && (! TREE_SIDE_EFFECTS (arg0)
5160                    || (global_bindings_p () == 0
5161                        && ! contains_placeholder_p (arg0))))
5162         return
5163           fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
5164                                                /*cond_first_p=*/0);
5165       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
5166         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5167                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
5168       else if ((TREE_CODE (arg0) == COND_EXPR
5169                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
5170                     && TREE_CODE_CLASS (code) != '<'))
5171                && (TREE_CODE (arg1) != COND_EXPR
5172                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
5173                && (! TREE_SIDE_EFFECTS (arg1)
5174                    || (global_bindings_p () == 0
5175                        && ! contains_placeholder_p (arg1))))
5176         return
5177           fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
5178                                                /*cond_first_p=*/1);
5179     }
5180   else if (TREE_CODE_CLASS (code) == '<'
5181            && TREE_CODE (arg0) == COMPOUND_EXPR)
5182     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
5183                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
5184   else if (TREE_CODE_CLASS (code) == '<'
5185            && TREE_CODE (arg1) == COMPOUND_EXPR)
5186     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
5187                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
5188
5189   switch (code)
5190     {
5191     case INTEGER_CST:
5192     case REAL_CST:
5193     case STRING_CST:
5194     case COMPLEX_CST:
5195     case CONSTRUCTOR:
5196       return t;
5197
5198     case CONST_DECL:
5199       return fold (DECL_INITIAL (t));
5200
5201     case NOP_EXPR:
5202     case FLOAT_EXPR:
5203     case CONVERT_EXPR:
5204     case FIX_TRUNC_EXPR:
5205       /* Other kinds of FIX are not handled properly by fold_convert.  */
5206
5207       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
5208         return TREE_OPERAND (t, 0);
5209
5210       /* Handle cases of two conversions in a row.  */
5211       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
5212           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
5213         {
5214           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5215           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
5216           tree final_type = TREE_TYPE (t);
5217           int inside_int = INTEGRAL_TYPE_P (inside_type);
5218           int inside_ptr = POINTER_TYPE_P (inside_type);
5219           int inside_float = FLOAT_TYPE_P (inside_type);
5220           unsigned int inside_prec = TYPE_PRECISION (inside_type);
5221           int inside_unsignedp = TREE_UNSIGNED (inside_type);
5222           int inter_int = INTEGRAL_TYPE_P (inter_type);
5223           int inter_ptr = POINTER_TYPE_P (inter_type);
5224           int inter_float = FLOAT_TYPE_P (inter_type);
5225           unsigned int inter_prec = TYPE_PRECISION (inter_type);
5226           int inter_unsignedp = TREE_UNSIGNED (inter_type);
5227           int final_int = INTEGRAL_TYPE_P (final_type);
5228           int final_ptr = POINTER_TYPE_P (final_type);
5229           int final_float = FLOAT_TYPE_P (final_type);
5230           unsigned int final_prec = TYPE_PRECISION (final_type);
5231           int final_unsignedp = TREE_UNSIGNED (final_type);
5232
5233           /* In addition to the cases of two conversions in a row
5234              handled below, if we are converting something to its own
5235              type via an object of identical or wider precision, neither
5236              conversion is needed.  */
5237           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
5238               && ((inter_int && final_int) || (inter_float && final_float))
5239               && inter_prec >= final_prec)
5240             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5241
5242           /* Likewise, if the intermediate and final types are either both
5243              float or both integer, we don't need the middle conversion if
5244              it is wider than the final type and doesn't change the signedness
5245              (for integers).  Avoid this if the final type is a pointer
5246              since then we sometimes need the inner conversion.  Likewise if
5247              the outer has a precision not equal to the size of its mode.  */
5248           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
5249                || (inter_float && inside_float))
5250               && inter_prec >= inside_prec
5251               && (inter_float || inter_unsignedp == inside_unsignedp)
5252               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5253                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5254               && ! final_ptr)
5255             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5256
5257           /* If we have a sign-extension of a zero-extended value, we can
5258              replace that by a single zero-extension.  */
5259           if (inside_int && inter_int && final_int
5260               && inside_prec < inter_prec && inter_prec < final_prec
5261               && inside_unsignedp && !inter_unsignedp)
5262             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5263
5264           /* Two conversions in a row are not needed unless:
5265              - some conversion is floating-point (overstrict for now), or
5266              - the intermediate type is narrower than both initial and
5267                final, or
5268              - the intermediate type and innermost type differ in signedness,
5269                and the outermost type is wider than the intermediate, or
5270              - the initial type is a pointer type and the precisions of the
5271                intermediate and final types differ, or
5272              - the final type is a pointer type and the precisions of the
5273                initial and intermediate types differ.  */
5274           if (! inside_float && ! inter_float && ! final_float
5275               && (inter_prec > inside_prec || inter_prec > final_prec)
5276               && ! (inside_int && inter_int
5277                     && inter_unsignedp != inside_unsignedp
5278                     && inter_prec < final_prec)
5279               && ((inter_unsignedp && inter_prec > inside_prec)
5280                   == (final_unsignedp && final_prec > inter_prec))
5281               && ! (inside_ptr && inter_prec != final_prec)
5282               && ! (final_ptr && inside_prec != inter_prec)
5283               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
5284                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
5285               && ! final_ptr)
5286             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5287         }
5288
5289       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
5290           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
5291           /* Detect assigning a bitfield.  */
5292           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
5293                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
5294         {
5295           /* Don't leave an assignment inside a conversion
5296              unless assigning a bitfield.  */
5297           tree prev = TREE_OPERAND (t, 0);
5298           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
5299           /* First do the assignment, then return converted constant.  */
5300           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
5301           TREE_USED (t) = 1;
5302           return t;
5303         }
5304       if (!wins)
5305         {
5306           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
5307           return t;
5308         }
5309       return fold_convert (t, arg0);
5310
5311     case VIEW_CONVERT_EXPR:
5312       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
5313         return build1 (VIEW_CONVERT_EXPR, type,
5314                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
5315       return t;
5316
5317 #if 0  /* This loses on &"foo"[0].  */
5318     case ARRAY_REF:
5319         {
5320           int i;
5321
5322           /* Fold an expression like: "foo"[2] */
5323           if (TREE_CODE (arg0) == STRING_CST
5324               && TREE_CODE (arg1) == INTEGER_CST
5325               && compare_tree_int (arg1, TREE_STRING_LENGTH (arg0)) < 0)
5326             {
5327               t = build_int_2 (TREE_STRING_POINTER (arg0)[TREE_INT_CST_LOW (arg))], 0);
5328               TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
5329               force_fit_type (t, 0);
5330             }
5331         }
5332       return t;
5333 #endif /* 0 */
5334
5335     case COMPONENT_REF:
5336       if (TREE_CODE (arg0) == CONSTRUCTOR)
5337         {
5338           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5339           if (m)
5340             t = TREE_VALUE (m);
5341         }
5342       return t;
5343
5344     case RANGE_EXPR:
5345       TREE_CONSTANT (t) = wins;
5346       return t;
5347
5348     case NEGATE_EXPR:
5349       if (wins)
5350         {
5351           if (TREE_CODE (arg0) == INTEGER_CST)
5352             {
5353               unsigned HOST_WIDE_INT low;
5354               HOST_WIDE_INT high;
5355               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5356                                          TREE_INT_CST_HIGH (arg0),
5357                                          &low, &high);
5358               t = build_int_2 (low, high);
5359               TREE_TYPE (t) = type;
5360               TREE_OVERFLOW (t)
5361                 = (TREE_OVERFLOW (arg0)
5362                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5363               TREE_CONSTANT_OVERFLOW (t)
5364                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5365             }
5366           else if (TREE_CODE (arg0) == REAL_CST)
5367             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5368         }
5369       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5370         return TREE_OPERAND (arg0, 0);
5371
5372       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5373       else if (TREE_CODE (arg0) == MINUS_EXPR
5374                && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
5375         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5376                       TREE_OPERAND (arg0, 0));
5377
5378       return t;
5379
5380     case ABS_EXPR:
5381       if (wins)
5382         {
5383           if (TREE_CODE (arg0) == INTEGER_CST)
5384             {
5385               /* If the value is unsigned, then the absolute value is
5386                  the same as the ordinary value.  */
5387               if (TREE_UNSIGNED (type))
5388                 return arg0;
5389               /* Similarly, if the value is non-negative.  */
5390               else if (INT_CST_LT (integer_minus_one_node, arg0))
5391                 return arg0;
5392               /* If the value is negative, then the absolute value is
5393                  its negation.  */
5394               else
5395                 {
5396                   unsigned HOST_WIDE_INT low;
5397                   HOST_WIDE_INT high;
5398                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5399                                              TREE_INT_CST_HIGH (arg0),
5400                                              &low, &high);
5401                   t = build_int_2 (low, high);
5402                   TREE_TYPE (t) = type;
5403                   TREE_OVERFLOW (t)
5404                     = (TREE_OVERFLOW (arg0)
5405                        | force_fit_type (t, overflow));
5406                   TREE_CONSTANT_OVERFLOW (t)
5407                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5408                 }
5409             }
5410           else if (TREE_CODE (arg0) == REAL_CST)
5411             {
5412               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5413                 t = build_real (type,
5414                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5415             }
5416         }
5417       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5418         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5419       return t;
5420
5421     case CONJ_EXPR:
5422       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5423         return convert (type, arg0);
5424       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5425         return build (COMPLEX_EXPR, type,
5426                       TREE_OPERAND (arg0, 0),
5427                       negate_expr (TREE_OPERAND (arg0, 1)));
5428       else if (TREE_CODE (arg0) == COMPLEX_CST)
5429         return build_complex (type, TREE_REALPART (arg0),
5430                               negate_expr (TREE_IMAGPART (arg0)));
5431       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5432         return fold (build (TREE_CODE (arg0), type,
5433                             fold (build1 (CONJ_EXPR, type,
5434                                           TREE_OPERAND (arg0, 0))),
5435                             fold (build1 (CONJ_EXPR,
5436                                           type, TREE_OPERAND (arg0, 1)))));
5437       else if (TREE_CODE (arg0) == CONJ_EXPR)
5438         return TREE_OPERAND (arg0, 0);
5439       return t;
5440
5441     case BIT_NOT_EXPR:
5442       if (wins)
5443         {
5444           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5445                            ~ TREE_INT_CST_HIGH (arg0));
5446           TREE_TYPE (t) = type;
5447           force_fit_type (t, 0);
5448           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5449           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5450         }
5451       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5452         return TREE_OPERAND (arg0, 0);
5453       return t;
5454
5455     case PLUS_EXPR:
5456       /* A + (-B) -> A - B */
5457       if (TREE_CODE (arg1) == NEGATE_EXPR)
5458         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5459       /* (-A) + B -> B - A */
5460       if (TREE_CODE (arg0) == NEGATE_EXPR)
5461         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5462       else if (! FLOAT_TYPE_P (type))
5463         {
5464           if (integer_zerop (arg1))
5465             return non_lvalue (convert (type, arg0));
5466
5467           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5468              with a constant, and the two constants have no bits in common,
5469              we should treat this as a BIT_IOR_EXPR since this may produce more
5470              simplifications.  */
5471           if (TREE_CODE (arg0) == BIT_AND_EXPR
5472               && TREE_CODE (arg1) == BIT_AND_EXPR
5473               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5474               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5475               && integer_zerop (const_binop (BIT_AND_EXPR,
5476                                              TREE_OPERAND (arg0, 1),
5477                                              TREE_OPERAND (arg1, 1), 0)))
5478             {
5479               code = BIT_IOR_EXPR;
5480               goto bit_ior;
5481             }
5482
5483           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5484              (plus (plus (mult) (mult)) (foo)) so that we can
5485              take advantage of the factoring cases below.  */
5486           if ((TREE_CODE (arg0) == PLUS_EXPR
5487                && TREE_CODE (arg1) == MULT_EXPR)
5488               || (TREE_CODE (arg1) == PLUS_EXPR
5489                   && TREE_CODE (arg0) == MULT_EXPR))
5490             {
5491               tree parg0, parg1, parg, marg;
5492
5493               if (TREE_CODE (arg0) == PLUS_EXPR)
5494                 parg = arg0, marg = arg1;
5495               else
5496                 parg = arg1, marg = arg0;
5497               parg0 = TREE_OPERAND (parg, 0);
5498               parg1 = TREE_OPERAND (parg, 1);
5499               STRIP_NOPS (parg0);
5500               STRIP_NOPS (parg1);
5501
5502               if (TREE_CODE (parg0) == MULT_EXPR
5503                   && TREE_CODE (parg1) != MULT_EXPR)
5504                 return fold (build (PLUS_EXPR, type,
5505                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5506                                     parg1));
5507               if (TREE_CODE (parg0) != MULT_EXPR
5508                   && TREE_CODE (parg1) == MULT_EXPR)
5509                 return fold (build (PLUS_EXPR, type,
5510                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5511                                     parg0));
5512             }
5513
5514           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5515             {
5516               tree arg00, arg01, arg10, arg11;
5517               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5518
5519               /* (A * C) + (B * C) -> (A+B) * C.
5520                  We are most concerned about the case where C is a constant,
5521                  but other combinations show up during loop reduction.  Since
5522                  it is not difficult, try all four possibilities.  */
5523
5524               arg00 = TREE_OPERAND (arg0, 0);
5525               arg01 = TREE_OPERAND (arg0, 1);
5526               arg10 = TREE_OPERAND (arg1, 0);
5527               arg11 = TREE_OPERAND (arg1, 1);
5528               same = NULL_TREE;
5529
5530               if (operand_equal_p (arg01, arg11, 0))
5531                 same = arg01, alt0 = arg00, alt1 = arg10;
5532               else if (operand_equal_p (arg00, arg10, 0))
5533                 same = arg00, alt0 = arg01, alt1 = arg11;
5534               else if (operand_equal_p (arg00, arg11, 0))
5535                 same = arg00, alt0 = arg01, alt1 = arg10;
5536               else if (operand_equal_p (arg01, arg10, 0))
5537                 same = arg01, alt0 = arg00, alt1 = arg11;
5538
5539               /* No identical multiplicands; see if we can find a common
5540                  power-of-two factor in non-power-of-two multiplies.  This
5541                  can help in multi-dimensional array access.  */
5542               else if (TREE_CODE (arg01) == INTEGER_CST
5543                        && TREE_CODE (arg11) == INTEGER_CST
5544                        && TREE_INT_CST_HIGH (arg01) == 0
5545                        && TREE_INT_CST_HIGH (arg11) == 0)
5546                 {
5547                   HOST_WIDE_INT int01, int11, tmp;
5548                   int01 = TREE_INT_CST_LOW (arg01);
5549                   int11 = TREE_INT_CST_LOW (arg11);
5550
5551                   /* Move min of absolute values to int11.  */
5552                   if ((int01 >= 0 ? int01 : -int01)
5553                       < (int11 >= 0 ? int11 : -int11))
5554                     {
5555                       tmp = int01, int01 = int11, int11 = tmp;
5556                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5557                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5558                     }
5559
5560                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5561                     {
5562                       alt0 = fold (build (MULT_EXPR, type, arg00,
5563                                           build_int_2 (int01 / int11, 0)));
5564                       alt1 = arg10;
5565                       same = arg11;
5566                     }
5567                 }
5568
5569               if (same)
5570                 return fold (build (MULT_EXPR, type,
5571                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5572                                     same));
5573             }
5574         }
5575       /* In IEEE floating point, x+0 may not equal x.  */
5576       else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5577                 || flag_unsafe_math_optimizations)
5578                && real_zerop (arg1))
5579         return non_lvalue (convert (type, arg0));
5580       /* x+(-0) equals x, even for IEEE.  */
5581       else if (TREE_CODE (arg1) == REAL_CST
5582                && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5583         return non_lvalue (convert (type, arg0));
5584
5585      bit_rotate:
5586       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5587          is a rotate of A by C1 bits.  */
5588       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5589          is a rotate of A by B bits.  */
5590       {
5591         enum tree_code code0, code1;
5592         code0 = TREE_CODE (arg0);
5593         code1 = TREE_CODE (arg1);
5594         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5595              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5596             && operand_equal_p (TREE_OPERAND (arg0, 0),
5597                                 TREE_OPERAND (arg1, 0), 0)
5598             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5599           {
5600             tree tree01, tree11;
5601             enum tree_code code01, code11;
5602
5603             tree01 = TREE_OPERAND (arg0, 1);
5604             tree11 = TREE_OPERAND (arg1, 1);
5605             STRIP_NOPS (tree01);
5606             STRIP_NOPS (tree11);
5607             code01 = TREE_CODE (tree01);
5608             code11 = TREE_CODE (tree11);
5609             if (code01 == INTEGER_CST
5610                 && code11 == INTEGER_CST
5611                 && TREE_INT_CST_HIGH (tree01) == 0
5612                 && TREE_INT_CST_HIGH (tree11) == 0
5613                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5614                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5615               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5616                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5617             else if (code11 == MINUS_EXPR)
5618               {
5619                 tree tree110, tree111;
5620                 tree110 = TREE_OPERAND (tree11, 0);
5621                 tree111 = TREE_OPERAND (tree11, 1);
5622                 STRIP_NOPS (tree110);
5623                 STRIP_NOPS (tree111);
5624                 if (TREE_CODE (tree110) == INTEGER_CST
5625                     && 0 == compare_tree_int (tree110,
5626                                               TYPE_PRECISION
5627                                               (TREE_TYPE (TREE_OPERAND
5628                                                           (arg0, 0))))
5629                     && operand_equal_p (tree01, tree111, 0))
5630                   return build ((code0 == LSHIFT_EXPR
5631                                  ? LROTATE_EXPR
5632                                  : RROTATE_EXPR),
5633                                 type, TREE_OPERAND (arg0, 0), tree01);
5634               }
5635             else if (code01 == MINUS_EXPR)
5636               {
5637                 tree tree010, tree011;
5638                 tree010 = TREE_OPERAND (tree01, 0);
5639                 tree011 = TREE_OPERAND (tree01, 1);
5640                 STRIP_NOPS (tree010);
5641                 STRIP_NOPS (tree011);
5642                 if (TREE_CODE (tree010) == INTEGER_CST
5643                     && 0 == compare_tree_int (tree010,
5644                                               TYPE_PRECISION
5645                                               (TREE_TYPE (TREE_OPERAND
5646                                                           (arg0, 0))))
5647                     && operand_equal_p (tree11, tree011, 0))
5648                   return build ((code0 != LSHIFT_EXPR
5649                                  ? LROTATE_EXPR
5650                                  : RROTATE_EXPR),
5651                                 type, TREE_OPERAND (arg0, 0), tree11);
5652               }
5653           }
5654       }
5655
5656     associate:
5657       /* In most languages, can't associate operations on floats through
5658          parentheses.  Rather than remember where the parentheses were, we
5659          don't associate floats at all.  It shouldn't matter much.  However,
5660          associating multiplications is only very slightly inaccurate, so do
5661          that if -funsafe-math-optimizations is specified.  */
5662
5663       if (! wins
5664           && (! FLOAT_TYPE_P (type)
5665               || (flag_unsafe_math_optimizations && code == MULT_EXPR)))
5666         {
5667           tree var0, con0, lit0, var1, con1, lit1;
5668
5669           /* Split both trees into variables, constants, and literals.  Then
5670              associate each group together, the constants with literals,
5671              then the result with variables.  This increases the chances of
5672              literals being recombined later and of generating relocatable
5673              expressions for the sum of a constant and literal.  */
5674           var0 = split_tree (arg0, code, &con0, &lit0, 0);
5675           var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
5676
5677           /* Only do something if we found more than two objects.  Otherwise,
5678              nothing has changed and we risk infinite recursion.  */
5679           if (2 < ((var0 != 0) + (var1 != 0) + (con0 != 0) + (con1 != 0)
5680                    + (lit0 != 0) + (lit1 != 0)))
5681             {
5682               var0 = associate_trees (var0, var1, code, type);
5683               con0 = associate_trees (con0, con1, code, type);
5684               lit0 = associate_trees (lit0, lit1, code, type);
5685               con0 = associate_trees (con0, lit0, code, type);
5686               return convert (type, associate_trees (var0, con0, code, type));
5687             }
5688         }
5689
5690     binary:
5691 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
5692       if (TREE_CODE (arg1) == REAL_CST)
5693         return t;
5694 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
5695       if (wins)
5696         t1 = const_binop (code, arg0, arg1, 0);
5697       if (t1 != NULL_TREE)
5698         {
5699           /* The return value should always have
5700              the same type as the original expression.  */
5701           if (TREE_TYPE (t1) != TREE_TYPE (t))
5702             t1 = convert (TREE_TYPE (t), t1);
5703
5704           return t1;
5705         }
5706       return t;
5707
5708     case MINUS_EXPR:
5709       /* A - (-B) -> A + B */
5710       if (TREE_CODE (arg1) == NEGATE_EXPR)
5711         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5712       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5713       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5714         return
5715           fold (build (MINUS_EXPR, type,
5716                        build_real (TREE_TYPE (arg1),
5717                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5718                        TREE_OPERAND (arg0, 0)));
5719
5720       if (! FLOAT_TYPE_P (type))
5721         {
5722           if (! wins && integer_zerop (arg0))
5723             return negate_expr (convert (type, arg1));
5724           if (integer_zerop (arg1))
5725             return non_lvalue (convert (type, arg0));
5726
5727           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5728              about the case where C is a constant, just try one of the
5729              four possibilities.  */
5730
5731           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5732               && operand_equal_p (TREE_OPERAND (arg0, 1),
5733                                   TREE_OPERAND (arg1, 1), 0))
5734             return fold (build (MULT_EXPR, type,
5735                                 fold (build (MINUS_EXPR, type,
5736                                              TREE_OPERAND (arg0, 0),
5737                                              TREE_OPERAND (arg1, 0))),
5738                                 TREE_OPERAND (arg0, 1)));
5739         }
5740
5741       else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5742                || flag_unsafe_math_optimizations)
5743         {
5744           /* Except with IEEE floating point, 0-x equals -x.  */
5745           if (! wins && real_zerop (arg0))
5746             return negate_expr (convert (type, arg1));
5747           /* Except with IEEE floating point, x-0 equals x.  */
5748           if (real_zerop (arg1))
5749             return non_lvalue (convert (type, arg0));
5750         }
5751
5752       /* Fold &x - &x.  This can happen from &x.foo - &x.
5753          This is unsafe for certain floats even in non-IEEE formats.
5754          In IEEE, it is unsafe because it does wrong for NaNs.
5755          Also note that operand_equal_p is always false if an operand
5756          is volatile.  */
5757
5758       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
5759           && operand_equal_p (arg0, arg1, 0))
5760         return convert (type, integer_zero_node);
5761
5762       goto associate;
5763
5764     case MULT_EXPR:
5765       /* (-A) * (-B) -> A * B  */
5766       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5767         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5768                             TREE_OPERAND (arg1, 0)));
5769
5770       if (! FLOAT_TYPE_P (type))
5771         {
5772           if (integer_zerop (arg1))
5773             return omit_one_operand (type, arg1, arg0);
5774           if (integer_onep (arg1))
5775             return non_lvalue (convert (type, arg0));
5776
5777           /* (a * (1 << b)) is (a << b)  */
5778           if (TREE_CODE (arg1) == LSHIFT_EXPR
5779               && integer_onep (TREE_OPERAND (arg1, 0)))
5780             return fold (build (LSHIFT_EXPR, type, arg0,
5781                                 TREE_OPERAND (arg1, 1)));
5782           if (TREE_CODE (arg0) == LSHIFT_EXPR
5783               && integer_onep (TREE_OPERAND (arg0, 0)))
5784             return fold (build (LSHIFT_EXPR, type, arg1,
5785                                 TREE_OPERAND (arg0, 1)));
5786
5787           if (TREE_CODE (arg1) == INTEGER_CST
5788               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5789                                              code, NULL_TREE)))
5790             return convert (type, tem);
5791
5792         }
5793       else
5794         {
5795           /* x*0 is 0, except for IEEE floating point.  */
5796           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5797                || flag_unsafe_math_optimizations)
5798               && real_zerop (arg1))
5799             return omit_one_operand (type, arg1, arg0);
5800           /* In IEEE floating point, x*1 is not equivalent to x for snans.
5801              However, ANSI says we can drop signals,
5802              so we can do this anyway.  */
5803           if (real_onep (arg1))
5804             return non_lvalue (convert (type, arg0));
5805           /* x*2 is x+x */
5806           if (! wins && real_twop (arg1) && global_bindings_p () == 0
5807               && ! contains_placeholder_p (arg0))
5808             {
5809               tree arg = save_expr (arg0);
5810               return build (PLUS_EXPR, type, arg, arg);
5811             }
5812         }
5813       goto associate;
5814
5815     case BIT_IOR_EXPR:
5816     bit_ior:
5817       if (integer_all_onesp (arg1))
5818         return omit_one_operand (type, arg1, arg0);
5819       if (integer_zerop (arg1))
5820         return non_lvalue (convert (type, arg0));
5821       t1 = distribute_bit_expr (code, type, arg0, arg1);
5822       if (t1 != NULL_TREE)
5823         return t1;
5824
5825       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5826
5827          This results in more efficient code for machines without a NAND
5828          instruction.  Combine will canonicalize to the first form
5829          which will allow use of NAND instructions provided by the
5830          backend if they exist.  */
5831       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5832           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5833         {
5834           return fold (build1 (BIT_NOT_EXPR, type,
5835                                build (BIT_AND_EXPR, type,
5836                                       TREE_OPERAND (arg0, 0),
5837                                       TREE_OPERAND (arg1, 0))));
5838         }
5839
5840       /* See if this can be simplified into a rotate first.  If that
5841          is unsuccessful continue in the association code.  */
5842       goto bit_rotate;
5843
5844     case BIT_XOR_EXPR:
5845       if (integer_zerop (arg1))
5846         return non_lvalue (convert (type, arg0));
5847       if (integer_all_onesp (arg1))
5848         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5849
5850       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5851          with a constant, and the two constants have no bits in common,
5852          we should treat this as a BIT_IOR_EXPR since this may produce more
5853          simplifications.  */
5854       if (TREE_CODE (arg0) == BIT_AND_EXPR
5855           && TREE_CODE (arg1) == BIT_AND_EXPR
5856           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5857           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5858           && integer_zerop (const_binop (BIT_AND_EXPR,
5859                                          TREE_OPERAND (arg0, 1),
5860                                          TREE_OPERAND (arg1, 1), 0)))
5861         {
5862           code = BIT_IOR_EXPR;
5863           goto bit_ior;
5864         }
5865
5866       /* See if this can be simplified into a rotate first.  If that
5867          is unsuccessful continue in the association code.  */
5868       goto bit_rotate;
5869
5870     case BIT_AND_EXPR:
5871     bit_and:
5872       if (integer_all_onesp (arg1))
5873         return non_lvalue (convert (type, arg0));
5874       if (integer_zerop (arg1))
5875         return omit_one_operand (type, arg1, arg0);
5876       t1 = distribute_bit_expr (code, type, arg0, arg1);
5877       if (t1 != NULL_TREE)
5878         return t1;
5879       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5880       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5881           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5882         {
5883           unsigned int prec
5884             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5885
5886           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5887               && (~TREE_INT_CST_LOW (arg0)
5888                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5889             return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5890         }
5891       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5892           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5893         {
5894           unsigned int prec
5895             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5896
5897           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5898               && (~TREE_INT_CST_LOW (arg1)
5899                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5900             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5901         }
5902
5903       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5904
5905          This results in more efficient code for machines without a NOR
5906          instruction.  Combine will canonicalize to the first form
5907          which will allow use of NOR instructions provided by the
5908          backend if they exist.  */
5909       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5910           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5911         {
5912           return fold (build1 (BIT_NOT_EXPR, type,
5913                                build (BIT_IOR_EXPR, type,
5914                                       TREE_OPERAND (arg0, 0),
5915                                       TREE_OPERAND (arg1, 0))));
5916         }
5917
5918       goto associate;
5919
5920     case BIT_ANDTC_EXPR:
5921       if (integer_all_onesp (arg0))
5922         return non_lvalue (convert (type, arg1));
5923       if (integer_zerop (arg0))
5924         return omit_one_operand (type, arg0, arg1);
5925       if (TREE_CODE (arg1) == INTEGER_CST)
5926         {
5927           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5928           code = BIT_AND_EXPR;
5929           goto bit_and;
5930         }
5931       goto binary;
5932
5933     case RDIV_EXPR:
5934       /* In most cases, do nothing with a divide by zero.  */
5935 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5936 #ifndef REAL_INFINITY
5937       if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5938         return t;
5939 #endif
5940 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5941
5942       /* (-A) / (-B) -> A / B  */
5943       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5944         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5945                             TREE_OPERAND (arg1, 0)));
5946
5947       /* In IEEE floating point, x/1 is not equivalent to x for snans.
5948          However, ANSI says we can drop signals, so we can do this anyway.  */
5949       if (real_onep (arg1))
5950         return non_lvalue (convert (type, arg0));
5951
5952       /* If ARG1 is a constant, we can convert this to a multiply by the
5953          reciprocal.  This does not have the same rounding properties,
5954          so only do this if -funsafe-math-optimizations.  We can actually
5955          always safely do it if ARG1 is a power of two, but it's hard to
5956          tell if it is or not in a portable manner.  */
5957       if (TREE_CODE (arg1) == REAL_CST)
5958         {
5959           if (flag_unsafe_math_optimizations
5960               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5961                                           arg1, 0)))
5962             return fold (build (MULT_EXPR, type, arg0, tem));
5963           /* Find the reciprocal if optimizing and the result is exact.  */
5964           else if (optimize)
5965             {
5966               REAL_VALUE_TYPE r;
5967               r = TREE_REAL_CST (arg1);
5968               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5969                 {
5970                   tem = build_real (type, r);
5971                   return fold (build (MULT_EXPR, type, arg0, tem));
5972                 }
5973             }
5974         }
5975       /* Convert A/B/C to A/(B*C).  */
5976       if (flag_unsafe_math_optimizations
5977           && TREE_CODE (arg0) == RDIV_EXPR)
5978         {
5979           return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5980                               build (MULT_EXPR, type, TREE_OPERAND (arg0, 1),
5981                                      arg1)));
5982         }
5983       /* Convert A/(B/C) to (A/B)*C.  */
5984       if (flag_unsafe_math_optimizations
5985           && TREE_CODE (arg1) == RDIV_EXPR)
5986         {
5987           return fold (build (MULT_EXPR, type,
5988                               build (RDIV_EXPR, type, arg0,
5989                                      TREE_OPERAND (arg1, 0)),
5990                               TREE_OPERAND (arg1, 1)));
5991         }
5992       goto binary;
5993
5994     case TRUNC_DIV_EXPR:
5995     case ROUND_DIV_EXPR:
5996     case FLOOR_DIV_EXPR:
5997     case CEIL_DIV_EXPR:
5998     case EXACT_DIV_EXPR:
5999       if (integer_onep (arg1))
6000         return non_lvalue (convert (type, arg0));
6001       if (integer_zerop (arg1))
6002         return t;
6003
6004       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
6005          operation, EXACT_DIV_EXPR.
6006
6007          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
6008          At one time others generated faster code, it's not clear if they do
6009          after the last round to changes to the DIV code in expmed.c.  */
6010       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
6011           && multiple_of_p (type, arg0, arg1))
6012         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
6013
6014       if (TREE_CODE (arg1) == INTEGER_CST
6015           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6016                                          code, NULL_TREE)))
6017         return convert (type, tem);
6018
6019       goto binary;
6020
6021     case CEIL_MOD_EXPR:
6022     case FLOOR_MOD_EXPR:
6023     case ROUND_MOD_EXPR:
6024     case TRUNC_MOD_EXPR:
6025       if (integer_onep (arg1))
6026         return omit_one_operand (type, integer_zero_node, arg0);
6027       if (integer_zerop (arg1))
6028         return t;
6029
6030       if (TREE_CODE (arg1) == INTEGER_CST
6031           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6032                                          code, NULL_TREE)))
6033         return convert (type, tem);
6034
6035       goto binary;
6036
6037     case LSHIFT_EXPR:
6038     case RSHIFT_EXPR:
6039     case LROTATE_EXPR:
6040     case RROTATE_EXPR:
6041       if (integer_zerop (arg1))
6042         return non_lvalue (convert (type, arg0));
6043       /* Since negative shift count is not well-defined,
6044          don't try to compute it in the compiler.  */
6045       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
6046         return t;
6047       /* Rewrite an LROTATE_EXPR by a constant into an
6048          RROTATE_EXPR by a new constant.  */
6049       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
6050         {
6051           TREE_SET_CODE (t, RROTATE_EXPR);
6052           code = RROTATE_EXPR;
6053           TREE_OPERAND (t, 1) = arg1
6054             = const_binop
6055               (MINUS_EXPR,
6056                convert (TREE_TYPE (arg1),
6057                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
6058                arg1, 0);
6059           if (tree_int_cst_sgn (arg1) < 0)
6060             return t;
6061         }
6062
6063       /* If we have a rotate of a bit operation with the rotate count and
6064          the second operand of the bit operation both constant,
6065          permute the two operations.  */
6066       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6067           && (TREE_CODE (arg0) == BIT_AND_EXPR
6068               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
6069               || TREE_CODE (arg0) == BIT_IOR_EXPR
6070               || TREE_CODE (arg0) == BIT_XOR_EXPR)
6071           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6072         return fold (build (TREE_CODE (arg0), type,
6073                             fold (build (code, type,
6074                                          TREE_OPERAND (arg0, 0), arg1)),
6075                             fold (build (code, type,
6076                                          TREE_OPERAND (arg0, 1), arg1))));
6077
6078       /* Two consecutive rotates adding up to the width of the mode can
6079          be ignored.  */
6080       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6081           && TREE_CODE (arg0) == RROTATE_EXPR
6082           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6083           && TREE_INT_CST_HIGH (arg1) == 0
6084           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
6085           && ((TREE_INT_CST_LOW (arg1)
6086                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
6087               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
6088         return TREE_OPERAND (arg0, 0);
6089
6090       goto binary;
6091
6092     case MIN_EXPR:
6093       if (operand_equal_p (arg0, arg1, 0))
6094         return omit_one_operand (type, arg0, arg1);
6095       if (INTEGRAL_TYPE_P (type)
6096           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
6097         return omit_one_operand (type, arg1, arg0);
6098       goto associate;
6099
6100     case MAX_EXPR:
6101       if (operand_equal_p (arg0, arg1, 0))
6102         return omit_one_operand (type, arg0, arg1);
6103       if (INTEGRAL_TYPE_P (type)
6104           && TYPE_MAX_VALUE (type)
6105           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
6106         return omit_one_operand (type, arg1, arg0);
6107       goto associate;
6108
6109     case TRUTH_NOT_EXPR:
6110       /* Note that the operand of this must be an int
6111          and its values must be 0 or 1.
6112          ("true" is a fixed value perhaps depending on the language,
6113          but we don't handle values other than 1 correctly yet.)  */
6114       tem = invert_truthvalue (arg0);
6115       /* Avoid infinite recursion.  */
6116       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
6117         return t;
6118       return convert (type, tem);
6119
6120     case TRUTH_ANDIF_EXPR:
6121       /* Note that the operands of this must be ints
6122          and their values must be 0 or 1.
6123          ("true" is a fixed value perhaps depending on the language.)  */
6124       /* If first arg is constant zero, return it.  */
6125       if (integer_zerop (arg0))
6126         return convert (type, arg0);
6127     case TRUTH_AND_EXPR:
6128       /* If either arg is constant true, drop it.  */
6129       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6130         return non_lvalue (convert (type, arg1));
6131       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
6132           /* Preserve sequence points.  */
6133           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6134         return non_lvalue (convert (type, arg0));
6135       /* If second arg is constant zero, result is zero, but first arg
6136          must be evaluated.  */
6137       if (integer_zerop (arg1))
6138         return omit_one_operand (type, arg1, arg0);
6139       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
6140          case will be handled here.  */
6141       if (integer_zerop (arg0))
6142         return omit_one_operand (type, arg0, arg1);
6143
6144     truth_andor:
6145       /* We only do these simplifications if we are optimizing.  */
6146       if (!optimize)
6147         return t;
6148
6149       /* Check for things like (A || B) && (A || C).  We can convert this
6150          to A || (B && C).  Note that either operator can be any of the four
6151          truth and/or operations and the transformation will still be
6152          valid.   Also note that we only care about order for the
6153          ANDIF and ORIF operators.  If B contains side effects, this
6154          might change the truth-value of A.  */
6155       if (TREE_CODE (arg0) == TREE_CODE (arg1)
6156           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
6157               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
6158               || TREE_CODE (arg0) == TRUTH_AND_EXPR
6159               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
6160           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
6161         {
6162           tree a00 = TREE_OPERAND (arg0, 0);
6163           tree a01 = TREE_OPERAND (arg0, 1);
6164           tree a10 = TREE_OPERAND (arg1, 0);
6165           tree a11 = TREE_OPERAND (arg1, 1);
6166           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
6167                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
6168                              && (code == TRUTH_AND_EXPR
6169                                  || code == TRUTH_OR_EXPR));
6170
6171           if (operand_equal_p (a00, a10, 0))
6172             return fold (build (TREE_CODE (arg0), type, a00,
6173                                 fold (build (code, type, a01, a11))));
6174           else if (commutative && operand_equal_p (a00, a11, 0))
6175             return fold (build (TREE_CODE (arg0), type, a00,
6176                                 fold (build (code, type, a01, a10))));
6177           else if (commutative && operand_equal_p (a01, a10, 0))
6178             return fold (build (TREE_CODE (arg0), type, a01,
6179                                 fold (build (code, type, a00, a11))));
6180
6181           /* This case if tricky because we must either have commutative
6182              operators or else A10 must not have side-effects.  */
6183
6184           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
6185                    && operand_equal_p (a01, a11, 0))
6186             return fold (build (TREE_CODE (arg0), type,
6187                                 fold (build (code, type, a00, a10)),
6188                                 a01));
6189         }
6190
6191       /* See if we can build a range comparison.  */
6192       if (0 != (tem = fold_range_test (t)))
6193         return tem;
6194
6195       /* Check for the possibility of merging component references.  If our
6196          lhs is another similar operation, try to merge its rhs with our
6197          rhs.  Then try to merge our lhs and rhs.  */
6198       if (TREE_CODE (arg0) == code
6199           && 0 != (tem = fold_truthop (code, type,
6200                                        TREE_OPERAND (arg0, 1), arg1)))
6201         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6202
6203       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
6204         return tem;
6205
6206       return t;
6207
6208     case TRUTH_ORIF_EXPR:
6209       /* Note that the operands of this must be ints
6210          and their values must be 0 or true.
6211          ("true" is a fixed value perhaps depending on the language.)  */
6212       /* If first arg is constant true, return it.  */
6213       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6214         return convert (type, arg0);
6215     case TRUTH_OR_EXPR:
6216       /* If either arg is constant zero, drop it.  */
6217       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
6218         return non_lvalue (convert (type, arg1));
6219       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
6220           /* Preserve sequence points.  */
6221           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6222         return non_lvalue (convert (type, arg0));
6223       /* If second arg is constant true, result is true, but we must
6224          evaluate first arg.  */
6225       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
6226         return omit_one_operand (type, arg1, arg0);
6227       /* Likewise for first arg, but note this only occurs here for
6228          TRUTH_OR_EXPR.  */
6229       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6230         return omit_one_operand (type, arg0, arg1);
6231       goto truth_andor;
6232
6233     case TRUTH_XOR_EXPR:
6234       /* If either arg is constant zero, drop it.  */
6235       if (integer_zerop (arg0))
6236         return non_lvalue (convert (type, arg1));
6237       if (integer_zerop (arg1))
6238         return non_lvalue (convert (type, arg0));
6239       /* If either arg is constant true, this is a logical inversion.  */
6240       if (integer_onep (arg0))
6241         return non_lvalue (convert (type, invert_truthvalue (arg1)));
6242       if (integer_onep (arg1))
6243         return non_lvalue (convert (type, invert_truthvalue (arg0)));
6244       return t;
6245
6246     case EQ_EXPR:
6247     case NE_EXPR:
6248     case LT_EXPR:
6249     case GT_EXPR:
6250     case LE_EXPR:
6251     case GE_EXPR:
6252       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6253         {
6254           /* (-a) CMP (-b) -> b CMP a  */
6255           if (TREE_CODE (arg0) == NEGATE_EXPR
6256               && TREE_CODE (arg1) == NEGATE_EXPR)
6257             return fold (build (code, type, TREE_OPERAND (arg1, 0),
6258                                 TREE_OPERAND (arg0, 0)));
6259           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
6260           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
6261             return
6262               fold (build
6263                     (swap_tree_comparison (code), type,
6264                      TREE_OPERAND (arg0, 0),
6265                      build_real (TREE_TYPE (arg1),
6266                                  REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
6267           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
6268           /* a CMP (-0) -> a CMP 0  */
6269           if (TREE_CODE (arg1) == REAL_CST
6270               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
6271             return fold (build (code, type, arg0,
6272                                 build_real (TREE_TYPE (arg1), dconst0)));
6273         }
6274
6275       /* If one arg is a constant integer, put it last.  */
6276       if (TREE_CODE (arg0) == INTEGER_CST
6277           && TREE_CODE (arg1) != INTEGER_CST)
6278         {
6279           TREE_OPERAND (t, 0) = arg1;
6280           TREE_OPERAND (t, 1) = arg0;
6281           arg0 = TREE_OPERAND (t, 0);
6282           arg1 = TREE_OPERAND (t, 1);
6283           code = swap_tree_comparison (code);
6284           TREE_SET_CODE (t, code);
6285         }
6286
6287       /* Convert foo++ == CONST into ++foo == CONST + INCR.
6288          First, see if one arg is constant; find the constant arg
6289          and the other one.  */
6290       {
6291         tree constop = 0, varop = NULL_TREE;
6292         int constopnum = -1;
6293
6294         if (TREE_CONSTANT (arg1))
6295           constopnum = 1, constop = arg1, varop = arg0;
6296         if (TREE_CONSTANT (arg0))
6297           constopnum = 0, constop = arg0, varop = arg1;
6298
6299         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
6300           {
6301             /* This optimization is invalid for ordered comparisons
6302                if CONST+INCR overflows or if foo+incr might overflow.
6303                This optimization is invalid for floating point due to rounding.
6304                For pointer types we assume overflow doesn't happen.  */
6305             if (POINTER_TYPE_P (TREE_TYPE (varop))
6306                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6307                     && (code == EQ_EXPR || code == NE_EXPR)))
6308               {
6309                 tree newconst
6310                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6311                                  constop, TREE_OPERAND (varop, 1)));
6312
6313                 /* Do not overwrite the current varop to be a preincrement,
6314                    create a new node so that we won't confuse our caller who
6315                    might create trees and throw them away, reusing the
6316                    arguments that they passed to build.  This shows up in
6317                    the THEN or ELSE parts of ?: being postincrements.  */
6318                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6319                                TREE_OPERAND (varop, 0),
6320                                TREE_OPERAND (varop, 1));
6321
6322                 /* If VAROP is a reference to a bitfield, we must mask
6323                    the constant by the width of the field.  */
6324                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6325                     && DECL_BIT_FIELD(TREE_OPERAND
6326                                       (TREE_OPERAND (varop, 0), 1)))
6327                   {
6328                     int size
6329                       = TREE_INT_CST_LOW (DECL_SIZE
6330                                           (TREE_OPERAND
6331                                            (TREE_OPERAND (varop, 0), 1)));
6332                     tree mask, unsigned_type;
6333                     unsigned int precision;
6334                     tree folded_compare;
6335
6336                     /* First check whether the comparison would come out
6337                        always the same.  If we don't do that we would
6338                        change the meaning with the masking.  */
6339                     if (constopnum == 0)
6340                       folded_compare = fold (build (code, type, constop,
6341                                                     TREE_OPERAND (varop, 0)));
6342                     else
6343                       folded_compare = fold (build (code, type,
6344                                                     TREE_OPERAND (varop, 0),
6345                                                     constop));
6346                     if (integer_zerop (folded_compare)
6347                         || integer_onep (folded_compare))
6348                       return omit_one_operand (type, folded_compare, varop);
6349
6350                     unsigned_type = type_for_size (size, 1);
6351                     precision = TYPE_PRECISION (unsigned_type);
6352                     mask = build_int_2 (~0, ~0);
6353                     TREE_TYPE (mask) = unsigned_type;
6354                     force_fit_type (mask, 0);
6355                     mask = const_binop (RSHIFT_EXPR, mask,
6356                                         size_int (precision - size), 0);
6357                     newconst = fold (build (BIT_AND_EXPR,
6358                                             TREE_TYPE (varop), newconst,
6359                                             convert (TREE_TYPE (varop),
6360                                                      mask)));
6361                   }
6362
6363                 t = build (code, type,
6364                            (constopnum == 0) ? newconst : varop,
6365                            (constopnum == 1) ? newconst : varop);
6366                 return t;
6367               }
6368           }
6369         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6370           {
6371             if (POINTER_TYPE_P (TREE_TYPE (varop))
6372                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6373                     && (code == EQ_EXPR || code == NE_EXPR)))
6374               {
6375                 tree newconst
6376                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6377                                  constop, TREE_OPERAND (varop, 1)));
6378
6379                 /* Do not overwrite the current varop to be a predecrement,
6380                    create a new node so that we won't confuse our caller who
6381                    might create trees and throw them away, reusing the
6382                    arguments that they passed to build.  This shows up in
6383                    the THEN or ELSE parts of ?: being postdecrements.  */
6384                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6385                                TREE_OPERAND (varop, 0),
6386                                TREE_OPERAND (varop, 1));
6387
6388                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6389                     && DECL_BIT_FIELD(TREE_OPERAND
6390                                       (TREE_OPERAND (varop, 0), 1)))
6391                   {
6392                     int size
6393                       = TREE_INT_CST_LOW (DECL_SIZE
6394                                           (TREE_OPERAND
6395                                            (TREE_OPERAND (varop, 0), 1)));
6396                     tree mask, unsigned_type;
6397                     unsigned int precision;
6398                     tree folded_compare;
6399
6400                     if (constopnum == 0)
6401                       folded_compare = fold (build (code, type, constop,
6402                                                     TREE_OPERAND (varop, 0)));
6403                     else
6404                       folded_compare = fold (build (code, type,
6405                                                     TREE_OPERAND (varop, 0),
6406                                                     constop));
6407                     if (integer_zerop (folded_compare)
6408                         || integer_onep (folded_compare))
6409                       return omit_one_operand (type, folded_compare, varop);
6410
6411                     unsigned_type = type_for_size (size, 1);
6412                     precision = TYPE_PRECISION (unsigned_type);
6413                     mask = build_int_2 (~0, ~0);
6414                     TREE_TYPE (mask) = TREE_TYPE (varop);
6415                     force_fit_type (mask, 0);
6416                     mask = const_binop (RSHIFT_EXPR, mask,
6417                                         size_int (precision - size), 0);
6418                     newconst = fold (build (BIT_AND_EXPR,
6419                                             TREE_TYPE (varop), newconst,
6420                                             convert (TREE_TYPE (varop),
6421                                                      mask)));
6422                   }
6423
6424                 t = build (code, type,
6425                            (constopnum == 0) ? newconst : varop,
6426                            (constopnum == 1) ? newconst : varop);
6427                 return t;
6428               }
6429           }
6430       }
6431
6432       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
6433       if (TREE_CODE (arg1) == INTEGER_CST
6434           && TREE_CODE (arg0) != INTEGER_CST
6435           && tree_int_cst_sgn (arg1) > 0)
6436         {
6437           switch (TREE_CODE (t))
6438             {
6439             case GE_EXPR:
6440               code = GT_EXPR;
6441               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6442               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6443               break;
6444
6445             case LT_EXPR:
6446               code = LE_EXPR;
6447               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6448               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6449               break;
6450
6451             default:
6452               break;
6453             }
6454         }
6455
6456       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6457          a MINUS_EXPR of a constant, we can convert it into a comparison with
6458          a revised constant as long as no overflow occurs.  */
6459       if ((code == EQ_EXPR || code == NE_EXPR)
6460           && TREE_CODE (arg1) == INTEGER_CST
6461           && (TREE_CODE (arg0) == PLUS_EXPR
6462               || TREE_CODE (arg0) == MINUS_EXPR)
6463           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6464           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6465                                       ? MINUS_EXPR : PLUS_EXPR,
6466                                       arg1, TREE_OPERAND (arg0, 1), 0))
6467           && ! TREE_CONSTANT_OVERFLOW (tem))
6468         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6469
6470       /* Similarly for a NEGATE_EXPR.  */
6471       else if ((code == EQ_EXPR || code == NE_EXPR)
6472                && TREE_CODE (arg0) == NEGATE_EXPR
6473                && TREE_CODE (arg1) == INTEGER_CST
6474                && 0 != (tem = negate_expr (arg1))
6475                && TREE_CODE (tem) == INTEGER_CST
6476                && ! TREE_CONSTANT_OVERFLOW (tem))
6477         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6478
6479       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6480          for !=.  Don't do this for ordered comparisons due to overflow.  */
6481       else if ((code == NE_EXPR || code == EQ_EXPR)
6482                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6483         return fold (build (code, type,
6484                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6485
6486       /* If we are widening one operand of an integer comparison,
6487          see if the other operand is similarly being widened.  Perhaps we
6488          can do the comparison in the narrower type.  */
6489       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6490                && TREE_CODE (arg0) == NOP_EXPR
6491                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6492                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6493                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6494                    || (TREE_CODE (t1) == INTEGER_CST
6495                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6496         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6497
6498       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6499          constant, we can simplify it.  */
6500       else if (TREE_CODE (arg1) == INTEGER_CST
6501                && (TREE_CODE (arg0) == MIN_EXPR
6502                    || TREE_CODE (arg0) == MAX_EXPR)
6503                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6504         return optimize_minmax_comparison (t);
6505
6506       /* If we are comparing an ABS_EXPR with a constant, we can
6507          convert all the cases into explicit comparisons, but they may
6508          well not be faster than doing the ABS and one comparison.
6509          But ABS (X) <= C is a range comparison, which becomes a subtraction
6510          and a comparison, and is probably faster.  */
6511       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6512                && TREE_CODE (arg0) == ABS_EXPR
6513                && ! TREE_SIDE_EFFECTS (arg0)
6514                && (0 != (tem = negate_expr (arg1)))
6515                && TREE_CODE (tem) == INTEGER_CST
6516                && ! TREE_CONSTANT_OVERFLOW (tem))
6517         return fold (build (TRUTH_ANDIF_EXPR, type,
6518                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6519                             build (LE_EXPR, type,
6520                                    TREE_OPERAND (arg0, 0), arg1)));
6521
6522       /* If this is an EQ or NE comparison with zero and ARG0 is
6523          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6524          two operations, but the latter can be done in one less insn
6525          on machines that have only two-operand insns or on which a
6526          constant cannot be the first operand.  */
6527       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6528           && TREE_CODE (arg0) == BIT_AND_EXPR)
6529         {
6530           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6531               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6532             return
6533               fold (build (code, type,
6534                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6535                                   build (RSHIFT_EXPR,
6536                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6537                                          TREE_OPERAND (arg0, 1),
6538                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6539                                   convert (TREE_TYPE (arg0),
6540                                            integer_one_node)),
6541                            arg1));
6542           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6543                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6544             return
6545               fold (build (code, type,
6546                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6547                                   build (RSHIFT_EXPR,
6548                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6549                                          TREE_OPERAND (arg0, 0),
6550                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6551                                   convert (TREE_TYPE (arg0),
6552                                            integer_one_node)),
6553                            arg1));
6554         }
6555
6556       /* If this is an NE or EQ comparison of zero against the result of a
6557          signed MOD operation whose second operand is a power of 2, make
6558          the MOD operation unsigned since it is simpler and equivalent.  */
6559       if ((code == NE_EXPR || code == EQ_EXPR)
6560           && integer_zerop (arg1)
6561           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6562           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6563               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6564               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6565               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6566           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6567         {
6568           tree newtype = unsigned_type (TREE_TYPE (arg0));
6569           tree newmod = build (TREE_CODE (arg0), newtype,
6570                                convert (newtype, TREE_OPERAND (arg0, 0)),
6571                                convert (newtype, TREE_OPERAND (arg0, 1)));
6572
6573           return build (code, type, newmod, convert (newtype, arg1));
6574         }
6575
6576       /* If this is an NE comparison of zero with an AND of one, remove the
6577          comparison since the AND will give the correct value.  */
6578       if (code == NE_EXPR && integer_zerop (arg1)
6579           && TREE_CODE (arg0) == BIT_AND_EXPR
6580           && integer_onep (TREE_OPERAND (arg0, 1)))
6581         return convert (type, arg0);
6582
6583       /* If we have (A & C) == C where C is a power of 2, convert this into
6584          (A & C) != 0.  Similarly for NE_EXPR.  */
6585       if ((code == EQ_EXPR || code == NE_EXPR)
6586           && TREE_CODE (arg0) == BIT_AND_EXPR
6587           && integer_pow2p (TREE_OPERAND (arg0, 1))
6588           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6589         return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6590                       arg0, integer_zero_node);
6591
6592       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6593          and similarly for >= into !=.  */
6594       if ((code == LT_EXPR || code == GE_EXPR)
6595           && TREE_UNSIGNED (TREE_TYPE (arg0))
6596           && TREE_CODE (arg1) == LSHIFT_EXPR
6597           && integer_onep (TREE_OPERAND (arg1, 0)))
6598         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6599                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6600                              TREE_OPERAND (arg1, 1)),
6601                       convert (TREE_TYPE (arg0), integer_zero_node));
6602
6603       else if ((code == LT_EXPR || code == GE_EXPR)
6604                && TREE_UNSIGNED (TREE_TYPE (arg0))
6605                && (TREE_CODE (arg1) == NOP_EXPR
6606                    || TREE_CODE (arg1) == CONVERT_EXPR)
6607                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6608                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6609         return
6610           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6611                  convert (TREE_TYPE (arg0),
6612                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6613                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6614                  convert (TREE_TYPE (arg0), integer_zero_node));
6615
6616       /* Simplify comparison of something with itself.  (For IEEE
6617          floating-point, we can only do some of these simplifications.)  */
6618       if (operand_equal_p (arg0, arg1, 0))
6619         {
6620           switch (code)
6621             {
6622             case EQ_EXPR:
6623             case GE_EXPR:
6624             case LE_EXPR:
6625               if (! FLOAT_TYPE_P (TREE_TYPE (arg0)))
6626                 return constant_boolean_node (1, type);
6627               code = EQ_EXPR;
6628               TREE_SET_CODE (t, code);
6629               break;
6630
6631             case NE_EXPR:
6632               /* For NE, we can only do this simplification if integer.  */
6633               if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6634                 break;
6635               /* ... fall through ...  */
6636             case GT_EXPR:
6637             case LT_EXPR:
6638               return constant_boolean_node (0, type);
6639             default:
6640               abort ();
6641             }
6642         }
6643
6644       /* An unsigned comparison against 0 can be simplified.  */
6645       if (integer_zerop (arg1)
6646           && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6647               || POINTER_TYPE_P (TREE_TYPE (arg1)))
6648           && TREE_UNSIGNED (TREE_TYPE (arg1)))
6649         {
6650           switch (TREE_CODE (t))
6651             {
6652             case GT_EXPR:
6653               code = NE_EXPR;
6654               TREE_SET_CODE (t, NE_EXPR);
6655               break;
6656             case LE_EXPR:
6657               code = EQ_EXPR;
6658               TREE_SET_CODE (t, EQ_EXPR);
6659               break;
6660             case GE_EXPR:
6661               return omit_one_operand (type,
6662                                        convert (type, integer_one_node),
6663                                        arg0);
6664             case LT_EXPR:
6665               return omit_one_operand (type,
6666                                        convert (type, integer_zero_node),
6667                                        arg0);
6668             default:
6669               break;
6670             }
6671         }
6672
6673       /* Comparisons with the highest or lowest possible integer of
6674          the specified size will have known values and an unsigned
6675          <= 0x7fffffff can be simplified.  */
6676       {
6677         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6678
6679         if (TREE_CODE (arg1) == INTEGER_CST
6680             && ! TREE_CONSTANT_OVERFLOW (arg1)
6681             && width <= HOST_BITS_PER_WIDE_INT
6682             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6683                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6684           {
6685             if (TREE_INT_CST_HIGH (arg1) == 0
6686                 && (TREE_INT_CST_LOW (arg1)
6687                     == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6688                 && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6689               switch (TREE_CODE (t))
6690                 {
6691                 case GT_EXPR:
6692                   return omit_one_operand (type,
6693                                            convert (type, integer_zero_node),
6694                                            arg0);
6695                 case GE_EXPR:
6696                   TREE_SET_CODE (t, EQ_EXPR);
6697                   break;
6698
6699                 case LE_EXPR:
6700                   return omit_one_operand (type,
6701                                            convert (type, integer_one_node),
6702                                            arg0);
6703                 case LT_EXPR:
6704                   TREE_SET_CODE (t, NE_EXPR);
6705                   break;
6706
6707                 default:
6708                   break;
6709                 }
6710
6711             else if (TREE_INT_CST_HIGH (arg1) == -1
6712                      && (- TREE_INT_CST_LOW (arg1)
6713                          == ((unsigned HOST_WIDE_INT) 1 << (width - 1)))
6714                      && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6715               switch (TREE_CODE (t))
6716                 {
6717                 case LT_EXPR:
6718                   return omit_one_operand (type,
6719                                            convert (type, integer_zero_node),
6720                                            arg0);
6721                 case LE_EXPR:
6722                   TREE_SET_CODE (t, EQ_EXPR);
6723                   break;
6724
6725                 case GE_EXPR:
6726                   return omit_one_operand (type,
6727                                            convert (type, integer_one_node),
6728                                            arg0);
6729                 case GT_EXPR:
6730                   TREE_SET_CODE (t, NE_EXPR);
6731                   break;
6732
6733                 default:
6734                   break;
6735                 }
6736
6737             else if (TREE_INT_CST_HIGH (arg1) == 0
6738                       && (TREE_INT_CST_LOW (arg1)
6739                           == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6740                       && TREE_UNSIGNED (TREE_TYPE (arg1))
6741                          /* signed_type does not work on pointer types.  */
6742                       && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6743
6744               switch (TREE_CODE (t))
6745                 {
6746                 case LE_EXPR:
6747                   return fold (build (GE_EXPR, type,
6748                                       convert (signed_type (TREE_TYPE (arg0)),
6749                                                arg0),
6750                                       convert (signed_type (TREE_TYPE (arg1)),
6751                                                integer_zero_node)));
6752                 case GT_EXPR:
6753                   return fold (build (LT_EXPR, type,
6754                                       convert (signed_type (TREE_TYPE (arg0)),
6755                                                arg0),
6756                                       convert (signed_type (TREE_TYPE (arg1)),
6757                                                integer_zero_node)));
6758
6759                 default:
6760                   break;
6761                 }
6762           }
6763       }
6764
6765       /* If we are comparing an expression that just has comparisons
6766          of two integer values, arithmetic expressions of those comparisons,
6767          and constants, we can simplify it.  There are only three cases
6768          to check: the two values can either be equal, the first can be
6769          greater, or the second can be greater.  Fold the expression for
6770          those three values.  Since each value must be 0 or 1, we have
6771          eight possibilities, each of which corresponds to the constant 0
6772          or 1 or one of the six possible comparisons.
6773
6774          This handles common cases like (a > b) == 0 but also handles
6775          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6776          occur in macroized code.  */
6777
6778       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6779         {
6780           tree cval1 = 0, cval2 = 0;
6781           int save_p = 0;
6782
6783           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6784               /* Don't handle degenerate cases here; they should already
6785                  have been handled anyway.  */
6786               && cval1 != 0 && cval2 != 0
6787               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6788               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6789               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6790               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6791               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6792               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6793                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6794             {
6795               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6796               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6797
6798               /* We can't just pass T to eval_subst in case cval1 or cval2
6799                  was the same as ARG1.  */
6800
6801               tree high_result
6802                 = fold (build (code, type,
6803                                eval_subst (arg0, cval1, maxval, cval2, minval),
6804                                arg1));
6805               tree equal_result
6806                 = fold (build (code, type,
6807                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6808                                arg1));
6809               tree low_result
6810                 = fold (build (code, type,
6811                                eval_subst (arg0, cval1, minval, cval2, maxval),
6812                                arg1));
6813
6814               /* All three of these results should be 0 or 1.  Confirm they
6815                  are.  Then use those values to select the proper code
6816                  to use.  */
6817
6818               if ((integer_zerop (high_result)
6819                    || integer_onep (high_result))
6820                   && (integer_zerop (equal_result)
6821                       || integer_onep (equal_result))
6822                   && (integer_zerop (low_result)
6823                       || integer_onep (low_result)))
6824                 {
6825                   /* Make a 3-bit mask with the high-order bit being the
6826                      value for `>', the next for '=', and the low for '<'.  */
6827                   switch ((integer_onep (high_result) * 4)
6828                           + (integer_onep (equal_result) * 2)
6829                           + integer_onep (low_result))
6830                     {
6831                     case 0:
6832                       /* Always false.  */
6833                       return omit_one_operand (type, integer_zero_node, arg0);
6834                     case 1:
6835                       code = LT_EXPR;
6836                       break;
6837                     case 2:
6838                       code = EQ_EXPR;
6839                       break;
6840                     case 3:
6841                       code = LE_EXPR;
6842                       break;
6843                     case 4:
6844                       code = GT_EXPR;
6845                       break;
6846                     case 5:
6847                       code = NE_EXPR;
6848                       break;
6849                     case 6:
6850                       code = GE_EXPR;
6851                       break;
6852                     case 7:
6853                       /* Always true.  */
6854                       return omit_one_operand (type, integer_one_node, arg0);
6855                     }
6856
6857                   t = build (code, type, cval1, cval2);
6858                   if (save_p)
6859                     return save_expr (t);
6860                   else
6861                     return fold (t);
6862                 }
6863             }
6864         }
6865
6866       /* If this is a comparison of a field, we may be able to simplify it.  */
6867       if ((TREE_CODE (arg0) == COMPONENT_REF
6868            || TREE_CODE (arg0) == BIT_FIELD_REF)
6869           && (code == EQ_EXPR || code == NE_EXPR)
6870           /* Handle the constant case even without -O
6871              to make sure the warnings are given.  */
6872           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6873         {
6874           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6875           return t1 ? t1 : t;
6876         }
6877
6878       /* If this is a comparison of complex values and either or both sides
6879          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6880          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6881          This may prevent needless evaluations.  */
6882       if ((code == EQ_EXPR || code == NE_EXPR)
6883           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6884           && (TREE_CODE (arg0) == COMPLEX_EXPR
6885               || TREE_CODE (arg1) == COMPLEX_EXPR
6886               || TREE_CODE (arg0) == COMPLEX_CST
6887               || TREE_CODE (arg1) == COMPLEX_CST))
6888         {
6889           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6890           tree real0, imag0, real1, imag1;
6891
6892           arg0 = save_expr (arg0);
6893           arg1 = save_expr (arg1);
6894           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6895           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6896           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6897           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6898
6899           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6900                                : TRUTH_ORIF_EXPR),
6901                               type,
6902                               fold (build (code, type, real0, real1)),
6903                               fold (build (code, type, imag0, imag1))));
6904         }
6905
6906       /* Optimize comparisons of strlen vs zero to a compare of the
6907          first character of the string vs zero.  To wit,
6908                 strlen(ptr) == 0   =>  *ptr == 0
6909                 strlen(ptr) != 0   =>  *ptr != 0
6910          Other cases should reduce to one of these two (or a constant)
6911          due to the return value of strlen being unsigned.  */
6912       if ((code == EQ_EXPR || code == NE_EXPR)
6913           && integer_zerop (arg1)
6914           && TREE_CODE (arg0) == CALL_EXPR
6915           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR)
6916         {
6917           tree fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6918           tree arglist;
6919
6920           if (TREE_CODE (fndecl) == FUNCTION_DECL
6921               && DECL_BUILT_IN (fndecl)
6922               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
6923               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
6924               && (arglist = TREE_OPERAND (arg0, 1))
6925               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
6926               && ! TREE_CHAIN (arglist))
6927             return fold (build (code, type,
6928                                 build1 (INDIRECT_REF, char_type_node,
6929                                         TREE_VALUE(arglist)),
6930                                 integer_zero_node));
6931         }
6932
6933       /* From here on, the only cases we handle are when the result is
6934          known to be a constant.
6935
6936          To compute GT, swap the arguments and do LT.
6937          To compute GE, do LT and invert the result.
6938          To compute LE, swap the arguments, do LT and invert the result.
6939          To compute NE, do EQ and invert the result.
6940
6941          Therefore, the code below must handle only EQ and LT.  */
6942
6943       if (code == LE_EXPR || code == GT_EXPR)
6944         {
6945           tem = arg0, arg0 = arg1, arg1 = tem;
6946           code = swap_tree_comparison (code);
6947         }
6948
6949       /* Note that it is safe to invert for real values here because we
6950          will check below in the one case that it matters.  */
6951
6952       t1 = NULL_TREE;
6953       invert = 0;
6954       if (code == NE_EXPR || code == GE_EXPR)
6955         {
6956           invert = 1;
6957           code = invert_tree_comparison (code);
6958         }
6959
6960       /* Compute a result for LT or EQ if args permit;
6961          otherwise return T.  */
6962       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6963         {
6964           if (code == EQ_EXPR)
6965             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
6966           else
6967             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6968                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6969                                : INT_CST_LT (arg0, arg1)),
6970                               0);
6971         }
6972
6973 #if 0 /* This is no longer useful, but breaks some real code.  */
6974       /* Assume a nonexplicit constant cannot equal an explicit one,
6975          since such code would be undefined anyway.
6976          Exception: on sysvr4, using #pragma weak,
6977          a label can come out as 0.  */
6978       else if (TREE_CODE (arg1) == INTEGER_CST
6979                && !integer_zerop (arg1)
6980                && TREE_CONSTANT (arg0)
6981                && TREE_CODE (arg0) == ADDR_EXPR
6982                && code == EQ_EXPR)
6983         t1 = build_int_2 (0, 0);
6984 #endif
6985       /* Two real constants can be compared explicitly.  */
6986       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6987         {
6988           /* If either operand is a NaN, the result is false with two
6989              exceptions: First, an NE_EXPR is true on NaNs, but that case
6990              is already handled correctly since we will be inverting the
6991              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6992              or a GE_EXPR into a LT_EXPR, we must return true so that it
6993              will be inverted into false.  */
6994
6995           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6996               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6997             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6998
6999           else if (code == EQ_EXPR)
7000             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
7001                                                  TREE_REAL_CST (arg1)),
7002                               0);
7003           else
7004             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
7005                                                 TREE_REAL_CST (arg1)),
7006                               0);
7007         }
7008
7009       if (t1 == NULL_TREE)
7010         return t;
7011
7012       if (invert)
7013         TREE_INT_CST_LOW (t1) ^= 1;
7014
7015       TREE_TYPE (t1) = type;
7016       if (TREE_CODE (type) == BOOLEAN_TYPE)
7017         return truthvalue_conversion (t1);
7018       return t1;
7019
7020     case COND_EXPR:
7021       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
7022          so all simple results must be passed through pedantic_non_lvalue.  */
7023       if (TREE_CODE (arg0) == INTEGER_CST)
7024         return pedantic_non_lvalue
7025           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
7026       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
7027         return pedantic_omit_one_operand (type, arg1, arg0);
7028
7029       /* If the second operand is zero, invert the comparison and swap
7030          the second and third operands.  Likewise if the second operand
7031          is constant and the third is not or if the third operand is
7032          equivalent to the first operand of the comparison.  */
7033
7034       if (integer_zerop (arg1)
7035           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
7036           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7037               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7038                                                  TREE_OPERAND (t, 2),
7039                                                  TREE_OPERAND (arg0, 1))))
7040         {
7041           /* See if this can be inverted.  If it can't, possibly because
7042              it was a floating-point inequality comparison, don't do
7043              anything.  */
7044           tem = invert_truthvalue (arg0);
7045
7046           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7047             {
7048               t = build (code, type, tem,
7049                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7050               arg0 = tem;
7051               /* arg1 should be the first argument of the new T.  */
7052               arg1 = TREE_OPERAND (t, 1);
7053               STRIP_NOPS (arg1);
7054             }
7055         }
7056
7057       /* If we have A op B ? A : C, we may be able to convert this to a
7058          simpler expression, depending on the operation and the values
7059          of B and C.  IEEE floating point prevents this though,
7060          because A or B might be -0.0 or a NaN.  */
7061
7062       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7063           && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
7064               || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
7065               || flag_unsafe_math_optimizations)
7066           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7067                                              arg1, TREE_OPERAND (arg0, 1)))
7068         {
7069           tree arg2 = TREE_OPERAND (t, 2);
7070           enum tree_code comp_code = TREE_CODE (arg0);
7071
7072           STRIP_NOPS (arg2);
7073
7074           /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
7075              depending on the comparison operation.  */
7076           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
7077                ? real_zerop (TREE_OPERAND (arg0, 1))
7078                : integer_zerop (TREE_OPERAND (arg0, 1)))
7079               && TREE_CODE (arg2) == NEGATE_EXPR
7080               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
7081             switch (comp_code)
7082               {
7083               case EQ_EXPR:
7084                 return
7085                   pedantic_non_lvalue
7086                     (convert (type,
7087                               negate_expr
7088                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
7089                                         arg1))));
7090
7091               case NE_EXPR:
7092                 return pedantic_non_lvalue (convert (type, arg1));
7093               case GE_EXPR:
7094               case GT_EXPR:
7095                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7096                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
7097                 return pedantic_non_lvalue
7098                   (convert (type, fold (build1 (ABS_EXPR,
7099                                                 TREE_TYPE (arg1), arg1))));
7100               case LE_EXPR:
7101               case LT_EXPR:
7102                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7103                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
7104                 return pedantic_non_lvalue
7105                   (negate_expr (convert (type,
7106                                          fold (build1 (ABS_EXPR,
7107                                                        TREE_TYPE (arg1),
7108                                                        arg1)))));
7109               default:
7110                 abort ();
7111               }
7112
7113           /* If this is A != 0 ? A : 0, this is simply A.  For ==, it is
7114              always zero.  */
7115
7116           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
7117             {
7118               if (comp_code == NE_EXPR)
7119                 return pedantic_non_lvalue (convert (type, arg1));
7120               else if (comp_code == EQ_EXPR)
7121                 return pedantic_non_lvalue (convert (type, integer_zero_node));
7122             }
7123
7124           /* If this is A op B ? A : B, this is either A, B, min (A, B),
7125              or max (A, B), depending on the operation.  */
7126
7127           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
7128                                               arg2, TREE_OPERAND (arg0, 0)))
7129             {
7130               tree comp_op0 = TREE_OPERAND (arg0, 0);
7131               tree comp_op1 = TREE_OPERAND (arg0, 1);
7132               tree comp_type = TREE_TYPE (comp_op0);
7133
7134               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
7135               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
7136                 comp_type = type;
7137
7138               switch (comp_code)
7139                 {
7140                 case EQ_EXPR:
7141                   return pedantic_non_lvalue (convert (type, arg2));
7142                 case NE_EXPR:
7143                   return pedantic_non_lvalue (convert (type, arg1));
7144                 case LE_EXPR:
7145                 case LT_EXPR:
7146                   /* In C++ a ?: expression can be an lvalue, so put the
7147                      operand which will be used if they are equal first
7148                      so that we can convert this back to the
7149                      corresponding COND_EXPR.  */
7150                   return pedantic_non_lvalue
7151                     (convert (type, fold (build (MIN_EXPR, comp_type,
7152                                                  (comp_code == LE_EXPR
7153                                                   ? comp_op0 : comp_op1),
7154                                                  (comp_code == LE_EXPR
7155                                                   ? comp_op1 : comp_op0)))));
7156                   break;
7157                 case GE_EXPR:
7158                 case GT_EXPR:
7159                   return pedantic_non_lvalue
7160                     (convert (type, fold (build (MAX_EXPR, comp_type,
7161                                                  (comp_code == GE_EXPR
7162                                                   ? comp_op0 : comp_op1),
7163                                                  (comp_code == GE_EXPR
7164                                                   ? comp_op1 : comp_op0)))));
7165                   break;
7166                 default:
7167                   abort ();
7168                 }
7169             }
7170
7171           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
7172              we might still be able to simplify this.  For example,
7173              if C1 is one less or one more than C2, this might have started
7174              out as a MIN or MAX and been transformed by this function.
7175              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
7176
7177           if (INTEGRAL_TYPE_P (type)
7178               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7179               && TREE_CODE (arg2) == INTEGER_CST)
7180             switch (comp_code)
7181               {
7182               case EQ_EXPR:
7183                 /* We can replace A with C1 in this case.  */
7184                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
7185                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
7186                            TREE_OPERAND (t, 2));
7187                 break;
7188
7189               case LT_EXPR:
7190                 /* If C1 is C2 + 1, this is min(A, C2).  */
7191                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7192                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7193                                         const_binop (PLUS_EXPR, arg2,
7194                                                      integer_one_node, 0), 1))
7195                   return pedantic_non_lvalue
7196                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7197                 break;
7198
7199               case LE_EXPR:
7200                 /* If C1 is C2 - 1, this is min(A, C2).  */
7201                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7202                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7203                                         const_binop (MINUS_EXPR, arg2,
7204                                                      integer_one_node, 0), 1))
7205                   return pedantic_non_lvalue
7206                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7207                 break;
7208
7209               case GT_EXPR:
7210                 /* If C1 is C2 - 1, this is max(A, C2).  */
7211                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7212                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7213                                         const_binop (MINUS_EXPR, arg2,
7214                                                      integer_one_node, 0), 1))
7215                   return pedantic_non_lvalue
7216                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7217                 break;
7218
7219               case GE_EXPR:
7220                 /* If C1 is C2 + 1, this is max(A, C2).  */
7221                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7222                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7223                                         const_binop (PLUS_EXPR, arg2,
7224                                                      integer_one_node, 0), 1))
7225                   return pedantic_non_lvalue
7226                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7227                 break;
7228               case NE_EXPR:
7229                 break;
7230               default:
7231                 abort ();
7232               }
7233         }
7234
7235       /* If the second operand is simpler than the third, swap them
7236          since that produces better jump optimization results.  */
7237       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7238            || TREE_CODE (arg1) == SAVE_EXPR)
7239           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7240                 || DECL_P (TREE_OPERAND (t, 2))
7241                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7242         {
7243           /* See if this can be inverted.  If it can't, possibly because
7244              it was a floating-point inequality comparison, don't do
7245              anything.  */
7246           tem = invert_truthvalue (arg0);
7247
7248           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7249             {
7250               t = build (code, type, tem,
7251                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7252               arg0 = tem;
7253               /* arg1 should be the first argument of the new T.  */
7254               arg1 = TREE_OPERAND (t, 1);
7255               STRIP_NOPS (arg1);
7256             }
7257         }
7258
7259       /* Convert A ? 1 : 0 to simply A.  */
7260       if (integer_onep (TREE_OPERAND (t, 1))
7261           && integer_zerop (TREE_OPERAND (t, 2))
7262           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7263              call to fold will try to move the conversion inside
7264              a COND, which will recurse.  In that case, the COND_EXPR
7265              is probably the best choice, so leave it alone.  */
7266           && type == TREE_TYPE (arg0))
7267         return pedantic_non_lvalue (arg0);
7268
7269       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7270          operation is simply A & 2.  */
7271
7272       if (integer_zerop (TREE_OPERAND (t, 2))
7273           && TREE_CODE (arg0) == NE_EXPR
7274           && integer_zerop (TREE_OPERAND (arg0, 1))
7275           && integer_pow2p (arg1)
7276           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7277           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7278                               arg1, 1))
7279         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7280
7281       return t;
7282
7283     case COMPOUND_EXPR:
7284       /* When pedantic, a compound expression can be neither an lvalue
7285          nor an integer constant expression.  */
7286       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7287         return t;
7288       /* Don't let (0, 0) be null pointer constant.  */
7289       if (integer_zerop (arg1))
7290         return build1 (NOP_EXPR, type, arg1);
7291       return convert (type, arg1);
7292
7293     case COMPLEX_EXPR:
7294       if (wins)
7295         return build_complex (type, arg0, arg1);
7296       return t;
7297
7298     case REALPART_EXPR:
7299       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7300         return t;
7301       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7302         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7303                                  TREE_OPERAND (arg0, 1));
7304       else if (TREE_CODE (arg0) == COMPLEX_CST)
7305         return TREE_REALPART (arg0);
7306       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7307         return fold (build (TREE_CODE (arg0), type,
7308                             fold (build1 (REALPART_EXPR, type,
7309                                           TREE_OPERAND (arg0, 0))),
7310                             fold (build1 (REALPART_EXPR,
7311                                           type, TREE_OPERAND (arg0, 1)))));
7312       return t;
7313
7314     case IMAGPART_EXPR:
7315       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7316         return convert (type, integer_zero_node);
7317       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7318         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7319                                  TREE_OPERAND (arg0, 0));
7320       else if (TREE_CODE (arg0) == COMPLEX_CST)
7321         return TREE_IMAGPART (arg0);
7322       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7323         return fold (build (TREE_CODE (arg0), type,
7324                             fold (build1 (IMAGPART_EXPR, type,
7325                                           TREE_OPERAND (arg0, 0))),
7326                             fold (build1 (IMAGPART_EXPR, type,
7327                                           TREE_OPERAND (arg0, 1)))));
7328       return t;
7329
7330       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7331          appropriate.  */
7332     case CLEANUP_POINT_EXPR:
7333       if (! has_cleanups (arg0))
7334         return TREE_OPERAND (t, 0);
7335
7336       {
7337         enum tree_code code0 = TREE_CODE (arg0);
7338         int kind0 = TREE_CODE_CLASS (code0);
7339         tree arg00 = TREE_OPERAND (arg0, 0);
7340         tree arg01;
7341
7342         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7343           return fold (build1 (code0, type,
7344                                fold (build1 (CLEANUP_POINT_EXPR,
7345                                              TREE_TYPE (arg00), arg00))));
7346
7347         if (kind0 == '<' || kind0 == '2'
7348             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7349             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7350             || code0 == TRUTH_XOR_EXPR)
7351           {
7352             arg01 = TREE_OPERAND (arg0, 1);
7353
7354             if (TREE_CONSTANT (arg00)
7355                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7356                     && ! has_cleanups (arg00)))
7357               return fold (build (code0, type, arg00,
7358                                   fold (build1 (CLEANUP_POINT_EXPR,
7359                                                 TREE_TYPE (arg01), arg01))));
7360
7361             if (TREE_CONSTANT (arg01))
7362               return fold (build (code0, type,
7363                                   fold (build1 (CLEANUP_POINT_EXPR,
7364                                                 TREE_TYPE (arg00), arg00)),
7365                                   arg01));
7366           }
7367
7368         return t;
7369       }
7370
7371     case CALL_EXPR:
7372       /* Check for a built-in function.  */
7373       if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
7374           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))
7375               == FUNCTION_DECL)
7376           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)))
7377         {
7378           tree tmp = fold_builtin (expr);
7379           if (tmp)
7380             return tmp;
7381         }
7382       return t;
7383
7384     default:
7385       return t;
7386     } /* switch (code) */
7387 }
7388
7389 /* Determine if first argument is a multiple of second argument.  Return 0 if
7390    it is not, or we cannot easily determined it to be.
7391
7392    An example of the sort of thing we care about (at this point; this routine
7393    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7394    fold cases do now) is discovering that
7395
7396      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7397
7398    is a multiple of
7399
7400      SAVE_EXPR (J * 8)
7401
7402    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7403
7404    This code also handles discovering that
7405
7406      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7407
7408    is a multiple of 8 so we don't have to worry about dealing with a
7409    possible remainder.
7410
7411    Note that we *look* inside a SAVE_EXPR only to determine how it was
7412    calculated; it is not safe for fold to do much of anything else with the
7413    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7414    at run time.  For example, the latter example above *cannot* be implemented
7415    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7416    evaluation time of the original SAVE_EXPR is not necessarily the same at
7417    the time the new expression is evaluated.  The only optimization of this
7418    sort that would be valid is changing
7419
7420      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7421
7422    divided by 8 to
7423
7424      SAVE_EXPR (I) * SAVE_EXPR (J)
7425
7426    (where the same SAVE_EXPR (J) is used in the original and the
7427    transformed version).  */
7428
7429 static int
7430 multiple_of_p (type, top, bottom)
7431      tree type;
7432      tree top;
7433      tree bottom;
7434 {
7435   if (operand_equal_p (top, bottom, 0))
7436     return 1;
7437
7438   if (TREE_CODE (type) != INTEGER_TYPE)
7439     return 0;
7440
7441   switch (TREE_CODE (top))
7442     {
7443     case MULT_EXPR:
7444       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7445               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7446
7447     case PLUS_EXPR:
7448     case MINUS_EXPR:
7449       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7450               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7451
7452     case LSHIFT_EXPR:
7453       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
7454         {
7455           tree op1, t1;
7456
7457           op1 = TREE_OPERAND (top, 1);
7458           /* const_binop may not detect overflow correctly,
7459              so check for it explicitly here.  */
7460           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
7461               > TREE_INT_CST_LOW (op1)
7462               && TREE_INT_CST_HIGH (op1) == 0
7463               && 0 != (t1 = convert (type,
7464                                      const_binop (LSHIFT_EXPR, size_one_node,
7465                                                   op1, 0)))
7466               && ! TREE_OVERFLOW (t1))
7467             return multiple_of_p (type, t1, bottom);
7468         }
7469       return 0;
7470
7471     case NOP_EXPR:
7472       /* Can't handle conversions from non-integral or wider integral type.  */
7473       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7474           || (TYPE_PRECISION (type)
7475               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7476         return 0;
7477
7478       /* .. fall through ...  */
7479
7480     case SAVE_EXPR:
7481       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7482
7483     case INTEGER_CST:
7484       if (TREE_CODE (bottom) != INTEGER_CST
7485           || (TREE_UNSIGNED (type)
7486               && (tree_int_cst_sgn (top) < 0
7487                   || tree_int_cst_sgn (bottom) < 0)))
7488         return 0;
7489       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7490                                          top, bottom, 0));
7491
7492     default:
7493       return 0;
7494     }
7495 }
7496
7497 /* Return true if `t' is known to be non-negative.  */
7498
7499 int
7500 tree_expr_nonnegative_p (t)
7501      tree t;
7502 {
7503   switch (TREE_CODE (t))
7504     {
7505     case ABS_EXPR:
7506     case FFS_EXPR:
7507       return 1;
7508     case INTEGER_CST:
7509       return tree_int_cst_sgn (t) >= 0;
7510     case TRUNC_DIV_EXPR:
7511     case CEIL_DIV_EXPR:
7512     case FLOOR_DIV_EXPR:
7513     case ROUND_DIV_EXPR:
7514       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7515         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7516     case TRUNC_MOD_EXPR:
7517     case CEIL_MOD_EXPR:
7518     case FLOOR_MOD_EXPR:
7519     case ROUND_MOD_EXPR:
7520       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7521     case COND_EXPR:
7522       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
7523         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
7524     case COMPOUND_EXPR:
7525       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7526     case MIN_EXPR:
7527       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7528         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7529     case MAX_EXPR:
7530       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7531         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7532     case MODIFY_EXPR:
7533       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7534     case BIND_EXPR:
7535       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7536     case SAVE_EXPR:
7537       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7538     case NON_LVALUE_EXPR:
7539       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7540     case RTL_EXPR:
7541       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
7542
7543     default:
7544       if (truth_value_p (TREE_CODE (t)))
7545         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
7546         return 1;
7547       else
7548         /* We don't know sign of `t', so be conservative and return false.  */
7549         return 0;
7550     }
7551 }
7552
7553 /* Return true if `r' is known to be non-negative.
7554    Only handles constants at the moment.  */
7555
7556 int
7557 rtl_expr_nonnegative_p (r)
7558      rtx r;
7559 {
7560   switch (GET_CODE (r))
7561     {
7562     case CONST_INT:
7563       return INTVAL (r) >= 0;
7564
7565     case CONST_DOUBLE:
7566       if (GET_MODE (r) == VOIDmode)
7567         return CONST_DOUBLE_HIGH (r) >= 0;
7568       return 0;
7569
7570     case SYMBOL_REF:
7571     case LABEL_REF:
7572       /* These are always nonnegative.  */
7573       return 1;
7574
7575     default:
7576       return 0;
7577     }
7578 }