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 #if 0  /* This loses on &"foo"[0].  */
5312     case ARRAY_REF:
5313         {
5314           int i;
5315
5316           /* Fold an expression like: "foo"[2] */
5317           if (TREE_CODE (arg0) == STRING_CST
5318               && TREE_CODE (arg1) == INTEGER_CST
5319               && compare_tree_int (arg1, TREE_STRING_LENGTH (arg0)) < 0)
5320             {
5321               t = build_int_2 (TREE_STRING_POINTER (arg0)[TREE_INT_CST_LOW (arg))], 0);
5322               TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
5323               force_fit_type (t, 0);
5324             }
5325         }
5326       return t;
5327 #endif /* 0 */
5328
5329     case COMPONENT_REF:
5330       if (TREE_CODE (arg0) == CONSTRUCTOR)
5331         {
5332           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
5333           if (m)
5334             t = TREE_VALUE (m);
5335         }
5336       return t;
5337
5338     case RANGE_EXPR:
5339       TREE_CONSTANT (t) = wins;
5340       return t;
5341
5342     case NEGATE_EXPR:
5343       if (wins)
5344         {
5345           if (TREE_CODE (arg0) == INTEGER_CST)
5346             {
5347               unsigned HOST_WIDE_INT low;
5348               HOST_WIDE_INT high;
5349               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5350                                          TREE_INT_CST_HIGH (arg0),
5351                                          &low, &high);
5352               t = build_int_2 (low, high);
5353               TREE_TYPE (t) = type;
5354               TREE_OVERFLOW (t)
5355                 = (TREE_OVERFLOW (arg0)
5356                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5357               TREE_CONSTANT_OVERFLOW (t)
5358                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5359             }
5360           else if (TREE_CODE (arg0) == REAL_CST)
5361             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5362         }
5363       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5364         return TREE_OPERAND (arg0, 0);
5365
5366       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5367       else if (TREE_CODE (arg0) == MINUS_EXPR
5368                && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
5369         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5370                       TREE_OPERAND (arg0, 0));
5371
5372       return t;
5373
5374     case ABS_EXPR:
5375       if (wins)
5376         {
5377           if (TREE_CODE (arg0) == INTEGER_CST)
5378             {
5379               /* If the value is unsigned, then the absolute value is
5380                  the same as the ordinary value.  */
5381               if (TREE_UNSIGNED (type))
5382                 return arg0;
5383               /* Similarly, if the value is non-negative.  */
5384               else if (INT_CST_LT (integer_minus_one_node, arg0))
5385                 return arg0;
5386               /* If the value is negative, then the absolute value is
5387                  its negation.  */
5388               else
5389                 {
5390                   unsigned HOST_WIDE_INT low;
5391                   HOST_WIDE_INT high;
5392                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5393                                              TREE_INT_CST_HIGH (arg0),
5394                                              &low, &high);
5395                   t = build_int_2 (low, high);
5396                   TREE_TYPE (t) = type;
5397                   TREE_OVERFLOW (t)
5398                     = (TREE_OVERFLOW (arg0)
5399                        | force_fit_type (t, overflow));
5400                   TREE_CONSTANT_OVERFLOW (t)
5401                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5402                 }
5403             }
5404           else if (TREE_CODE (arg0) == REAL_CST)
5405             {
5406               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5407                 t = build_real (type,
5408                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5409             }
5410         }
5411       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5412         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5413       return t;
5414
5415     case CONJ_EXPR:
5416       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5417         return convert (type, arg0);
5418       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5419         return build (COMPLEX_EXPR, type,
5420                       TREE_OPERAND (arg0, 0),
5421                       negate_expr (TREE_OPERAND (arg0, 1)));
5422       else if (TREE_CODE (arg0) == COMPLEX_CST)
5423         return build_complex (type, TREE_REALPART (arg0),
5424                               negate_expr (TREE_IMAGPART (arg0)));
5425       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5426         return fold (build (TREE_CODE (arg0), type,
5427                             fold (build1 (CONJ_EXPR, type,
5428                                           TREE_OPERAND (arg0, 0))),
5429                             fold (build1 (CONJ_EXPR,
5430                                           type, TREE_OPERAND (arg0, 1)))));
5431       else if (TREE_CODE (arg0) == CONJ_EXPR)
5432         return TREE_OPERAND (arg0, 0);
5433       return t;
5434
5435     case BIT_NOT_EXPR:
5436       if (wins)
5437         {
5438           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5439                            ~ TREE_INT_CST_HIGH (arg0));
5440           TREE_TYPE (t) = type;
5441           force_fit_type (t, 0);
5442           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5443           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5444         }
5445       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5446         return TREE_OPERAND (arg0, 0);
5447       return t;
5448
5449     case PLUS_EXPR:
5450       /* A + (-B) -> A - B */
5451       if (TREE_CODE (arg1) == NEGATE_EXPR)
5452         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5453       /* (-A) + B -> B - A */
5454       if (TREE_CODE (arg0) == NEGATE_EXPR)
5455         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5456       else if (! FLOAT_TYPE_P (type))
5457         {
5458           if (integer_zerop (arg1))
5459             return non_lvalue (convert (type, arg0));
5460
5461           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5462              with a constant, and the two constants have no bits in common,
5463              we should treat this as a BIT_IOR_EXPR since this may produce more
5464              simplifications.  */
5465           if (TREE_CODE (arg0) == BIT_AND_EXPR
5466               && TREE_CODE (arg1) == BIT_AND_EXPR
5467               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5468               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5469               && integer_zerop (const_binop (BIT_AND_EXPR,
5470                                              TREE_OPERAND (arg0, 1),
5471                                              TREE_OPERAND (arg1, 1), 0)))
5472             {
5473               code = BIT_IOR_EXPR;
5474               goto bit_ior;
5475             }
5476
5477           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5478              (plus (plus (mult) (mult)) (foo)) so that we can
5479              take advantage of the factoring cases below.  */
5480           if ((TREE_CODE (arg0) == PLUS_EXPR
5481                && TREE_CODE (arg1) == MULT_EXPR)
5482               || (TREE_CODE (arg1) == PLUS_EXPR
5483                   && TREE_CODE (arg0) == MULT_EXPR))
5484             {
5485               tree parg0, parg1, parg, marg;
5486
5487               if (TREE_CODE (arg0) == PLUS_EXPR)
5488                 parg = arg0, marg = arg1;
5489               else
5490                 parg = arg1, marg = arg0;
5491               parg0 = TREE_OPERAND (parg, 0);
5492               parg1 = TREE_OPERAND (parg, 1);
5493               STRIP_NOPS (parg0);
5494               STRIP_NOPS (parg1);
5495
5496               if (TREE_CODE (parg0) == MULT_EXPR
5497                   && TREE_CODE (parg1) != MULT_EXPR)
5498                 return fold (build (PLUS_EXPR, type,
5499                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5500                                     parg1));
5501               if (TREE_CODE (parg0) != MULT_EXPR
5502                   && TREE_CODE (parg1) == MULT_EXPR)
5503                 return fold (build (PLUS_EXPR, type,
5504                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5505                                     parg0));
5506             }
5507
5508           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5509             {
5510               tree arg00, arg01, arg10, arg11;
5511               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5512
5513               /* (A * C) + (B * C) -> (A+B) * C.
5514                  We are most concerned about the case where C is a constant,
5515                  but other combinations show up during loop reduction.  Since
5516                  it is not difficult, try all four possibilities.  */
5517
5518               arg00 = TREE_OPERAND (arg0, 0);
5519               arg01 = TREE_OPERAND (arg0, 1);
5520               arg10 = TREE_OPERAND (arg1, 0);
5521               arg11 = TREE_OPERAND (arg1, 1);
5522               same = NULL_TREE;
5523
5524               if (operand_equal_p (arg01, arg11, 0))
5525                 same = arg01, alt0 = arg00, alt1 = arg10;
5526               else if (operand_equal_p (arg00, arg10, 0))
5527                 same = arg00, alt0 = arg01, alt1 = arg11;
5528               else if (operand_equal_p (arg00, arg11, 0))
5529                 same = arg00, alt0 = arg01, alt1 = arg10;
5530               else if (operand_equal_p (arg01, arg10, 0))
5531                 same = arg01, alt0 = arg00, alt1 = arg11;
5532
5533               /* No identical multiplicands; see if we can find a common
5534                  power-of-two factor in non-power-of-two multiplies.  This
5535                  can help in multi-dimensional array access.  */
5536               else if (TREE_CODE (arg01) == INTEGER_CST
5537                        && TREE_CODE (arg11) == INTEGER_CST
5538                        && TREE_INT_CST_HIGH (arg01) == 0
5539                        && TREE_INT_CST_HIGH (arg11) == 0)
5540                 {
5541                   HOST_WIDE_INT int01, int11, tmp;
5542                   int01 = TREE_INT_CST_LOW (arg01);
5543                   int11 = TREE_INT_CST_LOW (arg11);
5544
5545                   /* Move min of absolute values to int11.  */
5546                   if ((int01 >= 0 ? int01 : -int01)
5547                       < (int11 >= 0 ? int11 : -int11))
5548                     {
5549                       tmp = int01, int01 = int11, int11 = tmp;
5550                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5551                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5552                     }
5553
5554                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5555                     {
5556                       alt0 = fold (build (MULT_EXPR, type, arg00,
5557                                           build_int_2 (int01 / int11, 0)));
5558                       alt1 = arg10;
5559                       same = arg11;
5560                     }
5561                 }
5562
5563               if (same)
5564                 return fold (build (MULT_EXPR, type,
5565                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5566                                     same));
5567             }
5568         }
5569       /* In IEEE floating point, x+0 may not equal x.  */
5570       else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5571                 || flag_unsafe_math_optimizations)
5572                && real_zerop (arg1))
5573         return non_lvalue (convert (type, arg0));
5574       /* x+(-0) equals x, even for IEEE.  */
5575       else if (TREE_CODE (arg1) == REAL_CST
5576                && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5577         return non_lvalue (convert (type, arg0));
5578
5579      bit_rotate:
5580       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5581          is a rotate of A by C1 bits.  */
5582       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5583          is a rotate of A by B bits.  */
5584       {
5585         enum tree_code code0, code1;
5586         code0 = TREE_CODE (arg0);
5587         code1 = TREE_CODE (arg1);
5588         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5589              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5590             && operand_equal_p (TREE_OPERAND (arg0, 0),
5591                                 TREE_OPERAND (arg1, 0), 0)
5592             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5593           {
5594             tree tree01, tree11;
5595             enum tree_code code01, code11;
5596
5597             tree01 = TREE_OPERAND (arg0, 1);
5598             tree11 = TREE_OPERAND (arg1, 1);
5599             STRIP_NOPS (tree01);
5600             STRIP_NOPS (tree11);
5601             code01 = TREE_CODE (tree01);
5602             code11 = TREE_CODE (tree11);
5603             if (code01 == INTEGER_CST
5604                 && code11 == INTEGER_CST
5605                 && TREE_INT_CST_HIGH (tree01) == 0
5606                 && TREE_INT_CST_HIGH (tree11) == 0
5607                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5608                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5609               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5610                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5611             else if (code11 == MINUS_EXPR)
5612               {
5613                 tree tree110, tree111;
5614                 tree110 = TREE_OPERAND (tree11, 0);
5615                 tree111 = TREE_OPERAND (tree11, 1);
5616                 STRIP_NOPS (tree110);
5617                 STRIP_NOPS (tree111);
5618                 if (TREE_CODE (tree110) == INTEGER_CST
5619                     && 0 == compare_tree_int (tree110,
5620                                               TYPE_PRECISION
5621                                               (TREE_TYPE (TREE_OPERAND
5622                                                           (arg0, 0))))
5623                     && operand_equal_p (tree01, tree111, 0))
5624                   return build ((code0 == LSHIFT_EXPR
5625                                  ? LROTATE_EXPR
5626                                  : RROTATE_EXPR),
5627                                 type, TREE_OPERAND (arg0, 0), tree01);
5628               }
5629             else if (code01 == MINUS_EXPR)
5630               {
5631                 tree tree010, tree011;
5632                 tree010 = TREE_OPERAND (tree01, 0);
5633                 tree011 = TREE_OPERAND (tree01, 1);
5634                 STRIP_NOPS (tree010);
5635                 STRIP_NOPS (tree011);
5636                 if (TREE_CODE (tree010) == INTEGER_CST
5637                     && 0 == compare_tree_int (tree010,
5638                                               TYPE_PRECISION
5639                                               (TREE_TYPE (TREE_OPERAND
5640                                                           (arg0, 0))))
5641                     && operand_equal_p (tree11, tree011, 0))
5642                   return build ((code0 != LSHIFT_EXPR
5643                                  ? LROTATE_EXPR
5644                                  : RROTATE_EXPR),
5645                                 type, TREE_OPERAND (arg0, 0), tree11);
5646               }
5647           }
5648       }
5649
5650     associate:
5651       /* In most languages, can't associate operations on floats through
5652          parentheses.  Rather than remember where the parentheses were, we
5653          don't associate floats at all.  It shouldn't matter much.  However,
5654          associating multiplications is only very slightly inaccurate, so do
5655          that if -funsafe-math-optimizations is specified.  */
5656
5657       if (! wins
5658           && (! FLOAT_TYPE_P (type)
5659               || (flag_unsafe_math_optimizations && code == MULT_EXPR)))
5660         {
5661           tree var0, con0, lit0, var1, con1, lit1;
5662
5663           /* Split both trees into variables, constants, and literals.  Then
5664              associate each group together, the constants with literals,
5665              then the result with variables.  This increases the chances of
5666              literals being recombined later and of generating relocatable
5667              expressions for the sum of a constant and literal.  */
5668           var0 = split_tree (arg0, code, &con0, &lit0, 0);
5669           var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
5670
5671           /* Only do something if we found more than two objects.  Otherwise,
5672              nothing has changed and we risk infinite recursion.  */
5673           if (2 < ((var0 != 0) + (var1 != 0) + (con0 != 0) + (con1 != 0)
5674                    + (lit0 != 0) + (lit1 != 0)))
5675             {
5676               var0 = associate_trees (var0, var1, code, type);
5677               con0 = associate_trees (con0, con1, code, type);
5678               lit0 = associate_trees (lit0, lit1, code, type);
5679               con0 = associate_trees (con0, lit0, code, type);
5680               return convert (type, associate_trees (var0, con0, code, type));
5681             }
5682         }
5683
5684     binary:
5685 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
5686       if (TREE_CODE (arg1) == REAL_CST)
5687         return t;
5688 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
5689       if (wins)
5690         t1 = const_binop (code, arg0, arg1, 0);
5691       if (t1 != NULL_TREE)
5692         {
5693           /* The return value should always have
5694              the same type as the original expression.  */
5695           if (TREE_TYPE (t1) != TREE_TYPE (t))
5696             t1 = convert (TREE_TYPE (t), t1);
5697
5698           return t1;
5699         }
5700       return t;
5701
5702     case MINUS_EXPR:
5703       /* A - (-B) -> A + B */
5704       if (TREE_CODE (arg1) == NEGATE_EXPR)
5705         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5706       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5707       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5708         return
5709           fold (build (MINUS_EXPR, type,
5710                        build_real (TREE_TYPE (arg1),
5711                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5712                        TREE_OPERAND (arg0, 0)));
5713
5714       if (! FLOAT_TYPE_P (type))
5715         {
5716           if (! wins && integer_zerop (arg0))
5717             return negate_expr (convert (type, arg1));
5718           if (integer_zerop (arg1))
5719             return non_lvalue (convert (type, arg0));
5720
5721           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5722              about the case where C is a constant, just try one of the
5723              four possibilities.  */
5724
5725           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5726               && operand_equal_p (TREE_OPERAND (arg0, 1),
5727                                   TREE_OPERAND (arg1, 1), 0))
5728             return fold (build (MULT_EXPR, type,
5729                                 fold (build (MINUS_EXPR, type,
5730                                              TREE_OPERAND (arg0, 0),
5731                                              TREE_OPERAND (arg1, 0))),
5732                                 TREE_OPERAND (arg0, 1)));
5733         }
5734
5735       else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5736                || flag_unsafe_math_optimizations)
5737         {
5738           /* Except with IEEE floating point, 0-x equals -x.  */
5739           if (! wins && real_zerop (arg0))
5740             return negate_expr (convert (type, arg1));
5741           /* Except with IEEE floating point, x-0 equals x.  */
5742           if (real_zerop (arg1))
5743             return non_lvalue (convert (type, arg0));
5744         }
5745
5746       /* Fold &x - &x.  This can happen from &x.foo - &x.
5747          This is unsafe for certain floats even in non-IEEE formats.
5748          In IEEE, it is unsafe because it does wrong for NaNs.
5749          Also note that operand_equal_p is always false if an operand
5750          is volatile.  */
5751
5752       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
5753           && operand_equal_p (arg0, arg1, 0))
5754         return convert (type, integer_zero_node);
5755
5756       goto associate;
5757
5758     case MULT_EXPR:
5759       /* (-A) * (-B) -> A * B  */
5760       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5761         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5762                             TREE_OPERAND (arg1, 0)));
5763
5764       if (! FLOAT_TYPE_P (type))
5765         {
5766           if (integer_zerop (arg1))
5767             return omit_one_operand (type, arg1, arg0);
5768           if (integer_onep (arg1))
5769             return non_lvalue (convert (type, arg0));
5770
5771           /* (a * (1 << b)) is (a << b)  */
5772           if (TREE_CODE (arg1) == LSHIFT_EXPR
5773               && integer_onep (TREE_OPERAND (arg1, 0)))
5774             return fold (build (LSHIFT_EXPR, type, arg0,
5775                                 TREE_OPERAND (arg1, 1)));
5776           if (TREE_CODE (arg0) == LSHIFT_EXPR
5777               && integer_onep (TREE_OPERAND (arg0, 0)))
5778             return fold (build (LSHIFT_EXPR, type, arg1,
5779                                 TREE_OPERAND (arg0, 1)));
5780
5781           if (TREE_CODE (arg1) == INTEGER_CST
5782               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5783                                              code, NULL_TREE)))
5784             return convert (type, tem);
5785
5786         }
5787       else
5788         {
5789           /* x*0 is 0, except for IEEE floating point.  */
5790           if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5791                || flag_unsafe_math_optimizations)
5792               && real_zerop (arg1))
5793             return omit_one_operand (type, arg1, arg0);
5794           /* In IEEE floating point, x*1 is not equivalent to x for snans.
5795              However, ANSI says we can drop signals,
5796              so we can do this anyway.  */
5797           if (real_onep (arg1))
5798             return non_lvalue (convert (type, arg0));
5799           /* x*2 is x+x */
5800           if (! wins && real_twop (arg1) && global_bindings_p () == 0
5801               && ! contains_placeholder_p (arg0))
5802             {
5803               tree arg = save_expr (arg0);
5804               return build (PLUS_EXPR, type, arg, arg);
5805             }
5806         }
5807       goto associate;
5808
5809     case BIT_IOR_EXPR:
5810     bit_ior:
5811       if (integer_all_onesp (arg1))
5812         return omit_one_operand (type, arg1, arg0);
5813       if (integer_zerop (arg1))
5814         return non_lvalue (convert (type, arg0));
5815       t1 = distribute_bit_expr (code, type, arg0, arg1);
5816       if (t1 != NULL_TREE)
5817         return t1;
5818
5819       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5820
5821          This results in more efficient code for machines without a NAND
5822          instruction.  Combine will canonicalize to the first form
5823          which will allow use of NAND instructions provided by the
5824          backend if they exist.  */
5825       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5826           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5827         {
5828           return fold (build1 (BIT_NOT_EXPR, type,
5829                                build (BIT_AND_EXPR, type,
5830                                       TREE_OPERAND (arg0, 0),
5831                                       TREE_OPERAND (arg1, 0))));
5832         }
5833
5834       /* See if this can be simplified into a rotate first.  If that
5835          is unsuccessful continue in the association code.  */
5836       goto bit_rotate;
5837
5838     case BIT_XOR_EXPR:
5839       if (integer_zerop (arg1))
5840         return non_lvalue (convert (type, arg0));
5841       if (integer_all_onesp (arg1))
5842         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5843
5844       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5845          with a constant, and the two constants have no bits in common,
5846          we should treat this as a BIT_IOR_EXPR since this may produce more
5847          simplifications.  */
5848       if (TREE_CODE (arg0) == BIT_AND_EXPR
5849           && TREE_CODE (arg1) == BIT_AND_EXPR
5850           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5851           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5852           && integer_zerop (const_binop (BIT_AND_EXPR,
5853                                          TREE_OPERAND (arg0, 1),
5854                                          TREE_OPERAND (arg1, 1), 0)))
5855         {
5856           code = BIT_IOR_EXPR;
5857           goto bit_ior;
5858         }
5859
5860       /* See if this can be simplified into a rotate first.  If that
5861          is unsuccessful continue in the association code.  */
5862       goto bit_rotate;
5863
5864     case BIT_AND_EXPR:
5865     bit_and:
5866       if (integer_all_onesp (arg1))
5867         return non_lvalue (convert (type, arg0));
5868       if (integer_zerop (arg1))
5869         return omit_one_operand (type, arg1, arg0);
5870       t1 = distribute_bit_expr (code, type, arg0, arg1);
5871       if (t1 != NULL_TREE)
5872         return t1;
5873       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5874       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5875           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5876         {
5877           unsigned int prec
5878             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5879
5880           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5881               && (~TREE_INT_CST_LOW (arg0)
5882                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5883             return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5884         }
5885       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5886           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5887         {
5888           unsigned int prec
5889             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5890
5891           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5892               && (~TREE_INT_CST_LOW (arg1)
5893                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5894             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5895         }
5896
5897       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5898
5899          This results in more efficient code for machines without a NOR
5900          instruction.  Combine will canonicalize to the first form
5901          which will allow use of NOR instructions provided by the
5902          backend if they exist.  */
5903       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5904           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5905         {
5906           return fold (build1 (BIT_NOT_EXPR, type,
5907                                build (BIT_IOR_EXPR, type,
5908                                       TREE_OPERAND (arg0, 0),
5909                                       TREE_OPERAND (arg1, 0))));
5910         }
5911
5912       goto associate;
5913
5914     case BIT_ANDTC_EXPR:
5915       if (integer_all_onesp (arg0))
5916         return non_lvalue (convert (type, arg1));
5917       if (integer_zerop (arg0))
5918         return omit_one_operand (type, arg0, arg1);
5919       if (TREE_CODE (arg1) == INTEGER_CST)
5920         {
5921           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5922           code = BIT_AND_EXPR;
5923           goto bit_and;
5924         }
5925       goto binary;
5926
5927     case RDIV_EXPR:
5928       /* In most cases, do nothing with a divide by zero.  */
5929 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5930 #ifndef REAL_INFINITY
5931       if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5932         return t;
5933 #endif
5934 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5935
5936       /* (-A) / (-B) -> A / B  */
5937       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5938         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5939                             TREE_OPERAND (arg1, 0)));
5940
5941       /* In IEEE floating point, x/1 is not equivalent to x for snans.
5942          However, ANSI says we can drop signals, so we can do this anyway.  */
5943       if (real_onep (arg1))
5944         return non_lvalue (convert (type, arg0));
5945
5946       /* If ARG1 is a constant, we can convert this to a multiply by the
5947          reciprocal.  This does not have the same rounding properties,
5948          so only do this if -funsafe-math-optimizations.  We can actually
5949          always safely do it if ARG1 is a power of two, but it's hard to
5950          tell if it is or not in a portable manner.  */
5951       if (TREE_CODE (arg1) == REAL_CST)
5952         {
5953           if (flag_unsafe_math_optimizations
5954               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5955                                           arg1, 0)))
5956             return fold (build (MULT_EXPR, type, arg0, tem));
5957           /* Find the reciprocal if optimizing and the result is exact.  */
5958           else if (optimize)
5959             {
5960               REAL_VALUE_TYPE r;
5961               r = TREE_REAL_CST (arg1);
5962               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5963                 {
5964                   tem = build_real (type, r);
5965                   return fold (build (MULT_EXPR, type, arg0, tem));
5966                 }
5967             }
5968         }
5969       /* Convert A/B/C to A/(B*C).  */
5970       if (flag_unsafe_math_optimizations
5971           && TREE_CODE (arg0) == RDIV_EXPR)
5972         {
5973           return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5974                               build (MULT_EXPR, type, TREE_OPERAND (arg0, 1),
5975                                      arg1)));
5976         }
5977       /* Convert A/(B/C) to (A/B)*C.  */
5978       if (flag_unsafe_math_optimizations
5979           && TREE_CODE (arg1) == RDIV_EXPR)
5980         {
5981           return fold (build (MULT_EXPR, type,
5982                               build (RDIV_EXPR, type, arg0,
5983                                      TREE_OPERAND (arg1, 0)),
5984                               TREE_OPERAND (arg1, 1)));
5985         }
5986       goto binary;
5987
5988     case TRUNC_DIV_EXPR:
5989     case ROUND_DIV_EXPR:
5990     case FLOOR_DIV_EXPR:
5991     case CEIL_DIV_EXPR:
5992     case EXACT_DIV_EXPR:
5993       if (integer_onep (arg1))
5994         return non_lvalue (convert (type, arg0));
5995       if (integer_zerop (arg1))
5996         return t;
5997
5998       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5999          operation, EXACT_DIV_EXPR.
6000
6001          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
6002          At one time others generated faster code, it's not clear if they do
6003          after the last round to changes to the DIV code in expmed.c.  */
6004       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
6005           && multiple_of_p (type, arg0, arg1))
6006         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
6007
6008       if (TREE_CODE (arg1) == INTEGER_CST
6009           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6010                                          code, NULL_TREE)))
6011         return convert (type, tem);
6012
6013       goto binary;
6014
6015     case CEIL_MOD_EXPR:
6016     case FLOOR_MOD_EXPR:
6017     case ROUND_MOD_EXPR:
6018     case TRUNC_MOD_EXPR:
6019       if (integer_onep (arg1))
6020         return omit_one_operand (type, integer_zero_node, arg0);
6021       if (integer_zerop (arg1))
6022         return t;
6023
6024       if (TREE_CODE (arg1) == INTEGER_CST
6025           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
6026                                          code, NULL_TREE)))
6027         return convert (type, tem);
6028
6029       goto binary;
6030
6031     case LSHIFT_EXPR:
6032     case RSHIFT_EXPR:
6033     case LROTATE_EXPR:
6034     case RROTATE_EXPR:
6035       if (integer_zerop (arg1))
6036         return non_lvalue (convert (type, arg0));
6037       /* Since negative shift count is not well-defined,
6038          don't try to compute it in the compiler.  */
6039       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
6040         return t;
6041       /* Rewrite an LROTATE_EXPR by a constant into an
6042          RROTATE_EXPR by a new constant.  */
6043       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
6044         {
6045           TREE_SET_CODE (t, RROTATE_EXPR);
6046           code = RROTATE_EXPR;
6047           TREE_OPERAND (t, 1) = arg1
6048             = const_binop
6049               (MINUS_EXPR,
6050                convert (TREE_TYPE (arg1),
6051                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
6052                arg1, 0);
6053           if (tree_int_cst_sgn (arg1) < 0)
6054             return t;
6055         }
6056
6057       /* If we have a rotate of a bit operation with the rotate count and
6058          the second operand of the bit operation both constant,
6059          permute the two operations.  */
6060       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6061           && (TREE_CODE (arg0) == BIT_AND_EXPR
6062               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
6063               || TREE_CODE (arg0) == BIT_IOR_EXPR
6064               || TREE_CODE (arg0) == BIT_XOR_EXPR)
6065           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6066         return fold (build (TREE_CODE (arg0), type,
6067                             fold (build (code, type,
6068                                          TREE_OPERAND (arg0, 0), arg1)),
6069                             fold (build (code, type,
6070                                          TREE_OPERAND (arg0, 1), arg1))));
6071
6072       /* Two consecutive rotates adding up to the width of the mode can
6073          be ignored.  */
6074       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6075           && TREE_CODE (arg0) == RROTATE_EXPR
6076           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6077           && TREE_INT_CST_HIGH (arg1) == 0
6078           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
6079           && ((TREE_INT_CST_LOW (arg1)
6080                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
6081               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
6082         return TREE_OPERAND (arg0, 0);
6083
6084       goto binary;
6085
6086     case MIN_EXPR:
6087       if (operand_equal_p (arg0, arg1, 0))
6088         return omit_one_operand (type, arg0, arg1);
6089       if (INTEGRAL_TYPE_P (type)
6090           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
6091         return omit_one_operand (type, arg1, arg0);
6092       goto associate;
6093
6094     case MAX_EXPR:
6095       if (operand_equal_p (arg0, arg1, 0))
6096         return omit_one_operand (type, arg0, arg1);
6097       if (INTEGRAL_TYPE_P (type)
6098           && TYPE_MAX_VALUE (type)
6099           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
6100         return omit_one_operand (type, arg1, arg0);
6101       goto associate;
6102
6103     case TRUTH_NOT_EXPR:
6104       /* Note that the operand of this must be an int
6105          and its values must be 0 or 1.
6106          ("true" is a fixed value perhaps depending on the language,
6107          but we don't handle values other than 1 correctly yet.)  */
6108       tem = invert_truthvalue (arg0);
6109       /* Avoid infinite recursion.  */
6110       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
6111         return t;
6112       return convert (type, tem);
6113
6114     case TRUTH_ANDIF_EXPR:
6115       /* Note that the operands of this must be ints
6116          and their values must be 0 or 1.
6117          ("true" is a fixed value perhaps depending on the language.)  */
6118       /* If first arg is constant zero, return it.  */
6119       if (integer_zerop (arg0))
6120         return convert (type, arg0);
6121     case TRUTH_AND_EXPR:
6122       /* If either arg is constant true, drop it.  */
6123       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6124         return non_lvalue (convert (type, arg1));
6125       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
6126           /* Preserve sequence points.  */
6127           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6128         return non_lvalue (convert (type, arg0));
6129       /* If second arg is constant zero, result is zero, but first arg
6130          must be evaluated.  */
6131       if (integer_zerop (arg1))
6132         return omit_one_operand (type, arg1, arg0);
6133       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
6134          case will be handled here.  */
6135       if (integer_zerop (arg0))
6136         return omit_one_operand (type, arg0, arg1);
6137
6138     truth_andor:
6139       /* We only do these simplifications if we are optimizing.  */
6140       if (!optimize)
6141         return t;
6142
6143       /* Check for things like (A || B) && (A || C).  We can convert this
6144          to A || (B && C).  Note that either operator can be any of the four
6145          truth and/or operations and the transformation will still be
6146          valid.   Also note that we only care about order for the
6147          ANDIF and ORIF operators.  If B contains side effects, this
6148          might change the truth-value of A.  */
6149       if (TREE_CODE (arg0) == TREE_CODE (arg1)
6150           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
6151               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
6152               || TREE_CODE (arg0) == TRUTH_AND_EXPR
6153               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
6154           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
6155         {
6156           tree a00 = TREE_OPERAND (arg0, 0);
6157           tree a01 = TREE_OPERAND (arg0, 1);
6158           tree a10 = TREE_OPERAND (arg1, 0);
6159           tree a11 = TREE_OPERAND (arg1, 1);
6160           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
6161                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
6162                              && (code == TRUTH_AND_EXPR
6163                                  || code == TRUTH_OR_EXPR));
6164
6165           if (operand_equal_p (a00, a10, 0))
6166             return fold (build (TREE_CODE (arg0), type, a00,
6167                                 fold (build (code, type, a01, a11))));
6168           else if (commutative && operand_equal_p (a00, a11, 0))
6169             return fold (build (TREE_CODE (arg0), type, a00,
6170                                 fold (build (code, type, a01, a10))));
6171           else if (commutative && operand_equal_p (a01, a10, 0))
6172             return fold (build (TREE_CODE (arg0), type, a01,
6173                                 fold (build (code, type, a00, a11))));
6174
6175           /* This case if tricky because we must either have commutative
6176              operators or else A10 must not have side-effects.  */
6177
6178           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
6179                    && operand_equal_p (a01, a11, 0))
6180             return fold (build (TREE_CODE (arg0), type,
6181                                 fold (build (code, type, a00, a10)),
6182                                 a01));
6183         }
6184
6185       /* See if we can build a range comparison.  */
6186       if (0 != (tem = fold_range_test (t)))
6187         return tem;
6188
6189       /* Check for the possibility of merging component references.  If our
6190          lhs is another similar operation, try to merge its rhs with our
6191          rhs.  Then try to merge our lhs and rhs.  */
6192       if (TREE_CODE (arg0) == code
6193           && 0 != (tem = fold_truthop (code, type,
6194                                        TREE_OPERAND (arg0, 1), arg1)))
6195         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6196
6197       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
6198         return tem;
6199
6200       return t;
6201
6202     case TRUTH_ORIF_EXPR:
6203       /* Note that the operands of this must be ints
6204          and their values must be 0 or true.
6205          ("true" is a fixed value perhaps depending on the language.)  */
6206       /* If first arg is constant true, return it.  */
6207       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6208         return convert (type, arg0);
6209     case TRUTH_OR_EXPR:
6210       /* If either arg is constant zero, drop it.  */
6211       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
6212         return non_lvalue (convert (type, arg1));
6213       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
6214           /* Preserve sequence points.  */
6215           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
6216         return non_lvalue (convert (type, arg0));
6217       /* If second arg is constant true, result is true, but we must
6218          evaluate first arg.  */
6219       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
6220         return omit_one_operand (type, arg1, arg0);
6221       /* Likewise for first arg, but note this only occurs here for
6222          TRUTH_OR_EXPR.  */
6223       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
6224         return omit_one_operand (type, arg0, arg1);
6225       goto truth_andor;
6226
6227     case TRUTH_XOR_EXPR:
6228       /* If either arg is constant zero, drop it.  */
6229       if (integer_zerop (arg0))
6230         return non_lvalue (convert (type, arg1));
6231       if (integer_zerop (arg1))
6232         return non_lvalue (convert (type, arg0));
6233       /* If either arg is constant true, this is a logical inversion.  */
6234       if (integer_onep (arg0))
6235         return non_lvalue (convert (type, invert_truthvalue (arg1)));
6236       if (integer_onep (arg1))
6237         return non_lvalue (convert (type, invert_truthvalue (arg0)));
6238       return t;
6239
6240     case EQ_EXPR:
6241     case NE_EXPR:
6242     case LT_EXPR:
6243     case GT_EXPR:
6244     case LE_EXPR:
6245     case GE_EXPR:
6246       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6247         {
6248           /* (-a) CMP (-b) -> b CMP a  */
6249           if (TREE_CODE (arg0) == NEGATE_EXPR
6250               && TREE_CODE (arg1) == NEGATE_EXPR)
6251             return fold (build (code, type, TREE_OPERAND (arg1, 0),
6252                                 TREE_OPERAND (arg0, 0)));
6253           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
6254           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
6255             return
6256               fold (build
6257                     (swap_tree_comparison (code), type,
6258                      TREE_OPERAND (arg0, 0),
6259                      build_real (TREE_TYPE (arg1),
6260                                  REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
6261           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
6262           /* a CMP (-0) -> a CMP 0  */
6263           if (TREE_CODE (arg1) == REAL_CST
6264               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
6265             return fold (build (code, type, arg0,
6266                                 build_real (TREE_TYPE (arg1), dconst0)));
6267         }
6268
6269       /* If one arg is a constant integer, put it last.  */
6270       if (TREE_CODE (arg0) == INTEGER_CST
6271           && TREE_CODE (arg1) != INTEGER_CST)
6272         {
6273           TREE_OPERAND (t, 0) = arg1;
6274           TREE_OPERAND (t, 1) = arg0;
6275           arg0 = TREE_OPERAND (t, 0);
6276           arg1 = TREE_OPERAND (t, 1);
6277           code = swap_tree_comparison (code);
6278           TREE_SET_CODE (t, code);
6279         }
6280
6281       /* Convert foo++ == CONST into ++foo == CONST + INCR.
6282          First, see if one arg is constant; find the constant arg
6283          and the other one.  */
6284       {
6285         tree constop = 0, varop = NULL_TREE;
6286         int constopnum = -1;
6287
6288         if (TREE_CONSTANT (arg1))
6289           constopnum = 1, constop = arg1, varop = arg0;
6290         if (TREE_CONSTANT (arg0))
6291           constopnum = 0, constop = arg0, varop = arg1;
6292
6293         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
6294           {
6295             /* This optimization is invalid for ordered comparisons
6296                if CONST+INCR overflows or if foo+incr might overflow.
6297                This optimization is invalid for floating point due to rounding.
6298                For pointer types we assume overflow doesn't happen.  */
6299             if (POINTER_TYPE_P (TREE_TYPE (varop))
6300                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6301                     && (code == EQ_EXPR || code == NE_EXPR)))
6302               {
6303                 tree newconst
6304                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6305                                  constop, TREE_OPERAND (varop, 1)));
6306
6307                 /* Do not overwrite the current varop to be a preincrement,
6308                    create a new node so that we won't confuse our caller who
6309                    might create trees and throw them away, reusing the
6310                    arguments that they passed to build.  This shows up in
6311                    the THEN or ELSE parts of ?: being postincrements.  */
6312                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6313                                TREE_OPERAND (varop, 0),
6314                                TREE_OPERAND (varop, 1));
6315
6316                 /* If VAROP is a reference to a bitfield, we must mask
6317                    the constant by the width of the field.  */
6318                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6319                     && DECL_BIT_FIELD(TREE_OPERAND
6320                                       (TREE_OPERAND (varop, 0), 1)))
6321                   {
6322                     int size
6323                       = TREE_INT_CST_LOW (DECL_SIZE
6324                                           (TREE_OPERAND
6325                                            (TREE_OPERAND (varop, 0), 1)));
6326                     tree mask, unsigned_type;
6327                     unsigned int precision;
6328                     tree folded_compare;
6329
6330                     /* First check whether the comparison would come out
6331                        always the same.  If we don't do that we would
6332                        change the meaning with the masking.  */
6333                     if (constopnum == 0)
6334                       folded_compare = fold (build (code, type, constop,
6335                                                     TREE_OPERAND (varop, 0)));
6336                     else
6337                       folded_compare = fold (build (code, type,
6338                                                     TREE_OPERAND (varop, 0),
6339                                                     constop));
6340                     if (integer_zerop (folded_compare)
6341                         || integer_onep (folded_compare))
6342                       return omit_one_operand (type, folded_compare, varop);
6343
6344                     unsigned_type = type_for_size (size, 1);
6345                     precision = TYPE_PRECISION (unsigned_type);
6346                     mask = build_int_2 (~0, ~0);
6347                     TREE_TYPE (mask) = unsigned_type;
6348                     force_fit_type (mask, 0);
6349                     mask = const_binop (RSHIFT_EXPR, mask,
6350                                         size_int (precision - size), 0);
6351                     newconst = fold (build (BIT_AND_EXPR,
6352                                             TREE_TYPE (varop), newconst,
6353                                             convert (TREE_TYPE (varop),
6354                                                      mask)));
6355                   }
6356
6357                 t = build (code, type,
6358                            (constopnum == 0) ? newconst : varop,
6359                            (constopnum == 1) ? newconst : varop);
6360                 return t;
6361               }
6362           }
6363         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6364           {
6365             if (POINTER_TYPE_P (TREE_TYPE (varop))
6366                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6367                     && (code == EQ_EXPR || code == NE_EXPR)))
6368               {
6369                 tree newconst
6370                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6371                                  constop, TREE_OPERAND (varop, 1)));
6372
6373                 /* Do not overwrite the current varop to be a predecrement,
6374                    create a new node so that we won't confuse our caller who
6375                    might create trees and throw them away, reusing the
6376                    arguments that they passed to build.  This shows up in
6377                    the THEN or ELSE parts of ?: being postdecrements.  */
6378                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6379                                TREE_OPERAND (varop, 0),
6380                                TREE_OPERAND (varop, 1));
6381
6382                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6383                     && DECL_BIT_FIELD(TREE_OPERAND
6384                                       (TREE_OPERAND (varop, 0), 1)))
6385                   {
6386                     int size
6387                       = TREE_INT_CST_LOW (DECL_SIZE
6388                                           (TREE_OPERAND
6389                                            (TREE_OPERAND (varop, 0), 1)));
6390                     tree mask, unsigned_type;
6391                     unsigned int precision;
6392                     tree folded_compare;
6393
6394                     if (constopnum == 0)
6395                       folded_compare = fold (build (code, type, constop,
6396                                                     TREE_OPERAND (varop, 0)));
6397                     else
6398                       folded_compare = fold (build (code, type,
6399                                                     TREE_OPERAND (varop, 0),
6400                                                     constop));
6401                     if (integer_zerop (folded_compare)
6402                         || integer_onep (folded_compare))
6403                       return omit_one_operand (type, folded_compare, varop);
6404
6405                     unsigned_type = type_for_size (size, 1);
6406                     precision = TYPE_PRECISION (unsigned_type);
6407                     mask = build_int_2 (~0, ~0);
6408                     TREE_TYPE (mask) = TREE_TYPE (varop);
6409                     force_fit_type (mask, 0);
6410                     mask = const_binop (RSHIFT_EXPR, mask,
6411                                         size_int (precision - size), 0);
6412                     newconst = fold (build (BIT_AND_EXPR,
6413                                             TREE_TYPE (varop), newconst,
6414                                             convert (TREE_TYPE (varop),
6415                                                      mask)));
6416                   }
6417
6418                 t = build (code, type,
6419                            (constopnum == 0) ? newconst : varop,
6420                            (constopnum == 1) ? newconst : varop);
6421                 return t;
6422               }
6423           }
6424       }
6425
6426       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
6427       if (TREE_CODE (arg1) == INTEGER_CST
6428           && TREE_CODE (arg0) != INTEGER_CST
6429           && tree_int_cst_sgn (arg1) > 0)
6430         {
6431           switch (TREE_CODE (t))
6432             {
6433             case GE_EXPR:
6434               code = GT_EXPR;
6435               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6436               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6437               break;
6438
6439             case LT_EXPR:
6440               code = LE_EXPR;
6441               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6442               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6443               break;
6444
6445             default:
6446               break;
6447             }
6448         }
6449
6450       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6451          a MINUS_EXPR of a constant, we can convert it into a comparison with
6452          a revised constant as long as no overflow occurs.  */
6453       if ((code == EQ_EXPR || code == NE_EXPR)
6454           && TREE_CODE (arg1) == INTEGER_CST
6455           && (TREE_CODE (arg0) == PLUS_EXPR
6456               || TREE_CODE (arg0) == MINUS_EXPR)
6457           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6458           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6459                                       ? MINUS_EXPR : PLUS_EXPR,
6460                                       arg1, TREE_OPERAND (arg0, 1), 0))
6461           && ! TREE_CONSTANT_OVERFLOW (tem))
6462         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6463
6464       /* Similarly for a NEGATE_EXPR.  */
6465       else if ((code == EQ_EXPR || code == NE_EXPR)
6466                && TREE_CODE (arg0) == NEGATE_EXPR
6467                && TREE_CODE (arg1) == INTEGER_CST
6468                && 0 != (tem = negate_expr (arg1))
6469                && TREE_CODE (tem) == INTEGER_CST
6470                && ! TREE_CONSTANT_OVERFLOW (tem))
6471         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6472
6473       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6474          for !=.  Don't do this for ordered comparisons due to overflow.  */
6475       else if ((code == NE_EXPR || code == EQ_EXPR)
6476                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6477         return fold (build (code, type,
6478                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6479
6480       /* If we are widening one operand of an integer comparison,
6481          see if the other operand is similarly being widened.  Perhaps we
6482          can do the comparison in the narrower type.  */
6483       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6484                && TREE_CODE (arg0) == NOP_EXPR
6485                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6486                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6487                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6488                    || (TREE_CODE (t1) == INTEGER_CST
6489                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6490         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6491
6492       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6493          constant, we can simplify it.  */
6494       else if (TREE_CODE (arg1) == INTEGER_CST
6495                && (TREE_CODE (arg0) == MIN_EXPR
6496                    || TREE_CODE (arg0) == MAX_EXPR)
6497                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6498         return optimize_minmax_comparison (t);
6499
6500       /* If we are comparing an ABS_EXPR with a constant, we can
6501          convert all the cases into explicit comparisons, but they may
6502          well not be faster than doing the ABS and one comparison.
6503          But ABS (X) <= C is a range comparison, which becomes a subtraction
6504          and a comparison, and is probably faster.  */
6505       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6506                && TREE_CODE (arg0) == ABS_EXPR
6507                && ! TREE_SIDE_EFFECTS (arg0)
6508                && (0 != (tem = negate_expr (arg1)))
6509                && TREE_CODE (tem) == INTEGER_CST
6510                && ! TREE_CONSTANT_OVERFLOW (tem))
6511         return fold (build (TRUTH_ANDIF_EXPR, type,
6512                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6513                             build (LE_EXPR, type,
6514                                    TREE_OPERAND (arg0, 0), arg1)));
6515
6516       /* If this is an EQ or NE comparison with zero and ARG0 is
6517          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6518          two operations, but the latter can be done in one less insn
6519          on machines that have only two-operand insns or on which a
6520          constant cannot be the first operand.  */
6521       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6522           && TREE_CODE (arg0) == BIT_AND_EXPR)
6523         {
6524           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6525               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6526             return
6527               fold (build (code, type,
6528                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6529                                   build (RSHIFT_EXPR,
6530                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6531                                          TREE_OPERAND (arg0, 1),
6532                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6533                                   convert (TREE_TYPE (arg0),
6534                                            integer_one_node)),
6535                            arg1));
6536           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6537                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6538             return
6539               fold (build (code, type,
6540                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6541                                   build (RSHIFT_EXPR,
6542                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6543                                          TREE_OPERAND (arg0, 0),
6544                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6545                                   convert (TREE_TYPE (arg0),
6546                                            integer_one_node)),
6547                            arg1));
6548         }
6549
6550       /* If this is an NE or EQ comparison of zero against the result of a
6551          signed MOD operation whose second operand is a power of 2, make
6552          the MOD operation unsigned since it is simpler and equivalent.  */
6553       if ((code == NE_EXPR || code == EQ_EXPR)
6554           && integer_zerop (arg1)
6555           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6556           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6557               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6558               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6559               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6560           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6561         {
6562           tree newtype = unsigned_type (TREE_TYPE (arg0));
6563           tree newmod = build (TREE_CODE (arg0), newtype,
6564                                convert (newtype, TREE_OPERAND (arg0, 0)),
6565                                convert (newtype, TREE_OPERAND (arg0, 1)));
6566
6567           return build (code, type, newmod, convert (newtype, arg1));
6568         }
6569
6570       /* If this is an NE comparison of zero with an AND of one, remove the
6571          comparison since the AND will give the correct value.  */
6572       if (code == NE_EXPR && integer_zerop (arg1)
6573           && TREE_CODE (arg0) == BIT_AND_EXPR
6574           && integer_onep (TREE_OPERAND (arg0, 1)))
6575         return convert (type, arg0);
6576
6577       /* If we have (A & C) == C where C is a power of 2, convert this into
6578          (A & C) != 0.  Similarly for NE_EXPR.  */
6579       if ((code == EQ_EXPR || code == NE_EXPR)
6580           && TREE_CODE (arg0) == BIT_AND_EXPR
6581           && integer_pow2p (TREE_OPERAND (arg0, 1))
6582           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6583         return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6584                       arg0, integer_zero_node);
6585
6586       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6587          and similarly for >= into !=.  */
6588       if ((code == LT_EXPR || code == GE_EXPR)
6589           && TREE_UNSIGNED (TREE_TYPE (arg0))
6590           && TREE_CODE (arg1) == LSHIFT_EXPR
6591           && integer_onep (TREE_OPERAND (arg1, 0)))
6592         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6593                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6594                              TREE_OPERAND (arg1, 1)),
6595                       convert (TREE_TYPE (arg0), integer_zero_node));
6596
6597       else if ((code == LT_EXPR || code == GE_EXPR)
6598                && TREE_UNSIGNED (TREE_TYPE (arg0))
6599                && (TREE_CODE (arg1) == NOP_EXPR
6600                    || TREE_CODE (arg1) == CONVERT_EXPR)
6601                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6602                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6603         return
6604           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6605                  convert (TREE_TYPE (arg0),
6606                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6607                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6608                  convert (TREE_TYPE (arg0), integer_zero_node));
6609
6610       /* Simplify comparison of something with itself.  (For IEEE
6611          floating-point, we can only do some of these simplifications.)  */
6612       if (operand_equal_p (arg0, arg1, 0))
6613         {
6614           switch (code)
6615             {
6616             case EQ_EXPR:
6617             case GE_EXPR:
6618             case LE_EXPR:
6619               if (! FLOAT_TYPE_P (TREE_TYPE (arg0)))
6620                 return constant_boolean_node (1, type);
6621               code = EQ_EXPR;
6622               TREE_SET_CODE (t, code);
6623               break;
6624
6625             case NE_EXPR:
6626               /* For NE, we can only do this simplification if integer.  */
6627               if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6628                 break;
6629               /* ... fall through ...  */
6630             case GT_EXPR:
6631             case LT_EXPR:
6632               return constant_boolean_node (0, type);
6633             default:
6634               abort ();
6635             }
6636         }
6637
6638       /* An unsigned comparison against 0 can be simplified.  */
6639       if (integer_zerop (arg1)
6640           && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6641               || POINTER_TYPE_P (TREE_TYPE (arg1)))
6642           && TREE_UNSIGNED (TREE_TYPE (arg1)))
6643         {
6644           switch (TREE_CODE (t))
6645             {
6646             case GT_EXPR:
6647               code = NE_EXPR;
6648               TREE_SET_CODE (t, NE_EXPR);
6649               break;
6650             case LE_EXPR:
6651               code = EQ_EXPR;
6652               TREE_SET_CODE (t, EQ_EXPR);
6653               break;
6654             case GE_EXPR:
6655               return omit_one_operand (type,
6656                                        convert (type, integer_one_node),
6657                                        arg0);
6658             case LT_EXPR:
6659               return omit_one_operand (type,
6660                                        convert (type, integer_zero_node),
6661                                        arg0);
6662             default:
6663               break;
6664             }
6665         }
6666
6667       /* Comparisons with the highest or lowest possible integer of
6668          the specified size will have known values and an unsigned
6669          <= 0x7fffffff can be simplified.  */
6670       {
6671         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6672
6673         if (TREE_CODE (arg1) == INTEGER_CST
6674             && ! TREE_CONSTANT_OVERFLOW (arg1)
6675             && width <= HOST_BITS_PER_WIDE_INT
6676             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6677                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6678           {
6679             if (TREE_INT_CST_HIGH (arg1) == 0
6680                 && (TREE_INT_CST_LOW (arg1)
6681                     == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6682                 && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6683               switch (TREE_CODE (t))
6684                 {
6685                 case GT_EXPR:
6686                   return omit_one_operand (type,
6687                                            convert (type, integer_zero_node),
6688                                            arg0);
6689                 case GE_EXPR:
6690                   TREE_SET_CODE (t, EQ_EXPR);
6691                   break;
6692
6693                 case LE_EXPR:
6694                   return omit_one_operand (type,
6695                                            convert (type, integer_one_node),
6696                                            arg0);
6697                 case LT_EXPR:
6698                   TREE_SET_CODE (t, NE_EXPR);
6699                   break;
6700
6701                 default:
6702                   break;
6703                 }
6704
6705             else if (TREE_INT_CST_HIGH (arg1) == -1
6706                      && (- TREE_INT_CST_LOW (arg1)
6707                          == ((unsigned HOST_WIDE_INT) 1 << (width - 1)))
6708                      && ! TREE_UNSIGNED (TREE_TYPE (arg1)))
6709               switch (TREE_CODE (t))
6710                 {
6711                 case LT_EXPR:
6712                   return omit_one_operand (type,
6713                                            convert (type, integer_zero_node),
6714                                            arg0);
6715                 case LE_EXPR:
6716                   TREE_SET_CODE (t, EQ_EXPR);
6717                   break;
6718
6719                 case GE_EXPR:
6720                   return omit_one_operand (type,
6721                                            convert (type, integer_one_node),
6722                                            arg0);
6723                 case GT_EXPR:
6724                   TREE_SET_CODE (t, NE_EXPR);
6725                   break;
6726
6727                 default:
6728                   break;
6729                 }
6730
6731             else if (TREE_INT_CST_HIGH (arg1) == 0
6732                       && (TREE_INT_CST_LOW (arg1)
6733                           == ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1)
6734                       && TREE_UNSIGNED (TREE_TYPE (arg1))
6735                          /* signed_type does not work on pointer types.  */
6736                       && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6737
6738               switch (TREE_CODE (t))
6739                 {
6740                 case LE_EXPR:
6741                   return fold (build (GE_EXPR, type,
6742                                       convert (signed_type (TREE_TYPE (arg0)),
6743                                                arg0),
6744                                       convert (signed_type (TREE_TYPE (arg1)),
6745                                                integer_zero_node)));
6746                 case GT_EXPR:
6747                   return fold (build (LT_EXPR, type,
6748                                       convert (signed_type (TREE_TYPE (arg0)),
6749                                                arg0),
6750                                       convert (signed_type (TREE_TYPE (arg1)),
6751                                                integer_zero_node)));
6752
6753                 default:
6754                   break;
6755                 }
6756           }
6757       }
6758
6759       /* If we are comparing an expression that just has comparisons
6760          of two integer values, arithmetic expressions of those comparisons,
6761          and constants, we can simplify it.  There are only three cases
6762          to check: the two values can either be equal, the first can be
6763          greater, or the second can be greater.  Fold the expression for
6764          those three values.  Since each value must be 0 or 1, we have
6765          eight possibilities, each of which corresponds to the constant 0
6766          or 1 or one of the six possible comparisons.
6767
6768          This handles common cases like (a > b) == 0 but also handles
6769          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6770          occur in macroized code.  */
6771
6772       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6773         {
6774           tree cval1 = 0, cval2 = 0;
6775           int save_p = 0;
6776
6777           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6778               /* Don't handle degenerate cases here; they should already
6779                  have been handled anyway.  */
6780               && cval1 != 0 && cval2 != 0
6781               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6782               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6783               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6784               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6785               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6786               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6787                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6788             {
6789               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6790               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6791
6792               /* We can't just pass T to eval_subst in case cval1 or cval2
6793                  was the same as ARG1.  */
6794
6795               tree high_result
6796                 = fold (build (code, type,
6797                                eval_subst (arg0, cval1, maxval, cval2, minval),
6798                                arg1));
6799               tree equal_result
6800                 = fold (build (code, type,
6801                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6802                                arg1));
6803               tree low_result
6804                 = fold (build (code, type,
6805                                eval_subst (arg0, cval1, minval, cval2, maxval),
6806                                arg1));
6807
6808               /* All three of these results should be 0 or 1.  Confirm they
6809                  are.  Then use those values to select the proper code
6810                  to use.  */
6811
6812               if ((integer_zerop (high_result)
6813                    || integer_onep (high_result))
6814                   && (integer_zerop (equal_result)
6815                       || integer_onep (equal_result))
6816                   && (integer_zerop (low_result)
6817                       || integer_onep (low_result)))
6818                 {
6819                   /* Make a 3-bit mask with the high-order bit being the
6820                      value for `>', the next for '=', and the low for '<'.  */
6821                   switch ((integer_onep (high_result) * 4)
6822                           + (integer_onep (equal_result) * 2)
6823                           + integer_onep (low_result))
6824                     {
6825                     case 0:
6826                       /* Always false.  */
6827                       return omit_one_operand (type, integer_zero_node, arg0);
6828                     case 1:
6829                       code = LT_EXPR;
6830                       break;
6831                     case 2:
6832                       code = EQ_EXPR;
6833                       break;
6834                     case 3:
6835                       code = LE_EXPR;
6836                       break;
6837                     case 4:
6838                       code = GT_EXPR;
6839                       break;
6840                     case 5:
6841                       code = NE_EXPR;
6842                       break;
6843                     case 6:
6844                       code = GE_EXPR;
6845                       break;
6846                     case 7:
6847                       /* Always true.  */
6848                       return omit_one_operand (type, integer_one_node, arg0);
6849                     }
6850
6851                   t = build (code, type, cval1, cval2);
6852                   if (save_p)
6853                     return save_expr (t);
6854                   else
6855                     return fold (t);
6856                 }
6857             }
6858         }
6859
6860       /* If this is a comparison of a field, we may be able to simplify it.  */
6861       if ((TREE_CODE (arg0) == COMPONENT_REF
6862            || TREE_CODE (arg0) == BIT_FIELD_REF)
6863           && (code == EQ_EXPR || code == NE_EXPR)
6864           /* Handle the constant case even without -O
6865              to make sure the warnings are given.  */
6866           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6867         {
6868           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6869           return t1 ? t1 : t;
6870         }
6871
6872       /* If this is a comparison of complex values and either or both sides
6873          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6874          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6875          This may prevent needless evaluations.  */
6876       if ((code == EQ_EXPR || code == NE_EXPR)
6877           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6878           && (TREE_CODE (arg0) == COMPLEX_EXPR
6879               || TREE_CODE (arg1) == COMPLEX_EXPR
6880               || TREE_CODE (arg0) == COMPLEX_CST
6881               || TREE_CODE (arg1) == COMPLEX_CST))
6882         {
6883           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6884           tree real0, imag0, real1, imag1;
6885
6886           arg0 = save_expr (arg0);
6887           arg1 = save_expr (arg1);
6888           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6889           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6890           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6891           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6892
6893           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6894                                : TRUTH_ORIF_EXPR),
6895                               type,
6896                               fold (build (code, type, real0, real1)),
6897                               fold (build (code, type, imag0, imag1))));
6898         }
6899
6900       /* Optimize comparisons of strlen vs zero to a compare of the
6901          first character of the string vs zero.  To wit,
6902                 strlen(ptr) == 0   =>  *ptr == 0
6903                 strlen(ptr) != 0   =>  *ptr != 0
6904          Other cases should reduce to one of these two (or a constant)
6905          due to the return value of strlen being unsigned.  */
6906       if ((code == EQ_EXPR || code == NE_EXPR)
6907           && integer_zerop (arg1)
6908           && TREE_CODE (arg0) == CALL_EXPR
6909           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR)
6910         {
6911           tree fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6912           tree arglist;
6913
6914           if (TREE_CODE (fndecl) == FUNCTION_DECL
6915               && DECL_BUILT_IN (fndecl)
6916               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
6917               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
6918               && (arglist = TREE_OPERAND (arg0, 1))
6919               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
6920               && ! TREE_CHAIN (arglist))
6921             return fold (build (code, type,
6922                                 build1 (INDIRECT_REF, char_type_node,
6923                                         TREE_VALUE(arglist)),
6924                                 integer_zero_node));
6925         }
6926
6927       /* From here on, the only cases we handle are when the result is
6928          known to be a constant.
6929
6930          To compute GT, swap the arguments and do LT.
6931          To compute GE, do LT and invert the result.
6932          To compute LE, swap the arguments, do LT and invert the result.
6933          To compute NE, do EQ and invert the result.
6934
6935          Therefore, the code below must handle only EQ and LT.  */
6936
6937       if (code == LE_EXPR || code == GT_EXPR)
6938         {
6939           tem = arg0, arg0 = arg1, arg1 = tem;
6940           code = swap_tree_comparison (code);
6941         }
6942
6943       /* Note that it is safe to invert for real values here because we
6944          will check below in the one case that it matters.  */
6945
6946       t1 = NULL_TREE;
6947       invert = 0;
6948       if (code == NE_EXPR || code == GE_EXPR)
6949         {
6950           invert = 1;
6951           code = invert_tree_comparison (code);
6952         }
6953
6954       /* Compute a result for LT or EQ if args permit;
6955          otherwise return T.  */
6956       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6957         {
6958           if (code == EQ_EXPR)
6959             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
6960           else
6961             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6962                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6963                                : INT_CST_LT (arg0, arg1)),
6964                               0);
6965         }
6966
6967 #if 0 /* This is no longer useful, but breaks some real code.  */
6968       /* Assume a nonexplicit constant cannot equal an explicit one,
6969          since such code would be undefined anyway.
6970          Exception: on sysvr4, using #pragma weak,
6971          a label can come out as 0.  */
6972       else if (TREE_CODE (arg1) == INTEGER_CST
6973                && !integer_zerop (arg1)
6974                && TREE_CONSTANT (arg0)
6975                && TREE_CODE (arg0) == ADDR_EXPR
6976                && code == EQ_EXPR)
6977         t1 = build_int_2 (0, 0);
6978 #endif
6979       /* Two real constants can be compared explicitly.  */
6980       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6981         {
6982           /* If either operand is a NaN, the result is false with two
6983              exceptions: First, an NE_EXPR is true on NaNs, but that case
6984              is already handled correctly since we will be inverting the
6985              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6986              or a GE_EXPR into a LT_EXPR, we must return true so that it
6987              will be inverted into false.  */
6988
6989           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6990               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6991             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6992
6993           else if (code == EQ_EXPR)
6994             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6995                                                  TREE_REAL_CST (arg1)),
6996                               0);
6997           else
6998             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6999                                                 TREE_REAL_CST (arg1)),
7000                               0);
7001         }
7002
7003       if (t1 == NULL_TREE)
7004         return t;
7005
7006       if (invert)
7007         TREE_INT_CST_LOW (t1) ^= 1;
7008
7009       TREE_TYPE (t1) = type;
7010       if (TREE_CODE (type) == BOOLEAN_TYPE)
7011         return truthvalue_conversion (t1);
7012       return t1;
7013
7014     case COND_EXPR:
7015       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
7016          so all simple results must be passed through pedantic_non_lvalue.  */
7017       if (TREE_CODE (arg0) == INTEGER_CST)
7018         return pedantic_non_lvalue
7019           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
7020       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
7021         return pedantic_omit_one_operand (type, arg1, arg0);
7022
7023       /* If the second operand is zero, invert the comparison and swap
7024          the second and third operands.  Likewise if the second operand
7025          is constant and the third is not or if the third operand is
7026          equivalent to the first operand of the comparison.  */
7027
7028       if (integer_zerop (arg1)
7029           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
7030           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7031               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7032                                                  TREE_OPERAND (t, 2),
7033                                                  TREE_OPERAND (arg0, 1))))
7034         {
7035           /* See if this can be inverted.  If it can't, possibly because
7036              it was a floating-point inequality comparison, don't do
7037              anything.  */
7038           tem = invert_truthvalue (arg0);
7039
7040           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7041             {
7042               t = build (code, type, tem,
7043                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7044               arg0 = tem;
7045               /* arg1 should be the first argument of the new T.  */
7046               arg1 = TREE_OPERAND (t, 1);
7047               STRIP_NOPS (arg1);
7048             }
7049         }
7050
7051       /* If we have A op B ? A : C, we may be able to convert this to a
7052          simpler expression, depending on the operation and the values
7053          of B and C.  IEEE floating point prevents this though,
7054          because A or B might be -0.0 or a NaN.  */
7055
7056       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
7057           && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
7058               || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
7059               || flag_unsafe_math_optimizations)
7060           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
7061                                              arg1, TREE_OPERAND (arg0, 1)))
7062         {
7063           tree arg2 = TREE_OPERAND (t, 2);
7064           enum tree_code comp_code = TREE_CODE (arg0);
7065
7066           STRIP_NOPS (arg2);
7067
7068           /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
7069              depending on the comparison operation.  */
7070           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
7071                ? real_zerop (TREE_OPERAND (arg0, 1))
7072                : integer_zerop (TREE_OPERAND (arg0, 1)))
7073               && TREE_CODE (arg2) == NEGATE_EXPR
7074               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
7075             switch (comp_code)
7076               {
7077               case EQ_EXPR:
7078                 return
7079                   pedantic_non_lvalue
7080                     (convert (type,
7081                               negate_expr
7082                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
7083                                         arg1))));
7084
7085               case NE_EXPR:
7086                 return pedantic_non_lvalue (convert (type, arg1));
7087               case GE_EXPR:
7088               case GT_EXPR:
7089                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7090                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
7091                 return pedantic_non_lvalue
7092                   (convert (type, fold (build1 (ABS_EXPR,
7093                                                 TREE_TYPE (arg1), arg1))));
7094               case LE_EXPR:
7095               case LT_EXPR:
7096                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
7097                   arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
7098                 return pedantic_non_lvalue
7099                   (negate_expr (convert (type,
7100                                          fold (build1 (ABS_EXPR,
7101                                                        TREE_TYPE (arg1),
7102                                                        arg1)))));
7103               default:
7104                 abort ();
7105               }
7106
7107           /* If this is A != 0 ? A : 0, this is simply A.  For ==, it is
7108              always zero.  */
7109
7110           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
7111             {
7112               if (comp_code == NE_EXPR)
7113                 return pedantic_non_lvalue (convert (type, arg1));
7114               else if (comp_code == EQ_EXPR)
7115                 return pedantic_non_lvalue (convert (type, integer_zero_node));
7116             }
7117
7118           /* If this is A op B ? A : B, this is either A, B, min (A, B),
7119              or max (A, B), depending on the operation.  */
7120
7121           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
7122                                               arg2, TREE_OPERAND (arg0, 0)))
7123             {
7124               tree comp_op0 = TREE_OPERAND (arg0, 0);
7125               tree comp_op1 = TREE_OPERAND (arg0, 1);
7126               tree comp_type = TREE_TYPE (comp_op0);
7127
7128               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
7129               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
7130                 comp_type = type;
7131
7132               switch (comp_code)
7133                 {
7134                 case EQ_EXPR:
7135                   return pedantic_non_lvalue (convert (type, arg2));
7136                 case NE_EXPR:
7137                   return pedantic_non_lvalue (convert (type, arg1));
7138                 case LE_EXPR:
7139                 case LT_EXPR:
7140                   /* In C++ a ?: expression can be an lvalue, so put the
7141                      operand which will be used if they are equal first
7142                      so that we can convert this back to the
7143                      corresponding COND_EXPR.  */
7144                   return pedantic_non_lvalue
7145                     (convert (type, fold (build (MIN_EXPR, comp_type,
7146                                                  (comp_code == LE_EXPR
7147                                                   ? comp_op0 : comp_op1),
7148                                                  (comp_code == LE_EXPR
7149                                                   ? comp_op1 : comp_op0)))));
7150                   break;
7151                 case GE_EXPR:
7152                 case GT_EXPR:
7153                   return pedantic_non_lvalue
7154                     (convert (type, fold (build (MAX_EXPR, comp_type,
7155                                                  (comp_code == GE_EXPR
7156                                                   ? comp_op0 : comp_op1),
7157                                                  (comp_code == GE_EXPR
7158                                                   ? comp_op1 : comp_op0)))));
7159                   break;
7160                 default:
7161                   abort ();
7162                 }
7163             }
7164
7165           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
7166              we might still be able to simplify this.  For example,
7167              if C1 is one less or one more than C2, this might have started
7168              out as a MIN or MAX and been transformed by this function.
7169              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
7170
7171           if (INTEGRAL_TYPE_P (type)
7172               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7173               && TREE_CODE (arg2) == INTEGER_CST)
7174             switch (comp_code)
7175               {
7176               case EQ_EXPR:
7177                 /* We can replace A with C1 in this case.  */
7178                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
7179                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
7180                            TREE_OPERAND (t, 2));
7181                 break;
7182
7183               case LT_EXPR:
7184                 /* If C1 is C2 + 1, this is min(A, C2).  */
7185                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7186                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7187                                         const_binop (PLUS_EXPR, arg2,
7188                                                      integer_one_node, 0), 1))
7189                   return pedantic_non_lvalue
7190                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7191                 break;
7192
7193               case LE_EXPR:
7194                 /* If C1 is C2 - 1, this is min(A, C2).  */
7195                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7196                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7197                                         const_binop (MINUS_EXPR, arg2,
7198                                                      integer_one_node, 0), 1))
7199                   return pedantic_non_lvalue
7200                     (fold (build (MIN_EXPR, type, arg1, arg2)));
7201                 break;
7202
7203               case GT_EXPR:
7204                 /* If C1 is C2 - 1, this is max(A, C2).  */
7205                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
7206                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7207                                         const_binop (MINUS_EXPR, arg2,
7208                                                      integer_one_node, 0), 1))
7209                   return pedantic_non_lvalue
7210                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7211                 break;
7212
7213               case GE_EXPR:
7214                 /* If C1 is C2 + 1, this is max(A, C2).  */
7215                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
7216                     && operand_equal_p (TREE_OPERAND (arg0, 1),
7217                                         const_binop (PLUS_EXPR, arg2,
7218                                                      integer_one_node, 0), 1))
7219                   return pedantic_non_lvalue
7220                     (fold (build (MAX_EXPR, type, arg1, arg2)));
7221                 break;
7222               case NE_EXPR:
7223                 break;
7224               default:
7225                 abort ();
7226               }
7227         }
7228
7229       /* If the second operand is simpler than the third, swap them
7230          since that produces better jump optimization results.  */
7231       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7232            || TREE_CODE (arg1) == SAVE_EXPR)
7233           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7234                 || DECL_P (TREE_OPERAND (t, 2))
7235                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7236         {
7237           /* See if this can be inverted.  If it can't, possibly because
7238              it was a floating-point inequality comparison, don't do
7239              anything.  */
7240           tem = invert_truthvalue (arg0);
7241
7242           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7243             {
7244               t = build (code, type, tem,
7245                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7246               arg0 = tem;
7247               /* arg1 should be the first argument of the new T.  */
7248               arg1 = TREE_OPERAND (t, 1);
7249               STRIP_NOPS (arg1);
7250             }
7251         }
7252
7253       /* Convert A ? 1 : 0 to simply A.  */
7254       if (integer_onep (TREE_OPERAND (t, 1))
7255           && integer_zerop (TREE_OPERAND (t, 2))
7256           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7257              call to fold will try to move the conversion inside
7258              a COND, which will recurse.  In that case, the COND_EXPR
7259              is probably the best choice, so leave it alone.  */
7260           && type == TREE_TYPE (arg0))
7261         return pedantic_non_lvalue (arg0);
7262
7263       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7264          operation is simply A & 2.  */
7265
7266       if (integer_zerop (TREE_OPERAND (t, 2))
7267           && TREE_CODE (arg0) == NE_EXPR
7268           && integer_zerop (TREE_OPERAND (arg0, 1))
7269           && integer_pow2p (arg1)
7270           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7271           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7272                               arg1, 1))
7273         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7274
7275       return t;
7276
7277     case COMPOUND_EXPR:
7278       /* When pedantic, a compound expression can be neither an lvalue
7279          nor an integer constant expression.  */
7280       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7281         return t;
7282       /* Don't let (0, 0) be null pointer constant.  */
7283       if (integer_zerop (arg1))
7284         return build1 (NOP_EXPR, type, arg1);
7285       return convert (type, arg1);
7286
7287     case COMPLEX_EXPR:
7288       if (wins)
7289         return build_complex (type, arg0, arg1);
7290       return t;
7291
7292     case REALPART_EXPR:
7293       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7294         return t;
7295       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7296         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7297                                  TREE_OPERAND (arg0, 1));
7298       else if (TREE_CODE (arg0) == COMPLEX_CST)
7299         return TREE_REALPART (arg0);
7300       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7301         return fold (build (TREE_CODE (arg0), type,
7302                             fold (build1 (REALPART_EXPR, type,
7303                                           TREE_OPERAND (arg0, 0))),
7304                             fold (build1 (REALPART_EXPR,
7305                                           type, TREE_OPERAND (arg0, 1)))));
7306       return t;
7307
7308     case IMAGPART_EXPR:
7309       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7310         return convert (type, integer_zero_node);
7311       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7312         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7313                                  TREE_OPERAND (arg0, 0));
7314       else if (TREE_CODE (arg0) == COMPLEX_CST)
7315         return TREE_IMAGPART (arg0);
7316       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7317         return fold (build (TREE_CODE (arg0), type,
7318                             fold (build1 (IMAGPART_EXPR, type,
7319                                           TREE_OPERAND (arg0, 0))),
7320                             fold (build1 (IMAGPART_EXPR, type,
7321                                           TREE_OPERAND (arg0, 1)))));
7322       return t;
7323
7324       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7325          appropriate.  */
7326     case CLEANUP_POINT_EXPR:
7327       if (! has_cleanups (arg0))
7328         return TREE_OPERAND (t, 0);
7329
7330       {
7331         enum tree_code code0 = TREE_CODE (arg0);
7332         int kind0 = TREE_CODE_CLASS (code0);
7333         tree arg00 = TREE_OPERAND (arg0, 0);
7334         tree arg01;
7335
7336         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7337           return fold (build1 (code0, type,
7338                                fold (build1 (CLEANUP_POINT_EXPR,
7339                                              TREE_TYPE (arg00), arg00))));
7340
7341         if (kind0 == '<' || kind0 == '2'
7342             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7343             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7344             || code0 == TRUTH_XOR_EXPR)
7345           {
7346             arg01 = TREE_OPERAND (arg0, 1);
7347
7348             if (TREE_CONSTANT (arg00)
7349                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7350                     && ! has_cleanups (arg00)))
7351               return fold (build (code0, type, arg00,
7352                                   fold (build1 (CLEANUP_POINT_EXPR,
7353                                                 TREE_TYPE (arg01), arg01))));
7354
7355             if (TREE_CONSTANT (arg01))
7356               return fold (build (code0, type,
7357                                   fold (build1 (CLEANUP_POINT_EXPR,
7358                                                 TREE_TYPE (arg00), arg00)),
7359                                   arg01));
7360           }
7361
7362         return t;
7363       }
7364
7365     case CALL_EXPR:
7366       /* Check for a built-in function.  */
7367       if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
7368           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))
7369               == FUNCTION_DECL)
7370           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)))
7371         {
7372           tree tmp = fold_builtin (expr);
7373           if (tmp)
7374             return tmp;
7375         }
7376       return t;
7377
7378     default:
7379       return t;
7380     } /* switch (code) */
7381 }
7382
7383 /* Determine if first argument is a multiple of second argument.  Return 0 if
7384    it is not, or we cannot easily determined it to be.
7385
7386    An example of the sort of thing we care about (at this point; this routine
7387    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7388    fold cases do now) is discovering that
7389
7390      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7391
7392    is a multiple of
7393
7394      SAVE_EXPR (J * 8)
7395
7396    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7397
7398    This code also handles discovering that
7399
7400      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7401
7402    is a multiple of 8 so we don't have to worry about dealing with a
7403    possible remainder.
7404
7405    Note that we *look* inside a SAVE_EXPR only to determine how it was
7406    calculated; it is not safe for fold to do much of anything else with the
7407    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7408    at run time.  For example, the latter example above *cannot* be implemented
7409    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7410    evaluation time of the original SAVE_EXPR is not necessarily the same at
7411    the time the new expression is evaluated.  The only optimization of this
7412    sort that would be valid is changing
7413
7414      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7415
7416    divided by 8 to
7417
7418      SAVE_EXPR (I) * SAVE_EXPR (J)
7419
7420    (where the same SAVE_EXPR (J) is used in the original and the
7421    transformed version).  */
7422
7423 static int
7424 multiple_of_p (type, top, bottom)
7425      tree type;
7426      tree top;
7427      tree bottom;
7428 {
7429   if (operand_equal_p (top, bottom, 0))
7430     return 1;
7431
7432   if (TREE_CODE (type) != INTEGER_TYPE)
7433     return 0;
7434
7435   switch (TREE_CODE (top))
7436     {
7437     case MULT_EXPR:
7438       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7439               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7440
7441     case PLUS_EXPR:
7442     case MINUS_EXPR:
7443       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7444               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7445
7446     case LSHIFT_EXPR:
7447       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
7448         {
7449           tree op1, t1;
7450
7451           op1 = TREE_OPERAND (top, 1);
7452           /* const_binop may not detect overflow correctly,
7453              so check for it explicitly here.  */
7454           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
7455               > TREE_INT_CST_LOW (op1)
7456               && TREE_INT_CST_HIGH (op1) == 0
7457               && 0 != (t1 = convert (type,
7458                                      const_binop (LSHIFT_EXPR, size_one_node,
7459                                                   op1, 0)))
7460               && ! TREE_OVERFLOW (t1))
7461             return multiple_of_p (type, t1, bottom);
7462         }
7463       return 0;
7464
7465     case NOP_EXPR:
7466       /* Can't handle conversions from non-integral or wider integral type.  */
7467       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7468           || (TYPE_PRECISION (type)
7469               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7470         return 0;
7471
7472       /* .. fall through ...  */
7473
7474     case SAVE_EXPR:
7475       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7476
7477     case INTEGER_CST:
7478       if (TREE_CODE (bottom) != INTEGER_CST
7479           || (TREE_UNSIGNED (type)
7480               && (tree_int_cst_sgn (top) < 0
7481                   || tree_int_cst_sgn (bottom) < 0)))
7482         return 0;
7483       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7484                                          top, bottom, 0));
7485
7486     default:
7487       return 0;
7488     }
7489 }
7490
7491 /* Return true if `t' is known to be non-negative.  */
7492
7493 int
7494 tree_expr_nonnegative_p (t)
7495      tree t;
7496 {
7497   switch (TREE_CODE (t))
7498     {
7499     case ABS_EXPR:
7500     case FFS_EXPR:
7501       return 1;
7502     case INTEGER_CST:
7503       return tree_int_cst_sgn (t) >= 0;
7504     case TRUNC_DIV_EXPR:
7505     case CEIL_DIV_EXPR:
7506     case FLOOR_DIV_EXPR:
7507     case ROUND_DIV_EXPR:
7508       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7509         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7510     case TRUNC_MOD_EXPR:
7511     case CEIL_MOD_EXPR:
7512     case FLOOR_MOD_EXPR:
7513     case ROUND_MOD_EXPR:
7514       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7515     case COND_EXPR:
7516       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
7517         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
7518     case COMPOUND_EXPR:
7519       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7520     case MIN_EXPR:
7521       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7522         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7523     case MAX_EXPR:
7524       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7525         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7526     case MODIFY_EXPR:
7527       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7528     case BIND_EXPR:
7529       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7530     case SAVE_EXPR:
7531       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7532     case NON_LVALUE_EXPR:
7533       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7534     case RTL_EXPR:
7535       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
7536
7537     default:
7538       if (truth_value_p (TREE_CODE (t)))
7539         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
7540         return 1;
7541       else
7542         /* We don't know sign of `t', so be conservative and return false.  */
7543         return 0;
7544     }
7545 }
7546
7547 /* Return true if `r' is known to be non-negative.
7548    Only handles constants at the moment.  */
7549
7550 int
7551 rtl_expr_nonnegative_p (r)
7552      rtx r;
7553 {
7554   switch (GET_CODE (r))
7555     {
7556     case CONST_INT:
7557       return INTVAL (r) >= 0;
7558
7559     case CONST_DOUBLE:
7560       if (GET_MODE (r) == VOIDmode)
7561         return CONST_DOUBLE_HIGH (r) >= 0;
7562       return 0;
7563
7564     case SYMBOL_REF:
7565     case LABEL_REF:
7566       /* These are always nonnegative.  */
7567       return 1;
7568
7569     default:
7570       return 0;
7571     }
7572 }