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, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, 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, an overflowable flag and prior
  43    overflow indicators.  It forces the value to fit the type and sets
  44    TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.  */
  45
  46 #include "config.h"
  47 #include "system.h"
  48 #include "coretypes.h"
  49 #include "tm.h"
  50 #include "flags.h"
  51 #include "tree.h"
  52 #include "real.h"
  53 #include "rtl.h"
  54 #include "expr.h"
  55 #include "tm_p.h"
  56 #include "toplev.h"
  57 #include "ggc.h"
  58 #include "hashtab.h"
  59 #include "langhooks.h"
  60 #include "md5.h"
  61
  62 /* Non-zero if we are folding constants inside an initializer; zero
  63    otherwise.  */
  64 int folding_initializer = 0;
  65
  66 /* The following constants represent a bit based encoding of GCC's
  67    comparison operators.  This encoding simplifies transformations
  68    on relational comparison operators, such as AND and OR.  */
  69 enum comparison_code {
  70   COMPCODE_FALSE = 0,
  71   COMPCODE_LT = 1,
  72   COMPCODE_EQ = 2,
  73   COMPCODE_LE = 3,
  74   COMPCODE_GT = 4,
  75   COMPCODE_LTGT = 5,
  76   COMPCODE_GE = 6,
  77   COMPCODE_ORD = 7,
  78   COMPCODE_UNORD = 8,
  79   COMPCODE_UNLT = 9,
  80   COMPCODE_UNEQ = 10,
  81   COMPCODE_UNLE = 11,
  82   COMPCODE_UNGT = 12,
  83   COMPCODE_NE = 13,
  84   COMPCODE_UNGE = 14,
  85   COMPCODE_TRUE = 15
  86 };
  87
  88 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
  89 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
  90 static bool negate_mathfn_p (enum built_in_function);
  91 static bool negate_expr_p (tree);
  92 static tree negate_expr (tree);
  93 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
  94 static tree associate_trees (tree, tree, enum tree_code, tree);
  95 static tree const_binop (enum tree_code, tree, tree, int);
  96 static enum comparison_code comparison_to_compcode (enum tree_code);
  97 static enum tree_code compcode_to_comparison (enum comparison_code);
  98 static tree combine_comparisons (enum tree_code, enum tree_code,
  99                                  enum tree_code, tree, tree, tree);
 100 static int truth_value_p (enum tree_code);
 101 static int operand_equal_for_comparison_p (tree, tree, tree);
 102 static int twoval_comparison_p (tree, tree *, tree *, int *);
 103 static tree eval_subst (tree, tree, tree, tree, tree);
 104 static tree pedantic_omit_one_operand (tree, tree, tree);
 105 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
 106 static tree make_bit_field_ref (tree, tree, int, int, int);
 107 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
 108 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
 109                                     enum machine_mode *, int *, int *,
 110                                     tree *, tree *);
 111 static int all_ones_mask_p (tree, int);
 112 static tree sign_bit_p (tree, tree);
 113 static int simple_operand_p (tree);
 114 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 115 static tree range_predecessor (tree);
 116 static tree range_successor (tree);
 117 static tree make_range (tree, int *, tree *, tree *);
 118 static tree build_range_check (tree, tree, int, tree, tree);
 119 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
 120                          tree);
 121 static tree fold_range_test (enum tree_code, tree, tree, tree);
 122 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
 123 static tree unextend (tree, int, int, tree);
 124 static tree fold_truthop (enum tree_code, tree, tree, tree);
 125 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
 126 static tree extract_muldiv (tree, tree, enum tree_code, tree);
 127 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree);
 128 static int multiple_of_p (tree, tree, tree);
 129 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
 130                                                  tree, tree,
 131                                                  tree, tree, int);
 132 static bool fold_real_zero_addition_p (tree, tree, int);
 133 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
 134                                  tree, tree, tree);
 135 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
 136 static tree fold_div_compare (enum tree_code, tree, tree, tree);
 137 static bool reorder_operands_p (tree, tree);
 138 static tree fold_negate_const (tree, tree);
 139 static tree fold_not_const (tree, tree);
 140 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 141 static int native_encode_expr (tree, unsigned char *, int);
 142 static tree native_interpret_expr (tree, unsigned char *, int);
 143
 144
 145 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 146    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 147    and SUM1.  Then this yields nonzero if overflow occurred during the
 148    addition.
 149
 150    Overflow occurs if A and B have the same sign, but A and SUM differ in
 151    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 152    sign.  */
 153 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 154 \f
 155 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
 156    We do that by representing the two-word integer in 4 words, with only
 157    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
 158    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
 159
 160 #define LOWPART(x) \
 161   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
 162 #define HIGHPART(x) \
 163   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
 164 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
 165
 166 /* Unpack a two-word integer into 4 words.
 167    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
 168    WORDS points to the array of HOST_WIDE_INTs.  */
 169
 170 static void
 171 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
 172 {
 173   words[0] = LOWPART (low);
 174   words[1] = HIGHPART (low);
 175   words[2] = LOWPART (hi);
 176   words[3] = HIGHPART (hi);
 177 }
 178
 179 /* Pack an array of 4 words into a two-word integer.
 180    WORDS points to the array of words.
 181    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
 182
 183 static void
 184 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
 185         HOST_WIDE_INT *hi)
 186 {
 187   *low = words[0] + words[1] * BASE;
 188   *hi = words[2] + words[3] * BASE;
 189 }
 190 \f
 191 /* T is an INT_CST node.  OVERFLOWABLE indicates if we are interested
 192    in overflow of the value, when >0 we are only interested in signed
 193    overflow, for <0 we are interested in any overflow.  OVERFLOWED
 194    indicates whether overflow has already occurred.  CONST_OVERFLOWED
 195    indicates whether constant overflow has already occurred.  We force
 196    T's value to be within range of T's type (by setting to 0 or 1 all
 197    the bits outside the type's range).  We set TREE_OVERFLOWED if,
 198         OVERFLOWED is nonzero,
 199         or OVERFLOWABLE is >0 and signed overflow occurs
 200         or OVERFLOWABLE is <0 and any overflow occurs
 201    We set TREE_CONSTANT_OVERFLOWED if,
 202         CONST_OVERFLOWED is nonzero
 203         or we set TREE_OVERFLOWED.
 204   We return either the original T, or a copy.  */
 205
 206 tree
 207 force_fit_type (tree t, int overflowable,
 208                 bool overflowed, bool overflowed_const)
 209 {
 210   unsigned HOST_WIDE_INT low;
 211   HOST_WIDE_INT high;
 212   unsigned int prec;
 213   int sign_extended_type;
 214
 215   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 216
 217   low = TREE_INT_CST_LOW (t);
 218   high = TREE_INT_CST_HIGH (t);
 219
 220   if (POINTER_TYPE_P (TREE_TYPE (t))
 221       || TREE_CODE (TREE_TYPE (t)) == OFFSET_TYPE)
 222     prec = POINTER_SIZE;
 223   else
 224     prec = TYPE_PRECISION (TREE_TYPE (t));
 225   /* Size types *are* sign extended.  */
 226   sign_extended_type = (!TYPE_UNSIGNED (TREE_TYPE (t))
 227                         || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
 228                             && TYPE_IS_SIZETYPE (TREE_TYPE (t))));
 229
 230   /* First clear all bits that are beyond the type's precision.  */
 231
 232   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
 233     ;
 234   else if (prec > HOST_BITS_PER_WIDE_INT)
 235     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 236   else
 237     {
 238       high = 0;
 239       if (prec < HOST_BITS_PER_WIDE_INT)
 240         low &= ~((HOST_WIDE_INT) (-1) << prec);
 241     }
 242
 243   if (!sign_extended_type)
 244     /* No sign extension */;
 245   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
 246     /* Correct width already.  */;
 247   else if (prec > HOST_BITS_PER_WIDE_INT)
 248     {
 249       /* Sign extend top half? */
 250       if (high & ((unsigned HOST_WIDE_INT)1
 251                   << (prec - HOST_BITS_PER_WIDE_INT - 1)))
 252         high |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
 253     }
 254   else if (prec == HOST_BITS_PER_WIDE_INT)
 255     {
 256       if ((HOST_WIDE_INT)low < 0)
 257         high = -1;
 258     }
 259   else
 260     {
 261       /* Sign extend bottom half? */
 262       if (low & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
 263         {
 264           high = -1;
 265           low |= (HOST_WIDE_INT)(-1) << prec;
 266         }
 267     }
 268
 269   /* If the value changed, return a new node.  */
 270   if (overflowed || overflowed_const
 271       || low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
 272     {
 273       t = build_int_cst_wide (TREE_TYPE (t), low, high);
 274
 275       if (overflowed
 276           || overflowable < 0
 277           || (overflowable > 0 && sign_extended_type))
 278         {
 279           t = copy_node (t);
 280           TREE_OVERFLOW (t) = 1;
 281           TREE_CONSTANT_OVERFLOW (t) = 1;
 282         }
 283       else if (overflowed_const)
 284         {
 285           t = copy_node (t);
 286           TREE_CONSTANT_OVERFLOW (t) = 1;
 287         }
 288     }
 289
 290   return t;
 291 }
 292 \f
 293 /* Add two doubleword integers with doubleword result.
 294    Return nonzero if the operation overflows according to UNSIGNED_P.
 295    Each argument is given as two `HOST_WIDE_INT' pieces.
 296    One argument is L1 and H1; the other, L2 and H2.
 297    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 298
 299 int
 300 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 301                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
 302                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
 303                       bool unsigned_p)
 304 {
 305   unsigned HOST_WIDE_INT l;
 306   HOST_WIDE_INT h;
 307
 308   l = l1 + l2;
 309   h = h1 + h2 + (l < l1);
 310
 311   *lv = l;
 312   *hv = h;
 313
 314   if (unsigned_p)
 315     return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
 316   else
 317     return OVERFLOW_SUM_SIGN (h1, h2, h);
 318 }
 319
 320 /* Negate a doubleword integer with doubleword result.
 321    Return nonzero if the operation overflows, assuming it's signed.
 322    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
 323    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 324
 325 int
 326 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 327             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 328 {
 329   if (l1 == 0)
 330     {
 331       *lv = 0;
 332       *hv = - h1;
 333       return (*hv & h1) < 0;
 334     }
 335   else
 336     {
 337       *lv = -l1;
 338       *hv = ~h1;
 339       return 0;
 340     }
 341 }
 342 \f
 343 /* Multiply two doubleword integers with doubleword result.
 344    Return nonzero if the operation overflows according to UNSIGNED_P.
 345    Each argument is given as two `HOST_WIDE_INT' pieces.
 346    One argument is L1 and H1; the other, L2 and H2.
 347    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 348
 349 int
 350 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 351                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
 352                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
 353                       bool unsigned_p)
 354 {
 355   HOST_WIDE_INT arg1[4];
 356   HOST_WIDE_INT arg2[4];
 357   HOST_WIDE_INT prod[4 * 2];
 358   unsigned HOST_WIDE_INT carry;
 359   int i, j, k;
 360   unsigned HOST_WIDE_INT toplow, neglow;
 361   HOST_WIDE_INT tophigh, neghigh;
 362
 363   encode (arg1, l1, h1);
 364   encode (arg2, l2, h2);
 365
 366   memset (prod, 0, sizeof prod);
 367
 368   for (i = 0; i < 4; i++)
 369     {
 370       carry = 0;
 371       for (j = 0; j < 4; j++)
 372         {
 373           k = i + j;
 374           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
 375           carry += arg1[i] * arg2[j];
 376           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
 377           carry += prod[k];
 378           prod[k] = LOWPART (carry);
 379           carry = HIGHPART (carry);
 380         }
 381       prod[i + 4] = carry;
 382     }
 383
 384   decode (prod, lv, hv);
 385   decode (prod + 4, &toplow, &tophigh);
 386
 387   /* Unsigned overflow is immediate.  */
 388   if (unsigned_p)
 389     return (toplow | tophigh) != 0;
 390
 391   /* Check for signed overflow by calculating the signed representation of the
 392      top half of the result; it should agree with the low half's sign bit.  */
 393   if (h1 < 0)
 394     {
 395       neg_double (l2, h2, &neglow, &neghigh);
 396       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 397     }
 398   if (h2 < 0)
 399     {
 400       neg_double (l1, h1, &neglow, &neghigh);
 401       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
 402     }
 403   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
 404 }
 405 \f
 406 /* Shift the doubleword integer in L1, H1 left by COUNT places
 407    keeping only PREC bits of result.
 408    Shift right if COUNT is negative.
 409    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 410    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 411
 412 void
 413 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 414                HOST_WIDE_INT count, unsigned int prec,
 415                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
 416 {
 417   unsigned HOST_WIDE_INT signmask;
 418
 419   if (count < 0)
 420     {
 421       rshift_double (l1, h1, -count, prec, lv, hv, arith);
 422       return;
 423     }
 424
 425   if (SHIFT_COUNT_TRUNCATED)
 426     count %= prec;
 427
 428   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 429     {
 430       /* Shifting by the host word size is undefined according to the
 431          ANSI standard, so we must handle this as a special case.  */
 432       *hv = 0;
 433       *lv = 0;
 434     }
 435   else if (count >= HOST_BITS_PER_WIDE_INT)
 436     {
 437       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
 438       *lv = 0;
 439     }
 440   else
 441     {
 442       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
 443              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
 444       *lv = l1 << count;
 445     }
 446
 447   /* Sign extend all bits that are beyond the precision.  */
 448
 449   signmask = -((prec > HOST_BITS_PER_WIDE_INT
 450                 ? ((unsigned HOST_WIDE_INT) *hv
 451                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
 452                 : (*lv >> (prec - 1))) & 1);
 453
 454   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
 455     ;
 456   else if (prec >= HOST_BITS_PER_WIDE_INT)
 457     {
 458       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 459       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
 460     }
 461   else
 462     {
 463       *hv = signmask;
 464       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
 465       *lv |= signmask << prec;
 466     }
 467 }
 468
 469 /* Shift the doubleword integer in L1, H1 right by COUNT places
 470    keeping only PREC bits of result.  COUNT must be positive.
 471    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
 472    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 473
 474 void
 475 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 476                HOST_WIDE_INT count, unsigned int prec,
 477                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
 478                int arith)
 479 {
 480   unsigned HOST_WIDE_INT signmask;
 481
 482   signmask = (arith
 483               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
 484               : 0);
 485
 486   if (SHIFT_COUNT_TRUNCATED)
 487     count %= prec;
 488
 489   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
 490     {
 491       /* Shifting by the host word size is undefined according to the
 492          ANSI standard, so we must handle this as a special case.  */
 493       *hv = 0;
 494       *lv = 0;
 495     }
 496   else if (count >= HOST_BITS_PER_WIDE_INT)
 497     {
 498       *hv = 0;
 499       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
 500     }
 501   else
 502     {
 503       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
 504       *lv = ((l1 >> count)
 505              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
 506     }
 507
 508   /* Zero / sign extend all bits that are beyond the precision.  */
 509
 510   if (count >= (HOST_WIDE_INT)prec)
 511     {
 512       *hv = signmask;
 513       *lv = signmask;
 514     }
 515   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
 516     ;
 517   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
 518     {
 519       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
 520       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
 521     }
 522   else
 523     {
 524       *hv = signmask;
 525       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
 526       *lv |= signmask << (prec - count);
 527     }
 528 }
 529 \f
 530 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 531    keeping only PREC bits of result.
 532    Rotate right if COUNT is negative.
 533    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 534
 535 void
 536 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 537                 HOST_WIDE_INT count, unsigned int prec,
 538                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 539 {
 540   unsigned HOST_WIDE_INT s1l, s2l;
 541   HOST_WIDE_INT s1h, s2h;
 542
 543   count %= prec;
 544   if (count < 0)
 545     count += prec;
 546
 547   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 548   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 549   *lv = s1l | s2l;
 550   *hv = s1h | s2h;
 551 }
 552
 553 /* Rotate the doubleword integer in L1, H1 left by COUNT places
 554    keeping only PREC bits of result.  COUNT must be positive.
 555    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
 556
 557 void
 558 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 559                 HOST_WIDE_INT count, unsigned int prec,
 560                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
 561 {
 562   unsigned HOST_WIDE_INT s1l, s2l;
 563   HOST_WIDE_INT s1h, s2h;
 564
 565   count %= prec;
 566   if (count < 0)
 567     count += prec;
 568
 569   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
 570   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
 571   *lv = s1l | s2l;
 572   *hv = s1h | s2h;
 573 }
 574 \f
 575 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
 576    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
 577    CODE is a tree code for a kind of division, one of
 578    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
 579    or EXACT_DIV_EXPR
 580    It controls how the quotient is rounded to an integer.
 581    Return nonzero if the operation overflows.
 582    UNS nonzero says do unsigned division.  */
 583
 584 int
 585 div_and_round_double (enum tree_code code, int uns,
 586                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
 587                       HOST_WIDE_INT hnum_orig,
 588                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
 589                       HOST_WIDE_INT hden_orig,
 590                       unsigned HOST_WIDE_INT *lquo,
 591                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
 592                       HOST_WIDE_INT *hrem)
 593 {
 594   int quo_neg = 0;
 595   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
 596   HOST_WIDE_INT den[4], quo[4];
 597   int i, j;
 598   unsigned HOST_WIDE_INT work;
 599   unsigned HOST_WIDE_INT carry = 0;
 600   unsigned HOST_WIDE_INT lnum = lnum_orig;
 601   HOST_WIDE_INT hnum = hnum_orig;
 602   unsigned HOST_WIDE_INT lden = lden_orig;
 603   HOST_WIDE_INT hden = hden_orig;
 604   int overflow = 0;
 605
 606   if (hden == 0 && lden == 0)
 607     overflow = 1, lden = 1;
 608
 609   /* Calculate quotient sign and convert operands to unsigned.  */
 610   if (!uns)
 611     {
 612       if (hnum < 0)
 613         {
 614           quo_neg = ~ quo_neg;
 615           /* (minimum integer) / (-1) is the only overflow case.  */
 616           if (neg_double (lnum, hnum, &lnum, &hnum)
 617               && ((HOST_WIDE_INT) lden & hden) == -1)
 618             overflow = 1;
 619         }
 620       if (hden < 0)
 621         {
 622           quo_neg = ~ quo_neg;
 623           neg_double (lden, hden, &lden, &hden);
 624         }
 625     }
 626
 627   if (hnum == 0 && hden == 0)
 628     {                           /* single precision */
 629       *hquo = *hrem = 0;
 630       /* This unsigned division rounds toward zero.  */
 631       *lquo = lnum / lden;
 632       goto finish_up;
 633     }
 634
 635   if (hnum == 0)
 636     {                           /* trivial case: dividend < divisor */
 637       /* hden != 0 already checked.  */
 638       *hquo = *lquo = 0;
 639       *hrem = hnum;
 640       *lrem = lnum;
 641       goto finish_up;
 642     }
 643
 644   memset (quo, 0, sizeof quo);
 645
 646   memset (num, 0, sizeof num);  /* to zero 9th element */
 647   memset (den, 0, sizeof den);
 648
 649   encode (num, lnum, hnum);
 650   encode (den, lden, hden);
 651
 652   /* Special code for when the divisor < BASE.  */
 653   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
 654     {
 655       /* hnum != 0 already checked.  */
 656       for (i = 4 - 1; i >= 0; i--)
 657         {
 658           work = num[i] + carry * BASE;
 659           quo[i] = work / lden;
 660           carry = work % lden;
 661         }
 662     }
 663   else
 664     {
 665       /* Full double precision division,
 666          with thanks to Don Knuth's "Seminumerical Algorithms".  */
 667       int num_hi_sig, den_hi_sig;
 668       unsigned HOST_WIDE_INT quo_est, scale;
 669
 670       /* Find the highest nonzero divisor digit.  */
 671       for (i = 4 - 1;; i--)
 672         if (den[i] != 0)
 673           {
 674             den_hi_sig = i;
 675             break;
 676           }
 677
 678       /* Insure that the first digit of the divisor is at least BASE/2.
 679          This is required by the quotient digit estimation algorithm.  */
 680
 681       scale = BASE / (den[den_hi_sig] + 1);
 682       if (scale > 1)
 683         {               /* scale divisor and dividend */
 684           carry = 0;
 685           for (i = 0; i <= 4 - 1; i++)
 686             {
 687               work = (num[i] * scale) + carry;
 688               num[i] = LOWPART (work);
 689               carry = HIGHPART (work);
 690             }
 691
 692           num[4] = carry;
 693           carry = 0;
 694           for (i = 0; i <= 4 - 1; i++)
 695             {
 696               work = (den[i] * scale) + carry;
 697               den[i] = LOWPART (work);
 698               carry = HIGHPART (work);
 699               if (den[i] != 0) den_hi_sig = i;
 700             }
 701         }
 702
 703       num_hi_sig = 4;
 704
 705       /* Main loop */
 706       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
 707         {
 708           /* Guess the next quotient digit, quo_est, by dividing the first
 709              two remaining dividend digits by the high order quotient digit.
 710              quo_est is never low and is at most 2 high.  */
 711           unsigned HOST_WIDE_INT tmp;
 712
 713           num_hi_sig = i + den_hi_sig + 1;
 714           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
 715           if (num[num_hi_sig] != den[den_hi_sig])
 716             quo_est = work / den[den_hi_sig];
 717           else
 718             quo_est = BASE - 1;
 719
 720           /* Refine quo_est so it's usually correct, and at most one high.  */
 721           tmp = work - quo_est * den[den_hi_sig];
 722           if (tmp < BASE
 723               && (den[den_hi_sig - 1] * quo_est
 724                   > (tmp * BASE + num[num_hi_sig - 2])))
 725             quo_est--;
 726
 727           /* Try QUO_EST as the quotient digit, by multiplying the
 728              divisor by QUO_EST and subtracting from the remaining dividend.
 729              Keep in mind that QUO_EST is the I - 1st digit.  */
 730
 731           carry = 0;
 732           for (j = 0; j <= den_hi_sig; j++)
 733             {
 734               work = quo_est * den[j] + carry;
 735               carry = HIGHPART (work);
 736               work = num[i + j] - LOWPART (work);
 737               num[i + j] = LOWPART (work);
 738               carry += HIGHPART (work) != 0;
 739             }
 740
 741           /* If quo_est was high by one, then num[i] went negative and
 742              we need to correct things.  */
 743           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
 744             {
 745               quo_est--;
 746               carry = 0;                /* add divisor back in */
 747               for (j = 0; j <= den_hi_sig; j++)
 748                 {
 749                   work = num[i + j] + den[j] + carry;
 750                   carry = HIGHPART (work);
 751                   num[i + j] = LOWPART (work);
 752                 }
 753
 754               num [num_hi_sig] += carry;
 755             }
 756
 757           /* Store the quotient digit.  */
 758           quo[i] = quo_est;
 759         }
 760     }
 761
 762   decode (quo, lquo, hquo);
 763
 764  finish_up:
 765   /* If result is negative, make it so.  */
 766   if (quo_neg)
 767     neg_double (*lquo, *hquo, lquo, hquo);
 768
 769   /* Compute trial remainder:  rem = num - (quo * den)  */
 770   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 771   neg_double (*lrem, *hrem, lrem, hrem);
 772   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 773
 774   switch (code)
 775     {
 776     case TRUNC_DIV_EXPR:
 777     case TRUNC_MOD_EXPR:        /* round toward zero */
 778     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
 779       return overflow;
 780
 781     case FLOOR_DIV_EXPR:
 782     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
 783       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
 784         {
 785           /* quo = quo - 1;  */
 786           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
 787                       lquo, hquo);
 788         }
 789       else
 790         return overflow;
 791       break;
 792
 793     case CEIL_DIV_EXPR:
 794     case CEIL_MOD_EXPR:         /* round toward positive infinity */
 795       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
 796         {
 797           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 798                       lquo, hquo);
 799         }
 800       else
 801         return overflow;
 802       break;
 803
 804     case ROUND_DIV_EXPR:
 805     case ROUND_MOD_EXPR:        /* round to closest integer */
 806       {
 807         unsigned HOST_WIDE_INT labs_rem = *lrem;
 808         HOST_WIDE_INT habs_rem = *hrem;
 809         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
 810         HOST_WIDE_INT habs_den = hden, htwice;
 811
 812         /* Get absolute values.  */
 813         if (*hrem < 0)
 814           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
 815         if (hden < 0)
 816           neg_double (lden, hden, &labs_den, &habs_den);
 817
 818         /* If (2 * abs (lrem) >= abs (lden)) */
 819         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
 820                     labs_rem, habs_rem, &ltwice, &htwice);
 821
 822         if (((unsigned HOST_WIDE_INT) habs_den
 823              < (unsigned HOST_WIDE_INT) htwice)
 824             || (((unsigned HOST_WIDE_INT) habs_den
 825                  == (unsigned HOST_WIDE_INT) htwice)
 826                 && (labs_den < ltwice)))
 827           {
 828             if (*hquo < 0)
 829               /* quo = quo - 1;  */
 830               add_double (*lquo, *hquo,
 831                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
 832             else
 833               /* quo = quo + 1; */
 834               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
 835                           lquo, hquo);
 836           }
 837         else
 838           return overflow;
 839       }
 840       break;
 841
 842     default:
 843       gcc_unreachable ();
 844     }
 845
 846   /* Compute true remainder:  rem = num - (quo * den)  */
 847   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
 848   neg_double (*lrem, *hrem, lrem, hrem);
 849   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
 850   return overflow;
 851 }
 852
 853 /* If ARG2 divides ARG1 with zero remainder, carries out the division
 854    of type CODE and returns the quotient.
 855    Otherwise returns NULL_TREE.  */
 856
 857 static tree
 858 div_if_zero_remainder (enum tree_code code, tree arg1, tree arg2)
 859 {
 860   unsigned HOST_WIDE_INT int1l, int2l;
 861   HOST_WIDE_INT int1h, int2h;
 862   unsigned HOST_WIDE_INT quol, reml;
 863   HOST_WIDE_INT quoh, remh;
 864   tree type = TREE_TYPE (arg1);
 865   int uns = TYPE_UNSIGNED (type);
 866
 867   int1l = TREE_INT_CST_LOW (arg1);
 868   int1h = TREE_INT_CST_HIGH (arg1);
 869   int2l = TREE_INT_CST_LOW (arg2);
 870   int2h = TREE_INT_CST_HIGH (arg2);
 871
 872   div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
 873                         &quol, &quoh, &reml, &remh);
 874   if (remh != 0 || reml != 0)
 875     return NULL_TREE;
 876
 877   return build_int_cst_wide (type, quol, quoh);
 878 }
 879 \f
 880 /* Return true if the built-in mathematical function specified by CODE
 881    is odd, i.e. -f(x) == f(-x).  */
 882
 883 static bool
 884 negate_mathfn_p (enum built_in_function code)
 885 {
 886   switch (code)
 887     {
 888     CASE_FLT_FN (BUILT_IN_ASIN):
 889     CASE_FLT_FN (BUILT_IN_ASINH):
 890     CASE_FLT_FN (BUILT_IN_ATAN):
 891     CASE_FLT_FN (BUILT_IN_ATANH):
 892     CASE_FLT_FN (BUILT_IN_CBRT):
 893     CASE_FLT_FN (BUILT_IN_SIN):
 894     CASE_FLT_FN (BUILT_IN_SINH):
 895     CASE_FLT_FN (BUILT_IN_TAN):
 896     CASE_FLT_FN (BUILT_IN_TANH):
 897       return true;
 898
 899     default:
 900       break;
 901     }
 902   return false;
 903 }
 904
 905 /* Check whether we may negate an integer constant T without causing
 906    overflow.  */
 907
 908 bool
 909 may_negate_without_overflow_p (tree t)
 910 {
 911   unsigned HOST_WIDE_INT val;
 912   unsigned int prec;
 913   tree type;
 914
 915   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 916
 917   type = TREE_TYPE (t);
 918   if (TYPE_UNSIGNED (type))
 919     return false;
 920
 921   prec = TYPE_PRECISION (type);
 922   if (prec > HOST_BITS_PER_WIDE_INT)
 923     {
 924       if (TREE_INT_CST_LOW (t) != 0)
 925         return true;
 926       prec -= HOST_BITS_PER_WIDE_INT;
 927       val = TREE_INT_CST_HIGH (t);
 928     }
 929   else
 930     val = TREE_INT_CST_LOW (t);
 931   if (prec < HOST_BITS_PER_WIDE_INT)
 932     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 933   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
 934 }
 935
 936 /* Determine whether an expression T can be cheaply negated using
 937    the function negate_expr without introducing undefined overflow.  */
 938
 939 static bool
 940 negate_expr_p (tree t)
 941 {
 942   tree type;
 943
 944   if (t == 0)
 945     return false;
 946
 947   type = TREE_TYPE (t);
 948
 949   STRIP_SIGN_NOPS (t);
 950   switch (TREE_CODE (t))
 951     {
 952     case INTEGER_CST:
 953       if (TYPE_UNSIGNED (type)
 954           || (flag_wrapv && ! flag_trapv))
 955         return true;
 956
 957       /* Check that -CST will not overflow type.  */
 958       return may_negate_without_overflow_p (t);
 959     case BIT_NOT_EXPR:
 960        return INTEGRAL_TYPE_P (type)
 961               && (TYPE_UNSIGNED (type)
 962                   || (flag_wrapv && !flag_trapv));
 963
 964     case REAL_CST:
 965     case NEGATE_EXPR:
 966       return true;
 967
 968     case COMPLEX_CST:
 969       return negate_expr_p (TREE_REALPART (t))
 970              && negate_expr_p (TREE_IMAGPART (t));
 971
 972     case PLUS_EXPR:
 973       if (FLOAT_TYPE_P (type) && !flag_unsafe_math_optimizations)
 974         return false;
 975       /* -(A + B) -> (-B) - A.  */
 976       if (negate_expr_p (TREE_OPERAND (t, 1))
 977           && reorder_operands_p (TREE_OPERAND (t, 0),
 978                                  TREE_OPERAND (t, 1)))
 979         return true;
 980       /* -(A + B) -> (-A) - B.  */
 981       return negate_expr_p (TREE_OPERAND (t, 0));
 982
 983     case MINUS_EXPR:
 984       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
 985       return (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
 986              && reorder_operands_p (TREE_OPERAND (t, 0),
 987                                     TREE_OPERAND (t, 1));
 988
 989     case MULT_EXPR:
 990       if (TYPE_UNSIGNED (TREE_TYPE (t)))
 991         break;
 992
 993       /* Fall through.  */
 994
 995     case RDIV_EXPR:
 996       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
 997         return negate_expr_p (TREE_OPERAND (t, 1))
 998                || negate_expr_p (TREE_OPERAND (t, 0));
 999       break;
1000
1001     case TRUNC_DIV_EXPR:
1002     case ROUND_DIV_EXPR:
1003     case FLOOR_DIV_EXPR:
1004     case CEIL_DIV_EXPR:
1005     case EXACT_DIV_EXPR:
1006       if (TYPE_UNSIGNED (TREE_TYPE (t)) || flag_wrapv)
1007         break;
1008       return negate_expr_p (TREE_OPERAND (t, 1))
1009              || negate_expr_p (TREE_OPERAND (t, 0));
1010
1011     case NOP_EXPR:
1012       /* Negate -((double)float) as (double)(-float).  */
1013       if (TREE_CODE (type) == REAL_TYPE)
1014         {
1015           tree tem = strip_float_extensions (t);
1016           if (tem != t)
1017             return negate_expr_p (tem);
1018         }
1019       break;
1020
1021     case CALL_EXPR:
1022       /* Negate -f(x) as f(-x).  */
1023       if (negate_mathfn_p (builtin_mathfn_code (t)))
1024         return negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1)));
1025       break;
1026
1027     case RSHIFT_EXPR:
1028       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1029       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1030         {
1031           tree op1 = TREE_OPERAND (t, 1);
1032           if (TREE_INT_CST_HIGH (op1) == 0
1033               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1034                  == TREE_INT_CST_LOW (op1))
1035             return true;
1036         }
1037       break;
1038
1039     default:
1040       break;
1041     }
1042   return false;
1043 }
1044
1045 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
1046    simplification is possible.
1047    If negate_expr_p would return true for T, NULL_TREE will never be
1048    returned.  */
1049
1050 static tree
1051 fold_negate_expr (tree t)
1052 {
1053   tree type = TREE_TYPE (t);
1054   tree tem;
1055
1056   switch (TREE_CODE (t))
1057     {
1058     /* Convert - (~A) to A + 1.  */
1059     case BIT_NOT_EXPR:
1060       if (INTEGRAL_TYPE_P (type))
1061         return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
1062                             build_int_cst (type, 1));
1063       break;
1064
1065     case INTEGER_CST:
1066       tem = fold_negate_const (t, type);
1067       if (! TREE_OVERFLOW (tem)
1068           || TYPE_UNSIGNED (type)
1069           || ! flag_trapv)
1070         return tem;
1071       break;
1072
1073     case REAL_CST:
1074       tem = fold_negate_const (t, type);
1075       /* Two's complement FP formats, such as c4x, may overflow.  */
1076       if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
1077         return tem;
1078       break;
1079
1080     case COMPLEX_CST:
1081       {
1082         tree rpart = negate_expr (TREE_REALPART (t));
1083         tree ipart = negate_expr (TREE_IMAGPART (t));
1084
1085         if ((TREE_CODE (rpart) == REAL_CST
1086              && TREE_CODE (ipart) == REAL_CST)
1087             || (TREE_CODE (rpart) == INTEGER_CST
1088                 && TREE_CODE (ipart) == INTEGER_CST))
1089           return build_complex (type, rpart, ipart);
1090       }
1091       break;
1092
1093     case NEGATE_EXPR:
1094       return TREE_OPERAND (t, 0);
1095
1096     case PLUS_EXPR:
1097       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1098         {
1099           /* -(A + B) -> (-B) - A.  */
1100           if (negate_expr_p (TREE_OPERAND (t, 1))
1101               && reorder_operands_p (TREE_OPERAND (t, 0),
1102                                      TREE_OPERAND (t, 1)))
1103             {
1104               tem = negate_expr (TREE_OPERAND (t, 1));
1105               return fold_build2 (MINUS_EXPR, type,
1106                                   tem, TREE_OPERAND (t, 0));
1107             }
1108
1109           /* -(A + B) -> (-A) - B.  */
1110           if (negate_expr_p (TREE_OPERAND (t, 0)))
1111             {
1112               tem = negate_expr (TREE_OPERAND (t, 0));
1113               return fold_build2 (MINUS_EXPR, type,
1114                                   tem, TREE_OPERAND (t, 1));
1115             }
1116         }
1117       break;
1118
1119     case MINUS_EXPR:
1120       /* - (A - B) -> B - A  */
1121       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1122           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1123         return fold_build2 (MINUS_EXPR, type,
1124                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
1125       break;
1126
1127     case MULT_EXPR:
1128       if (TYPE_UNSIGNED (type))
1129         break;
1130
1131       /* Fall through.  */
1132
1133     case RDIV_EXPR:
1134       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
1135         {
1136           tem = TREE_OPERAND (t, 1);
1137           if (negate_expr_p (tem))
1138             return fold_build2 (TREE_CODE (t), type,
1139                                 TREE_OPERAND (t, 0), negate_expr (tem));
1140           tem = TREE_OPERAND (t, 0);
1141           if (negate_expr_p (tem))
1142             return fold_build2 (TREE_CODE (t), type,
1143                                 negate_expr (tem), TREE_OPERAND (t, 1));
1144         }
1145       break;
1146
1147     case TRUNC_DIV_EXPR:
1148     case ROUND_DIV_EXPR:
1149     case FLOOR_DIV_EXPR:
1150     case CEIL_DIV_EXPR:
1151     case EXACT_DIV_EXPR:
1152       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
1153         {
1154           tem = TREE_OPERAND (t, 1);
1155           if (negate_expr_p (tem))
1156             return fold_build2 (TREE_CODE (t), type,
1157                                 TREE_OPERAND (t, 0), negate_expr (tem));
1158           tem = TREE_OPERAND (t, 0);
1159           if (negate_expr_p (tem))
1160             return fold_build2 (TREE_CODE (t), type,
1161                                 negate_expr (tem), TREE_OPERAND (t, 1));
1162         }
1163       break;
1164
1165     case NOP_EXPR:
1166       /* Convert -((double)float) into (double)(-float).  */
1167       if (TREE_CODE (type) == REAL_TYPE)
1168         {
1169           tem = strip_float_extensions (t);
1170           if (tem != t && negate_expr_p (tem))
1171             return negate_expr (tem);
1172         }
1173       break;
1174
1175     case CALL_EXPR:
1176       /* Negate -f(x) as f(-x).  */
1177       if (negate_mathfn_p (builtin_mathfn_code (t))
1178           && negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1))))
1179         {
1180           tree fndecl, arg, arglist;
1181
1182           fndecl = get_callee_fndecl (t);
1183           arg = negate_expr (TREE_VALUE (TREE_OPERAND (t, 1)));
1184           arglist = build_tree_list (NULL_TREE, arg);
1185           return build_function_call_expr (fndecl, arglist);
1186         }
1187       break;
1188
1189     case RSHIFT_EXPR:
1190       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1191       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1192         {
1193           tree op1 = TREE_OPERAND (t, 1);
1194           if (TREE_INT_CST_HIGH (op1) == 0
1195               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1196                  == TREE_INT_CST_LOW (op1))
1197             {
1198               tree ntype = TYPE_UNSIGNED (type)
1199                            ? lang_hooks.types.signed_type (type)
1200                            : lang_hooks.types.unsigned_type (type);
1201               tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1202               temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1203               return fold_convert (type, temp);
1204             }
1205         }
1206       break;
1207
1208     default:
1209       break;
1210     }
1211
1212   return NULL_TREE;
1213 }
1214
1215 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
1216    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
1217    return NULL_TREE. */
1218
1219 static tree
1220 negate_expr (tree t)
1221 {
1222   tree type, tem;
1223
1224   if (t == NULL_TREE)
1225     return NULL_TREE;
1226
1227   type = TREE_TYPE (t);
1228   STRIP_SIGN_NOPS (t);
1229
1230   tem = fold_negate_expr (t);
1231   if (!tem)
1232     tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1233   return fold_convert (type, tem);
1234 }
1235 \f
1236 /* Split a tree IN into a constant, literal and variable parts that could be
1237    combined with CODE to make IN.  "constant" means an expression with
1238    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1239    commutative arithmetic operation.  Store the constant part into *CONP,
1240    the literal in *LITP and return the variable part.  If a part isn't
1241    present, set it to null.  If the tree does not decompose in this way,
1242    return the entire tree as the variable part and the other parts as null.
1243
1244    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1245    case, we negate an operand that was subtracted.  Except if it is a
1246    literal for which we use *MINUS_LITP instead.
1247
1248    If NEGATE_P is true, we are negating all of IN, again except a literal
1249    for which we use *MINUS_LITP instead.
1250
1251    If IN is itself a literal or constant, return it as appropriate.
1252
1253    Note that we do not guarantee that any of the three values will be the
1254    same type as IN, but they will have the same signedness and mode.  */
1255
1256 static tree
1257 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1258             tree *minus_litp, int negate_p)
1259 {
1260   tree var = 0;
1261
1262   *conp = 0;
1263   *litp = 0;
1264   *minus_litp = 0;
1265
1266   /* Strip any conversions that don't change the machine mode or signedness.  */
1267   STRIP_SIGN_NOPS (in);
1268
1269   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
1270     *litp = in;
1271   else if (TREE_CODE (in) == code
1272            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1273                /* We can associate addition and subtraction together (even
1274                   though the C standard doesn't say so) for integers because
1275                   the value is not affected.  For reals, the value might be
1276                   affected, so we can't.  */
1277                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1278                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1279     {
1280       tree op0 = TREE_OPERAND (in, 0);
1281       tree op1 = TREE_OPERAND (in, 1);
1282       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1283       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1284
1285       /* First see if either of the operands is a literal, then a constant.  */
1286       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
1287         *litp = op0, op0 = 0;
1288       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1289         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1290
1291       if (op0 != 0 && TREE_CONSTANT (op0))
1292         *conp = op0, op0 = 0;
1293       else if (op1 != 0 && TREE_CONSTANT (op1))
1294         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1295
1296       /* If we haven't dealt with either operand, this is not a case we can
1297          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
1298       if (op0 != 0 && op1 != 0)
1299         var = in;
1300       else if (op0 != 0)
1301         var = op0;
1302       else
1303         var = op1, neg_var_p = neg1_p;
1304
1305       /* Now do any needed negations.  */
1306       if (neg_litp_p)
1307         *minus_litp = *litp, *litp = 0;
1308       if (neg_conp_p)
1309         *conp = negate_expr (*conp);
1310       if (neg_var_p)
1311         var = negate_expr (var);
1312     }
1313   else if (TREE_CONSTANT (in))
1314     *conp = in;
1315   else
1316     var = in;
1317
1318   if (negate_p)
1319     {
1320       if (*litp)
1321         *minus_litp = *litp, *litp = 0;
1322       else if (*minus_litp)
1323         *litp = *minus_litp, *minus_litp = 0;
1324       *conp = negate_expr (*conp);
1325       var = negate_expr (var);
1326     }
1327
1328   return var;
1329 }
1330
1331 /* Re-associate trees split by the above function.  T1 and T2 are either
1332    expressions to associate or null.  Return the new expression, if any.  If
1333    we build an operation, do it in TYPE and with CODE.  */
1334
1335 static tree
1336 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1337 {
1338   if (t1 == 0)
1339     return t2;
1340   else if (t2 == 0)
1341     return t1;
1342
1343   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1344      try to fold this since we will have infinite recursion.  But do
1345      deal with any NEGATE_EXPRs.  */
1346   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1347       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1348     {
1349       if (code == PLUS_EXPR)
1350         {
1351           if (TREE_CODE (t1) == NEGATE_EXPR)
1352             return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1353                            fold_convert (type, TREE_OPERAND (t1, 0)));
1354           else if (TREE_CODE (t2) == NEGATE_EXPR)
1355             return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1356                            fold_convert (type, TREE_OPERAND (t2, 0)));
1357           else if (integer_zerop (t2))
1358             return fold_convert (type, t1);
1359         }
1360       else if (code == MINUS_EXPR)
1361         {
1362           if (integer_zerop (t2))
1363             return fold_convert (type, t1);
1364         }
1365
1366       return build2 (code, type, fold_convert (type, t1),
1367                      fold_convert (type, t2));
1368     }
1369
1370   return fold_build2 (code, type, fold_convert (type, t1),
1371                       fold_convert (type, t2));
1372 }
1373 \f
1374 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1375    to produce a new constant.  Return NULL_TREE if we don't know how
1376    to evaluate CODE at compile-time.
1377
1378    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1379
1380 tree
1381 int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1382 {
1383   unsigned HOST_WIDE_INT int1l, int2l;
1384   HOST_WIDE_INT int1h, int2h;
1385   unsigned HOST_WIDE_INT low;
1386   HOST_WIDE_INT hi;
1387   unsigned HOST_WIDE_INT garbagel;
1388   HOST_WIDE_INT garbageh;
1389   tree t;
1390   tree type = TREE_TYPE (arg1);
1391   int uns = TYPE_UNSIGNED (type);
1392   int is_sizetype
1393     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1394   int overflow = 0;
1395
1396   int1l = TREE_INT_CST_LOW (arg1);
1397   int1h = TREE_INT_CST_HIGH (arg1);
1398   int2l = TREE_INT_CST_LOW (arg2);
1399   int2h = TREE_INT_CST_HIGH (arg2);
1400
1401   switch (code)
1402     {
1403     case BIT_IOR_EXPR:
1404       low = int1l | int2l, hi = int1h | int2h;
1405       break;
1406
1407     case BIT_XOR_EXPR:
1408       low = int1l ^ int2l, hi = int1h ^ int2h;
1409       break;
1410
1411     case BIT_AND_EXPR:
1412       low = int1l & int2l, hi = int1h & int2h;
1413       break;
1414
1415     case RSHIFT_EXPR:
1416       int2l = -int2l;
1417     case LSHIFT_EXPR:
1418       /* It's unclear from the C standard whether shifts can overflow.
1419          The following code ignores overflow; perhaps a C standard
1420          interpretation ruling is needed.  */
1421       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1422                      &low, &hi, !uns);
1423       break;
1424
1425     case RROTATE_EXPR:
1426       int2l = - int2l;
1427     case LROTATE_EXPR:
1428       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1429                       &low, &hi);
1430       break;
1431
1432     case PLUS_EXPR:
1433       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1434       break;
1435
1436     case MINUS_EXPR:
1437       neg_double (int2l, int2h, &low, &hi);
1438       add_double (int1l, int1h, low, hi, &low, &hi);
1439       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1440       break;
1441
1442     case MULT_EXPR:
1443       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1444       break;
1445
1446     case TRUNC_DIV_EXPR:
1447     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1448     case EXACT_DIV_EXPR:
1449       /* This is a shortcut for a common special case.  */
1450       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1451           && ! TREE_CONSTANT_OVERFLOW (arg1)
1452           && ! TREE_CONSTANT_OVERFLOW (arg2)
1453           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1454         {
1455           if (code == CEIL_DIV_EXPR)
1456             int1l += int2l - 1;
1457
1458           low = int1l / int2l, hi = 0;
1459           break;
1460         }
1461
1462       /* ... fall through ...  */
1463
1464     case ROUND_DIV_EXPR:
1465       if (int2h == 0 && int2l == 0)
1466         return NULL_TREE;
1467       if (int2h == 0 && int2l == 1)
1468         {
1469           low = int1l, hi = int1h;
1470           break;
1471         }
1472       if (int1l == int2l && int1h == int2h
1473           && ! (int1l == 0 && int1h == 0))
1474         {
1475           low = 1, hi = 0;
1476           break;
1477         }
1478       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1479                                        &low, &hi, &garbagel, &garbageh);
1480       break;
1481
1482     case TRUNC_MOD_EXPR:
1483     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1484       /* This is a shortcut for a common special case.  */
1485       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1486           && ! TREE_CONSTANT_OVERFLOW (arg1)
1487           && ! TREE_CONSTANT_OVERFLOW (arg2)
1488           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1489         {
1490           if (code == CEIL_MOD_EXPR)
1491             int1l += int2l - 1;
1492           low = int1l % int2l, hi = 0;
1493           break;
1494         }
1495
1496       /* ... fall through ...  */
1497
1498     case ROUND_MOD_EXPR:
1499       if (int2h == 0 && int2l == 0)
1500         return NULL_TREE;
1501       overflow = div_and_round_double (code, uns,
1502                                        int1l, int1h, int2l, int2h,
1503                                        &garbagel, &garbageh, &low, &hi);
1504       break;
1505
1506     case MIN_EXPR:
1507     case MAX_EXPR:
1508       if (uns)
1509         low = (((unsigned HOST_WIDE_INT) int1h
1510                 < (unsigned HOST_WIDE_INT) int2h)
1511                || (((unsigned HOST_WIDE_INT) int1h
1512                     == (unsigned HOST_WIDE_INT) int2h)
1513                    && int1l < int2l));
1514       else
1515         low = (int1h < int2h
1516                || (int1h == int2h && int1l < int2l));
1517
1518       if (low == (code == MIN_EXPR))
1519         low = int1l, hi = int1h;
1520       else
1521         low = int2l, hi = int2h;
1522       break;
1523
1524     default:
1525       return NULL_TREE;
1526     }
1527
1528   t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1529
1530   if (notrunc)
1531     {
1532       /* Propagate overflow flags ourselves.  */
1533       if (((!uns || is_sizetype) && overflow)
1534           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1535         {
1536           t = copy_node (t);
1537           TREE_OVERFLOW (t) = 1;
1538           TREE_CONSTANT_OVERFLOW (t) = 1;
1539         }
1540       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1541         {
1542           t = copy_node (t);
1543           TREE_CONSTANT_OVERFLOW (t) = 1;
1544         }
1545     }
1546   else
1547     t = force_fit_type (t, 1,
1548                         ((!uns || is_sizetype) && overflow)
1549                         | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2),
1550                         TREE_CONSTANT_OVERFLOW (arg1)
1551                         | TREE_CONSTANT_OVERFLOW (arg2));
1552
1553   return t;
1554 }
1555
1556 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1557    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1558    are the same kind of constant and the same machine mode.  Return zero if
1559    combining the constants is not allowed in the current operating mode.
1560
1561    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1562
1563 static tree
1564 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1565 {
1566   /* Sanity check for the recursive cases.  */
1567   if (!arg1 || !arg2)
1568     return NULL_TREE;
1569
1570   STRIP_NOPS (arg1);
1571   STRIP_NOPS (arg2);
1572
1573   if (TREE_CODE (arg1) == INTEGER_CST)
1574     return int_const_binop (code, arg1, arg2, notrunc);
1575
1576   if (TREE_CODE (arg1) == REAL_CST)
1577     {
1578       enum machine_mode mode;
1579       REAL_VALUE_TYPE d1;
1580       REAL_VALUE_TYPE d2;
1581       REAL_VALUE_TYPE value;
1582       REAL_VALUE_TYPE result;
1583       bool inexact;
1584       tree t, type;
1585
1586       /* The following codes are handled by real_arithmetic.  */
1587       switch (code)
1588         {
1589         case PLUS_EXPR:
1590         case MINUS_EXPR:
1591         case MULT_EXPR:
1592         case RDIV_EXPR:
1593         case MIN_EXPR:
1594         case MAX_EXPR:
1595           break;
1596
1597         default:
1598           return NULL_TREE;
1599         }
1600
1601       d1 = TREE_REAL_CST (arg1);
1602       d2 = TREE_REAL_CST (arg2);
1603
1604       type = TREE_TYPE (arg1);
1605       mode = TYPE_MODE (type);
1606
1607       /* Don't perform operation if we honor signaling NaNs and
1608          either operand is a NaN.  */
1609       if (HONOR_SNANS (mode)
1610           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1611         return NULL_TREE;
1612
1613       /* Don't perform operation if it would raise a division
1614          by zero exception.  */
1615       if (code == RDIV_EXPR
1616           && REAL_VALUES_EQUAL (d2, dconst0)
1617           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1618         return NULL_TREE;
1619
1620       /* If either operand is a NaN, just return it.  Otherwise, set up
1621          for floating-point trap; we return an overflow.  */
1622       if (REAL_VALUE_ISNAN (d1))
1623         return arg1;
1624       else if (REAL_VALUE_ISNAN (d2))
1625         return arg2;
1626
1627       inexact = real_arithmetic (&value, code, &d1, &d2);
1628       real_convert (&result, mode, &value);
1629
1630       /* Don't constant fold this floating point operation if
1631          the result has overflowed and flag_trapping_math.  */
1632       if (flag_trapping_math
1633           && MODE_HAS_INFINITIES (mode)
1634           && REAL_VALUE_ISINF (result)
1635           && !REAL_VALUE_ISINF (d1)
1636           && !REAL_VALUE_ISINF (d2))
1637         return NULL_TREE;
1638
1639       /* Don't constant fold this floating point operation if the
1640          result may dependent upon the run-time rounding mode and
1641          flag_rounding_math is set, or if GCC's software emulation
1642          is unable to accurately represent the result.  */
1643       if ((flag_rounding_math
1644            || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
1645                && !flag_unsafe_math_optimizations))
1646           && (inexact || !real_identical (&result, &value)))
1647         return NULL_TREE;
1648
1649       t = build_real (type, result);
1650
1651       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1652       TREE_CONSTANT_OVERFLOW (t)
1653         = TREE_OVERFLOW (t)
1654           | TREE_CONSTANT_OVERFLOW (arg1)
1655           | TREE_CONSTANT_OVERFLOW (arg2);
1656       return t;
1657     }
1658
1659   if (TREE_CODE (arg1) == COMPLEX_CST)
1660     {
1661       tree type = TREE_TYPE (arg1);
1662       tree r1 = TREE_REALPART (arg1);
1663       tree i1 = TREE_IMAGPART (arg1);
1664       tree r2 = TREE_REALPART (arg2);
1665       tree i2 = TREE_IMAGPART (arg2);
1666       tree real, imag;
1667
1668       switch (code)
1669         {
1670         case PLUS_EXPR:
1671         case MINUS_EXPR:
1672           real = const_binop (code, r1, r2, notrunc);
1673           imag = const_binop (code, i1, i2, notrunc);
1674           break;
1675
1676         case MULT_EXPR:
1677           real = const_binop (MINUS_EXPR,
1678                               const_binop (MULT_EXPR, r1, r2, notrunc),
1679                               const_binop (MULT_EXPR, i1, i2, notrunc),
1680                               notrunc);
1681           imag = const_binop (PLUS_EXPR,
1682                               const_binop (MULT_EXPR, r1, i2, notrunc),
1683                               const_binop (MULT_EXPR, i1, r2, notrunc),
1684                               notrunc);
1685           break;
1686
1687         case RDIV_EXPR:
1688           {
1689             tree magsquared
1690               = const_binop (PLUS_EXPR,
1691                              const_binop (MULT_EXPR, r2, r2, notrunc),
1692                              const_binop (MULT_EXPR, i2, i2, notrunc),
1693                              notrunc);
1694             tree t1
1695               = const_binop (PLUS_EXPR,
1696                              const_binop (MULT_EXPR, r1, r2, notrunc),
1697                              const_binop (MULT_EXPR, i1, i2, notrunc),
1698                              notrunc);
1699             tree t2
1700               = const_binop (MINUS_EXPR,
1701                              const_binop (MULT_EXPR, i1, r2, notrunc),
1702                              const_binop (MULT_EXPR, r1, i2, notrunc),
1703                              notrunc);
1704
1705             if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1706               code = TRUNC_DIV_EXPR;
1707
1708             real = const_binop (code, t1, magsquared, notrunc);
1709             imag = const_binop (code, t2, magsquared, notrunc);
1710           }
1711           break;
1712
1713         default:
1714           return NULL_TREE;
1715         }
1716
1717       if (real && imag)
1718         return build_complex (type, real, imag);
1719     }
1720
1721   return NULL_TREE;
1722 }
1723
1724 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
1725    indicates which particular sizetype to create.  */
1726
1727 tree
1728 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1729 {
1730   return build_int_cst (sizetype_tab[(int) kind], number);
1731 }
1732 \f
1733 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1734    is a tree code.  The type of the result is taken from the operands.
1735    Both must be the same type integer type and it must be a size type.
1736    If the operands are constant, so is the result.  */
1737
1738 tree
1739 size_binop (enum tree_code code, tree arg0, tree arg1)
1740 {
1741   tree type = TREE_TYPE (arg0);
1742
1743   if (arg0 == error_mark_node || arg1 == error_mark_node)
1744     return error_mark_node;
1745
1746   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1747               && type == TREE_TYPE (arg1));
1748
1749   /* Handle the special case of two integer constants faster.  */
1750   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1751     {
1752       /* And some specific cases even faster than that.  */
1753       if (code == PLUS_EXPR && integer_zerop (arg0))
1754         return arg1;
1755       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1756                && integer_zerop (arg1))
1757         return arg0;
1758       else if (code == MULT_EXPR && integer_onep (arg0))
1759         return arg1;
1760
1761       /* Handle general case of two integer constants.  */
1762       return int_const_binop (code, arg0, arg1, 0);
1763     }
1764
1765   return fold_build2 (code, type, arg0, arg1);
1766 }
1767
1768 /* Given two values, either both of sizetype or both of bitsizetype,
1769    compute the difference between the two values.  Return the value
1770    in signed type corresponding to the type of the operands.  */
1771
1772 tree
1773 size_diffop (tree arg0, tree arg1)
1774 {
1775   tree type = TREE_TYPE (arg0);
1776   tree ctype;
1777
1778   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1779               && type == TREE_TYPE (arg1));
1780
1781   /* If the type is already signed, just do the simple thing.  */
1782   if (!TYPE_UNSIGNED (type))
1783     return size_binop (MINUS_EXPR, arg0, arg1);
1784
1785   ctype = type == bitsizetype ? sbitsizetype : ssizetype;
1786
1787   /* If either operand is not a constant, do the conversions to the signed
1788      type and subtract.  The hardware will do the right thing with any
1789      overflow in the subtraction.  */
1790   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1791     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
1792                        fold_convert (ctype, arg1));
1793
1794   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1795      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1796      overflow) and negate (which can't either).  Special-case a result
1797      of zero while we're here.  */
1798   if (tree_int_cst_equal (arg0, arg1))
1799     return build_int_cst (ctype, 0);
1800   else if (tree_int_cst_lt (arg1, arg0))
1801     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
1802   else
1803     return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
1804                        fold_convert (ctype, size_binop (MINUS_EXPR,
1805                                                         arg1, arg0)));
1806 }
1807 \f
1808 /* A subroutine of fold_convert_const handling conversions of an
1809    INTEGER_CST to another integer type.  */
1810
1811 static tree
1812 fold_convert_const_int_from_int (tree type, tree arg1)
1813 {
1814   tree t;
1815
1816   /* Given an integer constant, make new constant with new type,
1817      appropriately sign-extended or truncated.  */
1818   t = build_int_cst_wide (type, TREE_INT_CST_LOW (arg1),
1819                           TREE_INT_CST_HIGH (arg1));
1820
1821   t = force_fit_type (t,
1822                       /* Don't set the overflow when
1823                          converting a pointer  */
1824                       !POINTER_TYPE_P (TREE_TYPE (arg1)),
1825                       (TREE_INT_CST_HIGH (arg1) < 0
1826                        && (TYPE_UNSIGNED (type)
1827                            < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1828                       | TREE_OVERFLOW (arg1),
1829                       TREE_CONSTANT_OVERFLOW (arg1));
1830
1831   return t;
1832 }
1833
1834 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1835    to an integer type.  */
1836
1837 static tree
1838 fold_convert_const_int_from_real (enum tree_code code, tree type, tree arg1)
1839 {
1840   int overflow = 0;
1841   tree t;
1842
1843   /* The following code implements the floating point to integer
1844      conversion rules required by the Java Language Specification,
1845      that IEEE NaNs are mapped to zero and values that overflow
1846      the target precision saturate, i.e. values greater than
1847      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1848      are mapped to INT_MIN.  These semantics are allowed by the
1849      C and C++ standards that simply state that the behavior of
1850      FP-to-integer conversion is unspecified upon overflow.  */
1851
1852   HOST_WIDE_INT high, low;
1853   REAL_VALUE_TYPE r;
1854   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1855
1856   switch (code)
1857     {
1858     case FIX_TRUNC_EXPR:
1859       real_trunc (&r, VOIDmode, &x);
1860       break;
1861
1862     case FIX_CEIL_EXPR:
1863       real_ceil (&r, VOIDmode, &x);
1864       break;
1865
1866     case FIX_FLOOR_EXPR:
1867       real_floor (&r, VOIDmode, &x);
1868       break;
1869
1870     case FIX_ROUND_EXPR:
1871       real_round (&r, VOIDmode, &x);
1872       break;
1873
1874     default:
1875       gcc_unreachable ();
1876     }
1877
1878   /* If R is NaN, return zero and show we have an overflow.  */
1879   if (REAL_VALUE_ISNAN (r))
1880     {
1881       overflow = 1;
1882       high = 0;
1883       low = 0;
1884     }
1885
1886   /* See if R is less than the lower bound or greater than the
1887      upper bound.  */
1888
1889   if (! overflow)
1890     {
1891       tree lt = TYPE_MIN_VALUE (type);
1892       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1893       if (REAL_VALUES_LESS (r, l))
1894         {
1895           overflow = 1;
1896           high = TREE_INT_CST_HIGH (lt);
1897           low = TREE_INT_CST_LOW (lt);
1898         }
1899     }
1900
1901   if (! overflow)
1902     {
1903       tree ut = TYPE_MAX_VALUE (type);
1904       if (ut)
1905         {
1906           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1907           if (REAL_VALUES_LESS (u, r))
1908             {
1909               overflow = 1;
1910               high = TREE_INT_CST_HIGH (ut);
1911               low = TREE_INT_CST_LOW (ut);
1912             }
1913         }
1914     }
1915
1916   if (! overflow)
1917     REAL_VALUE_TO_INT (&low, &high, r);
1918
1919   t = build_int_cst_wide (type, low, high);
1920
1921   t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg1),
1922                       TREE_CONSTANT_OVERFLOW (arg1));
1923   return t;
1924 }
1925
1926 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1927    to another floating point type.  */
1928
1929 static tree
1930 fold_convert_const_real_from_real (tree type, tree arg1)
1931 {
1932   REAL_VALUE_TYPE value;
1933   tree t;
1934
1935   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1936   t = build_real (type, value);
1937
1938   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1939   TREE_CONSTANT_OVERFLOW (t)
1940     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1941   return t;
1942 }
1943
1944 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1945    type TYPE.  If no simplification can be done return NULL_TREE.  */
1946
1947 static tree
1948 fold_convert_const (enum tree_code code, tree type, tree arg1)
1949 {
1950   if (TREE_TYPE (arg1) == type)
1951     return arg1;
1952
1953   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1954     {
1955       if (TREE_CODE (arg1) == INTEGER_CST)
1956         return fold_convert_const_int_from_int (type, arg1);
1957       else if (TREE_CODE (arg1) == REAL_CST)
1958         return fold_convert_const_int_from_real (code, type, arg1);
1959     }
1960   else if (TREE_CODE (type) == REAL_TYPE)
1961     {
1962       if (TREE_CODE (arg1) == INTEGER_CST)
1963         return build_real_from_int_cst (type, arg1);
1964       if (TREE_CODE (arg1) == REAL_CST)
1965         return fold_convert_const_real_from_real (type, arg1);
1966     }
1967   return NULL_TREE;
1968 }
1969
1970 /* Construct a vector of zero elements of vector type TYPE.  */
1971
1972 static tree
1973 build_zero_vector (tree type)
1974 {
1975   tree elem, list;
1976   int i, units;
1977
1978   elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1979   units = TYPE_VECTOR_SUBPARTS (type);
1980
1981   list = NULL_TREE;
1982   for (i = 0; i < units; i++)
1983     list = tree_cons (NULL_TREE, elem, list);
1984   return build_vector (type, list);
1985 }
1986
1987 /* Convert expression ARG to type TYPE.  Used by the middle-end for
1988    simple conversions in preference to calling the front-end's convert.  */
1989
1990 tree
1991 fold_convert (tree type, tree arg)
1992 {
1993   tree orig = TREE_TYPE (arg);
1994   tree tem;
1995
1996   if (type == orig)
1997     return arg;
1998
1999   if (TREE_CODE (arg) == ERROR_MARK
2000       || TREE_CODE (type) == ERROR_MARK
2001       || TREE_CODE (orig) == ERROR_MARK)
2002     return error_mark_node;
2003
2004   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig)
2005       || lang_hooks.types_compatible_p (TYPE_MAIN_VARIANT (type),
2006                                         TYPE_MAIN_VARIANT (orig)))
2007     return fold_build1 (NOP_EXPR, type, arg);
2008
2009   switch (TREE_CODE (type))
2010     {
2011     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2012     case POINTER_TYPE: case REFERENCE_TYPE:
2013     case OFFSET_TYPE:
2014       if (TREE_CODE (arg) == INTEGER_CST)
2015         {
2016           tem = fold_convert_const (NOP_EXPR, type, arg);
2017           if (tem != NULL_TREE)
2018             return tem;
2019         }
2020       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2021           || TREE_CODE (orig) == OFFSET_TYPE)
2022         return fold_build1 (NOP_EXPR, type, arg);
2023       if (TREE_CODE (orig) == COMPLEX_TYPE)
2024         {
2025           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2026           return fold_convert (type, tem);
2027         }
2028       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2029                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2030       return fold_build1 (NOP_EXPR, type, arg);
2031
2032     case REAL_TYPE:
2033       if (TREE_CODE (arg) == INTEGER_CST)
2034         {
2035           tem = fold_convert_const (FLOAT_EXPR, type, arg);
2036           if (tem != NULL_TREE)
2037             return tem;
2038         }
2039       else if (TREE_CODE (arg) == REAL_CST)
2040         {
2041           tem = fold_convert_const (NOP_EXPR, type, arg);
2042           if (tem != NULL_TREE)
2043             return tem;
2044         }
2045
2046       switch (TREE_CODE (orig))
2047         {
2048         case INTEGER_TYPE:
2049         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2050         case POINTER_TYPE: case REFERENCE_TYPE:
2051           return fold_build1 (FLOAT_EXPR, type, arg);
2052
2053         case REAL_TYPE:
2054           return fold_build1 (NOP_EXPR, type, arg);
2055
2056         case COMPLEX_TYPE:
2057           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2058           return fold_convert (type, tem);
2059
2060         default:
2061           gcc_unreachable ();
2062         }
2063
2064     case COMPLEX_TYPE:
2065       switch (TREE_CODE (orig))
2066         {
2067         case INTEGER_TYPE:
2068         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2069         case POINTER_TYPE: case REFERENCE_TYPE:
2070         case REAL_TYPE:
2071           return build2 (COMPLEX_EXPR, type,
2072                          fold_convert (TREE_TYPE (type), arg),
2073                          fold_convert (TREE_TYPE (type), integer_zero_node));
2074         case COMPLEX_TYPE:
2075           {
2076             tree rpart, ipart;
2077
2078             if (TREE_CODE (arg) == COMPLEX_EXPR)
2079               {
2080                 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2081                 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2082                 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2083               }
2084
2085             arg = save_expr (arg);
2086             rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2087             ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2088             rpart = fold_convert (TREE_TYPE (type), rpart);
2089             ipart = fold_convert (TREE_TYPE (type), ipart);
2090             return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2091           }
2092
2093         default:
2094           gcc_unreachable ();
2095         }
2096
2097     case VECTOR_TYPE:
2098       if (integer_zerop (arg))
2099         return build_zero_vector (type);
2100       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2101       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2102                   || TREE_CODE (orig) == VECTOR_TYPE);
2103       return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2104
2105     case VOID_TYPE:
2106       return fold_build1 (NOP_EXPR, type, fold_ignored_result (arg));
2107
2108     default:
2109       gcc_unreachable ();
2110     }
2111 }
2112 \f
2113 /* Return false if expr can be assumed not to be an lvalue, true
2114    otherwise.  */
2115
2116 static bool
2117 maybe_lvalue_p (tree x)
2118 {
2119   /* We only need to wrap lvalue tree codes.  */
2120   switch (TREE_CODE (x))
2121   {
2122   case VAR_DECL:
2123   case PARM_DECL:
2124   case RESULT_DECL:
2125   case LABEL_DECL:
2126   case FUNCTION_DECL:
2127   case SSA_NAME:
2128
2129   case COMPONENT_REF:
2130   case INDIRECT_REF:
2131   case ALIGN_INDIRECT_REF:
2132   case MISALIGNED_INDIRECT_REF:
2133   case ARRAY_REF:
2134   case ARRAY_RANGE_REF:
2135   case BIT_FIELD_REF:
2136   case OBJ_TYPE_REF:
2137
2138   case REALPART_EXPR:
2139   case IMAGPART_EXPR:
2140   case PREINCREMENT_EXPR:
2141   case PREDECREMENT_EXPR:
2142   case SAVE_EXPR:
2143   case TRY_CATCH_EXPR:
2144   case WITH_CLEANUP_EXPR:
2145   case COMPOUND_EXPR:
2146   case MODIFY_EXPR:
2147   case TARGET_EXPR:
2148   case COND_EXPR:
2149   case BIND_EXPR:
2150   case MIN_EXPR:
2151   case MAX_EXPR:
2152     break;
2153
2154   default:
2155     /* Assume the worst for front-end tree codes.  */
2156     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2157       break;
2158     return false;
2159   }
2160
2161   return true;
2162 }
2163
2164 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2165
2166 tree
2167 non_lvalue (tree x)
2168 {
2169   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2170      us.  */
2171   if (in_gimple_form)
2172     return x;
2173
2174   if (! maybe_lvalue_p (x))
2175     return x;
2176   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2177 }
2178
2179 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2180    Zero means allow extended lvalues.  */
2181
2182 int pedantic_lvalues;
2183
2184 /* When pedantic, return an expr equal to X but certainly not valid as a
2185    pedantic lvalue.  Otherwise, return X.  */
2186
2187 static tree
2188 pedantic_non_lvalue (tree x)
2189 {
2190   if (pedantic_lvalues)
2191     return non_lvalue (x);
2192   else
2193     return x;
2194 }
2195 \f
2196 /* Given a tree comparison code, return the code that is the logical inverse
2197    of the given code.  It is not safe to do this for floating-point
2198    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2199    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2200
2201 enum tree_code
2202 invert_tree_comparison (enum tree_code code, bool honor_nans)
2203 {
2204   if (honor_nans && flag_trapping_math)
2205     return ERROR_MARK;
2206
2207   switch (code)
2208     {
2209     case EQ_EXPR:
2210       return NE_EXPR;
2211     case NE_EXPR:
2212       return EQ_EXPR;
2213     case GT_EXPR:
2214       return honor_nans ? UNLE_EXPR : LE_EXPR;
2215     case GE_EXPR:
2216       return honor_nans ? UNLT_EXPR : LT_EXPR;
2217     case LT_EXPR:
2218       return honor_nans ? UNGE_EXPR : GE_EXPR;
2219     case LE_EXPR:
2220       return honor_nans ? UNGT_EXPR : GT_EXPR;
2221     case LTGT_EXPR:
2222       return UNEQ_EXPR;
2223     case UNEQ_EXPR:
2224       return LTGT_EXPR;
2225     case UNGT_EXPR:
2226       return LE_EXPR;
2227     case UNGE_EXPR:
2228       return LT_EXPR;
2229     case UNLT_EXPR:
2230       return GE_EXPR;
2231     case UNLE_EXPR:
2232       return GT_EXPR;
2233     case ORDERED_EXPR:
2234       return UNORDERED_EXPR;
2235     case UNORDERED_EXPR:
2236       return ORDERED_EXPR;
2237     default:
2238       gcc_unreachable ();
2239     }
2240 }
2241
2242 /* Similar, but return the comparison that results if the operands are
2243    swapped.  This is safe for floating-point.  */
2244
2245 enum tree_code
2246 swap_tree_comparison (enum tree_code code)
2247 {
2248   switch (code)
2249     {
2250     case EQ_EXPR:
2251     case NE_EXPR:
2252     case ORDERED_EXPR:
2253     case UNORDERED_EXPR:
2254     case LTGT_EXPR:
2255     case UNEQ_EXPR:
2256       return code;
2257     case GT_EXPR:
2258       return LT_EXPR;
2259     case GE_EXPR:
2260       return LE_EXPR;
2261     case LT_EXPR:
2262       return GT_EXPR;
2263     case LE_EXPR:
2264       return GE_EXPR;
2265     case UNGT_EXPR:
2266       return UNLT_EXPR;
2267     case UNGE_EXPR:
2268       return UNLE_EXPR;
2269     case UNLT_EXPR:
2270       return UNGT_EXPR;
2271     case UNLE_EXPR:
2272       return UNGE_EXPR;
2273     default:
2274       gcc_unreachable ();
2275     }
2276 }
2277
2278
2279 /* Convert a comparison tree code from an enum tree_code representation
2280    into a compcode bit-based encoding.  This function is the inverse of
2281    compcode_to_comparison.  */
2282
2283 static enum comparison_code
2284 comparison_to_compcode (enum tree_code code)
2285 {
2286   switch (code)
2287     {
2288     case LT_EXPR:
2289       return COMPCODE_LT;
2290     case EQ_EXPR:
2291       return COMPCODE_EQ;
2292     case LE_EXPR:
2293       return COMPCODE_LE;
2294     case GT_EXPR:
2295       return COMPCODE_GT;
2296     case NE_EXPR:
2297       return COMPCODE_NE;
2298     case GE_EXPR:
2299       return COMPCODE_GE;
2300     case ORDERED_EXPR:
2301       return COMPCODE_ORD;
2302     case UNORDERED_EXPR:
2303       return COMPCODE_UNORD;
2304     case UNLT_EXPR:
2305       return COMPCODE_UNLT;
2306     case UNEQ_EXPR:
2307       return COMPCODE_UNEQ;
2308     case UNLE_EXPR:
2309       return COMPCODE_UNLE;
2310     case UNGT_EXPR:
2311       return COMPCODE_UNGT;
2312     case LTGT_EXPR:
2313       return COMPCODE_LTGT;
2314     case UNGE_EXPR:
2315       return COMPCODE_UNGE;
2316     default:
2317       gcc_unreachable ();
2318     }
2319 }
2320
2321 /* Convert a compcode bit-based encoding of a comparison operator back
2322    to GCC's enum tree_code representation.  This function is the
2323    inverse of comparison_to_compcode.  */
2324
2325 static enum tree_code
2326 compcode_to_comparison (enum comparison_code code)
2327 {
2328   switch (code)
2329     {
2330     case COMPCODE_LT:
2331       return LT_EXPR;
2332     case COMPCODE_EQ:
2333       return EQ_EXPR;
2334     case COMPCODE_LE:
2335       return LE_EXPR;
2336     case COMPCODE_GT:
2337       return GT_EXPR;
2338     case COMPCODE_NE:
2339       return NE_EXPR;
2340     case COMPCODE_GE:
2341       return GE_EXPR;
2342     case COMPCODE_ORD:
2343       return ORDERED_EXPR;
2344     case COMPCODE_UNORD:
2345       return UNORDERED_EXPR;
2346     case COMPCODE_UNLT:
2347       return UNLT_EXPR;
2348     case COMPCODE_UNEQ:
2349       return UNEQ_EXPR;
2350     case COMPCODE_UNLE:
2351       return UNLE_EXPR;
2352     case COMPCODE_UNGT:
2353       return UNGT_EXPR;
2354     case COMPCODE_LTGT:
2355       return LTGT_EXPR;
2356     case COMPCODE_UNGE:
2357       return UNGE_EXPR;
2358     default:
2359       gcc_unreachable ();
2360     }
2361 }
2362
2363 /* Return a tree for the comparison which is the combination of
2364    doing the AND or OR (depending on CODE) of the two operations LCODE
2365    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2366    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2367    if this makes the transformation invalid.  */
2368
2369 tree
2370 combine_comparisons (enum tree_code code, enum tree_code lcode,
2371                      enum tree_code rcode, tree truth_type,
2372                      tree ll_arg, tree lr_arg)
2373 {
2374   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2375   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2376   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2377   enum comparison_code compcode;
2378
2379   switch (code)
2380     {
2381     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2382       compcode = lcompcode & rcompcode;
2383       break;
2384
2385     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2386       compcode = lcompcode | rcompcode;
2387       break;
2388
2389     default:
2390       return NULL_TREE;
2391     }
2392
2393   if (!honor_nans)
2394     {
2395       /* Eliminate unordered comparisons, as well as LTGT and ORD
2396          which are not used unless the mode has NaNs.  */
2397       compcode &= ~COMPCODE_UNORD;
2398       if (compcode == COMPCODE_LTGT)
2399         compcode = COMPCODE_NE;
2400       else if (compcode == COMPCODE_ORD)
2401         compcode = COMPCODE_TRUE;
2402     }
2403    else if (flag_trapping_math)
2404      {
2405         /* Check that the original operation and the optimized ones will trap
2406            under the same condition.  */
2407         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2408                      && (lcompcode != COMPCODE_EQ)
2409                      && (lcompcode != COMPCODE_ORD);
2410         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2411                      && (rcompcode != COMPCODE_EQ)
2412                      && (rcompcode != COMPCODE_ORD);
2413         bool trap = (compcode & COMPCODE_UNORD) == 0
2414                     && (compcode != COMPCODE_EQ)
2415                     && (compcode != COMPCODE_ORD);
2416
2417         /* In a short-circuited boolean expression the LHS might be
2418            such that the RHS, if evaluated, will never trap.  For
2419            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2420            if neither x nor y is NaN.  (This is a mixed blessing: for
2421            example, the expression above will never trap, hence
2422            optimizing it to x < y would be invalid).  */
2423         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2424             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2425           rtrap = false;
2426
2427         /* If the comparison was short-circuited, and only the RHS
2428            trapped, we may now generate a spurious trap.  */
2429         if (rtrap && !ltrap
2430             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2431           return NULL_TREE;
2432
2433         /* If we changed the conditions that cause a trap, we lose.  */
2434         if ((ltrap || rtrap) != trap)
2435           return NULL_TREE;
2436       }
2437
2438   if (compcode == COMPCODE_TRUE)
2439     return constant_boolean_node (true, truth_type);
2440   else if (compcode == COMPCODE_FALSE)
2441     return constant_boolean_node (false, truth_type);
2442   else
2443     return fold_build2 (compcode_to_comparison (compcode),
2444                         truth_type, ll_arg, lr_arg);
2445 }
2446
2447 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2448
2449 static int
2450 truth_value_p (enum tree_code code)
2451 {
2452   return (TREE_CODE_CLASS (code) == tcc_comparison
2453           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2454           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2455           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2456 }
2457 \f
2458 /* Return nonzero if two operands (typically of the same tree node)
2459    are necessarily equal.  If either argument has side-effects this
2460    function returns zero.  FLAGS modifies behavior as follows:
2461
2462    If OEP_ONLY_CONST is set, only return nonzero for constants.
2463    This function tests whether the operands are indistinguishable;
2464    it does not test whether they are equal using C's == operation.
2465    The distinction is important for IEEE floating point, because
2466    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2467    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2468
2469    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2470    even though it may hold multiple values during a function.
2471    This is because a GCC tree node guarantees that nothing else is
2472    executed between the evaluation of its "operands" (which may often
2473    be evaluated in arbitrary order).  Hence if the operands themselves
2474    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2475    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2476    unset means assuming isochronic (or instantaneous) tree equivalence.
2477    Unless comparing arbitrary expression trees, such as from different
2478    statements, this flag can usually be left unset.
2479
2480    If OEP_PURE_SAME is set, then pure functions with identical arguments
2481    are considered the same.  It is used when the caller has other ways
2482    to ensure that global memory is unchanged in between.  */
2483
2484 int
2485 operand_equal_p (tree arg0, tree arg1, unsigned int flags)
2486 {
2487   /* If either is ERROR_MARK, they aren't equal.  */
2488   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
2489     return 0;
2490
2491   /* If both types don't have the same signedness, then we can't consider
2492      them equal.  We must check this before the STRIP_NOPS calls
2493      because they may change the signedness of the arguments.  */
2494   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2495     return 0;
2496
2497   /* If both types don't have the same precision, then it is not safe
2498      to strip NOPs.  */
2499   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
2500     return 0;
2501
2502   STRIP_NOPS (arg0);
2503   STRIP_NOPS (arg1);
2504
2505   /* In case both args are comparisons but with different comparison
2506      code, try to swap the comparison operands of one arg to produce
2507      a match and compare that variant.  */
2508   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2509       && COMPARISON_CLASS_P (arg0)
2510       && COMPARISON_CLASS_P (arg1))
2511     {
2512       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2513
2514       if (TREE_CODE (arg0) == swap_code)
2515         return operand_equal_p (TREE_OPERAND (arg0, 0),
2516                                 TREE_OPERAND (arg1, 1), flags)
2517                && operand_equal_p (TREE_OPERAND (arg0, 1),
2518                                    TREE_OPERAND (arg1, 0), flags);
2519     }
2520
2521   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2522       /* This is needed for conversions and for COMPONENT_REF.
2523          Might as well play it safe and always test this.  */
2524       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2525       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2526       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2527     return 0;
2528
2529   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2530      We don't care about side effects in that case because the SAVE_EXPR
2531      takes care of that for us. In all other cases, two expressions are
2532      equal if they have no side effects.  If we have two identical
2533      expressions with side effects that should be treated the same due
2534      to the only side effects being identical SAVE_EXPR's, that will
2535      be detected in the recursive calls below.  */
2536   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2537       && (TREE_CODE (arg0) == SAVE_EXPR
2538           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2539     return 1;
2540
2541   /* Next handle constant cases, those for which we can return 1 even
2542      if ONLY_CONST is set.  */
2543   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2544     switch (TREE_CODE (arg0))
2545       {
2546       case INTEGER_CST:
2547         return (! TREE_CONSTANT_OVERFLOW (arg0)
2548                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2549                 && tree_int_cst_equal (arg0, arg1));
2550
2551       case REAL_CST:
2552         return (! TREE_CONSTANT_OVERFLOW (arg0)
2553                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2554                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2555                                           TREE_REAL_CST (arg1)));
2556
2557       case VECTOR_CST:
2558         {
2559           tree v1, v2;
2560
2561           if (TREE_CONSTANT_OVERFLOW (arg0)
2562               || TREE_CONSTANT_OVERFLOW (arg1))
2563             return 0;
2564
2565           v1 = TREE_VECTOR_CST_ELTS (arg0);
2566           v2 = TREE_VECTOR_CST_ELTS (arg1);
2567           while (v1 && v2)
2568             {
2569               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2570                                     flags))
2571                 return 0;
2572               v1 = TREE_CHAIN (v1);
2573               v2 = TREE_CHAIN (v2);
2574             }
2575
2576           return v1 == v2;
2577         }
2578
2579       case COMPLEX_CST:
2580         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2581                                  flags)
2582                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2583                                     flags));
2584
2585       case STRING_CST:
2586         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2587                 && ! memcmp (TREE_STRING_POINTER (arg0),
2588                               TREE_STRING_POINTER (arg1),
2589                               TREE_STRING_LENGTH (arg0)));
2590
2591       case ADDR_EXPR:
2592         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2593                                 0);
2594       default:
2595         break;
2596       }
2597
2598   if (flags & OEP_ONLY_CONST)
2599     return 0;
2600
2601 /* Define macros to test an operand from arg0 and arg1 for equality and a
2602    variant that allows null and views null as being different from any
2603    non-null value.  In the latter case, if either is null, the both
2604    must be; otherwise, do the normal comparison.  */
2605 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
2606                                     TREE_OPERAND (arg1, N), flags)
2607
2608 #define OP_SAME_WITH_NULL(N)                            \
2609   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2610    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2611
2612   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2613     {
2614     case tcc_unary:
2615       /* Two conversions are equal only if signedness and modes match.  */
2616       switch (TREE_CODE (arg0))
2617         {
2618         case NOP_EXPR:
2619         case CONVERT_EXPR:
2620         case FIX_CEIL_EXPR:
2621         case FIX_TRUNC_EXPR:
2622         case FIX_FLOOR_EXPR:
2623         case FIX_ROUND_EXPR:
2624           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2625               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2626             return 0;
2627           break;
2628         default:
2629           break;
2630         }
2631
2632       return OP_SAME (0);
2633
2634
2635     case tcc_comparison:
2636     case tcc_binary:
2637       if (OP_SAME (0) && OP_SAME (1))
2638         return 1;
2639
2640       /* For commutative ops, allow the other order.  */
2641       return (commutative_tree_code (TREE_CODE (arg0))
2642               && operand_equal_p (TREE_OPERAND (arg0, 0),
2643                                   TREE_OPERAND (arg1, 1), flags)
2644               && operand_equal_p (TREE_OPERAND (arg0, 1),
2645                                   TREE_OPERAND (arg1, 0), flags));
2646
2647     case tcc_reference:
2648       /* If either of the pointer (or reference) expressions we are
2649          dereferencing contain a side effect, these cannot be equal.  */
2650       if (TREE_SIDE_EFFECTS (arg0)
2651           || TREE_SIDE_EFFECTS (arg1))
2652         return 0;
2653
2654       switch (TREE_CODE (arg0))
2655         {
2656         case INDIRECT_REF:
2657         case ALIGN_INDIRECT_REF:
2658         case MISALIGNED_INDIRECT_REF:
2659         case REALPART_EXPR:
2660         case IMAGPART_EXPR:
2661           return OP_SAME (0);
2662
2663         case ARRAY_REF:
2664         case ARRAY_RANGE_REF:
2665           /* Operands 2 and 3 may be null.  */
2666           return (OP_SAME (0)
2667                   && OP_SAME (1)
2668                   && OP_SAME_WITH_NULL (2)
2669                   && OP_SAME_WITH_NULL (3));
2670
2671         case COMPONENT_REF:
2672           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
2673              may be NULL when we're called to compare MEM_EXPRs.  */
2674           return OP_SAME_WITH_NULL (0)
2675                  && OP_SAME (1)
2676                  && OP_SAME_WITH_NULL (2);
2677
2678         case BIT_FIELD_REF:
2679           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2680
2681         default:
2682           return 0;
2683         }
2684
2685     case tcc_expression:
2686       switch (TREE_CODE (arg0))
2687         {
2688         case ADDR_EXPR:
2689         case TRUTH_NOT_EXPR:
2690           return OP_SAME (0);
2691
2692         case TRUTH_ANDIF_EXPR:
2693         case TRUTH_ORIF_EXPR:
2694           return OP_SAME (0) && OP_SAME (1);
2695
2696         case TRUTH_AND_EXPR:
2697         case TRUTH_OR_EXPR:
2698         case TRUTH_XOR_EXPR:
2699           if (OP_SAME (0) && OP_SAME (1))
2700             return 1;
2701
2702           /* Otherwise take into account this is a commutative operation.  */
2703           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2704                                    TREE_OPERAND (arg1, 1), flags)
2705                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2706                                       TREE_OPERAND (arg1, 0), flags));
2707
2708         case CALL_EXPR:
2709           /* If the CALL_EXPRs call different functions, then they
2710              clearly can not be equal.  */
2711           if (!OP_SAME (0))
2712             return 0;
2713
2714           {
2715             unsigned int cef = call_expr_flags (arg0);
2716             if (flags & OEP_PURE_SAME)
2717               cef &= ECF_CONST | ECF_PURE;
2718             else
2719               cef &= ECF_CONST;
2720             if (!cef)
2721               return 0;
2722           }
2723
2724           /* Now see if all the arguments are the same.  operand_equal_p
2725              does not handle TREE_LIST, so we walk the operands here
2726              feeding them to operand_equal_p.  */
2727           arg0 = TREE_OPERAND (arg0, 1);
2728           arg1 = TREE_OPERAND (arg1, 1);
2729           while (arg0 && arg1)
2730             {
2731               if (! operand_equal_p (TREE_VALUE (arg0), TREE_VALUE (arg1),
2732                                      flags))
2733                 return 0;
2734
2735               arg0 = TREE_CHAIN (arg0);
2736               arg1 = TREE_CHAIN (arg1);
2737             }
2738
2739           /* If we get here and both argument lists are exhausted
2740              then the CALL_EXPRs are equal.  */
2741           return ! (arg0 || arg1);
2742
2743         default:
2744           return 0;
2745         }
2746
2747     case tcc_declaration:
2748       /* Consider __builtin_sqrt equal to sqrt.  */
2749       return (TREE_CODE (arg0) == FUNCTION_DECL
2750               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2751               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2752               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2753
2754     default:
2755       return 0;
2756     }
2757
2758 #undef OP_SAME
2759 #undef OP_SAME_WITH_NULL
2760 }
2761 \f
2762 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2763    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2764
2765    When in doubt, return 0.  */
2766
2767 static int
2768 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2769 {
2770   int unsignedp1, unsignedpo;
2771   tree primarg0, primarg1, primother;
2772   unsigned int correct_width;
2773
2774   if (operand_equal_p (arg0, arg1, 0))
2775     return 1;
2776
2777   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2778       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2779     return 0;
2780
2781   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2782      and see if the inner values are the same.  This removes any
2783      signedness comparison, which doesn't matter here.  */
2784   primarg0 = arg0, primarg1 = arg1;
2785   STRIP_NOPS (primarg0);
2786   STRIP_NOPS (primarg1);
2787   if (operand_equal_p (primarg0, primarg1, 0))
2788     return 1;
2789
2790   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2791      actual comparison operand, ARG0.
2792
2793      First throw away any conversions to wider types
2794      already present in the operands.  */
2795
2796   primarg1 = get_narrower (arg1, &unsignedp1);
2797   primother = get_narrower (other, &unsignedpo);
2798
2799   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2800   if (unsignedp1 == unsignedpo
2801       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2802       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2803     {
2804       tree type = TREE_TYPE (arg0);
2805
2806       /* Make sure shorter operand is extended the right way
2807          to match the longer operand.  */
2808       primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
2809                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2810
2811       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2812         return 1;
2813     }
2814
2815   return 0;
2816 }
2817 \f
2818 /* See if ARG is an expression that is either a comparison or is performing
2819    arithmetic on comparisons.  The comparisons must only be comparing
2820    two different values, which will be stored in *CVAL1 and *CVAL2; if
2821    they are nonzero it means that some operands have already been found.
2822    No variables may be used anywhere else in the expression except in the
2823    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2824    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2825
2826    If this is true, return 1.  Otherwise, return zero.  */
2827
2828 static int
2829 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2830 {
2831   enum tree_code code = TREE_CODE (arg);
2832   enum tree_code_class class = TREE_CODE_CLASS (code);
2833
2834   /* We can handle some of the tcc_expression cases here.  */
2835   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
2836     class = tcc_unary;
2837   else if (class == tcc_expression
2838            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2839                || code == COMPOUND_EXPR))
2840     class = tcc_binary;
2841
2842   else if (class == tcc_expression && code == SAVE_EXPR
2843            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2844     {
2845       /* If we've already found a CVAL1 or CVAL2, this expression is
2846          two complex to handle.  */
2847       if (*cval1 || *cval2)
2848         return 0;
2849
2850       class = tcc_unary;
2851       *save_p = 1;
2852     }
2853
2854   switch (class)
2855     {
2856     case tcc_unary:
2857       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2858
2859     case tcc_binary:
2860       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2861               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2862                                       cval1, cval2, save_p));
2863
2864     case tcc_constant:
2865       return 1;
2866
2867     case tcc_expression:
2868       if (code == COND_EXPR)
2869         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2870                                      cval1, cval2, save_p)
2871                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2872                                         cval1, cval2, save_p)
2873                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2874                                         cval1, cval2, save_p));
2875       return 0;
2876
2877     case tcc_comparison:
2878       /* First see if we can handle the first operand, then the second.  For
2879          the second operand, we know *CVAL1 can't be zero.  It must be that
2880          one side of the comparison is each of the values; test for the
2881          case where this isn't true by failing if the two operands
2882          are the same.  */
2883
2884       if (operand_equal_p (TREE_OPERAND (arg, 0),
2885                            TREE_OPERAND (arg, 1), 0))
2886         return 0;
2887
2888       if (*cval1 == 0)
2889         *cval1 = TREE_OPERAND (arg, 0);
2890       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2891         ;
2892       else if (*cval2 == 0)
2893         *cval2 = TREE_OPERAND (arg, 0);
2894       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2895         ;
2896       else
2897         return 0;
2898
2899       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2900         ;
2901       else if (*cval2 == 0)
2902         *cval2 = TREE_OPERAND (arg, 1);
2903       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2904         ;
2905       else
2906         return 0;
2907
2908       return 1;
2909
2910     default:
2911       return 0;
2912     }
2913 }
2914 \f
2915 /* ARG is a tree that is known to contain just arithmetic operations and
2916    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2917    any occurrence of OLD0 as an operand of a comparison and likewise for
2918    NEW1 and OLD1.  */
2919
2920 static tree
2921 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
2922 {
2923   tree type = TREE_TYPE (arg);
2924   enum tree_code code = TREE_CODE (arg);
2925   enum tree_code_class class = TREE_CODE_CLASS (code);
2926
2927   /* We can handle some of the tcc_expression cases here.  */
2928   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
2929     class = tcc_unary;
2930   else if (class == tcc_expression
2931            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2932     class = tcc_binary;
2933
2934   switch (class)
2935     {
2936     case tcc_unary:
2937       return fold_build1 (code, type,
2938                           eval_subst (TREE_OPERAND (arg, 0),
2939                                       old0, new0, old1, new1));
2940
2941     case tcc_binary:
2942       return fold_build2 (code, type,
2943                           eval_subst (TREE_OPERAND (arg, 0),
2944                                       old0, new0, old1, new1),
2945                           eval_subst (TREE_OPERAND (arg, 1),
2946                                       old0, new0, old1, new1));
2947
2948     case tcc_expression:
2949       switch (code)
2950         {
2951         case SAVE_EXPR:
2952           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2953
2954         case COMPOUND_EXPR:
2955           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2956
2957         case COND_EXPR:
2958           return fold_build3 (code, type,
2959                               eval_subst (TREE_OPERAND (arg, 0),
2960                                           old0, new0, old1, new1),
2961                               eval_subst (TREE_OPERAND (arg, 1),
2962                                           old0, new0, old1, new1),
2963                               eval_subst (TREE_OPERAND (arg, 2),
2964                                           old0, new0, old1, new1));
2965         default:
2966           break;
2967         }
2968       /* Fall through - ???  */
2969
2970     case tcc_comparison:
2971       {
2972         tree arg0 = TREE_OPERAND (arg, 0);
2973         tree arg1 = TREE_OPERAND (arg, 1);
2974
2975         /* We need to check both for exact equality and tree equality.  The
2976            former will be true if the operand has a side-effect.  In that
2977            case, we know the operand occurred exactly once.  */
2978
2979         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2980           arg0 = new0;
2981         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2982           arg0 = new1;
2983
2984         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2985           arg1 = new0;
2986         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2987           arg1 = new1;
2988
2989         return fold_build2 (code, type, arg0, arg1);
2990       }
2991
2992     default:
2993       return arg;
2994     }
2995 }
2996 \f
2997 /* Return a tree for the case when the result of an expression is RESULT
2998    converted to TYPE and OMITTED was previously an operand of the expression
2999    but is now not needed (e.g., we folded OMITTED * 0).
3000
3001    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
3002    the conversion of RESULT to TYPE.  */
3003
3004 tree
3005 omit_one_operand (tree type, tree result, tree omitted)
3006 {
3007   tree t = fold_convert (type, result);
3008
3009   if (TREE_SIDE_EFFECTS (omitted))
3010     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3011
3012   return non_lvalue (t);
3013 }
3014
3015 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
3016
3017 static tree
3018 pedantic_omit_one_operand (tree type, tree result, tree omitted)
3019 {
3020   tree t = fold_convert (type, result);
3021
3022   if (TREE_SIDE_EFFECTS (omitted))
3023     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3024
3025   return pedantic_non_lvalue (t);
3026 }
3027
3028 /* Return a tree for the case when the result of an expression is RESULT
3029    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3030    of the expression but are now not needed.
3031
3032    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3033    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3034    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3035    just do the conversion of RESULT to TYPE.  */
3036
3037 tree
3038 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3039 {
3040   tree t = fold_convert (type, result);
3041
3042   if (TREE_SIDE_EFFECTS (omitted2))
3043     t = build2 (COMPOUND_EXPR, type, omitted2, t);
3044   if (TREE_SIDE_EFFECTS (omitted1))
3045     t = build2 (COMPOUND_EXPR, type, omitted1, t);
3046
3047   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3048 }
3049
3050 \f
3051 /* Return a simplified tree node for the truth-negation of ARG.  This
3052    never alters ARG itself.  We assume that ARG is an operation that
3053    returns a truth value (0 or 1).
3054
3055    FIXME: one would think we would fold the result, but it causes
3056    problems with the dominator optimizer.  */
3057
3058 tree
3059 fold_truth_not_expr (tree arg)
3060 {
3061   tree type = TREE_TYPE (arg);
3062   enum tree_code code = TREE_CODE (arg);
3063
3064   /* If this is a comparison, we can simply invert it, except for
3065      floating-point non-equality comparisons, in which case we just
3066      enclose a TRUTH_NOT_EXPR around what we have.  */
3067
3068   if (TREE_CODE_CLASS (code) == tcc_comparison)
3069     {
3070       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3071       if (FLOAT_TYPE_P (op_type)
3072           && flag_trapping_math
3073           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3074           && code != NE_EXPR && code != EQ_EXPR)
3075         return NULL_TREE;
3076       else
3077         {
3078           code = invert_tree_comparison (code,
3079                                          HONOR_NANS (TYPE_MODE (op_type)));
3080           if (code == ERROR_MARK)
3081             return NULL_TREE;
3082           else
3083             return build2 (code, type,
3084                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3085         }
3086     }
3087
3088   switch (code)
3089     {
3090     case INTEGER_CST:
3091       return constant_boolean_node (integer_zerop (arg), type);
3092
3093     case TRUTH_AND_EXPR:
3094       return build2 (TRUTH_OR_EXPR, type,
3095                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3096                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3097
3098     case TRUTH_OR_EXPR:
3099       return build2 (TRUTH_AND_EXPR, type,
3100                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3101                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3102
3103     case TRUTH_XOR_EXPR:
3104       /* Here we can invert either operand.  We invert the first operand
3105          unless the second operand is a TRUTH_NOT_EXPR in which case our
3106          result is the XOR of the first operand with the inside of the
3107          negation of the second operand.  */
3108
3109       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3110         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3111                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3112       else
3113         return build2 (TRUTH_XOR_EXPR, type,
3114                        invert_truthvalue (TREE_OPERAND (arg, 0)),
3115                        TREE_OPERAND (arg, 1));
3116
3117     case TRUTH_ANDIF_EXPR:
3118       return build2 (TRUTH_ORIF_EXPR, type,
3119                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3120                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3121
3122     case TRUTH_ORIF_EXPR:
3123       return build2 (TRUTH_ANDIF_EXPR, type,
3124                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3125                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3126
3127     case TRUTH_NOT_EXPR:
3128       return TREE_OPERAND (arg, 0);
3129
3130     case COND_EXPR:
3131       {
3132         tree arg1 = TREE_OPERAND (arg, 1);
3133         tree arg2 = TREE_OPERAND (arg, 2);
3134         /* A COND_EXPR may have a throw as one operand, which
3135            then has void type.  Just leave void operands
3136            as they are.  */
3137         return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3138                        VOID_TYPE_P (TREE_TYPE (arg1))
3139                        ? arg1 : invert_truthvalue (arg1),
3140                        VOID_TYPE_P (TREE_TYPE (arg2))
3141                        ? arg2 : invert_truthvalue (arg2));
3142       }
3143
3144     case COMPOUND_EXPR:
3145       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3146                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3147
3148     case NON_LVALUE_EXPR:
3149       return invert_truthvalue (TREE_OPERAND (arg, 0));
3150
3151     case NOP_EXPR:
3152       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3153         return build1 (TRUTH_NOT_EXPR, type, arg);
3154
3155     case CONVERT_EXPR:
3156     case FLOAT_EXPR:
3157       return build1 (TREE_CODE (arg), type,
3158                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3159
3160     case BIT_AND_EXPR:
3161       if (!integer_onep (TREE_OPERAND (arg, 1)))
3162         break;
3163       return build2 (EQ_EXPR, type, arg,
3164                      build_int_cst (type, 0));
3165
3166     case SAVE_EXPR:
3167       return build1 (TRUTH_NOT_EXPR, type, arg);
3168
3169     case CLEANUP_POINT_EXPR:
3170       return build1 (CLEANUP_POINT_EXPR, type,
3171                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3172
3173     default:
3174       break;
3175     }
3176
3177   return NULL_TREE;
3178 }
3179
3180 /* Return a simplified tree node for the truth-negation of ARG.  This
3181    never alters ARG itself.  We assume that ARG is an operation that
3182    returns a truth value (0 or 1).
3183
3184    FIXME: one would think we would fold the result, but it causes
3185    problems with the dominator optimizer.  */
3186
3187 tree
3188 invert_truthvalue (tree arg)
3189 {
3190   tree tem;
3191
3192   if (TREE_CODE (arg) == ERROR_MARK)
3193     return arg;
3194
3195   tem = fold_truth_not_expr (arg);
3196   if (!tem)
3197     tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3198
3199   return tem;
3200 }
3201
3202 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3203    operands are another bit-wise operation with a common input.  If so,
3204    distribute the bit operations to save an operation and possibly two if
3205    constants are involved.  For example, convert
3206         (A | B) & (A | C) into A | (B & C)
3207    Further simplification will occur if B and C are constants.
3208
3209    If this optimization cannot be done, 0 will be returned.  */
3210
3211 static tree
3212 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3213 {
3214   tree common;
3215   tree left, right;
3216
3217   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3218       || TREE_CODE (arg0) == code
3219       || (TREE_CODE (arg0) != BIT_AND_EXPR
3220           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3221     return 0;
3222
3223   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3224     {
3225       common = TREE_OPERAND (arg0, 0);
3226       left = TREE_OPERAND (arg0, 1);
3227       right = TREE_OPERAND (arg1, 1);
3228     }
3229   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3230     {
3231       common = TREE_OPERAND (arg0, 0);
3232       left = TREE_OPERAND (arg0, 1);
3233       right = TREE_OPERAND (arg1, 0);
3234     }
3235   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3236     {
3237       common = TREE_OPERAND (arg0, 1);
3238       left = TREE_OPERAND (arg0, 0);
3239       right = TREE_OPERAND (arg1, 1);
3240     }
3241   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3242     {
3243       common = TREE_OPERAND (arg0, 1);
3244       left = TREE_OPERAND (arg0, 0);
3245       right = TREE_OPERAND (arg1, 0);
3246     }
3247   else
3248     return 0;
3249
3250   return fold_build2 (TREE_CODE (arg0), type, common,
3251                       fold_build2 (code, type, left, right));
3252 }
3253
3254 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3255    with code CODE.  This optimization is unsafe.  */
3256 static tree
3257 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3258 {
3259   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3260   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3261
3262   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3263   if (mul0 == mul1
3264       && operand_equal_p (TREE_OPERAND (arg0, 1),
3265                        TREE_OPERAND (arg1, 1), 0))
3266     return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3267                         fold_build2 (code, type,
3268                                      TREE_OPERAND (arg0, 0),
3269                                      TREE_OPERAND (arg1, 0)),
3270                         TREE_OPERAND (arg0, 1));
3271
3272   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3273   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3274                        TREE_OPERAND (arg1, 0), 0)
3275       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3276       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3277     {
3278       REAL_VALUE_TYPE r0, r1;
3279       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3280       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3281       if (!mul0)
3282         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3283       if (!mul1)
3284         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3285       real_arithmetic (&r0, code, &r0, &r1);
3286       return fold_build2 (MULT_EXPR, type,
3287                           TREE_OPERAND (arg0, 0),
3288                           build_real (type, r0));
3289     }
3290
3291   return NULL_TREE;
3292 }
3293 \f
3294 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3295    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3296
3297 static tree
3298 make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos,
3299                     int unsignedp)
3300 {
3301   tree result;
3302
3303   if (bitpos == 0)
3304     {
3305       tree size = TYPE_SIZE (TREE_TYPE (inner));
3306       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3307            || POINTER_TYPE_P (TREE_TYPE (inner)))
3308           && host_integerp (size, 0)
3309           && tree_low_cst (size, 0) == bitsize)
3310         return fold_convert (type, inner);
3311     }
3312
3313   result = build3 (BIT_FIELD_REF, type, inner,
3314                    size_int (bitsize), bitsize_int (bitpos));
3315
3316   BIT_FIELD_REF_UNSIGNED (result) = unsignedp;
3317
3318   return result;
3319 }
3320
3321 /* Optimize a bit-field compare.
3322
3323    There are two cases:  First is a compare against a constant and the
3324    second is a comparison of two items where the fields are at the same
3325    bit position relative to the start of a chunk (byte, halfword, word)
3326    large enough to contain it.  In these cases we can avoid the shift
3327    implicit in bitfield extractions.
3328
3329    For constants, we emit a compare of the shifted constant with the
3330    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3331    compared.  For two fields at the same position, we do the ANDs with the
3332    similar mask and compare the result of the ANDs.
3333
3334    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3335    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3336    are the left and right operands of the comparison, respectively.
3337
3338    If the optimization described above can be done, we return the resulting
3339    tree.  Otherwise we return zero.  */
3340
3341 static tree
3342 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3343                             tree lhs, tree rhs)
3344 {
3345   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3346   tree type = TREE_TYPE (lhs);
3347   tree signed_type, unsigned_type;
3348   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3349   enum machine_mode lmode, rmode, nmode;
3350   int lunsignedp, runsignedp;
3351   int lvolatilep = 0, rvolatilep = 0;
3352   tree linner, rinner = NULL_TREE;
3353   tree mask;
3354   tree offset;
3355
3356   /* Get all the information about the extractions being done.  If the bit size
3357      if the same as the size of the underlying object, we aren't doing an
3358      extraction at all and so can do nothing.  We also don't want to
3359      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3360      then will no longer be able to replace it.  */
3361   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3362                                 &lunsignedp, &lvolatilep, false);
3363   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3364       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3365     return 0;
3366
3367  if (!const_p)
3368    {
3369      /* If this is not a constant, we can only do something if bit positions,
3370         sizes, and signedness are the same.  */
3371      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3372                                    &runsignedp, &rvolatilep, false);
3373
3374      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3375          || lunsignedp != runsignedp || offset != 0
3376          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3377        return 0;
3378    }
3379
3380   /* See if we can find a mode to refer to this field.  We should be able to,
3381      but fail if we can't.  */
3382   nmode = get_best_mode (lbitsize, lbitpos,
3383                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3384                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3385                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3386                          word_mode, lvolatilep || rvolatilep);
3387   if (nmode == VOIDmode)
3388     return 0;
3389
3390   /* Set signed and unsigned types of the precision of this mode for the
3391      shifts below.  */
3392   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3393   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3394
3395   /* Compute the bit position and size for the new reference and our offset
3396      within it. If the new reference is the same size as the original, we
3397      won't optimize anything, so return zero.  */
3398   nbitsize = GET_MODE_BITSIZE (nmode);
3399   nbitpos = lbitpos & ~ (nbitsize - 1);
3400   lbitpos -= nbitpos;
3401   if (nbitsize == lbitsize)
3402     return 0;
3403
3404   if (BYTES_BIG_ENDIAN)
3405     lbitpos = nbitsize - lbitsize - lbitpos;
3406
3407   /* Make the mask to be used against the extracted field.  */
3408   mask = build_int_cst (unsigned_type, -1);
3409   mask = force_fit_type (mask, 0, false, false);
3410   mask = fold_convert (unsigned_type, mask);
3411   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3412   mask = const_binop (RSHIFT_EXPR, mask,
3413                       size_int (nbitsize - lbitsize - lbitpos), 0);
3414
3415   if (! const_p)
3416     /* If not comparing with constant, just rework the comparison
3417        and return.  */
3418     return build2 (code, compare_type,
3419                    build2 (BIT_AND_EXPR, unsigned_type,
3420                            make_bit_field_ref (linner, unsigned_type,
3421                                                nbitsize, nbitpos, 1),
3422                            mask),
3423                    build2 (BIT_AND_EXPR, unsigned_type,
3424                            make_bit_field_ref (rinner, unsigned_type,
3425                                                nbitsize, nbitpos, 1),
3426                            mask));
3427
3428   /* Otherwise, we are handling the constant case. See if the constant is too
3429      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3430      this not only for its own sake, but to avoid having to test for this
3431      error case below.  If we didn't, we might generate wrong code.
3432
3433      For unsigned fields, the constant shifted right by the field length should
3434      be all zero.  For signed fields, the high-order bits should agree with
3435      the sign bit.  */
3436
3437   if (lunsignedp)
3438     {
3439       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3440                                         fold_convert (unsigned_type, rhs),
3441                                         size_int (lbitsize), 0)))
3442         {
3443           warning (0, "comparison is always %d due to width of bit-field",
3444                    code == NE_EXPR);
3445           return constant_boolean_node (code == NE_EXPR, compare_type);
3446         }
3447     }
3448   else
3449     {
3450       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3451                               size_int (lbitsize - 1), 0);
3452       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3453         {
3454           warning (0, "comparison is always %d due to width of bit-field",
3455                    code == NE_EXPR);
3456           return constant_boolean_node (code == NE_EXPR, compare_type);
3457         }
3458     }
3459
3460   /* Single-bit compares should always be against zero.  */
3461   if (lbitsize == 1 && ! integer_zerop (rhs))
3462     {
3463       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3464       rhs = build_int_cst (type, 0);
3465     }
3466
3467   /* Make a new bitfield reference, shift the constant over the
3468      appropriate number of bits and mask it with the computed mask
3469      (in case this was a signed field).  If we changed it, make a new one.  */
3470   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3471   if (lvolatilep)
3472     {
3473       TREE_SIDE_EFFECTS (lhs) = 1;
3474       TREE_THIS_VOLATILE (lhs) = 1;
3475     }
3476
3477   rhs = const_binop (BIT_AND_EXPR,
3478                      const_binop (LSHIFT_EXPR,
3479                                   fold_convert (unsigned_type, rhs),
3480                                   size_int (lbitpos), 0),
3481                      mask, 0);
3482
3483   return build2 (code, compare_type,
3484                  build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
3485                  rhs);
3486 }
3487 \f
3488 /* Subroutine for fold_truthop: decode a field reference.
3489
3490    If EXP is a comparison reference, we return the innermost reference.
3491
3492    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3493    set to the starting bit number.
3494
3495    If the innermost field can be completely contained in a mode-sized
3496    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3497
3498    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3499    otherwise it is not changed.
3500
3501    *PUNSIGNEDP is set to the signedness of the field.
3502
3503    *PMASK is set to the mask used.  This is either contained in a
3504    BIT_AND_EXPR or derived from the width of the field.
3505
3506    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3507
3508    Return 0 if this is not a component reference or is one that we can't
3509    do anything with.  */
3510
3511 static tree
3512 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
3513                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3514                         int *punsignedp, int *pvolatilep,
3515                         tree *pmask, tree *pand_mask)
3516 {
3517   tree outer_type = 0;
3518   tree and_mask = 0;
3519   tree mask, inner, offset;
3520   tree unsigned_type;
3521   unsigned int precision;
3522
3523   /* All the optimizations using this function assume integer fields.
3524      There are problems with FP fields since the type_for_size call
3525      below can fail for, e.g., XFmode.  */
3526   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3527     return 0;
3528
3529   /* We are interested in the bare arrangement of bits, so strip everything
3530      that doesn't affect the machine mode.  However, record the type of the
3531      outermost expression if it may matter below.  */
3532   if (TREE_CODE (exp) == NOP_EXPR
3533       || TREE_CODE (exp) == CONVERT_EXPR
3534       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3535     outer_type = TREE_TYPE (exp);
3536   STRIP_NOPS (exp);
3537
3538   if (TREE_CODE (exp) == BIT_AND_EXPR)
3539     {
3540       and_mask = TREE_OPERAND (exp, 1);
3541       exp = TREE_OPERAND (exp, 0);
3542       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3543       if (TREE_CODE (and_mask) != INTEGER_CST)
3544         return 0;
3545     }
3546
3547   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3548                                punsignedp, pvolatilep, false);
3549   if ((inner == exp && and_mask == 0)
3550       || *pbitsize < 0 || offset != 0
3551       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3552     return 0;
3553
3554   /* If the number of bits in the reference is the same as the bitsize of
3555      the outer type, then the outer type gives the signedness. Otherwise
3556      (in case of a small bitfield) the signedness is unchanged.  */
3557   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3558     *punsignedp = TYPE_UNSIGNED (outer_type);
3559
3560   /* Compute the mask to access the bitfield.  */
3561   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3562   precision = TYPE_PRECISION (unsigned_type);
3563
3564   mask = build_int_cst (unsigned_type, -1);
3565   mask = force_fit_type (mask, 0, false, false);
3566
3567   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3568   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3569
3570   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3571   if (and_mask != 0)
3572     mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
3573                         fold_convert (unsigned_type, and_mask), mask);
3574
3575   *pmask = mask;
3576   *pand_mask = and_mask;
3577   return inner;
3578 }
3579
3580 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3581    bit positions.  */
3582
3583 static int
3584 all_ones_mask_p (tree mask, int size)
3585 {
3586   tree type = TREE_TYPE (mask);
3587   unsigned int precision = TYPE_PRECISION (type);
3588   tree tmask;
3589
3590   tmask = build_int_cst (lang_hooks.types.signed_type (type), -1);
3591   tmask = force_fit_type (tmask, 0, false, false);
3592
3593   return
3594     tree_int_cst_equal (mask,
3595                         const_binop (RSHIFT_EXPR,
3596                                      const_binop (LSHIFT_EXPR, tmask,
3597                                                   size_int (precision - size),
3598                                                   0),
3599                                      size_int (precision - size), 0));
3600 }
3601
3602 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3603    represents the sign bit of EXP's type.  If EXP represents a sign
3604    or zero extension, also test VAL against the unextended type.
3605    The return value is the (sub)expression whose sign bit is VAL,
3606    or NULL_TREE otherwise.  */
3607
3608 static tree
3609 sign_bit_p (tree exp, tree val)
3610 {
3611   unsigned HOST_WIDE_INT mask_lo, lo;
3612   HOST_WIDE_INT mask_hi, hi;
3613   int width;
3614   tree t;
3615
3616   /* Tree EXP must have an integral type.  */
3617   t = TREE_TYPE (exp);
3618   if (! INTEGRAL_TYPE_P (t))
3619     return NULL_TREE;
3620
3621   /* Tree VAL must be an integer constant.  */
3622   if (TREE_CODE (val) != INTEGER_CST
3623       || TREE_CONSTANT_OVERFLOW (val))
3624     return NULL_TREE;
3625
3626   width = TYPE_PRECISION (t);
3627   if (width > HOST_BITS_PER_WIDE_INT)
3628     {
3629       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3630       lo = 0;
3631
3632       mask_hi = ((unsigned HOST_WIDE_INT) -1
3633                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3634       mask_lo = -1;
3635     }
3636   else
3637     {
3638       hi = 0;
3639       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3640
3641       mask_hi = 0;
3642       mask_lo = ((unsigned HOST_WIDE_INT) -1
3643                  >> (HOST_BITS_PER_WIDE_INT - width));
3644     }
3645
3646   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3647      treat VAL as if it were unsigned.  */
3648   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3649       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3650     return exp;
3651
3652   /* Handle extension from a narrower type.  */
3653   if (TREE_CODE (exp) == NOP_EXPR
3654       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3655     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3656
3657   return NULL_TREE;
3658 }
3659
3660 /* Subroutine for fold_truthop: determine if an operand is simple enough
3661    to be evaluated unconditionally.  */
3662
3663 static int
3664 simple_operand_p (tree exp)
3665 {
3666   /* Strip any conversions that don't change the machine mode.  */
3667   STRIP_NOPS (exp);
3668
3669   return (CONSTANT_CLASS_P (exp)
3670           || TREE_CODE (exp) == SSA_NAME
3671           || (DECL_P (exp)
3672               && ! TREE_ADDRESSABLE (exp)
3673               && ! TREE_THIS_VOLATILE (exp)
3674               && ! DECL_NONLOCAL (exp)
3675               /* Don't regard global variables as simple.  They may be
3676                  allocated in ways unknown to the compiler (shared memory,
3677                  #pragma weak, etc).  */
3678               && ! TREE_PUBLIC (exp)
3679               && ! DECL_EXTERNAL (exp)
3680               /* Loading a static variable is unduly expensive, but global
3681                  registers aren't expensive.  */
3682               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3683 }
3684 \f
3685 /* The following functions are subroutines to fold_range_test and allow it to
3686    try to change a logical combination of comparisons into a range test.
3687
3688    For example, both
3689         X == 2 || X == 3 || X == 4 || X == 5
3690    and
3691         X >= 2 && X <= 5
3692    are converted to
3693         (unsigned) (X - 2) <= 3
3694
3695    We describe each set of comparisons as being either inside or outside
3696    a range, using a variable named like IN_P, and then describe the
3697    range with a lower and upper bound.  If one of the bounds is omitted,
3698    it represents either the highest or lowest value of the type.
3699
3700    In the comments below, we represent a range by two numbers in brackets
3701    preceded by a "+" to designate being inside that range, or a "-" to
3702    designate being outside that range, so the condition can be inverted by
3703    flipping the prefix.  An omitted bound is represented by a "-".  For
3704    example, "- [-, 10]" means being outside the range starting at the lowest
3705    possible value and ending at 10, in other words, being greater than 10.
3706    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3707    always false.
3708
3709    We set up things so that the missing bounds are handled in a consistent
3710    manner so neither a missing bound nor "true" and "false" need to be
3711    handled using a special case.  */
3712
3713 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3714    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3715    and UPPER1_P are nonzero if the respective argument is an upper bound
3716    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3717    must be specified for a comparison.  ARG1 will be converted to ARG0's
3718    type if both are specified.  */
3719
3720 static tree
3721 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3722              tree arg1, int upper1_p)
3723 {
3724   tree tem;
3725   int result;
3726   int sgn0, sgn1;
3727
3728   /* If neither arg represents infinity, do the normal operation.
3729      Else, if not a comparison, return infinity.  Else handle the special
3730      comparison rules. Note that most of the cases below won't occur, but
3731      are handled for consistency.  */
3732
3733   if (arg0 != 0 && arg1 != 0)
3734     {
3735       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3736                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
3737       STRIP_NOPS (tem);
3738       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3739     }
3740
3741   if (TREE_CODE_CLASS (code) != tcc_comparison)
3742     return 0;
3743
3744   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3745      for neither.  In real maths, we cannot assume open ended ranges are
3746      the same. But, this is computer arithmetic, where numbers are finite.
3747      We can therefore make the transformation of any unbounded range with
3748      the value Z, Z being greater than any representable number. This permits
3749      us to treat unbounded ranges as equal.  */
3750   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3751   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3752   switch (code)
3753     {
3754     case EQ_EXPR:
3755       result = sgn0 == sgn1;
3756       break;
3757     case NE_EXPR:
3758       result = sgn0 != sgn1;
3759       break;
3760     case LT_EXPR:
3761       result = sgn0 < sgn1;
3762       break;
3763     case LE_EXPR:
3764       result = sgn0 <= sgn1;
3765       break;
3766     case GT_EXPR:
3767       result = sgn0 > sgn1;
3768       break;
3769     case GE_EXPR:
3770       result = sgn0 >= sgn1;
3771       break;
3772     default:
3773       gcc_unreachable ();
3774     }
3775
3776   return constant_boolean_node (result, type);
3777 }
3778 \f
3779 /* Given EXP, a logical expression, set the range it is testing into
3780    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3781    actually being tested.  *PLOW and *PHIGH will be made of the same type
3782    as the returned expression.  If EXP is not a comparison, we will most
3783    likely not be returning a useful value and range.  */
3784
3785 static tree
3786 make_range (tree exp, int *pin_p, tree *plow, tree *phigh)
3787 {
3788   enum tree_code code;
3789   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
3790   tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
3791   int in_p, n_in_p;
3792   tree low, high, n_low, n_high;
3793
3794   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3795      and see if we can refine the range.  Some of the cases below may not
3796      happen, but it doesn't seem worth worrying about this.  We "continue"
3797      the outer loop when we've changed something; otherwise we "break"
3798      the switch, which will "break" the while.  */
3799
3800   in_p = 0;
3801   low = high = build_int_cst (TREE_TYPE (exp), 0);
3802
3803   while (1)
3804     {
3805       code = TREE_CODE (exp);
3806       exp_type = TREE_TYPE (exp);
3807
3808       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3809         {
3810           if (TREE_CODE_LENGTH (code) > 0)
3811             arg0 = TREE_OPERAND (exp, 0);
3812           if (TREE_CODE_CLASS (code) == tcc_comparison
3813               || TREE_CODE_CLASS (code) == tcc_unary
3814               || TREE_CODE_CLASS (code) == tcc_binary)
3815             arg0_type = TREE_TYPE (arg0);
3816           if (TREE_CODE_CLASS (code) == tcc_binary
3817               || TREE_CODE_CLASS (code) == tcc_comparison
3818               || (TREE_CODE_CLASS (code) == tcc_expression
3819                   && TREE_CODE_LENGTH (code) > 1))
3820             arg1 = TREE_OPERAND (exp, 1);
3821         }
3822
3823       switch (code)
3824         {
3825         case TRUTH_NOT_EXPR:
3826           in_p = ! in_p, exp = arg0;
3827           continue;
3828
3829         case EQ_EXPR: case NE_EXPR:
3830         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3831           /* We can only do something if the range is testing for zero
3832              and if the second operand is an integer constant.  Note that
3833              saying something is "in" the range we make is done by
3834              complementing IN_P since it will set in the initial case of
3835              being not equal to zero; "out" is leaving it alone.  */
3836           if (low == 0 || high == 0
3837               || ! integer_zerop (low) || ! integer_zerop (high)
3838               || TREE_CODE (arg1) != INTEGER_CST)
3839             break;
3840
3841           switch (code)
3842             {
3843             case NE_EXPR:  /* - [c, c]  */
3844               low = high = arg1;
3845               break;
3846             case EQ_EXPR:  /* + [c, c]  */
3847               in_p = ! in_p, low = high = arg1;
3848               break;
3849             case GT_EXPR:  /* - [-, c] */
3850               low = 0, high = arg1;
3851               break;
3852             case GE_EXPR:  /* + [c, -] */
3853               in_p = ! in_p, low = arg1, high = 0;
3854               break;
3855             case LT_EXPR:  /* - [c, -] */
3856               low = arg1, high = 0;
3857               break;
3858             case LE_EXPR:  /* + [-, c] */
3859               in_p = ! in_p, low = 0, high = arg1;
3860               break;
3861             default:
3862               gcc_unreachable ();
3863             }
3864
3865           /* If this is an unsigned comparison, we also know that EXP is
3866              greater than or equal to zero.  We base the range tests we make
3867              on that fact, so we record it here so we can parse existing
3868              range tests.  We test arg0_type since often the return type
3869              of, e.g. EQ_EXPR, is boolean.  */
3870           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3871             {
3872               if (! merge_ranges (&n_in_p, &n_low, &n_high,
3873                                   in_p, low, high, 1,
3874                                   build_int_cst (arg0_type, 0),
3875                                   NULL_TREE))
3876                 break;
3877
3878               in_p = n_in_p, low = n_low, high = n_high;
3879
3880               /* If the high bound is missing, but we have a nonzero low
3881                  bound, reverse the range so it goes from zero to the low bound
3882                  minus 1.  */
3883               if (high == 0 && low && ! integer_zerop (low))
3884                 {
3885                   in_p = ! in_p;
3886                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3887                                       integer_one_node, 0);
3888                   low = build_int_cst (arg0_type, 0);
3889                 }
3890             }
3891
3892           exp = arg0;
3893           continue;
3894
3895         case NEGATE_EXPR:
3896           /* (-x) IN [a,b] -> x in [-b, -a]  */
3897           n_low = range_binop (MINUS_EXPR, exp_type,
3898                                build_int_cst (exp_type, 0),
3899                                0, high, 1);
3900           n_high = range_binop (MINUS_EXPR, exp_type,
3901                                 build_int_cst (exp_type, 0),
3902                                 0, low, 0);
3903           low = n_low, high = n_high;
3904           exp = arg0;
3905           continue;
3906
3907         case BIT_NOT_EXPR:
3908           /* ~ X -> -X - 1  */
3909           exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
3910                         build_int_cst (exp_type, 1));
3911           continue;
3912
3913         case PLUS_EXPR:  case MINUS_EXPR:
3914           if (TREE_CODE (arg1) != INTEGER_CST)
3915             break;
3916
3917           /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
3918              move a constant to the other side.  */
3919           if (flag_wrapv && !TYPE_UNSIGNED (arg0_type))
3920             break;
3921
3922           /* If EXP is signed, any overflow in the computation is undefined,
3923              so we don't worry about it so long as our computations on
3924              the bounds don't overflow.  For unsigned, overflow is defined
3925              and this is exactly the right thing.  */
3926           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3927                                arg0_type, low, 0, arg1, 0);
3928           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3929                                 arg0_type, high, 1, arg1, 0);
3930           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3931               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3932             break;
3933
3934           /* Check for an unsigned range which has wrapped around the maximum
3935              value thus making n_high < n_low, and normalize it.  */
3936           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3937             {
3938               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
3939                                  integer_one_node, 0);
3940               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
3941                                   integer_one_node, 0);
3942
3943               /* If the range is of the form +/- [ x+1, x ], we won't
3944                  be able to normalize it.  But then, it represents the
3945                  whole range or the empty set, so make it
3946                  +/- [ -, - ].  */
3947               if (tree_int_cst_equal (n_low, low)
3948                   && tree_int_cst_equal (n_high, high))
3949                 low = high = 0;
3950               else
3951                 in_p = ! in_p;
3952             }
3953           else
3954             low = n_low, high = n_high;
3955
3956           exp = arg0;
3957           continue;
3958
3959         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
3960           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
3961             break;
3962
3963           if (! INTEGRAL_TYPE_P (arg0_type)
3964               || (low != 0 && ! int_fits_type_p (low, arg0_type))
3965               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
3966             break;
3967
3968           n_low = low, n_high = high;
3969
3970           if (n_low != 0)
3971             n_low = fold_convert (arg0_type, n_low);
3972
3973           if (n_high != 0)
3974             n_high = fold_convert (arg0_type, n_high);
3975
3976
3977           /* If we're converting arg0 from an unsigned type, to exp,
3978              a signed type,  we will be doing the comparison as unsigned.
3979              The tests above have already verified that LOW and HIGH
3980              are both positive.
3981
3982              So we have to ensure that we will handle large unsigned
3983              values the same way that the current signed bounds treat
3984              negative values.  */
3985
3986           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
3987             {
3988               tree high_positive;
3989               tree equiv_type = lang_hooks.types.type_for_mode
3990                 (TYPE_MODE (arg0_type), 1);
3991
3992               /* A range without an upper bound is, naturally, unbounded.
3993                  Since convert would have cropped a very large value, use
3994                  the max value for the destination type.  */
3995               high_positive
3996                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
3997                 : TYPE_MAX_VALUE (arg0_type);
3998
3999               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4000                 high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
4001                                              fold_convert (arg0_type,
4002                                                            high_positive),
4003                                              fold_convert (arg0_type,
4004                                                            integer_one_node));
4005
4006               /* If the low bound is specified, "and" the range with the
4007                  range for which the original unsigned value will be
4008                  positive.  */
4009               if (low != 0)
4010                 {
4011                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4012                                       1, n_low, n_high, 1,
4013                                       fold_convert (arg0_type,
4014                                                     integer_zero_node),
4015                                       high_positive))
4016                     break;
4017
4018                   in_p = (n_in_p == in_p);
4019                 }
4020               else
4021                 {
4022                   /* Otherwise, "or" the range with the range of the input
4023                      that will be interpreted as negative.  */
4024                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4025                                       0, n_low, n_high, 1,
4026                                       fold_convert (arg0_type,
4027                                                     integer_zero_node),
4028                                       high_positive))
4029                     break;
4030
4031                   in_p = (in_p != n_in_p);
4032                 }
4033             }
4034
4035           exp = arg0;
4036           low = n_low, high = n_high;
4037           continue;
4038
4039         default:
4040           break;
4041         }
4042
4043       break;
4044     }
4045
4046   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4047   if (TREE_CODE (exp) == INTEGER_CST)
4048     {
4049       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4050                                                  exp, 0, low, 0))
4051                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4052                                                     exp, 1, high, 1)));
4053       low = high = 0;
4054       exp = 0;
4055     }
4056
4057   *pin_p = in_p, *plow = low, *phigh = high;
4058   return exp;
4059 }
4060 \f
4061 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4062    type, TYPE, return an expression to test if EXP is in (or out of, depending
4063    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4064
4065 static tree
4066 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
4067 {
4068   tree etype = TREE_TYPE (exp);
4069   tree value;
4070
4071 #ifdef HAVE_canonicalize_funcptr_for_compare
4072   /* Disable this optimization for function pointer expressions
4073      on targets that require function pointer canonicalization.  */
4074   if (HAVE_canonicalize_funcptr_for_compare
4075       && TREE_CODE (etype) == POINTER_TYPE
4076       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4077     return NULL_TREE;
4078 #endif
4079
4080   if (! in_p)
4081     {
4082       value = build_range_check (type, exp, 1, low, high);
4083       if (value != 0)
4084         return invert_truthvalue (value);
4085
4086       return 0;
4087     }
4088
4089   if (low == 0 && high == 0)
4090     return build_int_cst (type, 1);
4091
4092   if (low == 0)
4093     return fold_build2 (LE_EXPR, type, exp,
4094                         fold_convert (etype, high));
4095
4096   if (high == 0)
4097     return fold_build2 (GE_EXPR, type, exp,
4098                         fold_convert (etype, low));
4099
4100   if (operand_equal_p (low, high, 0))
4101     return fold_build2 (EQ_EXPR, type, exp,
4102                         fold_convert (etype, low));
4103
4104   if (integer_zerop (low))
4105     {
4106       if (! TYPE_UNSIGNED (etype))
4107         {
4108           etype = lang_hooks.types.unsigned_type (etype);
4109           high = fold_convert (etype, high);
4110           exp = fold_convert (etype, exp);
4111         }
4112       return build_range_check (type, exp, 1, 0, high);
4113     }
4114
4115   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4116   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4117     {
4118       unsigned HOST_WIDE_INT lo;
4119       HOST_WIDE_INT hi;
4120       int prec;
4121
4122       prec = TYPE_PRECISION (etype);
4123       if (prec <= HOST_BITS_PER_WIDE_INT)
4124         {
4125           hi = 0;
4126           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4127         }
4128       else
4129         {
4130           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4131           lo = (unsigned HOST_WIDE_INT) -1;
4132         }
4133
4134       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4135         {
4136           if (TYPE_UNSIGNED (etype))
4137             {
4138               etype = lang_hooks.types.signed_type (etype);
4139               exp = fold_convert (etype, exp);
4140             }
4141           return fold_build2 (GT_EXPR, type, exp,
4142                               build_int_cst (etype, 0));
4143         }
4144     }
4145
4146   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4147      This requires wrap-around arithmetics for the type of the expression.  */
4148   switch (TREE_CODE (etype))
4149     {
4150     case INTEGER_TYPE:
4151       /* There is no requirement that LOW be within the range of ETYPE
4152          if the latter is a subtype.  It must, however, be within the base
4153          type of ETYPE.  So be sure we do the subtraction in that type.  */
4154       if (TREE_TYPE (etype))
4155         etype = TREE_TYPE (etype);
4156       break;
4157
4158     case ENUMERAL_TYPE:
4159     case BOOLEAN_TYPE:
4160       etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4161                                               TYPE_UNSIGNED (etype));
4162       break;
4163
4164     default:
4165       break;
4166     }
4167
4168   /* If we don't have wrap-around arithmetics upfront, try to force it.  */
4169   if (TREE_CODE (etype) == INTEGER_TYPE
4170       && !TYPE_UNSIGNED (etype) && !flag_wrapv)
4171     {
4172       tree utype, minv, maxv;
4173
4174       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4175          for the type in question, as we rely on this here.  */
4176       utype = lang_hooks.types.unsigned_type (etype);
4177       maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
4178       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4179                           integer_one_node, 1);
4180       minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
4181
4182       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4183                                       minv, 1, maxv, 1)))
4184         etype = utype;
4185       else
4186         return 0;
4187     }
4188
4189   high = fold_convert (etype, high);
4190   low = fold_convert (etype, low);
4191   exp = fold_convert (etype, exp);
4192
4193   value = const_binop (MINUS_EXPR, high, low, 0);
4194
4195   if (value != 0 && !TREE_OVERFLOW (value))
4196     return build_range_check (type,
4197                               fold_build2 (MINUS_EXPR, etype, exp, low),
4198                               1, build_int_cst (etype, 0), value);
4199
4200   return 0;
4201 }
4202 \f
4203 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4204
4205 static tree
4206 range_predecessor (tree val)
4207 {
4208   tree type = TREE_TYPE (val);
4209
4210   if (INTEGRAL_TYPE_P (type)
4211       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4212     return 0;
4213   else
4214     return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4215 }
4216
4217 /* Return the successor of VAL in its type, handling the infinite case.  */
4218
4219 static tree
4220 range_successor (tree val)
4221 {
4222   tree type = TREE_TYPE (val);
4223
4224   if (INTEGRAL_TYPE_P (type)
4225       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4226     return 0;
4227   else
4228     return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4229 }
4230
4231 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4232    can, 0 if we can't.  Set the output range into the specified parameters.  */
4233
4234 static int
4235 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4236               tree high0, int in1_p, tree low1, tree high1)
4237 {
4238   int no_overlap;
4239   int subset;
4240   int temp;
4241   tree tem;
4242   int in_p;
4243   tree low, high;
4244   int lowequal = ((low0 == 0 && low1 == 0)
4245                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4246                                                 low0, 0, low1, 0)));
4247   int highequal = ((high0 == 0 && high1 == 0)
4248                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4249                                                  high0, 1, high1, 1)));
4250
4251   /* Make range 0 be the range that starts first, or ends last if they
4252      start at the same value.  Swap them if it isn't.  */
4253   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4254                                  low0, 0, low1, 0))
4255       || (lowequal
4256           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4257                                         high1, 1, high0, 1))))
4258     {
4259       temp = in0_p, in0_p = in1_p, in1_p = temp;
4260       tem = low0, low0 = low1, low1 = tem;
4261       tem = high0, high0 = high1, high1 = tem;
4262     }
4263
4264   /* Now flag two cases, whether the ranges are disjoint or whether the
4265      second range is totally subsumed in the first.  Note that the tests
4266      below are simplified by the ones above.  */
4267   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4268                                           high0, 1, low1, 0));
4269   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4270                                       high1, 1, high0, 1));
4271
4272   /* We now have four cases, depending on whether we are including or
4273      excluding the two ranges.  */
4274   if (in0_p && in1_p)
4275     {
4276       /* If they don't overlap, the result is false.  If the second range
4277          is a subset it is the result.  Otherwise, the range is from the start
4278          of the second to the end of the first.  */
4279       if (no_overlap)
4280         in_p = 0, low = high = 0;
4281       else if (subset)
4282         in_p = 1, low = low1, high = high1;
4283       else
4284         in_p = 1, low = low1, high = high0;
4285     }
4286
4287   else if (in0_p && ! in1_p)
4288     {
4289       /* If they don't overlap, the result is the first range.  If they are
4290          equal, the result is false.  If the second range is a subset of the
4291          first, and the ranges begin at the same place, we go from just after
4292          the end of the second range to the end of the first.  If the second
4293          range is not a subset of the first, or if it is a subset and both
4294          ranges end at the same place, the range starts at the start of the
4295          first range and ends just before the second range.
4296          Otherwise, we can't describe this as a single range.  */
4297       if (no_overlap)
4298         in_p = 1, low = low0, high = high0;
4299       else if (lowequal && highequal)
4300         in_p = 0, low = high = 0;
4301       else if (subset && lowequal)
4302         {
4303           low = range_successor (high1);
4304           high = high0;
4305           in_p = (low != 0);
4306         }
4307       else if (! subset || highequal)
4308         {
4309           low = low0;
4310           high = range_predecessor (low1);
4311           in_p = (high != 0);
4312         }
4313       else
4314         return 0;
4315     }
4316
4317   else if (! in0_p && in1_p)
4318     {
4319       /* If they don't overlap, the result is the second range.  If the second
4320          is a subset of the first, the result is false.  Otherwise,
4321          the range starts just after the first range and ends at the
4322          end of the second.  */
4323       if (no_overlap)
4324         in_p = 1, low = low1, high = high1;
4325       else if (subset || highequal)
4326         in_p = 0, low = high = 0;
4327       else
4328         {
4329           low = range_successor (high0);
4330           high = high1;
4331           in_p = (low != 0);
4332         }
4333     }
4334
4335   else
4336     {
4337       /* The case where we are excluding both ranges.  Here the complex case
4338          is if they don't overlap.  In that case, the only time we have a
4339          range is if they are adjacent.  If the second is a subset of the
4340          first, the result is the first.  Otherwise, the range to exclude
4341          starts at the beginning of the first range and ends at the end of the
4342          second.  */
4343       if (no_overlap)
4344         {
4345           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4346                                          range_successor (high0),
4347                                          1, low1, 0)))
4348             in_p = 0, low = low0, high = high1;
4349           else
4350             {
4351               /* Canonicalize - [min, x] into - [-, x].  */
4352               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4353                 switch (TREE_CODE (TREE_TYPE (low0)))
4354                   {
4355                   case ENUMERAL_TYPE:
4356                     if (TYPE_PRECISION (TREE_TYPE (low0))
4357                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4358                       break;
4359                     /* FALLTHROUGH */
4360                   case INTEGER_TYPE:
4361                     if (tree_int_cst_equal (low0,
4362                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4363                       low0 = 0;
4364                     break;
4365                   case POINTER_TYPE:
4366                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4367                         && integer_zerop (low0))
4368                       low0 = 0;
4369                     break;
4370                   default:
4371                     break;
4372                   }
4373
4374               /* Canonicalize - [x, max] into - [x, -].  */
4375               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4376                 switch (TREE_CODE (TREE_TYPE (high1)))
4377                   {
4378                   case ENUMERAL_TYPE:
4379                     if (TYPE_PRECISION (TREE_TYPE (high1))
4380                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4381                       break;
4382                     /* FALLTHROUGH */
4383                   case INTEGER_TYPE:
4384                     if (tree_int_cst_equal (high1,
4385                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4386                       high1 = 0;
4387                     break;
4388                   case POINTER_TYPE:
4389                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4390                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4391                                                        high1, 1,
4392                                                        integer_one_node, 1)))
4393                       high1 = 0;
4394                     break;
4395                   default:
4396                     break;
4397                   }
4398
4399               /* The ranges might be also adjacent between the maximum and
4400                  minimum values of the given type.  For
4401                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4402                  return + [x + 1, y - 1].  */
4403               if (low0 == 0 && high1 == 0)
4404                 {
4405                   low = range_successor (high0);
4406                   high = range_predecessor (low1);
4407                   if (low == 0 || high == 0)
4408                     return 0;
4409
4410                   in_p = 1;
4411                 }
4412               else
4413                 return 0;
4414             }
4415         }
4416       else if (subset)
4417         in_p = 0, low = low0, high = high0;
4418       else
4419         in_p = 0, low = low0, high = high1;
4420     }
4421
4422   *pin_p = in_p, *plow = low, *phigh = high;
4423   return 1;
4424 }
4425 \f
4426
4427 /* Subroutine of fold, looking inside expressions of the form
4428    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4429    of the COND_EXPR.  This function is being used also to optimize
4430    A op B ? C : A, by reversing the comparison first.
4431
4432    Return a folded expression whose code is not a COND_EXPR
4433    anymore, or NULL_TREE if no folding opportunity is found.  */
4434
4435 static tree
4436 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
4437 {
4438   enum tree_code comp_code = TREE_CODE (arg0);
4439   tree arg00 = TREE_OPERAND (arg0, 0);
4440   tree arg01 = TREE_OPERAND (arg0, 1);
4441   tree arg1_type = TREE_TYPE (arg1);
4442   tree tem;
4443
4444   STRIP_NOPS (arg1);
4445   STRIP_NOPS (arg2);
4446
4447   /* If we have A op 0 ? A : -A, consider applying the following
4448      transformations:
4449
4450      A == 0? A : -A    same as -A
4451      A != 0? A : -A    same as A
4452      A >= 0? A : -A    same as abs (A)
4453      A > 0?  A : -A    same as abs (A)
4454      A <= 0? A : -A    same as -abs (A)
4455      A < 0?  A : -A    same as -abs (A)
4456
4457      None of these transformations work for modes with signed
4458      zeros.  If A is +/-0, the first two transformations will
4459      change the sign of the result (from +0 to -0, or vice
4460      versa).  The last four will fix the sign of the result,
4461      even though the original expressions could be positive or
4462      negative, depending on the sign of A.
4463
4464      Note that all these transformations are correct if A is
4465      NaN, since the two alternatives (A and -A) are also NaNs.  */
4466   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
4467        ? real_zerop (arg01)
4468        : integer_zerop (arg01))
4469       && ((TREE_CODE (arg2) == NEGATE_EXPR
4470            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4471              /* In the case that A is of the form X-Y, '-A' (arg2) may
4472                 have already been folded to Y-X, check for that. */
4473           || (TREE_CODE (arg1) == MINUS_EXPR
4474               && TREE_CODE (arg2) == MINUS_EXPR
4475               && operand_equal_p (TREE_OPERAND (arg1, 0),
4476                                   TREE_OPERAND (arg2, 1), 0)
4477               && operand_equal_p (TREE_OPERAND (arg1, 1),
4478                                   TREE_OPERAND (arg2, 0), 0))))
4479     switch (comp_code)
4480       {
4481       case EQ_EXPR:
4482       case UNEQ_EXPR:
4483         tem = fold_convert (arg1_type, arg1);
4484         return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
4485       case NE_EXPR:
4486       case LTGT_EXPR:
4487         return pedantic_non_lvalue (fold_convert (type, arg1));
4488       case UNGE_EXPR:
4489       case UNGT_EXPR:
4490         if (flag_trapping_math)
4491           break;
4492         /* Fall through.  */
4493       case GE_EXPR:
4494       case GT_EXPR:
4495         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4496           arg1 = fold_convert (lang_hooks.types.signed_type
4497                                (TREE_TYPE (arg1)), arg1);
4498         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4499         return pedantic_non_lvalue (fold_convert (type, tem));
4500       case UNLE_EXPR:
4501       case UNLT_EXPR:
4502         if (flag_trapping_math)
4503           break;
4504       case LE_EXPR:
4505       case LT_EXPR:
4506         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4507           arg1 = fold_convert (lang_hooks.types.signed_type
4508                                (TREE_TYPE (arg1)), arg1);
4509         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4510         return negate_expr (fold_convert (type, tem));
4511       default:
4512         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4513         break;
4514       }
4515
4516   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4517      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4518      both transformations are correct when A is NaN: A != 0
4519      is then true, and A == 0 is false.  */
4520
4521   if (integer_zerop (arg01) && integer_zerop (arg2))
4522     {
4523       if (comp_code == NE_EXPR)
4524         return pedantic_non_lvalue (fold_convert (type, arg1));
4525       else if (comp_code == EQ_EXPR)
4526         return build_int_cst (type, 0);
4527     }
4528
4529   /* Try some transformations of A op B ? A : B.
4530
4531      A == B? A : B    same as B
4532      A != B? A : B    same as A
4533      A >= B? A : B    same as max (A, B)
4534      A > B?  A : B    same as max (B, A)
4535      A <= B? A : B    same as min (A, B)
4536      A < B?  A : B    same as min (B, A)
4537
4538      As above, these transformations don't work in the presence
4539      of signed zeros.  For example, if A and B are zeros of
4540      opposite sign, the first two transformations will change
4541      the sign of the result.  In the last four, the original
4542      expressions give different results for (A=+0, B=-0) and
4543      (A=-0, B=+0), but the transformed expressions do not.
4544
4545      The first two transformations are correct if either A or B
4546      is a NaN.  In the first transformation, the condition will
4547      be false, and B will indeed be chosen.  In the case of the
4548      second transformation, the condition A != B will be true,
4549      and A will be chosen.
4550
4551      The conversions to max() and min() are not correct if B is
4552      a number and A is not.  The conditions in the original
4553      expressions will be false, so all four give B.  The min()
4554      and max() versions would give a NaN instead.  */
4555   if (operand_equal_for_comparison_p (arg01, arg2, arg00)
4556       /* Avoid these transformations if the COND_EXPR may be used
4557          as an lvalue in the C++ front-end.  PR c++/19199.  */
4558       && (in_gimple_form
4559           || (strcmp (lang_hooks.name, "GNU C++") != 0
4560               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4561           || ! maybe_lvalue_p (arg1)
4562           || ! maybe_lvalue_p (arg2)))
4563     {
4564       tree comp_op0 = arg00;
4565       tree comp_op1 = arg01;
4566       tree comp_type = TREE_TYPE (comp_op0);
4567
4568       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4569       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4570         {
4571           comp_type = type;
4572           comp_op0 = arg1;
4573           comp_op1 = arg2;
4574         }
4575
4576       switch (comp_code)
4577         {
4578         case EQ_EXPR:
4579           return pedantic_non_lvalue (fold_convert (type, arg2));
4580         case NE_EXPR:
4581           return pedantic_non_lvalue (fold_convert (type, arg1));
4582         case LE_EXPR:
4583         case LT_EXPR:
4584         case UNLE_EXPR:
4585         case UNLT_EXPR:
4586           /* In C++ a ?: expression can be an lvalue, so put the
4587              operand which will be used if they are equal first
4588              so that we can convert this back to the
4589              corresponding COND_EXPR.  */
4590           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4591             {
4592               comp_op0 = fold_convert (comp_type, comp_op0);
4593               comp_op1 = fold_convert (comp_type, comp_op1);
4594               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4595                     ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
4596                     : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
4597               return pedantic_non_lvalue (fold_convert (type, tem));
4598             }
4599           break;
4600         case GE_EXPR:
4601         case GT_EXPR:
4602         case UNGE_EXPR:
4603         case UNGT_EXPR:
4604           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4605             {
4606               comp_op0 = fold_convert (comp_type, comp_op0);
4607               comp_op1 = fold_convert (comp_type, comp_op1);
4608               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4609                     ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
4610                     : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
4611               return pedantic_non_lvalue (fold_convert (type, tem));
4612             }
4613           break;
4614         case UNEQ_EXPR:
4615           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4616             return pedantic_non_lvalue (fold_convert (type, arg2));
4617           break;
4618         case LTGT_EXPR:
4619           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4620             return pedantic_non_lvalue (fold_convert (type, arg1));
4621           break;
4622         default:
4623           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4624           break;
4625         }
4626     }
4627
4628   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4629      we might still be able to simplify this.  For example,
4630      if C1 is one less or one more than C2, this might have started
4631      out as a MIN or MAX and been transformed by this function.
4632      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4633
4634   if (INTEGRAL_TYPE_P (type)
4635       && TREE_CODE (arg01) == INTEGER_CST
4636       && TREE_CODE (arg2) == INTEGER_CST)
4637     switch (comp_code)
4638       {
4639       case EQ_EXPR:
4640         /* We can replace A with C1 in this case.  */
4641         arg1 = fold_convert (type, arg01);
4642         return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
4643
4644       case LT_EXPR:
4645         /* If C1 is C2 + 1, this is min(A, C2).  */
4646         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4647                                OEP_ONLY_CONST)
4648             && operand_equal_p (arg01,
4649                                 const_binop (PLUS_EXPR, arg2,
4650                                              integer_one_node, 0),
4651                                 OEP_ONLY_CONST))
4652           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
4653                                                    type, arg1, arg2));
4654         break;
4655
4656       case LE_EXPR:
4657         /* If C1 is C2 - 1, this is min(A, C2).  */
4658         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4659                                OEP_ONLY_CONST)
4660             && operand_equal_p (arg01,
4661                                 const_binop (MINUS_EXPR, arg2,
4662                                              integer_one_node, 0),
4663                                 OEP_ONLY_CONST))
4664           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
4665                                                    type, arg1, arg2));
4666         break;
4667
4668       case GT_EXPR:
4669         /* If C1 is C2 - 1, this is max(A, C2).  */
4670         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4671                                OEP_ONLY_CONST)
4672             && operand_equal_p (arg01,
4673                                 const_binop (MINUS_EXPR, arg2,
4674                                              integer_one_node, 0),
4675                                 OEP_ONLY_CONST))
4676           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
4677                                                    type, arg1, arg2));
4678         break;
4679
4680       case GE_EXPR:
4681         /* If C1 is C2 + 1, this is max(A, C2).  */
4682         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4683                                OEP_ONLY_CONST)
4684             && operand_equal_p (arg01,
4685                                 const_binop (PLUS_EXPR, arg2,
4686                                              integer_one_node, 0),
4687                                 OEP_ONLY_CONST))
4688           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
4689                                                    type, arg1, arg2));
4690         break;
4691       case NE_EXPR:
4692         break;
4693       default:
4694         gcc_unreachable ();
4695       }
4696
4697   return NULL_TREE;
4698 }
4699
4700
4701 \f
4702 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4703 #define LOGICAL_OP_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
4704 #endif
4705
4706 /* EXP is some logical combination of boolean tests.  See if we can
4707    merge it into some range test.  Return the new tree if so.  */
4708
4709 static tree
4710 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
4711 {
4712   int or_op = (code == TRUTH_ORIF_EXPR
4713                || code == TRUTH_OR_EXPR);
4714   int in0_p, in1_p, in_p;
4715   tree low0, low1, low, high0, high1, high;
4716   tree lhs = make_range (op0, &in0_p, &low0, &high0);
4717   tree rhs = make_range (op1, &in1_p, &low1, &high1);
4718   tree tem;
4719
4720   /* If this is an OR operation, invert both sides; we will invert
4721      again at the end.  */
4722   if (or_op)
4723     in0_p = ! in0_p, in1_p = ! in1_p;
4724
4725   /* If both expressions are the same, if we can merge the ranges, and we
4726      can build the range test, return it or it inverted.  If one of the
4727      ranges is always true or always false, consider it to be the same
4728      expression as the other.  */
4729   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4730       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4731                        in1_p, low1, high1)
4732       && 0 != (tem = (build_range_check (type,
4733                                          lhs != 0 ? lhs
4734                                          : rhs != 0 ? rhs : integer_zero_node,
4735                                          in_p, low, high))))
4736     return or_op ? invert_truthvalue (tem) : tem;
4737
4738   /* On machines where the branch cost is expensive, if this is a
4739      short-circuited branch and the underlying object on both sides
4740      is the same, make a non-short-circuit operation.  */
4741   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4742            && lhs != 0 && rhs != 0
4743            && (code == TRUTH_ANDIF_EXPR
4744                || code == TRUTH_ORIF_EXPR)
4745            && operand_equal_p (lhs, rhs, 0))
4746     {
4747       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4748          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4749          which cases we can't do this.  */
4750       if (simple_operand_p (lhs))
4751         return build2 (code == TRUTH_ANDIF_EXPR
4752                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4753                        type, op0, op1);
4754
4755       else if (lang_hooks.decls.global_bindings_p () == 0
4756                && ! CONTAINS_PLACEHOLDER_P (lhs))
4757         {
4758           tree common = save_expr (lhs);
4759
4760           if (0 != (lhs = build_range_check (type, common,
4761                                              or_op ? ! in0_p : in0_p,
4762                                              low0, high0))
4763               && (0 != (rhs = build_range_check (type, common,
4764                                                  or_op ? ! in1_p : in1_p,
4765                                                  low1, high1))))
4766             return build2 (code == TRUTH_ANDIF_EXPR
4767                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4768                            type, lhs, rhs);
4769         }
4770     }
4771
4772   return 0;
4773 }
4774 \f
4775 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4776    bit value.  Arrange things so the extra bits will be set to zero if and
4777    only if C is signed-extended to its full width.  If MASK is nonzero,
4778    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4779
4780 static tree
4781 unextend (tree c, int p, int unsignedp, tree mask)
4782 {
4783   tree type = TREE_TYPE (c);
4784   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4785   tree temp;
4786
4787   if (p == modesize || unsignedp)
4788     return c;
4789
4790   /* We work by getting just the sign bit into the low-order bit, then
4791      into the high-order bit, then sign-extend.  We then XOR that value
4792      with C.  */
4793   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
4794   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
4795
4796   /* We must use a signed type in order to get an arithmetic right shift.
4797      However, we must also avoid introducing accidental overflows, so that
4798      a subsequent call to integer_zerop will work.  Hence we must
4799      do the type conversion here.  At this point, the constant is either
4800      zero or one, and the conversion to a signed type can never overflow.
4801      We could get an overflow if this conversion is done anywhere else.  */
4802   if (TYPE_UNSIGNED (type))
4803     temp = fold_convert (lang_hooks.types.signed_type (type), temp);
4804
4805   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
4806   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
4807   if (mask != 0)
4808     temp = const_binop (BIT_AND_EXPR, temp,
4809                         fold_convert (TREE_TYPE (c), mask), 0);
4810   /* If necessary, convert the type back to match the type of C.  */
4811   if (TYPE_UNSIGNED (type))
4812     temp = fold_convert (type, temp);
4813
4814   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
4815 }
4816 \f
4817 /* Find ways of folding logical expressions of LHS and RHS:
4818    Try to merge two comparisons to the same innermost item.
4819    Look for range tests like "ch >= '0' && ch <= '9'".
4820    Look for combinations of simple terms on machines with expensive branches
4821    and evaluate the RHS unconditionally.
4822
4823    For example, if we have p->a == 2 && p->b == 4 and we can make an
4824    object large enough to span both A and B, we can do this with a comparison
4825    against the object ANDed with the a mask.
4826
4827    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
4828    operations to do this with one comparison.
4829
4830    We check for both normal comparisons and the BIT_AND_EXPRs made this by
4831    function and the one above.
4832
4833    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
4834    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
4835
4836    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
4837    two operands.
4838
4839    We return the simplified tree or 0 if no optimization is possible.  */
4840
4841 static tree
4842 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
4843 {
4844   /* If this is the "or" of two comparisons, we can do something if
4845      the comparisons are NE_EXPR.  If this is the "and", we can do something
4846      if the comparisons are EQ_EXPR.  I.e.,
4847         (a->b == 2 && a->c == 4) can become (a->new == NEW).
4848
4849      WANTED_CODE is this operation code.  For single bit fields, we can
4850      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
4851      comparison for one-bit fields.  */
4852
4853   enum tree_code wanted_code;
4854   enum tree_code lcode, rcode;
4855   tree ll_arg, lr_arg, rl_arg, rr_arg;
4856   tree ll_inner, lr_inner, rl_inner, rr_inner;
4857   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
4858   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
4859   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
4860   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
4861   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
4862   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
4863   enum machine_mode lnmode, rnmode;
4864   tree ll_mask, lr_mask, rl_mask, rr_mask;
4865   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
4866   tree l_const, r_const;
4867   tree lntype, rntype, result;
4868   int first_bit, end_bit;
4869   int volatilep;
4870   tree orig_lhs = lhs, orig_rhs = rhs;
4871   enum tree_code orig_code = code;
4872
4873   /* Start by getting the comparison codes.  Fail if anything is volatile.
4874      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
4875      it were surrounded with a NE_EXPR.  */
4876
4877   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
4878     return 0;
4879
4880   lcode = TREE_CODE (lhs);
4881   rcode = TREE_CODE (rhs);
4882
4883   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
4884     {
4885       lhs = build2 (NE_EXPR, truth_type, lhs,
4886                     build_int_cst (TREE_TYPE (lhs), 0));
4887       lcode = NE_EXPR;
4888     }
4889
4890   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
4891     {
4892       rhs = build2 (NE_EXPR, truth_type, rhs,
4893                     build_int_cst (TREE_TYPE (rhs), 0));
4894       rcode = NE_EXPR;
4895     }
4896
4897   if (TREE_CODE_CLASS (lcode) != tcc_comparison
4898       || TREE_CODE_CLASS (rcode) != tcc_comparison)
4899     return 0;
4900
4901   ll_arg = TREE_OPERAND (lhs, 0);
4902   lr_arg = TREE_OPERAND (lhs, 1);
4903   rl_arg = TREE_OPERAND (rhs, 0);
4904   rr_arg = TREE_OPERAND (rhs, 1);
4905
4906   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
4907   if (simple_operand_p (ll_arg)
4908       && simple_operand_p (lr_arg))
4909     {
4910       tree result;
4911       if (operand_equal_p (ll_arg, rl_arg, 0)
4912           && operand_equal_p (lr_arg, rr_arg, 0))
4913         {
4914           result = combine_comparisons (code, lcode, rcode,
4915                                         truth_type, ll_arg, lr_arg);
4916           if (result)
4917             return result;
4918         }
4919       else if (operand_equal_p (ll_arg, rr_arg, 0)
4920                && operand_equal_p (lr_arg, rl_arg, 0))
4921         {
4922           result = combine_comparisons (code, lcode,
4923                                         swap_tree_comparison (rcode),
4924                                         truth_type, ll_arg, lr_arg);
4925           if (result)
4926             return result;
4927         }
4928     }
4929
4930   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
4931           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
4932
4933   /* If the RHS can be evaluated unconditionally and its operands are
4934      simple, it wins to evaluate the RHS unconditionally on machines
4935      with expensive branches.  In this case, this isn't a comparison
4936      that can be merged.  Avoid doing this if the RHS is a floating-point
4937      comparison since those can trap.  */
4938
4939   if (BRANCH_COST >= 2
4940       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
4941       && simple_operand_p (rl_arg)
4942       && simple_operand_p (rr_arg))
4943     {
4944       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
4945       if (code == TRUTH_OR_EXPR
4946           && lcode == NE_EXPR && integer_zerop (lr_arg)
4947           && rcode == NE_EXPR && integer_zerop (rr_arg)
4948           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4949         return build2 (NE_EXPR, truth_type,
4950                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4951                                ll_arg, rl_arg),
4952                        build_int_cst (TREE_TYPE (ll_arg), 0));
4953
4954       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
4955       if (code == TRUTH_AND_EXPR
4956           && lcode == EQ_EXPR && integer_zerop (lr_arg)
4957           && rcode == EQ_EXPR && integer_zerop (rr_arg)
4958           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
4959         return build2 (EQ_EXPR, truth_type,
4960                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
4961                                ll_arg, rl_arg),
4962                        build_int_cst (TREE_TYPE (ll_arg), 0));
4963
4964       if (LOGICAL_OP_NON_SHORT_CIRCUIT)
4965         {
4966           if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
4967             return build2 (code, truth_type, lhs, rhs);
4968           return NULL_TREE;
4969         }
4970     }
4971
4972   /* See if the comparisons can be merged.  Then get all the parameters for
4973      each side.  */
4974
4975   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
4976       || (rcode != EQ_EXPR && rcode != NE_EXPR))
4977     return 0;
4978
4979   volatilep = 0;
4980   ll_inner = decode_field_reference (ll_arg,
4981                                      &ll_bitsize, &ll_bitpos, &ll_mode,
4982                                      &ll_unsignedp, &volatilep, &ll_mask,
4983                                      &ll_and_mask);
4984   lr_inner = decode_field_reference (lr_arg,
4985                                      &lr_bitsize, &lr_bitpos, &lr_mode,
4986                                      &lr_unsignedp, &volatilep, &lr_mask,
4987                                      &lr_and_mask);
4988   rl_inner = decode_field_reference (rl_arg,
4989                                      &rl_bitsize, &rl_bitpos, &rl_mode,
4990                                      &rl_unsignedp, &volatilep, &rl_mask,
4991                                      &rl_and_mask);
4992   rr_inner = decode_field_reference (rr_arg,
4993                                      &rr_bitsize, &rr_bitpos, &rr_mode,
4994                                      &rr_unsignedp, &volatilep, &rr_mask,
4995                                      &rr_and_mask);
4996
4997   /* It must be true that the inner operation on the lhs of each
4998      comparison must be the same if we are to be able to do anything.
4999      Then see if we have constants.  If not, the same must be true for
5000      the rhs's.  */
5001   if (volatilep || ll_inner == 0 || rl_inner == 0
5002       || ! operand_equal_p (ll_inner, rl_inner, 0))
5003     return 0;
5004
5005   if (TREE_CODE (lr_arg) == INTEGER_CST
5006       && TREE_CODE (rr_arg) == INTEGER_CST)
5007     l_const = lr_arg, r_const = rr_arg;
5008   else if (lr_inner == 0 || rr_inner == 0
5009            || ! operand_equal_p (lr_inner, rr_inner, 0))
5010     return 0;
5011   else
5012     l_const = r_const = 0;
5013
5014   /* If either comparison code is not correct for our logical operation,
5015      fail.  However, we can convert a one-bit comparison against zero into
5016      the opposite comparison against that bit being set in the field.  */
5017
5018   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5019   if (lcode != wanted_code)
5020     {
5021       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5022         {
5023           /* Make the left operand unsigned, since we are only interested
5024              in the value of one bit.  Otherwise we are doing the wrong
5025              thing below.  */
5026           ll_unsignedp = 1;
5027           l_const = ll_mask;
5028         }
5029       else
5030         return 0;
5031     }
5032
5033   /* This is analogous to the code for l_const above.  */
5034   if (rcode != wanted_code)
5035     {
5036       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5037         {
5038           rl_unsignedp = 1;
5039           r_const = rl_mask;
5040         }
5041       else
5042         return 0;
5043     }
5044
5045   /* After this point all optimizations will generate bit-field
5046      references, which we might not want.  */
5047   if (! lang_hooks.can_use_bit_fields_p ())
5048     return 0;
5049
5050   /* See if we can find a mode that contains both fields being compared on
5051      the left.  If we can't, fail.  Otherwise, update all constants and masks
5052      to be relative to a field of that size.  */
5053   first_bit = MIN (ll_bitpos, rl_bitpos);
5054   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5055   lnmode = get_best_mode (end_bit - first_bit, first_bit,
5056                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5057                           volatilep);
5058   if (lnmode == VOIDmode)
5059     return 0;
5060
5061   lnbitsize = GET_MODE_BITSIZE (lnmode);
5062   lnbitpos = first_bit & ~ (lnbitsize - 1);
5063   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5064   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5065
5066   if (BYTES_BIG_ENDIAN)
5067     {
5068       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5069       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5070     }
5071
5072   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
5073                          size_int (xll_bitpos), 0);
5074   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
5075                          size_int (xrl_bitpos), 0);
5076
5077   if (l_const)
5078     {
5079       l_const = fold_convert (lntype, l_const);
5080       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5081       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
5082       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5083                                         fold_build1 (BIT_NOT_EXPR,
5084                                                      lntype, ll_mask),
5085                                         0)))
5086         {
5087           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5088
5089           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5090         }
5091     }
5092   if (r_const)
5093     {
5094       r_const = fold_convert (lntype, r_const);
5095       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5096       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
5097       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5098                                         fold_build1 (BIT_NOT_EXPR,
5099                                                      lntype, rl_mask),
5100                                         0)))
5101         {
5102           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5103
5104           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5105         }
5106     }
5107
5108   /* If the right sides are not constant, do the same for it.  Also,
5109      disallow this optimization if a size or signedness mismatch occurs
5110      between the left and right sides.  */
5111   if (l_const == 0)
5112     {
5113       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5114           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5115           /* Make sure the two fields on the right
5116              correspond to the left without being swapped.  */
5117           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5118         return 0;
5119
5120       first_bit = MIN (lr_bitpos, rr_bitpos);
5121       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5122       rnmode = get_best_mode (end_bit - first_bit, first_bit,
5123                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5124                               volatilep);
5125       if (rnmode == VOIDmode)
5126         return 0;
5127
5128       rnbitsize = GET_MODE_BITSIZE (rnmode);
5129       rnbitpos = first_bit & ~ (rnbitsize - 1);
5130       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5131       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5132
5133       if (BYTES_BIG_ENDIAN)
5134         {
5135           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5136           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5137         }
5138
5139       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
5140                              size_int (xlr_bitpos), 0);
5141       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
5142                              size_int (xrr_bitpos), 0);
5143
5144       /* Make a mask that corresponds to both fields being compared.
5145          Do this for both items being compared.  If the operands are the
5146          same size and the bits being compared are in the same position
5147          then we can do this by masking both and comparing the masked
5148          results.  */
5149       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5150       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
5151       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5152         {
5153           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5154                                     ll_unsignedp || rl_unsignedp);
5155           if (! all_ones_mask_p (ll_mask, lnbitsize))
5156             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5157
5158           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
5159                                     lr_unsignedp || rr_unsignedp);
5160           if (! all_ones_mask_p (lr_mask, rnbitsize))
5161             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5162
5163           return build2 (wanted_code, truth_type, lhs, rhs);
5164         }
5165
5166       /* There is still another way we can do something:  If both pairs of
5167          fields being compared are adjacent, we may be able to make a wider
5168          field containing them both.
5169
5170          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5171          the mask must be shifted to account for the shift done by
5172          make_bit_field_ref.  */
5173       if ((ll_bitsize + ll_bitpos == rl_bitpos
5174            && lr_bitsize + lr_bitpos == rr_bitpos)
5175           || (ll_bitpos == rl_bitpos + rl_bitsize
5176               && lr_bitpos == rr_bitpos + rr_bitsize))
5177         {
5178           tree type;
5179
5180           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
5181                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5182           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
5183                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5184
5185           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5186                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
5187           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5188                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
5189
5190           /* Convert to the smaller type before masking out unwanted bits.  */
5191           type = lntype;
5192           if (lntype != rntype)
5193             {
5194               if (lnbitsize > rnbitsize)
5195                 {
5196                   lhs = fold_convert (rntype, lhs);
5197                   ll_mask = fold_convert (rntype, ll_mask);
5198                   type = rntype;
5199                 }
5200               else if (lnbitsize < rnbitsize)
5201                 {
5202                   rhs = fold_convert (lntype, rhs);
5203                   lr_mask = fold_convert (lntype, lr_mask);
5204                   type = lntype;
5205                 }
5206             }
5207
5208           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5209             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5210
5211           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5212             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5213
5214           return build2 (wanted_code, truth_type, lhs, rhs);
5215         }
5216
5217       return 0;
5218     }
5219
5220   /* Handle the case of comparisons with constants.  If there is something in
5221      common between the masks, those bits of the constants must be the same.
5222      If not, the condition is always false.  Test for this to avoid generating
5223      incorrect code below.  */
5224   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
5225   if (! integer_zerop (result)
5226       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
5227                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
5228     {
5229       if (wanted_code == NE_EXPR)
5230         {
5231           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5232           return constant_boolean_node (true, truth_type);
5233         }
5234       else
5235         {
5236           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5237           return constant_boolean_node (false, truth_type);
5238         }
5239     }
5240
5241   /* Construct the expression we will return.  First get the component
5242      reference we will make.  Unless the mask is all ones the width of
5243      that field, perform the mask operation.  Then compare with the
5244      merged constant.  */
5245   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5246                                ll_unsignedp || rl_unsignedp);
5247
5248   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5249   if (! all_ones_mask_p (ll_mask, lnbitsize))
5250     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
5251
5252   return build2 (wanted_code, truth_type, result,
5253                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
5254 }
5255 \f
5256 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5257    constant.  */
5258
5259 static tree
5260 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5261 {
5262   tree arg0 = op0;
5263   enum tree_code op_code;
5264   tree comp_const = op1;
5265   tree minmax_const;
5266   int consts_equal, consts_lt;
5267   tree inner;
5268
5269   STRIP_SIGN_NOPS (arg0);
5270
5271   op_code = TREE_CODE (arg0);
5272   minmax_const = TREE_OPERAND (arg0, 1);
5273   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5274   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5275   inner = TREE_OPERAND (arg0, 0);
5276
5277   /* If something does not permit us to optimize, return the original tree.  */
5278   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5279       || TREE_CODE (comp_const) != INTEGER_CST
5280       || TREE_CONSTANT_OVERFLOW (comp_const)
5281       || TREE_CODE (minmax_const) != INTEGER_CST
5282       || TREE_CONSTANT_OVERFLOW (minmax_const))
5283     return NULL_TREE;
5284
5285   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5286      and GT_EXPR, doing the rest with recursive calls using logical
5287      simplifications.  */
5288   switch (code)
5289     {
5290     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5291       {
5292         tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5293                                           type, op0, op1);
5294         if (tem)
5295           return invert_truthvalue (tem);
5296         return NULL_TREE;
5297       }
5298
5299     case GE_EXPR:
5300       return
5301         fold_build2 (TRUTH_ORIF_EXPR, type,
5302                      optimize_minmax_comparison
5303                      (EQ_EXPR, type, arg0, comp_const),
5304                      optimize_minmax_comparison
5305                      (GT_EXPR, type, arg0, comp_const));
5306
5307     case EQ_EXPR:
5308       if (op_code == MAX_EXPR && consts_equal)
5309         /* MAX (X, 0) == 0  ->  X <= 0  */
5310         return fold_build2 (LE_EXPR, type, inner, comp_const);
5311
5312       else if (op_code == MAX_EXPR && consts_lt)
5313         /* MAX (X, 0) == 5  ->  X == 5   */
5314         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5315
5316       else if (op_code == MAX_EXPR)
5317         /* MAX (X, 0) == -1  ->  false  */
5318         return omit_one_operand (type, integer_zero_node, inner);
5319
5320       else if (consts_equal)
5321         /* MIN (X, 0) == 0  ->  X >= 0  */
5322         return fold_build2 (GE_EXPR, type, inner, comp_const);
5323
5324       else if (consts_lt)
5325         /* MIN (X, 0) == 5  ->  false  */
5326         return omit_one_operand (type, integer_zero_node, inner);
5327
5328       else
5329         /* MIN (X, 0) == -1  ->  X == -1  */
5330         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5331
5332     case GT_EXPR:
5333       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5334         /* MAX (X, 0) > 0  ->  X > 0
5335            MAX (X, 0) > 5  ->  X > 5  */
5336         return fold_build2 (GT_EXPR, type, inner, comp_const);
5337
5338       else if (op_code == MAX_EXPR)
5339         /* MAX (X, 0) > -1  ->  true  */
5340         return omit_one_operand (type, integer_one_node, inner);
5341
5342       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5343         /* MIN (X, 0) > 0  ->  false
5344            MIN (X, 0) > 5  ->  false  */
5345         return omit_one_operand (type, integer_zero_node, inner);
5346
5347       else
5348         /* MIN (X, 0) > -1  ->  X > -1  */
5349         return fold_build2 (GT_EXPR, type, inner, comp_const);
5350
5351     default:
5352       return NULL_TREE;
5353     }
5354 }
5355 \f
5356 /* T is an integer expression that is being multiplied, divided, or taken a
5357    modulus (CODE says which and what kind of divide or modulus) by a
5358    constant C.  See if we can eliminate that operation by folding it with
5359    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5360    should be used for the computation if wider than our type.
5361
5362    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5363    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5364    expression would not overflow or that overflow is undefined for the type
5365    in the language in question.
5366
5367    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
5368    the machine has a multiply-accumulate insn or that this is part of an
5369    addressing calculation.
5370
5371    If we return a non-null expression, it is an equivalent form of the
5372    original computation, but need not be in the original type.  */
5373
5374 static tree
5375 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type)
5376 {
5377   /* To avoid exponential search depth, refuse to allow recursion past
5378      three levels.  Beyond that (1) it's highly unlikely that we'll find
5379      something interesting and (2) we've probably processed it before
5380      when we built the inner expression.  */
5381
5382   static int depth;
5383   tree ret;
5384
5385   if (depth > 3)
5386     return NULL;
5387
5388   depth++;
5389   ret = extract_muldiv_1 (t, c, code, wide_type);
5390   depth--;
5391
5392   return ret;
5393 }
5394
5395 static tree
5396 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type)
5397 {
5398   tree type = TREE_TYPE (t);
5399   enum tree_code tcode = TREE_CODE (t);
5400   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5401                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5402                 ? wide_type : type);
5403   tree t1, t2;
5404   int same_p = tcode == code;
5405   tree op0 = NULL_TREE, op1 = NULL_TREE;
5406
5407   /* Don't deal with constants of zero here; they confuse the code below.  */
5408   if (integer_zerop (c))
5409     return NULL_TREE;
5410
5411   if (TREE_CODE_CLASS (tcode) == tcc_unary)
5412     op0 = TREE_OPERAND (t, 0);
5413
5414   if (TREE_CODE_CLASS (tcode) == tcc_binary)
5415     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5416
5417   /* Note that we need not handle conditional operations here since fold
5418      already handles those cases.  So just do arithmetic here.  */
5419   switch (tcode)
5420     {
5421     case INTEGER_CST:
5422       /* For a constant, we can always simplify if we are a multiply
5423          or (for divide and modulus) if it is a multiple of our constant.  */
5424       if (code == MULT_EXPR
5425           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
5426         return const_binop (code, fold_convert (ctype, t),
5427                             fold_convert (ctype, c), 0);
5428       break;
5429
5430     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
5431       /* If op0 is an expression ...  */
5432       if ((COMPARISON_CLASS_P (op0)
5433            || UNARY_CLASS_P (op0)
5434            || BINARY_CLASS_P (op0)
5435            || EXPRESSION_CLASS_P (op0))
5436           /* ... and is unsigned, and its type is smaller than ctype,
5437              then we cannot pass through as widening.  */
5438           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
5439                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5440                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5441                && (GET_MODE_SIZE (TYPE_MODE (ctype))
5442                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
5443               /* ... or this is a truncation (t is narrower than op0),
5444                  then we cannot pass through this narrowing.  */
5445               || (GET_MODE_SIZE (TYPE_MODE (type))
5446                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
5447               /* ... or signedness changes for division or modulus,
5448                  then we cannot pass through this conversion.  */
5449               || (code != MULT_EXPR
5450                   && (TYPE_UNSIGNED (ctype)
5451                       != TYPE_UNSIGNED (TREE_TYPE (op0))))))
5452         break;
5453
5454       /* Pass the constant down and see if we can make a simplification.  If
5455          we can, replace this expression with the inner simplification for
5456          possible later conversion to our or some other type.  */
5457       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5458           && TREE_CODE (t2) == INTEGER_CST
5459           && ! TREE_CONSTANT_OVERFLOW (t2)
5460           && (0 != (t1 = extract_muldiv (op0, t2, code,
5461                                          code == MULT_EXPR
5462                                          ? ctype : NULL_TREE))))
5463         return t1;
5464       break;
5465
5466     case ABS_EXPR:
5467       /* If widening the type changes it from signed to unsigned, then we
5468          must avoid building ABS_EXPR itself as unsigned.  */
5469       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5470         {
5471           tree cstype = (*lang_hooks.types.signed_type) (ctype);
5472           if ((t1 = extract_muldiv (op0, c, code, cstype)) != 0)
5473             {
5474               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5475               return fold_convert (ctype, t1);
5476             }
5477           break;
5478         }
5479       /* FALLTHROUGH */
5480     case NEGATE_EXPR:
5481       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5482         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5483       break;
5484
5485     case MIN_EXPR:  case MAX_EXPR:
5486       /* If widening the type changes the signedness, then we can't perform
5487          this optimization as that changes the result.  */
5488       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5489         break;
5490
5491       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5492       if ((t1 = extract_muldiv (op0, c, code, wide_type)) != 0
5493           && (t2 = extract_muldiv (op1, c, code, wide_type)) != 0)
5494         {
5495           if (tree_int_cst_sgn (c) < 0)
5496             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5497
5498           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5499                               fold_convert (ctype, t2));
5500         }
5501       break;
5502
5503     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5504       /* If the second operand is constant, this is a multiplication
5505          or floor division, by a power of two, so we can treat it that
5506          way unless the multiplier or divisor overflows.  Signed
5507          left-shift overflow is implementation-defined rather than
5508          undefined in C90, so do not convert signed left shift into
5509          multiplication.  */
5510       if (TREE_CODE (op1) == INTEGER_CST
5511           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5512           /* const_binop may not detect overflow correctly,
5513              so check for it explicitly here.  */
5514           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5515           && TREE_INT_CST_HIGH (op1) == 0
5516           && 0 != (t1 = fold_convert (ctype,
5517                                       const_binop (LSHIFT_EXPR,
5518                                                    size_one_node,
5519                                                    op1, 0)))
5520           && ! TREE_OVERFLOW (t1))
5521         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5522                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5523                                        ctype, fold_convert (ctype, op0), t1),
5524                                c, code, wide_type);
5525       break;
5526
5527     case PLUS_EXPR:  case MINUS_EXPR:
5528       /* See if we can eliminate the operation on both sides.  If we can, we
5529          can return a new PLUS or MINUS.  If we can't, the only remaining
5530          cases where we can do anything are if the second operand is a
5531          constant.  */
5532       t1 = extract_muldiv (op0, c, code, wide_type);
5533       t2 = extract_muldiv (op1, c, code, wide_type);
5534       if (t1 != 0 && t2 != 0
5535           && (code == MULT_EXPR
5536               /* If not multiplication, we can only do this if both operands
5537                  are divisible by c.  */
5538               || (multiple_of_p (ctype, op0, c)
5539                   && multiple_of_p (ctype, op1, c))))
5540         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5541                             fold_convert (ctype, t2));
5542
5543       /* If this was a subtraction, negate OP1 and set it to be an addition.
5544          This simplifies the logic below.  */
5545       if (tcode == MINUS_EXPR)
5546         tcode = PLUS_EXPR, op1 = negate_expr (op1);
5547
5548       if (TREE_CODE (op1) != INTEGER_CST)
5549         break;
5550
5551       /* If either OP1 or C are negative, this optimization is not safe for
5552          some of the division and remainder types while for others we need
5553          to change the code.  */
5554       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5555         {
5556           if (code == CEIL_DIV_EXPR)
5557             code = FLOOR_DIV_EXPR;
5558           else if (code == FLOOR_DIV_EXPR)
5559             code = CEIL_DIV_EXPR;
5560           else if (code != MULT_EXPR
5561                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5562             break;
5563         }
5564
5565       /* If it's a multiply or a division/modulus operation of a multiple
5566          of our constant, do the operation and verify it doesn't overflow.  */
5567       if (code == MULT_EXPR
5568           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5569         {
5570           op1 = const_binop (code, fold_convert (ctype, op1),
5571                              fold_convert (ctype, c), 0);
5572           /* We allow the constant to overflow with wrapping semantics.  */
5573           if (op1 == 0
5574               || (TREE_OVERFLOW (op1) && ! flag_wrapv))
5575             break;
5576         }
5577       else
5578         break;
5579
5580       /* If we have an unsigned type is not a sizetype, we cannot widen
5581          the operation since it will change the result if the original
5582          computation overflowed.  */
5583       if (TYPE_UNSIGNED (ctype)
5584           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5585           && ctype != type)
5586         break;
5587
5588       /* If we were able to eliminate our operation from the first side,
5589          apply our operation to the second side and reform the PLUS.  */
5590       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5591         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5592
5593       /* The last case is if we are a multiply.  In that case, we can
5594          apply the distributive law to commute the multiply and addition
5595          if the multiplication of the constants doesn't overflow.  */
5596       if (code == MULT_EXPR)
5597         return fold_build2 (tcode, ctype,
5598                             fold_build2 (code, ctype,
5599                                          fold_convert (ctype, op0),
5600                                          fold_convert (ctype, c)),
5601                             op1);
5602
5603       break;
5604
5605     case MULT_EXPR:
5606       /* We have a special case here if we are doing something like
5607          (C * 8) % 4 since we know that's zero.  */
5608       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5609            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5610           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5611           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5612         return omit_one_operand (type, integer_zero_node, op0);
5613
5614       /* ... fall through ...  */
5615
5616     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5617     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5618       /* If we can extract our operation from the LHS, do so and return a
5619          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5620          do something only if the second operand is a constant.  */
5621       if (same_p
5622           && (t1 = extract_muldiv (op0, c, code, wide_type)) != 0)
5623         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5624                             fold_convert (ctype, op1));
5625       else if (tcode == MULT_EXPR && code == MULT_EXPR
5626                && (t1 = extract_muldiv (op1, c, code, wide_type)) != 0)
5627         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5628                             fold_convert (ctype, t1));
5629       else if (TREE_CODE (op1) != INTEGER_CST)
5630         return 0;
5631
5632       /* If these are the same operation types, we can associate them
5633          assuming no overflow.  */
5634       if (tcode == code
5635           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5636                                      fold_convert (ctype, c), 0))
5637           && ! TREE_OVERFLOW (t1))
5638         return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
5639
5640       /* If these operations "cancel" each other, we have the main
5641          optimizations of this pass, which occur when either constant is a
5642          multiple of the other, in which case we replace this with either an
5643          operation or CODE or TCODE.
5644
5645          If we have an unsigned type that is not a sizetype, we cannot do
5646          this since it will change the result if the original computation
5647          overflowed.  */
5648       if ((! TYPE_UNSIGNED (ctype)
5649            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5650           && ! flag_wrapv
5651           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5652               || (tcode == MULT_EXPR
5653                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5654                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
5655         {
5656           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5657             return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5658                                 fold_convert (ctype,
5659                                               const_binop (TRUNC_DIV_EXPR,
5660                                                            op1, c, 0)));
5661           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5662             return fold_build2 (code, ctype, fold_convert (ctype, op0),
5663                                 fold_convert (ctype,
5664                                               const_binop (TRUNC_DIV_EXPR,
5665                                                            c, op1, 0)));
5666         }
5667       break;
5668
5669     default:
5670       break;
5671     }
5672
5673   return 0;
5674 }
5675 \f
5676 /* Return a node which has the indicated constant VALUE (either 0 or
5677    1), and is of the indicated TYPE.  */
5678
5679 tree
5680 constant_boolean_node (int value, tree type)
5681 {
5682   if (type == integer_type_node)
5683     return value ? integer_one_node : integer_zero_node;
5684   else if (type == boolean_type_node)
5685     return value ? boolean_true_node : boolean_false_node;
5686   else
5687     return build_int_cst (type, value);
5688 }
5689
5690
5691 /* Return true if expr looks like an ARRAY_REF and set base and
5692    offset to the appropriate trees.  If there is no offset,
5693    offset is set to NULL_TREE.  Base will be canonicalized to
5694    something you can get the element type from using
5695    TREE_TYPE (TREE_TYPE (base)).  Offset will be the offset
5696    in bytes to the base.  */
5697
5698 static bool
5699 extract_array_ref (tree expr, tree *base, tree *offset)
5700 {
5701   /* One canonical form is a PLUS_EXPR with the first
5702      argument being an ADDR_EXPR with a possible NOP_EXPR
5703      attached.  */
5704   if (TREE_CODE (expr) == PLUS_EXPR)
5705     {
5706       tree op0 = TREE_OPERAND (expr, 0);
5707       tree inner_base, dummy1;
5708       /* Strip NOP_EXPRs here because the C frontends and/or
5709          folders present us (int *)&x.a + 4B possibly.  */
5710       STRIP_NOPS (op0);
5711       if (extract_array_ref (op0, &inner_base, &dummy1))
5712         {
5713           *base = inner_base;
5714           if (dummy1 == NULL_TREE)
5715             *offset = TREE_OPERAND (expr, 1);
5716           else
5717             *offset = fold_build2 (PLUS_EXPR, TREE_TYPE (expr),
5718                                    dummy1, TREE_OPERAND (expr, 1));
5719           return true;
5720         }
5721     }
5722   /* Other canonical form is an ADDR_EXPR of an ARRAY_REF,
5723      which we transform into an ADDR_EXPR with appropriate
5724      offset.  For other arguments to the ADDR_EXPR we assume
5725      zero offset and as such do not care about the ADDR_EXPR
5726      type and strip possible nops from it.  */
5727   else if (TREE_CODE (expr) == ADDR_EXPR)
5728     {
5729       tree op0 = TREE_OPERAND (expr, 0);
5730       if (TREE_CODE (op0) == ARRAY_REF)
5731         {
5732           tree idx = TREE_OPERAND (op0, 1);
5733           *base = TREE_OPERAND (op0, 0);
5734           *offset = fold_build2 (MULT_EXPR, TREE_TYPE (idx), idx,
5735                                  array_ref_element_size (op0));
5736         }
5737       else
5738         {
5739           /* Handle array-to-pointer decay as &a.  */
5740           if (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE)
5741             *base = TREE_OPERAND (expr, 0);
5742           else
5743             *base = expr;
5744           *offset = NULL_TREE;
5745         }
5746       return true;
5747     }
5748   /* The next canonical form is a VAR_DECL with POINTER_TYPE.  */
5749   else if (SSA_VAR_P (expr)
5750            && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5751     {
5752       *base = expr;
5753       *offset = NULL_TREE;
5754       return true;
5755     }
5756
5757   return false;
5758 }
5759
5760
5761 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5762    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5763    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5764    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5765    COND is the first argument to CODE; otherwise (as in the example
5766    given here), it is the second argument.  TYPE is the type of the
5767    original expression.  Return NULL_TREE if no simplification is
5768    possible.  */
5769
5770 static tree
5771 fold_binary_op_with_conditional_arg (enum tree_code code,
5772                                      tree type, tree op0, tree op1,
5773                                      tree cond, tree arg, int cond_first_p)
5774 {
5775   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
5776   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
5777   tree test, true_value, false_value;
5778   tree lhs = NULL_TREE;
5779   tree rhs = NULL_TREE;
5780
5781   /* This transformation is only worthwhile if we don't have to wrap
5782      arg in a SAVE_EXPR, and the operation can be simplified on at least
5783      one of the branches once its pushed inside the COND_EXPR.  */
5784   if (!TREE_CONSTANT (arg))
5785     return NULL_TREE;
5786
5787   if (TREE_CODE (cond) == COND_EXPR)
5788     {
5789       test = TREE_OPERAND (cond, 0);
5790       true_value = TREE_OPERAND (cond, 1);
5791       false_value = TREE_OPERAND (cond, 2);
5792       /* If this operand throws an expression, then it does not make
5793          sense to try to perform a logical or arithmetic operation
5794          involving it.  */
5795       if (VOID_TYPE_P (TREE_TYPE (true_value)))
5796         lhs = true_value;
5797       if (VOID_TYPE_P (TREE_TYPE (false_value)))
5798         rhs = false_value;
5799     }
5800   else
5801     {
5802       tree testtype = TREE_TYPE (cond);
5803       test = cond;
5804       true_value = constant_boolean_node (true, testtype);
5805       false_value = constant_boolean_node (false, testtype);
5806     }
5807
5808   arg = fold_convert (arg_type, arg);
5809   if (lhs == 0)
5810     {
5811       true_value = fold_convert (cond_type, true_value);
5812       if (cond_first_p)
5813         lhs = fold_build2 (code, type, true_value, arg);
5814       else
5815         lhs = fold_build2 (code, type, arg, true_value);
5816     }
5817   if (rhs == 0)
5818     {
5819       false_value = fold_convert (cond_type, false_value);
5820       if (cond_first_p)
5821         rhs = fold_build2 (code, type, false_value, arg);
5822       else
5823         rhs = fold_build2 (code, type, arg, false_value);
5824     }
5825
5826   test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
5827   return fold_convert (type, test);
5828 }
5829
5830 \f
5831 /* Subroutine of fold() that checks for the addition of +/- 0.0.
5832
5833    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
5834    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
5835    ADDEND is the same as X.
5836
5837    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
5838    and finite.  The problematic cases are when X is zero, and its mode
5839    has signed zeros.  In the case of rounding towards -infinity,
5840    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
5841    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
5842
5843 static bool
5844 fold_real_zero_addition_p (tree type, tree addend, int negate)
5845 {
5846   if (!real_zerop (addend))
5847     return false;
5848
5849   /* Don't allow the fold with -fsignaling-nans.  */
5850   if (HONOR_SNANS (TYPE_MODE (type)))
5851     return false;
5852
5853   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
5854   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
5855     return true;
5856
5857   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
5858   if (TREE_CODE (addend) == REAL_CST
5859       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
5860     negate = !negate;
5861
5862   /* The mode has signed zeros, and we have to honor their sign.
5863      In this situation, there is only one case we can return true for.
5864      X - 0 is the same as X unless rounding towards -infinity is
5865      supported.  */
5866   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
5867 }
5868
5869 /* Subroutine of fold() that checks comparisons of built-in math
5870    functions against real constants.
5871
5872    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
5873    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
5874    is the type of the result and ARG0 and ARG1 are the operands of the
5875    comparison.  ARG1 must be a TREE_REAL_CST.
5876
5877    The function returns the constant folded tree if a simplification
5878    can be made, and NULL_TREE otherwise.  */
5879
5880 static tree
5881 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
5882                      tree type, tree arg0, tree arg1)
5883 {
5884   REAL_VALUE_TYPE c;
5885
5886   if (BUILTIN_SQRT_P (fcode))
5887     {
5888       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
5889       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
5890
5891       c = TREE_REAL_CST (arg1);
5892       if (REAL_VALUE_NEGATIVE (c))
5893         {
5894           /* sqrt(x) < y is always false, if y is negative.  */
5895           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
5896             return omit_one_operand (type, integer_zero_node, arg);
5897
5898           /* sqrt(x) > y is always true, if y is negative and we
5899              don't care about NaNs, i.e. negative values of x.  */
5900           if (code == NE_EXPR || !HONOR_NANS (mode))
5901             return omit_one_operand (type, integer_one_node, arg);
5902
5903           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
5904           return fold_build2 (GE_EXPR, type, arg,
5905                               build_real (TREE_TYPE (arg), dconst0));
5906         }
5907       else if (code == GT_EXPR || code == GE_EXPR)
5908         {
5909           REAL_VALUE_TYPE c2;
5910
5911           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5912           real_convert (&c2, mode, &c2);
5913
5914           if (REAL_VALUE_ISINF (c2))
5915             {
5916               /* sqrt(x) > y is x == +Inf, when y is very large.  */
5917               if (HONOR_INFINITIES (mode))
5918                 return fold_build2 (EQ_EXPR, type, arg,
5919                                     build_real (TREE_TYPE (arg), c2));
5920
5921               /* sqrt(x) > y is always false, when y is very large
5922                  and we don't care about infinities.  */
5923               return omit_one_operand (type, integer_zero_node, arg);
5924             }
5925
5926           /* sqrt(x) > c is the same as x > c*c.  */
5927           return fold_build2 (code, type, arg,
5928                               build_real (TREE_TYPE (arg), c2));
5929         }
5930       else if (code == LT_EXPR || code == LE_EXPR)
5931         {
5932           REAL_VALUE_TYPE c2;
5933
5934           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
5935           real_convert (&c2, mode, &c2);
5936
5937           if (REAL_VALUE_ISINF (c2))
5938             {
5939               /* sqrt(x) < y is always true, when y is a very large
5940                  value and we don't care about NaNs or Infinities.  */
5941               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
5942                 return omit_one_operand (type, integer_one_node, arg);
5943
5944               /* sqrt(x) < y is x != +Inf when y is very large and we
5945                  don't care about NaNs.  */
5946               if (! HONOR_NANS (mode))
5947                 return fold_build2 (NE_EXPR, type, arg,
5948                                     build_real (TREE_TYPE (arg), c2));
5949
5950               /* sqrt(x) < y is x >= 0 when y is very large and we
5951                  don't care about Infinities.  */
5952               if (! HONOR_INFINITIES (mode))
5953                 return fold_build2 (GE_EXPR, type, arg,
5954                                     build_real (TREE_TYPE (arg), dconst0));
5955
5956               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
5957               if (lang_hooks.decls.global_bindings_p () != 0
5958                   || CONTAINS_PLACEHOLDER_P (arg))
5959                 return NULL_TREE;
5960
5961               arg = save_expr (arg);
5962               return fold_build2 (TRUTH_ANDIF_EXPR, type,
5963                                   fold_build2 (GE_EXPR, type, arg,
5964                                                build_real (TREE_TYPE (arg),
5965                                                            dconst0)),
5966                                   fold_build2 (NE_EXPR, type, arg,
5967                                                build_real (TREE_TYPE (arg),
5968                                                            c2)));
5969             }
5970
5971           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
5972           if (! HONOR_NANS (mode))
5973             return fold_build2 (code, type, arg,
5974                                 build_real (TREE_TYPE (arg), c2));
5975
5976           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
5977           if (lang_hooks.decls.global_bindings_p () == 0
5978               && ! CONTAINS_PLACEHOLDER_P (arg))
5979             {
5980               arg = save_expr (arg);
5981               return fold_build2 (TRUTH_ANDIF_EXPR, type,
5982                                   fold_build2 (GE_EXPR, type, arg,
5983                                                build_real (TREE_TYPE (arg),
5984                                                            dconst0)),
5985                                   fold_build2 (code, type, arg,
5986                                                build_real (TREE_TYPE (arg),
5987                                                            c2)));
5988             }
5989         }
5990     }
5991
5992   return NULL_TREE;
5993 }
5994
5995 /* Subroutine of fold() that optimizes comparisons against Infinities,
5996    either +Inf or -Inf.
5997
5998    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
5999    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6000    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6001
6002    The function returns the constant folded tree if a simplification
6003    can be made, and NULL_TREE otherwise.  */
6004
6005 static tree
6006 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6007 {
6008   enum machine_mode mode;
6009   REAL_VALUE_TYPE max;
6010   tree temp;
6011   bool neg;
6012
6013   mode = TYPE_MODE (TREE_TYPE (arg0));
6014
6015   /* For negative infinity swap the sense of the comparison.  */
6016   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6017   if (neg)
6018     code = swap_tree_comparison (code);
6019
6020   switch (code)
6021     {
6022     case GT_EXPR:
6023       /* x > +Inf is always false, if with ignore sNANs.  */
6024       if (HONOR_SNANS (mode))
6025         return NULL_TREE;
6026       return omit_one_operand (type, integer_zero_node, arg0);
6027
6028     case LE_EXPR:
6029       /* x <= +Inf is always true, if we don't case about NaNs.  */
6030       if (! HONOR_NANS (mode))
6031         return omit_one_operand (type, integer_one_node, arg0);
6032
6033       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
6034       if (lang_hooks.decls.global_bindings_p () == 0
6035           && ! CONTAINS_PLACEHOLDER_P (arg0))
6036         {
6037           arg0 = save_expr (arg0);
6038           return fold_build2 (EQ_EXPR, type, arg0, arg0);
6039         }
6040       break;
6041
6042     case EQ_EXPR:
6043     case GE_EXPR:
6044       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
6045       real_maxval (&max, neg, mode);
6046       return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6047                           arg0, build_real (TREE_TYPE (arg0), max));
6048
6049     case LT_EXPR:
6050       /* x < +Inf is always equal to x <= DBL_MAX.  */
6051       real_maxval (&max, neg, mode);
6052       return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6053                           arg0, build_real (TREE_TYPE (arg0), max));
6054
6055     case NE_EXPR:
6056       /* x != +Inf is always equal to !(x > DBL_MAX).  */
6057       real_maxval (&max, neg, mode);
6058       if (! HONOR_NANS (mode))
6059         return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6060                             arg0, build_real (TREE_TYPE (arg0), max));
6061
6062       /* The transformation below creates non-gimple code and thus is
6063          not appropriate if we are in gimple form.  */
6064       if (in_gimple_form)
6065         return NULL_TREE;
6066
6067       temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6068                           arg0, build_real (TREE_TYPE (arg0), max));
6069       return fold_build1 (TRUTH_NOT_EXPR, type, temp);
6070
6071     default:
6072       break;
6073     }
6074
6075   return NULL_TREE;
6076 }
6077
6078 /* Subroutine of fold() that optimizes comparisons of a division by
6079    a nonzero integer constant against an integer constant, i.e.
6080    X/C1 op C2.
6081
6082    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6083    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6084    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6085
6086    The function returns the constant folded tree if a simplification
6087    can be made, and NULL_TREE otherwise.  */
6088
6089 static tree
6090 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6091 {
6092   tree prod, tmp, hi, lo;
6093   tree arg00 = TREE_OPERAND (arg0, 0);
6094   tree arg01 = TREE_OPERAND (arg0, 1);
6095   unsigned HOST_WIDE_INT lpart;
6096   HOST_WIDE_INT hpart;
6097   bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6098   bool neg_overflow;
6099   int overflow;
6100
6101   /* We have to do this the hard way to detect unsigned overflow.
6102      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
6103   overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6104                                    TREE_INT_CST_HIGH (arg01),
6105                                    TREE_INT_CST_LOW (arg1),
6106                                    TREE_INT_CST_HIGH (arg1),
6107                                    &lpart, &hpart, unsigned_p);
6108   prod = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
6109   prod = force_fit_type (prod, -1, overflow, false);
6110   neg_overflow = false;
6111
6112   if (unsigned_p)
6113     {
6114       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
6115       lo = prod;
6116
6117       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
6118       overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6119                                        TREE_INT_CST_HIGH (prod),
6120                                        TREE_INT_CST_LOW (tmp),
6121                                        TREE_INT_CST_HIGH (tmp),
6122                                        &lpart, &hpart, unsigned_p);
6123       hi = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
6124       hi = force_fit_type (hi, -1, overflow | TREE_OVERFLOW (prod),
6125                            TREE_CONSTANT_OVERFLOW (prod));
6126     }
6127   else if (tree_int_cst_sgn (arg01) >= 0)
6128     {
6129       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
6130       switch (tree_int_cst_sgn (arg1))
6131         {
6132         case -1:
6133           neg_overflow = true;
6134           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6135           hi = prod;
6136           break;
6137
6138         case  0:
6139           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6140           hi = tmp;
6141           break;
6142
6143         case  1:
6144           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6145           lo = prod;
6146           break;
6147
6148         default:
6149           gcc_unreachable ();
6150         }
6151     }
6152   else
6153     {
6154       /* A negative divisor reverses the relational operators.  */
6155       code = swap_tree_comparison (code);
6156
6157       tmp = int_const_binop (PLUS_EXPR, arg01, integer_one_node, 0);
6158       switch (tree_int_cst_sgn (arg1))
6159         {
6160         case -1:
6161           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6162           lo = prod;
6163           break;
6164
6165         case  0:
6166           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6167           lo = tmp;
6168           break;
6169
6170         case  1:
6171           neg_overflow = true;
6172           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6173           hi = prod;
6174           break;
6175
6176         default:
6177           gcc_unreachable ();
6178         }
6179     }
6180
6181   switch (code)
6182     {
6183     case EQ_EXPR:
6184       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6185         return omit_one_operand (type, integer_zero_node, arg00);
6186       if (TREE_OVERFLOW (hi))
6187         return fold_build2 (GE_EXPR, type, arg00, lo);
6188       if (TREE_OVERFLOW (lo))
6189         return fold_build2 (LE_EXPR, type, arg00, hi);
6190       return build_range_check (type, arg00, 1, lo, hi);
6191
6192     case NE_EXPR:
6193       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6194         return omit_one_operand (type, integer_one_node, arg00);
6195       if (TREE_OVERFLOW (hi))
6196         return fold_build2 (LT_EXPR, type, arg00, lo);
6197       if (TREE_OVERFLOW (lo))
6198         return fold_build2 (GT_EXPR, type, arg00, hi);
6199       return build_range_check (type, arg00, 0, lo, hi);
6200
6201     case LT_EXPR:
6202       if (TREE_OVERFLOW (lo))
6203         {
6204           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6205           return omit_one_operand (type, tmp, arg00);
6206         }
6207       return fold_build2 (LT_EXPR, type, arg00, lo);
6208
6209     case LE_EXPR:
6210       if (TREE_OVERFLOW (hi))
6211         {
6212           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6213           return omit_one_operand (type, tmp, arg00);
6214         }
6215       return fold_build2 (LE_EXPR, type, arg00, hi);
6216
6217     case GT_EXPR:
6218       if (TREE_OVERFLOW (hi))
6219         {
6220           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6221           return omit_one_operand (type, tmp, arg00);
6222         }
6223       return fold_build2 (GT_EXPR, type, arg00, hi);
6224
6225     case GE_EXPR:
6226       if (TREE_OVERFLOW (lo))
6227         {
6228           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6229           return omit_one_operand (type, tmp, arg00);
6230         }
6231       return fold_build2 (GE_EXPR, type, arg00, lo);
6232
6233     default:
6234       break;
6235     }
6236
6237   return NULL_TREE;
6238 }
6239
6240
6241 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6242    equality/inequality test, then return a simplified form of the test
6243    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6244    result type.  */
6245
6246 static tree
6247 fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
6248                                      tree result_type)
6249 {
6250   /* If this is testing a single bit, we can optimize the test.  */
6251   if ((code == NE_EXPR || code == EQ_EXPR)
6252       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6253       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6254     {
6255       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6256          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6257       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6258
6259       if (arg00 != NULL_TREE
6260           /* This is only a win if casting to a signed type is cheap,
6261              i.e. when arg00's type is not a partial mode.  */
6262           && TYPE_PRECISION (TREE_TYPE (arg00))
6263              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6264         {
6265           tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
6266           return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6267                               result_type, fold_convert (stype, arg00),
6268                               build_int_cst (stype, 0));
6269         }
6270     }
6271
6272   return NULL_TREE;
6273 }
6274
6275 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6276    equality/inequality test, then return a simplified form of
6277    the test using shifts and logical operations.  Otherwise return
6278    NULL.  TYPE is the desired result type.  */
6279
6280 tree
6281 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
6282                       tree result_type)
6283 {
6284   /* If this is testing a single bit, we can optimize the test.  */
6285   if ((code == NE_EXPR || code == EQ_EXPR)
6286       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6287       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6288     {
6289       tree inner = TREE_OPERAND (arg0, 0);
6290       tree type = TREE_TYPE (arg0);
6291       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6292       enum machine_mode operand_mode = TYPE_MODE (type);
6293       int ops_unsigned;
6294       tree signed_type, unsigned_type, intermediate_type;
6295       tree tem;
6296
6297       /* First, see if we can fold the single bit test into a sign-bit
6298          test.  */
6299       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6300                                                  result_type);
6301       if (tem)
6302         return tem;
6303
6304       /* Otherwise we have (A & C) != 0 where C is a single bit,
6305          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6306          Similarly for (A & C) == 0.  */
6307
6308       /* If INNER is a right shift of a constant and it plus BITNUM does
6309          not overflow, adjust BITNUM and INNER.  */
6310       if (TREE_CODE (inner) == RSHIFT_EXPR
6311           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6312           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6313           && bitnum < TYPE_PRECISION (type)
6314           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6315                                    bitnum - TYPE_PRECISION (type)))
6316         {
6317           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6318           inner = TREE_OPERAND (inner, 0);
6319         }
6320
6321       /* If we are going to be able to omit the AND below, we must do our
6322          operations as unsigned.  If we must use the AND, we have a choice.
6323          Normally unsigned is faster, but for some machines signed is.  */
6324 #ifdef LOAD_EXTEND_OP
6325       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6326                       && !flag_syntax_only) ? 0 : 1;
6327 #else
6328       ops_unsigned = 1;
6329 #endif
6330
6331       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6332       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6333       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6334       inner = fold_convert (intermediate_type, inner);
6335
6336       if (bitnum != 0)
6337         inner = build2 (RSHIFT_EXPR, intermediate_type,
6338                         inner, size_int (bitnum));
6339
6340       if (code == EQ_EXPR)
6341         inner = fold_build2 (BIT_XOR_EXPR, intermediate_type,
6342                              inner, integer_one_node);
6343
6344       /* Put the AND last so it can combine with more things.  */
6345       inner = build2 (BIT_AND_EXPR, intermediate_type,
6346                       inner, integer_one_node);
6347
6348       /* Make sure to return the proper type.  */
6349       inner = fold_convert (result_type, inner);
6350
6351       return inner;
6352     }
6353   return NULL_TREE;
6354 }
6355
6356 /* Check whether we are allowed to reorder operands arg0 and arg1,
6357    such that the evaluation of arg1 occurs before arg0.  */
6358
6359 static bool
6360 reorder_operands_p (tree arg0, tree arg1)
6361 {
6362   if (! flag_evaluation_order)
6363       return true;
6364   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6365     return true;
6366   return ! TREE_SIDE_EFFECTS (arg0)
6367          && ! TREE_SIDE_EFFECTS (arg1);
6368 }
6369
6370 /* Test whether it is preferable two swap two operands, ARG0 and
6371    ARG1, for example because ARG0 is an integer constant and ARG1
6372    isn't.  If REORDER is true, only recommend swapping if we can
6373    evaluate the operands in reverse order.  */
6374
6375 bool
6376 tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
6377 {
6378   STRIP_SIGN_NOPS (arg0);
6379   STRIP_SIGN_NOPS (arg1);
6380
6381   if (TREE_CODE (arg1) == INTEGER_CST)
6382     return 0;
6383   if (TREE_CODE (arg0) == INTEGER_CST)
6384     return 1;
6385
6386   if (TREE_CODE (arg1) == REAL_CST)
6387     return 0;
6388   if (TREE_CODE (arg0) == REAL_CST)
6389     return 1;
6390
6391   if (TREE_CODE (arg1) == COMPLEX_CST)
6392     return 0;
6393   if (TREE_CODE (arg0) == COMPLEX_CST)
6394     return 1;
6395
6396   if (TREE_CONSTANT (arg1))
6397     return 0;
6398   if (TREE_CONSTANT (arg0))
6399     return 1;
6400
6401   if (optimize_size)
6402     return 0;
6403
6404   if (reorder && flag_evaluation_order
6405       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6406     return 0;
6407
6408   if (DECL_P (arg1))
6409     return 0;
6410   if (DECL_P (arg0))
6411     return 1;
6412
6413   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6414      for commutative and comparison operators.  Ensuring a canonical
6415      form allows the optimizers to find additional redundancies without
6416      having to explicitly check for both orderings.  */
6417   if (TREE_CODE (arg0) == SSA_NAME
6418       && TREE_CODE (arg1) == SSA_NAME
6419       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6420     return 1;
6421
6422   return 0;
6423 }
6424
6425 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6426    ARG0 is extended to a wider type.  */
6427
6428 static tree
6429 fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
6430 {
6431   tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6432   tree arg1_unw;
6433   tree shorter_type, outer_type;
6434   tree min, max;
6435   bool above, below;
6436
6437   if (arg0_unw == arg0)
6438     return NULL_TREE;
6439   shorter_type = TREE_TYPE (arg0_unw);
6440
6441 #ifdef HAVE_canonicalize_funcptr_for_compare
6442   /* Disable this optimization if we're casting a function pointer
6443      type on targets that require function pointer canonicalization.  */
6444   if (HAVE_canonicalize_funcptr_for_compare
6445       && TREE_CODE (shorter_type) == POINTER_TYPE
6446       && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6447     return NULL_TREE;
6448 #endif
6449
6450   if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6451     return NULL_TREE;
6452
6453   arg1_unw = get_unwidened (arg1, shorter_type);
6454
6455   /* If possible, express the comparison in the shorter mode.  */
6456   if ((code == EQ_EXPR || code == NE_EXPR
6457        || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6458       && (TREE_TYPE (arg1_unw) == shorter_type
6459           || (TREE_CODE (arg1_unw) == INTEGER_CST
6460               && (TREE_CODE (shorter_type) == INTEGER_TYPE
6461                   || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6462               && int_fits_type_p (arg1_unw, shorter_type))))
6463     return fold_build2 (code, type, arg0_unw,
6464                        fold_convert (shorter_type, arg1_unw));
6465
6466   if (TREE_CODE (arg1_unw) != INTEGER_CST
6467       || TREE_CODE (shorter_type) != INTEGER_TYPE
6468       || !int_fits_type_p (arg1_unw, shorter_type))
6469     return NULL_TREE;
6470
6471   /* If we are comparing with the integer that does not fit into the range
6472      of the shorter type, the result is known.  */
6473   outer_type = TREE_TYPE (arg1_unw);
6474   min = lower_bound_in_type (outer_type, shorter_type);
6475   max = upper_bound_in_type (outer_type, shorter_type);
6476
6477   above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6478                                                    max, arg1_unw));
6479   below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6480                                                    arg1_unw, min));
6481
6482   switch (code)
6483     {
6484     case EQ_EXPR:
6485       if (above || below)
6486         return omit_one_operand (type, integer_zero_node, arg0);
6487       break;
6488
6489     case NE_EXPR:
6490       if (above || below)
6491         return omit_one_operand (type, integer_one_node, arg0);
6492       break;
6493
6494     case LT_EXPR:
6495     case LE_EXPR:
6496       if (above)
6497         return omit_one_operand (type, integer_one_node, arg0);
6498       else if (below)
6499         return omit_one_operand (type, integer_zero_node, arg0);
6500
6501     case GT_EXPR:
6502     case GE_EXPR:
6503       if (above)
6504         return omit_one_operand (type, integer_zero_node, arg0);
6505       else if (below)
6506         return omit_one_operand (type, integer_one_node, arg0);
6507
6508     default:
6509       break;
6510     }
6511
6512   return NULL_TREE;
6513 }
6514
6515 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6516    ARG0 just the signedness is changed.  */
6517
6518 static tree
6519 fold_sign_changed_comparison (enum tree_code code, tree type,
6520                               tree arg0, tree arg1)
6521 {
6522   tree arg0_inner, tmp;
6523   tree inner_type, outer_type;
6524
6525   if (TREE_CODE (arg0) != NOP_EXPR
6526       && TREE_CODE (arg0) != CONVERT_EXPR)
6527     return NULL_TREE;
6528
6529   outer_type = TREE_TYPE (arg0);
6530   arg0_inner = TREE_OPERAND (arg0, 0);
6531   inner_type = TREE_TYPE (arg0_inner);
6532
6533 #ifdef HAVE_canonicalize_funcptr_for_compare
6534   /* Disable this optimization if we're casting a function pointer
6535      type on targets that require function pointer canonicalization.  */
6536   if (HAVE_canonicalize_funcptr_for_compare
6537       && TREE_CODE (inner_type) == POINTER_TYPE
6538       && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6539     return NULL_TREE;
6540 #endif
6541
6542   if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6543     return NULL_TREE;
6544
6545   if (TREE_CODE (arg1) != INTEGER_CST
6546       && !((TREE_CODE (arg1) == NOP_EXPR
6547             || TREE_CODE (arg1) == CONVERT_EXPR)
6548            && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6549     return NULL_TREE;
6550
6551   if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6552       && code != NE_EXPR
6553       && code != EQ_EXPR)
6554     return NULL_TREE;
6555
6556   if (TREE_CODE (arg1) == INTEGER_CST)
6557     {
6558       tmp = build_int_cst_wide (inner_type,
6559                                 TREE_INT_CST_LOW (arg1),
6560                                 TREE_INT_CST_HIGH (arg1));
6561       arg1 = force_fit_type (tmp, 0,
6562                              TREE_OVERFLOW (arg1),
6563                              TREE_CONSTANT_OVERFLOW (arg1));
6564     }
6565   else
6566     arg1 = fold_convert (inner_type, arg1);
6567
6568   return fold_build2 (code, type, arg0_inner, arg1);
6569 }
6570
6571 /* Tries to replace &a[idx] CODE s * delta with &a[idx CODE delta], if s is
6572    step of the array.  Reconstructs s and delta in the case of s * delta
6573    being an integer constant (and thus already folded).
6574    ADDR is the address. MULT is the multiplicative expression.
6575    If the function succeeds, the new address expression is returned.  Otherwise
6576    NULL_TREE is returned.  */
6577
6578 static tree
6579 try_move_mult_to_index (enum tree_code code, tree addr, tree op1)
6580 {
6581   tree s, delta, step;
6582   tree ref = TREE_OPERAND (addr, 0), pref;
6583   tree ret, pos;
6584   tree itype;
6585
6586   /* Canonicalize op1 into a possibly non-constant delta
6587      and an INTEGER_CST s.  */
6588   if (TREE_CODE (op1) == MULT_EXPR)
6589     {
6590       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6591
6592       STRIP_NOPS (arg0);
6593       STRIP_NOPS (arg1);
6594
6595       if (TREE_CODE (arg0) == INTEGER_CST)
6596         {
6597           s = arg0;
6598           delta = arg1;
6599         }
6600       else if (TREE_CODE (arg1) == INTEGER_CST)
6601         {
6602           s = arg1;
6603           delta = arg0;
6604         }
6605       else
6606         return NULL_TREE;
6607     }
6608   else if (TREE_CODE (op1) == INTEGER_CST)
6609     {
6610       delta = op1;
6611       s = NULL_TREE;
6612     }
6613   else
6614     {
6615       /* Simulate we are delta * 1.  */
6616       delta = op1;
6617       s = integer_one_node;
6618     }
6619
6620   for (;; ref = TREE_OPERAND (ref, 0))
6621     {
6622       if (TREE_CODE (ref) == ARRAY_REF)
6623         {
6624           itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
6625           if (! itype)
6626             continue;
6627
6628           step = array_ref_element_size (ref);
6629           if (TREE_CODE (step) != INTEGER_CST)
6630             continue;
6631
6632           if (s)
6633             {
6634               if (! tree_int_cst_equal (step, s))
6635                 continue;
6636             }
6637           else
6638             {
6639               /* Try if delta is a multiple of step.  */
6640               tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, delta, step);
6641               if (! tmp)
6642                 continue;
6643               delta = tmp;
6644             }
6645
6646           break;
6647         }
6648
6649       if (!handled_component_p (ref))
6650         return NULL_TREE;
6651     }
6652
6653   /* We found the suitable array reference.  So copy everything up to it,
6654      and replace the index.  */
6655
6656   pref = TREE_OPERAND (addr, 0);
6657   ret = copy_node (pref);
6658   pos = ret;
6659
6660   while (pref != ref)
6661     {
6662       pref = TREE_OPERAND (pref, 0);
6663       TREE_OPERAND (pos, 0) = copy_node (pref);
6664       pos = TREE_OPERAND (pos, 0);
6665     }
6666
6667   TREE_OPERAND (pos, 1) = fold_build2 (code, itype,
6668                                        fold_convert (itype,
6669                                                      TREE_OPERAND (pos, 1)),
6670                                        fold_convert (itype, delta));
6671
6672   return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
6673 }
6674
6675
6676 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
6677    means A >= Y && A != MAX, but in this case we know that
6678    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
6679
6680 static tree
6681 fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
6682 {
6683   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6684
6685   if (TREE_CODE (bound) == LT_EXPR)
6686     a = TREE_OPERAND (bound, 0);
6687   else if (TREE_CODE (bound) == GT_EXPR)
6688     a = TREE_OPERAND (bound, 1);
6689   else
6690     return NULL_TREE;
6691
6692   typea = TREE_TYPE (a);
6693   if (!INTEGRAL_TYPE_P (typea)
6694       && !POINTER_TYPE_P (typea))
6695     return NULL_TREE;
6696
6697   if (TREE_CODE (ineq) == LT_EXPR)
6698     {
6699       a1 = TREE_OPERAND (ineq, 1);
6700       y = TREE_OPERAND (ineq, 0);
6701     }
6702   else if (TREE_CODE (ineq) == GT_EXPR)
6703     {
6704       a1 = TREE_OPERAND (ineq, 0);
6705       y = TREE_OPERAND (ineq, 1);
6706     }
6707   else
6708     return NULL_TREE;
6709
6710   if (TREE_TYPE (a1) != typea)
6711     return NULL_TREE;
6712
6713   diff = fold_build2 (MINUS_EXPR, typea, a1, a);
6714   if (!integer_onep (diff))
6715     return NULL_TREE;
6716
6717   return fold_build2 (GE_EXPR, type, a, y);
6718 }
6719
6720 /* Fold a sum or difference of at least one multiplication.
6721    Returns the folded tree or NULL if no simplification could be made.  */
6722
6723 static tree
6724 fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
6725 {
6726   tree arg00, arg01, arg10, arg11;
6727   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6728
6729   /* (A * C) +- (B * C) -> (A+-B) * C.
6730      (A * C) +- A -> A * (C+-1).
6731      We are most concerned about the case where C is a constant,
6732      but other combinations show up during loop reduction.  Since
6733      it is not difficult, try all four possibilities.  */
6734
6735   if (TREE_CODE (arg0) == MULT_EXPR)
6736     {
6737       arg00 = TREE_OPERAND (arg0, 0);
6738       arg01 = TREE_OPERAND (arg0, 1);
6739     }
6740   else
6741     {
6742       arg00 = arg0;
6743       arg01 = build_one_cst (type);
6744     }
6745   if (TREE_CODE (arg1) == MULT_EXPR)
6746     {
6747       arg10 = TREE_OPERAND (arg1, 0);
6748       arg11 = TREE_OPERAND (arg1, 1);
6749     }
6750   else
6751     {
6752       arg10 = arg1;
6753       arg11 = build_one_cst (type);
6754     }
6755   same = NULL_TREE;
6756
6757   if (operand_equal_p (arg01, arg11, 0))
6758     same = arg01, alt0 = arg00, alt1 = arg10;
6759   else if (operand_equal_p (arg00, arg10, 0))
6760     same = arg00, alt0 = arg01, alt1 = arg11;
6761   else if (operand_equal_p (arg00, arg11, 0))
6762     same = arg00, alt0 = arg01, alt1 = arg10;
6763   else if (operand_equal_p (arg01, arg10, 0))
6764     same = arg01, alt0 = arg00, alt1 = arg11;
6765
6766   /* No identical multiplicands; see if we can find a common
6767      power-of-two factor in non-power-of-two multiplies.  This
6768      can help in multi-dimensional array access.  */
6769   else if (host_integerp (arg01, 0)
6770            && host_integerp (arg11, 0))
6771     {
6772       HOST_WIDE_INT int01, int11, tmp;
6773       bool swap = false;
6774       tree maybe_same;
6775       int01 = TREE_INT_CST_LOW (arg01);
6776       int11 = TREE_INT_CST_LOW (arg11);
6777
6778       /* Move min of absolute values to int11.  */
6779       if ((int01 >= 0 ? int01 : -int01)
6780           < (int11 >= 0 ? int11 : -int11))
6781         {
6782           tmp = int01, int01 = int11, int11 = tmp;
6783           alt0 = arg00, arg00 = arg10, arg10 = alt0;
6784           maybe_same = arg01;
6785           swap = true;
6786         }
6787       else
6788         maybe_same = arg11;
6789
6790       if (exact_log2 (int11) > 0 && int01 % int11 == 0)
6791         {
6792           alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
6793                               build_int_cst (TREE_TYPE (arg00),
6794                                              int01 / int11));
6795           alt1 = arg10;
6796           same = maybe_same;
6797           if (swap)
6798             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
6799         }
6800     }
6801
6802   if (same)
6803     return fold_build2 (MULT_EXPR, type,
6804                         fold_build2 (code, type,
6805                                      fold_convert (type, alt0),
6806                                      fold_convert (type, alt1)),
6807                         fold_convert (type, same));
6808
6809   return NULL_TREE;
6810 }
6811
6812 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
6813    specified by EXPR into the buffer PTR of length LEN bytes.
6814    Return the number of bytes placed in the buffer, or zero
6815    upon failure.  */
6816
6817 static int
6818 native_encode_int (tree expr, unsigned char *ptr, int len)
6819 {
6820   tree type = TREE_TYPE (expr);
6821   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
6822   int byte, offset, word, words;
6823   unsigned char value;
6824
6825   if (total_bytes > len)
6826     return 0;
6827   words = total_bytes / UNITS_PER_WORD;
6828
6829   for (byte = 0; byte < total_bytes; byte++)
6830     {
6831       int bitpos = byte * BITS_PER_UNIT;
6832       if (bitpos < HOST_BITS_PER_WIDE_INT)
6833         value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
6834       else
6835         value = (unsigned char) (TREE_INT_CST_HIGH (expr)
6836                                  >> (bitpos - HOST_BITS_PER_WIDE_INT));
6837
6838       if (total_bytes > UNITS_PER_WORD)
6839         {
6840           word = byte / UNITS_PER_WORD;
6841           if (WORDS_BIG_ENDIAN)
6842             word = (words - 1) - word;
6843           offset = word * UNITS_PER_WORD;
6844           if (BYTES_BIG_ENDIAN)
6845             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
6846           else
6847             offset += byte % UNITS_PER_WORD;
6848         }
6849       else
6850         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
6851       ptr[offset] = value;
6852     }
6853   return total_bytes;
6854 }
6855
6856
6857 /* Subroutine of native_encode_expr.  Encode the REAL_CST
6858    specified by EXPR into the buffer PTR of length LEN bytes.
6859    Return the number of bytes placed in the buffer, or zero
6860    upon failure.  */
6861
6862 static int
6863 native_encode_real (tree expr, unsigned char *ptr, int len)
6864 {
6865   tree type = TREE_TYPE (expr);
6866   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
6867   int byte, offset, word, words;
6868   unsigned char value;
6869
6870   /* There are always 32 bits in each long, no matter the size of
6871      the hosts long.  We handle floating point representations with
6872      up to 192 bits.  */
6873   long tmp[6];
6874
6875   if (total_bytes > len)
6876     return 0;
6877   words = total_bytes / UNITS_PER_WORD;
6878
6879   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
6880
6881   for (byte = 0; byte < total_bytes; byte++)
6882     {
6883       int bitpos = byte * BITS_PER_UNIT;
6884       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
6885
6886       if (total_bytes > UNITS_PER_WORD)
6887         {
6888           word = byte / UNITS_PER_WORD;
6889           if (FLOAT_WORDS_BIG_ENDIAN)
6890             word = (words - 1) - word;
6891           offset = word * UNITS_PER_WORD;
6892           if (BYTES_BIG_ENDIAN)
6893             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
6894           else
6895             offset += byte % UNITS_PER_WORD;
6896         }
6897       else
6898         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
6899       ptr[offset] = value;
6900     }
6901   return total_bytes;
6902 }
6903
6904 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
6905    specified by EXPR into the buffer PTR of length LEN bytes.
6906    Return the number of bytes placed in the buffer, or zero
6907    upon failure.  */
6908
6909 static int
6910 native_encode_complex (tree expr, unsigned char *ptr, int len)
6911 {
6912   int rsize, isize;
6913   tree part;
6914
6915   part = TREE_REALPART (expr);
6916   rsize = native_encode_expr (part, ptr, len);
6917   if (rsize == 0)
6918     return 0;
6919   part = TREE_IMAGPART (expr);
6920   isize = native_encode_expr (part, ptr+rsize, len-rsize);
6921   if (isize != rsize)
6922     return 0;
6923   return rsize + isize;
6924 }
6925
6926
6927 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
6928    specified by EXPR into the buffer PTR of length LEN bytes.
6929    Return the number of bytes placed in the buffer, or zero
6930    upon failure.  */
6931
6932 static int
6933 native_encode_vector (tree expr, unsigned char *ptr, int len)
6934 {
6935   int i, size, offset, count;
6936   tree itype, elem, elements;
6937
6938   offset = 0;
6939   elements = TREE_VECTOR_CST_ELTS (expr);
6940   count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
6941   itype = TREE_TYPE (TREE_TYPE (expr));
6942   size = GET_MODE_SIZE (TYPE_MODE (itype));
6943   for (i = 0; i < count; i++)
6944     {
6945       if (elements)
6946         {
6947           elem = TREE_VALUE (elements);
6948           elements = TREE_CHAIN (elements);
6949         }
6950       else
6951         elem = NULL_TREE;
6952
6953       if (elem)
6954         {
6955           if (native_encode_expr (elem, ptr+offset, len-offset) != size)
6956             return 0;
6957         }
6958       else
6959         {
6960           if (offset + size > len)
6961             return 0;
6962           memset (ptr+offset, 0, size);
6963         }
6964       offset += size;
6965     }
6966   return offset;
6967 }
6968
6969
6970 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
6971    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
6972    buffer PTR of length LEN bytes.  Return the number of bytes
6973    placed in the buffer, or zero upon failure.  */
6974
6975 static int
6976 native_encode_expr (tree expr, unsigned char *ptr, int len)
6977 {
6978   switch (TREE_CODE (expr))
6979     {
6980     case INTEGER_CST:
6981       return native_encode_int (expr, ptr, len);
6982
6983     case REAL_CST:
6984       return native_encode_real (expr, ptr, len);
6985
6986     case COMPLEX_CST:
6987       return native_encode_complex (expr, ptr, len);
6988
6989     case VECTOR_CST:
6990       return native_encode_vector (expr, ptr, len);
6991
6992     default:
6993       return 0;
6994     }
6995 }
6996
6997
6998 /* Subroutine of native_interpret_expr.  Interpret the contents of
6999    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7000    If the buffer cannot be interpreted, return NULL_TREE.  */
7001
7002 static tree
7003 native_interpret_int (tree type, unsigned char *ptr, int len)
7004 {
7005   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7006   int byte, offset, word, words;
7007   unsigned char value;
7008   unsigned int HOST_WIDE_INT lo = 0;
7009   HOST_WIDE_INT hi = 0;
7010
7011   if (total_bytes > len)
7012     return NULL_TREE;
7013   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7014     return NULL_TREE;
7015   words = total_bytes / UNITS_PER_WORD;
7016
7017   for (byte = 0; byte < total_bytes; byte++)
7018     {
7019       int bitpos = byte * BITS_PER_UNIT;
7020       if (total_bytes > UNITS_PER_WORD)
7021         {
7022           word = byte / UNITS_PER_WORD;
7023           if (WORDS_BIG_ENDIAN)
7024             word = (words - 1) - word;
7025           offset = word * UNITS_PER_WORD;
7026           if (BYTES_BIG_ENDIAN)
7027             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7028           else
7029             offset += byte % UNITS_PER_WORD;
7030         }
7031       else
7032         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7033       value = ptr[offset];
7034
7035       if (bitpos < HOST_BITS_PER_WIDE_INT)
7036         lo |= (unsigned HOST_WIDE_INT) value << bitpos;
7037       else
7038         hi |= (unsigned HOST_WIDE_INT) value
7039               << (bitpos - HOST_BITS_PER_WIDE_INT);
7040     }
7041
7042   return force_fit_type (build_int_cst_wide (type, lo, hi),
7043                          0, false, false);
7044 }
7045
7046
7047 /* Subroutine of native_interpret_expr.  Interpret the contents of
7048    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7049    If the buffer cannot be interpreted, return NULL_TREE.  */
7050
7051 static tree
7052 native_interpret_real (tree type, unsigned char *ptr, int len)
7053 {
7054   enum machine_mode mode = TYPE_MODE (type);
7055   int total_bytes = GET_MODE_SIZE (mode);
7056   int byte, offset, word, words;
7057   unsigned char value;
7058   /* There are always 32 bits in each long, no matter the size of
7059      the hosts long.  We handle floating point representations with
7060      up to 192 bits.  */
7061   REAL_VALUE_TYPE r;
7062   long tmp[6];
7063
7064   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7065   if (total_bytes > len || total_bytes > 24)
7066     return NULL_TREE;
7067   words = total_bytes / UNITS_PER_WORD;
7068
7069   memset (tmp, 0, sizeof (tmp));
7070   for (byte = 0; byte < total_bytes; byte++)
7071     {
7072       int bitpos = byte * BITS_PER_UNIT;
7073       if (total_bytes > UNITS_PER_WORD)
7074         {
7075           word = byte / UNITS_PER_WORD;
7076           if (FLOAT_WORDS_BIG_ENDIAN)
7077             word = (words - 1) - word;
7078           offset = word * UNITS_PER_WORD;
7079           if (BYTES_BIG_ENDIAN)
7080             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7081           else
7082             offset += byte % UNITS_PER_WORD;
7083         }
7084       else
7085         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7086       value = ptr[offset];
7087
7088       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7089     }
7090
7091   real_from_target (&r, tmp, mode);
7092   return build_real (type, r);
7093 }
7094
7095
7096 /* Subroutine of native_interpret_expr.  Interpret the contents of
7097    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7098    If the buffer cannot be interpreted, return NULL_TREE.  */
7099
7100 static tree
7101 native_interpret_complex (tree type, unsigned char *ptr, int len)
7102 {
7103   tree etype, rpart, ipart;
7104   int size;
7105
7106   etype = TREE_TYPE (type);
7107   size = GET_MODE_SIZE (TYPE_MODE (etype));
7108   if (size * 2 > len)
7109     return NULL_TREE;
7110   rpart = native_interpret_expr (etype, ptr, size);
7111   if (!rpart)
7112     return NULL_TREE;
7113   ipart = native_interpret_expr (etype, ptr+size, size);
7114   if (!ipart)
7115     return NULL_TREE;
7116   return build_complex (type, rpart, ipart);
7117 }
7118
7119
7120 /* Subroutine of native_interpret_expr.  Interpret the contents of
7121    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7122    If the buffer cannot be interpreted, return NULL_TREE.  */
7123
7124 static tree
7125 native_interpret_vector (tree type, unsigned char *ptr, int len)
7126 {
7127   tree etype, elem, elements;
7128   int i, size, count;
7129
7130   etype = TREE_TYPE (type);
7131   size = GET_MODE_SIZE (TYPE_MODE (etype));
7132   count = TYPE_VECTOR_SUBPARTS (type);
7133   if (size * count > len)
7134     return NULL_TREE;
7135
7136   elements = NULL_TREE;
7137   for (i = count - 1; i >= 0; i--)
7138     {
7139       elem = native_interpret_expr (etype, ptr+(i*size), size);
7140       if (!elem)
7141         return NULL_TREE;
7142       elements = tree_cons (NULL_TREE, elem, elements);
7143     }
7144   return build_vector (type, elements);
7145 }
7146
7147
7148 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7149    the buffer PTR of length LEN as a constant of type TYPE.  For
7150    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7151    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7152    return NULL_TREE.  */
7153
7154 static tree
7155 native_interpret_expr (tree type, unsigned char *ptr, int len)
7156 {
7157   switch (TREE_CODE (type))
7158     {
7159     case INTEGER_TYPE:
7160     case ENUMERAL_TYPE:
7161     case BOOLEAN_TYPE:
7162       return native_interpret_int (type, ptr, len);
7163
7164     case REAL_TYPE:
7165       return native_interpret_real (type, ptr, len);
7166
7167     case COMPLEX_TYPE:
7168       return native_interpret_complex (type, ptr, len);
7169
7170     case VECTOR_TYPE:
7171       return native_interpret_vector (type, ptr, len);
7172
7173     default:
7174       return NULL_TREE;
7175     }
7176 }
7177
7178
7179 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7180    TYPE at compile-time.  If we're unable to perform the conversion
7181    return NULL_TREE.  */
7182
7183 static tree
7184 fold_view_convert_expr (tree type, tree expr)
7185 {
7186   /* We support up to 512-bit values (for V8DFmode).  */
7187   unsigned char buffer[64];
7188   int len;
7189
7190   /* Check that the host and target are sane.  */
7191   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7192     return NULL_TREE;
7193
7194   len = native_encode_expr (expr, buffer, sizeof (buffer));
7195   if (len == 0)
7196     return NULL_TREE;
7197
7198   return native_interpret_expr (type, buffer, len);
7199 }
7200
7201
7202 /* Fold a unary expression of code CODE and type TYPE with operand
7203    OP0.  Return the folded expression if folding is successful.
7204    Otherwise, return NULL_TREE.  */
7205
7206 tree
7207 fold_unary (enum tree_code code, tree type, tree op0)
7208 {
7209   tree tem;
7210   tree arg0;
7211   enum tree_code_class kind = TREE_CODE_CLASS (code);
7212
7213   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7214               && TREE_CODE_LENGTH (code) == 1);
7215
7216   arg0 = op0;
7217   if (arg0)
7218     {
7219       if (code == NOP_EXPR || code == CONVERT_EXPR
7220           || code == FLOAT_EXPR || code == ABS_EXPR)
7221         {
7222           /* Don't use STRIP_NOPS, because signedness of argument type
7223              matters.  */
7224           STRIP_SIGN_NOPS (arg0);
7225         }
7226       else
7227         {
7228           /* Strip any conversions that don't change the mode.  This
7229              is safe for every expression, except for a comparison
7230              expression because its signedness is derived from its
7231              operands.
7232
7233              Note that this is done as an internal manipulation within
7234              the constant folder, in order to find the simplest
7235              representation of the arguments so that their form can be
7236              studied.  In any cases, the appropriate type conversions
7237              should be put back in the tree that will get out of the
7238              constant folder.  */
7239           STRIP_NOPS (arg0);
7240         }
7241     }
7242
7243   if (TREE_CODE_CLASS (code) == tcc_unary)
7244     {
7245       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7246         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7247                        fold_build1 (code, type, TREE_OPERAND (arg0, 1)));
7248       else if (TREE_CODE (arg0) == COND_EXPR)
7249         {
7250           tree arg01 = TREE_OPERAND (arg0, 1);
7251           tree arg02 = TREE_OPERAND (arg0, 2);
7252           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7253             arg01 = fold_build1 (code, type, arg01);
7254           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7255             arg02 = fold_build1 (code, type, arg02);
7256           tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
7257                              arg01, arg02);
7258
7259           /* If this was a conversion, and all we did was to move into
7260              inside the COND_EXPR, bring it back out.  But leave it if
7261              it is a conversion from integer to integer and the
7262              result precision is no wider than a word since such a
7263              conversion is cheap and may be optimized away by combine,
7264              while it couldn't if it were outside the COND_EXPR.  Then return
7265              so we don't get into an infinite recursion loop taking the
7266              conversion out and then back in.  */
7267
7268           if ((code == NOP_EXPR || code == CONVERT_EXPR
7269                || code == NON_LVALUE_EXPR)
7270               && TREE_CODE (tem) == COND_EXPR
7271               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7272               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7273               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7274               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7275               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7276                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7277               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7278                      && (INTEGRAL_TYPE_P
7279                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7280                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7281                   || flag_syntax_only))
7282             tem = build1 (code, type,
7283                           build3 (COND_EXPR,
7284                                   TREE_TYPE (TREE_OPERAND
7285                                              (TREE_OPERAND (tem, 1), 0)),
7286                                   TREE_OPERAND (tem, 0),
7287                                   TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7288                                   TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
7289           return tem;
7290         }
7291       else if (COMPARISON_CLASS_P (arg0))
7292         {
7293           if (TREE_CODE (type) == BOOLEAN_TYPE)
7294             {
7295               arg0 = copy_node (arg0);
7296               TREE_TYPE (arg0) = type;
7297               return arg0;
7298             }
7299           else if (TREE_CODE (type) != INTEGER_TYPE)
7300             return fold_build3 (COND_EXPR, type, arg0,
7301                                 fold_build1 (code, type,
7302                                              integer_one_node),
7303                                 fold_build1 (code, type,
7304                                              integer_zero_node));
7305         }
7306    }
7307
7308   switch (code)
7309     {
7310     case NOP_EXPR:
7311     case FLOAT_EXPR:
7312     case CONVERT_EXPR:
7313     case FIX_TRUNC_EXPR:
7314     case FIX_CEIL_EXPR:
7315     case FIX_FLOOR_EXPR:
7316     case FIX_ROUND_EXPR:
7317       if (TREE_TYPE (op0) == type)
7318         return op0;
7319
7320       /* If we have (type) (a CMP b) and type is an integral type, return
7321          new expression involving the new type.  */
7322       if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
7323         return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
7324                             TREE_OPERAND (op0, 1));
7325
7326       /* Handle cases of two conversions in a row.  */
7327       if (TREE_CODE (op0) == NOP_EXPR
7328           || TREE_CODE (op0) == CONVERT_EXPR)
7329         {
7330           tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7331           tree inter_type = TREE_TYPE (op0);
7332           int inside_int = INTEGRAL_TYPE_P (inside_type);
7333           int inside_ptr = POINTER_TYPE_P (inside_type);
7334           int inside_float = FLOAT_TYPE_P (inside_type);
7335           int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7336           unsigned int inside_prec = TYPE_PRECISION (inside_type);
7337           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7338           int inter_int = INTEGRAL_TYPE_P (inter_type);
7339           int inter_ptr = POINTER_TYPE_P (inter_type);
7340           int inter_float = FLOAT_TYPE_P (inter_type);
7341           int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7342           unsigned int inter_prec = TYPE_PRECISION (inter_type);
7343           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7344           int final_int = INTEGRAL_TYPE_P (type);
7345           int final_ptr = POINTER_TYPE_P (type);
7346           int final_float = FLOAT_TYPE_P (type);
7347           int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7348           unsigned int final_prec = TYPE_PRECISION (type);
7349           int final_unsignedp = TYPE_UNSIGNED (type);
7350
7351           /* In addition to the cases of two conversions in a row
7352              handled below, if we are converting something to its own
7353              type via an object of identical or wider precision, neither
7354              conversion is needed.  */
7355           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7356               && (((inter_int || inter_ptr) && final_int)
7357                   || (inter_float && final_float))
7358               && inter_prec >= final_prec)
7359             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7360
7361           /* Likewise, if the intermediate and final types are either both
7362              float or both integer, we don't need the middle conversion if
7363              it is wider than the final type and doesn't change the signedness
7364              (for integers).  Avoid this if the final type is a pointer
7365              since then we sometimes need the inner conversion.  Likewise if
7366              the outer has a precision not equal to the size of its mode.  */
7367           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
7368                || (inter_float && inside_float)
7369                || (inter_vec && inside_vec))
7370               && inter_prec >= inside_prec
7371               && (inter_float || inter_vec
7372                   || inter_unsignedp == inside_unsignedp)
7373               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7374                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7375               && ! final_ptr
7376               && (! final_vec || inter_prec == inside_prec))
7377             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7378
7379           /* If we have a sign-extension of a zero-extended value, we can
7380              replace that by a single zero-extension.  */
7381           if (inside_int && inter_int && final_int
7382               && inside_prec < inter_prec && inter_prec < final_prec
7383               && inside_unsignedp && !inter_unsignedp)
7384             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7385
7386           /* Two conversions in a row are not needed unless:
7387              - some conversion is floating-point (overstrict for now), or
7388              - some conversion is a vector (overstrict for now), or
7389              - the intermediate type is narrower than both initial and
7390                final, or
7391              - the intermediate type and innermost type differ in signedness,
7392                and the outermost type is wider than the intermediate, or
7393              - the initial type is a pointer type and the precisions of the
7394                intermediate and final types differ, or
7395              - the final type is a pointer type and the precisions of the
7396                initial and intermediate types differ.
7397              - the final type is a pointer type and the initial type not
7398              - the initial type is a pointer to an array and the final type
7399                not.  */
7400           if (! inside_float && ! inter_float && ! final_float
7401               && ! inside_vec && ! inter_vec && ! final_vec
7402               && (inter_prec >= inside_prec || inter_prec >= final_prec)
7403               && ! (inside_int && inter_int
7404                     && inter_unsignedp != inside_unsignedp
7405                     && inter_prec < final_prec)
7406               && ((inter_unsignedp && inter_prec > inside_prec)
7407                   == (final_unsignedp && final_prec > inter_prec))
7408               && ! (inside_ptr && inter_prec != final_prec)
7409               && ! (final_ptr && inside_prec != inter_prec)
7410               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7411                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7412               && final_ptr == inside_ptr
7413               && ! (inside_ptr
7414                     && TREE_CODE (TREE_TYPE (inside_type)) == ARRAY_TYPE
7415                     && TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
7416             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7417         }
7418
7419       /* Handle (T *)&A.B.C for A being of type T and B and C
7420          living at offset zero.  This occurs frequently in
7421          C++ upcasting and then accessing the base.  */
7422       if (TREE_CODE (op0) == ADDR_EXPR
7423           && POINTER_TYPE_P (type)
7424           && handled_component_p (TREE_OPERAND (op0, 0)))
7425         {
7426           HOST_WIDE_INT bitsize, bitpos;
7427           tree offset;
7428           enum machine_mode mode;
7429           int unsignedp, volatilep;
7430           tree base = TREE_OPERAND (op0, 0);
7431           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7432                                       &mode, &unsignedp, &volatilep, false);
7433           /* If the reference was to a (constant) zero offset, we can use
7434              the address of the base if it has the same base type
7435              as the result type.  */
7436           if (! offset && bitpos == 0
7437               && TYPE_MAIN_VARIANT (TREE_TYPE (type))
7438                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7439             return fold_convert (type, build_fold_addr_expr (base));
7440         }
7441
7442       if (TREE_CODE (op0) == MODIFY_EXPR
7443           && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7444           /* Detect assigning a bitfield.  */
7445           && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7446                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7447         {
7448           /* Don't leave an assignment inside a conversion
7449              unless assigning a bitfield.  */
7450           tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
7451           /* First do the assignment, then return converted constant.  */
7452           tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7453           TREE_NO_WARNING (tem) = 1;
7454           TREE_USED (tem) = 1;
7455           return tem;
7456         }
7457
7458       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7459          constants (if x has signed type, the sign bit cannot be set
7460          in c).  This folds extension into the BIT_AND_EXPR.  */
7461       if (INTEGRAL_TYPE_P (type)
7462           && TREE_CODE (type) != BOOLEAN_TYPE
7463           && TREE_CODE (op0) == BIT_AND_EXPR
7464           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7465         {
7466           tree and = op0;
7467           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
7468           int change = 0;
7469
7470           if (TYPE_UNSIGNED (TREE_TYPE (and))
7471               || (TYPE_PRECISION (type)
7472                   <= TYPE_PRECISION (TREE_TYPE (and))))
7473             change = 1;
7474           else if (TYPE_PRECISION (TREE_TYPE (and1))
7475                    <= HOST_BITS_PER_WIDE_INT
7476                    && host_integerp (and1, 1))
7477             {
7478               unsigned HOST_WIDE_INT cst;
7479
7480               cst = tree_low_cst (and1, 1);
7481               cst &= (HOST_WIDE_INT) -1
7482                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7483               change = (cst == 0);
7484 #ifdef LOAD_EXTEND_OP
7485               if (change
7486                   && !flag_syntax_only
7487                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7488                       == ZERO_EXTEND))
7489                 {
7490                   tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
7491                   and0 = fold_convert (uns, and0);
7492                   and1 = fold_convert (uns, and1);
7493                 }
7494 #endif
7495             }
7496           if (change)
7497             {
7498               tem = build_int_cst_wide (type, TREE_INT_CST_LOW (and1),
7499                                         TREE_INT_CST_HIGH (and1));
7500               tem = force_fit_type (tem, 0, TREE_OVERFLOW (and1),
7501                                     TREE_CONSTANT_OVERFLOW (and1));
7502               return fold_build2 (BIT_AND_EXPR, type,
7503                                   fold_convert (type, and0), tem);
7504             }
7505         }
7506
7507       /* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
7508          T2 being pointers to types of the same size.  */
7509       if (POINTER_TYPE_P (type)
7510           && BINARY_CLASS_P (arg0)
7511           && TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7512           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7513         {
7514           tree arg00 = TREE_OPERAND (arg0, 0);
7515           tree t0 = type;
7516           tree t1 = TREE_TYPE (arg00);
7517           tree tt0 = TREE_TYPE (t0);
7518           tree tt1 = TREE_TYPE (t1);
7519           tree s0 = TYPE_SIZE (tt0);
7520           tree s1 = TYPE_SIZE (tt1);
7521
7522           if (s0 && s1 && operand_equal_p (s0, s1, OEP_ONLY_CONST))
7523             return build2 (TREE_CODE (arg0), t0, fold_convert (t0, arg00),
7524                            TREE_OPERAND (arg0, 1));
7525         }
7526
7527       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7528          of the same precision, and X is a integer type not narrower than
7529          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
7530       if (INTEGRAL_TYPE_P (type)
7531           && TREE_CODE (op0) == BIT_NOT_EXPR
7532           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7533           && (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
7534               || TREE_CODE (TREE_OPERAND (op0, 0)) == CONVERT_EXPR)
7535           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7536         {
7537           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7538           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7539               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7540             return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
7541         }
7542
7543       tem = fold_convert_const (code, type, arg0);
7544       return tem ? tem : NULL_TREE;
7545
7546     case VIEW_CONVERT_EXPR:
7547       if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
7548         return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
7549       return fold_view_convert_expr (type, op0);
7550
7551     case NEGATE_EXPR:
7552       tem = fold_negate_expr (arg0);
7553       if (tem)
7554         return fold_convert (type, tem);
7555       return NULL_TREE;
7556
7557     case ABS_EXPR:
7558       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
7559         return fold_abs_const (arg0, type);
7560       else if (TREE_CODE (arg0) == NEGATE_EXPR)
7561         return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
7562       /* Convert fabs((double)float) into (double)fabsf(float).  */
7563       else if (TREE_CODE (arg0) == NOP_EXPR
7564                && TREE_CODE (type) == REAL_TYPE)
7565         {
7566           tree targ0 = strip_float_extensions (arg0);
7567           if (targ0 != arg0)
7568             return fold_convert (type, fold_build1 (ABS_EXPR,
7569                                                     TREE_TYPE (targ0),
7570                                                     targ0));
7571         }
7572       /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
7573       else if (tree_expr_nonnegative_p (arg0) || TREE_CODE (arg0) == ABS_EXPR)
7574         return arg0;
7575
7576       /* Strip sign ops from argument.  */
7577       if (TREE_CODE (type) == REAL_TYPE)
7578         {
7579           tem = fold_strip_sign_ops (arg0);
7580           if (tem)
7581             return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
7582         }
7583       return NULL_TREE;
7584
7585     case CONJ_EXPR:
7586       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7587         return fold_convert (type, arg0);
7588       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7589         {
7590           tree itype = TREE_TYPE (type);
7591           tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
7592           tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
7593           return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
7594         }
7595       if (TREE_CODE (arg0) == COMPLEX_CST)
7596         {
7597           tree itype = TREE_TYPE (type);
7598           tree rpart = fold_convert (itype, TREE_REALPART (arg0));
7599           tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
7600           return build_complex (type, rpart, negate_expr (ipart));
7601         }
7602       if (TREE_CODE (arg0) == CONJ_EXPR)
7603         return fold_convert (type, TREE_OPERAND (arg0, 0));
7604       return NULL_TREE;
7605
7606     case BIT_NOT_EXPR:
7607       if (TREE_CODE (arg0) == INTEGER_CST)
7608         return fold_not_const (arg0, type);
7609       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
7610         return TREE_OPERAND (arg0, 0);
7611       /* Convert ~ (-A) to A - 1.  */
7612       else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
7613         return fold_build2 (MINUS_EXPR, type, TREE_OPERAND (arg0, 0),
7614                             build_int_cst (type, 1));
7615       /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
7616       else if (INTEGRAL_TYPE_P (type)
7617                && ((TREE_CODE (arg0) == MINUS_EXPR
7618                     && integer_onep (TREE_OPERAND (arg0, 1)))
7619                    || (TREE_CODE (arg0) == PLUS_EXPR
7620                        && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
7621         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
7622       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
7623       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7624                && (tem = fold_unary (BIT_NOT_EXPR, type,
7625                                      fold_convert (type,
7626                                                    TREE_OPERAND (arg0, 0)))))
7627         return fold_build2 (BIT_XOR_EXPR, type, tem,
7628                             fold_convert (type, TREE_OPERAND (arg0, 1)));
7629       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7630                && (tem = fold_unary (BIT_NOT_EXPR, type,
7631                                      fold_convert (type,
7632                                                    TREE_OPERAND (arg0, 1)))))
7633         return fold_build2 (BIT_XOR_EXPR, type,
7634                             fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
7635
7636       return NULL_TREE;
7637
7638     case TRUTH_NOT_EXPR:
7639       /* The argument to invert_truthvalue must have Boolean type.  */
7640       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7641           arg0 = fold_convert (boolean_type_node, arg0);
7642
7643       /* Note that the operand of this must be an int
7644          and its values must be 0 or 1.
7645          ("true" is a fixed value perhaps depending on the language,
7646          but we don't handle values other than 1 correctly yet.)  */
7647       tem = fold_truth_not_expr (arg0);
7648       if (!tem)
7649         return NULL_TREE;
7650       return fold_convert (type, tem);
7651
7652     case REALPART_EXPR:
7653       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7654         return fold_convert (type, arg0);
7655       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7656         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7657                                  TREE_OPERAND (arg0, 1));
7658       if (TREE_CODE (arg0) == COMPLEX_CST)
7659         return fold_convert (type, TREE_REALPART (arg0));
7660       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7661         {
7662           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7663           tem = fold_build2 (TREE_CODE (arg0), itype,
7664                              fold_build1 (REALPART_EXPR, itype,
7665                                           TREE_OPERAND (arg0, 0)),
7666                              fold_build1 (REALPART_EXPR, itype,
7667                                           TREE_OPERAND (arg0, 1)));
7668           return fold_convert (type, tem);
7669         }
7670       if (TREE_CODE (arg0) == CONJ_EXPR)
7671         {
7672           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7673           tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7674           return fold_convert (type, tem);
7675         }
7676       return NULL_TREE;
7677
7678     case IMAGPART_EXPR:
7679       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7680         return fold_convert (type, integer_zero_node);
7681       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7682         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7683                                  TREE_OPERAND (arg0, 0));
7684       if (TREE_CODE (arg0) == COMPLEX_CST)
7685         return fold_convert (type, TREE_IMAGPART (arg0));
7686       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7687         {
7688           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7689           tem = fold_build2 (TREE_CODE (arg0), itype,
7690                              fold_build1 (IMAGPART_EXPR, itype,
7691                                           TREE_OPERAND (arg0, 0)),
7692                              fold_build1 (IMAGPART_EXPR, itype,
7693                                           TREE_OPERAND (arg0, 1)));
7694           return fold_convert (type, tem);
7695         }
7696       if (TREE_CODE (arg0) == CONJ_EXPR)
7697         {
7698           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7699           tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7700           return fold_convert (type, negate_expr (tem));
7701         }
7702       return NULL_TREE;
7703
7704     default:
7705       return NULL_TREE;
7706     } /* switch (code) */
7707 }
7708
7709 /* Fold a binary expression of code CODE and type TYPE with operands
7710    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
7711    Return the folded expression if folding is successful.  Otherwise,
7712    return NULL_TREE.  */
7713
7714 static tree
7715 fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
7716 {
7717   enum tree_code compl_code;
7718
7719   if (code == MIN_EXPR)
7720     compl_code = MAX_EXPR;
7721   else if (code == MAX_EXPR)
7722     compl_code = MIN_EXPR;
7723   else
7724     gcc_unreachable ();
7725
7726   /* MIN (MAX (a, b), b) == b.  */
7727   if (TREE_CODE (op0) == compl_code
7728       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
7729     return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
7730
7731   /* MIN (MAX (b, a), b) == b.  */
7732   if (TREE_CODE (op0) == compl_code
7733       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
7734       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
7735     return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
7736
7737   /* MIN (a, MAX (a, b)) == a.  */
7738   if (TREE_CODE (op1) == compl_code
7739       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
7740       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
7741     return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
7742
7743   /* MIN (a, MAX (b, a)) == a.  */
7744   if (TREE_CODE (op1) == compl_code
7745       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
7746       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
7747     return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
7748
7749   return NULL_TREE;
7750 }
7751
7752 /* Subroutine of fold_binary.  This routine performs all of the
7753    transformations that are common to the equality/inequality
7754    operators (EQ_EXPR and NE_EXPR) and the ordering operators
7755    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
7756    fold_binary should call fold_binary.  Fold a comparison with
7757    tree code CODE and type TYPE with operands OP0 and OP1.  Return
7758    the folded comparison or NULL_TREE.  */
7759
7760 static tree
7761 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
7762 {
7763   tree arg0, arg1, tem;
7764
7765   arg0 = op0;
7766   arg1 = op1;
7767
7768   STRIP_SIGN_NOPS (arg0);
7769   STRIP_SIGN_NOPS (arg1);
7770
7771   tem = fold_relational_const (code, type, arg0, arg1);
7772   if (tem != NULL_TREE)
7773     return tem;
7774
7775   /* If one arg is a real or integer constant, put it last.  */
7776   if (tree_swap_operands_p (arg0, arg1, true))
7777     return fold_build2 (swap_tree_comparison (code), type, op1, op0);
7778
7779   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
7780   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7781       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7782           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
7783           && !TYPE_UNSIGNED (TREE_TYPE (arg1))
7784           && !(flag_wrapv || flag_trapv))
7785       && (TREE_CODE (arg1) == INTEGER_CST
7786           && !TREE_OVERFLOW (arg1)))
7787     {
7788       tree const1 = TREE_OPERAND (arg0, 1);
7789       tree const2 = arg1;
7790       tree variable = TREE_OPERAND (arg0, 0);
7791       tree lhs;
7792       int lhs_add;
7793       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
7794
7795       lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
7796                          TREE_TYPE (arg1), const2, const1);
7797       if (TREE_CODE (lhs) == TREE_CODE (arg1)
7798           && (TREE_CODE (lhs) != INTEGER_CST
7799               || !TREE_OVERFLOW (lhs)))
7800         return fold_build2 (code, type, variable, lhs);
7801     }
7802
7803   /* If this is a comparison of two exprs that look like an ARRAY_REF of the
7804      same object, then we can fold this to a comparison of the two offsets in
7805      signed size type.  This is possible because pointer arithmetic is
7806      restricted to retain within an object and overflow on pointer differences
7807      is undefined as of 6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
7808   if (POINTER_TYPE_P (TREE_TYPE (arg0))
7809       && !flag_wrapv && !flag_trapv)
7810     {
7811       tree base0, offset0, base1, offset1;
7812
7813       if (extract_array_ref (arg0, &base0, &offset0)
7814           && extract_array_ref (arg1, &base1, &offset1)
7815           && operand_equal_p (base0, base1, 0))
7816         {
7817           tree signed_size_type_node;
7818           signed_size_type_node = signed_type_for (size_type_node);
7819
7820           /* By converting to signed size type we cover middle-end pointer
7821              arithmetic which operates on unsigned pointer types of size
7822              type size and ARRAY_REF offsets which are properly sign or
7823              zero extended from their type in case it is narrower than
7824              size type.  */
7825           if (offset0 == NULL_TREE)
7826             offset0 = build_int_cst (signed_size_type_node, 0);
7827           else
7828             offset0 = fold_convert (signed_size_type_node, offset0);
7829           if (offset1 == NULL_TREE)
7830             offset1 = build_int_cst (signed_size_type_node, 0);
7831           else
7832             offset1 = fold_convert (signed_size_type_node, offset1);
7833
7834           return fold_build2 (code, type, offset0, offset1);
7835         }
7836     }
7837
7838   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
7839     {
7840       tree targ0 = strip_float_extensions (arg0);
7841       tree targ1 = strip_float_extensions (arg1);
7842       tree newtype = TREE_TYPE (targ0);
7843
7844       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
7845         newtype = TREE_TYPE (targ1);
7846
7847       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
7848       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
7849         return fold_build2 (code, type, fold_convert (newtype, targ0),
7850                             fold_convert (newtype, targ1));
7851
7852       /* (-a) CMP (-b) -> b CMP a  */
7853       if (TREE_CODE (arg0) == NEGATE_EXPR
7854           && TREE_CODE (arg1) == NEGATE_EXPR)
7855         return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
7856                             TREE_OPERAND (arg0, 0));
7857
7858       if (TREE_CODE (arg1) == REAL_CST)
7859         {
7860           REAL_VALUE_TYPE cst;
7861           cst = TREE_REAL_CST (arg1);
7862
7863           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
7864           if (TREE_CODE (arg0) == NEGATE_EXPR)
7865             return fold_build2 (swap_tree_comparison (code), type,
7866                                 TREE_OPERAND (arg0, 0),
7867                                 build_real (TREE_TYPE (arg1),
7868                                             REAL_VALUE_NEGATE (cst)));
7869
7870           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
7871           /* a CMP (-0) -> a CMP 0  */
7872           if (REAL_VALUE_MINUS_ZERO (cst))
7873             return fold_build2 (code, type, arg0,
7874                                 build_real (TREE_TYPE (arg1), dconst0));
7875
7876           /* x != NaN is always true, other ops are always false.  */
7877           if (REAL_VALUE_ISNAN (cst)
7878               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
7879             {
7880               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
7881               return omit_one_operand (type, tem, arg0);
7882             }
7883
7884           /* Fold comparisons against infinity.  */
7885           if (REAL_VALUE_ISINF (cst))
7886             {
7887               tem = fold_inf_compare (code, type, arg0, arg1);
7888               if (tem != NULL_TREE)
7889                 return tem;
7890             }
7891         }
7892
7893       /* If this is a comparison of a real constant with a PLUS_EXPR
7894          or a MINUS_EXPR of a real constant, we can convert it into a
7895          comparison with a revised real constant as long as no overflow
7896          occurs when unsafe_math_optimizations are enabled.  */
7897       if (flag_unsafe_math_optimizations
7898           && TREE_CODE (arg1) == REAL_CST
7899           && (TREE_CODE (arg0) == PLUS_EXPR
7900               || TREE_CODE (arg0) == MINUS_EXPR)
7901           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7902           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
7903                                       ? MINUS_EXPR : PLUS_EXPR,
7904                                       arg1, TREE_OPERAND (arg0, 1), 0))
7905           && ! TREE_CONSTANT_OVERFLOW (tem))
7906         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
7907
7908       /* Likewise, we can simplify a comparison of a real constant with
7909          a MINUS_EXPR whose first operand is also a real constant, i.e.
7910          (c1 - x) < c2 becomes x > c1-c2.  */
7911       if (flag_unsafe_math_optimizations
7912           && TREE_CODE (arg1) == REAL_CST
7913           && TREE_CODE (arg0) == MINUS_EXPR
7914           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
7915           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
7916                                       arg1, 0))
7917           && ! TREE_CONSTANT_OVERFLOW (tem))
7918         return fold_build2 (swap_tree_comparison (code), type,
7919                             TREE_OPERAND (arg0, 1), tem);
7920
7921       /* Fold comparisons against built-in math functions.  */
7922       if (TREE_CODE (arg1) == REAL_CST
7923           && flag_unsafe_math_optimizations
7924           && ! flag_errno_math)
7925         {
7926           enum built_in_function fcode = builtin_mathfn_code (arg0);
7927
7928           if (fcode != END_BUILTINS)
7929             {
7930               tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
7931               if (tem != NULL_TREE)
7932                 return tem;
7933             }
7934         }
7935     }
7936
7937   /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
7938   if (TREE_CONSTANT (arg1)
7939       && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
7940           || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
7941       /* This optimization is invalid for ordered comparisons
7942          if CONST+INCR overflows or if foo+incr might overflow.
7943          This optimization is invalid for floating point due to rounding.
7944          For pointer types we assume overflow doesn't happen.  */
7945       && (POINTER_TYPE_P (TREE_TYPE (arg0))
7946           || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
7947               && (code == EQ_EXPR || code == NE_EXPR))))
7948     {
7949       tree varop, newconst;
7950
7951       if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
7952         {
7953           newconst = fold_build2 (PLUS_EXPR, TREE_TYPE (arg0),
7954                                   arg1, TREE_OPERAND (arg0, 1));
7955           varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
7956                           TREE_OPERAND (arg0, 0),
7957                           TREE_OPERAND (arg0, 1));
7958         }
7959       else
7960         {
7961           newconst = fold_build2 (MINUS_EXPR, TREE_TYPE (arg0),
7962                                   arg1, TREE_OPERAND (arg0, 1));
7963           varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
7964                           TREE_OPERAND (arg0, 0),
7965                           TREE_OPERAND (arg0, 1));
7966         }
7967
7968
7969       /* If VAROP is a reference to a bitfield, we must mask
7970          the constant by the width of the field.  */
7971       if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
7972           && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
7973           && host_integerp (DECL_SIZE (TREE_OPERAND
7974                                          (TREE_OPERAND (varop, 0), 1)), 1))
7975         {
7976           tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
7977           HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
7978           tree folded_compare, shift;
7979
7980           /* First check whether the comparison would come out
7981              always the same.  If we don't do that we would
7982              change the meaning with the masking.  */
7983           folded_compare = fold_build2 (code, type,
7984                                         TREE_OPERAND (varop, 0), arg1);
7985           if (TREE_CODE (folded_compare) == INTEGER_CST)
7986             return omit_one_operand (type, folded_compare, varop);
7987
7988           shift = build_int_cst (NULL_TREE,
7989                                  TYPE_PRECISION (TREE_TYPE (varop)) - size);
7990           shift = fold_convert (TREE_TYPE (varop), shift);
7991           newconst = fold_build2 (LSHIFT_EXPR, TREE_TYPE (varop),
7992                                   newconst, shift);
7993           newconst = fold_build2 (RSHIFT_EXPR, TREE_TYPE (varop),
7994                                   newconst, shift);
7995         }
7996
7997       return fold_build2 (code, type, varop, newconst);
7998     }
7999
8000   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8001       && (TREE_CODE (arg0) == NOP_EXPR
8002           || TREE_CODE (arg0) == CONVERT_EXPR))
8003     {
8004       /* If we are widening one operand of an integer comparison,
8005          see if the other operand is similarly being widened.  Perhaps we
8006          can do the comparison in the narrower type.  */
8007       tem = fold_widened_comparison (code, type, arg0, arg1);
8008       if (tem)
8009         return tem;
8010
8011       /* Or if we are changing signedness.  */
8012       tem = fold_sign_changed_comparison (code, type, arg0, arg1);
8013       if (tem)
8014         return tem;
8015     }
8016
8017   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8018      constant, we can simplify it.  */
8019   if (TREE_CODE (arg1) == INTEGER_CST
8020       && (TREE_CODE (arg0) == MIN_EXPR
8021           || TREE_CODE (arg0) == MAX_EXPR)
8022       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8023     {
8024       tem = optimize_minmax_comparison (code, type, op0, op1);
8025       if (tem)
8026         return tem;
8027     }
8028
8029   /* Simplify comparison of something with itself.  (For IEEE
8030      floating-point, we can only do some of these simplifications.)  */
8031   if (operand_equal_p (arg0, arg1, 0))
8032     {
8033       switch (code)
8034         {
8035         case EQ_EXPR:
8036           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8037               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8038             return constant_boolean_node (1, type);
8039           break;
8040
8041         case GE_EXPR:
8042         case LE_EXPR:
8043           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8044               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8045             return constant_boolean_node (1, type);
8046           return fold_build2 (EQ_EXPR, type, arg0, arg1);
8047
8048         case NE_EXPR:
8049           /* For NE, we can only do this simplification if integer
8050              or we don't honor IEEE floating point NaNs.  */
8051           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8052               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8053             break;
8054           /* ... fall through ...  */
8055         case GT_EXPR:
8056         case LT_EXPR:
8057           return constant_boolean_node (0, type);
8058         default:
8059           gcc_unreachable ();
8060         }
8061     }
8062
8063   /* If we are comparing an expression that just has comparisons
8064      of two integer values, arithmetic expressions of those comparisons,
8065      and constants, we can simplify it.  There are only three cases
8066      to check: the two values can either be equal, the first can be
8067      greater, or the second can be greater.  Fold the expression for
8068      those three values.  Since each value must be 0 or 1, we have
8069      eight possibilities, each of which corresponds to the constant 0
8070      or 1 or one of the six possible comparisons.
8071
8072      This handles common cases like (a > b) == 0 but also handles
8073      expressions like  ((x > y) - (y > x)) > 0, which supposedly
8074      occur in macroized code.  */
8075
8076   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8077     {
8078       tree cval1 = 0, cval2 = 0;
8079       int save_p = 0;
8080
8081       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8082           /* Don't handle degenerate cases here; they should already
8083              have been handled anyway.  */
8084           && cval1 != 0 && cval2 != 0
8085           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8086           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8087           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8088           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8089           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8090           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8091                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8092         {
8093           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8094           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8095
8096           /* We can't just pass T to eval_subst in case cval1 or cval2
8097              was the same as ARG1.  */
8098
8099           tree high_result
8100                 = fold_build2 (code, type,
8101                                eval_subst (arg0, cval1, maxval,
8102                                            cval2, minval),
8103                                arg1);
8104           tree equal_result
8105                 = fold_build2 (code, type,
8106                                eval_subst (arg0, cval1, maxval,
8107                                            cval2, maxval),
8108                                arg1);
8109           tree low_result
8110                 = fold_build2 (code, type,
8111                                eval_subst (arg0, cval1, minval,
8112                                            cval2, maxval),
8113                                arg1);
8114
8115           /* All three of these results should be 0 or 1.  Confirm they are.
8116              Then use those values to select the proper code to use.  */
8117
8118           if (TREE_CODE (high_result) == INTEGER_CST
8119               && TREE_CODE (equal_result) == INTEGER_CST
8120               && TREE_CODE (low_result) == INTEGER_CST)
8121             {
8122               /* Make a 3-bit mask with the high-order bit being the
8123                  value for `>', the next for '=', and the low for '<'.  */
8124               switch ((integer_onep (high_result) * 4)
8125                       + (integer_onep (equal_result) * 2)
8126                       + integer_onep (low_result))
8127                 {
8128                 case 0:
8129                   /* Always false.  */
8130                   return omit_one_operand (type, integer_zero_node, arg0);
8131                 case 1:
8132                   code = LT_EXPR;
8133                   break;
8134                 case 2:
8135                   code = EQ_EXPR;
8136                   break;
8137                 case 3:
8138                   code = LE_EXPR;
8139                   break;
8140                 case 4:
8141                   code = GT_EXPR;
8142                   break;
8143                 case 5:
8144                   code = NE_EXPR;
8145                   break;
8146                 case 6:
8147                   code = GE_EXPR;
8148                   break;
8149                 case 7:
8150                   /* Always true.  */
8151                   return omit_one_operand (type, integer_one_node, arg0);
8152                 }
8153
8154               if (save_p)
8155                 return save_expr (build2 (code, type, cval1, cval2));
8156               return fold_build2 (code, type, cval1, cval2);
8157             }
8158         }
8159     }
8160
8161   /* Fold a comparison of the address of COMPONENT_REFs with the same
8162      type and component to a comparison of the address of the base
8163      object.  In short, &x->a OP &y->a to x OP y and
8164      &x->a OP &y.a to x OP &y  */
8165   if (TREE_CODE (arg0) == ADDR_EXPR
8166       && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
8167       && TREE_CODE (arg1) == ADDR_EXPR
8168       && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
8169     {
8170       tree cref0 = TREE_OPERAND (arg0, 0);
8171       tree cref1 = TREE_OPERAND (arg1, 0);
8172       if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
8173         {
8174           tree op0 = TREE_OPERAND (cref0, 0);
8175           tree op1 = TREE_OPERAND (cref1, 0);
8176           return fold_build2 (code, type,
8177                               build_fold_addr_expr (op0),
8178                               build_fold_addr_expr (op1));
8179         }
8180     }
8181
8182   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8183      into a single range test.  */
8184   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
8185        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
8186       && TREE_CODE (arg1) == INTEGER_CST
8187       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8188       && !integer_zerop (TREE_OPERAND (arg0, 1))
8189       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8190       && !TREE_OVERFLOW (arg1))
8191     {
8192       tem = fold_div_compare (code, type, arg0, arg1);
8193       if (tem != NULL_TREE)
8194         return tem;
8195     }
8196
8197   return NULL_TREE;
8198 }
8199
8200
8201 /* Subroutine of fold_binary.  Optimize complex multiplications of the
8202    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
8203    argument EXPR represents the expression "z" of type TYPE.  */
8204
8205 static tree
8206 fold_mult_zconjz (tree type, tree expr)
8207 {
8208   tree itype = TREE_TYPE (type);
8209   tree rpart, ipart, tem;
8210
8211   if (TREE_CODE (expr) == COMPLEX_EXPR)
8212     {
8213       rpart = TREE_OPERAND (expr, 0);
8214       ipart = TREE_OPERAND (expr, 1);
8215     }
8216   else if (TREE_CODE (expr) == COMPLEX_CST)
8217     {
8218       rpart = TREE_REALPART (expr);
8219       ipart = TREE_IMAGPART (expr);
8220     }
8221   else
8222     {
8223       expr = save_expr (expr);
8224       rpart = fold_build1 (REALPART_EXPR, itype, expr);
8225       ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
8226     }
8227
8228   rpart = save_expr (rpart);
8229   ipart = save_expr (ipart);
8230   tem = fold_build2 (PLUS_EXPR, itype,
8231                      fold_build2 (MULT_EXPR, itype, rpart, rpart),
8232                      fold_build2 (MULT_EXPR, itype, ipart, ipart));
8233   return fold_build2 (COMPLEX_EXPR, type, tem,
8234                       fold_convert (itype, integer_zero_node));
8235 }
8236
8237
8238 /* Fold a binary expression of code CODE and type TYPE with operands
8239    OP0 and OP1.  Return the folded expression if folding is
8240    successful.  Otherwise, return NULL_TREE.  */
8241
8242 tree
8243 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
8244 {
8245   enum tree_code_class kind = TREE_CODE_CLASS (code);
8246   tree arg0, arg1, tem;
8247   tree t1 = NULL_TREE;
8248
8249   gcc_assert (IS_EXPR_CODE_CLASS (kind)
8250               && TREE_CODE_LENGTH (code) == 2
8251               && op0 != NULL_TREE
8252               && op1 != NULL_TREE);
8253
8254   arg0 = op0;
8255   arg1 = op1;
8256
8257   /* Strip any conversions that don't change the mode.  This is
8258      safe for every expression, except for a comparison expression
8259      because its signedness is derived from its operands.  So, in
8260      the latter case, only strip conversions that don't change the
8261      signedness.
8262
8263      Note that this is done as an internal manipulation within the
8264      constant folder, in order to find the simplest representation
8265      of the arguments so that their form can be studied.  In any
8266      cases, the appropriate type conversions should be put back in
8267      the tree that will get out of the constant folder.  */
8268
8269   if (kind == tcc_comparison)
8270     {
8271       STRIP_SIGN_NOPS (arg0);
8272       STRIP_SIGN_NOPS (arg1);
8273     }
8274   else
8275     {
8276       STRIP_NOPS (arg0);
8277       STRIP_NOPS (arg1);
8278     }
8279
8280   /* Note that TREE_CONSTANT isn't enough: static var addresses are
8281      constant but we can't do arithmetic on them.  */
8282   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
8283       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8284       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
8285       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
8286     {
8287       if (kind == tcc_binary)
8288         tem = const_binop (code, arg0, arg1, 0);
8289       else if (kind == tcc_comparison)
8290         tem = fold_relational_const (code, type, arg0, arg1);
8291       else
8292         tem = NULL_TREE;
8293
8294       if (tem != NULL_TREE)
8295         {
8296           if (TREE_TYPE (tem) != type)
8297             tem = fold_convert (type, tem);
8298           return tem;
8299         }
8300     }
8301
8302   /* If this is a commutative operation, and ARG0 is a constant, move it
8303      to ARG1 to reduce the number of tests below.  */
8304   if (commutative_tree_code (code)
8305       && tree_swap_operands_p (arg0, arg1, true))
8306     return fold_build2 (code, type, op1, op0);
8307
8308   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
8309
8310      First check for cases where an arithmetic operation is applied to a
8311      compound, conditional, or comparison operation.  Push the arithmetic
8312      operation inside the compound or conditional to see if any folding
8313      can then be done.  Convert comparison to conditional for this purpose.
8314      The also optimizes non-constant cases that used to be done in
8315      expand_expr.
8316
8317      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
8318      one of the operands is a comparison and the other is a comparison, a
8319      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
8320      code below would make the expression more complex.  Change it to a
8321      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
8322      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
8323
8324   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
8325        || code == EQ_EXPR || code == NE_EXPR)
8326       && ((truth_value_p (TREE_CODE (arg0))
8327            && (truth_value_p (TREE_CODE (arg1))
8328                || (TREE_CODE (arg1) == BIT_AND_EXPR
8329                    && integer_onep (TREE_OPERAND (arg1, 1)))))
8330           || (truth_value_p (TREE_CODE (arg1))
8331               && (truth_value_p (TREE_CODE (arg0))
8332                   || (TREE_CODE (arg0) == BIT_AND_EXPR
8333                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
8334     {
8335       tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
8336                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
8337                          : TRUTH_XOR_EXPR,
8338                          boolean_type_node,
8339                          fold_convert (boolean_type_node, arg0),
8340                          fold_convert (boolean_type_node, arg1));
8341
8342       if (code == EQ_EXPR)
8343         tem = invert_truthvalue (tem);
8344
8345       return fold_convert (type, tem);
8346     }
8347
8348   if (TREE_CODE_CLASS (code) == tcc_binary
8349       || TREE_CODE_CLASS (code) == tcc_comparison)
8350     {
8351       if (TREE_CODE (arg0) == COMPOUND_EXPR)
8352         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
8353                        fold_build2 (code, type,
8354                                     TREE_OPERAND (arg0, 1), op1));
8355       if (TREE_CODE (arg1) == COMPOUND_EXPR
8356           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
8357         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
8358                        fold_build2 (code, type,
8359                                     op0, TREE_OPERAND (arg1, 1)));
8360
8361       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
8362         {
8363           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8364                                                      arg0, arg1,
8365                                                      /*cond_first_p=*/1);
8366           if (tem != NULL_TREE)
8367             return tem;
8368         }
8369
8370       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
8371         {
8372           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8373                                                      arg1, arg0,
8374                                                      /*cond_first_p=*/0);
8375           if (tem != NULL_TREE)
8376             return tem;
8377         }
8378     }
8379
8380   switch (code)
8381     {
8382     case PLUS_EXPR:
8383       /* A + (-B) -> A - B */
8384       if (TREE_CODE (arg1) == NEGATE_EXPR)
8385         return fold_build2 (MINUS_EXPR, type,
8386                             fold_convert (type, arg0),
8387                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8388       /* (-A) + B -> B - A */
8389       if (TREE_CODE (arg0) == NEGATE_EXPR
8390           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
8391         return fold_build2 (MINUS_EXPR, type,
8392                             fold_convert (type, arg1),
8393                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8394       /* Convert ~A + 1 to -A.  */
8395       if (INTEGRAL_TYPE_P (type)
8396           && TREE_CODE (arg0) == BIT_NOT_EXPR
8397           && integer_onep (arg1))
8398         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
8399
8400       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
8401          same or one.  */
8402       if ((TREE_CODE (arg0) == MULT_EXPR
8403            || TREE_CODE (arg1) == MULT_EXPR)
8404           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
8405         {
8406           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
8407           if (tem)
8408             return tem;
8409         }
8410
8411       if (! FLOAT_TYPE_P (type))
8412         {
8413           if (integer_zerop (arg1))
8414             return non_lvalue (fold_convert (type, arg0));
8415
8416           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
8417              with a constant, and the two constants have no bits in common,
8418              we should treat this as a BIT_IOR_EXPR since this may produce more
8419              simplifications.  */
8420           if (TREE_CODE (arg0) == BIT_AND_EXPR
8421               && TREE_CODE (arg1) == BIT_AND_EXPR
8422               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8423               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8424               && integer_zerop (const_binop (BIT_AND_EXPR,
8425                                              TREE_OPERAND (arg0, 1),
8426                                              TREE_OPERAND (arg1, 1), 0)))
8427             {
8428               code = BIT_IOR_EXPR;
8429               goto bit_ior;
8430             }
8431
8432           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
8433              (plus (plus (mult) (mult)) (foo)) so that we can
8434              take advantage of the factoring cases below.  */
8435           if (((TREE_CODE (arg0) == PLUS_EXPR
8436                 || TREE_CODE (arg0) == MINUS_EXPR)
8437                && TREE_CODE (arg1) == MULT_EXPR)
8438               || ((TREE_CODE (arg1) == PLUS_EXPR
8439                    || TREE_CODE (arg1) == MINUS_EXPR)
8440                   && TREE_CODE (arg0) == MULT_EXPR))
8441             {
8442               tree parg0, parg1, parg, marg;
8443               enum tree_code pcode;
8444
8445               if (TREE_CODE (arg1) == MULT_EXPR)
8446                 parg = arg0, marg = arg1;
8447               else
8448                 parg = arg1, marg = arg0;
8449               pcode = TREE_CODE (parg);
8450               parg0 = TREE_OPERAND (parg, 0);
8451               parg1 = TREE_OPERAND (parg, 1);
8452               STRIP_NOPS (parg0);
8453               STRIP_NOPS (parg1);
8454
8455               if (TREE_CODE (parg0) == MULT_EXPR
8456                   && TREE_CODE (parg1) != MULT_EXPR)
8457                 return fold_build2 (pcode, type,
8458                                     fold_build2 (PLUS_EXPR, type,
8459                                                  fold_convert (type, parg0),
8460                                                  fold_convert (type, marg)),
8461                                     fold_convert (type, parg1));
8462               if (TREE_CODE (parg0) != MULT_EXPR
8463                   && TREE_CODE (parg1) == MULT_EXPR)
8464                 return fold_build2 (PLUS_EXPR, type,
8465                                     fold_convert (type, parg0),
8466                                     fold_build2 (pcode, type,
8467                                                  fold_convert (type, marg),
8468                                                  fold_convert (type,
8469                                                                parg1)));
8470             }
8471
8472           /* Try replacing &a[i1] + c * i2 with &a[i1 + i2], if c is step
8473              of the array.  Loop optimizer sometimes produce this type of
8474              expressions.  */
8475           if (TREE_CODE (arg0) == ADDR_EXPR)
8476             {
8477               tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
8478               if (tem)
8479                 return fold_convert (type, tem);
8480             }
8481           else if (TREE_CODE (arg1) == ADDR_EXPR)
8482             {
8483               tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
8484               if (tem)
8485                 return fold_convert (type, tem);
8486             }
8487         }
8488       else
8489         {
8490           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
8491           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
8492             return non_lvalue (fold_convert (type, arg0));
8493
8494           /* Likewise if the operands are reversed.  */
8495           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
8496             return non_lvalue (fold_convert (type, arg1));
8497
8498           /* Convert X + -C into X - C.  */
8499           if (TREE_CODE (arg1) == REAL_CST
8500               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
8501             {
8502               tem = fold_negate_const (arg1, type);
8503               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
8504                 return fold_build2 (MINUS_EXPR, type,
8505                                     fold_convert (type, arg0),
8506                                     fold_convert (type, tem));
8507             }
8508
8509           if (flag_unsafe_math_optimizations
8510               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
8511               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
8512               && (tem = distribute_real_division (code, type, arg0, arg1)))
8513             return tem;
8514
8515           /* Convert x+x into x*2.0.  */
8516           if (operand_equal_p (arg0, arg1, 0)
8517               && SCALAR_FLOAT_TYPE_P (type))
8518             return fold_build2 (MULT_EXPR, type, arg0,
8519                                 build_real (type, dconst2));
8520
8521           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  */
8522           if (flag_unsafe_math_optimizations
8523               && TREE_CODE (arg1) == PLUS_EXPR
8524               && TREE_CODE (arg0) != MULT_EXPR)
8525             {
8526               tree tree10 = TREE_OPERAND (arg1, 0);
8527               tree tree11 = TREE_OPERAND (arg1, 1);
8528               if (TREE_CODE (tree11) == MULT_EXPR
8529                   && TREE_CODE (tree10) == MULT_EXPR)
8530                 {
8531                   tree tree0;
8532                   tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
8533                   return fold_build2 (PLUS_EXPR, type, tree0, tree11);
8534                 }
8535             }
8536           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  */
8537           if (flag_unsafe_math_optimizations
8538               && TREE_CODE (arg0) == PLUS_EXPR
8539               && TREE_CODE (arg1) != MULT_EXPR)
8540             {
8541               tree tree00 = TREE_OPERAND (arg0, 0);
8542               tree tree01 = TREE_OPERAND (arg0, 1);
8543               if (TREE_CODE (tree01) == MULT_EXPR
8544                   && TREE_CODE (tree00) == MULT_EXPR)
8545                 {
8546                   tree tree0;
8547                   tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
8548                   return fold_build2 (PLUS_EXPR, type, tree00, tree0);
8549                 }
8550             }
8551         }
8552
8553      bit_rotate:
8554       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
8555          is a rotate of A by C1 bits.  */
8556       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
8557          is a rotate of A by B bits.  */
8558       {
8559         enum tree_code code0, code1;
8560         code0 = TREE_CODE (arg0);
8561         code1 = TREE_CODE (arg1);
8562         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
8563              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
8564             && operand_equal_p (TREE_OPERAND (arg0, 0),
8565                                 TREE_OPERAND (arg1, 0), 0)
8566             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
8567           {
8568             tree tree01, tree11;
8569             enum tree_code code01, code11;
8570
8571             tree01 = TREE_OPERAND (arg0, 1);
8572             tree11 = TREE_OPERAND (arg1, 1);
8573             STRIP_NOPS (tree01);
8574             STRIP_NOPS (tree11);
8575             code01 = TREE_CODE (tree01);
8576             code11 = TREE_CODE (tree11);
8577             if (code01 == INTEGER_CST
8578                 && code11 == INTEGER_CST
8579                 && TREE_INT_CST_HIGH (tree01) == 0
8580                 && TREE_INT_CST_HIGH (tree11) == 0
8581                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
8582                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
8583               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
8584                              code0 == LSHIFT_EXPR ? tree01 : tree11);
8585             else if (code11 == MINUS_EXPR)
8586               {
8587                 tree tree110, tree111;
8588                 tree110 = TREE_OPERAND (tree11, 0);
8589                 tree111 = TREE_OPERAND (tree11, 1);
8590                 STRIP_NOPS (tree110);
8591                 STRIP_NOPS (tree111);
8592                 if (TREE_CODE (tree110) == INTEGER_CST
8593                     && 0 == compare_tree_int (tree110,
8594                                               TYPE_PRECISION
8595                                               (TREE_TYPE (TREE_OPERAND
8596                                                           (arg0, 0))))
8597                     && operand_equal_p (tree01, tree111, 0))
8598                   return build2 ((code0 == LSHIFT_EXPR
8599                                   ? LROTATE_EXPR
8600                                   : RROTATE_EXPR),
8601                                  type, TREE_OPERAND (arg0, 0), tree01);
8602               }
8603             else if (code01 == MINUS_EXPR)
8604               {
8605                 tree tree010, tree011;
8606                 tree010 = TREE_OPERAND (tree01, 0);
8607                 tree011 = TREE_OPERAND (tree01, 1);
8608                 STRIP_NOPS (tree010);
8609                 STRIP_NOPS (tree011);
8610                 if (TREE_CODE (tree010) == INTEGER_CST
8611                     && 0 == compare_tree_int (tree010,
8612                                               TYPE_PRECISION
8613                                               (TREE_TYPE (TREE_OPERAND
8614                                                           (arg0, 0))))
8615                     && operand_equal_p (tree11, tree011, 0))
8616                   return build2 ((code0 != LSHIFT_EXPR
8617                                   ? LROTATE_EXPR
8618                                   : RROTATE_EXPR),
8619                                  type, TREE_OPERAND (arg0, 0), tree11);
8620               }
8621           }
8622       }
8623
8624     associate:
8625       /* In most languages, can't associate operations on floats through
8626          parentheses.  Rather than remember where the parentheses were, we
8627          don't associate floats at all, unless the user has specified
8628          -funsafe-math-optimizations.  */
8629
8630       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
8631         {
8632           tree var0, con0, lit0, minus_lit0;
8633           tree var1, con1, lit1, minus_lit1;
8634
8635           /* Split both trees into variables, constants, and literals.  Then
8636              associate each group together, the constants with literals,
8637              then the result with variables.  This increases the chances of
8638              literals being recombined later and of generating relocatable
8639              expressions for the sum of a constant and literal.  */
8640           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
8641           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
8642                              code == MINUS_EXPR);
8643
8644           /* Only do something if we found more than two objects.  Otherwise,
8645              nothing has changed and we risk infinite recursion.  */
8646           if (2 < ((var0 != 0) + (var1 != 0)
8647                    + (con0 != 0) + (con1 != 0)
8648                    + (lit0 != 0) + (lit1 != 0)
8649                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
8650             {
8651               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
8652               if (code == MINUS_EXPR)
8653                 code = PLUS_EXPR;
8654
8655               var0 = associate_trees (var0, var1, code, type);
8656               con0 = associate_trees (con0, con1, code, type);
8657               lit0 = associate_trees (lit0, lit1, code, type);
8658               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
8659
8660               /* Preserve the MINUS_EXPR if the negative part of the literal is
8661                  greater than the positive part.  Otherwise, the multiplicative
8662                  folding code (i.e extract_muldiv) may be fooled in case
8663                  unsigned constants are subtracted, like in the following
8664                  example: ((X*2 + 4) - 8U)/2.  */
8665               if (minus_lit0 && lit0)
8666                 {
8667                   if (TREE_CODE (lit0) == INTEGER_CST
8668                       && TREE_CODE (minus_lit0) == INTEGER_CST
8669                       && tree_int_cst_lt (lit0, minus_lit0))
8670                     {
8671                       minus_lit0 = associate_trees (minus_lit0, lit0,
8672                                                     MINUS_EXPR, type);
8673                       lit0 = 0;
8674                     }
8675                   else
8676                     {
8677                       lit0 = associate_trees (lit0, minus_lit0,
8678                                               MINUS_EXPR, type);
8679                       minus_lit0 = 0;
8680                     }
8681                 }
8682               if (minus_lit0)
8683                 {
8684                   if (con0 == 0)
8685                     return fold_convert (type,
8686                                          associate_trees (var0, minus_lit0,
8687                                                           MINUS_EXPR, type));
8688                   else
8689                     {
8690                       con0 = associate_trees (con0, minus_lit0,
8691                                               MINUS_EXPR, type);
8692                       return fold_convert (type,
8693                                            associate_trees (var0, con0,
8694                                                             PLUS_EXPR, type));
8695                     }
8696                 }
8697
8698               con0 = associate_trees (con0, lit0, code, type);
8699               return fold_convert (type, associate_trees (var0, con0,
8700                                                           code, type));
8701             }
8702         }
8703
8704       return NULL_TREE;
8705
8706     case MINUS_EXPR:
8707       /* A - (-B) -> A + B */
8708       if (TREE_CODE (arg1) == NEGATE_EXPR)
8709         return fold_build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0));
8710       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
8711       if (TREE_CODE (arg0) == NEGATE_EXPR
8712           && (FLOAT_TYPE_P (type)
8713               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
8714           && negate_expr_p (arg1)
8715           && reorder_operands_p (arg0, arg1))
8716         return fold_build2 (MINUS_EXPR, type, negate_expr (arg1),
8717                             TREE_OPERAND (arg0, 0));
8718       /* Convert -A - 1 to ~A.  */
8719       if (INTEGRAL_TYPE_P (type)
8720           && TREE_CODE (arg0) == NEGATE_EXPR
8721           && integer_onep (arg1))
8722         return fold_build1 (BIT_NOT_EXPR, type,
8723                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8724
8725       /* Convert -1 - A to ~A.  */
8726       if (INTEGRAL_TYPE_P (type)
8727           && integer_all_onesp (arg0))
8728         return fold_build1 (BIT_NOT_EXPR, type, arg1);
8729
8730       if (! FLOAT_TYPE_P (type))
8731         {
8732           if (integer_zerop (arg0))
8733             return negate_expr (fold_convert (type, arg1));
8734           if (integer_zerop (arg1))
8735             return non_lvalue (fold_convert (type, arg0));
8736
8737           /* Fold A - (A & B) into ~B & A.  */
8738           if (!TREE_SIDE_EFFECTS (arg0)
8739               && TREE_CODE (arg1) == BIT_AND_EXPR)
8740             {
8741               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
8742                 return fold_build2 (BIT_AND_EXPR, type,
8743                                     fold_build1 (BIT_NOT_EXPR, type,
8744                                                  TREE_OPERAND (arg1, 0)),
8745                                     arg0);
8746               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8747                 return fold_build2 (BIT_AND_EXPR, type,
8748                                     fold_build1 (BIT_NOT_EXPR, type,
8749                                                  TREE_OPERAND (arg1, 1)),
8750                                     arg0);
8751             }
8752
8753           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
8754              any power of 2 minus 1.  */
8755           if (TREE_CODE (arg0) == BIT_AND_EXPR
8756               && TREE_CODE (arg1) == BIT_AND_EXPR
8757               && operand_equal_p (TREE_OPERAND (arg0, 0),
8758                                   TREE_OPERAND (arg1, 0), 0))
8759             {
8760               tree mask0 = TREE_OPERAND (arg0, 1);
8761               tree mask1 = TREE_OPERAND (arg1, 1);
8762               tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
8763
8764               if (operand_equal_p (tem, mask1, 0))
8765                 {
8766                   tem = fold_build2 (BIT_XOR_EXPR, type,
8767                                      TREE_OPERAND (arg0, 0), mask1);
8768                   return fold_build2 (MINUS_EXPR, type, tem, mask1);
8769                 }
8770             }
8771         }
8772
8773       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
8774       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
8775         return non_lvalue (fold_convert (type, arg0));
8776
8777       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
8778          ARG0 is zero and X + ARG0 reduces to X, since that would mean
8779          (-ARG1 + ARG0) reduces to -ARG1.  */
8780       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
8781         return negate_expr (fold_convert (type, arg1));
8782
8783       /* Fold &x - &x.  This can happen from &x.foo - &x.
8784          This is unsafe for certain floats even in non-IEEE formats.
8785          In IEEE, it is unsafe because it does wrong for NaNs.
8786          Also note that operand_equal_p is always false if an operand
8787          is volatile.  */
8788
8789       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
8790           && operand_equal_p (arg0, arg1, 0))
8791         return fold_convert (type, integer_zero_node);
8792
8793       /* A - B -> A + (-B) if B is easily negatable.  */
8794       if (negate_expr_p (arg1)
8795           && ((FLOAT_TYPE_P (type)
8796                /* Avoid this transformation if B is a positive REAL_CST.  */
8797                && (TREE_CODE (arg1) != REAL_CST
8798                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
8799               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
8800         return fold_build2 (PLUS_EXPR, type,
8801                             fold_convert (type, arg0),
8802                             fold_convert (type, negate_expr (arg1)));
8803
8804       /* Try folding difference of addresses.  */
8805       {
8806         HOST_WIDE_INT diff;
8807
8808         if ((TREE_CODE (arg0) == ADDR_EXPR
8809              || TREE_CODE (arg1) == ADDR_EXPR)
8810             && ptr_difference_const (arg0, arg1, &diff))
8811           return build_int_cst_type (type, diff);
8812       }
8813
8814       /* Fold &a[i] - &a[j] to i-j.  */
8815       if (TREE_CODE (arg0) == ADDR_EXPR
8816           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
8817           && TREE_CODE (arg1) == ADDR_EXPR
8818           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
8819         {
8820           tree aref0 = TREE_OPERAND (arg0, 0);
8821           tree aref1 = TREE_OPERAND (arg1, 0);
8822           if (operand_equal_p (TREE_OPERAND (aref0, 0),
8823                                TREE_OPERAND (aref1, 0), 0))
8824             {
8825               tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
8826               tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
8827               tree esz = array_ref_element_size (aref0);
8828               tree diff = build2 (MINUS_EXPR, type, op0, op1);
8829               return fold_build2 (MULT_EXPR, type, diff,
8830                                   fold_convert (type, esz));
8831
8832             }
8833         }
8834
8835       /* Try replacing &a[i1] - c * i2 with &a[i1 - i2], if c is step
8836          of the array.  Loop optimizer sometimes produce this type of
8837          expressions.  */
8838       if (TREE_CODE (arg0) == ADDR_EXPR)
8839         {
8840           tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
8841           if (tem)
8842             return fold_convert (type, tem);
8843         }
8844
8845       if (flag_unsafe_math_optimizations
8846           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
8847           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
8848           && (tem = distribute_real_division (code, type, arg0, arg1)))
8849         return tem;
8850
8851       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
8852          same or one.  */
8853       if ((TREE_CODE (arg0) == MULT_EXPR
8854            || TREE_CODE (arg1) == MULT_EXPR)
8855           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
8856         {
8857           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
8858           if (tem)
8859             return tem;
8860         }
8861
8862       goto associate;
8863
8864     case MULT_EXPR:
8865       /* (-A) * (-B) -> A * B  */
8866       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
8867         return fold_build2 (MULT_EXPR, type,
8868                             fold_convert (type, TREE_OPERAND (arg0, 0)),
8869                             fold_convert (type, negate_expr (arg1)));
8870       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
8871         return fold_build2 (MULT_EXPR, type,
8872                             fold_convert (type, negate_expr (arg0)),
8873                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8874
8875       if (! FLOAT_TYPE_P (type))
8876         {
8877           if (integer_zerop (arg1))
8878             return omit_one_operand (type, arg1, arg0);
8879           if (integer_onep (arg1))
8880             return non_lvalue (fold_convert (type, arg0));
8881           /* Transform x * -1 into -x.  */
8882           if (integer_all_onesp (arg1))
8883             return fold_convert (type, negate_expr (arg0));
8884
8885           /* (a * (1 << b)) is (a << b)  */
8886           if (TREE_CODE (arg1) == LSHIFT_EXPR
8887               && integer_onep (TREE_OPERAND (arg1, 0)))
8888             return fold_build2 (LSHIFT_EXPR, type, arg0,
8889                                 TREE_OPERAND (arg1, 1));
8890           if (TREE_CODE (arg0) == LSHIFT_EXPR
8891               && integer_onep (TREE_OPERAND (arg0, 0)))
8892             return fold_build2 (LSHIFT_EXPR, type, arg1,
8893                                 TREE_OPERAND (arg0, 1));
8894
8895           if (TREE_CODE (arg1) == INTEGER_CST
8896               && 0 != (tem = extract_muldiv (op0,
8897                                              fold_convert (type, arg1),
8898                                              code, NULL_TREE)))
8899             return fold_convert (type, tem);
8900
8901           /* Optimize z * conj(z) for integer complex numbers.  */
8902           if (TREE_CODE (arg0) == CONJ_EXPR
8903               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8904             return fold_mult_zconjz (type, arg1);
8905           if (TREE_CODE (arg1) == CONJ_EXPR
8906               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8907             return fold_mult_zconjz (type, arg0);
8908         }
8909       else
8910         {
8911           /* Maybe fold x * 0 to 0.  The expressions aren't the same
8912              when x is NaN, since x * 0 is also NaN.  Nor are they the
8913              same in modes with signed zeros, since multiplying a
8914              negative value by 0 gives -0, not +0.  */
8915           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
8916               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
8917               && real_zerop (arg1))
8918             return omit_one_operand (type, arg1, arg0);
8919           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
8920           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
8921               && real_onep (arg1))
8922             return non_lvalue (fold_convert (type, arg0));
8923
8924           /* Transform x * -1.0 into -x.  */
8925           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
8926               && real_minus_onep (arg1))
8927             return fold_convert (type, negate_expr (arg0));
8928
8929           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
8930           if (flag_unsafe_math_optimizations
8931               && TREE_CODE (arg0) == RDIV_EXPR
8932               && TREE_CODE (arg1) == REAL_CST
8933               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
8934             {
8935               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
8936                                       arg1, 0);
8937               if (tem)
8938                 return fold_build2 (RDIV_EXPR, type, tem,
8939                                     TREE_OPERAND (arg0, 1));
8940             }
8941
8942           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
8943           if (operand_equal_p (arg0, arg1, 0))
8944             {
8945               tree tem = fold_strip_sign_ops (arg0);
8946               if (tem != NULL_TREE)
8947                 {
8948                   tem = fold_convert (type, tem);
8949                   return fold_build2 (MULT_EXPR, type, tem, tem);
8950                 }
8951             }
8952
8953           /* Optimize z * conj(z) for floating point complex numbers.
8954              Guarded by flag_unsafe_math_optimizations as non-finite
8955              imaginary components don't produce scalar results.  */
8956           if (flag_unsafe_math_optimizations
8957               && TREE_CODE (arg0) == CONJ_EXPR
8958               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8959             return fold_mult_zconjz (type, arg1);
8960           if (flag_unsafe_math_optimizations
8961               && TREE_CODE (arg1) == CONJ_EXPR
8962               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8963             return fold_mult_zconjz (type, arg0);
8964
8965           if (flag_unsafe_math_optimizations)
8966             {
8967               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
8968               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
8969
8970               /* Optimizations of root(...)*root(...).  */
8971               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
8972                 {
8973                   tree rootfn, arg, arglist;
8974                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
8975                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
8976
8977                   /* Optimize sqrt(x)*sqrt(x) as x.  */
8978                   if (BUILTIN_SQRT_P (fcode0)
8979                       && operand_equal_p (arg00, arg10, 0)
8980                       && ! HONOR_SNANS (TYPE_MODE (type)))
8981                     return arg00;
8982
8983                   /* Optimize root(x)*root(y) as root(x*y).  */
8984                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
8985                   arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
8986                   arglist = build_tree_list (NULL_TREE, arg);
8987                   return build_function_call_expr (rootfn, arglist);
8988                 }
8989
8990               /* Optimize expN(x)*expN(y) as expN(x+y).  */
8991               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
8992                 {
8993                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
8994                   tree arg = fold_build2 (PLUS_EXPR, type,
8995                                           TREE_VALUE (TREE_OPERAND (arg0, 1)),
8996                                           TREE_VALUE (TREE_OPERAND (arg1, 1)));
8997                   tree arglist = build_tree_list (NULL_TREE, arg);
8998                   return build_function_call_expr (expfn, arglist);
8999                 }
9000
9001               /* Optimizations of pow(...)*pow(...).  */
9002               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
9003                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
9004                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
9005                 {
9006                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9007                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9008                                                                      1)));
9009                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9010                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9011                                                                      1)));
9012
9013                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
9014                   if (operand_equal_p (arg01, arg11, 0))
9015                     {
9016                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9017                       tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
9018                       tree arglist = tree_cons (NULL_TREE, arg,
9019                                                 build_tree_list (NULL_TREE,
9020                                                                  arg01));
9021                       return build_function_call_expr (powfn, arglist);
9022                     }
9023
9024                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
9025                   if (operand_equal_p (arg00, arg10, 0))
9026                     {
9027                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9028                       tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
9029                       tree arglist = tree_cons (NULL_TREE, arg00,
9030                                                 build_tree_list (NULL_TREE,
9031                                                                  arg));
9032                       return build_function_call_expr (powfn, arglist);
9033                     }
9034                 }
9035
9036               /* Optimize tan(x)*cos(x) as sin(x).  */
9037               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
9038                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
9039                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
9040                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
9041                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
9042                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
9043                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9044                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9045                 {
9046                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
9047
9048                   if (sinfn != NULL_TREE)
9049                     return build_function_call_expr (sinfn,
9050                                                      TREE_OPERAND (arg0, 1));
9051                 }
9052
9053               /* Optimize x*pow(x,c) as pow(x,c+1).  */
9054               if (fcode1 == BUILT_IN_POW
9055                   || fcode1 == BUILT_IN_POWF
9056                   || fcode1 == BUILT_IN_POWL)
9057                 {
9058                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9059                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9060                                                                      1)));
9061                   if (TREE_CODE (arg11) == REAL_CST
9062                       && ! TREE_CONSTANT_OVERFLOW (arg11)
9063                       && operand_equal_p (arg0, arg10, 0))
9064                     {
9065                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9066                       REAL_VALUE_TYPE c;
9067                       tree arg, arglist;
9068
9069                       c = TREE_REAL_CST (arg11);
9070                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9071                       arg = build_real (type, c);
9072                       arglist = build_tree_list (NULL_TREE, arg);
9073                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9074                       return build_function_call_expr (powfn, arglist);
9075                     }
9076                 }
9077
9078               /* Optimize pow(x,c)*x as pow(x,c+1).  */
9079               if (fcode0 == BUILT_IN_POW
9080                   || fcode0 == BUILT_IN_POWF
9081                   || fcode0 == BUILT_IN_POWL)
9082                 {
9083                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9084                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9085                                                                      1)));
9086                   if (TREE_CODE (arg01) == REAL_CST
9087                       && ! TREE_CONSTANT_OVERFLOW (arg01)
9088                       && operand_equal_p (arg1, arg00, 0))
9089                     {
9090                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9091                       REAL_VALUE_TYPE c;
9092                       tree arg, arglist;
9093
9094                       c = TREE_REAL_CST (arg01);
9095                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9096                       arg = build_real (type, c);
9097                       arglist = build_tree_list (NULL_TREE, arg);
9098                       arglist = tree_cons (NULL_TREE, arg1, arglist);
9099                       return build_function_call_expr (powfn, arglist);
9100                     }
9101                 }
9102
9103               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
9104               if (! optimize_size
9105                   && operand_equal_p (arg0, arg1, 0))
9106                 {
9107                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
9108
9109                   if (powfn)
9110                     {
9111                       tree arg = build_real (type, dconst2);
9112                       tree arglist = build_tree_list (NULL_TREE, arg);
9113                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9114                       return build_function_call_expr (powfn, arglist);
9115                     }
9116                 }
9117             }
9118         }
9119       goto associate;
9120
9121     case BIT_IOR_EXPR:
9122     bit_ior:
9123       if (integer_all_onesp (arg1))
9124         return omit_one_operand (type, arg1, arg0);
9125       if (integer_zerop (arg1))
9126         return non_lvalue (fold_convert (type, arg0));
9127       if (operand_equal_p (arg0, arg1, 0))
9128         return non_lvalue (fold_convert (type, arg0));
9129
9130       /* ~X | X is -1.  */
9131       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9132           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9133         {
9134           t1 = build_int_cst (type, -1);
9135           t1 = force_fit_type (t1, 0, false, false);
9136           return omit_one_operand (type, t1, arg1);
9137         }
9138
9139       /* X | ~X is -1.  */
9140       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9141           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9142         {
9143           t1 = build_int_cst (type, -1);
9144           t1 = force_fit_type (t1, 0, false, false);
9145           return omit_one_operand (type, t1, arg0);
9146         }
9147
9148       /* Canonicalize (X & C1) | C2.  */
9149       if (TREE_CODE (arg0) == BIT_AND_EXPR
9150           && TREE_CODE (arg1) == INTEGER_CST
9151           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9152         {
9153           unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, mlo, mhi;
9154           int width = TYPE_PRECISION (type);
9155           hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
9156           lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
9157           hi2 = TREE_INT_CST_HIGH (arg1);
9158           lo2 = TREE_INT_CST_LOW (arg1);
9159
9160           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
9161           if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
9162             return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9163
9164           if (width > HOST_BITS_PER_WIDE_INT)
9165             {
9166               mhi = (unsigned HOST_WIDE_INT) -1
9167                     >> (2 * HOST_BITS_PER_WIDE_INT - width);
9168               mlo = -1;
9169             }
9170           else
9171             {
9172               mhi = 0;
9173               mlo = (unsigned HOST_WIDE_INT) -1
9174                     >> (HOST_BITS_PER_WIDE_INT - width);
9175             }
9176
9177           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
9178           if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
9179             return fold_build2 (BIT_IOR_EXPR, type,
9180                                 TREE_OPERAND (arg0, 0), arg1);
9181
9182           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2.  */
9183           hi1 &= mhi;
9184           lo1 &= mlo;
9185           if ((hi1 & ~hi2) != hi1 || (lo1 & ~lo2) != lo1)
9186             return fold_build2 (BIT_IOR_EXPR, type,
9187                                 fold_build2 (BIT_AND_EXPR, type,
9188                                              TREE_OPERAND (arg0, 0),
9189                                              build_int_cst_wide (type,
9190                                                                  lo1 & ~lo2,
9191                                                                  hi1 & ~hi2)),
9192                                 arg1);
9193         }
9194
9195       /* (X & Y) | Y is (X, Y).  */
9196       if (TREE_CODE (arg0) == BIT_AND_EXPR
9197           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9198         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9199       /* (X & Y) | X is (Y, X).  */
9200       if (TREE_CODE (arg0) == BIT_AND_EXPR
9201           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9202           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9203         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9204       /* X | (X & Y) is (Y, X).  */
9205       if (TREE_CODE (arg1) == BIT_AND_EXPR
9206           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9207           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9208         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9209       /* X | (Y & X) is (Y, X).  */
9210       if (TREE_CODE (arg1) == BIT_AND_EXPR
9211           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9212           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9213         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9214
9215       t1 = distribute_bit_expr (code, type, arg0, arg1);
9216       if (t1 != NULL_TREE)
9217         return t1;
9218
9219       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
9220
9221          This results in more efficient code for machines without a NAND
9222          instruction.  Combine will canonicalize to the first form
9223          which will allow use of NAND instructions provided by the
9224          backend if they exist.  */
9225       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9226           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9227         {
9228           return fold_build1 (BIT_NOT_EXPR, type,
9229                               build2 (BIT_AND_EXPR, type,
9230                                       TREE_OPERAND (arg0, 0),
9231                                       TREE_OPERAND (arg1, 0)));
9232         }
9233
9234       /* See if this can be simplified into a rotate first.  If that
9235          is unsuccessful continue in the association code.  */
9236       goto bit_rotate;
9237
9238     case BIT_XOR_EXPR:
9239       if (integer_zerop (arg1))
9240         return non_lvalue (fold_convert (type, arg0));
9241       if (integer_all_onesp (arg1))
9242         return fold_build1 (BIT_NOT_EXPR, type, arg0);
9243       if (operand_equal_p (arg0, arg1, 0))
9244         return omit_one_operand (type, integer_zero_node, arg0);
9245
9246       /* ~X ^ X is -1.  */
9247       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9248           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9249         {
9250           t1 = build_int_cst (type, -1);
9251           t1 = force_fit_type (t1, 0, false, false);
9252           return omit_one_operand (type, t1, arg1);
9253         }
9254
9255       /* X ^ ~X is -1.  */
9256       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9257           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9258         {
9259           t1 = build_int_cst (type, -1);
9260           t1 = force_fit_type (t1, 0, false, false);
9261           return omit_one_operand (type, t1, arg0);
9262         }
9263
9264       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
9265          with a constant, and the two constants have no bits in common,
9266          we should treat this as a BIT_IOR_EXPR since this may produce more
9267          simplifications.  */
9268       if (TREE_CODE (arg0) == BIT_AND_EXPR
9269           && TREE_CODE (arg1) == BIT_AND_EXPR
9270           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9271           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9272           && integer_zerop (const_binop (BIT_AND_EXPR,
9273                                          TREE_OPERAND (arg0, 1),
9274                                          TREE_OPERAND (arg1, 1), 0)))
9275         {
9276           code = BIT_IOR_EXPR;
9277           goto bit_ior;
9278         }
9279
9280       /* (X | Y) ^ X -> Y & ~ X*/
9281       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9282           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9283         {
9284           tree t2 = TREE_OPERAND (arg0, 1);
9285           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9286                             arg1);
9287           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9288                             fold_convert (type, t1));
9289           return t1;
9290         }
9291
9292       /* (Y | X) ^ X -> Y & ~ X*/
9293       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9294           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9295         {
9296           tree t2 = TREE_OPERAND (arg0, 0);
9297           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9298                             arg1);
9299           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9300                             fold_convert (type, t1));
9301           return t1;
9302         }
9303
9304       /* X ^ (X | Y) -> Y & ~ X*/
9305       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9306           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
9307         {
9308           tree t2 = TREE_OPERAND (arg1, 1);
9309           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9310                             arg0);
9311           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9312                             fold_convert (type, t1));
9313           return t1;
9314         }
9315
9316       /* X ^ (Y | X) -> Y & ~ X*/
9317       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9318           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
9319         {
9320           tree t2 = TREE_OPERAND (arg1, 0);
9321           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9322                             arg0);
9323           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9324                             fold_convert (type, t1));
9325           return t1;
9326         }
9327
9328       /* Convert ~X ^ ~Y to X ^ Y.  */
9329       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9330           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9331         return fold_build2 (code, type,
9332                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9333                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9334
9335       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
9336       if (TREE_CODE (arg0) == BIT_AND_EXPR
9337           && integer_onep (TREE_OPERAND (arg0, 1))
9338           && integer_onep (arg1))
9339         return fold_build2 (EQ_EXPR, type, arg0,
9340                             build_int_cst (TREE_TYPE (arg0), 0));
9341
9342       /* Fold (X & Y) ^ Y as ~X & Y.  */
9343       if (TREE_CODE (arg0) == BIT_AND_EXPR
9344           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9345         {
9346           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9347           return fold_build2 (BIT_AND_EXPR, type,
9348                               fold_build1 (BIT_NOT_EXPR, type, tem),
9349                               fold_convert (type, arg1));
9350         }
9351       /* Fold (X & Y) ^ X as ~Y & X.  */
9352       if (TREE_CODE (arg0) == BIT_AND_EXPR
9353           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9354           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9355         {
9356           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9357           return fold_build2 (BIT_AND_EXPR, type,
9358                               fold_build1 (BIT_NOT_EXPR, type, tem),
9359                               fold_convert (type, arg1));
9360         }
9361       /* Fold X ^ (X & Y) as X & ~Y.  */
9362       if (TREE_CODE (arg1) == BIT_AND_EXPR
9363           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9364         {
9365           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9366           return fold_build2 (BIT_AND_EXPR, type,
9367                               fold_convert (type, arg0),
9368                               fold_build1 (BIT_NOT_EXPR, type, tem));
9369         }
9370       /* Fold X ^ (Y & X) as ~Y & X.  */
9371       if (TREE_CODE (arg1) == BIT_AND_EXPR
9372           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9373           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9374         {
9375           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9376           return fold_build2 (BIT_AND_EXPR, type,
9377                               fold_build1 (BIT_NOT_EXPR, type, tem),
9378                               fold_convert (type, arg0));
9379         }
9380
9381       /* See if this can be simplified into a rotate first.  If that
9382          is unsuccessful continue in the association code.  */
9383       goto bit_rotate;
9384
9385     case BIT_AND_EXPR:
9386       if (integer_all_onesp (arg1))
9387         return non_lvalue (fold_convert (type, arg0));
9388       if (integer_zerop (arg1))
9389         return omit_one_operand (type, arg1, arg0);
9390       if (operand_equal_p (arg0, arg1, 0))
9391         return non_lvalue (fold_convert (type, arg0));
9392
9393       /* ~X & X is always zero.  */
9394       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9395           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9396         return omit_one_operand (type, integer_zero_node, arg1);
9397
9398       /* X & ~X is always zero.  */
9399       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9400           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9401         return omit_one_operand (type, integer_zero_node, arg0);
9402
9403       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
9404       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9405           && TREE_CODE (arg1) == INTEGER_CST
9406           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9407         return fold_build2 (BIT_IOR_EXPR, type,
9408                             fold_build2 (BIT_AND_EXPR, type,
9409                                          TREE_OPERAND (arg0, 0), arg1),
9410                             fold_build2 (BIT_AND_EXPR, type,
9411                                          TREE_OPERAND (arg0, 1), arg1));
9412
9413       /* (X | Y) & Y is (X, Y).  */
9414       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9415           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9416         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9417       /* (X | Y) & X is (Y, X).  */
9418       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9419           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9420           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9421         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9422       /* X & (X | Y) is (Y, X).  */
9423       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9424           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9425           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9426         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9427       /* X & (Y | X) is (Y, X).  */
9428       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9429           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9430           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9431         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9432
9433       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
9434       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9435           && integer_onep (TREE_OPERAND (arg0, 1))
9436           && integer_onep (arg1))
9437         {
9438           tem = TREE_OPERAND (arg0, 0);
9439           return fold_build2 (EQ_EXPR, type,
9440                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9441                                            build_int_cst (TREE_TYPE (tem), 1)),
9442                               build_int_cst (TREE_TYPE (tem), 0));
9443         }
9444       /* Fold ~X & 1 as (X & 1) == 0.  */
9445       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9446           && integer_onep (arg1))
9447         {
9448           tem = TREE_OPERAND (arg0, 0);
9449           return fold_build2 (EQ_EXPR, type,
9450                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9451                                            build_int_cst (TREE_TYPE (tem), 1)),
9452                               build_int_cst (TREE_TYPE (tem), 0));
9453         }
9454
9455       /* Fold (X ^ Y) & Y as ~X & Y.  */
9456       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9457           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9458         {
9459           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9460           return fold_build2 (BIT_AND_EXPR, type,
9461                               fold_build1 (BIT_NOT_EXPR, type, tem),
9462                               fold_convert (type, arg1));
9463         }
9464       /* Fold (X ^ Y) & X as ~Y & X.  */
9465       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9466           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9467           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9468         {
9469           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9470           return fold_build2 (BIT_AND_EXPR, type,
9471                               fold_build1 (BIT_NOT_EXPR, type, tem),
9472                               fold_convert (type, arg1));
9473         }
9474       /* Fold X & (X ^ Y) as X & ~Y.  */
9475       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9476           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9477         {
9478           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9479           return fold_build2 (BIT_AND_EXPR, type,
9480                               fold_convert (type, arg0),
9481                               fold_build1 (BIT_NOT_EXPR, type, tem));
9482         }
9483       /* Fold X & (Y ^ X) as ~Y & X.  */
9484       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9485           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9486           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9487         {
9488           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9489           return fold_build2 (BIT_AND_EXPR, type,
9490                               fold_build1 (BIT_NOT_EXPR, type, tem),
9491                               fold_convert (type, arg0));
9492         }
9493
9494       t1 = distribute_bit_expr (code, type, arg0, arg1);
9495       if (t1 != NULL_TREE)
9496         return t1;
9497       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
9498       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
9499           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
9500         {
9501           unsigned int prec
9502             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
9503
9504           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
9505               && (~TREE_INT_CST_LOW (arg1)
9506                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
9507             return fold_convert (type, TREE_OPERAND (arg0, 0));
9508         }
9509
9510       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
9511
9512          This results in more efficient code for machines without a NOR
9513          instruction.  Combine will canonicalize to the first form
9514          which will allow use of NOR instructions provided by the
9515          backend if they exist.  */
9516       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9517           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9518         {
9519           return fold_build1 (BIT_NOT_EXPR, type,
9520                               build2 (BIT_IOR_EXPR, type,
9521                                       TREE_OPERAND (arg0, 0),
9522                                       TREE_OPERAND (arg1, 0)));
9523         }
9524
9525       goto associate;
9526
9527     case RDIV_EXPR:
9528       /* Don't touch a floating-point divide by zero unless the mode
9529          of the constant can represent infinity.  */
9530       if (TREE_CODE (arg1) == REAL_CST
9531           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
9532           && real_zerop (arg1))
9533         return NULL_TREE;
9534
9535       /* Optimize A / A to 1.0 if we don't care about
9536          NaNs or Infinities.  Skip the transformation
9537          for non-real operands.  */
9538       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
9539           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9540           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
9541           && operand_equal_p (arg0, arg1, 0))
9542         {
9543           tree r = build_real (TREE_TYPE (arg0), dconst1);
9544
9545           return omit_two_operands (type, r, arg0, arg1);
9546         }
9547
9548       /* The complex version of the above A / A optimization.  */
9549       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
9550           && operand_equal_p (arg0, arg1, 0))
9551         {
9552           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
9553           if (! HONOR_NANS (TYPE_MODE (elem_type))
9554               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
9555             {
9556               tree r = build_real (elem_type, dconst1);
9557               /* omit_two_operands will call fold_convert for us.  */
9558               return omit_two_operands (type, r, arg0, arg1);
9559             }
9560         }
9561
9562       /* (-A) / (-B) -> A / B  */
9563       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9564         return fold_build2 (RDIV_EXPR, type,
9565                             TREE_OPERAND (arg0, 0),
9566                             negate_expr (arg1));
9567       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9568         return fold_build2 (RDIV_EXPR, type,
9569                             negate_expr (arg0),
9570                             TREE_OPERAND (arg1, 0));
9571
9572       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
9573       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9574           && real_onep (arg1))
9575         return non_lvalue (fold_convert (type, arg0));
9576
9577       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
9578       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9579           && real_minus_onep (arg1))
9580         return non_lvalue (fold_convert (type, negate_expr (arg0)));
9581
9582       /* If ARG1 is a constant, we can convert this to a multiply by the
9583          reciprocal.  This does not have the same rounding properties,
9584          so only do this if -funsafe-math-optimizations.  We can actually
9585          always safely do it if ARG1 is a power of two, but it's hard to
9586          tell if it is or not in a portable manner.  */
9587       if (TREE_CODE (arg1) == REAL_CST)
9588         {
9589           if (flag_unsafe_math_optimizations
9590               && 0 != (tem = const_binop (code, build_real (type, dconst1),
9591                                           arg1, 0)))
9592             return fold_build2 (MULT_EXPR, type, arg0, tem);
9593           /* Find the reciprocal if optimizing and the result is exact.  */
9594           if (optimize)
9595             {
9596               REAL_VALUE_TYPE r;
9597               r = TREE_REAL_CST (arg1);
9598               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
9599                 {
9600                   tem = build_real (type, r);
9601                   return fold_build2 (MULT_EXPR, type,
9602                                       fold_convert (type, arg0), tem);
9603                 }
9604             }
9605         }
9606       /* Convert A/B/C to A/(B*C).  */
9607       if (flag_unsafe_math_optimizations
9608           && TREE_CODE (arg0) == RDIV_EXPR)
9609         return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
9610                             fold_build2 (MULT_EXPR, type,
9611                                          TREE_OPERAND (arg0, 1), arg1));
9612
9613       /* Convert A/(B/C) to (A/B)*C.  */
9614       if (flag_unsafe_math_optimizations
9615           && TREE_CODE (arg1) == RDIV_EXPR)
9616         return fold_build2 (MULT_EXPR, type,
9617                             fold_build2 (RDIV_EXPR, type, arg0,
9618                                          TREE_OPERAND (arg1, 0)),
9619                             TREE_OPERAND (arg1, 1));
9620
9621       /* Convert C1/(X*C2) into (C1/C2)/X.  */
9622       if (flag_unsafe_math_optimizations
9623           && TREE_CODE (arg1) == MULT_EXPR
9624           && TREE_CODE (arg0) == REAL_CST
9625           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
9626         {
9627           tree tem = const_binop (RDIV_EXPR, arg0,
9628                                   TREE_OPERAND (arg1, 1), 0);
9629           if (tem)
9630             return fold_build2 (RDIV_EXPR, type, tem,
9631                                 TREE_OPERAND (arg1, 0));
9632         }
9633
9634       if (flag_unsafe_math_optimizations)
9635         {
9636           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
9637           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
9638
9639           /* Optimize sin(x)/cos(x) as tan(x).  */
9640           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
9641                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
9642                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
9643               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9644                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9645             {
9646               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9647
9648               if (tanfn != NULL_TREE)
9649                 return build_function_call_expr (tanfn,
9650                                                  TREE_OPERAND (arg0, 1));
9651             }
9652
9653           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
9654           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
9655                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
9656                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
9657               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9658                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9659             {
9660               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9661
9662               if (tanfn != NULL_TREE)
9663                 {
9664                   tree tmp = TREE_OPERAND (arg0, 1);
9665                   tmp = build_function_call_expr (tanfn, tmp);
9666                   return fold_build2 (RDIV_EXPR, type,
9667                                       build_real (type, dconst1), tmp);
9668                 }
9669             }
9670
9671           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
9672              NaNs or Infinities.  */
9673           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
9674                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
9675                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
9676             {
9677               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9678               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9679
9680               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9681                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9682                   && operand_equal_p (arg00, arg01, 0))
9683                 {
9684                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9685
9686                   if (cosfn != NULL_TREE)
9687                     return build_function_call_expr (cosfn,
9688                                                      TREE_OPERAND (arg0, 1));
9689                 }
9690             }
9691
9692           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
9693              NaNs or Infinities.  */
9694           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
9695                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
9696                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
9697             {
9698               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9699               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9700
9701               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9702                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9703                   && operand_equal_p (arg00, arg01, 0))
9704                 {
9705                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9706
9707                   if (cosfn != NULL_TREE)
9708                     {
9709                       tree tmp = TREE_OPERAND (arg0, 1);
9710                       tmp = build_function_call_expr (cosfn, tmp);
9711                       return fold_build2 (RDIV_EXPR, type,
9712                                           build_real (type, dconst1),
9713                                           tmp);
9714                     }
9715                 }
9716             }
9717
9718           /* Optimize pow(x,c)/x as pow(x,c-1).  */
9719           if (fcode0 == BUILT_IN_POW
9720               || fcode0 == BUILT_IN_POWF
9721               || fcode0 == BUILT_IN_POWL)
9722             {
9723               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9724               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
9725               if (TREE_CODE (arg01) == REAL_CST
9726                   && ! TREE_CONSTANT_OVERFLOW (arg01)
9727                   && operand_equal_p (arg1, arg00, 0))
9728                 {
9729                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9730                   REAL_VALUE_TYPE c;
9731                   tree arg, arglist;
9732
9733                   c = TREE_REAL_CST (arg01);
9734                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
9735                   arg = build_real (type, c);
9736                   arglist = build_tree_list (NULL_TREE, arg);
9737                   arglist = tree_cons (NULL_TREE, arg1, arglist);
9738                   return build_function_call_expr (powfn, arglist);
9739                 }
9740             }
9741
9742           /* Optimize x/expN(y) into x*expN(-y).  */
9743           if (BUILTIN_EXPONENT_P (fcode1))
9744             {
9745               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9746               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
9747               tree arglist = build_tree_list (NULL_TREE,
9748                                               fold_convert (type, arg));
9749               arg1 = build_function_call_expr (expfn, arglist);
9750               return fold_build2 (MULT_EXPR, type, arg0, arg1);
9751             }
9752
9753           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
9754           if (fcode1 == BUILT_IN_POW
9755               || fcode1 == BUILT_IN_POWF
9756               || fcode1 == BUILT_IN_POWL)
9757             {
9758               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9759               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9760               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
9761               tree neg11 = fold_convert (type, negate_expr (arg11));
9762               tree arglist = tree_cons(NULL_TREE, arg10,
9763                                        build_tree_list (NULL_TREE, neg11));
9764               arg1 = build_function_call_expr (powfn, arglist);
9765               return fold_build2 (MULT_EXPR, type, arg0, arg1);
9766             }
9767         }
9768       return NULL_TREE;
9769
9770     case TRUNC_DIV_EXPR:
9771     case FLOOR_DIV_EXPR:
9772       /* Simplify A / (B << N) where A and B are positive and B is
9773          a power of 2, to A >> (N + log2(B)).  */
9774       if (TREE_CODE (arg1) == LSHIFT_EXPR
9775           && (TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (arg0)))
9776         {
9777           tree sval = TREE_OPERAND (arg1, 0);
9778           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
9779             {
9780               tree sh_cnt = TREE_OPERAND (arg1, 1);
9781               unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
9782
9783               sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
9784                                     sh_cnt, build_int_cst (NULL_TREE, pow2));
9785               return fold_build2 (RSHIFT_EXPR, type,
9786                                   fold_convert (type, arg0), sh_cnt);
9787             }
9788         }
9789       /* Fall thru */
9790
9791     case ROUND_DIV_EXPR:
9792     case CEIL_DIV_EXPR:
9793     case EXACT_DIV_EXPR:
9794       if (integer_onep (arg1))
9795         return non_lvalue (fold_convert (type, arg0));
9796       if (integer_zerop (arg1))
9797         return NULL_TREE;
9798       /* X / -1 is -X.  */
9799       if (!TYPE_UNSIGNED (type)
9800           && TREE_CODE (arg1) == INTEGER_CST
9801           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
9802           && TREE_INT_CST_HIGH (arg1) == -1)
9803         return fold_convert (type, negate_expr (arg0));
9804
9805       /* Convert -A / -B to A / B when the type is signed and overflow is
9806          undefined.  */
9807       if (!TYPE_UNSIGNED (type) && !flag_wrapv
9808           && TREE_CODE (arg0) == NEGATE_EXPR
9809           && negate_expr_p (arg1))
9810         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
9811                             negate_expr (arg1));
9812       if (!TYPE_UNSIGNED (type) && !flag_wrapv
9813           && TREE_CODE (arg1) == NEGATE_EXPR
9814           && negate_expr_p (arg0))
9815         return fold_build2 (code, type, negate_expr (arg0),
9816                             TREE_OPERAND (arg1, 0));
9817
9818       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
9819          operation, EXACT_DIV_EXPR.
9820
9821          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
9822          At one time others generated faster code, it's not clear if they do
9823          after the last round to changes to the DIV code in expmed.c.  */
9824       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
9825           && multiple_of_p (type, arg0, arg1))
9826         return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
9827
9828       if (TREE_CODE (arg1) == INTEGER_CST
9829           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
9830         return fold_convert (type, tem);
9831
9832       return NULL_TREE;
9833
9834     case CEIL_MOD_EXPR:
9835     case FLOOR_MOD_EXPR:
9836     case ROUND_MOD_EXPR:
9837     case TRUNC_MOD_EXPR:
9838       /* X % 1 is always zero, but be sure to preserve any side
9839          effects in X.  */
9840       if (integer_onep (arg1))
9841         return omit_one_operand (type, integer_zero_node, arg0);
9842
9843       /* X % 0, return X % 0 unchanged so that we can get the
9844          proper warnings and errors.  */
9845       if (integer_zerop (arg1))
9846         return NULL_TREE;
9847
9848       /* 0 % X is always zero, but be sure to preserve any side
9849          effects in X.  Place this after checking for X == 0.  */
9850       if (integer_zerop (arg0))
9851         return omit_one_operand (type, integer_zero_node, arg1);
9852
9853       /* X % -1 is zero.  */
9854       if (!TYPE_UNSIGNED (type)
9855           && TREE_CODE (arg1) == INTEGER_CST
9856           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
9857           && TREE_INT_CST_HIGH (arg1) == -1)
9858         return omit_one_operand (type, integer_zero_node, arg0);
9859
9860       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
9861          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
9862       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
9863           && (TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (arg0)))
9864         {
9865           tree c = arg1;
9866           /* Also optimize A % (C << N)  where C is a power of 2,
9867              to A & ((C << N) - 1).  */
9868           if (TREE_CODE (arg1) == LSHIFT_EXPR)
9869             c = TREE_OPERAND (arg1, 0);
9870
9871           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
9872             {
9873               tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1),
9874                                        arg1, integer_one_node);
9875               return fold_build2 (BIT_AND_EXPR, type,
9876                                   fold_convert (type, arg0),
9877                                   fold_convert (type, mask));
9878             }
9879         }
9880
9881       /* X % -C is the same as X % C.  */
9882       if (code == TRUNC_MOD_EXPR
9883           && !TYPE_UNSIGNED (type)
9884           && TREE_CODE (arg1) == INTEGER_CST
9885           && !TREE_CONSTANT_OVERFLOW (arg1)
9886           && TREE_INT_CST_HIGH (arg1) < 0
9887           && !flag_trapv
9888           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
9889           && !sign_bit_p (arg1, arg1))
9890         return fold_build2 (code, type, fold_convert (type, arg0),
9891                             fold_convert (type, negate_expr (arg1)));
9892
9893       /* X % -Y is the same as X % Y.  */
9894       if (code == TRUNC_MOD_EXPR
9895           && !TYPE_UNSIGNED (type)
9896           && TREE_CODE (arg1) == NEGATE_EXPR
9897           && !flag_trapv)
9898         return fold_build2 (code, type, fold_convert (type, arg0),
9899                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9900
9901       if (TREE_CODE (arg1) == INTEGER_CST
9902           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
9903         return fold_convert (type, tem);
9904
9905       return NULL_TREE;
9906
9907     case LROTATE_EXPR:
9908     case RROTATE_EXPR:
9909       if (integer_all_onesp (arg0))
9910         return omit_one_operand (type, arg0, arg1);
9911       goto shift;
9912
9913     case RSHIFT_EXPR:
9914       /* Optimize -1 >> x for arithmetic right shifts.  */
9915       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
9916         return omit_one_operand (type, arg0, arg1);
9917       /* ... fall through ...  */
9918
9919     case LSHIFT_EXPR:
9920     shift:
9921       if (integer_zerop (arg1))
9922         return non_lvalue (fold_convert (type, arg0));
9923       if (integer_zerop (arg0))
9924         return omit_one_operand (type, arg0, arg1);
9925
9926       /* Since negative shift count is not well-defined,
9927          don't try to compute it in the compiler.  */
9928       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
9929         return NULL_TREE;
9930
9931       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
9932       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
9933           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
9934           && host_integerp (TREE_OPERAND (arg0, 1), false)
9935           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
9936         {
9937           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
9938                                + TREE_INT_CST_LOW (arg1));
9939
9940           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
9941              being well defined.  */
9942           if (low >= TYPE_PRECISION (type))
9943             {
9944               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
9945                 low = low % TYPE_PRECISION (type);
9946               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
9947                 return build_int_cst (type, 0);
9948               else
9949                 low = TYPE_PRECISION (type) - 1;
9950             }
9951
9952           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
9953                               build_int_cst (type, low));
9954         }
9955
9956       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
9957          into x & ((unsigned)-1 >> c) for unsigned types.  */
9958       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
9959            || (TYPE_UNSIGNED (type)
9960                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
9961           && host_integerp (arg1, false)
9962           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
9963           && host_integerp (TREE_OPERAND (arg0, 1), false)
9964           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
9965         {
9966           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
9967           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
9968           tree lshift;
9969           tree arg00;
9970
9971           if (low0 == low1)
9972             {
9973               arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
9974
9975               lshift = build_int_cst (type, -1);
9976               lshift = int_const_binop (code, lshift, arg1, 0);
9977
9978               return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
9979             }
9980         }
9981
9982       /* Rewrite an LROTATE_EXPR by a constant into an
9983          RROTATE_EXPR by a new constant.  */
9984       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
9985         {
9986           tree tem = build_int_cst (NULL_TREE,
9987                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
9988           tem = fold_convert (TREE_TYPE (arg1), tem);
9989           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
9990           return fold_build2 (RROTATE_EXPR, type, arg0, tem);
9991         }
9992
9993       /* If we have a rotate of a bit operation with the rotate count and
9994          the second operand of the bit operation both constant,
9995          permute the two operations.  */
9996       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
9997           && (TREE_CODE (arg0) == BIT_AND_EXPR
9998               || TREE_CODE (arg0) == BIT_IOR_EXPR
9999               || TREE_CODE (arg0) == BIT_XOR_EXPR)
10000           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10001         return fold_build2 (TREE_CODE (arg0), type,
10002                             fold_build2 (code, type,
10003                                          TREE_OPERAND (arg0, 0), arg1),
10004                             fold_build2 (code, type,
10005                                          TREE_OPERAND (arg0, 1), arg1));
10006
10007       /* Two consecutive rotates adding up to the width of the mode can
10008          be ignored.  */
10009       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10010           && TREE_CODE (arg0) == RROTATE_EXPR
10011           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10012           && TREE_INT_CST_HIGH (arg1) == 0
10013           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
10014           && ((TREE_INT_CST_LOW (arg1)
10015                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
10016               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
10017         return TREE_OPERAND (arg0, 0);
10018
10019       return NULL_TREE;
10020
10021     case MIN_EXPR:
10022       if (operand_equal_p (arg0, arg1, 0))
10023         return omit_one_operand (type, arg0, arg1);
10024       if (INTEGRAL_TYPE_P (type)
10025           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
10026         return omit_one_operand (type, arg1, arg0);
10027       tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
10028       if (tem)
10029         return tem;
10030       goto associate;
10031
10032     case MAX_EXPR:
10033       if (operand_equal_p (arg0, arg1, 0))
10034         return omit_one_operand (type, arg0, arg1);
10035       if (INTEGRAL_TYPE_P (type)
10036           && TYPE_MAX_VALUE (type)
10037           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
10038         return omit_one_operand (type, arg1, arg0);
10039       tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
10040       if (tem)
10041         return tem;
10042       goto associate;
10043
10044     case TRUTH_ANDIF_EXPR:
10045       /* Note that the operands of this must be ints
10046          and their values must be 0 or 1.
10047          ("true" is a fixed value perhaps depending on the language.)  */
10048       /* If first arg is constant zero, return it.  */
10049       if (integer_zerop (arg0))
10050         return fold_convert (type, arg0);
10051     case TRUTH_AND_EXPR:
10052       /* If either arg is constant true, drop it.  */
10053       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10054         return non_lvalue (fold_convert (type, arg1));
10055       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
10056           /* Preserve sequence points.  */
10057           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10058         return non_lvalue (fold_convert (type, arg0));
10059       /* If second arg is constant zero, result is zero, but first arg
10060          must be evaluated.  */
10061       if (integer_zerop (arg1))
10062         return omit_one_operand (type, arg1, arg0);
10063       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10064          case will be handled here.  */
10065       if (integer_zerop (arg0))
10066         return omit_one_operand (type, arg0, arg1);
10067
10068       /* !X && X is always false.  */
10069       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10070           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10071         return omit_one_operand (type, integer_zero_node, arg1);
10072       /* X && !X is always false.  */
10073       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10074           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10075         return omit_one_operand (type, integer_zero_node, arg0);
10076
10077       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
10078          means A >= Y && A != MAX, but in this case we know that
10079          A < X <= MAX.  */
10080
10081       if (!TREE_SIDE_EFFECTS (arg0)
10082           && !TREE_SIDE_EFFECTS (arg1))
10083         {
10084           tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
10085           if (tem && !operand_equal_p (tem, arg0, 0))
10086             return fold_build2 (code, type, tem, arg1);
10087
10088           tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
10089           if (tem && !operand_equal_p (tem, arg1, 0))
10090             return fold_build2 (code, type, arg0, tem);
10091         }
10092
10093     truth_andor:
10094       /* We only do these simplifications if we are optimizing.  */
10095       if (!optimize)
10096         return NULL_TREE;
10097
10098       /* Check for things like (A || B) && (A || C).  We can convert this
10099          to A || (B && C).  Note that either operator can be any of the four
10100          truth and/or operations and the transformation will still be
10101          valid.   Also note that we only care about order for the
10102          ANDIF and ORIF operators.  If B contains side effects, this
10103          might change the truth-value of A.  */
10104       if (TREE_CODE (arg0) == TREE_CODE (arg1)
10105           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
10106               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
10107               || TREE_CODE (arg0) == TRUTH_AND_EXPR
10108               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
10109           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
10110         {
10111           tree a00 = TREE_OPERAND (arg0, 0);
10112           tree a01 = TREE_OPERAND (arg0, 1);
10113           tree a10 = TREE_OPERAND (arg1, 0);
10114           tree a11 = TREE_OPERAND (arg1, 1);
10115           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
10116                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
10117                              && (code == TRUTH_AND_EXPR
10118                                  || code == TRUTH_OR_EXPR));
10119
10120           if (operand_equal_p (a00, a10, 0))
10121             return fold_build2 (TREE_CODE (arg0), type, a00,
10122                                 fold_build2 (code, type, a01, a11));
10123           else if (commutative && operand_equal_p (a00, a11, 0))
10124             return fold_build2 (TREE_CODE (arg0), type, a00,
10125                                 fold_build2 (code, type, a01, a10));
10126           else if (commutative && operand_equal_p (a01, a10, 0))
10127             return fold_build2 (TREE_CODE (arg0), type, a01,
10128                                 fold_build2 (code, type, a00, a11));
10129
10130           /* This case if tricky because we must either have commutative
10131              operators or else A10 must not have side-effects.  */
10132
10133           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
10134                    && operand_equal_p (a01, a11, 0))
10135             return fold_build2 (TREE_CODE (arg0), type,
10136                                 fold_build2 (code, type, a00, a10),
10137                                 a01);
10138         }
10139
10140       /* See if we can build a range comparison.  */
10141       if (0 != (tem = fold_range_test (code, type, op0, op1)))
10142         return tem;
10143
10144       /* Check for the possibility of merging component references.  If our
10145          lhs is another similar operation, try to merge its rhs with our
10146          rhs.  Then try to merge our lhs and rhs.  */
10147       if (TREE_CODE (arg0) == code
10148           && 0 != (tem = fold_truthop (code, type,
10149                                        TREE_OPERAND (arg0, 1), arg1)))
10150         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10151
10152       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
10153         return tem;
10154
10155       return NULL_TREE;
10156
10157     case TRUTH_ORIF_EXPR:
10158       /* Note that the operands of this must be ints
10159          and their values must be 0 or true.
10160          ("true" is a fixed value perhaps depending on the language.)  */
10161       /* If first arg is constant true, return it.  */
10162       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10163         return fold_convert (type, arg0);
10164     case TRUTH_OR_EXPR:
10165       /* If either arg is constant zero, drop it.  */
10166       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
10167         return non_lvalue (fold_convert (type, arg1));
10168       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
10169           /* Preserve sequence points.  */
10170           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10171         return non_lvalue (fold_convert (type, arg0));
10172       /* If second arg is constant true, result is true, but we must
10173          evaluate first arg.  */
10174       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
10175         return omit_one_operand (type, arg1, arg0);
10176       /* Likewise for first arg, but note this only occurs here for
10177          TRUTH_OR_EXPR.  */
10178       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10179         return omit_one_operand (type, arg0, arg1);
10180
10181       /* !X || X is always true.  */
10182       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10183           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10184         return omit_one_operand (type, integer_one_node, arg1);
10185       /* X || !X is always true.  */
10186       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10187           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10188         return omit_one_operand (type, integer_one_node, arg0);
10189
10190       goto truth_andor;
10191
10192     case TRUTH_XOR_EXPR:
10193       /* If the second arg is constant zero, drop it.  */
10194       if (integer_zerop (arg1))
10195         return non_lvalue (fold_convert (type, arg0));
10196       /* If the second arg is constant true, this is a logical inversion.  */
10197       if (integer_onep (arg1))
10198         {
10199           /* Only call invert_truthvalue if operand is a truth value.  */
10200           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
10201             tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
10202           else
10203             tem = invert_truthvalue (arg0);
10204           return non_lvalue (fold_convert (type, tem));
10205         }
10206       /* Identical arguments cancel to zero.  */
10207       if (operand_equal_p (arg0, arg1, 0))
10208         return omit_one_operand (type, integer_zero_node, arg0);
10209
10210       /* !X ^ X is always true.  */
10211       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10212           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10213         return omit_one_operand (type, integer_one_node, arg1);
10214
10215       /* X ^ !X is always true.  */
10216       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10217           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10218         return omit_one_operand (type, integer_one_node, arg0);
10219
10220       return NULL_TREE;
10221
10222     case EQ_EXPR:
10223     case NE_EXPR:
10224       tem = fold_comparison (code, type, op0, op1);
10225       if (tem != NULL_TREE)
10226         return tem;
10227
10228       /* bool_var != 0 becomes bool_var. */
10229       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10230           && code == NE_EXPR)
10231         return non_lvalue (fold_convert (type, arg0));
10232
10233       /* bool_var == 1 becomes bool_var. */
10234       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10235           && code == EQ_EXPR)
10236         return non_lvalue (fold_convert (type, arg0));
10237
10238       /* bool_var != 1 becomes !bool_var. */
10239       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10240           && code == NE_EXPR)
10241         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10242
10243       /* bool_var == 0 becomes !bool_var. */
10244       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10245           && code == EQ_EXPR)
10246         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10247
10248       /*  ~a != C becomes a != ~C where C is a constant.  Likewise for ==.  */
10249       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10250           && TREE_CODE (arg1) == INTEGER_CST)
10251         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10252                             fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
10253                                          arg1));
10254
10255       /* If this is an equality comparison of the address of a non-weak
10256          object against zero, then we know the result.  */
10257       if (TREE_CODE (arg0) == ADDR_EXPR
10258           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10259           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10260           && integer_zerop (arg1))
10261         return constant_boolean_node (code != EQ_EXPR, type);
10262
10263       /* If this is an equality comparison of the address of two non-weak,
10264          unaliased symbols neither of which are extern (since we do not
10265          have access to attributes for externs), then we know the result.  */
10266       if (TREE_CODE (arg0) == ADDR_EXPR
10267           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10268           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10269           && ! lookup_attribute ("alias",
10270                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
10271           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
10272           && TREE_CODE (arg1) == ADDR_EXPR
10273           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
10274           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
10275           && ! lookup_attribute ("alias",
10276                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
10277           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
10278         {
10279           /* We know that we're looking at the address of two
10280              non-weak, unaliased, static _DECL nodes.
10281
10282              It is both wasteful and incorrect to call operand_equal_p
10283              to compare the two ADDR_EXPR nodes.  It is wasteful in that
10284              all we need to do is test pointer equality for the arguments
10285              to the two ADDR_EXPR nodes.  It is incorrect to use
10286              operand_equal_p as that function is NOT equivalent to a
10287              C equality test.  It can in fact return false for two
10288              objects which would test as equal using the C equality
10289              operator.  */
10290           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
10291           return constant_boolean_node (equal
10292                                         ? code == EQ_EXPR : code != EQ_EXPR,
10293                                         type);
10294         }
10295
10296       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
10297          a MINUS_EXPR of a constant, we can convert it into a comparison with
10298          a revised constant as long as no overflow occurs.  */
10299       if (TREE_CODE (arg1) == INTEGER_CST
10300           && (TREE_CODE (arg0) == PLUS_EXPR
10301               || TREE_CODE (arg0) == MINUS_EXPR)
10302           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10303           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
10304                                       ? MINUS_EXPR : PLUS_EXPR,
10305                                       fold_convert (TREE_TYPE (arg0), arg1),
10306                                       TREE_OPERAND (arg0, 1), 0))
10307           && ! TREE_CONSTANT_OVERFLOW (tem))
10308         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10309
10310       /* Similarly for a NEGATE_EXPR.  */
10311       if (TREE_CODE (arg0) == NEGATE_EXPR
10312           && TREE_CODE (arg1) == INTEGER_CST
10313           && 0 != (tem = negate_expr (arg1))
10314           && TREE_CODE (tem) == INTEGER_CST
10315           && ! TREE_CONSTANT_OVERFLOW (tem))
10316         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10317
10318       /* If we have X - Y == 0, we can convert that to X == Y and similarly
10319          for !=.  Don't do this for ordered comparisons due to overflow.  */
10320       if (TREE_CODE (arg0) == MINUS_EXPR
10321           && integer_zerop (arg1))
10322         return fold_build2 (code, type,
10323                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
10324
10325       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
10326       if (TREE_CODE (arg0) == ABS_EXPR
10327           && (integer_zerop (arg1) || real_zerop (arg1)))
10328         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
10329
10330       /* If this is an EQ or NE comparison with zero and ARG0 is
10331          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
10332          two operations, but the latter can be done in one less insn
10333          on machines that have only two-operand insns or on which a
10334          constant cannot be the first operand.  */
10335       if (TREE_CODE (arg0) == BIT_AND_EXPR
10336           && integer_zerop (arg1))
10337         {
10338           tree arg00 = TREE_OPERAND (arg0, 0);
10339           tree arg01 = TREE_OPERAND (arg0, 1);
10340           if (TREE_CODE (arg00) == LSHIFT_EXPR
10341               && integer_onep (TREE_OPERAND (arg00, 0)))
10342             return
10343               fold_build2 (code, type,
10344                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10345                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
10346                                            arg01, TREE_OPERAND (arg00, 1)),
10347                                    fold_convert (TREE_TYPE (arg0),
10348                                                  integer_one_node)),
10349                            arg1);
10350           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
10351                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
10352             return
10353               fold_build2 (code, type,
10354                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10355                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
10356                                            arg00, TREE_OPERAND (arg01, 1)),
10357                                    fold_convert (TREE_TYPE (arg0),
10358                                                  integer_one_node)),
10359                            arg1);
10360         }
10361
10362       /* If this is an NE or EQ comparison of zero against the result of a
10363          signed MOD operation whose second operand is a power of 2, make
10364          the MOD operation unsigned since it is simpler and equivalent.  */
10365       if (integer_zerop (arg1)
10366           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
10367           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
10368               || TREE_CODE (arg0) == CEIL_MOD_EXPR
10369               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
10370               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
10371           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10372         {
10373           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
10374           tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
10375                                      fold_convert (newtype,
10376                                                    TREE_OPERAND (arg0, 0)),
10377                                      fold_convert (newtype,
10378                                                    TREE_OPERAND (arg0, 1)));
10379
10380           return fold_build2 (code, type, newmod,
10381                               fold_convert (newtype, arg1));
10382         }
10383
10384       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10385          C1 is a valid shift constant, and C2 is a power of two, i.e.
10386          a single bit.  */
10387       if (TREE_CODE (arg0) == BIT_AND_EXPR
10388           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
10389           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
10390              == INTEGER_CST
10391           && integer_pow2p (TREE_OPERAND (arg0, 1))
10392           && integer_zerop (arg1))
10393         {
10394           tree itype = TREE_TYPE (arg0);
10395           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
10396           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
10397
10398           /* Check for a valid shift count.  */
10399           if (TREE_INT_CST_HIGH (arg001) == 0
10400               && TREE_INT_CST_LOW (arg001) < prec)
10401             {
10402               tree arg01 = TREE_OPERAND (arg0, 1);
10403               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10404               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
10405               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10406                  can be rewritten as (X & (C2 << C1)) != 0.  */
10407               if ((log2 + TREE_INT_CST_LOW (arg01)) < prec)
10408                 {
10409                   tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
10410                   tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
10411                   return fold_build2 (code, type, tem, arg1);
10412                 }
10413               /* Otherwise, for signed (arithmetic) shifts,
10414                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10415                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
10416               else if (!TYPE_UNSIGNED (itype))
10417                 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
10418                                     arg000, build_int_cst (itype, 0));
10419               /* Otherwise, of unsigned (logical) shifts,
10420                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10421                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
10422               else
10423                 return omit_one_operand (type,
10424                                          code == EQ_EXPR ? integer_one_node
10425                                                          : integer_zero_node,
10426                                          arg000);
10427             }
10428         }
10429
10430       /* If this is an NE comparison of zero with an AND of one, remove the
10431          comparison since the AND will give the correct value.  */
10432       if (code == NE_EXPR
10433           && integer_zerop (arg1)
10434           && TREE_CODE (arg0) == BIT_AND_EXPR
10435           && integer_onep (TREE_OPERAND (arg0, 1)))
10436         return fold_convert (type, arg0);
10437
10438       /* If we have (A & C) == C where C is a power of 2, convert this into
10439          (A & C) != 0.  Similarly for NE_EXPR.  */
10440       if (TREE_CODE (arg0) == BIT_AND_EXPR
10441           && integer_pow2p (TREE_OPERAND (arg0, 1))
10442           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10443         return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10444                             arg0, fold_convert (TREE_TYPE (arg0),
10445                                                 integer_zero_node));
10446
10447       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
10448          bit, then fold the expression into A < 0 or A >= 0.  */
10449       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
10450       if (tem)
10451         return tem;
10452
10453       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10454          Similarly for NE_EXPR.  */
10455       if (TREE_CODE (arg0) == BIT_AND_EXPR
10456           && TREE_CODE (arg1) == INTEGER_CST
10457           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10458         {
10459           tree notc = fold_build1 (BIT_NOT_EXPR,
10460                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
10461                                    TREE_OPERAND (arg0, 1));
10462           tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10463                                        arg1, notc);
10464           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10465           if (integer_nonzerop (dandnotc))
10466             return omit_one_operand (type, rslt, arg0);
10467         }
10468
10469       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
10470          Similarly for NE_EXPR.  */
10471       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10472           && TREE_CODE (arg1) == INTEGER_CST
10473           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10474         {
10475           tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
10476           tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10477                                        TREE_OPERAND (arg0, 1), notd);
10478           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10479           if (integer_nonzerop (candnotd))
10480             return omit_one_operand (type, rslt, arg0);
10481         }
10482
10483       /* If this is a comparison of a field, we may be able to simplify it.  */
10484       if (((TREE_CODE (arg0) == COMPONENT_REF
10485             && lang_hooks.can_use_bit_fields_p ())
10486            || TREE_CODE (arg0) == BIT_FIELD_REF)
10487           /* Handle the constant case even without -O
10488              to make sure the warnings are given.  */
10489           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
10490         {
10491           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
10492           if (t1)
10493             return t1;
10494         }
10495
10496       /* Optimize comparisons of strlen vs zero to a compare of the
10497          first character of the string vs zero.  To wit,
10498                 strlen(ptr) == 0   =>  *ptr == 0
10499                 strlen(ptr) != 0   =>  *ptr != 0
10500          Other cases should reduce to one of these two (or a constant)
10501          due to the return value of strlen being unsigned.  */
10502       if (TREE_CODE (arg0) == CALL_EXPR
10503           && integer_zerop (arg1))
10504         {
10505           tree fndecl = get_callee_fndecl (arg0);
10506           tree arglist;
10507
10508           if (fndecl
10509               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
10510               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
10511               && (arglist = TREE_OPERAND (arg0, 1))
10512               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
10513               && ! TREE_CHAIN (arglist))
10514             {
10515               tree iref = build_fold_indirect_ref (TREE_VALUE (arglist));
10516               return fold_build2 (code, type, iref,
10517                                   build_int_cst (TREE_TYPE (iref), 0));
10518             }
10519         }
10520
10521       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10522          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
10523       if (TREE_CODE (arg0) == RSHIFT_EXPR
10524           && integer_zerop (arg1)
10525           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10526         {
10527           tree arg00 = TREE_OPERAND (arg0, 0);
10528           tree arg01 = TREE_OPERAND (arg0, 1);
10529           tree itype = TREE_TYPE (arg00);
10530           if (TREE_INT_CST_HIGH (arg01) == 0
10531               && TREE_INT_CST_LOW (arg01)
10532                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
10533             {
10534               if (TYPE_UNSIGNED (itype))
10535                 {
10536                   itype = lang_hooks.types.signed_type (itype);
10537                   arg00 = fold_convert (itype, arg00);
10538                 }
10539               return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
10540                                   type, arg00, build_int_cst (itype, 0));
10541             }
10542         }
10543
10544       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
10545       if (integer_zerop (arg1)
10546           && TREE_CODE (arg0) == BIT_XOR_EXPR)
10547         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10548                             TREE_OPERAND (arg0, 1));
10549
10550       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
10551       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10552           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10553         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10554                             build_int_cst (TREE_TYPE (arg1), 0));
10555       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
10556       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10557           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10558           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10559         return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
10560                             build_int_cst (TREE_TYPE (arg1), 0));
10561
10562       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
10563       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10564           && TREE_CODE (arg1) == INTEGER_CST
10565           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10566         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10567                             fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
10568                                          TREE_OPERAND (arg0, 1), arg1));
10569
10570       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10571          (X & C) == 0 when C is a single bit.  */
10572       if (TREE_CODE (arg0) == BIT_AND_EXPR
10573           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
10574           && integer_zerop (arg1)
10575           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10576         {
10577           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10578                              TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
10579                              TREE_OPERAND (arg0, 1));
10580           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
10581                               type, tem, arg1);
10582         }
10583
10584       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10585          constant C is a power of two, i.e. a single bit.  */
10586       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10587           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
10588           && integer_zerop (arg1)
10589           && integer_pow2p (TREE_OPERAND (arg0, 1))
10590           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10591                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10592         {
10593           tree arg00 = TREE_OPERAND (arg0, 0);
10594           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10595                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
10596         }
10597
10598       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10599          when is C is a power of two, i.e. a single bit.  */
10600       if (TREE_CODE (arg0) == BIT_AND_EXPR
10601           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
10602           && integer_zerop (arg1)
10603           && integer_pow2p (TREE_OPERAND (arg0, 1))
10604           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10605                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10606         {
10607           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10608           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
10609                              arg000, TREE_OPERAND (arg0, 1));
10610           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10611                               tem, build_int_cst (TREE_TYPE (tem), 0));
10612         }
10613
10614       if (integer_zerop (arg1)
10615           && tree_expr_nonzero_p (arg0))
10616         {
10617           tree res = constant_boolean_node (code==NE_EXPR, type);
10618           return omit_one_operand (type, res, arg0);
10619         }
10620       return NULL_TREE;
10621
10622     case LT_EXPR:
10623     case GT_EXPR:
10624     case LE_EXPR:
10625     case GE_EXPR:
10626       tem = fold_comparison (code, type, op0, op1);
10627       if (tem != NULL_TREE)
10628         return tem;
10629
10630       /* Transform comparisons of the form X +- C CMP X.  */
10631       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
10632           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10633           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
10634                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
10635               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10636                   && !TYPE_UNSIGNED (TREE_TYPE (arg1))
10637                   && !(flag_wrapv || flag_trapv))))
10638         {
10639           tree arg01 = TREE_OPERAND (arg0, 1);
10640           enum tree_code code0 = TREE_CODE (arg0);
10641           int is_positive;
10642
10643           if (TREE_CODE (arg01) == REAL_CST)
10644             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
10645           else
10646             is_positive = tree_int_cst_sgn (arg01);
10647
10648           /* (X - c) > X becomes false.  */
10649           if (code == GT_EXPR
10650               && ((code0 == MINUS_EXPR && is_positive >= 0)
10651                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10652             return constant_boolean_node (0, type);
10653
10654           /* Likewise (X + c) < X becomes false.  */
10655           if (code == LT_EXPR
10656               && ((code0 == PLUS_EXPR && is_positive >= 0)
10657                   || (code0 == MINUS_EXPR && is_positive <= 0)))
10658             return constant_boolean_node (0, type);
10659
10660           /* Convert (X - c) <= X to true.  */
10661           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
10662               && code == LE_EXPR
10663               && ((code0 == MINUS_EXPR && is_positive >= 0)
10664                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10665             return constant_boolean_node (1, type);
10666
10667           /* Convert (X + c) >= X to true.  */
10668           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
10669               && code == GE_EXPR
10670               && ((code0 == PLUS_EXPR && is_positive >= 0)
10671                   || (code0 == MINUS_EXPR && is_positive <= 0)))
10672             return constant_boolean_node (1, type);
10673
10674           if (TREE_CODE (arg01) == INTEGER_CST)
10675             {
10676               /* Convert X + c > X and X - c < X to true for integers.  */
10677               if (code == GT_EXPR
10678                   && ((code0 == PLUS_EXPR && is_positive > 0)
10679                       || (code0 == MINUS_EXPR && is_positive < 0)))
10680                 return constant_boolean_node (1, type);
10681
10682               if (code == LT_EXPR
10683                   && ((code0 == MINUS_EXPR && is_positive > 0)
10684                       || (code0 == PLUS_EXPR && is_positive < 0)))
10685                 return constant_boolean_node (1, type);
10686
10687               /* Convert X + c <= X and X - c >= X to false for integers.  */
10688               if (code == LE_EXPR
10689                   && ((code0 == PLUS_EXPR && is_positive > 0)
10690                       || (code0 == MINUS_EXPR && is_positive < 0)))
10691                 return constant_boolean_node (0, type);
10692
10693               if (code == GE_EXPR
10694                   && ((code0 == MINUS_EXPR && is_positive > 0)
10695                       || (code0 == PLUS_EXPR && is_positive < 0)))
10696                 return constant_boolean_node (0, type);
10697             }
10698         }
10699
10700       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
10701          This transformation affects the cases which are handled in later
10702          optimizations involving comparisons with non-negative constants.  */
10703       if (TREE_CODE (arg1) == INTEGER_CST
10704           && TREE_CODE (arg0) != INTEGER_CST
10705           && tree_int_cst_sgn (arg1) > 0)
10706         {
10707           if (code == GE_EXPR)
10708             {
10709               arg1 = const_binop (MINUS_EXPR, arg1,
10710                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
10711               return fold_build2 (GT_EXPR, type, arg0,
10712                                   fold_convert (TREE_TYPE (arg0), arg1));
10713             }
10714           if (code == LT_EXPR)
10715             {
10716               arg1 = const_binop (MINUS_EXPR, arg1,
10717                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
10718               return fold_build2 (LE_EXPR, type, arg0,
10719                                   fold_convert (TREE_TYPE (arg0), arg1));
10720             }
10721         }
10722
10723       /* Comparisons with the highest or lowest possible integer of
10724          the specified size will have known values.  */
10725       {
10726         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
10727
10728         if (TREE_CODE (arg1) == INTEGER_CST
10729             && ! TREE_CONSTANT_OVERFLOW (arg1)
10730             && width <= 2 * HOST_BITS_PER_WIDE_INT
10731             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10732                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
10733           {
10734             HOST_WIDE_INT signed_max_hi;
10735             unsigned HOST_WIDE_INT signed_max_lo;
10736             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
10737
10738             if (width <= HOST_BITS_PER_WIDE_INT)
10739               {
10740                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
10741                                 - 1;
10742                 signed_max_hi = 0;
10743                 max_hi = 0;
10744
10745                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
10746                   {
10747                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
10748                     min_lo = 0;
10749                     min_hi = 0;
10750                   }
10751                 else
10752                   {
10753                     max_lo = signed_max_lo;
10754                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
10755                     min_hi = -1;
10756                   }
10757               }
10758             else
10759               {
10760                 width -= HOST_BITS_PER_WIDE_INT;
10761                 signed_max_lo = -1;
10762                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
10763                                 - 1;
10764                 max_lo = -1;
10765                 min_lo = 0;
10766
10767                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
10768                   {
10769                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
10770                     min_hi = 0;
10771                   }
10772                 else
10773                   {
10774                     max_hi = signed_max_hi;
10775                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
10776                   }
10777               }
10778
10779             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
10780                 && TREE_INT_CST_LOW (arg1) == max_lo)
10781               switch (code)
10782                 {
10783                 case GT_EXPR:
10784                   return omit_one_operand (type, integer_zero_node, arg0);
10785
10786                 case GE_EXPR:
10787                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
10788
10789                 case LE_EXPR:
10790                   return omit_one_operand (type, integer_one_node, arg0);
10791
10792                 case LT_EXPR:
10793                   return fold_build2 (NE_EXPR, type, arg0, arg1);
10794
10795                 /* The GE_EXPR and LT_EXPR cases above are not normally
10796                    reached because of previous transformations.  */
10797
10798                 default:
10799                   break;
10800                 }
10801             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
10802                      == max_hi
10803                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
10804               switch (code)
10805                 {
10806                 case GT_EXPR:
10807                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
10808                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
10809                 case LE_EXPR:
10810                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
10811                   return fold_build2 (NE_EXPR, type, arg0, arg1);
10812                 default:
10813                   break;
10814                 }
10815             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
10816                      == min_hi
10817                      && TREE_INT_CST_LOW (arg1) == min_lo)
10818               switch (code)
10819                 {
10820                 case LT_EXPR:
10821                   return omit_one_operand (type, integer_zero_node, arg0);
10822
10823                 case LE_EXPR:
10824                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
10825
10826                 case GE_EXPR:
10827                   return omit_one_operand (type, integer_one_node, arg0);
10828
10829                 case GT_EXPR:
10830                   return fold_build2 (NE_EXPR, type, op0, op1);
10831
10832                 default:
10833                   break;
10834                 }
10835             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
10836                      == min_hi
10837                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
10838               switch (code)
10839                 {
10840                 case GE_EXPR:
10841                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
10842                   return fold_build2 (NE_EXPR, type, arg0, arg1);
10843                 case LT_EXPR:
10844                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
10845                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
10846                 default:
10847                   break;
10848                 }
10849
10850             else if (!in_gimple_form
10851                      && TREE_INT_CST_HIGH (arg1) == signed_max_hi
10852                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
10853                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
10854                      /* signed_type does not work on pointer types.  */
10855                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
10856               {
10857                 /* The following case also applies to X < signed_max+1
10858                    and X >= signed_max+1 because previous transformations.  */
10859                 if (code == LE_EXPR || code == GT_EXPR)
10860                   {
10861                     tree st0, st1;
10862                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
10863                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
10864                     return fold_build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
10865                                         type, fold_convert (st0, arg0),
10866                                         build_int_cst (st1, 0));
10867                   }
10868               }
10869           }
10870       }
10871
10872       /* If we are comparing an ABS_EXPR with a constant, we can
10873          convert all the cases into explicit comparisons, but they may
10874          well not be faster than doing the ABS and one comparison.
10875          But ABS (X) <= C is a range comparison, which becomes a subtraction
10876          and a comparison, and is probably faster.  */
10877       if (code == LE_EXPR
10878           && TREE_CODE (arg1) == INTEGER_CST
10879           && TREE_CODE (arg0) == ABS_EXPR
10880           && ! TREE_SIDE_EFFECTS (arg0)
10881           && (0 != (tem = negate_expr (arg1)))
10882           && TREE_CODE (tem) == INTEGER_CST
10883           && ! TREE_CONSTANT_OVERFLOW (tem))
10884         return fold_build2 (TRUTH_ANDIF_EXPR, type,
10885                             build2 (GE_EXPR, type,
10886                                     TREE_OPERAND (arg0, 0), tem),
10887                             build2 (LE_EXPR, type,
10888                                     TREE_OPERAND (arg0, 0), arg1));
10889
10890       /* Convert ABS_EXPR<x> >= 0 to true.  */
10891       if (code == GE_EXPR
10892           && tree_expr_nonnegative_p (arg0)
10893           && (integer_zerop (arg1)
10894               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10895                   && real_zerop (arg1))))
10896         return omit_one_operand (type, integer_one_node, arg0);
10897
10898       /* Convert ABS_EXPR<x> < 0 to false.  */
10899       if (code == LT_EXPR
10900           && tree_expr_nonnegative_p (arg0)
10901           && (integer_zerop (arg1) || real_zerop (arg1)))
10902         return omit_one_operand (type, integer_zero_node, arg0);
10903
10904       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
10905          and similarly for >= into !=.  */
10906       if ((code == LT_EXPR || code == GE_EXPR)
10907           && TYPE_UNSIGNED (TREE_TYPE (arg0))
10908           && TREE_CODE (arg1) == LSHIFT_EXPR
10909           && integer_onep (TREE_OPERAND (arg1, 0)))
10910         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
10911                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
10912                                TREE_OPERAND (arg1, 1)),
10913                        build_int_cst (TREE_TYPE (arg0), 0));
10914
10915       if ((code == LT_EXPR || code == GE_EXPR)
10916           && TYPE_UNSIGNED (TREE_TYPE (arg0))
10917           && (TREE_CODE (arg1) == NOP_EXPR
10918               || TREE_CODE (arg1) == CONVERT_EXPR)
10919           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
10920           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
10921         return
10922           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
10923                   fold_convert (TREE_TYPE (arg0),
10924                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
10925                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
10926                                                       1))),
10927                   build_int_cst (TREE_TYPE (arg0), 0));
10928
10929       return NULL_TREE;
10930
10931     case UNORDERED_EXPR:
10932     case ORDERED_EXPR:
10933     case UNLT_EXPR:
10934     case UNLE_EXPR:
10935     case UNGT_EXPR:
10936     case UNGE_EXPR:
10937     case UNEQ_EXPR:
10938     case LTGT_EXPR:
10939       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
10940         {
10941           t1 = fold_relational_const (code, type, arg0, arg1);
10942           if (t1 != NULL_TREE)
10943             return t1;
10944         }
10945
10946       /* If the first operand is NaN, the result is constant.  */
10947       if (TREE_CODE (arg0) == REAL_CST
10948           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
10949           && (code != LTGT_EXPR || ! flag_trapping_math))
10950         {
10951           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
10952                ? integer_zero_node
10953                : integer_one_node;
10954           return omit_one_operand (type, t1, arg1);
10955         }
10956
10957       /* If the second operand is NaN, the result is constant.  */
10958       if (TREE_CODE (arg1) == REAL_CST
10959           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
10960           && (code != LTGT_EXPR || ! flag_trapping_math))
10961         {
10962           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
10963                ? integer_zero_node
10964                : integer_one_node;
10965           return omit_one_operand (type, t1, arg0);
10966         }
10967
10968       /* Simplify unordered comparison of something with itself.  */
10969       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
10970           && operand_equal_p (arg0, arg1, 0))
10971         return constant_boolean_node (1, type);
10972
10973       if (code == LTGT_EXPR
10974           && !flag_trapping_math
10975           && operand_equal_p (arg0, arg1, 0))
10976         return constant_boolean_node (0, type);
10977
10978       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
10979       {
10980         tree targ0 = strip_float_extensions (arg0);
10981         tree targ1 = strip_float_extensions (arg1);
10982         tree newtype = TREE_TYPE (targ0);
10983
10984         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
10985           newtype = TREE_TYPE (targ1);
10986
10987         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
10988           return fold_build2 (code, type, fold_convert (newtype, targ0),
10989                               fold_convert (newtype, targ1));
10990       }
10991
10992       return NULL_TREE;
10993
10994     case COMPOUND_EXPR:
10995       /* When pedantic, a compound expression can be neither an lvalue
10996          nor an integer constant expression.  */
10997       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
10998         return NULL_TREE;
10999       /* Don't let (0, 0) be null pointer constant.  */
11000       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11001                                  : fold_convert (type, arg1);
11002       return pedantic_non_lvalue (tem);
11003
11004     case COMPLEX_EXPR:
11005       if ((TREE_CODE (arg0) == REAL_CST
11006            && TREE_CODE (arg1) == REAL_CST)
11007           || (TREE_CODE (arg0) == INTEGER_CST
11008               && TREE_CODE (arg1) == INTEGER_CST))
11009         return build_complex (type, arg0, arg1);
11010       return NULL_TREE;
11011
11012     case ASSERT_EXPR:
11013       /* An ASSERT_EXPR should never be passed to fold_binary.  */
11014       gcc_unreachable ();
11015
11016     default:
11017       return NULL_TREE;
11018     } /* switch (code) */
11019 }
11020
11021 /* Callback for walk_tree, looking for LABEL_EXPR.
11022    Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
11023    Do not check the sub-tree of GOTO_EXPR.  */
11024
11025 static tree
11026 contains_label_1 (tree *tp,
11027                   int *walk_subtrees,
11028                   void *data ATTRIBUTE_UNUSED)
11029 {
11030   switch (TREE_CODE (*tp))
11031     {
11032     case LABEL_EXPR:
11033       return *tp;
11034     case GOTO_EXPR:
11035       *walk_subtrees = 0;
11036     /* no break */
11037     default:
11038       return NULL_TREE;
11039     }
11040 }
11041
11042 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
11043    accessible from outside the sub-tree. Returns NULL_TREE if no
11044    addressable label is found.  */
11045
11046 static bool
11047 contains_label_p (tree st)
11048 {
11049   return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
11050 }
11051
11052 /* Fold a ternary expression of code CODE and type TYPE with operands
11053    OP0, OP1, and OP2.  Return the folded expression if folding is
11054    successful.  Otherwise, return NULL_TREE.  */
11055
11056 tree
11057 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
11058 {
11059   tree tem;
11060   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
11061   enum tree_code_class kind = TREE_CODE_CLASS (code);
11062
11063   gcc_assert (IS_EXPR_CODE_CLASS (kind)
11064               && TREE_CODE_LENGTH (code) == 3);
11065
11066   /* Strip any conversions that don't change the mode.  This is safe
11067      for every expression, except for a comparison expression because
11068      its signedness is derived from its operands.  So, in the latter
11069      case, only strip conversions that don't change the signedness.
11070
11071      Note that this is done as an internal manipulation within the
11072      constant folder, in order to find the simplest representation of
11073      the arguments so that their form can be studied.  In any cases,
11074      the appropriate type conversions should be put back in the tree
11075      that will get out of the constant folder.  */
11076   if (op0)
11077     {
11078       arg0 = op0;
11079       STRIP_NOPS (arg0);
11080     }
11081
11082   if (op1)
11083     {
11084       arg1 = op1;
11085       STRIP_NOPS (arg1);
11086     }
11087
11088   switch (code)
11089     {
11090     case COMPONENT_REF:
11091       if (TREE_CODE (arg0) == CONSTRUCTOR
11092           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
11093         {
11094           unsigned HOST_WIDE_INT idx;
11095           tree field, value;
11096           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
11097             if (field == arg1)
11098               return value;
11099         }
11100       return NULL_TREE;
11101
11102     case COND_EXPR:
11103       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11104          so all simple results must be passed through pedantic_non_lvalue.  */
11105       if (TREE_CODE (arg0) == INTEGER_CST)
11106         {
11107           tree unused_op = integer_zerop (arg0) ? op1 : op2;
11108           tem = integer_zerop (arg0) ? op2 : op1;
11109           /* Only optimize constant conditions when the selected branch
11110              has the same type as the COND_EXPR.  This avoids optimizing
11111              away "c ? x : throw", where the throw has a void type.
11112              Avoid throwing away that operand which contains label.  */
11113           if ((!TREE_SIDE_EFFECTS (unused_op)
11114                || !contains_label_p (unused_op))
11115               && (! VOID_TYPE_P (TREE_TYPE (tem))
11116                   || VOID_TYPE_P (type)))
11117             return pedantic_non_lvalue (tem);
11118           return NULL_TREE;
11119         }
11120       if (operand_equal_p (arg1, op2, 0))
11121         return pedantic_omit_one_operand (type, arg1, arg0);
11122
11123       /* If we have A op B ? A : C, we may be able to convert this to a
11124          simpler expression, depending on the operation and the values
11125          of B and C.  Signed zeros prevent all of these transformations,
11126          for reasons given above each one.
11127
11128          Also try swapping the arguments and inverting the conditional.  */
11129       if (COMPARISON_CLASS_P (arg0)
11130           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11131                                              arg1, TREE_OPERAND (arg0, 1))
11132           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
11133         {
11134           tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
11135           if (tem)
11136             return tem;
11137         }
11138
11139       if (COMPARISON_CLASS_P (arg0)
11140           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11141                                              op2,
11142                                              TREE_OPERAND (arg0, 1))
11143           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
11144         {
11145           tem = fold_truth_not_expr (arg0);
11146           if (tem && COMPARISON_CLASS_P (tem))
11147             {
11148               tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
11149               if (tem)
11150                 return tem;
11151             }
11152         }
11153
11154       /* If the second operand is simpler than the third, swap them
11155          since that produces better jump optimization results.  */
11156       if (truth_value_p (TREE_CODE (arg0))
11157           && tree_swap_operands_p (op1, op2, false))
11158         {
11159           /* See if this can be inverted.  If it can't, possibly because
11160              it was a floating-point inequality comparison, don't do
11161              anything.  */
11162           tem = fold_truth_not_expr (arg0);
11163           if (tem)
11164             return fold_build3 (code, type, tem, op2, op1);
11165         }
11166
11167       /* Convert A ? 1 : 0 to simply A.  */
11168       if (integer_onep (op1)
11169           && integer_zerop (op2)
11170           /* If we try to convert OP0 to our type, the
11171              call to fold will try to move the conversion inside
11172              a COND, which will recurse.  In that case, the COND_EXPR
11173              is probably the best choice, so leave it alone.  */
11174           && type == TREE_TYPE (arg0))
11175         return pedantic_non_lvalue (arg0);
11176
11177       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
11178          over COND_EXPR in cases such as floating point comparisons.  */
11179       if (integer_zerop (op1)
11180           && integer_onep (op2)
11181           && truth_value_p (TREE_CODE (arg0)))
11182         return pedantic_non_lvalue (fold_convert (type,
11183                                                   invert_truthvalue (arg0)));
11184
11185       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
11186       if (TREE_CODE (arg0) == LT_EXPR
11187           && integer_zerop (TREE_OPERAND (arg0, 1))
11188           && integer_zerop (op2)
11189           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11190         return fold_convert (type,
11191                              fold_build2 (BIT_AND_EXPR,
11192                                           TREE_TYPE (tem), tem,
11193                                           fold_convert (TREE_TYPE (tem), arg1)));
11194
11195       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
11196          already handled above.  */
11197       if (TREE_CODE (arg0) == BIT_AND_EXPR
11198           && integer_onep (TREE_OPERAND (arg0, 1))
11199           && integer_zerop (op2)
11200           && integer_pow2p (arg1))
11201         {
11202           tree tem = TREE_OPERAND (arg0, 0);
11203           STRIP_NOPS (tem);
11204           if (TREE_CODE (tem) == RSHIFT_EXPR
11205               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
11206               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
11207                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
11208             return fold_build2 (BIT_AND_EXPR, type,
11209                                 TREE_OPERAND (tem, 0), arg1);
11210         }
11211
11212       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
11213          is probably obsolete because the first operand should be a
11214          truth value (that's why we have the two cases above), but let's
11215          leave it in until we can confirm this for all front-ends.  */
11216       if (integer_zerop (op2)
11217           && TREE_CODE (arg0) == NE_EXPR
11218           && integer_zerop (TREE_OPERAND (arg0, 1))
11219           && integer_pow2p (arg1)
11220           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
11221           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11222                               arg1, OEP_ONLY_CONST))
11223         return pedantic_non_lvalue (fold_convert (type,
11224                                                   TREE_OPERAND (arg0, 0)));
11225
11226       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
11227       if (integer_zerop (op2)
11228           && truth_value_p (TREE_CODE (arg0))
11229           && truth_value_p (TREE_CODE (arg1)))
11230         return fold_build2 (TRUTH_ANDIF_EXPR, type,
11231                             fold_convert (type, arg0),
11232                             arg1);
11233
11234       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
11235       if (integer_onep (op2)
11236           && truth_value_p (TREE_CODE (arg0))
11237           && truth_value_p (TREE_CODE (arg1)))
11238         {
11239           /* Only perform transformation if ARG0 is easily inverted.  */
11240           tem = fold_truth_not_expr (arg0);
11241           if (tem)
11242             return fold_build2 (TRUTH_ORIF_EXPR, type,
11243                                 fold_convert (type, tem),
11244                                 arg1);
11245         }
11246
11247       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
11248       if (integer_zerop (arg1)
11249           && truth_value_p (TREE_CODE (arg0))
11250           && truth_value_p (TREE_CODE (op2)))
11251         {
11252           /* Only perform transformation if ARG0 is easily inverted.  */
11253           tem = fold_truth_not_expr (arg0);
11254           if (tem)
11255             return fold_build2 (TRUTH_ANDIF_EXPR, type,
11256                                 fold_convert (type, tem),
11257                                 op2);
11258         }
11259
11260       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
11261       if (integer_onep (arg1)
11262           && truth_value_p (TREE_CODE (arg0))
11263           && truth_value_p (TREE_CODE (op2)))
11264         return fold_build2 (TRUTH_ORIF_EXPR, type,
11265                             fold_convert (type, arg0),
11266                             op2);
11267
11268       return NULL_TREE;
11269
11270     case CALL_EXPR:
11271       /* Check for a built-in function.  */
11272       if (TREE_CODE (op0) == ADDR_EXPR
11273           && TREE_CODE (TREE_OPERAND (op0, 0)) == FUNCTION_DECL
11274           && DECL_BUILT_IN (TREE_OPERAND (op0, 0)))
11275         return fold_builtin (TREE_OPERAND (op0, 0), op1, false);
11276       return NULL_TREE;
11277
11278     case BIT_FIELD_REF:
11279       if (TREE_CODE (arg0) == VECTOR_CST
11280           && type == TREE_TYPE (TREE_TYPE (arg0))
11281           && host_integerp (arg1, 1)
11282           && host_integerp (op2, 1))
11283         {
11284           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
11285           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
11286
11287           if (width != 0
11288               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
11289               && (idx % width) == 0
11290               && (idx = idx / width)
11291                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
11292             {
11293               tree elements = TREE_VECTOR_CST_ELTS (arg0);
11294               while (idx-- > 0 && elements)
11295                 elements = TREE_CHAIN (elements);
11296               if (elements)
11297                 return TREE_VALUE (elements);
11298               else
11299                 return fold_convert (type, integer_zero_node);
11300             }
11301         }
11302       return NULL_TREE;
11303
11304     default:
11305       return NULL_TREE;
11306     } /* switch (code) */
11307 }
11308
11309 /* Perform constant folding and related simplification of EXPR.
11310    The related simplifications include x*1 => x, x*0 => 0, etc.,
11311    and application of the associative law.
11312    NOP_EXPR conversions may be removed freely (as long as we
11313    are careful not to change the type of the overall expression).
11314    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11315    but we can constant-fold them if they have constant operands.  */
11316
11317 #ifdef ENABLE_FOLD_CHECKING
11318 # define fold(x) fold_1 (x)
11319 static tree fold_1 (tree);
11320 static
11321 #endif
11322 tree
11323 fold (tree expr)
11324 {
11325   const tree t = expr;
11326   enum tree_code code = TREE_CODE (t);
11327   enum tree_code_class kind = TREE_CODE_CLASS (code);
11328   tree tem;
11329
11330   /* Return right away if a constant.  */
11331   if (kind == tcc_constant)
11332     return t;
11333
11334   if (IS_EXPR_CODE_CLASS (kind))
11335     {
11336       tree type = TREE_TYPE (t);
11337       tree op0, op1, op2;
11338
11339       switch (TREE_CODE_LENGTH (code))
11340         {
11341         case 1:
11342           op0 = TREE_OPERAND (t, 0);
11343           tem = fold_unary (code, type, op0);
11344           return tem ? tem : expr;
11345         case 2:
11346           op0 = TREE_OPERAND (t, 0);
11347           op1 = TREE_OPERAND (t, 1);
11348           tem = fold_binary (code, type, op0, op1);
11349           return tem ? tem : expr;
11350         case 3:
11351           op0 = TREE_OPERAND (t, 0);
11352           op1 = TREE_OPERAND (t, 1);
11353           op2 = TREE_OPERAND (t, 2);
11354           tem = fold_ternary (code, type, op0, op1, op2);
11355           return tem ? tem : expr;
11356         default:
11357           break;
11358         }
11359     }
11360
11361   switch (code)
11362     {
11363     case CONST_DECL:
11364       return fold (DECL_INITIAL (t));
11365
11366     default:
11367       return t;
11368     } /* switch (code) */
11369 }
11370
11371 #ifdef ENABLE_FOLD_CHECKING
11372 #undef fold
11373
11374 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
11375 static void fold_check_failed (tree, tree);
11376 void print_fold_checksum (tree);
11377
11378 /* When --enable-checking=fold, compute a digest of expr before
11379    and after actual fold call to see if fold did not accidentally
11380    change original expr.  */
11381
11382 tree
11383 fold (tree expr)
11384 {
11385   tree ret;
11386   struct md5_ctx ctx;
11387   unsigned char checksum_before[16], checksum_after[16];
11388   htab_t ht;
11389
11390   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11391   md5_init_ctx (&ctx);
11392   fold_checksum_tree (expr, &ctx, ht);
11393   md5_finish_ctx (&ctx, checksum_before);
11394   htab_empty (ht);
11395
11396   ret = fold_1 (expr);
11397
11398   md5_init_ctx (&ctx);
11399   fold_checksum_tree (expr, &ctx, ht);
11400   md5_finish_ctx (&ctx, checksum_after);
11401   htab_delete (ht);
11402
11403   if (memcmp (checksum_before, checksum_after, 16))
11404     fold_check_failed (expr, ret);
11405
11406   return ret;
11407 }
11408
11409 void
11410 print_fold_checksum (tree expr)
11411 {
11412   struct md5_ctx ctx;
11413   unsigned char checksum[16], cnt;
11414   htab_t ht;
11415
11416   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11417   md5_init_ctx (&ctx);
11418   fold_checksum_tree (expr, &ctx, ht);
11419   md5_finish_ctx (&ctx, checksum);
11420   htab_delete (ht);
11421   for (cnt = 0; cnt < 16; ++cnt)
11422     fprintf (stderr, "%02x", checksum[cnt]);
11423   putc ('\n', stderr);
11424 }
11425
11426 static void
11427 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
11428 {
11429   internal_error ("fold check: original tree changed by fold");
11430 }
11431
11432 static void
11433 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
11434 {
11435   void **slot;
11436   enum tree_code code;
11437   struct tree_function_decl buf;
11438   int i, len;
11439
11440 recursive_label:
11441
11442   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
11443                <= sizeof (struct tree_function_decl))
11444               && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
11445   if (expr == NULL)
11446     return;
11447   slot = htab_find_slot (ht, expr, INSERT);
11448   if (*slot != NULL)
11449     return;
11450   *slot = expr;
11451   code = TREE_CODE (expr);
11452   if (TREE_CODE_CLASS (code) == tcc_declaration
11453       && DECL_ASSEMBLER_NAME_SET_P (expr))
11454     {
11455       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
11456       memcpy ((char *) &buf, expr, tree_size (expr));
11457       expr = (tree) &buf;
11458       SET_DECL_ASSEMBLER_NAME (expr, NULL);
11459     }
11460   else if (TREE_CODE_CLASS (code) == tcc_type
11461            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
11462                || TYPE_CACHED_VALUES_P (expr)
11463                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)))
11464     {
11465       /* Allow these fields to be modified.  */
11466       memcpy ((char *) &buf, expr, tree_size (expr));
11467       expr = (tree) &buf;
11468       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr) = 0;
11469       TYPE_POINTER_TO (expr) = NULL;
11470       TYPE_REFERENCE_TO (expr) = NULL;
11471       if (TYPE_CACHED_VALUES_P (expr))
11472         {
11473           TYPE_CACHED_VALUES_P (expr) = 0;
11474           TYPE_CACHED_VALUES (expr) = NULL;
11475         }
11476     }
11477   md5_process_bytes (expr, tree_size (expr), ctx);
11478   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
11479   if (TREE_CODE_CLASS (code) != tcc_type
11480       && TREE_CODE_CLASS (code) != tcc_declaration
11481       && code != TREE_LIST)
11482     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
11483   switch (TREE_CODE_CLASS (code))
11484     {
11485     case tcc_constant:
11486       switch (code)
11487         {
11488         case STRING_CST:
11489           md5_process_bytes (TREE_STRING_POINTER (expr),
11490                              TREE_STRING_LENGTH (expr), ctx);
11491           break;
11492         case COMPLEX_CST:
11493           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
11494           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
11495           break;
11496         case VECTOR_CST:
11497           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
11498           break;
11499         default:
11500           break;
11501         }
11502       break;
11503     case tcc_exceptional:
11504       switch (code)
11505         {
11506         case TREE_LIST:
11507           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
11508           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
11509           expr = TREE_CHAIN (expr);
11510           goto recursive_label;
11511           break;
11512         case TREE_VEC:
11513           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
11514             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
11515           break;
11516         default:
11517           break;
11518         }
11519       break;
11520     case tcc_expression:
11521     case tcc_reference:
11522     case tcc_comparison:
11523     case tcc_unary:
11524     case tcc_binary:
11525     case tcc_statement:
11526       len = TREE_CODE_LENGTH (code);
11527       for (i = 0; i < len; ++i)
11528         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
11529       break;
11530     case tcc_declaration:
11531       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
11532       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
11533       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
11534         {
11535           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
11536           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
11537           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
11538           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
11539           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
11540         }
11541       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
11542         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
11543
11544       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
11545         {
11546           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
11547           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
11548           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
11549         }
11550       break;
11551     case tcc_type:
11552       if (TREE_CODE (expr) == ENUMERAL_TYPE)
11553         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
11554       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
11555       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
11556       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
11557       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
11558       if (INTEGRAL_TYPE_P (expr)
11559           || SCALAR_FLOAT_TYPE_P (expr))
11560         {
11561           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
11562           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
11563         }
11564       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
11565       if (TREE_CODE (expr) == RECORD_TYPE
11566           || TREE_CODE (expr) == UNION_TYPE
11567           || TREE_CODE (expr) == QUAL_UNION_TYPE)
11568         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
11569       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
11570       break;
11571     default:
11572       break;
11573     }
11574 }
11575
11576 #endif
11577
11578 /* Fold a unary tree expression with code CODE of type TYPE with an
11579    operand OP0.  Return a folded expression if successful.  Otherwise,
11580    return a tree expression with code CODE of type TYPE with an
11581    operand OP0.  */
11582
11583 tree
11584 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
11585 {
11586   tree tem;
11587 #ifdef ENABLE_FOLD_CHECKING
11588   unsigned char checksum_before[16], checksum_after[16];
11589   struct md5_ctx ctx;
11590   htab_t ht;
11591
11592   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11593   md5_init_ctx (&ctx);
11594   fold_checksum_tree (op0, &ctx, ht);
11595   md5_finish_ctx (&ctx, checksum_before);
11596   htab_empty (ht);
11597 #endif
11598
11599   tem = fold_unary (code, type, op0);
11600   if (!tem)
11601     tem = build1_stat (code, type, op0 PASS_MEM_STAT);
11602
11603 #ifdef ENABLE_FOLD_CHECKING
11604   md5_init_ctx (&ctx);
11605   fold_checksum_tree (op0, &ctx, ht);
11606   md5_finish_ctx (&ctx, checksum_after);
11607   htab_delete (ht);
11608
11609   if (memcmp (checksum_before, checksum_after, 16))
11610     fold_check_failed (op0, tem);
11611 #endif
11612   return tem;
11613 }
11614
11615 /* Fold a binary tree expression with code CODE of type TYPE with
11616    operands OP0 and OP1.  Return a folded expression if successful.
11617    Otherwise, return a tree expression with code CODE of type TYPE
11618    with operands OP0 and OP1.  */
11619
11620 tree
11621 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
11622                   MEM_STAT_DECL)
11623 {
11624   tree tem;
11625 #ifdef ENABLE_FOLD_CHECKING
11626   unsigned char checksum_before_op0[16],
11627                 checksum_before_op1[16],
11628                 checksum_after_op0[16],
11629                 checksum_after_op1[16];
11630   struct md5_ctx ctx;
11631   htab_t ht;
11632
11633   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11634   md5_init_ctx (&ctx);
11635   fold_checksum_tree (op0, &ctx, ht);
11636   md5_finish_ctx (&ctx, checksum_before_op0);
11637   htab_empty (ht);
11638
11639   md5_init_ctx (&ctx);
11640   fold_checksum_tree (op1, &ctx, ht);
11641   md5_finish_ctx (&ctx, checksum_before_op1);
11642   htab_empty (ht);
11643 #endif
11644
11645   tem = fold_binary (code, type, op0, op1);
11646   if (!tem)
11647     tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
11648
11649 #ifdef ENABLE_FOLD_CHECKING
11650   md5_init_ctx (&ctx);
11651   fold_checksum_tree (op0, &ctx, ht);
11652   md5_finish_ctx (&ctx, checksum_after_op0);
11653   htab_empty (ht);
11654
11655   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
11656     fold_check_failed (op0, tem);
11657
11658   md5_init_ctx (&ctx);
11659   fold_checksum_tree (op1, &ctx, ht);
11660   md5_finish_ctx (&ctx, checksum_after_op1);
11661   htab_delete (ht);
11662
11663   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
11664     fold_check_failed (op1, tem);
11665 #endif
11666   return tem;
11667 }
11668
11669 /* Fold a ternary tree expression with code CODE of type TYPE with
11670    operands OP0, OP1, and OP2.  Return a folded expression if
11671    successful.  Otherwise, return a tree expression with code CODE of
11672    type TYPE with operands OP0, OP1, and OP2.  */
11673
11674 tree
11675 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
11676              MEM_STAT_DECL)
11677 {
11678   tree tem;
11679 #ifdef ENABLE_FOLD_CHECKING
11680   unsigned char checksum_before_op0[16],
11681                 checksum_before_op1[16],
11682                 checksum_before_op2[16],
11683                 checksum_after_op0[16],
11684                 checksum_after_op1[16],
11685                 checksum_after_op2[16];
11686   struct md5_ctx ctx;
11687   htab_t ht;
11688
11689   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11690   md5_init_ctx (&ctx);
11691   fold_checksum_tree (op0, &ctx, ht);
11692   md5_finish_ctx (&ctx, checksum_before_op0);
11693   htab_empty (ht);
11694
11695   md5_init_ctx (&ctx);
11696   fold_checksum_tree (op1, &ctx, ht);
11697   md5_finish_ctx (&ctx, checksum_before_op1);
11698   htab_empty (ht);
11699
11700   md5_init_ctx (&ctx);
11701   fold_checksum_tree (op2, &ctx, ht);
11702   md5_finish_ctx (&ctx, checksum_before_op2);
11703   htab_empty (ht);
11704 #endif
11705
11706   tem = fold_ternary (code, type, op0, op1, op2);
11707   if (!tem)
11708     tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
11709
11710 #ifdef ENABLE_FOLD_CHECKING
11711   md5_init_ctx (&ctx);
11712   fold_checksum_tree (op0, &ctx, ht);
11713   md5_finish_ctx (&ctx, checksum_after_op0);
11714   htab_empty (ht);
11715
11716   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
11717     fold_check_failed (op0, tem);
11718
11719   md5_init_ctx (&ctx);
11720   fold_checksum_tree (op1, &ctx, ht);
11721   md5_finish_ctx (&ctx, checksum_after_op1);
11722   htab_empty (ht);
11723
11724   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
11725     fold_check_failed (op1, tem);
11726
11727   md5_init_ctx (&ctx);
11728   fold_checksum_tree (op2, &ctx, ht);
11729   md5_finish_ctx (&ctx, checksum_after_op2);
11730   htab_delete (ht);
11731
11732   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
11733     fold_check_failed (op2, tem);
11734 #endif
11735   return tem;
11736 }
11737
11738 /* Perform constant folding and related simplification of initializer
11739    expression EXPR.  These behave identically to "fold_buildN" but ignore
11740    potential run-time traps and exceptions that fold must preserve.  */
11741
11742 #define START_FOLD_INIT \
11743   int saved_signaling_nans = flag_signaling_nans;\
11744   int saved_trapping_math = flag_trapping_math;\
11745   int saved_rounding_math = flag_rounding_math;\
11746   int saved_trapv = flag_trapv;\
11747   int saved_folding_initializer = folding_initializer;\
11748   flag_signaling_nans = 0;\
11749   flag_trapping_math = 0;\
11750   flag_rounding_math = 0;\
11751   flag_trapv = 0;\
11752   folding_initializer = 1;
11753
11754 #define END_FOLD_INIT \
11755   flag_signaling_nans = saved_signaling_nans;\
11756   flag_trapping_math = saved_trapping_math;\
11757   flag_rounding_math = saved_rounding_math;\
11758   flag_trapv = saved_trapv;\
11759   folding_initializer = saved_folding_initializer;
11760
11761 tree
11762 fold_build1_initializer (enum tree_code code, tree type, tree op)
11763 {
11764   tree result;
11765   START_FOLD_INIT;
11766
11767   result = fold_build1 (code, type, op);
11768
11769   END_FOLD_INIT;
11770   return result;
11771 }
11772
11773 tree
11774 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
11775 {
11776   tree result;
11777   START_FOLD_INIT;
11778
11779   result = fold_build2 (code, type, op0, op1);
11780
11781   END_FOLD_INIT;
11782   return result;
11783 }
11784
11785 tree
11786 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
11787                          tree op2)
11788 {
11789   tree result;
11790   START_FOLD_INIT;
11791
11792   result = fold_build3 (code, type, op0, op1, op2);
11793
11794   END_FOLD_INIT;
11795   return result;
11796 }
11797
11798 #undef START_FOLD_INIT
11799 #undef END_FOLD_INIT
11800
11801 /* Determine if first argument is a multiple of second argument.  Return 0 if
11802    it is not, or we cannot easily determined it to be.
11803
11804    An example of the sort of thing we care about (at this point; this routine
11805    could surely be made more general, and expanded to do what the *_DIV_EXPR's
11806    fold cases do now) is discovering that
11807
11808      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
11809
11810    is a multiple of
11811
11812      SAVE_EXPR (J * 8)
11813
11814    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
11815
11816    This code also handles discovering that
11817
11818      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
11819
11820    is a multiple of 8 so we don't have to worry about dealing with a
11821    possible remainder.
11822
11823    Note that we *look* inside a SAVE_EXPR only to determine how it was
11824    calculated; it is not safe for fold to do much of anything else with the
11825    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
11826    at run time.  For example, the latter example above *cannot* be implemented
11827    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
11828    evaluation time of the original SAVE_EXPR is not necessarily the same at
11829    the time the new expression is evaluated.  The only optimization of this
11830    sort that would be valid is changing
11831
11832      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
11833
11834    divided by 8 to
11835
11836      SAVE_EXPR (I) * SAVE_EXPR (J)
11837
11838    (where the same SAVE_EXPR (J) is used in the original and the
11839    transformed version).  */
11840
11841 static int
11842 multiple_of_p (tree type, tree top, tree bottom)
11843 {
11844   if (operand_equal_p (top, bottom, 0))
11845     return 1;
11846
11847   if (TREE_CODE (type) != INTEGER_TYPE)
11848     return 0;
11849
11850   switch (TREE_CODE (top))
11851     {
11852     case BIT_AND_EXPR:
11853       /* Bitwise and provides a power of two multiple.  If the mask is
11854          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
11855       if (!integer_pow2p (bottom))
11856         return 0;
11857       /* FALLTHRU */
11858
11859     case MULT_EXPR:
11860       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
11861               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
11862
11863     case PLUS_EXPR:
11864     case MINUS_EXPR:
11865       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
11866               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
11867
11868     case LSHIFT_EXPR:
11869       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
11870         {
11871           tree op1, t1;
11872
11873           op1 = TREE_OPERAND (top, 1);
11874           /* const_binop may not detect overflow correctly,
11875              so check for it explicitly here.  */
11876           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
11877               > TREE_INT_CST_LOW (op1)
11878               && TREE_INT_CST_HIGH (op1) == 0
11879               && 0 != (t1 = fold_convert (type,
11880                                           const_binop (LSHIFT_EXPR,
11881                                                        size_one_node,
11882                                                        op1, 0)))
11883               && ! TREE_OVERFLOW (t1))
11884             return multiple_of_p (type, t1, bottom);
11885         }
11886       return 0;
11887
11888     case NOP_EXPR:
11889       /* Can't handle conversions from non-integral or wider integral type.  */
11890       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
11891           || (TYPE_PRECISION (type)
11892               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
11893         return 0;
11894
11895       /* .. fall through ...  */
11896
11897     case SAVE_EXPR:
11898       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
11899
11900     case INTEGER_CST:
11901       if (TREE_CODE (bottom) != INTEGER_CST
11902           || (TYPE_UNSIGNED (type)
11903               && (tree_int_cst_sgn (top) < 0
11904                   || tree_int_cst_sgn (bottom) < 0)))
11905         return 0;
11906       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
11907                                          top, bottom, 0));
11908
11909     default:
11910       return 0;
11911     }
11912 }
11913
11914 /* Return true if `t' is known to be non-negative.  */
11915
11916 int
11917 tree_expr_nonnegative_p (tree t)
11918 {
11919   if (t == error_mark_node)
11920     return 0;
11921
11922   if (TYPE_UNSIGNED (TREE_TYPE (t)))
11923     return 1;
11924
11925   switch (TREE_CODE (t))
11926     {
11927     case SSA_NAME:
11928       /* Query VRP to see if it has recorded any information about
11929          the range of this object.  */
11930       return ssa_name_nonnegative_p (t);
11931
11932     case ABS_EXPR:
11933       /* We can't return 1 if flag_wrapv is set because
11934          ABS_EXPR<INT_MIN> = INT_MIN.  */
11935       if (!(flag_wrapv && INTEGRAL_TYPE_P (TREE_TYPE (t))))
11936         return 1;
11937       break;
11938
11939     case INTEGER_CST:
11940       return tree_int_cst_sgn (t) >= 0;
11941
11942     case REAL_CST:
11943       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
11944
11945     case PLUS_EXPR:
11946       if (FLOAT_TYPE_P (TREE_TYPE (t)))
11947         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
11948                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
11949
11950       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
11951          both unsigned and at least 2 bits shorter than the result.  */
11952       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
11953           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
11954           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
11955         {
11956           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
11957           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
11958           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
11959               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
11960             {
11961               unsigned int prec = MAX (TYPE_PRECISION (inner1),
11962                                        TYPE_PRECISION (inner2)) + 1;
11963               return prec < TYPE_PRECISION (TREE_TYPE (t));
11964             }
11965         }
11966       break;
11967
11968     case MULT_EXPR:
11969       if (FLOAT_TYPE_P (TREE_TYPE (t)))
11970         {
11971           /* x * x for floating point x is always non-negative.  */
11972           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
11973             return 1;
11974           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
11975                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
11976         }
11977
11978       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
11979          both unsigned and their total bits is shorter than the result.  */
11980       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
11981           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
11982           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
11983         {
11984           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
11985           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
11986           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
11987               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
11988             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
11989                    < TYPE_PRECISION (TREE_TYPE (t));
11990         }
11991       return 0;
11992
11993     case BIT_AND_EXPR:
11994     case MAX_EXPR:
11995       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
11996              || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
11997
11998     case BIT_IOR_EXPR:
11999     case BIT_XOR_EXPR:
12000     case MIN_EXPR:
12001     case RDIV_EXPR:
12002     case TRUNC_DIV_EXPR:
12003     case CEIL_DIV_EXPR:
12004     case FLOOR_DIV_EXPR:
12005     case ROUND_DIV_EXPR:
12006       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12007              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12008
12009     case TRUNC_MOD_EXPR:
12010     case CEIL_MOD_EXPR:
12011     case FLOOR_MOD_EXPR:
12012     case ROUND_MOD_EXPR:
12013     case SAVE_EXPR:
12014     case NON_LVALUE_EXPR:
12015     case FLOAT_EXPR:
12016       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12017
12018     case COMPOUND_EXPR:
12019     case MODIFY_EXPR:
12020       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12021
12022     case BIND_EXPR:
12023       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
12024
12025     case COND_EXPR:
12026       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
12027              && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
12028
12029     case NOP_EXPR:
12030       {
12031         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12032         tree outer_type = TREE_TYPE (t);
12033
12034         if (TREE_CODE (outer_type) == REAL_TYPE)
12035           {
12036             if (TREE_CODE (inner_type) == REAL_TYPE)
12037               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12038             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12039               {
12040                 if (TYPE_UNSIGNED (inner_type))
12041                   return 1;
12042                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12043               }
12044           }
12045         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
12046           {
12047             if (TREE_CODE (inner_type) == REAL_TYPE)
12048               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
12049             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12050               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
12051                       && TYPE_UNSIGNED (inner_type);
12052           }
12053       }
12054       break;
12055
12056     case TARGET_EXPR:
12057       {
12058         tree temp = TARGET_EXPR_SLOT (t);
12059         t = TARGET_EXPR_INITIAL (t);
12060
12061         /* If the initializer is non-void, then it's a normal expression
12062            that will be assigned to the slot.  */
12063         if (!VOID_TYPE_P (t))
12064           return tree_expr_nonnegative_p (t);
12065
12066         /* Otherwise, the initializer sets the slot in some way.  One common
12067            way is an assignment statement at the end of the initializer.  */
12068         while (1)
12069           {
12070             if (TREE_CODE (t) == BIND_EXPR)
12071               t = expr_last (BIND_EXPR_BODY (t));
12072             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
12073                      || TREE_CODE (t) == TRY_CATCH_EXPR)
12074               t = expr_last (TREE_OPERAND (t, 0));
12075             else if (TREE_CODE (t) == STATEMENT_LIST)
12076               t = expr_last (t);
12077             else
12078               break;
12079           }
12080         if (TREE_CODE (t) == MODIFY_EXPR
12081             && TREE_OPERAND (t, 0) == temp)
12082           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12083
12084         return 0;
12085       }
12086
12087     case CALL_EXPR:
12088       {
12089         tree fndecl = get_callee_fndecl (t);
12090         tree arglist = TREE_OPERAND (t, 1);
12091         if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
12092           switch (DECL_FUNCTION_CODE (fndecl))
12093             {
12094             CASE_FLT_FN (BUILT_IN_ACOS):
12095             CASE_FLT_FN (BUILT_IN_ACOSH):
12096             CASE_FLT_FN (BUILT_IN_CABS):
12097             CASE_FLT_FN (BUILT_IN_COSH):
12098             CASE_FLT_FN (BUILT_IN_ERFC):
12099             CASE_FLT_FN (BUILT_IN_EXP):
12100             CASE_FLT_FN (BUILT_IN_EXP10):
12101             CASE_FLT_FN (BUILT_IN_EXP2):
12102             CASE_FLT_FN (BUILT_IN_FABS):
12103             CASE_FLT_FN (BUILT_IN_FDIM):
12104             CASE_FLT_FN (BUILT_IN_HYPOT):
12105             CASE_FLT_FN (BUILT_IN_POW10):
12106             CASE_INT_FN (BUILT_IN_FFS):
12107             CASE_INT_FN (BUILT_IN_PARITY):
12108             CASE_INT_FN (BUILT_IN_POPCOUNT):
12109               /* Always true.  */
12110               return 1;
12111
12112             CASE_FLT_FN (BUILT_IN_SQRT):
12113               /* sqrt(-0.0) is -0.0.  */
12114               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
12115                 return 1;
12116               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
12117
12118             CASE_FLT_FN (BUILT_IN_ASINH):
12119             CASE_FLT_FN (BUILT_IN_ATAN):
12120             CASE_FLT_FN (BUILT_IN_ATANH):
12121             CASE_FLT_FN (BUILT_IN_CBRT):
12122             CASE_FLT_FN (BUILT_IN_CEIL):
12123             CASE_FLT_FN (BUILT_IN_ERF):
12124             CASE_FLT_FN (BUILT_IN_EXPM1):
12125             CASE_FLT_FN (BUILT_IN_FLOOR):
12126             CASE_FLT_FN (BUILT_IN_FMOD):
12127             CASE_FLT_FN (BUILT_IN_FREXP):
12128             CASE_FLT_FN (BUILT_IN_LCEIL):
12129             CASE_FLT_FN (BUILT_IN_LDEXP):
12130             CASE_FLT_FN (BUILT_IN_LFLOOR):
12131             CASE_FLT_FN (BUILT_IN_LLCEIL):
12132             CASE_FLT_FN (BUILT_IN_LLFLOOR):
12133             CASE_FLT_FN (BUILT_IN_LLRINT):
12134             CASE_FLT_FN (BUILT_IN_LLROUND):
12135             CASE_FLT_FN (BUILT_IN_LRINT):
12136             CASE_FLT_FN (BUILT_IN_LROUND):
12137             CASE_FLT_FN (BUILT_IN_MODF):
12138             CASE_FLT_FN (BUILT_IN_NEARBYINT):
12139             CASE_FLT_FN (BUILT_IN_POW):
12140             CASE_FLT_FN (BUILT_IN_RINT):
12141             CASE_FLT_FN (BUILT_IN_ROUND):
12142             CASE_FLT_FN (BUILT_IN_SIGNBIT):
12143             CASE_FLT_FN (BUILT_IN_SINH):
12144             CASE_FLT_FN (BUILT_IN_TANH):
12145             CASE_FLT_FN (BUILT_IN_TRUNC):
12146               /* True if the 1st argument is nonnegative.  */
12147               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
12148
12149             CASE_FLT_FN (BUILT_IN_FMAX):
12150               /* True if the 1st OR 2nd arguments are nonnegative.  */
12151               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
12152                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12153
12154             CASE_FLT_FN (BUILT_IN_FMIN):
12155               /* True if the 1st AND 2nd arguments are nonnegative.  */
12156               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
12157                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12158
12159             CASE_FLT_FN (BUILT_IN_COPYSIGN):
12160               /* True if the 2nd argument is nonnegative.  */
12161               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12162
12163             default:
12164               break;
12165             }
12166       }
12167
12168       /* ... fall through ...  */
12169
12170     default:
12171       if (truth_value_p (TREE_CODE (t)))
12172         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
12173         return 1;
12174     }
12175
12176   /* We don't know sign of `t', so be conservative and return false.  */
12177   return 0;
12178 }
12179
12180 /* Return true when T is an address and is known to be nonzero.
12181    For floating point we further ensure that T is not denormal.
12182    Similar logic is present in nonzero_address in rtlanal.h.  */
12183
12184 bool
12185 tree_expr_nonzero_p (tree t)
12186 {
12187   tree type = TREE_TYPE (t);
12188
12189   /* Doing something useful for floating point would need more work.  */
12190   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
12191     return false;
12192
12193   switch (TREE_CODE (t))
12194     {
12195     case SSA_NAME:
12196       /* Query VRP to see if it has recorded any information about
12197          the range of this object.  */
12198       return ssa_name_nonzero_p (t);
12199
12200     case ABS_EXPR:
12201       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12202
12203     case INTEGER_CST:
12204       /* We used to test for !integer_zerop here.  This does not work correctly
12205          if TREE_CONSTANT_OVERFLOW (t).  */
12206       return (TREE_INT_CST_LOW (t) != 0
12207               || TREE_INT_CST_HIGH (t) != 0);
12208
12209     case PLUS_EXPR:
12210       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
12211         {
12212           /* With the presence of negative values it is hard
12213              to say something.  */
12214           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12215               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
12216             return false;
12217           /* One of operands must be positive and the other non-negative.  */
12218           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12219                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12220         }
12221       break;
12222
12223     case MULT_EXPR:
12224       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
12225         {
12226           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12227                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12228         }
12229       break;
12230
12231     case NOP_EXPR:
12232       {
12233         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12234         tree outer_type = TREE_TYPE (t);
12235
12236         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
12237                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
12238       }
12239       break;
12240
12241    case ADDR_EXPR:
12242       {
12243         tree base = get_base_address (TREE_OPERAND (t, 0));
12244
12245         if (!base)
12246           return false;
12247
12248         /* Weak declarations may link to NULL.  */
12249         if (VAR_OR_FUNCTION_DECL_P (base))
12250           return !DECL_WEAK (base);
12251
12252         /* Constants are never weak.  */
12253         if (CONSTANT_CLASS_P (base))
12254           return true;
12255
12256         return false;
12257       }
12258
12259     case COND_EXPR:
12260       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12261               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
12262
12263     case MIN_EXPR:
12264       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12265               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12266
12267     case MAX_EXPR:
12268       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
12269         {
12270           /* When both operands are nonzero, then MAX must be too.  */
12271           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
12272             return true;
12273
12274           /* MAX where operand 0 is positive is positive.  */
12275           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12276         }
12277       /* MAX where operand 1 is positive is positive.  */
12278       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12279                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
12280         return true;
12281       break;
12282
12283     case COMPOUND_EXPR:
12284     case MODIFY_EXPR:
12285     case BIND_EXPR:
12286       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
12287
12288     case SAVE_EXPR:
12289     case NON_LVALUE_EXPR:
12290       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12291
12292     case BIT_IOR_EXPR:
12293       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12294              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12295
12296     case CALL_EXPR:
12297       return alloca_call_p (t);
12298
12299     default:
12300       break;
12301     }
12302   return false;
12303 }
12304
12305 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
12306    attempt to fold the expression to a constant without modifying TYPE,
12307    OP0 or OP1.
12308
12309    If the expression could be simplified to a constant, then return
12310    the constant.  If the expression would not be simplified to a
12311    constant, then return NULL_TREE.  */
12312
12313 tree
12314 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
12315 {
12316   tree tem = fold_binary (code, type, op0, op1);
12317   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12318 }
12319
12320 /* Given the components of a unary expression CODE, TYPE and OP0,
12321    attempt to fold the expression to a constant without modifying
12322    TYPE or OP0.
12323
12324    If the expression could be simplified to a constant, then return
12325    the constant.  If the expression would not be simplified to a
12326    constant, then return NULL_TREE.  */
12327
12328 tree
12329 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
12330 {
12331   tree tem = fold_unary (code, type, op0);
12332   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12333 }
12334
12335 /* If EXP represents referencing an element in a constant string
12336    (either via pointer arithmetic or array indexing), return the
12337    tree representing the value accessed, otherwise return NULL.  */
12338
12339 tree
12340 fold_read_from_constant_string (tree exp)
12341 {
12342   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
12343     {
12344       tree exp1 = TREE_OPERAND (exp, 0);
12345       tree index;
12346       tree string;
12347
12348       if (TREE_CODE (exp) == INDIRECT_REF)
12349         string = string_constant (exp1, &index);
12350       else
12351         {
12352           tree low_bound = array_ref_low_bound (exp);
12353           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
12354
12355           /* Optimize the special-case of a zero lower bound.
12356
12357              We convert the low_bound to sizetype to avoid some problems
12358              with constant folding.  (E.g. suppose the lower bound is 1,
12359              and its mode is QI.  Without the conversion,l (ARRAY
12360              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
12361              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
12362           if (! integer_zerop (low_bound))
12363             index = size_diffop (index, fold_convert (sizetype, low_bound));
12364
12365           string = exp1;
12366         }
12367
12368       if (string
12369           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
12370           && TREE_CODE (string) == STRING_CST
12371           && TREE_CODE (index) == INTEGER_CST
12372           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
12373           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
12374               == MODE_INT)
12375           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
12376         return fold_convert (TREE_TYPE (exp),
12377                              build_int_cst (NULL_TREE,
12378                                             (TREE_STRING_POINTER (string)
12379                                              [TREE_INT_CST_LOW (index)])));
12380     }
12381   return NULL;
12382 }
12383
12384 /* Return the tree for neg (ARG0) when ARG0 is known to be either
12385    an integer constant or real constant.
12386
12387    TYPE is the type of the result.  */
12388
12389 static tree
12390 fold_negate_const (tree arg0, tree type)
12391 {
12392   tree t = NULL_TREE;
12393
12394   switch (TREE_CODE (arg0))
12395     {
12396     case INTEGER_CST:
12397       {
12398         unsigned HOST_WIDE_INT low;
12399         HOST_WIDE_INT high;
12400         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
12401                                    TREE_INT_CST_HIGH (arg0),
12402                                    &low, &high);
12403         t = build_int_cst_wide (type, low, high);
12404         t = force_fit_type (t, 1,
12405                             (overflow | TREE_OVERFLOW (arg0))
12406                             && !TYPE_UNSIGNED (type),
12407                             TREE_CONSTANT_OVERFLOW (arg0));
12408         break;
12409       }
12410
12411     case REAL_CST:
12412       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
12413       break;
12414
12415     default:
12416       gcc_unreachable ();
12417     }
12418
12419   return t;
12420 }
12421
12422 /* Return the tree for abs (ARG0) when ARG0 is known to be either
12423    an integer constant or real constant.
12424
12425    TYPE is the type of the result.  */
12426
12427 tree
12428 fold_abs_const (tree arg0, tree type)
12429 {
12430   tree t = NULL_TREE;
12431
12432   switch (TREE_CODE (arg0))
12433     {
12434     case INTEGER_CST:
12435       /* If the value is unsigned, then the absolute value is
12436          the same as the ordinary value.  */
12437       if (TYPE_UNSIGNED (type))
12438         t = arg0;
12439       /* Similarly, if the value is non-negative.  */
12440       else if (INT_CST_LT (integer_minus_one_node, arg0))
12441         t = arg0;
12442       /* If the value is negative, then the absolute value is
12443          its negation.  */
12444       else
12445         {
12446           unsigned HOST_WIDE_INT low;
12447           HOST_WIDE_INT high;
12448           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
12449                                      TREE_INT_CST_HIGH (arg0),
12450                                      &low, &high);
12451           t = build_int_cst_wide (type, low, high);
12452           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
12453                               TREE_CONSTANT_OVERFLOW (arg0));
12454         }
12455       break;
12456
12457     case REAL_CST:
12458       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
12459         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
12460       else
12461         t =  arg0;
12462       break;
12463
12464     default:
12465       gcc_unreachable ();
12466     }
12467
12468   return t;
12469 }
12470
12471 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
12472    constant.  TYPE is the type of the result.  */
12473
12474 static tree
12475 fold_not_const (tree arg0, tree type)
12476 {
12477   tree t = NULL_TREE;
12478
12479   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
12480
12481   t = build_int_cst_wide (type,
12482                           ~ TREE_INT_CST_LOW (arg0),
12483                           ~ TREE_INT_CST_HIGH (arg0));
12484   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
12485                       TREE_CONSTANT_OVERFLOW (arg0));
12486
12487   return t;
12488 }
12489
12490 /* Given CODE, a relational operator, the target type, TYPE and two
12491    constant operands OP0 and OP1, return the result of the
12492    relational operation.  If the result is not a compile time
12493    constant, then return NULL_TREE.  */
12494
12495 static tree
12496 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
12497 {
12498   int result, invert;
12499
12500   /* From here on, the only cases we handle are when the result is
12501      known to be a constant.  */
12502
12503   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
12504     {
12505       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
12506       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
12507
12508       /* Handle the cases where either operand is a NaN.  */
12509       if (real_isnan (c0) || real_isnan (c1))
12510         {
12511           switch (code)
12512             {
12513             case EQ_EXPR:
12514             case ORDERED_EXPR:
12515               result = 0;
12516               break;
12517
12518             case NE_EXPR:
12519             case UNORDERED_EXPR:
12520             case UNLT_EXPR:
12521             case UNLE_EXPR:
12522             case UNGT_EXPR:
12523             case UNGE_EXPR:
12524             case UNEQ_EXPR:
12525               result = 1;
12526               break;
12527
12528             case LT_EXPR:
12529             case LE_EXPR:
12530             case GT_EXPR:
12531             case GE_EXPR:
12532             case LTGT_EXPR:
12533               if (flag_trapping_math)
12534                 return NULL_TREE;
12535               result = 0;
12536               break;
12537
12538             default:
12539               gcc_unreachable ();
12540             }
12541
12542           return constant_boolean_node (result, type);
12543         }
12544
12545       return constant_boolean_node (real_compare (code, c0, c1), type);
12546     }
12547
12548   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
12549
12550      To compute GT, swap the arguments and do LT.
12551      To compute GE, do LT and invert the result.
12552      To compute LE, swap the arguments, do LT and invert the result.
12553      To compute NE, do EQ and invert the result.
12554
12555      Therefore, the code below must handle only EQ and LT.  */
12556
12557   if (code == LE_EXPR || code == GT_EXPR)
12558     {
12559       tree tem = op0;
12560       op0 = op1;
12561       op1 = tem;
12562       code = swap_tree_comparison (code);
12563     }
12564
12565   /* Note that it is safe to invert for real values here because we
12566      have already handled the one case that it matters.  */
12567
12568   invert = 0;
12569   if (code == NE_EXPR || code == GE_EXPR)
12570     {
12571       invert = 1;
12572       code = invert_tree_comparison (code, false);
12573     }
12574
12575   /* Compute a result for LT or EQ if args permit;
12576      Otherwise return T.  */
12577   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
12578     {
12579       if (code == EQ_EXPR)
12580         result = tree_int_cst_equal (op0, op1);
12581       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
12582         result = INT_CST_LT_UNSIGNED (op0, op1);
12583       else
12584         result = INT_CST_LT (op0, op1);
12585     }
12586   else
12587     return NULL_TREE;
12588
12589   if (invert)
12590     result ^= 1;
12591   return constant_boolean_node (result, type);
12592 }
12593
12594 /* Build an expression for the a clean point containing EXPR with type TYPE.
12595    Don't build a cleanup point expression for EXPR which don't have side
12596    effects.  */
12597
12598 tree
12599 fold_build_cleanup_point_expr (tree type, tree expr)
12600 {
12601   /* If the expression does not have side effects then we don't have to wrap
12602      it with a cleanup point expression.  */
12603   if (!TREE_SIDE_EFFECTS (expr))
12604     return expr;
12605
12606   /* If the expression is a return, check to see if the expression inside the
12607      return has no side effects or the right hand side of the modify expression
12608      inside the return. If either don't have side effects set we don't need to
12609      wrap the expression in a cleanup point expression.  Note we don't check the
12610      left hand side of the modify because it should always be a return decl.  */
12611   if (TREE_CODE (expr) == RETURN_EXPR)
12612     {
12613       tree op = TREE_OPERAND (expr, 0);
12614       if (!op || !TREE_SIDE_EFFECTS (op))
12615         return expr;
12616       op = TREE_OPERAND (op, 1);
12617       if (!TREE_SIDE_EFFECTS (op))
12618         return expr;
12619     }
12620
12621   return build1 (CLEANUP_POINT_EXPR, type, expr);
12622 }
12623
12624 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
12625    avoid confusing the gimplify process.  */
12626
12627 tree
12628 build_fold_addr_expr_with_type (tree t, tree ptrtype)
12629 {
12630   /* The size of the object is not relevant when talking about its address.  */
12631   if (TREE_CODE (t) == WITH_SIZE_EXPR)
12632     t = TREE_OPERAND (t, 0);
12633
12634   /* Note: doesn't apply to ALIGN_INDIRECT_REF */
12635   if (TREE_CODE (t) == INDIRECT_REF
12636       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
12637     {
12638       t = TREE_OPERAND (t, 0);
12639       if (TREE_TYPE (t) != ptrtype)
12640         t = build1 (NOP_EXPR, ptrtype, t);
12641     }
12642   else
12643     {
12644       tree base = t;
12645
12646       while (handled_component_p (base))
12647         base = TREE_OPERAND (base, 0);
12648       if (DECL_P (base))
12649         TREE_ADDRESSABLE (base) = 1;
12650
12651       t = build1 (ADDR_EXPR, ptrtype, t);
12652     }
12653
12654   return t;
12655 }
12656
12657 tree
12658 build_fold_addr_expr (tree t)
12659 {
12660   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
12661 }
12662
12663 /* Given a pointer value OP0 and a type TYPE, return a simplified version
12664    of an indirection through OP0, or NULL_TREE if no simplification is
12665    possible.  */
12666
12667 tree
12668 fold_indirect_ref_1 (tree type, tree op0)
12669 {
12670   tree sub = op0;
12671   tree subtype;
12672
12673   STRIP_NOPS (sub);
12674   subtype = TREE_TYPE (sub);
12675   if (!POINTER_TYPE_P (subtype))
12676     return NULL_TREE;
12677
12678   if (TREE_CODE (sub) == ADDR_EXPR)
12679     {
12680       tree op = TREE_OPERAND (sub, 0);
12681       tree optype = TREE_TYPE (op);
12682       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
12683       if (type == optype)
12684         {
12685           tree fop = fold_read_from_constant_string (op);
12686           if (fop)
12687             return fop;
12688           else
12689             return op;
12690         }
12691       /* *(foo *)&fooarray => fooarray[0] */
12692       else if (TREE_CODE (optype) == ARRAY_TYPE
12693                && type == TREE_TYPE (optype))
12694         {
12695           tree type_domain = TYPE_DOMAIN (optype);
12696           tree min_val = size_zero_node;
12697           if (type_domain && TYPE_MIN_VALUE (type_domain))
12698             min_val = TYPE_MIN_VALUE (type_domain);
12699           return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
12700         }
12701       /* *(foo *)&complexfoo => __real__ complexfoo */
12702       else if (TREE_CODE (optype) == COMPLEX_TYPE
12703                && type == TREE_TYPE (optype))
12704         return fold_build1 (REALPART_EXPR, type, op);
12705     }
12706
12707   /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
12708   if (TREE_CODE (sub) == PLUS_EXPR
12709       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
12710     {
12711       tree op00 = TREE_OPERAND (sub, 0);
12712       tree op01 = TREE_OPERAND (sub, 1);
12713       tree op00type;
12714
12715       STRIP_NOPS (op00);
12716       op00type = TREE_TYPE (op00);
12717       if (TREE_CODE (op00) == ADDR_EXPR
12718           && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
12719           && type == TREE_TYPE (TREE_TYPE (op00type)))
12720         {
12721           tree size = TYPE_SIZE_UNIT (type);
12722           if (tree_int_cst_equal (size, op01))
12723             return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
12724         }
12725     }
12726
12727   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
12728   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
12729       && type == TREE_TYPE (TREE_TYPE (subtype)))
12730     {
12731       tree type_domain;
12732       tree min_val = size_zero_node;
12733       sub = build_fold_indirect_ref (sub);
12734       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
12735       if (type_domain && TYPE_MIN_VALUE (type_domain))
12736         min_val = TYPE_MIN_VALUE (type_domain);
12737       return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
12738     }
12739
12740   return NULL_TREE;
12741 }
12742
12743 /* Builds an expression for an indirection through T, simplifying some
12744    cases.  */
12745
12746 tree
12747 build_fold_indirect_ref (tree t)
12748 {
12749   tree type = TREE_TYPE (TREE_TYPE (t));
12750   tree sub = fold_indirect_ref_1 (type, t);
12751
12752   if (sub)
12753     return sub;
12754   else
12755     return build1 (INDIRECT_REF, type, t);
12756 }
12757
12758 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
12759
12760 tree
12761 fold_indirect_ref (tree t)
12762 {
12763   tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
12764
12765   if (sub)
12766     return sub;
12767   else
12768     return t;
12769 }
12770
12771 /* Strip non-trapping, non-side-effecting tree nodes from an expression
12772    whose result is ignored.  The type of the returned tree need not be
12773    the same as the original expression.  */
12774
12775 tree
12776 fold_ignored_result (tree t)
12777 {
12778   if (!TREE_SIDE_EFFECTS (t))
12779     return integer_zero_node;
12780
12781   for (;;)
12782     switch (TREE_CODE_CLASS (TREE_CODE (t)))
12783       {
12784       case tcc_unary:
12785         t = TREE_OPERAND (t, 0);
12786         break;
12787
12788       case tcc_binary:
12789       case tcc_comparison:
12790         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
12791           t = TREE_OPERAND (t, 0);
12792         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
12793           t = TREE_OPERAND (t, 1);
12794         else
12795           return t;
12796         break;
12797
12798       case tcc_expression:
12799         switch (TREE_CODE (t))
12800           {
12801           case COMPOUND_EXPR:
12802             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
12803               return t;
12804             t = TREE_OPERAND (t, 0);
12805             break;
12806
12807           case COND_EXPR:
12808             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
12809                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
12810               return t;
12811             t = TREE_OPERAND (t, 0);
12812             break;
12813
12814           default:
12815             return t;
12816           }
12817         break;
12818
12819       default:
12820         return t;
12821       }
12822 }
12823
12824 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
12825    This can only be applied to objects of a sizetype.  */
12826
12827 tree
12828 round_up (tree value, int divisor)
12829 {
12830   tree div = NULL_TREE;
12831
12832   gcc_assert (divisor > 0);
12833   if (divisor == 1)
12834     return value;
12835
12836   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
12837      have to do anything.  Only do this when we are not given a const,
12838      because in that case, this check is more expensive than just
12839      doing it.  */
12840   if (TREE_CODE (value) != INTEGER_CST)
12841     {
12842       div = build_int_cst (TREE_TYPE (value), divisor);
12843
12844       if (multiple_of_p (TREE_TYPE (value), value, div))
12845         return value;
12846     }
12847
12848   /* If divisor is a power of two, simplify this to bit manipulation.  */
12849   if (divisor == (divisor & -divisor))
12850     {
12851       tree t;
12852
12853       t = build_int_cst (TREE_TYPE (value), divisor - 1);
12854       value = size_binop (PLUS_EXPR, value, t);
12855       t = build_int_cst (TREE_TYPE (value), -divisor);
12856       value = size_binop (BIT_AND_EXPR, value, t);
12857     }
12858   else
12859     {
12860       if (!div)
12861         div = build_int_cst (TREE_TYPE (value), divisor);
12862       value = size_binop (CEIL_DIV_EXPR, value, div);
12863       value = size_binop (MULT_EXPR, value, div);
12864     }
12865
12866   return value;
12867 }
12868
12869 /* Likewise, but round down.  */
12870
12871 tree
12872 round_down (tree value, int divisor)
12873 {
12874   tree div = NULL_TREE;
12875
12876   gcc_assert (divisor > 0);
12877   if (divisor == 1)
12878     return value;
12879
12880   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
12881      have to do anything.  Only do this when we are not given a const,
12882      because in that case, this check is more expensive than just
12883      doing it.  */
12884   if (TREE_CODE (value) != INTEGER_CST)
12885     {
12886       div = build_int_cst (TREE_TYPE (value), divisor);
12887
12888       if (multiple_of_p (TREE_TYPE (value), value, div))
12889         return value;
12890     }
12891
12892   /* If divisor is a power of two, simplify this to bit manipulation.  */
12893   if (divisor == (divisor & -divisor))
12894     {
12895       tree t;
12896
12897       t = build_int_cst (TREE_TYPE (value), -divisor);
12898       value = size_binop (BIT_AND_EXPR, value, t);
12899     }
12900   else
12901     {
12902       if (!div)
12903         div = build_int_cst (TREE_TYPE (value), divisor);
12904       value = size_binop (FLOOR_DIV_EXPR, value, div);
12905       value = size_binop (MULT_EXPR, value, div);
12906     }
12907
12908   return value;
12909 }
12910
12911 /* Returns the pointer to the base of the object addressed by EXP and
12912    extracts the information about the offset of the access, storing it
12913    to PBITPOS and POFFSET.  */
12914
12915 static tree
12916 split_address_to_core_and_offset (tree exp,
12917                                   HOST_WIDE_INT *pbitpos, tree *poffset)
12918 {
12919   tree core;
12920   enum machine_mode mode;
12921   int unsignedp, volatilep;
12922   HOST_WIDE_INT bitsize;
12923
12924   if (TREE_CODE (exp) == ADDR_EXPR)
12925     {
12926       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
12927                                   poffset, &mode, &unsignedp, &volatilep,
12928                                   false);
12929       core = build_fold_addr_expr (core);
12930     }
12931   else
12932     {
12933       core = exp;
12934       *pbitpos = 0;
12935       *poffset = NULL_TREE;
12936     }
12937
12938   return core;
12939 }
12940
12941 /* Returns true if addresses of E1 and E2 differ by a constant, false
12942    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
12943
12944 bool
12945 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
12946 {
12947   tree core1, core2;
12948   HOST_WIDE_INT bitpos1, bitpos2;
12949   tree toffset1, toffset2, tdiff, type;
12950
12951   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
12952   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
12953
12954   if (bitpos1 % BITS_PER_UNIT != 0
12955       || bitpos2 % BITS_PER_UNIT != 0
12956       || !operand_equal_p (core1, core2, 0))
12957     return false;
12958
12959   if (toffset1 && toffset2)
12960     {
12961       type = TREE_TYPE (toffset1);
12962       if (type != TREE_TYPE (toffset2))
12963         toffset2 = fold_convert (type, toffset2);
12964
12965       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
12966       if (!cst_and_fits_in_hwi (tdiff))
12967         return false;
12968
12969       *diff = int_cst_value (tdiff);
12970     }
12971   else if (toffset1 || toffset2)
12972     {
12973       /* If only one of the offsets is non-constant, the difference cannot
12974          be a constant.  */
12975       return false;
12976     }
12977   else
12978     *diff = 0;
12979
12980   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
12981   return true;
12982 }
12983
12984 /* Simplify the floating point expression EXP when the sign of the
12985    result is not significant.  Return NULL_TREE if no simplification
12986    is possible.  */
12987
12988 tree
12989 fold_strip_sign_ops (tree exp)
12990 {
12991   tree arg0, arg1;
12992
12993   switch (TREE_CODE (exp))
12994     {
12995     case ABS_EXPR:
12996     case NEGATE_EXPR:
12997       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
12998       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
12999
13000     case MULT_EXPR:
13001     case RDIV_EXPR:
13002       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
13003         return NULL_TREE;
13004       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
13005       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
13006       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
13007         return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
13008                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
13009                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
13010       break;
13011
13012     default:
13013       break;
13014     }
13015   return NULL_TREE;
13016 }
13017