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