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