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