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
4434   if (cond_first_p)
4435     {
4436       true_rhs = false_rhs = &arg;
4437       true_lhs = &true_value;
4438       false_lhs = &false_value;
4439     }
4440   else
4441     {
4442       true_lhs = false_lhs = &arg;
4443       true_rhs = &true_value;
4444       false_rhs = &false_value;
4445     }
4446
4447   if (TREE_CODE (cond) == COND_EXPR)
4448     {
4449       test = TREE_OPERAND (cond, 0);
4450       true_value = TREE_OPERAND (cond, 1);
4451       false_value = TREE_OPERAND (cond, 2);
4452       /* If this operand throws an expression, then it does not make
4453          sense to try to perform a logical or arithmetic operation
4454          involving it.  Instead of building `a + throw 3' for example,
4455          we simply build `a, throw 3'.  */
4456       if (VOID_TYPE_P (TREE_TYPE (true_value)))
4457         {
4458           lhs_code = COMPOUND_EXPR;
4459           if (!cond_first_p)
4460             lhs_type = void_type_node;
4461         }
4462       if (VOID_TYPE_P (TREE_TYPE (false_value)))
4463         {
4464           rhs_code = COMPOUND_EXPR;
4465           if (!cond_first_p)
4466             rhs_type = void_type_node;
4467         }
4468     }
4469   else
4470     {
4471       tree testtype = TREE_TYPE (cond);
4472       test = cond;
4473       true_value = convert (testtype, integer_one_node);
4474       false_value = convert (testtype, integer_zero_node);
4475     }
4476
4477   /* If ARG is complex we want to make sure we only evaluate
4478      it once.  Though this is only required if it is volatile, it
4479      might be more efficient even if it is not.  However, if we
4480      succeed in folding one part to a constant, we do not need
4481      to make this SAVE_EXPR.  Since we do this optimization
4482      primarily to see if we do end up with constant and this
4483      SAVE_EXPR interferes with later optimizations, suppressing
4484      it when we can is important.
4485
4486      If we are not in a function, we can't make a SAVE_EXPR, so don't
4487      try to do so.  Don't try to see if the result is a constant
4488      if an arm is a COND_EXPR since we get exponential behavior
4489      in that case.  */
4490
4491   if (TREE_CODE (arg) != SAVE_EXPR && ! TREE_CONSTANT (arg)
4492       && (*lang_hooks.decls.global_bindings_p) () == 0
4493       && ((TREE_CODE (arg) != VAR_DECL
4494            && TREE_CODE (arg) != PARM_DECL)
4495           || TREE_SIDE_EFFECTS (arg)))
4496     {
4497       if (TREE_CODE (true_value) != COND_EXPR)
4498         lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4499
4500       if (TREE_CODE (false_value) != COND_EXPR)
4501         rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4502
4503       if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4504           && (rhs == 0 || !TREE_CONSTANT (rhs)))
4505         arg = save_expr (arg), lhs = rhs = 0;
4506     }
4507
4508   if (lhs == 0)
4509     lhs = fold (build (lhs_code, lhs_type, *true_lhs, *true_rhs));
4510   if (rhs == 0)
4511     rhs = fold (build (rhs_code, rhs_type, *false_lhs, *false_rhs));
4512
4513   test = fold (build (COND_EXPR, type, test, lhs, rhs));
4514
4515   if (TREE_CODE (arg) == SAVE_EXPR)
4516     return build (COMPOUND_EXPR, type,
4517                   convert (void_type_node, arg),
4518                   strip_compound_expr (test, arg));
4519   else
4520     return convert (type, test);
4521 }
4522
4523 \f
4524 /* Subroutine of fold() that checks for the addition of +/- 0.0.
4525
4526    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
4527    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
4528    ADDEND is the same as X.
4529
4530    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
4531    and finite.  The problematic cases are when X is zero, and its mode
4532    has signed zeros.  In the case of rounding towards -infinity,
4533    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
4534    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
4535
4536 static bool
4537 fold_real_zero_addition_p (type, addend, negate)
4538      tree type, addend;
4539      int negate;
4540 {
4541   if (!real_zerop (addend))
4542     return false;
4543
4544   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
4545   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
4546     return true;
4547
4548   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
4549   if (TREE_CODE (addend) == REAL_CST
4550       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
4551     negate = !negate;
4552
4553   /* The mode has signed zeros, and we have to honor their sign.
4554      In this situation, there is only one case we can return true for.
4555      X - 0 is the same as X unless rounding towards -infinity is
4556      supported.  */
4557   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
4558 }
4559
4560
4561 /* Perform constant folding and related simplification of EXPR.
4562    The related simplifications include x*1 => x, x*0 => 0, etc.,
4563    and application of the associative law.
4564    NOP_EXPR conversions may be removed freely (as long as we
4565    are careful not to change the C type of the overall expression)
4566    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4567    but we can constant-fold them if they have constant operands.  */
4568
4569 tree
4570 fold (expr)
4571      tree expr;
4572 {
4573   tree t = expr;
4574   tree t1 = NULL_TREE;
4575   tree tem;
4576   tree type = TREE_TYPE (expr);
4577   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4578   enum tree_code code = TREE_CODE (t);
4579   int kind = TREE_CODE_CLASS (code);
4580   int invert;
4581   /* WINS will be nonzero when the switch is done
4582      if all operands are constant.  */
4583   int wins = 1;
4584
4585   /* Don't try to process an RTL_EXPR since its operands aren't trees.
4586      Likewise for a SAVE_EXPR that's already been evaluated.  */
4587   if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t) != 0))
4588     return t;
4589
4590   /* Return right away if a constant.  */
4591   if (kind == 'c')
4592     return t;
4593
4594 #ifdef MAX_INTEGER_COMPUTATION_MODE
4595   check_max_integer_computation_mode (expr);
4596 #endif
4597
4598   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4599     {
4600       tree subop;
4601
4602       /* Special case for conversion ops that can have fixed point args.  */
4603       arg0 = TREE_OPERAND (t, 0);
4604
4605       /* Don't use STRIP_NOPS, because signedness of argument type matters.  */
4606       if (arg0 != 0)
4607         STRIP_SIGN_NOPS (arg0);
4608
4609       if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4610         subop = TREE_REALPART (arg0);
4611       else
4612         subop = arg0;
4613
4614       if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4615           && TREE_CODE (subop) != REAL_CST
4616           )
4617         /* Note that TREE_CONSTANT isn't enough:
4618            static var addresses are constant but we can't
4619            do arithmetic on them.  */
4620         wins = 0;
4621     }
4622   else if (IS_EXPR_CODE_CLASS (kind) || kind == 'r')
4623     {
4624       int len = first_rtl_op (code);
4625       int i;
4626       for (i = 0; i < len; i++)
4627         {
4628           tree op = TREE_OPERAND (t, i);
4629           tree subop;
4630
4631           if (op == 0)
4632             continue;           /* Valid for CALL_EXPR, at least.  */
4633
4634           if (kind == '<' || code == RSHIFT_EXPR)
4635             {
4636               /* Signedness matters here.  Perhaps we can refine this
4637                  later.  */
4638               STRIP_SIGN_NOPS (op);
4639             }
4640           else
4641             /* Strip any conversions that don't change the mode.  */
4642             STRIP_NOPS (op);
4643
4644           if (TREE_CODE (op) == COMPLEX_CST)
4645             subop = TREE_REALPART (op);
4646           else
4647             subop = op;
4648
4649           if (TREE_CODE (subop) != INTEGER_CST
4650               && TREE_CODE (subop) != REAL_CST)
4651             /* Note that TREE_CONSTANT isn't enough:
4652                static var addresses are constant but we can't
4653                do arithmetic on them.  */
4654             wins = 0;
4655
4656           if (i == 0)
4657             arg0 = op;
4658           else if (i == 1)
4659             arg1 = op;
4660         }
4661     }
4662
4663   /* If this is a commutative operation, and ARG0 is a constant, move it
4664      to ARG1 to reduce the number of tests below.  */
4665   if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4666        || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4667        || code == BIT_AND_EXPR)
4668       && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4669     {
4670       tem = arg0; arg0 = arg1; arg1 = tem;
4671
4672       tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4673       TREE_OPERAND (t, 1) = tem;
4674     }
4675
4676   /* Now WINS is set as described above,
4677      ARG0 is the first operand of EXPR,
4678      and ARG1 is the second operand (if it has more than one operand).
4679
4680      First check for cases where an arithmetic operation is applied to a
4681      compound, conditional, or comparison operation.  Push the arithmetic
4682      operation inside the compound or conditional to see if any folding
4683      can then be done.  Convert comparison to conditional for this purpose.
4684      The also optimizes non-constant cases that used to be done in
4685      expand_expr.
4686
4687      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
4688      one of the operands is a comparison and the other is a comparison, a
4689      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
4690      code below would make the expression more complex.  Change it to a
4691      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
4692      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
4693
4694   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4695        || code == EQ_EXPR || code == NE_EXPR)
4696       && ((truth_value_p (TREE_CODE (arg0))
4697            && (truth_value_p (TREE_CODE (arg1))
4698                || (TREE_CODE (arg1) == BIT_AND_EXPR
4699                    && integer_onep (TREE_OPERAND (arg1, 1)))))
4700           || (truth_value_p (TREE_CODE (arg1))
4701               && (truth_value_p (TREE_CODE (arg0))
4702                   || (TREE_CODE (arg0) == BIT_AND_EXPR
4703                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
4704     {
4705       t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4706                        : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4707                        : TRUTH_XOR_EXPR,
4708                        type, arg0, arg1));
4709
4710       if (code == EQ_EXPR)
4711         t = invert_truthvalue (t);
4712
4713       return t;
4714     }
4715
4716   if (TREE_CODE_CLASS (code) == '1')
4717     {
4718       if (TREE_CODE (arg0) == COMPOUND_EXPR)
4719         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4720                       fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4721       else if (TREE_CODE (arg0) == COND_EXPR)
4722         {
4723           t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4724                            fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
4725                            fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
4726
4727           /* If this was a conversion, and all we did was to move into
4728              inside the COND_EXPR, bring it back out.  But leave it if
4729              it is a conversion from integer to integer and the
4730              result precision is no wider than a word since such a
4731              conversion is cheap and may be optimized away by combine,
4732              while it couldn't if it were outside the COND_EXPR.  Then return
4733              so we don't get into an infinite recursion loop taking the
4734              conversion out and then back in.  */
4735
4736           if ((code == NOP_EXPR || code == CONVERT_EXPR
4737                || code == NON_LVALUE_EXPR)
4738               && TREE_CODE (t) == COND_EXPR
4739               && TREE_CODE (TREE_OPERAND (t, 1)) == code
4740               && TREE_CODE (TREE_OPERAND (t, 2)) == code
4741               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4742                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4743               && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4744                     && (INTEGRAL_TYPE_P
4745                         (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))))
4746                     && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4747             t = build1 (code, type,
4748                         build (COND_EXPR,
4749                                TREE_TYPE (TREE_OPERAND
4750                                           (TREE_OPERAND (t, 1), 0)),
4751                                TREE_OPERAND (t, 0),
4752                                TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4753                                TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4754           return t;
4755         }
4756       else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4757         return fold (build (COND_EXPR, type, arg0,
4758                             fold (build1 (code, type, integer_one_node)),
4759                             fold (build1 (code, type, integer_zero_node))));
4760    }
4761   else if (TREE_CODE_CLASS (code) == '2'
4762            || TREE_CODE_CLASS (code) == '<')
4763     {
4764       if (TREE_CODE (arg1) == COMPOUND_EXPR)
4765         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4766                       fold (build (code, type,
4767                                    arg0, TREE_OPERAND (arg1, 1))));
4768       else if ((TREE_CODE (arg1) == COND_EXPR
4769                 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4770                     && TREE_CODE_CLASS (code) != '<'))
4771                && (TREE_CODE (arg0) != COND_EXPR
4772                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4773                && (! TREE_SIDE_EFFECTS (arg0)
4774                    || ((*lang_hooks.decls.global_bindings_p) () == 0
4775                        && ! contains_placeholder_p (arg0))))
4776         return
4777           fold_binary_op_with_conditional_arg (code, type, arg1, arg0,
4778                                                /*cond_first_p=*/0);
4779       else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4780         return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4781                       fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4782       else if ((TREE_CODE (arg0) == COND_EXPR
4783                 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4784                     && TREE_CODE_CLASS (code) != '<'))
4785                && (TREE_CODE (arg1) != COND_EXPR
4786                    || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4787                && (! TREE_SIDE_EFFECTS (arg1)
4788                    || ((*lang_hooks.decls.global_bindings_p) () == 0
4789                        && ! contains_placeholder_p (arg1))))
4790         return
4791           fold_binary_op_with_conditional_arg (code, type, arg0, arg1,
4792                                                /*cond_first_p=*/1);
4793     }
4794   else if (TREE_CODE_CLASS (code) == '<'
4795            && TREE_CODE (arg0) == COMPOUND_EXPR)
4796     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4797                   fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4798   else if (TREE_CODE_CLASS (code) == '<'
4799            && TREE_CODE (arg1) == COMPOUND_EXPR)
4800     return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4801                   fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4802
4803   switch (code)
4804     {
4805     case INTEGER_CST:
4806     case REAL_CST:
4807     case VECTOR_CST:
4808     case STRING_CST:
4809     case COMPLEX_CST:
4810     case CONSTRUCTOR:
4811       return t;
4812
4813     case CONST_DECL:
4814       return fold (DECL_INITIAL (t));
4815
4816     case NOP_EXPR:
4817     case FLOAT_EXPR:
4818     case CONVERT_EXPR:
4819     case FIX_TRUNC_EXPR:
4820       /* Other kinds of FIX are not handled properly by fold_convert.  */
4821
4822       if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4823         return TREE_OPERAND (t, 0);
4824
4825       /* Handle cases of two conversions in a row.  */
4826       if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4827           || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4828         {
4829           tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4830           tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4831           tree final_type = TREE_TYPE (t);
4832           int inside_int = INTEGRAL_TYPE_P (inside_type);
4833           int inside_ptr = POINTER_TYPE_P (inside_type);
4834           int inside_float = FLOAT_TYPE_P (inside_type);
4835           unsigned int inside_prec = TYPE_PRECISION (inside_type);
4836           int inside_unsignedp = TREE_UNSIGNED (inside_type);
4837           int inter_int = INTEGRAL_TYPE_P (inter_type);
4838           int inter_ptr = POINTER_TYPE_P (inter_type);
4839           int inter_float = FLOAT_TYPE_P (inter_type);
4840           unsigned int inter_prec = TYPE_PRECISION (inter_type);
4841           int inter_unsignedp = TREE_UNSIGNED (inter_type);
4842           int final_int = INTEGRAL_TYPE_P (final_type);
4843           int final_ptr = POINTER_TYPE_P (final_type);
4844           int final_float = FLOAT_TYPE_P (final_type);
4845           unsigned int final_prec = TYPE_PRECISION (final_type);
4846           int final_unsignedp = TREE_UNSIGNED (final_type);
4847
4848           /* In addition to the cases of two conversions in a row
4849              handled below, if we are converting something to its own
4850              type via an object of identical or wider precision, neither
4851              conversion is needed.  */
4852           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (final_type)
4853               && ((inter_int && final_int) || (inter_float && final_float))
4854               && inter_prec >= final_prec)
4855             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4856
4857           /* Likewise, if the intermediate and final types are either both
4858              float or both integer, we don't need the middle conversion if
4859              it is wider than the final type and doesn't change the signedness
4860              (for integers).  Avoid this if the final type is a pointer
4861              since then we sometimes need the inner conversion.  Likewise if
4862              the outer has a precision not equal to the size of its mode.  */
4863           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4864                || (inter_float && inside_float))
4865               && inter_prec >= inside_prec
4866               && (inter_float || inter_unsignedp == inside_unsignedp)
4867               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4868                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4869               && ! final_ptr)
4870             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4871
4872           /* If we have a sign-extension of a zero-extended value, we can
4873              replace that by a single zero-extension.  */
4874           if (inside_int && inter_int && final_int
4875               && inside_prec < inter_prec && inter_prec < final_prec
4876               && inside_unsignedp && !inter_unsignedp)
4877             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4878
4879           /* Two conversions in a row are not needed unless:
4880              - some conversion is floating-point (overstrict for now), or
4881              - the intermediate type is narrower than both initial and
4882                final, or
4883              - the intermediate type and innermost type differ in signedness,
4884                and the outermost type is wider than the intermediate, or
4885              - the initial type is a pointer type and the precisions of the
4886                intermediate and final types differ, or
4887              - the final type is a pointer type and the precisions of the
4888                initial and intermediate types differ.  */
4889           if (! inside_float && ! inter_float && ! final_float
4890               && (inter_prec > inside_prec || inter_prec > final_prec)
4891               && ! (inside_int && inter_int
4892                     && inter_unsignedp != inside_unsignedp
4893                     && inter_prec < final_prec)
4894               && ((inter_unsignedp && inter_prec > inside_prec)
4895                   == (final_unsignedp && final_prec > inter_prec))
4896               && ! (inside_ptr && inter_prec != final_prec)
4897               && ! (final_ptr && inside_prec != inter_prec)
4898               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4899                     && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4900               && ! final_ptr)
4901             return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4902         }
4903
4904       if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
4905           && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
4906           /* Detect assigning a bitfield.  */
4907           && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
4908                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
4909         {
4910           /* Don't leave an assignment inside a conversion
4911              unless assigning a bitfield.  */
4912           tree prev = TREE_OPERAND (t, 0);
4913           TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
4914           /* First do the assignment, then return converted constant.  */
4915           t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
4916           TREE_USED (t) = 1;
4917           return t;
4918         }
4919
4920       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
4921          constants (if x has signed type, the sign bit cannot be set
4922          in c).  This folds extension into the BIT_AND_EXPR.  */
4923       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
4924           && TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE
4925           && TREE_CODE (TREE_OPERAND (t, 0)) == BIT_AND_EXPR
4926           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 1)) == INTEGER_CST)
4927         {
4928           tree and = TREE_OPERAND (t, 0);
4929           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
4930           int change = 0;
4931
4932           if (TREE_UNSIGNED (TREE_TYPE (and))
4933               || (TYPE_PRECISION (TREE_TYPE (t))
4934                   <= TYPE_PRECISION (TREE_TYPE (and))))
4935             change = 1;
4936           else if (TYPE_PRECISION (TREE_TYPE (and1))
4937                    <= HOST_BITS_PER_WIDE_INT
4938                    && host_integerp (and1, 1))
4939             {
4940               unsigned HOST_WIDE_INT cst;
4941
4942               cst = tree_low_cst (and1, 1);
4943               cst &= (HOST_WIDE_INT) -1
4944                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
4945               change = (cst == 0);
4946 #ifdef LOAD_EXTEND_OP
4947               if (change
4948                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
4949                       == ZERO_EXTEND))
4950                 {
4951                   tree uns = (*lang_hooks.types.unsigned_type) (TREE_TYPE (and0));
4952                   and0 = convert (uns, and0);
4953                   and1 = convert (uns, and1);
4954                 }
4955 #endif
4956             }
4957           if (change)
4958             return fold (build (BIT_AND_EXPR, TREE_TYPE (t),
4959                                 convert (TREE_TYPE (t), and0),
4960                                 convert (TREE_TYPE (t), and1)));
4961         }
4962
4963       if (!wins)
4964         {
4965           TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
4966           return t;
4967         }
4968       return fold_convert (t, arg0);
4969
4970     case VIEW_CONVERT_EXPR:
4971       if (TREE_CODE (TREE_OPERAND (t, 0)) == VIEW_CONVERT_EXPR)
4972         return build1 (VIEW_CONVERT_EXPR, type,
4973                        TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4974       return t;
4975
4976     case COMPONENT_REF:
4977       if (TREE_CODE (arg0) == CONSTRUCTOR)
4978         {
4979           tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
4980           if (m)
4981             t = TREE_VALUE (m);
4982         }
4983       return t;
4984
4985     case RANGE_EXPR:
4986       TREE_CONSTANT (t) = wins;
4987       return t;
4988
4989     case NEGATE_EXPR:
4990       if (wins)
4991         {
4992           if (TREE_CODE (arg0) == INTEGER_CST)
4993             {
4994               unsigned HOST_WIDE_INT low;
4995               HOST_WIDE_INT high;
4996               int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4997                                          TREE_INT_CST_HIGH (arg0),
4998                                          &low, &high);
4999               t = build_int_2 (low, high);
5000               TREE_TYPE (t) = type;
5001               TREE_OVERFLOW (t)
5002                 = (TREE_OVERFLOW (arg0)
5003                    | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
5004               TREE_CONSTANT_OVERFLOW (t)
5005                 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5006             }
5007           else if (TREE_CODE (arg0) == REAL_CST)
5008             t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5009         }
5010       else if (TREE_CODE (arg0) == NEGATE_EXPR)
5011         return TREE_OPERAND (arg0, 0);
5012
5013       /* Convert - (a - b) to (b - a) for non-floating-point.  */
5014       else if (TREE_CODE (arg0) == MINUS_EXPR
5015                && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
5016         return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
5017                       TREE_OPERAND (arg0, 0));
5018
5019       return t;
5020
5021     case ABS_EXPR:
5022       if (wins)
5023         {
5024           if (TREE_CODE (arg0) == INTEGER_CST)
5025             {
5026               /* If the value is unsigned, then the absolute value is
5027                  the same as the ordinary value.  */
5028               if (TREE_UNSIGNED (type))
5029                 return arg0;
5030               /* Similarly, if the value is non-negative.  */
5031               else if (INT_CST_LT (integer_minus_one_node, arg0))
5032                 return arg0;
5033               /* If the value is negative, then the absolute value is
5034                  its negation.  */
5035               else
5036                 {
5037                   unsigned HOST_WIDE_INT low;
5038                   HOST_WIDE_INT high;
5039                   int overflow = neg_double (TREE_INT_CST_LOW (arg0),
5040                                              TREE_INT_CST_HIGH (arg0),
5041                                              &low, &high);
5042                   t = build_int_2 (low, high);
5043                   TREE_TYPE (t) = type;
5044                   TREE_OVERFLOW (t)
5045                     = (TREE_OVERFLOW (arg0)
5046                        | force_fit_type (t, overflow));
5047                   TREE_CONSTANT_OVERFLOW (t)
5048                     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
5049                 }
5050             }
5051           else if (TREE_CODE (arg0) == REAL_CST)
5052             {
5053               if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
5054                 t = build_real (type,
5055                                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
5056             }
5057         }
5058       else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
5059         return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
5060       return t;
5061
5062     case CONJ_EXPR:
5063       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
5064         return convert (type, arg0);
5065       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
5066         return build (COMPLEX_EXPR, type,
5067                       TREE_OPERAND (arg0, 0),
5068                       negate_expr (TREE_OPERAND (arg0, 1)));
5069       else if (TREE_CODE (arg0) == COMPLEX_CST)
5070         return build_complex (type, TREE_REALPART (arg0),
5071                               negate_expr (TREE_IMAGPART (arg0)));
5072       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
5073         return fold (build (TREE_CODE (arg0), type,
5074                             fold (build1 (CONJ_EXPR, type,
5075                                           TREE_OPERAND (arg0, 0))),
5076                             fold (build1 (CONJ_EXPR,
5077                                           type, TREE_OPERAND (arg0, 1)))));
5078       else if (TREE_CODE (arg0) == CONJ_EXPR)
5079         return TREE_OPERAND (arg0, 0);
5080       return t;
5081
5082     case BIT_NOT_EXPR:
5083       if (wins)
5084         {
5085           t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
5086                            ~ TREE_INT_CST_HIGH (arg0));
5087           TREE_TYPE (t) = type;
5088           force_fit_type (t, 0);
5089           TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
5090           TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
5091         }
5092       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
5093         return TREE_OPERAND (arg0, 0);
5094       return t;
5095
5096     case PLUS_EXPR:
5097       /* A + (-B) -> A - B */
5098       if (TREE_CODE (arg1) == NEGATE_EXPR)
5099         return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5100       /* (-A) + B -> B - A */
5101       if (TREE_CODE (arg0) == NEGATE_EXPR)
5102         return fold (build (MINUS_EXPR, type, arg1, TREE_OPERAND (arg0, 0)));
5103       else if (! FLOAT_TYPE_P (type))
5104         {
5105           if (integer_zerop (arg1))
5106             return non_lvalue (convert (type, arg0));
5107
5108           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
5109              with a constant, and the two constants have no bits in common,
5110              we should treat this as a BIT_IOR_EXPR since this may produce more
5111              simplifications.  */
5112           if (TREE_CODE (arg0) == BIT_AND_EXPR
5113               && TREE_CODE (arg1) == BIT_AND_EXPR
5114               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5115               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5116               && integer_zerop (const_binop (BIT_AND_EXPR,
5117                                              TREE_OPERAND (arg0, 1),
5118                                              TREE_OPERAND (arg1, 1), 0)))
5119             {
5120               code = BIT_IOR_EXPR;
5121               goto bit_ior;
5122             }
5123
5124           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
5125              (plus (plus (mult) (mult)) (foo)) so that we can
5126              take advantage of the factoring cases below.  */
5127           if ((TREE_CODE (arg0) == PLUS_EXPR
5128                && TREE_CODE (arg1) == MULT_EXPR)
5129               || (TREE_CODE (arg1) == PLUS_EXPR
5130                   && TREE_CODE (arg0) == MULT_EXPR))
5131             {
5132               tree parg0, parg1, parg, marg;
5133
5134               if (TREE_CODE (arg0) == PLUS_EXPR)
5135                 parg = arg0, marg = arg1;
5136               else
5137                 parg = arg1, marg = arg0;
5138               parg0 = TREE_OPERAND (parg, 0);
5139               parg1 = TREE_OPERAND (parg, 1);
5140               STRIP_NOPS (parg0);
5141               STRIP_NOPS (parg1);
5142
5143               if (TREE_CODE (parg0) == MULT_EXPR
5144                   && TREE_CODE (parg1) != MULT_EXPR)
5145                 return fold (build (PLUS_EXPR, type,
5146                                     fold (build (PLUS_EXPR, type, parg0, marg)),
5147                                     parg1));
5148               if (TREE_CODE (parg0) != MULT_EXPR
5149                   && TREE_CODE (parg1) == MULT_EXPR)
5150                 return fold (build (PLUS_EXPR, type,
5151                                     fold (build (PLUS_EXPR, type, parg1, marg)),
5152                                     parg0));
5153             }
5154
5155           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
5156             {
5157               tree arg00, arg01, arg10, arg11;
5158               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
5159
5160               /* (A * C) + (B * C) -> (A+B) * C.
5161                  We are most concerned about the case where C is a constant,
5162                  but other combinations show up during loop reduction.  Since
5163                  it is not difficult, try all four possibilities.  */
5164
5165               arg00 = TREE_OPERAND (arg0, 0);
5166               arg01 = TREE_OPERAND (arg0, 1);
5167               arg10 = TREE_OPERAND (arg1, 0);
5168               arg11 = TREE_OPERAND (arg1, 1);
5169               same = NULL_TREE;
5170
5171               if (operand_equal_p (arg01, arg11, 0))
5172                 same = arg01, alt0 = arg00, alt1 = arg10;
5173               else if (operand_equal_p (arg00, arg10, 0))
5174                 same = arg00, alt0 = arg01, alt1 = arg11;
5175               else if (operand_equal_p (arg00, arg11, 0))
5176                 same = arg00, alt0 = arg01, alt1 = arg10;
5177               else if (operand_equal_p (arg01, arg10, 0))
5178                 same = arg01, alt0 = arg00, alt1 = arg11;
5179
5180               /* No identical multiplicands; see if we can find a common
5181                  power-of-two factor in non-power-of-two multiplies.  This
5182                  can help in multi-dimensional array access.  */
5183               else if (TREE_CODE (arg01) == INTEGER_CST
5184                        && TREE_CODE (arg11) == INTEGER_CST
5185                        && TREE_INT_CST_HIGH (arg01) == 0
5186                        && TREE_INT_CST_HIGH (arg11) == 0)
5187                 {
5188                   HOST_WIDE_INT int01, int11, tmp;
5189                   int01 = TREE_INT_CST_LOW (arg01);
5190                   int11 = TREE_INT_CST_LOW (arg11);
5191
5192                   /* Move min of absolute values to int11.  */
5193                   if ((int01 >= 0 ? int01 : -int01)
5194                       < (int11 >= 0 ? int11 : -int11))
5195                     {
5196                       tmp = int01, int01 = int11, int11 = tmp;
5197                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
5198                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
5199                     }
5200
5201                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
5202                     {
5203                       alt0 = fold (build (MULT_EXPR, type, arg00,
5204                                           build_int_2 (int01 / int11, 0)));
5205                       alt1 = arg10;
5206                       same = arg11;
5207                     }
5208                 }
5209
5210               if (same)
5211                 return fold (build (MULT_EXPR, type,
5212                                     fold (build (PLUS_EXPR, type, alt0, alt1)),
5213                                     same));
5214             }
5215         }
5216
5217       /* See if ARG1 is zero and X + ARG1 reduces to X.  */
5218       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
5219         return non_lvalue (convert (type, arg0));
5220
5221       /* Likewise if the operands are reversed.  */
5222       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5223         return non_lvalue (convert (type, arg1));
5224
5225      bit_rotate:
5226       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5227          is a rotate of A by C1 bits.  */
5228       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5229          is a rotate of A by B bits.  */
5230       {
5231         enum tree_code code0, code1;
5232         code0 = TREE_CODE (arg0);
5233         code1 = TREE_CODE (arg1);
5234         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5235              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5236             && operand_equal_p (TREE_OPERAND (arg0, 0),
5237                                 TREE_OPERAND (arg1, 0), 0)
5238             && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5239           {
5240             tree tree01, tree11;
5241             enum tree_code code01, code11;
5242
5243             tree01 = TREE_OPERAND (arg0, 1);
5244             tree11 = TREE_OPERAND (arg1, 1);
5245             STRIP_NOPS (tree01);
5246             STRIP_NOPS (tree11);
5247             code01 = TREE_CODE (tree01);
5248             code11 = TREE_CODE (tree11);
5249             if (code01 == INTEGER_CST
5250                 && code11 == INTEGER_CST
5251                 && TREE_INT_CST_HIGH (tree01) == 0
5252                 && TREE_INT_CST_HIGH (tree11) == 0
5253                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5254                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5255               return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5256                             code0 == LSHIFT_EXPR ? tree01 : tree11);
5257             else if (code11 == MINUS_EXPR)
5258               {
5259                 tree tree110, tree111;
5260                 tree110 = TREE_OPERAND (tree11, 0);
5261                 tree111 = TREE_OPERAND (tree11, 1);
5262                 STRIP_NOPS (tree110);
5263                 STRIP_NOPS (tree111);
5264                 if (TREE_CODE (tree110) == INTEGER_CST
5265                     && 0 == compare_tree_int (tree110,
5266                                               TYPE_PRECISION
5267                                               (TREE_TYPE (TREE_OPERAND
5268                                                           (arg0, 0))))
5269                     && operand_equal_p (tree01, tree111, 0))
5270                   return build ((code0 == LSHIFT_EXPR
5271                                  ? LROTATE_EXPR
5272                                  : RROTATE_EXPR),
5273                                 type, TREE_OPERAND (arg0, 0), tree01);
5274               }
5275             else if (code01 == MINUS_EXPR)
5276               {
5277                 tree tree010, tree011;
5278                 tree010 = TREE_OPERAND (tree01, 0);
5279                 tree011 = TREE_OPERAND (tree01, 1);
5280                 STRIP_NOPS (tree010);
5281                 STRIP_NOPS (tree011);
5282                 if (TREE_CODE (tree010) == INTEGER_CST
5283                     && 0 == compare_tree_int (tree010,
5284                                               TYPE_PRECISION
5285                                               (TREE_TYPE (TREE_OPERAND
5286                                                           (arg0, 0))))
5287                     && operand_equal_p (tree11, tree011, 0))
5288                   return build ((code0 != LSHIFT_EXPR
5289                                  ? LROTATE_EXPR
5290                                  : RROTATE_EXPR),
5291                                 type, TREE_OPERAND (arg0, 0), tree11);
5292               }
5293           }
5294       }
5295
5296     associate:
5297       /* In most languages, can't associate operations on floats through
5298          parentheses.  Rather than remember where the parentheses were, we
5299          don't associate floats at all.  It shouldn't matter much.  However,
5300          associating multiplications is only very slightly inaccurate, so do
5301          that if -funsafe-math-optimizations is specified.  */
5302
5303       if (! wins
5304           && (! FLOAT_TYPE_P (type)
5305               || (flag_unsafe_math_optimizations && code == MULT_EXPR)))
5306         {
5307           tree var0, con0, lit0, minus_lit0;
5308           tree var1, con1, lit1, minus_lit1;
5309
5310           /* Split both trees into variables, constants, and literals.  Then
5311              associate each group together, the constants with literals,
5312              then the result with variables.  This increases the chances of
5313              literals being recombined later and of generating relocatable
5314              expressions for the sum of a constant and literal.  */
5315           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
5316           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
5317                              code == MINUS_EXPR);
5318
5319           /* Only do something if we found more than two objects.  Otherwise,
5320              nothing has changed and we risk infinite recursion.  */
5321           if (2 < ((var0 != 0) + (var1 != 0)
5322                    + (con0 != 0) + (con1 != 0)
5323                    + (lit0 != 0) + (lit1 != 0)
5324                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
5325             {
5326               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
5327               if (code == MINUS_EXPR)
5328                 code = PLUS_EXPR;
5329
5330               var0 = associate_trees (var0, var1, code, type);
5331               con0 = associate_trees (con0, con1, code, type);
5332               lit0 = associate_trees (lit0, lit1, code, type);
5333               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
5334
5335               /* Preserve the MINUS_EXPR if the negative part of the literal is
5336                  greater than the positive part.  Otherwise, the multiplicative
5337                  folding code (i.e extract_muldiv) may be fooled in case
5338                  unsigned constants are substracted, like in the following
5339                  example: ((X*2 + 4) - 8U)/2.  */
5340               if (minus_lit0 && lit0)
5341                 {
5342                   if (tree_int_cst_lt (lit0, minus_lit0))
5343                     {
5344                       minus_lit0 = associate_trees (minus_lit0, lit0,
5345                                                     MINUS_EXPR, type);
5346                       lit0 = 0;
5347                     }
5348                   else
5349                     {
5350                       lit0 = associate_trees (lit0, minus_lit0,
5351                                               MINUS_EXPR, type);
5352                       minus_lit0 = 0;
5353                     }
5354                 }
5355               if (minus_lit0)
5356                 {
5357                   if (con0 == 0)
5358                     return convert (type, associate_trees (var0, minus_lit0,
5359                                                            MINUS_EXPR, type));
5360                   else
5361                     {
5362                       con0 = associate_trees (con0, minus_lit0,
5363                                               MINUS_EXPR, type);
5364                       return convert (type, associate_trees (var0, con0,
5365                                                              PLUS_EXPR, type));
5366                     }
5367                 }
5368
5369               con0 = associate_trees (con0, lit0, code, type);
5370               return convert (type, associate_trees (var0, con0, code, type));
5371             }
5372         }
5373
5374     binary:
5375       if (wins)
5376         t1 = const_binop (code, arg0, arg1, 0);
5377       if (t1 != NULL_TREE)
5378         {
5379           /* The return value should always have
5380              the same type as the original expression.  */
5381           if (TREE_TYPE (t1) != TREE_TYPE (t))
5382             t1 = convert (TREE_TYPE (t), t1);
5383
5384           return t1;
5385         }
5386       return t;
5387
5388     case MINUS_EXPR:
5389       /* A - (-B) -> A + B */
5390       if (TREE_CODE (arg1) == NEGATE_EXPR)
5391         return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
5392       /* (-A) - CST -> (-CST) - A   for floating point (what about ints ?)  */
5393       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5394         return
5395           fold (build (MINUS_EXPR, type,
5396                        build_real (TREE_TYPE (arg1),
5397                                    REAL_VALUE_NEGATE (TREE_REAL_CST (arg1))),
5398                        TREE_OPERAND (arg0, 0)));
5399
5400       if (! FLOAT_TYPE_P (type))
5401         {
5402           if (! wins && integer_zerop (arg0))
5403             return negate_expr (convert (type, arg1));
5404           if (integer_zerop (arg1))
5405             return non_lvalue (convert (type, arg0));
5406
5407           /* (A * C) - (B * C) -> (A-B) * C.  Since we are most concerned
5408              about the case where C is a constant, just try one of the
5409              four possibilities.  */
5410
5411           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
5412               && operand_equal_p (TREE_OPERAND (arg0, 1),
5413                                   TREE_OPERAND (arg1, 1), 0))
5414             return fold (build (MULT_EXPR, type,
5415                                 fold (build (MINUS_EXPR, type,
5416                                              TREE_OPERAND (arg0, 0),
5417                                              TREE_OPERAND (arg1, 0))),
5418                                 TREE_OPERAND (arg0, 1)));
5419         }
5420
5421       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
5422       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
5423         return non_lvalue (convert (type, arg0));
5424
5425       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
5426          ARG0 is zero and X + ARG0 reduces to X, since that would mean
5427          (-ARG1 + ARG0) reduces to -ARG1.  */
5428       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
5429         return negate_expr (convert (type, arg1));
5430
5431       /* Fold &x - &x.  This can happen from &x.foo - &x.
5432          This is unsafe for certain floats even in non-IEEE formats.
5433          In IEEE, it is unsafe because it does wrong for NaNs.
5434          Also note that operand_equal_p is always false if an operand
5435          is volatile.  */
5436
5437       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
5438           && operand_equal_p (arg0, arg1, 0))
5439         return convert (type, integer_zero_node);
5440
5441       goto associate;
5442
5443     case MULT_EXPR:
5444       /* (-A) * (-B) -> A * B  */
5445       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5446         return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
5447                             TREE_OPERAND (arg1, 0)));
5448
5449       if (! FLOAT_TYPE_P (type))
5450         {
5451           if (integer_zerop (arg1))
5452             return omit_one_operand (type, arg1, arg0);
5453           if (integer_onep (arg1))
5454             return non_lvalue (convert (type, arg0));
5455
5456           /* (a * (1 << b)) is (a << b)  */
5457           if (TREE_CODE (arg1) == LSHIFT_EXPR
5458               && integer_onep (TREE_OPERAND (arg1, 0)))
5459             return fold (build (LSHIFT_EXPR, type, arg0,
5460                                 TREE_OPERAND (arg1, 1)));
5461           if (TREE_CODE (arg0) == LSHIFT_EXPR
5462               && integer_onep (TREE_OPERAND (arg0, 0)))
5463             return fold (build (LSHIFT_EXPR, type, arg1,
5464                                 TREE_OPERAND (arg0, 1)));
5465
5466           if (TREE_CODE (arg1) == INTEGER_CST
5467               && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5468                                              code, NULL_TREE)))
5469             return convert (type, tem);
5470
5471         }
5472       else
5473         {
5474           /* Maybe fold x * 0 to 0.  The expressions aren't the same
5475              when x is NaN, since x * 0 is also NaN.  Nor are they the
5476              same in modes with signed zeros, since multiplying a
5477              negative value by 0 gives -0, not +0.  */
5478           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
5479               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
5480               && real_zerop (arg1))
5481             return omit_one_operand (type, arg1, arg0);
5482           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
5483           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5484               && real_onep (arg1))
5485             return non_lvalue (convert (type, arg0));
5486
5487           /* Transform x * -1.0 into -x.  */
5488           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5489               && real_minus_onep (arg1))
5490             return fold (build1 (NEGATE_EXPR, type, arg0));
5491
5492           /* x*2 is x+x */
5493           if (! wins && real_twop (arg1)
5494               && (*lang_hooks.decls.global_bindings_p) () == 0
5495               && ! contains_placeholder_p (arg0))
5496             {
5497               tree arg = save_expr (arg0);
5498               return build (PLUS_EXPR, type, arg, arg);
5499             }
5500         }
5501       goto associate;
5502
5503     case BIT_IOR_EXPR:
5504     bit_ior:
5505       if (integer_all_onesp (arg1))
5506         return omit_one_operand (type, arg1, arg0);
5507       if (integer_zerop (arg1))
5508         return non_lvalue (convert (type, arg0));
5509       t1 = distribute_bit_expr (code, type, arg0, arg1);
5510       if (t1 != NULL_TREE)
5511         return t1;
5512
5513       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5514
5515          This results in more efficient code for machines without a NAND
5516          instruction.  Combine will canonicalize to the first form
5517          which will allow use of NAND instructions provided by the
5518          backend if they exist.  */
5519       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5520           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5521         {
5522           return fold (build1 (BIT_NOT_EXPR, type,
5523                                build (BIT_AND_EXPR, type,
5524                                       TREE_OPERAND (arg0, 0),
5525                                       TREE_OPERAND (arg1, 0))));
5526         }
5527
5528       /* See if this can be simplified into a rotate first.  If that
5529          is unsuccessful continue in the association code.  */
5530       goto bit_rotate;
5531
5532     case BIT_XOR_EXPR:
5533       if (integer_zerop (arg1))
5534         return non_lvalue (convert (type, arg0));
5535       if (integer_all_onesp (arg1))
5536         return fold (build1 (BIT_NOT_EXPR, type, arg0));
5537
5538       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5539          with a constant, and the two constants have no bits in common,
5540          we should treat this as a BIT_IOR_EXPR since this may produce more
5541          simplifications.  */
5542       if (TREE_CODE (arg0) == BIT_AND_EXPR
5543           && TREE_CODE (arg1) == BIT_AND_EXPR
5544           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5545           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
5546           && integer_zerop (const_binop (BIT_AND_EXPR,
5547                                          TREE_OPERAND (arg0, 1),
5548                                          TREE_OPERAND (arg1, 1), 0)))
5549         {
5550           code = BIT_IOR_EXPR;
5551           goto bit_ior;
5552         }
5553
5554       /* See if this can be simplified into a rotate first.  If that
5555          is unsuccessful continue in the association code.  */
5556       goto bit_rotate;
5557
5558     case BIT_AND_EXPR:
5559     bit_and:
5560       if (integer_all_onesp (arg1))
5561         return non_lvalue (convert (type, arg0));
5562       if (integer_zerop (arg1))
5563         return omit_one_operand (type, arg1, arg0);
5564       t1 = distribute_bit_expr (code, type, arg0, arg1);
5565       if (t1 != NULL_TREE)
5566         return t1;
5567       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
5568       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5569           && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5570         {
5571           unsigned int prec
5572             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5573
5574           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5575               && (~TREE_INT_CST_LOW (arg1)
5576                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5577             return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5578         }
5579
5580       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5581
5582          This results in more efficient code for machines without a NOR
5583          instruction.  Combine will canonicalize to the first form
5584          which will allow use of NOR instructions provided by the
5585          backend if they exist.  */
5586       if (TREE_CODE (arg0) == BIT_NOT_EXPR
5587           && TREE_CODE (arg1) == BIT_NOT_EXPR)
5588         {
5589           return fold (build1 (BIT_NOT_EXPR, type,
5590                                build (BIT_IOR_EXPR, type,
5591                                       TREE_OPERAND (arg0, 0),
5592                                       TREE_OPERAND (arg1, 0))));
5593         }
5594
5595       goto associate;
5596
5597     case BIT_ANDTC_EXPR:
5598       if (integer_all_onesp (arg0))
5599         return non_lvalue (convert (type, arg1));
5600       if (integer_zerop (arg0))
5601         return omit_one_operand (type, arg0, arg1);
5602       if (TREE_CODE (arg1) == INTEGER_CST)
5603         {
5604           arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5605           code = BIT_AND_EXPR;
5606           goto bit_and;
5607         }
5608       goto binary;
5609
5610     case RDIV_EXPR:
5611       /* Don't touch a floating-point divide by zero unless the mode
5612          of the constant can represent infinity.  */
5613       if (TREE_CODE (arg1) == REAL_CST
5614           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
5615           && real_zerop (arg1))
5616         return t;
5617
5618       /* (-A) / (-B) -> A / B  */
5619       if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
5620         return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5621                             TREE_OPERAND (arg1, 0)));
5622
5623       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
5624       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
5625           && real_onep (arg1))
5626         return non_lvalue (convert (type, arg0));
5627
5628       /* If ARG1 is a constant, we can convert this to a multiply by the
5629          reciprocal.  This does not have the same rounding properties,
5630          so only do this if -funsafe-math-optimizations.  We can actually
5631          always safely do it if ARG1 is a power of two, but it's hard to
5632          tell if it is or not in a portable manner.  */
5633       if (TREE_CODE (arg1) == REAL_CST)
5634         {
5635           if (flag_unsafe_math_optimizations
5636               && 0 != (tem = const_binop (code, build_real (type, dconst1),
5637                                           arg1, 0)))
5638             return fold (build (MULT_EXPR, type, arg0, tem));
5639           /* Find the reciprocal if optimizing and the result is exact.  */
5640           else if (optimize)
5641             {
5642               REAL_VALUE_TYPE r;
5643               r = TREE_REAL_CST (arg1);
5644               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5645                 {
5646                   tem = build_real (type, r);
5647                   return fold (build (MULT_EXPR, type, arg0, tem));
5648                 }
5649             }
5650         }
5651       /* Convert A/B/C to A/(B*C).  */
5652       if (flag_unsafe_math_optimizations
5653           && TREE_CODE (arg0) == RDIV_EXPR)
5654         {
5655           return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
5656                               build (MULT_EXPR, type, TREE_OPERAND (arg0, 1),
5657                                      arg1)));
5658         }
5659       /* Convert A/(B/C) to (A/B)*C.  */
5660       if (flag_unsafe_math_optimizations
5661           && TREE_CODE (arg1) == RDIV_EXPR)
5662         {
5663           return fold (build (MULT_EXPR, type,
5664                               build (RDIV_EXPR, type, arg0,
5665                                      TREE_OPERAND (arg1, 0)),
5666                               TREE_OPERAND (arg1, 1)));
5667         }
5668       goto binary;
5669
5670     case TRUNC_DIV_EXPR:
5671     case ROUND_DIV_EXPR:
5672     case FLOOR_DIV_EXPR:
5673     case CEIL_DIV_EXPR:
5674     case EXACT_DIV_EXPR:
5675       if (integer_onep (arg1))
5676         return non_lvalue (convert (type, arg0));
5677       if (integer_zerop (arg1))
5678         return t;
5679
5680       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5681          operation, EXACT_DIV_EXPR.
5682
5683          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5684          At one time others generated faster code, it's not clear if they do
5685          after the last round to changes to the DIV code in expmed.c.  */
5686       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5687           && multiple_of_p (type, arg0, arg1))
5688         return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5689
5690       if (TREE_CODE (arg1) == INTEGER_CST
5691           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5692                                          code, NULL_TREE)))
5693         return convert (type, tem);
5694
5695       goto binary;
5696
5697     case CEIL_MOD_EXPR:
5698     case FLOOR_MOD_EXPR:
5699     case ROUND_MOD_EXPR:
5700     case TRUNC_MOD_EXPR:
5701       if (integer_onep (arg1))
5702         return omit_one_operand (type, integer_zero_node, arg0);
5703       if (integer_zerop (arg1))
5704         return t;
5705
5706       if (TREE_CODE (arg1) == INTEGER_CST
5707           && 0 != (tem = extract_muldiv (TREE_OPERAND (t, 0), arg1,
5708                                          code, NULL_TREE)))
5709         return convert (type, tem);
5710
5711       goto binary;
5712
5713     case LSHIFT_EXPR:
5714     case RSHIFT_EXPR:
5715     case LROTATE_EXPR:
5716     case RROTATE_EXPR:
5717       if (integer_zerop (arg1))
5718         return non_lvalue (convert (type, arg0));
5719       /* Since negative shift count is not well-defined,
5720          don't try to compute it in the compiler.  */
5721       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5722         return t;
5723       /* Rewrite an LROTATE_EXPR by a constant into an
5724          RROTATE_EXPR by a new constant.  */
5725       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5726         {
5727           TREE_SET_CODE (t, RROTATE_EXPR);
5728           code = RROTATE_EXPR;
5729           TREE_OPERAND (t, 1) = arg1
5730             = const_binop
5731               (MINUS_EXPR,
5732                convert (TREE_TYPE (arg1),
5733                         build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5734                arg1, 0);
5735           if (tree_int_cst_sgn (arg1) < 0)
5736             return t;
5737         }
5738
5739       /* If we have a rotate of a bit operation with the rotate count and
5740          the second operand of the bit operation both constant,
5741          permute the two operations.  */
5742       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5743           && (TREE_CODE (arg0) == BIT_AND_EXPR
5744               || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5745               || TREE_CODE (arg0) == BIT_IOR_EXPR
5746               || TREE_CODE (arg0) == BIT_XOR_EXPR)
5747           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5748         return fold (build (TREE_CODE (arg0), type,
5749                             fold (build (code, type,
5750                                          TREE_OPERAND (arg0, 0), arg1)),
5751                             fold (build (code, type,
5752                                          TREE_OPERAND (arg0, 1), arg1))));
5753
5754       /* Two consecutive rotates adding up to the width of the mode can
5755          be ignored.  */
5756       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5757           && TREE_CODE (arg0) == RROTATE_EXPR
5758           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5759           && TREE_INT_CST_HIGH (arg1) == 0
5760           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5761           && ((TREE_INT_CST_LOW (arg1)
5762                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5763               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
5764         return TREE_OPERAND (arg0, 0);
5765
5766       goto binary;
5767
5768     case MIN_EXPR:
5769       if (operand_equal_p (arg0, arg1, 0))
5770         return omit_one_operand (type, arg0, arg1);
5771       if (INTEGRAL_TYPE_P (type)
5772           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5773         return omit_one_operand (type, arg1, arg0);
5774       goto associate;
5775
5776     case MAX_EXPR:
5777       if (operand_equal_p (arg0, arg1, 0))
5778         return omit_one_operand (type, arg0, arg1);
5779       if (INTEGRAL_TYPE_P (type)
5780           && TYPE_MAX_VALUE (type)
5781           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5782         return omit_one_operand (type, arg1, arg0);
5783       goto associate;
5784
5785     case TRUTH_NOT_EXPR:
5786       /* Note that the operand of this must be an int
5787          and its values must be 0 or 1.
5788          ("true" is a fixed value perhaps depending on the language,
5789          but we don't handle values other than 1 correctly yet.)  */
5790       tem = invert_truthvalue (arg0);
5791       /* Avoid infinite recursion.  */
5792       if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5793         return t;
5794       return convert (type, tem);
5795
5796     case TRUTH_ANDIF_EXPR:
5797       /* Note that the operands of this must be ints
5798          and their values must be 0 or 1.
5799          ("true" is a fixed value perhaps depending on the language.)  */
5800       /* If first arg is constant zero, return it.  */
5801       if (integer_zerop (arg0))
5802         return convert (type, arg0);
5803     case TRUTH_AND_EXPR:
5804       /* If either arg is constant true, drop it.  */
5805       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5806         return non_lvalue (convert (type, arg1));
5807       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
5808           /* Preserve sequence points.  */
5809           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
5810         return non_lvalue (convert (type, arg0));
5811       /* If second arg is constant zero, result is zero, but first arg
5812          must be evaluated.  */
5813       if (integer_zerop (arg1))
5814         return omit_one_operand (type, arg1, arg0);
5815       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5816          case will be handled here.  */
5817       if (integer_zerop (arg0))
5818         return omit_one_operand (type, arg0, arg1);
5819
5820     truth_andor:
5821       /* We only do these simplifications if we are optimizing.  */
5822       if (!optimize)
5823         return t;
5824
5825       /* Check for things like (A || B) && (A || C).  We can convert this
5826          to A || (B && C).  Note that either operator can be any of the four
5827          truth and/or operations and the transformation will still be
5828          valid.   Also note that we only care about order for the
5829          ANDIF and ORIF operators.  If B contains side effects, this
5830          might change the truth-value of A.  */
5831       if (TREE_CODE (arg0) == TREE_CODE (arg1)
5832           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5833               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5834               || TREE_CODE (arg0) == TRUTH_AND_EXPR
5835               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5836           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5837         {
5838           tree a00 = TREE_OPERAND (arg0, 0);
5839           tree a01 = TREE_OPERAND (arg0, 1);
5840           tree a10 = TREE_OPERAND (arg1, 0);
5841           tree a11 = TREE_OPERAND (arg1, 1);
5842           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5843                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5844                              && (code == TRUTH_AND_EXPR
5845                                  || code == TRUTH_OR_EXPR));
5846
5847           if (operand_equal_p (a00, a10, 0))
5848             return fold (build (TREE_CODE (arg0), type, a00,
5849                                 fold (build (code, type, a01, a11))));
5850           else if (commutative && operand_equal_p (a00, a11, 0))
5851             return fold (build (TREE_CODE (arg0), type, a00,
5852                                 fold (build (code, type, a01, a10))));
5853           else if (commutative && operand_equal_p (a01, a10, 0))
5854             return fold (build (TREE_CODE (arg0), type, a01,
5855                                 fold (build (code, type, a00, a11))));
5856
5857           /* This case if tricky because we must either have commutative
5858              operators or else A10 must not have side-effects.  */
5859
5860           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5861                    && operand_equal_p (a01, a11, 0))
5862             return fold (build (TREE_CODE (arg0), type,
5863                                 fold (build (code, type, a00, a10)),
5864                                 a01));
5865         }
5866
5867       /* See if we can build a range comparison.  */
5868       if (0 != (tem = fold_range_test (t)))
5869         return tem;
5870
5871       /* Check for the possibility of merging component references.  If our
5872          lhs is another similar operation, try to merge its rhs with our
5873          rhs.  Then try to merge our lhs and rhs.  */
5874       if (TREE_CODE (arg0) == code
5875           && 0 != (tem = fold_truthop (code, type,
5876                                        TREE_OPERAND (arg0, 1), arg1)))
5877         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5878
5879       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5880         return tem;
5881
5882       return t;
5883
5884     case TRUTH_ORIF_EXPR:
5885       /* Note that the operands of this must be ints
5886          and their values must be 0 or true.
5887          ("true" is a fixed value perhaps depending on the language.)  */
5888       /* If first arg is constant true, return it.  */
5889       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5890         return convert (type, arg0);
5891     case TRUTH_OR_EXPR:
5892       /* If either arg is constant zero, drop it.  */
5893       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5894         return non_lvalue (convert (type, arg1));
5895       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
5896           /* Preserve sequence points.  */
5897           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
5898         return non_lvalue (convert (type, arg0));
5899       /* If second arg is constant true, result is true, but we must
5900          evaluate first arg.  */
5901       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5902         return omit_one_operand (type, arg1, arg0);
5903       /* Likewise for first arg, but note this only occurs here for
5904          TRUTH_OR_EXPR.  */
5905       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5906         return omit_one_operand (type, arg0, arg1);
5907       goto truth_andor;
5908
5909     case TRUTH_XOR_EXPR:
5910       /* If either arg is constant zero, drop it.  */
5911       if (integer_zerop (arg0))
5912         return non_lvalue (convert (type, arg1));
5913       if (integer_zerop (arg1))
5914         return non_lvalue (convert (type, arg0));
5915       /* If either arg is constant true, this is a logical inversion.  */
5916       if (integer_onep (arg0))
5917         return non_lvalue (convert (type, invert_truthvalue (arg1)));
5918       if (integer_onep (arg1))
5919         return non_lvalue (convert (type, invert_truthvalue (arg0)));
5920       return t;
5921
5922     case EQ_EXPR:
5923     case NE_EXPR:
5924     case LT_EXPR:
5925     case GT_EXPR:
5926     case LE_EXPR:
5927     case GE_EXPR:
5928       /* If one arg is a real or integer constant, put it last.  */
5929       if ((TREE_CODE (arg0) == INTEGER_CST
5930            && TREE_CODE (arg1) != INTEGER_CST)
5931           || (TREE_CODE (arg0) == REAL_CST
5932               && TREE_CODE (arg0) != REAL_CST))
5933         {
5934           TREE_OPERAND (t, 0) = arg1;
5935           TREE_OPERAND (t, 1) = arg0;
5936           arg0 = TREE_OPERAND (t, 0);
5937           arg1 = TREE_OPERAND (t, 1);
5938           code = swap_tree_comparison (code);
5939           TREE_SET_CODE (t, code);
5940         }
5941
5942       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
5943         {
5944           /* (-a) CMP (-b) -> b CMP a  */
5945           if (TREE_CODE (arg0) == NEGATE_EXPR
5946               && TREE_CODE (arg1) == NEGATE_EXPR)
5947             return fold (build (code, type, TREE_OPERAND (arg1, 0),
5948                                 TREE_OPERAND (arg0, 0)));
5949           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
5950           if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == REAL_CST)
5951             return
5952               fold (build
5953                     (swap_tree_comparison (code), type,
5954                      TREE_OPERAND (arg0, 0),
5955                      build_real (TREE_TYPE (arg1),
5956                                  REAL_VALUE_NEGATE (TREE_REAL_CST (arg1)))));
5957           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
5958           /* a CMP (-0) -> a CMP 0  */
5959           if (TREE_CODE (arg1) == REAL_CST
5960               && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1)))
5961             return fold (build (code, type, arg0,
5962                                 build_real (TREE_TYPE (arg1), dconst0)));
5963
5964           /* If this is a comparison of a real constant with a PLUS_EXPR
5965              or a MINUS_EXPR of a real constant, we can convert it into a
5966              comparison with a revised real constant as long as no overflow
5967              occurs when unsafe_math_optimizations are enabled.  */
5968           if (flag_unsafe_math_optimizations
5969               && TREE_CODE (arg1) == REAL_CST
5970               && (TREE_CODE (arg0) == PLUS_EXPR
5971                   || TREE_CODE (arg0) == MINUS_EXPR)
5972               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
5973               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
5974                                           ? MINUS_EXPR : PLUS_EXPR,
5975                                           arg1, TREE_OPERAND (arg0, 1), 0))
5976               && ! TREE_CONSTANT_OVERFLOW (tem))
5977             return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5978         }
5979
5980       /* Convert foo++ == CONST into ++foo == CONST + INCR.
5981          First, see if one arg is constant; find the constant arg
5982          and the other one.  */
5983       {
5984         tree constop = 0, varop = NULL_TREE;
5985         int constopnum = -1;
5986
5987         if (TREE_CONSTANT (arg1))
5988           constopnum = 1, constop = arg1, varop = arg0;
5989         if (TREE_CONSTANT (arg0))
5990           constopnum = 0, constop = arg0, varop = arg1;
5991
5992         if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5993           {
5994             /* This optimization is invalid for ordered comparisons
5995                if CONST+INCR overflows or if foo+incr might overflow.
5996                This optimization is invalid for floating point due to rounding.
5997                For pointer types we assume overflow doesn't happen.  */
5998             if (POINTER_TYPE_P (TREE_TYPE (varop))
5999                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6000                     && (code == EQ_EXPR || code == NE_EXPR)))
6001               {
6002                 tree newconst
6003                   = fold (build (PLUS_EXPR, TREE_TYPE (varop),
6004                                  constop, TREE_OPERAND (varop, 1)));
6005
6006                 /* Do not overwrite the current varop to be a preincrement,
6007                    create a new node so that we won't confuse our caller who
6008                    might create trees and throw them away, reusing the
6009                    arguments that they passed to build.  This shows up in
6010                    the THEN or ELSE parts of ?: being postincrements.  */
6011                 varop = build (PREINCREMENT_EXPR, TREE_TYPE (varop),
6012                                TREE_OPERAND (varop, 0),
6013                                TREE_OPERAND (varop, 1));
6014
6015                 /* If VAROP is a reference to a bitfield, we must mask
6016                    the constant by the width of the field.  */
6017                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6018                     && DECL_BIT_FIELD(TREE_OPERAND
6019                                       (TREE_OPERAND (varop, 0), 1)))
6020                   {
6021                     int size
6022                       = TREE_INT_CST_LOW (DECL_SIZE
6023                                           (TREE_OPERAND
6024                                            (TREE_OPERAND (varop, 0), 1)));
6025                     tree mask, unsigned_type;
6026                     unsigned int precision;
6027                     tree folded_compare;
6028
6029                     /* First check whether the comparison would come out
6030                        always the same.  If we don't do that we would
6031                        change the meaning with the masking.  */
6032                     if (constopnum == 0)
6033                       folded_compare = fold (build (code, type, constop,
6034                                                     TREE_OPERAND (varop, 0)));
6035                     else
6036                       folded_compare = fold (build (code, type,
6037                                                     TREE_OPERAND (varop, 0),
6038                                                     constop));
6039                     if (integer_zerop (folded_compare)
6040                         || integer_onep (folded_compare))
6041                       return omit_one_operand (type, folded_compare, varop);
6042
6043                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6044                     precision = TYPE_PRECISION (unsigned_type);
6045                     mask = build_int_2 (~0, ~0);
6046                     TREE_TYPE (mask) = unsigned_type;
6047                     force_fit_type (mask, 0);
6048                     mask = const_binop (RSHIFT_EXPR, mask,
6049                                         size_int (precision - size), 0);
6050                     newconst = fold (build (BIT_AND_EXPR,
6051                                             TREE_TYPE (varop), newconst,
6052                                             convert (TREE_TYPE (varop),
6053                                                      mask)));
6054                   }
6055
6056                 t = build (code, type,
6057                            (constopnum == 0) ? newconst : varop,
6058                            (constopnum == 1) ? newconst : varop);
6059                 return t;
6060               }
6061           }
6062         else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
6063           {
6064             if (POINTER_TYPE_P (TREE_TYPE (varop))
6065                 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
6066                     && (code == EQ_EXPR || code == NE_EXPR)))
6067               {
6068                 tree newconst
6069                   = fold (build (MINUS_EXPR, TREE_TYPE (varop),
6070                                  constop, TREE_OPERAND (varop, 1)));
6071
6072                 /* Do not overwrite the current varop to be a predecrement,
6073                    create a new node so that we won't confuse our caller who
6074                    might create trees and throw them away, reusing the
6075                    arguments that they passed to build.  This shows up in
6076                    the THEN or ELSE parts of ?: being postdecrements.  */
6077                 varop = build (PREDECREMENT_EXPR, TREE_TYPE (varop),
6078                                TREE_OPERAND (varop, 0),
6079                                TREE_OPERAND (varop, 1));
6080
6081                 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
6082                     && DECL_BIT_FIELD(TREE_OPERAND
6083                                       (TREE_OPERAND (varop, 0), 1)))
6084                   {
6085                     int size
6086                       = TREE_INT_CST_LOW (DECL_SIZE
6087                                           (TREE_OPERAND
6088                                            (TREE_OPERAND (varop, 0), 1)));
6089                     tree mask, unsigned_type;
6090                     unsigned int precision;
6091                     tree folded_compare;
6092
6093                     if (constopnum == 0)
6094                       folded_compare = fold (build (code, type, constop,
6095                                                     TREE_OPERAND (varop, 0)));
6096                     else
6097                       folded_compare = fold (build (code, type,
6098                                                     TREE_OPERAND (varop, 0),
6099                                                     constop));
6100                     if (integer_zerop (folded_compare)
6101                         || integer_onep (folded_compare))
6102                       return omit_one_operand (type, folded_compare, varop);
6103
6104                     unsigned_type = (*lang_hooks.types.type_for_size)(size, 1);
6105                     precision = TYPE_PRECISION (unsigned_type);
6106                     mask = build_int_2 (~0, ~0);
6107                     TREE_TYPE (mask) = TREE_TYPE (varop);
6108                     force_fit_type (mask, 0);
6109                     mask = const_binop (RSHIFT_EXPR, mask,
6110                                         size_int (precision - size), 0);
6111                     newconst = fold (build (BIT_AND_EXPR,
6112                                             TREE_TYPE (varop), newconst,
6113                                             convert (TREE_TYPE (varop),
6114                                                      mask)));
6115                   }
6116
6117                 t = build (code, type,
6118                            (constopnum == 0) ? newconst : varop,
6119                            (constopnum == 1) ? newconst : varop);
6120                 return t;
6121               }
6122           }
6123       }
6124
6125       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
6126          This transformation affects the cases which are handled in later
6127          optimizations involving comparisons with non-negative constants.  */
6128       if (TREE_CODE (arg1) == INTEGER_CST
6129           && TREE_CODE (arg0) != INTEGER_CST
6130           && tree_int_cst_sgn (arg1) > 0)
6131         {
6132           switch (code)
6133             {
6134             case GE_EXPR:
6135               code = GT_EXPR;
6136               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6137               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6138               break;
6139
6140             case LT_EXPR:
6141               code = LE_EXPR;
6142               arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6143               t = build (code, type, TREE_OPERAND (t, 0), arg1);
6144               break;
6145
6146             default:
6147               break;
6148             }
6149         }
6150
6151       /* Comparisons with the highest or lowest possible integer of
6152          the specified size will have known values.  */
6153       {
6154         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
6155
6156         if (TREE_CODE (arg1) == INTEGER_CST
6157             && ! TREE_CONSTANT_OVERFLOW (arg1)
6158             && width <= HOST_BITS_PER_WIDE_INT
6159             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
6160                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
6161           {
6162             unsigned HOST_WIDE_INT signed_max;
6163             unsigned HOST_WIDE_INT max, min;
6164
6165             signed_max = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
6166
6167             if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6168               {
6169                 max = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
6170                 min = 0;
6171               }
6172             else
6173               {
6174                 max = signed_max;
6175                 min = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
6176               }
6177
6178             if (TREE_INT_CST_HIGH (arg1) == 0
6179                 && TREE_INT_CST_LOW (arg1) == max)
6180               switch (code)
6181                 {
6182                 case GT_EXPR:
6183                   return omit_one_operand (type,
6184                                            convert (type, integer_zero_node),
6185                                            arg0);
6186                 case GE_EXPR:
6187                   code = EQ_EXPR;
6188                   TREE_SET_CODE (t, EQ_EXPR);
6189                   break;
6190                 case LE_EXPR:
6191                   return omit_one_operand (type,
6192                                            convert (type, integer_one_node),
6193                                            arg0);
6194                 case LT_EXPR:
6195                   code = NE_EXPR;
6196                   TREE_SET_CODE (t, NE_EXPR);
6197                   break;
6198
6199                 /* The GE_EXPR and LT_EXPR cases above are not normally
6200                    reached because of  previous transformations.  */
6201
6202                 default:
6203                   break;
6204                 }
6205             else if (TREE_INT_CST_HIGH (arg1) == 0
6206                      && TREE_INT_CST_LOW (arg1) == max - 1)
6207               switch (code)
6208                 {
6209                 case GT_EXPR:
6210                   code = EQ_EXPR;
6211                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6212                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6213                   break;
6214                 case LE_EXPR:
6215                   code = NE_EXPR;
6216                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
6217                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6218                   break;
6219                 default:
6220                   break;
6221                 }
6222             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6223                      && TREE_INT_CST_LOW (arg1) == min)
6224               switch (code)
6225                 {
6226                 case LT_EXPR:
6227                   return omit_one_operand (type,
6228                                            convert (type, integer_zero_node),
6229                                            arg0);
6230                 case LE_EXPR:
6231                   code = EQ_EXPR;
6232                   TREE_SET_CODE (t, EQ_EXPR);
6233                   break;
6234
6235                 case GE_EXPR:
6236                   return omit_one_operand (type,
6237                                            convert (type, integer_one_node),
6238                                            arg0);
6239                 case GT_EXPR:
6240                   code = NE_EXPR;
6241                   TREE_SET_CODE (t, NE_EXPR);
6242                   break;
6243
6244                 default:
6245                   break;
6246                 }
6247             else if (TREE_INT_CST_HIGH (arg1) == (min ? -1 : 0)
6248                      && TREE_INT_CST_LOW (arg1) == min + 1)
6249               switch (code)
6250                 {
6251                 case GE_EXPR:
6252                   code = NE_EXPR;
6253                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6254                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6255                   break;
6256                 case LT_EXPR:
6257                   code = EQ_EXPR;
6258                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
6259                   t = build (code, type, TREE_OPERAND (t, 0), arg1);
6260                   break;
6261                 default:
6262                   break;
6263                 }
6264
6265             else if (TREE_INT_CST_HIGH (arg1) == 0
6266                      && TREE_INT_CST_LOW (arg1) == signed_max
6267                      && TREE_UNSIGNED (TREE_TYPE (arg1))
6268                      /* signed_type does not work on pointer types.  */
6269                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
6270               {
6271                 /* The following case also applies to X < signed_max+1
6272                    and X >= signed_max+1 because previous transformations.  */
6273                 if (code == LE_EXPR || code == GT_EXPR)
6274                   {
6275                     tree st0, st1;
6276                     st0 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg0));
6277                     st1 = (*lang_hooks.types.signed_type) (TREE_TYPE (arg1));
6278                     return fold
6279                       (build (code == LE_EXPR ? GE_EXPR: LT_EXPR,
6280                               type, convert (st0, arg0),
6281                               convert (st1, integer_zero_node)));
6282                   }
6283               }
6284           }
6285       }
6286
6287       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6288          a MINUS_EXPR of a constant, we can convert it into a comparison with
6289          a revised constant as long as no overflow occurs.  */
6290       if ((code == EQ_EXPR || code == NE_EXPR)
6291           && TREE_CODE (arg1) == INTEGER_CST
6292           && (TREE_CODE (arg0) == PLUS_EXPR
6293               || TREE_CODE (arg0) == MINUS_EXPR)
6294           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6295           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
6296                                       ? MINUS_EXPR : PLUS_EXPR,
6297                                       arg1, TREE_OPERAND (arg0, 1), 0))
6298           && ! TREE_CONSTANT_OVERFLOW (tem))
6299         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6300
6301       /* Similarly for a NEGATE_EXPR.  */
6302       else if ((code == EQ_EXPR || code == NE_EXPR)
6303                && TREE_CODE (arg0) == NEGATE_EXPR
6304                && TREE_CODE (arg1) == INTEGER_CST
6305                && 0 != (tem = negate_expr (arg1))
6306                && TREE_CODE (tem) == INTEGER_CST
6307                && ! TREE_CONSTANT_OVERFLOW (tem))
6308         return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
6309
6310       /* If we have X - Y == 0, we can convert that to X == Y and similarly
6311          for !=.  Don't do this for ordered comparisons due to overflow.  */
6312       else if ((code == NE_EXPR || code == EQ_EXPR)
6313                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
6314         return fold (build (code, type,
6315                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1)));
6316
6317       /* If we are widening one operand of an integer comparison,
6318          see if the other operand is similarly being widened.  Perhaps we
6319          can do the comparison in the narrower type.  */
6320       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
6321                && TREE_CODE (arg0) == NOP_EXPR
6322                && (tem = get_unwidened (arg0, NULL_TREE)) != arg0
6323                && (t1 = get_unwidened (arg1, TREE_TYPE (tem))) != 0
6324                && (TREE_TYPE (t1) == TREE_TYPE (tem)
6325                    || (TREE_CODE (t1) == INTEGER_CST
6326                        && int_fits_type_p (t1, TREE_TYPE (tem)))))
6327         return fold (build (code, type, tem, convert (TREE_TYPE (tem), t1)));
6328
6329       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6330          constant, we can simplify it.  */
6331       else if (TREE_CODE (arg1) == INTEGER_CST
6332                && (TREE_CODE (arg0) == MIN_EXPR
6333                    || TREE_CODE (arg0) == MAX_EXPR)
6334                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
6335         return optimize_minmax_comparison (t);
6336
6337       /* If we are comparing an ABS_EXPR with a constant, we can
6338          convert all the cases into explicit comparisons, but they may
6339          well not be faster than doing the ABS and one comparison.
6340          But ABS (X) <= C is a range comparison, which becomes a subtraction
6341          and a comparison, and is probably faster.  */
6342       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
6343                && TREE_CODE (arg0) == ABS_EXPR
6344                && ! TREE_SIDE_EFFECTS (arg0)
6345                && (0 != (tem = negate_expr (arg1)))
6346                && TREE_CODE (tem) == INTEGER_CST
6347                && ! TREE_CONSTANT_OVERFLOW (tem))
6348         return fold (build (TRUTH_ANDIF_EXPR, type,
6349                             build (GE_EXPR, type, TREE_OPERAND (arg0, 0), tem),
6350                             build (LE_EXPR, type,
6351                                    TREE_OPERAND (arg0, 0), arg1)));
6352
6353       /* If this is an EQ or NE comparison with zero and ARG0 is
6354          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
6355          two operations, but the latter can be done in one less insn
6356          on machines that have only two-operand insns or on which a
6357          constant cannot be the first operand.  */
6358       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
6359           && TREE_CODE (arg0) == BIT_AND_EXPR)
6360         {
6361           if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
6362               && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
6363             return
6364               fold (build (code, type,
6365                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6366                                   build (RSHIFT_EXPR,
6367                                          TREE_TYPE (TREE_OPERAND (arg0, 0)),
6368                                          TREE_OPERAND (arg0, 1),
6369                                          TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
6370                                   convert (TREE_TYPE (arg0),
6371                                            integer_one_node)),
6372                            arg1));
6373           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
6374                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
6375             return
6376               fold (build (code, type,
6377                            build (BIT_AND_EXPR, TREE_TYPE (arg0),
6378                                   build (RSHIFT_EXPR,
6379                                          TREE_TYPE (TREE_OPERAND (arg0, 1)),
6380                                          TREE_OPERAND (arg0, 0),
6381                                          TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
6382                                   convert (TREE_TYPE (arg0),
6383                                            integer_one_node)),
6384                            arg1));
6385         }
6386
6387       /* If this is an NE or EQ comparison of zero against the result of a
6388          signed MOD operation whose second operand is a power of 2, make
6389          the MOD operation unsigned since it is simpler and equivalent.  */
6390       if ((code == NE_EXPR || code == EQ_EXPR)
6391           && integer_zerop (arg1)
6392           && ! TREE_UNSIGNED (TREE_TYPE (arg0))
6393           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
6394               || TREE_CODE (arg0) == CEIL_MOD_EXPR
6395               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
6396               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
6397           && integer_pow2p (TREE_OPERAND (arg0, 1)))
6398         {
6399           tree newtype = (*lang_hooks.types.unsigned_type) (TREE_TYPE (arg0));
6400           tree newmod = build (TREE_CODE (arg0), newtype,
6401                                convert (newtype, TREE_OPERAND (arg0, 0)),
6402                                convert (newtype, TREE_OPERAND (arg0, 1)));
6403
6404           return build (code, type, newmod, convert (newtype, arg1));
6405         }
6406
6407       /* If this is an NE comparison of zero with an AND of one, remove the
6408          comparison since the AND will give the correct value.  */
6409       if (code == NE_EXPR && integer_zerop (arg1)
6410           && TREE_CODE (arg0) == BIT_AND_EXPR
6411           && integer_onep (TREE_OPERAND (arg0, 1)))
6412         return convert (type, arg0);
6413
6414       /* If we have (A & C) == C where C is a power of 2, convert this into
6415          (A & C) != 0.  Similarly for NE_EXPR.  */
6416       if ((code == EQ_EXPR || code == NE_EXPR)
6417           && TREE_CODE (arg0) == BIT_AND_EXPR
6418           && integer_pow2p (TREE_OPERAND (arg0, 1))
6419           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
6420         return fold (build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
6421                             arg0, integer_zero_node));
6422
6423       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6424          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6425       if ((code == EQ_EXPR || code == NE_EXPR)
6426           && TREE_CODE (arg0) == BIT_AND_EXPR
6427           && integer_zerop (arg1))
6428         {
6429           tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0),
6430                                    TREE_OPERAND (arg0, 1));
6431           if (arg00 != NULL_TREE)
6432           {
6433             tree stype = (*lang_hooks.types.signed_type) (TREE_TYPE (arg00));
6434             return fold (build (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
6435                                 convert (stype, arg00),
6436                                 convert (stype, integer_zero_node)));
6437           }
6438         }
6439
6440       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6441          and similarly for >= into !=.  */
6442       if ((code == LT_EXPR || code == GE_EXPR)
6443           && TREE_UNSIGNED (TREE_TYPE (arg0))
6444           && TREE_CODE (arg1) == LSHIFT_EXPR
6445           && integer_onep (TREE_OPERAND (arg1, 0)))
6446         return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6447                       build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6448                              TREE_OPERAND (arg1, 1)),
6449                       convert (TREE_TYPE (arg0), integer_zero_node));
6450
6451       else if ((code == LT_EXPR || code == GE_EXPR)
6452                && TREE_UNSIGNED (TREE_TYPE (arg0))
6453                && (TREE_CODE (arg1) == NOP_EXPR
6454                    || TREE_CODE (arg1) == CONVERT_EXPR)
6455                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
6456                && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
6457         return
6458           build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
6459                  convert (TREE_TYPE (arg0),
6460                           build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
6461                                  TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
6462                  convert (TREE_TYPE (arg0), integer_zero_node));
6463
6464       /* Simplify comparison of something with itself.  (For IEEE
6465          floating-point, we can only do some of these simplifications.)  */
6466       if (operand_equal_p (arg0, arg1, 0))
6467         {
6468           switch (code)
6469             {
6470             case EQ_EXPR:
6471             case GE_EXPR:
6472             case LE_EXPR:
6473               if (! FLOAT_TYPE_P (TREE_TYPE (arg0)))
6474                 return constant_boolean_node (1, type);
6475               code = EQ_EXPR;
6476               TREE_SET_CODE (t, code);
6477               break;
6478
6479             case NE_EXPR:
6480               /* For NE, we can only do this simplification if integer.  */
6481               if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
6482                 break;
6483               /* ... fall through ...  */
6484             case GT_EXPR:
6485             case LT_EXPR:
6486               return constant_boolean_node (0, type);
6487             default:
6488               abort ();
6489             }
6490         }
6491
6492       /* If we are comparing an expression that just has comparisons
6493          of two integer values, arithmetic expressions of those comparisons,
6494          and constants, we can simplify it.  There are only three cases
6495          to check: the two values can either be equal, the first can be
6496          greater, or the second can be greater.  Fold the expression for
6497          those three values.  Since each value must be 0 or 1, we have
6498          eight possibilities, each of which corresponds to the constant 0
6499          or 1 or one of the six possible comparisons.
6500
6501          This handles common cases like (a > b) == 0 but also handles
6502          expressions like  ((x > y) - (y > x)) > 0, which supposedly
6503          occur in macroized code.  */
6504
6505       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
6506         {
6507           tree cval1 = 0, cval2 = 0;
6508           int save_p = 0;
6509
6510           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
6511               /* Don't handle degenerate cases here; they should already
6512                  have been handled anyway.  */
6513               && cval1 != 0 && cval2 != 0
6514               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
6515               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
6516               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
6517               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
6518               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
6519               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
6520                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
6521             {
6522               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
6523               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
6524
6525               /* We can't just pass T to eval_subst in case cval1 or cval2
6526                  was the same as ARG1.  */
6527
6528               tree high_result
6529                 = fold (build (code, type,
6530                                eval_subst (arg0, cval1, maxval, cval2, minval),
6531                                arg1));
6532               tree equal_result
6533                 = fold (build (code, type,
6534                                eval_subst (arg0, cval1, maxval, cval2, maxval),
6535                                arg1));
6536               tree low_result
6537                 = fold (build (code, type,
6538                                eval_subst (arg0, cval1, minval, cval2, maxval),
6539                                arg1));
6540
6541               /* All three of these results should be 0 or 1.  Confirm they
6542                  are.  Then use those values to select the proper code
6543                  to use.  */
6544
6545               if ((integer_zerop (high_result)
6546                    || integer_onep (high_result))
6547                   && (integer_zerop (equal_result)
6548                       || integer_onep (equal_result))
6549                   && (integer_zerop (low_result)
6550                       || integer_onep (low_result)))
6551                 {
6552                   /* Make a 3-bit mask with the high-order bit being the
6553                      value for `>', the next for '=', and the low for '<'.  */
6554                   switch ((integer_onep (high_result) * 4)
6555                           + (integer_onep (equal_result) * 2)
6556                           + integer_onep (low_result))
6557                     {
6558                     case 0:
6559                       /* Always false.  */
6560                       return omit_one_operand (type, integer_zero_node, arg0);
6561                     case 1:
6562                       code = LT_EXPR;
6563                       break;
6564                     case 2:
6565                       code = EQ_EXPR;
6566                       break;
6567                     case 3:
6568                       code = LE_EXPR;
6569                       break;
6570                     case 4:
6571                       code = GT_EXPR;
6572                       break;
6573                     case 5:
6574                       code = NE_EXPR;
6575                       break;
6576                     case 6:
6577                       code = GE_EXPR;
6578                       break;
6579                     case 7:
6580                       /* Always true.  */
6581                       return omit_one_operand (type, integer_one_node, arg0);
6582                     }
6583
6584                   t = build (code, type, cval1, cval2);
6585                   if (save_p)
6586                     return save_expr (t);
6587                   else
6588                     return fold (t);
6589                 }
6590             }
6591         }
6592
6593       /* If this is a comparison of a field, we may be able to simplify it.  */
6594       if (((TREE_CODE (arg0) == COMPONENT_REF
6595             && (*lang_hooks.can_use_bit_fields_p) ())
6596            || TREE_CODE (arg0) == BIT_FIELD_REF)
6597           && (code == EQ_EXPR || code == NE_EXPR)
6598           /* Handle the constant case even without -O
6599              to make sure the warnings are given.  */
6600           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6601         {
6602           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6603           return t1 ? t1 : t;
6604         }
6605
6606       /* If this is a comparison of complex values and either or both sides
6607          are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6608          comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6609          This may prevent needless evaluations.  */
6610       if ((code == EQ_EXPR || code == NE_EXPR)
6611           && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6612           && (TREE_CODE (arg0) == COMPLEX_EXPR
6613               || TREE_CODE (arg1) == COMPLEX_EXPR
6614               || TREE_CODE (arg0) == COMPLEX_CST
6615               || TREE_CODE (arg1) == COMPLEX_CST))
6616         {
6617           tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6618           tree real0, imag0, real1, imag1;
6619
6620           arg0 = save_expr (arg0);
6621           arg1 = save_expr (arg1);
6622           real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6623           imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6624           real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6625           imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6626
6627           return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6628                                : TRUTH_ORIF_EXPR),
6629                               type,
6630                               fold (build (code, type, real0, real1)),
6631                               fold (build (code, type, imag0, imag1))));
6632         }
6633
6634       /* Optimize comparisons of strlen vs zero to a compare of the
6635          first character of the string vs zero.  To wit,
6636                 strlen(ptr) == 0   =>  *ptr == 0
6637                 strlen(ptr) != 0   =>  *ptr != 0
6638          Other cases should reduce to one of these two (or a constant)
6639          due to the return value of strlen being unsigned.  */
6640       if ((code == EQ_EXPR || code == NE_EXPR)
6641           && integer_zerop (arg1)
6642           && TREE_CODE (arg0) == CALL_EXPR
6643           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR)
6644         {
6645           tree fndecl = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
6646           tree arglist;
6647
6648           if (TREE_CODE (fndecl) == FUNCTION_DECL
6649               && DECL_BUILT_IN (fndecl)
6650               && DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_MD
6651               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
6652               && (arglist = TREE_OPERAND (arg0, 1))
6653               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
6654               && ! TREE_CHAIN (arglist))
6655             return fold (build (code, type,
6656                                 build1 (INDIRECT_REF, char_type_node,
6657                                         TREE_VALUE(arglist)),
6658                                 integer_zero_node));
6659         }
6660
6661       /* From here on, the only cases we handle are when the result is
6662          known to be a constant.
6663
6664          To compute GT, swap the arguments and do LT.
6665          To compute GE, do LT and invert the result.
6666          To compute LE, swap the arguments, do LT and invert the result.
6667          To compute NE, do EQ and invert the result.
6668
6669          Therefore, the code below must handle only EQ and LT.  */
6670
6671       if (code == LE_EXPR || code == GT_EXPR)
6672         {
6673           tem = arg0, arg0 = arg1, arg1 = tem;
6674           code = swap_tree_comparison (code);
6675         }
6676
6677       /* Note that it is safe to invert for real values here because we
6678          will check below in the one case that it matters.  */
6679
6680       t1 = NULL_TREE;
6681       invert = 0;
6682       if (code == NE_EXPR || code == GE_EXPR)
6683         {
6684           invert = 1;
6685           code = invert_tree_comparison (code);
6686         }
6687
6688       /* Compute a result for LT or EQ if args permit;
6689          otherwise return T.  */
6690       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6691         {
6692           if (code == EQ_EXPR)
6693             t1 = build_int_2 (tree_int_cst_equal (arg0, arg1), 0);
6694           else
6695             t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6696                                ? INT_CST_LT_UNSIGNED (arg0, arg1)
6697                                : INT_CST_LT (arg0, arg1)),
6698                               0);
6699         }
6700
6701 #if 0 /* This is no longer useful, but breaks some real code.  */
6702       /* Assume a nonexplicit constant cannot equal an explicit one,
6703          since such code would be undefined anyway.
6704          Exception: on sysvr4, using #pragma weak,
6705          a label can come out as 0.  */
6706       else if (TREE_CODE (arg1) == INTEGER_CST
6707                && !integer_zerop (arg1)
6708                && TREE_CONSTANT (arg0)
6709                && TREE_CODE (arg0) == ADDR_EXPR
6710                && code == EQ_EXPR)
6711         t1 = build_int_2 (0, 0);
6712 #endif
6713       /* Two real constants can be compared explicitly.  */
6714       else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6715         {
6716           /* If either operand is a NaN, the result is false with two
6717              exceptions: First, an NE_EXPR is true on NaNs, but that case
6718              is already handled correctly since we will be inverting the
6719              result for NE_EXPR.  Second, if we had inverted a LE_EXPR
6720              or a GE_EXPR into a LT_EXPR, we must return true so that it
6721              will be inverted into false.  */
6722
6723           if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6724               || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6725             t1 = build_int_2 (invert && code == LT_EXPR, 0);
6726
6727           else if (code == EQ_EXPR)
6728             t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6729                                                  TREE_REAL_CST (arg1)),
6730                               0);
6731           else
6732             t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6733                                                 TREE_REAL_CST (arg1)),
6734                               0);
6735         }
6736
6737       if (t1 == NULL_TREE)
6738         return t;
6739
6740       if (invert)
6741         TREE_INT_CST_LOW (t1) ^= 1;
6742
6743       TREE_TYPE (t1) = type;
6744       if (TREE_CODE (type) == BOOLEAN_TYPE)
6745         return (*lang_hooks.truthvalue_conversion) (t1);
6746       return t1;
6747
6748     case COND_EXPR:
6749       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6750          so all simple results must be passed through pedantic_non_lvalue.  */
6751       if (TREE_CODE (arg0) == INTEGER_CST)
6752         return pedantic_non_lvalue
6753           (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6754       else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6755         return pedantic_omit_one_operand (type, arg1, arg0);
6756
6757       /* If the second operand is zero, invert the comparison and swap
6758          the second and third operands.  Likewise if the second operand
6759          is constant and the third is not or if the third operand is
6760          equivalent to the first operand of the comparison.  */
6761
6762       if (integer_zerop (arg1)
6763           || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6764           || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6765               && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6766                                                  TREE_OPERAND (t, 2),
6767                                                  TREE_OPERAND (arg0, 1))))
6768         {
6769           /* See if this can be inverted.  If it can't, possibly because
6770              it was a floating-point inequality comparison, don't do
6771              anything.  */
6772           tem = invert_truthvalue (arg0);
6773
6774           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6775             {
6776               t = build (code, type, tem,
6777                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6778               arg0 = tem;
6779               /* arg1 should be the first argument of the new T.  */
6780               arg1 = TREE_OPERAND (t, 1);
6781               STRIP_NOPS (arg1);
6782             }
6783         }
6784
6785       /* If we have A op B ? A : C, we may be able to convert this to a
6786          simpler expression, depending on the operation and the values
6787          of B and C.  Signed zeros prevent all of these transformations,
6788          for reasons given above each one.  */
6789
6790       if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6791           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6792                                              arg1, TREE_OPERAND (arg0, 1))
6793           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
6794         {
6795           tree arg2 = TREE_OPERAND (t, 2);
6796           enum tree_code comp_code = TREE_CODE (arg0);
6797
6798           STRIP_NOPS (arg2);
6799
6800           /* If we have A op 0 ? A : -A, consider applying the following
6801              transformations:
6802
6803              A == 0? A : -A    same as -A
6804              A != 0? A : -A    same as A
6805              A >= 0? A : -A    same as abs (A)
6806              A > 0?  A : -A    same as abs (A)
6807              A <= 0? A : -A    same as -abs (A)
6808              A < 0?  A : -A    same as -abs (A)
6809
6810              None of these transformations work for modes with signed
6811              zeros.  If A is +/-0, the first two transformations will
6812              change the sign of the result (from +0 to -0, or vice
6813              versa).  The last four will fix the sign of the result,
6814              even though the original expressions could be positive or
6815              negative, depending on the sign of A.
6816
6817              Note that all these transformations are correct if A is
6818              NaN, since the two alternatives (A and -A) are also NaNs.  */
6819           if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
6820                ? real_zerop (TREE_OPERAND (arg0, 1))
6821                : integer_zerop (TREE_OPERAND (arg0, 1)))
6822               && TREE_CODE (arg2) == NEGATE_EXPR
6823               && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
6824             switch (comp_code)
6825               {
6826               case EQ_EXPR:
6827                 return
6828                   pedantic_non_lvalue
6829                     (convert (type,
6830                               negate_expr
6831                               (convert (TREE_TYPE (TREE_OPERAND (t, 1)),
6832                                         arg1))));
6833               case NE_EXPR:
6834                 return pedantic_non_lvalue (convert (type, arg1));
6835               case GE_EXPR:
6836               case GT_EXPR:
6837                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6838                   arg1 = convert ((*lang_hooks.types.signed_type)
6839                                   (TREE_TYPE (arg1)), arg1);
6840                 return pedantic_non_lvalue
6841                   (convert (type, fold (build1 (ABS_EXPR,
6842                                                 TREE_TYPE (arg1), arg1))));
6843               case LE_EXPR:
6844               case LT_EXPR:
6845                 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6846                   arg1 = convert ((lang_hooks.types.signed_type)
6847                                   (TREE_TYPE (arg1)), arg1);
6848                 return pedantic_non_lvalue
6849                   (negate_expr (convert (type,
6850                                          fold (build1 (ABS_EXPR,
6851                                                        TREE_TYPE (arg1),
6852                                                        arg1)))));
6853               default:
6854                 abort ();
6855               }
6856
6857           /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
6858              A == 0 ? A : 0 is always 0 unless A is -0.  Note that
6859              both transformations are correct when A is NaN: A != 0
6860              is then true, and A == 0 is false.  */
6861
6862           if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
6863             {
6864               if (comp_code == NE_EXPR)
6865                 return pedantic_non_lvalue (convert (type, arg1));
6866               else if (comp_code == EQ_EXPR)
6867                 return pedantic_non_lvalue (convert (type, integer_zero_node));
6868             }
6869
6870           /* Try some transformations of A op B ? A : B.
6871
6872              A == B? A : B    same as B
6873              A != B? A : B    same as A
6874              A >= B? A : B    same as max (A, B)
6875              A > B?  A : B    same as max (B, A)
6876              A <= B? A : B    same as min (A, B)
6877              A < B?  A : B    same as min (B, A)
6878
6879              As above, these transformations don't work in the presence
6880              of signed zeros.  For example, if A and B are zeros of
6881              opposite sign, the first two transformations will change
6882              the sign of the result.  In the last four, the original
6883              expressions give different results for (A=+0, B=-0) and
6884              (A=-0, B=+0), but the transformed expressions do not.
6885
6886              The first two transformations are correct if either A or B
6887              is a NaN.  In the first transformation, the condition will
6888              be false, and B will indeed be chosen.  In the case of the
6889              second transformation, the condition A != B will be true,
6890              and A will be chosen.
6891
6892              The conversions to max() and min() are not correct if B is
6893              a number and A is not.  The conditions in the original
6894              expressions will be false, so all four give B.  The min()
6895              and max() versions would give a NaN instead.  */
6896           if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
6897                                               arg2, TREE_OPERAND (arg0, 0)))
6898             {
6899               tree comp_op0 = TREE_OPERAND (arg0, 0);
6900               tree comp_op1 = TREE_OPERAND (arg0, 1);
6901               tree comp_type = TREE_TYPE (comp_op0);
6902
6903               /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
6904               if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
6905                 comp_type = type;
6906
6907               switch (comp_code)
6908                 {
6909                 case EQ_EXPR:
6910                   return pedantic_non_lvalue (convert (type, arg2));
6911                 case NE_EXPR:
6912                   return pedantic_non_lvalue (convert (type, arg1));
6913                 case LE_EXPR:
6914                 case LT_EXPR:
6915                   /* In C++ a ?: expression can be an lvalue, so put the
6916                      operand which will be used if they are equal first
6917                      so that we can convert this back to the
6918                      corresponding COND_EXPR.  */
6919                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
6920                     return pedantic_non_lvalue
6921                       (convert (type, fold (build (MIN_EXPR, comp_type,
6922                                                    (comp_code == LE_EXPR
6923                                                     ? comp_op0 : comp_op1),
6924                                                    (comp_code == LE_EXPR
6925                                                     ? comp_op1 : comp_op0)))));
6926                   break;
6927                 case GE_EXPR:
6928                 case GT_EXPR:
6929                   if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
6930                     return pedantic_non_lvalue
6931                       (convert (type, fold (build (MAX_EXPR, comp_type,
6932                                                    (comp_code == GE_EXPR
6933                                                     ? comp_op0 : comp_op1),
6934                                                    (comp_code == GE_EXPR
6935                                                     ? comp_op1 : comp_op0)))));
6936                   break;
6937                 default:
6938                   abort ();
6939                 }
6940             }
6941
6942           /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6943              we might still be able to simplify this.  For example,
6944              if C1 is one less or one more than C2, this might have started
6945              out as a MIN or MAX and been transformed by this function.
6946              Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
6947
6948           if (INTEGRAL_TYPE_P (type)
6949               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6950               && TREE_CODE (arg2) == INTEGER_CST)
6951             switch (comp_code)
6952               {
6953               case EQ_EXPR:
6954                 /* We can replace A with C1 in this case.  */
6955                 arg1 = convert (type, TREE_OPERAND (arg0, 1));
6956                 t = build (code, type, TREE_OPERAND (t, 0), arg1,
6957                            TREE_OPERAND (t, 2));
6958                 break;
6959
6960               case LT_EXPR:
6961                 /* If C1 is C2 + 1, this is min(A, C2).  */
6962                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6963                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6964                                         const_binop (PLUS_EXPR, arg2,
6965                                                      integer_one_node, 0), 1))
6966                   return pedantic_non_lvalue
6967                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6968                 break;
6969
6970               case LE_EXPR:
6971                 /* If C1 is C2 - 1, this is min(A, C2).  */
6972                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6973                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6974                                         const_binop (MINUS_EXPR, arg2,
6975                                                      integer_one_node, 0), 1))
6976                   return pedantic_non_lvalue
6977                     (fold (build (MIN_EXPR, type, arg1, arg2)));
6978                 break;
6979
6980               case GT_EXPR:
6981                 /* If C1 is C2 - 1, this is max(A, C2).  */
6982                 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6983                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6984                                         const_binop (MINUS_EXPR, arg2,
6985                                                      integer_one_node, 0), 1))
6986                   return pedantic_non_lvalue
6987                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6988                 break;
6989
6990               case GE_EXPR:
6991                 /* If C1 is C2 + 1, this is max(A, C2).  */
6992                 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6993                     && operand_equal_p (TREE_OPERAND (arg0, 1),
6994                                         const_binop (PLUS_EXPR, arg2,
6995                                                      integer_one_node, 0), 1))
6996                   return pedantic_non_lvalue
6997                     (fold (build (MAX_EXPR, type, arg1, arg2)));
6998                 break;
6999               case NE_EXPR:
7000                 break;
7001               default:
7002                 abort ();
7003               }
7004         }
7005
7006       /* If the second operand is simpler than the third, swap them
7007          since that produces better jump optimization results.  */
7008       if ((TREE_CONSTANT (arg1) || DECL_P (arg1)
7009            || TREE_CODE (arg1) == SAVE_EXPR)
7010           && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
7011                 || DECL_P (TREE_OPERAND (t, 2))
7012                 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
7013         {
7014           /* See if this can be inverted.  If it can't, possibly because
7015              it was a floating-point inequality comparison, don't do
7016              anything.  */
7017           tem = invert_truthvalue (arg0);
7018
7019           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7020             {
7021               t = build (code, type, tem,
7022                          TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
7023               arg0 = tem;
7024               /* arg1 should be the first argument of the new T.  */
7025               arg1 = TREE_OPERAND (t, 1);
7026               STRIP_NOPS (arg1);
7027             }
7028         }
7029
7030       /* Convert A ? 1 : 0 to simply A.  */
7031       if (integer_onep (TREE_OPERAND (t, 1))
7032           && integer_zerop (TREE_OPERAND (t, 2))
7033           /* If we try to convert TREE_OPERAND (t, 0) to our type, the
7034              call to fold will try to move the conversion inside
7035              a COND, which will recurse.  In that case, the COND_EXPR
7036              is probably the best choice, so leave it alone.  */
7037           && type == TREE_TYPE (arg0))
7038         return pedantic_non_lvalue (arg0);
7039
7040       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
7041          over COND_EXPR in cases such as floating point comparisons.  */
7042       if (integer_zerop (TREE_OPERAND (t, 1))
7043           && integer_onep (TREE_OPERAND (t, 2))
7044           && truth_value_p (TREE_CODE (arg0)))
7045         return pedantic_non_lvalue (convert (type,
7046                                              invert_truthvalue (arg0)));
7047
7048       /* Look for expressions of the form A & 2 ? 2 : 0.  The result of this
7049          operation is simply A & 2.  */
7050
7051       if (integer_zerop (TREE_OPERAND (t, 2))
7052           && TREE_CODE (arg0) == NE_EXPR
7053           && integer_zerop (TREE_OPERAND (arg0, 1))
7054           && integer_pow2p (arg1)
7055           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
7056           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
7057                               arg1, 1))
7058         return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
7059
7060       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
7061       if (integer_zerop (TREE_OPERAND (t, 2))
7062           && truth_value_p (TREE_CODE (arg0))
7063           && truth_value_p (TREE_CODE (arg1)))
7064         return pedantic_non_lvalue (fold (build (TRUTH_ANDIF_EXPR, type,
7065                                                  arg0, arg1)));
7066
7067       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
7068       if (integer_onep (TREE_OPERAND (t, 2))
7069           && truth_value_p (TREE_CODE (arg0))
7070           && truth_value_p (TREE_CODE (arg1)))
7071         {
7072           /* Only perform transformation if ARG0 is easily inverted.  */
7073           tem = invert_truthvalue (arg0);
7074           if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
7075             return pedantic_non_lvalue (fold (build (TRUTH_ORIF_EXPR, type,
7076                                                      tem, arg1)));
7077         }
7078
7079       return t;
7080
7081     case COMPOUND_EXPR:
7082       /* When pedantic, a compound expression can be neither an lvalue
7083          nor an integer constant expression.  */
7084       if (TREE_SIDE_EFFECTS (arg0) || pedantic)
7085         return t;
7086       /* Don't let (0, 0) be null pointer constant.  */
7087       if (integer_zerop (arg1))
7088         return build1 (NOP_EXPR, type, arg1);
7089       return convert (type, arg1);
7090
7091     case COMPLEX_EXPR:
7092       if (wins)
7093         return build_complex (type, arg0, arg1);
7094       return t;
7095
7096     case REALPART_EXPR:
7097       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7098         return t;
7099       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7100         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7101                                  TREE_OPERAND (arg0, 1));
7102       else if (TREE_CODE (arg0) == COMPLEX_CST)
7103         return TREE_REALPART (arg0);
7104       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7105         return fold (build (TREE_CODE (arg0), type,
7106                             fold (build1 (REALPART_EXPR, type,
7107                                           TREE_OPERAND (arg0, 0))),
7108                             fold (build1 (REALPART_EXPR,
7109                                           type, TREE_OPERAND (arg0, 1)))));
7110       return t;
7111
7112     case IMAGPART_EXPR:
7113       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7114         return convert (type, integer_zero_node);
7115       else if (TREE_CODE (arg0) == COMPLEX_EXPR)
7116         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7117                                  TREE_OPERAND (arg0, 0));
7118       else if (TREE_CODE (arg0) == COMPLEX_CST)
7119         return TREE_IMAGPART (arg0);
7120       else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7121         return fold (build (TREE_CODE (arg0), type,
7122                             fold (build1 (IMAGPART_EXPR, type,
7123                                           TREE_OPERAND (arg0, 0))),
7124                             fold (build1 (IMAGPART_EXPR, type,
7125                                           TREE_OPERAND (arg0, 1)))));
7126       return t;
7127
7128       /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
7129          appropriate.  */
7130     case CLEANUP_POINT_EXPR:
7131       if (! has_cleanups (arg0))
7132         return TREE_OPERAND (t, 0);
7133
7134       {
7135         enum tree_code code0 = TREE_CODE (arg0);
7136         int kind0 = TREE_CODE_CLASS (code0);
7137         tree arg00 = TREE_OPERAND (arg0, 0);
7138         tree arg01;
7139
7140         if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
7141           return fold (build1 (code0, type,
7142                                fold (build1 (CLEANUP_POINT_EXPR,
7143                                              TREE_TYPE (arg00), arg00))));
7144
7145         if (kind0 == '<' || kind0 == '2'
7146             || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
7147             || code0 == TRUTH_AND_EXPR   || code0 == TRUTH_OR_EXPR
7148             || code0 == TRUTH_XOR_EXPR)
7149           {
7150             arg01 = TREE_OPERAND (arg0, 1);
7151
7152             if (TREE_CONSTANT (arg00)
7153                 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
7154                     && ! has_cleanups (arg00)))
7155               return fold (build (code0, type, arg00,
7156                                   fold (build1 (CLEANUP_POINT_EXPR,
7157                                                 TREE_TYPE (arg01), arg01))));
7158
7159             if (TREE_CONSTANT (arg01))
7160               return fold (build (code0, type,
7161                                   fold (build1 (CLEANUP_POINT_EXPR,
7162                                                 TREE_TYPE (arg00), arg00)),
7163                                   arg01));
7164           }
7165
7166         return t;
7167       }
7168
7169     case CALL_EXPR:
7170       /* Check for a built-in function.  */
7171       if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
7172           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))
7173               == FUNCTION_DECL)
7174           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)))
7175         {
7176           tree tmp = fold_builtin (expr);
7177           if (tmp)
7178             return tmp;
7179         }
7180       return t;
7181
7182     default:
7183       return t;
7184     } /* switch (code) */
7185 }
7186
7187 /* Determine if first argument is a multiple of second argument.  Return 0 if
7188    it is not, or we cannot easily determined it to be.
7189
7190    An example of the sort of thing we care about (at this point; this routine
7191    could surely be made more general, and expanded to do what the *_DIV_EXPR's
7192    fold cases do now) is discovering that
7193
7194      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7195
7196    is a multiple of
7197
7198      SAVE_EXPR (J * 8)
7199
7200    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7201
7202    This code also handles discovering that
7203
7204      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7205
7206    is a multiple of 8 so we don't have to worry about dealing with a
7207    possible remainder.
7208
7209    Note that we *look* inside a SAVE_EXPR only to determine how it was
7210    calculated; it is not safe for fold to do much of anything else with the
7211    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7212    at run time.  For example, the latter example above *cannot* be implemented
7213    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7214    evaluation time of the original SAVE_EXPR is not necessarily the same at
7215    the time the new expression is evaluated.  The only optimization of this
7216    sort that would be valid is changing
7217
7218      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7219
7220    divided by 8 to
7221
7222      SAVE_EXPR (I) * SAVE_EXPR (J)
7223
7224    (where the same SAVE_EXPR (J) is used in the original and the
7225    transformed version).  */
7226
7227 static int
7228 multiple_of_p (type, top, bottom)
7229      tree type;
7230      tree top;
7231      tree bottom;
7232 {
7233   if (operand_equal_p (top, bottom, 0))
7234     return 1;
7235
7236   if (TREE_CODE (type) != INTEGER_TYPE)
7237     return 0;
7238
7239   switch (TREE_CODE (top))
7240     {
7241     case MULT_EXPR:
7242       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7243               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7244
7245     case PLUS_EXPR:
7246     case MINUS_EXPR:
7247       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
7248               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
7249
7250     case LSHIFT_EXPR:
7251       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
7252         {
7253           tree op1, t1;
7254
7255           op1 = TREE_OPERAND (top, 1);
7256           /* const_binop may not detect overflow correctly,
7257              so check for it explicitly here.  */
7258           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
7259               > TREE_INT_CST_LOW (op1)
7260               && TREE_INT_CST_HIGH (op1) == 0
7261               && 0 != (t1 = convert (type,
7262                                      const_binop (LSHIFT_EXPR, size_one_node,
7263                                                   op1, 0)))
7264               && ! TREE_OVERFLOW (t1))
7265             return multiple_of_p (type, t1, bottom);
7266         }
7267       return 0;
7268
7269     case NOP_EXPR:
7270       /* Can't handle conversions from non-integral or wider integral type.  */
7271       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
7272           || (TYPE_PRECISION (type)
7273               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
7274         return 0;
7275
7276       /* .. fall through ...  */
7277
7278     case SAVE_EXPR:
7279       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
7280
7281     case INTEGER_CST:
7282       if (TREE_CODE (bottom) != INTEGER_CST
7283           || (TREE_UNSIGNED (type)
7284               && (tree_int_cst_sgn (top) < 0
7285                   || tree_int_cst_sgn (bottom) < 0)))
7286         return 0;
7287       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
7288                                          top, bottom, 0));
7289
7290     default:
7291       return 0;
7292     }
7293 }
7294
7295 /* Return true if `t' is known to be non-negative.  */
7296
7297 int
7298 tree_expr_nonnegative_p (t)
7299      tree t;
7300 {
7301   switch (TREE_CODE (t))
7302     {
7303     case ABS_EXPR:
7304     case FFS_EXPR:
7305       return 1;
7306     case INTEGER_CST:
7307       return tree_int_cst_sgn (t) >= 0;
7308     case TRUNC_DIV_EXPR:
7309     case CEIL_DIV_EXPR:
7310     case FLOOR_DIV_EXPR:
7311     case ROUND_DIV_EXPR:
7312       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7313         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7314     case TRUNC_MOD_EXPR:
7315     case CEIL_MOD_EXPR:
7316     case FLOOR_MOD_EXPR:
7317     case ROUND_MOD_EXPR:
7318       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7319     case COND_EXPR:
7320       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
7321         && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
7322     case COMPOUND_EXPR:
7323       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7324     case MIN_EXPR:
7325       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7326         && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7327     case MAX_EXPR:
7328       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
7329         || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7330     case MODIFY_EXPR:
7331       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7332     case BIND_EXPR:
7333       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
7334     case SAVE_EXPR:
7335       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7336     case NON_LVALUE_EXPR:
7337       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
7338     case RTL_EXPR:
7339       return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t));
7340
7341     default:
7342       if (truth_value_p (TREE_CODE (t)))
7343         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
7344         return 1;
7345       else
7346         /* We don't know sign of `t', so be conservative and return false.  */
7347         return 0;
7348     }
7349 }
7350
7351 /* Return true if `r' is known to be non-negative.
7352    Only handles constants at the moment.  */
7353
7354 int
7355 rtl_expr_nonnegative_p (r)
7356      rtx r;
7357 {
7358   switch (GET_CODE (r))
7359     {
7360     case CONST_INT:
7361       return INTVAL (r) >= 0;
7362
7363     case CONST_DOUBLE:
7364       if (GET_MODE (r) == VOIDmode)
7365         return CONST_DOUBLE_HIGH (r) >= 0;
7366       return 0;
7367
7368     case CONST_VECTOR:
7369       {
7370         int units, i;
7371         rtx elt;
7372
7373         units = CONST_VECTOR_NUNITS (r);
7374
7375         for (i = 0; i < units; ++i)
7376           {
7377             elt = CONST_VECTOR_ELT (r, i);
7378             if (!rtl_expr_nonnegative_p (elt))
7379               return 0;
7380           }
7381
7382         return 1;
7383       }
7384
7385     case SYMBOL_REF:
7386     case LABEL_REF:
7387       /* These are always nonnegative.  */
7388       return 1;
7389
7390     default:
7391       return 0;
7392     }
7393 }
7394
7395 #include "gt-fold-const.h"