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 (abs (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 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
7753    by changing CODE to reduce the magnitude of constants involved in
7754    ARG0 of the comparison.
7755    Returns a canonicalized comparison tree if a simplification was
7756    possible, otherwise returns NULL_TREE.  */
7757
7758 static tree
7759 maybe_canonicalize_comparison_1 (enum tree_code code, tree type,
7760                                  tree arg0, tree arg1)
7761 {
7762   enum tree_code code0 = TREE_CODE (arg0);
7763   tree t, cst0 = NULL_TREE;
7764   int sgn0;
7765   bool swap = false;
7766
7767   /* Match A +- CST code arg1 and CST code arg1.  */
7768   if (!(((code0 == MINUS_EXPR
7769           || code0 == PLUS_EXPR)
7770          && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
7771         || code0 == INTEGER_CST))
7772     return NULL_TREE;
7773
7774   /* Identify the constant in arg0 and its sign.  */
7775   if (code0 == INTEGER_CST)
7776     cst0 = arg0;
7777   else
7778     cst0 = TREE_OPERAND (arg0, 1);
7779   sgn0 = tree_int_cst_sgn (cst0);
7780
7781   /* Overflowed constants and zero will cause problems.  */
7782   if (integer_zerop (cst0)
7783       || TREE_OVERFLOW (cst0))
7784     return NULL_TREE;
7785
7786   /* See if we can reduce the mangitude of the constant in
7787      arg0 by changing the comparison code.  */
7788   if (code0 == INTEGER_CST)
7789     {
7790       /* CST <= arg1  ->  CST-1 < arg1.  */
7791       if (code == LE_EXPR && sgn0 == 1)
7792         code = LT_EXPR;
7793       /* -CST < arg1  ->  -CST-1 <= arg1.  */
7794       else if (code == LT_EXPR && sgn0 == -1)
7795         code = LE_EXPR;
7796       /* CST > arg1  ->  CST-1 >= arg1.  */
7797       else if (code == GT_EXPR && sgn0 == 1)
7798         code = GE_EXPR;
7799       /* -CST >= arg1  ->  -CST-1 > arg1.  */
7800       else if (code == GE_EXPR && sgn0 == -1)
7801         code = GT_EXPR;
7802       else
7803         return NULL_TREE;
7804       /* arg1 code' CST' might be more canonical.  */
7805       swap = true;
7806     }
7807   else
7808     {
7809       /* A - CST < arg1  ->  A - CST-1 <= arg1.  */
7810       if (code == LT_EXPR
7811           && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
7812         code = LE_EXPR;
7813       /* A + CST > arg1  ->  A + CST-1 >= arg1.  */
7814       else if (code == GT_EXPR
7815                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
7816         code = GE_EXPR;
7817       /* A + CST <= arg1  ->  A + CST-1 < arg1.  */
7818       else if (code == LE_EXPR
7819                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
7820         code = LT_EXPR;
7821       /* A - CST >= arg1  ->  A - CST-1 > arg1.  */
7822       else if (code == GE_EXPR
7823                && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
7824         code = GT_EXPR;
7825       else
7826         return NULL_TREE;
7827     }
7828
7829   /* Now build the constant reduced in magnitude.  */
7830   t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
7831                        cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
7832   if (code0 != INTEGER_CST)
7833     t = fold_build2 (code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
7834
7835   /* If swapping might yield to a more canonical form, do so.  */
7836   if (swap)
7837     return fold_build2 (swap_tree_comparison (code), type, arg1, t);
7838   else
7839     return fold_build2 (code, type, t, arg1);
7840 }
7841
7842 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
7843    overflow further.  Try to decrease the magnitude of constants involved
7844    by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
7845    and put sole constants at the second argument position.
7846    Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
7847
7848 static tree
7849 maybe_canonicalize_comparison (enum tree_code code, tree type,
7850                                tree arg0, tree arg1)
7851 {
7852   tree t;
7853
7854   /* In principle pointers also have undefined overflow behavior,
7855      but that causes problems elsewhere.  */
7856   if ((flag_wrapv || flag_trapv)
7857       || (TYPE_UNSIGNED (TREE_TYPE (arg0))
7858           || POINTER_TYPE_P (TREE_TYPE (arg0))))
7859     return NULL_TREE;
7860
7861   /* Try canonicalization by simplifying arg0.  */
7862   t = maybe_canonicalize_comparison_1 (code, type, arg0, arg1);
7863   if (t)
7864     return t;
7865
7866   /* Try canonicalization by simplifying arg1 using the swapped
7867      comparsion.  */
7868   code = swap_tree_comparison (code);
7869   return maybe_canonicalize_comparison_1 (code, type, arg1, arg0);
7870 }
7871
7872 /* Subroutine of fold_binary.  This routine performs all of the
7873    transformations that are common to the equality/inequality
7874    operators (EQ_EXPR and NE_EXPR) and the ordering operators
7875    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
7876    fold_binary should call fold_binary.  Fold a comparison with
7877    tree code CODE and type TYPE with operands OP0 and OP1.  Return
7878    the folded comparison or NULL_TREE.  */
7879
7880 static tree
7881 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
7882 {
7883   tree arg0, arg1, tem;
7884
7885   arg0 = op0;
7886   arg1 = op1;
7887
7888   STRIP_SIGN_NOPS (arg0);
7889   STRIP_SIGN_NOPS (arg1);
7890
7891   tem = fold_relational_const (code, type, arg0, arg1);
7892   if (tem != NULL_TREE)
7893     return tem;
7894
7895   /* If one arg is a real or integer constant, put it last.  */
7896   if (tree_swap_operands_p (arg0, arg1, true))
7897     return fold_build2 (swap_tree_comparison (code), type, op1, op0);
7898
7899   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
7900   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7901       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7902           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
7903           && !TYPE_UNSIGNED (TREE_TYPE (arg1))
7904           && !(flag_wrapv || flag_trapv))
7905       && (TREE_CODE (arg1) == INTEGER_CST
7906           && !TREE_OVERFLOW (arg1)))
7907     {
7908       tree const1 = TREE_OPERAND (arg0, 1);
7909       tree const2 = arg1;
7910       tree variable = TREE_OPERAND (arg0, 0);
7911       tree lhs;
7912       int lhs_add;
7913       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
7914
7915       lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
7916                          TREE_TYPE (arg1), const2, const1);
7917       if (TREE_CODE (lhs) == TREE_CODE (arg1)
7918           && (TREE_CODE (lhs) != INTEGER_CST
7919               || !TREE_OVERFLOW (lhs)))
7920         return fold_build2 (code, type, variable, lhs);
7921     }
7922
7923   /* If this is a comparison of two exprs that look like an ARRAY_REF of the
7924      same object, then we can fold this to a comparison of the two offsets in
7925      signed size type.  This is possible because pointer arithmetic is
7926      restricted to retain within an object and overflow on pointer differences
7927      is undefined as of 6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
7928   if (POINTER_TYPE_P (TREE_TYPE (arg0))
7929       && !flag_wrapv && !flag_trapv)
7930     {
7931       tree base0, offset0, base1, offset1;
7932
7933       if (extract_array_ref (arg0, &base0, &offset0)
7934           && extract_array_ref (arg1, &base1, &offset1)
7935           && operand_equal_p (base0, base1, 0))
7936         {
7937           tree signed_size_type_node;
7938           signed_size_type_node = signed_type_for (size_type_node);
7939
7940           /* By converting to signed size type we cover middle-end pointer
7941              arithmetic which operates on unsigned pointer types of size
7942              type size and ARRAY_REF offsets which are properly sign or
7943              zero extended from their type in case it is narrower than
7944              size type.  */
7945           if (offset0 == NULL_TREE)
7946             offset0 = build_int_cst (signed_size_type_node, 0);
7947           else
7948             offset0 = fold_convert (signed_size_type_node, offset0);
7949           if (offset1 == NULL_TREE)
7950             offset1 = build_int_cst (signed_size_type_node, 0);
7951           else
7952             offset1 = fold_convert (signed_size_type_node, offset1);
7953
7954           return fold_build2 (code, type, offset0, offset1);
7955         }
7956     }
7957
7958   /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
7959      X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
7960      the resulting offset is smaller in absolute value than the
7961      original one.  */
7962   if (!(flag_wrapv || flag_trapv)
7963       && !TYPE_UNSIGNED (TREE_TYPE (arg0))
7964       && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7965       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7966           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
7967       && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
7968       && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7969           && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
7970     {
7971       tree const1 = TREE_OPERAND (arg0, 1);
7972       tree const2 = TREE_OPERAND (arg1, 1);
7973       tree variable1 = TREE_OPERAND (arg0, 0);
7974       tree variable2 = TREE_OPERAND (arg1, 0);
7975       tree cst;
7976
7977       /* Put the constant on the side where it doesn't overflow and is
7978          of lower absolute value than before.  */
7979       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
7980                              ? MINUS_EXPR : PLUS_EXPR,
7981                              const2, const1, 0);
7982       if (!TREE_OVERFLOW (cst)
7983           && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
7984         return fold_build2 (code, type,
7985                             variable1,
7986                             fold_build2 (TREE_CODE (arg1), TREE_TYPE (arg1),
7987                                          variable2, cst));
7988
7989       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
7990                              ? MINUS_EXPR : PLUS_EXPR,
7991                              const1, const2, 0);
7992       if (!TREE_OVERFLOW (cst)
7993           && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
7994         return fold_build2 (code, type,
7995                             fold_build2 (TREE_CODE (arg0), TREE_TYPE (arg0),
7996                                          variable1, cst),
7997                             variable2);
7998     }
7999
8000   tem = maybe_canonicalize_comparison (code, type, arg0, arg1);
8001   if (tem)
8002     return tem;
8003
8004   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
8005     {
8006       tree targ0 = strip_float_extensions (arg0);
8007       tree targ1 = strip_float_extensions (arg1);
8008       tree newtype = TREE_TYPE (targ0);
8009
8010       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8011         newtype = TREE_TYPE (targ1);
8012
8013       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8014       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8015         return fold_build2 (code, type, fold_convert (newtype, targ0),
8016                             fold_convert (newtype, targ1));
8017
8018       /* (-a) CMP (-b) -> b CMP a  */
8019       if (TREE_CODE (arg0) == NEGATE_EXPR
8020           && TREE_CODE (arg1) == NEGATE_EXPR)
8021         return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
8022                             TREE_OPERAND (arg0, 0));
8023
8024       if (TREE_CODE (arg1) == REAL_CST)
8025         {
8026           REAL_VALUE_TYPE cst;
8027           cst = TREE_REAL_CST (arg1);
8028
8029           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
8030           if (TREE_CODE (arg0) == NEGATE_EXPR)
8031             return fold_build2 (swap_tree_comparison (code), type,
8032                                 TREE_OPERAND (arg0, 0),
8033                                 build_real (TREE_TYPE (arg1),
8034                                             REAL_VALUE_NEGATE (cst)));
8035
8036           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
8037           /* a CMP (-0) -> a CMP 0  */
8038           if (REAL_VALUE_MINUS_ZERO (cst))
8039             return fold_build2 (code, type, arg0,
8040                                 build_real (TREE_TYPE (arg1), dconst0));
8041
8042           /* x != NaN is always true, other ops are always false.  */
8043           if (REAL_VALUE_ISNAN (cst)
8044               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
8045             {
8046               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8047               return omit_one_operand (type, tem, arg0);
8048             }
8049
8050           /* Fold comparisons against infinity.  */
8051           if (REAL_VALUE_ISINF (cst))
8052             {
8053               tem = fold_inf_compare (code, type, arg0, arg1);
8054               if (tem != NULL_TREE)
8055                 return tem;
8056             }
8057         }
8058
8059       /* If this is a comparison of a real constant with a PLUS_EXPR
8060          or a MINUS_EXPR of a real constant, we can convert it into a
8061          comparison with a revised real constant as long as no overflow
8062          occurs when unsafe_math_optimizations are enabled.  */
8063       if (flag_unsafe_math_optimizations
8064           && TREE_CODE (arg1) == REAL_CST
8065           && (TREE_CODE (arg0) == PLUS_EXPR
8066               || TREE_CODE (arg0) == MINUS_EXPR)
8067           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8068           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8069                                       ? MINUS_EXPR : PLUS_EXPR,
8070                                       arg1, TREE_OPERAND (arg0, 1), 0))
8071           && ! TREE_CONSTANT_OVERFLOW (tem))
8072         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
8073
8074       /* Likewise, we can simplify a comparison of a real constant with
8075          a MINUS_EXPR whose first operand is also a real constant, i.e.
8076          (c1 - x) < c2 becomes x > c1-c2.  */
8077       if (flag_unsafe_math_optimizations
8078           && TREE_CODE (arg1) == REAL_CST
8079           && TREE_CODE (arg0) == MINUS_EXPR
8080           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8081           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8082                                       arg1, 0))
8083           && ! TREE_CONSTANT_OVERFLOW (tem))
8084         return fold_build2 (swap_tree_comparison (code), type,
8085                             TREE_OPERAND (arg0, 1), tem);
8086
8087       /* Fold comparisons against built-in math functions.  */
8088       if (TREE_CODE (arg1) == REAL_CST
8089           && flag_unsafe_math_optimizations
8090           && ! flag_errno_math)
8091         {
8092           enum built_in_function fcode = builtin_mathfn_code (arg0);
8093
8094           if (fcode != END_BUILTINS)
8095             {
8096               tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8097               if (tem != NULL_TREE)
8098                 return tem;
8099             }
8100         }
8101     }
8102
8103   /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
8104   if (TREE_CONSTANT (arg1)
8105       && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
8106           || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
8107       /* This optimization is invalid for ordered comparisons
8108          if CONST+INCR overflows or if foo+incr might overflow.
8109          This optimization is invalid for floating point due to rounding.
8110          For pointer types we assume overflow doesn't happen.  */
8111       && (POINTER_TYPE_P (TREE_TYPE (arg0))
8112           || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8113               && (code == EQ_EXPR || code == NE_EXPR))))
8114     {
8115       tree varop, newconst;
8116
8117       if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
8118         {
8119           newconst = fold_build2 (PLUS_EXPR, TREE_TYPE (arg0),
8120                                   arg1, TREE_OPERAND (arg0, 1));
8121           varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
8122                           TREE_OPERAND (arg0, 0),
8123                           TREE_OPERAND (arg0, 1));
8124         }
8125       else
8126         {
8127           newconst = fold_build2 (MINUS_EXPR, TREE_TYPE (arg0),
8128                                   arg1, TREE_OPERAND (arg0, 1));
8129           varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
8130                           TREE_OPERAND (arg0, 0),
8131                           TREE_OPERAND (arg0, 1));
8132         }
8133
8134
8135       /* If VAROP is a reference to a bitfield, we must mask
8136          the constant by the width of the field.  */
8137       if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
8138           && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
8139           && host_integerp (DECL_SIZE (TREE_OPERAND
8140                                          (TREE_OPERAND (varop, 0), 1)), 1))
8141         {
8142           tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
8143           HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
8144           tree folded_compare, shift;
8145
8146           /* First check whether the comparison would come out
8147              always the same.  If we don't do that we would
8148              change the meaning with the masking.  */
8149           folded_compare = fold_build2 (code, type,
8150                                         TREE_OPERAND (varop, 0), arg1);
8151           if (TREE_CODE (folded_compare) == INTEGER_CST)
8152             return omit_one_operand (type, folded_compare, varop);
8153
8154           shift = build_int_cst (NULL_TREE,
8155                                  TYPE_PRECISION (TREE_TYPE (varop)) - size);
8156           shift = fold_convert (TREE_TYPE (varop), shift);
8157           newconst = fold_build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8158                                   newconst, shift);
8159           newconst = fold_build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8160                                   newconst, shift);
8161         }
8162
8163       return fold_build2 (code, type, varop, newconst);
8164     }
8165
8166   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8167       && (TREE_CODE (arg0) == NOP_EXPR
8168           || TREE_CODE (arg0) == CONVERT_EXPR))
8169     {
8170       /* If we are widening one operand of an integer comparison,
8171          see if the other operand is similarly being widened.  Perhaps we
8172          can do the comparison in the narrower type.  */
8173       tem = fold_widened_comparison (code, type, arg0, arg1);
8174       if (tem)
8175         return tem;
8176
8177       /* Or if we are changing signedness.  */
8178       tem = fold_sign_changed_comparison (code, type, arg0, arg1);
8179       if (tem)
8180         return tem;
8181     }
8182
8183   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8184      constant, we can simplify it.  */
8185   if (TREE_CODE (arg1) == INTEGER_CST
8186       && (TREE_CODE (arg0) == MIN_EXPR
8187           || TREE_CODE (arg0) == MAX_EXPR)
8188       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8189     {
8190       tem = optimize_minmax_comparison (code, type, op0, op1);
8191       if (tem)
8192         return tem;
8193     }
8194
8195   /* Simplify comparison of something with itself.  (For IEEE
8196      floating-point, we can only do some of these simplifications.)  */
8197   if (operand_equal_p (arg0, arg1, 0))
8198     {
8199       switch (code)
8200         {
8201         case EQ_EXPR:
8202           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8203               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8204             return constant_boolean_node (1, type);
8205           break;
8206
8207         case GE_EXPR:
8208         case LE_EXPR:
8209           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8210               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8211             return constant_boolean_node (1, type);
8212           return fold_build2 (EQ_EXPR, type, arg0, arg1);
8213
8214         case NE_EXPR:
8215           /* For NE, we can only do this simplification if integer
8216              or we don't honor IEEE floating point NaNs.  */
8217           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8218               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8219             break;
8220           /* ... fall through ...  */
8221         case GT_EXPR:
8222         case LT_EXPR:
8223           return constant_boolean_node (0, type);
8224         default:
8225           gcc_unreachable ();
8226         }
8227     }
8228
8229   /* If we are comparing an expression that just has comparisons
8230      of two integer values, arithmetic expressions of those comparisons,
8231      and constants, we can simplify it.  There are only three cases
8232      to check: the two values can either be equal, the first can be
8233      greater, or the second can be greater.  Fold the expression for
8234      those three values.  Since each value must be 0 or 1, we have
8235      eight possibilities, each of which corresponds to the constant 0
8236      or 1 or one of the six possible comparisons.
8237
8238      This handles common cases like (a > b) == 0 but also handles
8239      expressions like  ((x > y) - (y > x)) > 0, which supposedly
8240      occur in macroized code.  */
8241
8242   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8243     {
8244       tree cval1 = 0, cval2 = 0;
8245       int save_p = 0;
8246
8247       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8248           /* Don't handle degenerate cases here; they should already
8249              have been handled anyway.  */
8250           && cval1 != 0 && cval2 != 0
8251           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8252           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8253           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8254           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8255           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8256           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8257                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8258         {
8259           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8260           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8261
8262           /* We can't just pass T to eval_subst in case cval1 or cval2
8263              was the same as ARG1.  */
8264
8265           tree high_result
8266                 = fold_build2 (code, type,
8267                                eval_subst (arg0, cval1, maxval,
8268                                            cval2, minval),
8269                                arg1);
8270           tree equal_result
8271                 = fold_build2 (code, type,
8272                                eval_subst (arg0, cval1, maxval,
8273                                            cval2, maxval),
8274                                arg1);
8275           tree low_result
8276                 = fold_build2 (code, type,
8277                                eval_subst (arg0, cval1, minval,
8278                                            cval2, maxval),
8279                                arg1);
8280
8281           /* All three of these results should be 0 or 1.  Confirm they are.
8282              Then use those values to select the proper code to use.  */
8283
8284           if (TREE_CODE (high_result) == INTEGER_CST
8285               && TREE_CODE (equal_result) == INTEGER_CST
8286               && TREE_CODE (low_result) == INTEGER_CST)
8287             {
8288               /* Make a 3-bit mask with the high-order bit being the
8289                  value for `>', the next for '=', and the low for '<'.  */
8290               switch ((integer_onep (high_result) * 4)
8291                       + (integer_onep (equal_result) * 2)
8292                       + integer_onep (low_result))
8293                 {
8294                 case 0:
8295                   /* Always false.  */
8296                   return omit_one_operand (type, integer_zero_node, arg0);
8297                 case 1:
8298                   code = LT_EXPR;
8299                   break;
8300                 case 2:
8301                   code = EQ_EXPR;
8302                   break;
8303                 case 3:
8304                   code = LE_EXPR;
8305                   break;
8306                 case 4:
8307                   code = GT_EXPR;
8308                   break;
8309                 case 5:
8310                   code = NE_EXPR;
8311                   break;
8312                 case 6:
8313                   code = GE_EXPR;
8314                   break;
8315                 case 7:
8316                   /* Always true.  */
8317                   return omit_one_operand (type, integer_one_node, arg0);
8318                 }
8319
8320               if (save_p)
8321                 return save_expr (build2 (code, type, cval1, cval2));
8322               return fold_build2 (code, type, cval1, cval2);
8323             }
8324         }
8325     }
8326
8327   /* Fold a comparison of the address of COMPONENT_REFs with the same
8328      type and component to a comparison of the address of the base
8329      object.  In short, &x->a OP &y->a to x OP y and
8330      &x->a OP &y.a to x OP &y  */
8331   if (TREE_CODE (arg0) == ADDR_EXPR
8332       && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
8333       && TREE_CODE (arg1) == ADDR_EXPR
8334       && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
8335     {
8336       tree cref0 = TREE_OPERAND (arg0, 0);
8337       tree cref1 = TREE_OPERAND (arg1, 0);
8338       if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
8339         {
8340           tree op0 = TREE_OPERAND (cref0, 0);
8341           tree op1 = TREE_OPERAND (cref1, 0);
8342           return fold_build2 (code, type,
8343                               build_fold_addr_expr (op0),
8344                               build_fold_addr_expr (op1));
8345         }
8346     }
8347
8348   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8349      into a single range test.  */
8350   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
8351        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
8352       && TREE_CODE (arg1) == INTEGER_CST
8353       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8354       && !integer_zerop (TREE_OPERAND (arg0, 1))
8355       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8356       && !TREE_OVERFLOW (arg1))
8357     {
8358       tem = fold_div_compare (code, type, arg0, arg1);
8359       if (tem != NULL_TREE)
8360         return tem;
8361     }
8362
8363   /* Fold ~X op ~Y as Y op X.  */
8364   if (TREE_CODE (arg0) == BIT_NOT_EXPR
8365       && TREE_CODE (arg1) == BIT_NOT_EXPR)
8366     return fold_build2 (code, type,
8367                         TREE_OPERAND (arg1, 0),
8368                         TREE_OPERAND (arg0, 0));
8369
8370   /* Fold ~X op C as X op' ~C, where op' is the swapped comparison.  */
8371   if (TREE_CODE (arg0) == BIT_NOT_EXPR
8372       && TREE_CODE (arg1) == INTEGER_CST)
8373     return fold_build2 (swap_tree_comparison (code), type,
8374                         TREE_OPERAND (arg0, 0),
8375                         fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1));
8376
8377   return NULL_TREE;
8378 }
8379
8380
8381 /* Subroutine of fold_binary.  Optimize complex multiplications of the
8382    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
8383    argument EXPR represents the expression "z" of type TYPE.  */
8384
8385 static tree
8386 fold_mult_zconjz (tree type, tree expr)
8387 {
8388   tree itype = TREE_TYPE (type);
8389   tree rpart, ipart, tem;
8390
8391   if (TREE_CODE (expr) == COMPLEX_EXPR)
8392     {
8393       rpart = TREE_OPERAND (expr, 0);
8394       ipart = TREE_OPERAND (expr, 1);
8395     }
8396   else if (TREE_CODE (expr) == COMPLEX_CST)
8397     {
8398       rpart = TREE_REALPART (expr);
8399       ipart = TREE_IMAGPART (expr);
8400     }
8401   else
8402     {
8403       expr = save_expr (expr);
8404       rpart = fold_build1 (REALPART_EXPR, itype, expr);
8405       ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
8406     }
8407
8408   rpart = save_expr (rpart);
8409   ipart = save_expr (ipart);
8410   tem = fold_build2 (PLUS_EXPR, itype,
8411                      fold_build2 (MULT_EXPR, itype, rpart, rpart),
8412                      fold_build2 (MULT_EXPR, itype, ipart, ipart));
8413   return fold_build2 (COMPLEX_EXPR, type, tem,
8414                       fold_convert (itype, integer_zero_node));
8415 }
8416
8417
8418 /* Fold a binary expression of code CODE and type TYPE with operands
8419    OP0 and OP1.  Return the folded expression if folding is
8420    successful.  Otherwise, return NULL_TREE.  */
8421
8422 tree
8423 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
8424 {
8425   enum tree_code_class kind = TREE_CODE_CLASS (code);
8426   tree arg0, arg1, tem;
8427   tree t1 = NULL_TREE;
8428
8429   gcc_assert (IS_EXPR_CODE_CLASS (kind)
8430               && TREE_CODE_LENGTH (code) == 2
8431               && op0 != NULL_TREE
8432               && op1 != NULL_TREE);
8433
8434   arg0 = op0;
8435   arg1 = op1;
8436
8437   /* Strip any conversions that don't change the mode.  This is
8438      safe for every expression, except for a comparison expression
8439      because its signedness is derived from its operands.  So, in
8440      the latter case, only strip conversions that don't change the
8441      signedness.
8442
8443      Note that this is done as an internal manipulation within the
8444      constant folder, in order to find the simplest representation
8445      of the arguments so that their form can be studied.  In any
8446      cases, the appropriate type conversions should be put back in
8447      the tree that will get out of the constant folder.  */
8448
8449   if (kind == tcc_comparison)
8450     {
8451       STRIP_SIGN_NOPS (arg0);
8452       STRIP_SIGN_NOPS (arg1);
8453     }
8454   else
8455     {
8456       STRIP_NOPS (arg0);
8457       STRIP_NOPS (arg1);
8458     }
8459
8460   /* Note that TREE_CONSTANT isn't enough: static var addresses are
8461      constant but we can't do arithmetic on them.  */
8462   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
8463       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8464       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
8465       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
8466     {
8467       if (kind == tcc_binary)
8468         tem = const_binop (code, arg0, arg1, 0);
8469       else if (kind == tcc_comparison)
8470         tem = fold_relational_const (code, type, arg0, arg1);
8471       else
8472         tem = NULL_TREE;
8473
8474       if (tem != NULL_TREE)
8475         {
8476           if (TREE_TYPE (tem) != type)
8477             tem = fold_convert (type, tem);
8478           return tem;
8479         }
8480     }
8481
8482   /* If this is a commutative operation, and ARG0 is a constant, move it
8483      to ARG1 to reduce the number of tests below.  */
8484   if (commutative_tree_code (code)
8485       && tree_swap_operands_p (arg0, arg1, true))
8486     return fold_build2 (code, type, op1, op0);
8487
8488   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
8489
8490      First check for cases where an arithmetic operation is applied to a
8491      compound, conditional, or comparison operation.  Push the arithmetic
8492      operation inside the compound or conditional to see if any folding
8493      can then be done.  Convert comparison to conditional for this purpose.
8494      The also optimizes non-constant cases that used to be done in
8495      expand_expr.
8496
8497      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
8498      one of the operands is a comparison and the other is a comparison, a
8499      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
8500      code below would make the expression more complex.  Change it to a
8501      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
8502      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
8503
8504   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
8505        || code == EQ_EXPR || code == NE_EXPR)
8506       && ((truth_value_p (TREE_CODE (arg0))
8507            && (truth_value_p (TREE_CODE (arg1))
8508                || (TREE_CODE (arg1) == BIT_AND_EXPR
8509                    && integer_onep (TREE_OPERAND (arg1, 1)))))
8510           || (truth_value_p (TREE_CODE (arg1))
8511               && (truth_value_p (TREE_CODE (arg0))
8512                   || (TREE_CODE (arg0) == BIT_AND_EXPR
8513                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
8514     {
8515       tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
8516                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
8517                          : TRUTH_XOR_EXPR,
8518                          boolean_type_node,
8519                          fold_convert (boolean_type_node, arg0),
8520                          fold_convert (boolean_type_node, arg1));
8521
8522       if (code == EQ_EXPR)
8523         tem = invert_truthvalue (tem);
8524
8525       return fold_convert (type, tem);
8526     }
8527
8528   if (TREE_CODE_CLASS (code) == tcc_binary
8529       || TREE_CODE_CLASS (code) == tcc_comparison)
8530     {
8531       if (TREE_CODE (arg0) == COMPOUND_EXPR)
8532         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
8533                        fold_build2 (code, type,
8534                                     TREE_OPERAND (arg0, 1), op1));
8535       if (TREE_CODE (arg1) == COMPOUND_EXPR
8536           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
8537         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
8538                        fold_build2 (code, type,
8539                                     op0, TREE_OPERAND (arg1, 1)));
8540
8541       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
8542         {
8543           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8544                                                      arg0, arg1,
8545                                                      /*cond_first_p=*/1);
8546           if (tem != NULL_TREE)
8547             return tem;
8548         }
8549
8550       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
8551         {
8552           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8553                                                      arg1, arg0,
8554                                                      /*cond_first_p=*/0);
8555           if (tem != NULL_TREE)
8556             return tem;
8557         }
8558     }
8559
8560   switch (code)
8561     {
8562     case PLUS_EXPR:
8563       /* A + (-B) -> A - B */
8564       if (TREE_CODE (arg1) == NEGATE_EXPR)
8565         return fold_build2 (MINUS_EXPR, type,
8566                             fold_convert (type, arg0),
8567                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8568       /* (-A) + B -> B - A */
8569       if (TREE_CODE (arg0) == NEGATE_EXPR
8570           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
8571         return fold_build2 (MINUS_EXPR, type,
8572                             fold_convert (type, arg1),
8573                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8574       /* Convert ~A + 1 to -A.  */
8575       if (INTEGRAL_TYPE_P (type)
8576           && TREE_CODE (arg0) == BIT_NOT_EXPR
8577           && integer_onep (arg1))
8578         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
8579
8580       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
8581          same or one.  */
8582       if ((TREE_CODE (arg0) == MULT_EXPR
8583            || TREE_CODE (arg1) == MULT_EXPR)
8584           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
8585         {
8586           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
8587           if (tem)
8588             return tem;
8589         }
8590
8591       if (! FLOAT_TYPE_P (type))
8592         {
8593           if (integer_zerop (arg1))
8594             return non_lvalue (fold_convert (type, arg0));
8595
8596           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
8597              with a constant, and the two constants have no bits in common,
8598              we should treat this as a BIT_IOR_EXPR since this may produce more
8599              simplifications.  */
8600           if (TREE_CODE (arg0) == BIT_AND_EXPR
8601               && TREE_CODE (arg1) == BIT_AND_EXPR
8602               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8603               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8604               && integer_zerop (const_binop (BIT_AND_EXPR,
8605                                              TREE_OPERAND (arg0, 1),
8606                                              TREE_OPERAND (arg1, 1), 0)))
8607             {
8608               code = BIT_IOR_EXPR;
8609               goto bit_ior;
8610             }
8611
8612           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
8613              (plus (plus (mult) (mult)) (foo)) so that we can
8614              take advantage of the factoring cases below.  */
8615           if (((TREE_CODE (arg0) == PLUS_EXPR
8616                 || TREE_CODE (arg0) == MINUS_EXPR)
8617                && TREE_CODE (arg1) == MULT_EXPR)
8618               || ((TREE_CODE (arg1) == PLUS_EXPR
8619                    || TREE_CODE (arg1) == MINUS_EXPR)
8620                   && TREE_CODE (arg0) == MULT_EXPR))
8621             {
8622               tree parg0, parg1, parg, marg;
8623               enum tree_code pcode;
8624
8625               if (TREE_CODE (arg1) == MULT_EXPR)
8626                 parg = arg0, marg = arg1;
8627               else
8628                 parg = arg1, marg = arg0;
8629               pcode = TREE_CODE (parg);
8630               parg0 = TREE_OPERAND (parg, 0);
8631               parg1 = TREE_OPERAND (parg, 1);
8632               STRIP_NOPS (parg0);
8633               STRIP_NOPS (parg1);
8634
8635               if (TREE_CODE (parg0) == MULT_EXPR
8636                   && TREE_CODE (parg1) != MULT_EXPR)
8637                 return fold_build2 (pcode, type,
8638                                     fold_build2 (PLUS_EXPR, type,
8639                                                  fold_convert (type, parg0),
8640                                                  fold_convert (type, marg)),
8641                                     fold_convert (type, parg1));
8642               if (TREE_CODE (parg0) != MULT_EXPR
8643                   && TREE_CODE (parg1) == MULT_EXPR)
8644                 return fold_build2 (PLUS_EXPR, type,
8645                                     fold_convert (type, parg0),
8646                                     fold_build2 (pcode, type,
8647                                                  fold_convert (type, marg),
8648                                                  fold_convert (type,
8649                                                                parg1)));
8650             }
8651
8652           /* Try replacing &a[i1] + c * i2 with &a[i1 + i2], if c is step
8653              of the array.  Loop optimizer sometimes produce this type of
8654              expressions.  */
8655           if (TREE_CODE (arg0) == ADDR_EXPR)
8656             {
8657               tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
8658               if (tem)
8659                 return fold_convert (type, tem);
8660             }
8661           else if (TREE_CODE (arg1) == ADDR_EXPR)
8662             {
8663               tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
8664               if (tem)
8665                 return fold_convert (type, tem);
8666             }
8667         }
8668       else
8669         {
8670           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
8671           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
8672             return non_lvalue (fold_convert (type, arg0));
8673
8674           /* Likewise if the operands are reversed.  */
8675           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
8676             return non_lvalue (fold_convert (type, arg1));
8677
8678           /* Convert X + -C into X - C.  */
8679           if (TREE_CODE (arg1) == REAL_CST
8680               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
8681             {
8682               tem = fold_negate_const (arg1, type);
8683               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
8684                 return fold_build2 (MINUS_EXPR, type,
8685                                     fold_convert (type, arg0),
8686                                     fold_convert (type, tem));
8687             }
8688
8689           if (flag_unsafe_math_optimizations
8690               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
8691               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
8692               && (tem = distribute_real_division (code, type, arg0, arg1)))
8693             return tem;
8694
8695           /* Convert x+x into x*2.0.  */
8696           if (operand_equal_p (arg0, arg1, 0)
8697               && SCALAR_FLOAT_TYPE_P (type))
8698             return fold_build2 (MULT_EXPR, type, arg0,
8699                                 build_real (type, dconst2));
8700
8701           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  */
8702           if (flag_unsafe_math_optimizations
8703               && TREE_CODE (arg1) == PLUS_EXPR
8704               && TREE_CODE (arg0) != MULT_EXPR)
8705             {
8706               tree tree10 = TREE_OPERAND (arg1, 0);
8707               tree tree11 = TREE_OPERAND (arg1, 1);
8708               if (TREE_CODE (tree11) == MULT_EXPR
8709                   && TREE_CODE (tree10) == MULT_EXPR)
8710                 {
8711                   tree tree0;
8712                   tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
8713                   return fold_build2 (PLUS_EXPR, type, tree0, tree11);
8714                 }
8715             }
8716           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  */
8717           if (flag_unsafe_math_optimizations
8718               && TREE_CODE (arg0) == PLUS_EXPR
8719               && TREE_CODE (arg1) != MULT_EXPR)
8720             {
8721               tree tree00 = TREE_OPERAND (arg0, 0);
8722               tree tree01 = TREE_OPERAND (arg0, 1);
8723               if (TREE_CODE (tree01) == MULT_EXPR
8724                   && TREE_CODE (tree00) == MULT_EXPR)
8725                 {
8726                   tree tree0;
8727                   tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
8728                   return fold_build2 (PLUS_EXPR, type, tree00, tree0);
8729                 }
8730             }
8731         }
8732
8733      bit_rotate:
8734       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
8735          is a rotate of A by C1 bits.  */
8736       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
8737          is a rotate of A by B bits.  */
8738       {
8739         enum tree_code code0, code1;
8740         code0 = TREE_CODE (arg0);
8741         code1 = TREE_CODE (arg1);
8742         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
8743              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
8744             && operand_equal_p (TREE_OPERAND (arg0, 0),
8745                                 TREE_OPERAND (arg1, 0), 0)
8746             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
8747           {
8748             tree tree01, tree11;
8749             enum tree_code code01, code11;
8750
8751             tree01 = TREE_OPERAND (arg0, 1);
8752             tree11 = TREE_OPERAND (arg1, 1);
8753             STRIP_NOPS (tree01);
8754             STRIP_NOPS (tree11);
8755             code01 = TREE_CODE (tree01);
8756             code11 = TREE_CODE (tree11);
8757             if (code01 == INTEGER_CST
8758                 && code11 == INTEGER_CST
8759                 && TREE_INT_CST_HIGH (tree01) == 0
8760                 && TREE_INT_CST_HIGH (tree11) == 0
8761                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
8762                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
8763               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
8764                              code0 == LSHIFT_EXPR ? tree01 : tree11);
8765             else if (code11 == MINUS_EXPR)
8766               {
8767                 tree tree110, tree111;
8768                 tree110 = TREE_OPERAND (tree11, 0);
8769                 tree111 = TREE_OPERAND (tree11, 1);
8770                 STRIP_NOPS (tree110);
8771                 STRIP_NOPS (tree111);
8772                 if (TREE_CODE (tree110) == INTEGER_CST
8773                     && 0 == compare_tree_int (tree110,
8774                                               TYPE_PRECISION
8775                                               (TREE_TYPE (TREE_OPERAND
8776                                                           (arg0, 0))))
8777                     && operand_equal_p (tree01, tree111, 0))
8778                   return build2 ((code0 == LSHIFT_EXPR
8779                                   ? LROTATE_EXPR
8780                                   : RROTATE_EXPR),
8781                                  type, TREE_OPERAND (arg0, 0), tree01);
8782               }
8783             else if (code01 == MINUS_EXPR)
8784               {
8785                 tree tree010, tree011;
8786                 tree010 = TREE_OPERAND (tree01, 0);
8787                 tree011 = TREE_OPERAND (tree01, 1);
8788                 STRIP_NOPS (tree010);
8789                 STRIP_NOPS (tree011);
8790                 if (TREE_CODE (tree010) == INTEGER_CST
8791                     && 0 == compare_tree_int (tree010,
8792                                               TYPE_PRECISION
8793                                               (TREE_TYPE (TREE_OPERAND
8794                                                           (arg0, 0))))
8795                     && operand_equal_p (tree11, tree011, 0))
8796                   return build2 ((code0 != LSHIFT_EXPR
8797                                   ? LROTATE_EXPR
8798                                   : RROTATE_EXPR),
8799                                  type, TREE_OPERAND (arg0, 0), tree11);
8800               }
8801           }
8802       }
8803
8804     associate:
8805       /* In most languages, can't associate operations on floats through
8806          parentheses.  Rather than remember where the parentheses were, we
8807          don't associate floats at all, unless the user has specified
8808          -funsafe-math-optimizations.  */
8809
8810       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
8811         {
8812           tree var0, con0, lit0, minus_lit0;
8813           tree var1, con1, lit1, minus_lit1;
8814
8815           /* Split both trees into variables, constants, and literals.  Then
8816              associate each group together, the constants with literals,
8817              then the result with variables.  This increases the chances of
8818              literals being recombined later and of generating relocatable
8819              expressions for the sum of a constant and literal.  */
8820           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
8821           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
8822                              code == MINUS_EXPR);
8823
8824           /* Only do something if we found more than two objects.  Otherwise,
8825              nothing has changed and we risk infinite recursion.  */
8826           if (2 < ((var0 != 0) + (var1 != 0)
8827                    + (con0 != 0) + (con1 != 0)
8828                    + (lit0 != 0) + (lit1 != 0)
8829                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
8830             {
8831               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
8832               if (code == MINUS_EXPR)
8833                 code = PLUS_EXPR;
8834
8835               var0 = associate_trees (var0, var1, code, type);
8836               con0 = associate_trees (con0, con1, code, type);
8837               lit0 = associate_trees (lit0, lit1, code, type);
8838               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
8839
8840               /* Preserve the MINUS_EXPR if the negative part of the literal is
8841                  greater than the positive part.  Otherwise, the multiplicative
8842                  folding code (i.e extract_muldiv) may be fooled in case
8843                  unsigned constants are subtracted, like in the following
8844                  example: ((X*2 + 4) - 8U)/2.  */
8845               if (minus_lit0 && lit0)
8846                 {
8847                   if (TREE_CODE (lit0) == INTEGER_CST
8848                       && TREE_CODE (minus_lit0) == INTEGER_CST
8849                       && tree_int_cst_lt (lit0, minus_lit0))
8850                     {
8851                       minus_lit0 = associate_trees (minus_lit0, lit0,
8852                                                     MINUS_EXPR, type);
8853                       lit0 = 0;
8854                     }
8855                   else
8856                     {
8857                       lit0 = associate_trees (lit0, minus_lit0,
8858                                               MINUS_EXPR, type);
8859                       minus_lit0 = 0;
8860                     }
8861                 }
8862               if (minus_lit0)
8863                 {
8864                   if (con0 == 0)
8865                     return fold_convert (type,
8866                                          associate_trees (var0, minus_lit0,
8867                                                           MINUS_EXPR, type));
8868                   else
8869                     {
8870                       con0 = associate_trees (con0, minus_lit0,
8871                                               MINUS_EXPR, type);
8872                       return fold_convert (type,
8873                                            associate_trees (var0, con0,
8874                                                             PLUS_EXPR, type));
8875                     }
8876                 }
8877
8878               con0 = associate_trees (con0, lit0, code, type);
8879               return fold_convert (type, associate_trees (var0, con0,
8880                                                           code, type));
8881             }
8882         }
8883
8884       return NULL_TREE;
8885
8886     case MINUS_EXPR:
8887       /* A - (-B) -> A + B */
8888       if (TREE_CODE (arg1) == NEGATE_EXPR)
8889         return fold_build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0));
8890       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
8891       if (TREE_CODE (arg0) == NEGATE_EXPR
8892           && (FLOAT_TYPE_P (type)
8893               || INTEGRAL_TYPE_P (type))
8894           && negate_expr_p (arg1)
8895           && reorder_operands_p (arg0, arg1))
8896         return fold_build2 (MINUS_EXPR, type, negate_expr (arg1),
8897                             TREE_OPERAND (arg0, 0));
8898       /* Convert -A - 1 to ~A.  */
8899       if (INTEGRAL_TYPE_P (type)
8900           && TREE_CODE (arg0) == NEGATE_EXPR
8901           && integer_onep (arg1))
8902         return fold_build1 (BIT_NOT_EXPR, type,
8903                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8904
8905       /* Convert -1 - A to ~A.  */
8906       if (INTEGRAL_TYPE_P (type)
8907           && integer_all_onesp (arg0))
8908         return fold_build1 (BIT_NOT_EXPR, type, arg1);
8909
8910       if (! FLOAT_TYPE_P (type))
8911         {
8912           if (integer_zerop (arg0))
8913             return negate_expr (fold_convert (type, arg1));
8914           if (integer_zerop (arg1))
8915             return non_lvalue (fold_convert (type, arg0));
8916
8917           /* Fold A - (A & B) into ~B & A.  */
8918           if (!TREE_SIDE_EFFECTS (arg0)
8919               && TREE_CODE (arg1) == BIT_AND_EXPR)
8920             {
8921               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
8922                 return fold_build2 (BIT_AND_EXPR, type,
8923                                     fold_build1 (BIT_NOT_EXPR, type,
8924                                                  TREE_OPERAND (arg1, 0)),
8925                                     arg0);
8926               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8927                 return fold_build2 (BIT_AND_EXPR, type,
8928                                     fold_build1 (BIT_NOT_EXPR, type,
8929                                                  TREE_OPERAND (arg1, 1)),
8930                                     arg0);
8931             }
8932
8933           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
8934              any power of 2 minus 1.  */
8935           if (TREE_CODE (arg0) == BIT_AND_EXPR
8936               && TREE_CODE (arg1) == BIT_AND_EXPR
8937               && operand_equal_p (TREE_OPERAND (arg0, 0),
8938                                   TREE_OPERAND (arg1, 0), 0))
8939             {
8940               tree mask0 = TREE_OPERAND (arg0, 1);
8941               tree mask1 = TREE_OPERAND (arg1, 1);
8942               tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
8943
8944               if (operand_equal_p (tem, mask1, 0))
8945                 {
8946                   tem = fold_build2 (BIT_XOR_EXPR, type,
8947                                      TREE_OPERAND (arg0, 0), mask1);
8948                   return fold_build2 (MINUS_EXPR, type, tem, mask1);
8949                 }
8950             }
8951         }
8952
8953       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
8954       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
8955         return non_lvalue (fold_convert (type, arg0));
8956
8957       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
8958          ARG0 is zero and X + ARG0 reduces to X, since that would mean
8959          (-ARG1 + ARG0) reduces to -ARG1.  */
8960       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
8961         return negate_expr (fold_convert (type, arg1));
8962
8963       /* Fold &x - &x.  This can happen from &x.foo - &x.
8964          This is unsafe for certain floats even in non-IEEE formats.
8965          In IEEE, it is unsafe because it does wrong for NaNs.
8966          Also note that operand_equal_p is always false if an operand
8967          is volatile.  */
8968
8969       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
8970           && operand_equal_p (arg0, arg1, 0))
8971         return fold_convert (type, integer_zero_node);
8972
8973       /* A - B -> A + (-B) if B is easily negatable.  */
8974       if (negate_expr_p (arg1)
8975           && ((FLOAT_TYPE_P (type)
8976                /* Avoid this transformation if B is a positive REAL_CST.  */
8977                && (TREE_CODE (arg1) != REAL_CST
8978                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
8979               || INTEGRAL_TYPE_P (type)))
8980         return fold_build2 (PLUS_EXPR, type,
8981                             fold_convert (type, arg0),
8982                             fold_convert (type, negate_expr (arg1)));
8983
8984       /* Try folding difference of addresses.  */
8985       {
8986         HOST_WIDE_INT diff;
8987
8988         if ((TREE_CODE (arg0) == ADDR_EXPR
8989              || TREE_CODE (arg1) == ADDR_EXPR)
8990             && ptr_difference_const (arg0, arg1, &diff))
8991           return build_int_cst_type (type, diff);
8992       }
8993
8994       /* Fold &a[i] - &a[j] to i-j.  */
8995       if (TREE_CODE (arg0) == ADDR_EXPR
8996           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
8997           && TREE_CODE (arg1) == ADDR_EXPR
8998           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
8999         {
9000           tree aref0 = TREE_OPERAND (arg0, 0);
9001           tree aref1 = TREE_OPERAND (arg1, 0);
9002           if (operand_equal_p (TREE_OPERAND (aref0, 0),
9003                                TREE_OPERAND (aref1, 0), 0))
9004             {
9005               tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
9006               tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
9007               tree esz = array_ref_element_size (aref0);
9008               tree diff = build2 (MINUS_EXPR, type, op0, op1);
9009               return fold_build2 (MULT_EXPR, type, diff,
9010                                   fold_convert (type, esz));
9011
9012             }
9013         }
9014
9015       /* Try replacing &a[i1] - c * i2 with &a[i1 - i2], if c is step
9016          of the array.  Loop optimizer sometimes produce this type of
9017          expressions.  */
9018       if (TREE_CODE (arg0) == ADDR_EXPR)
9019         {
9020           tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
9021           if (tem)
9022             return fold_convert (type, tem);
9023         }
9024
9025       if (flag_unsafe_math_optimizations
9026           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9027           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9028           && (tem = distribute_real_division (code, type, arg0, arg1)))
9029         return tem;
9030
9031       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
9032          same or one.  */
9033       if ((TREE_CODE (arg0) == MULT_EXPR
9034            || TREE_CODE (arg1) == MULT_EXPR)
9035           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
9036         {
9037           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9038           if (tem)
9039             return tem;
9040         }
9041
9042       goto associate;
9043
9044     case MULT_EXPR:
9045       /* (-A) * (-B) -> A * B  */
9046       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9047         return fold_build2 (MULT_EXPR, type,
9048                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9049                             fold_convert (type, negate_expr (arg1)));
9050       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9051         return fold_build2 (MULT_EXPR, type,
9052                             fold_convert (type, negate_expr (arg0)),
9053                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9054
9055       if (! FLOAT_TYPE_P (type))
9056         {
9057           if (integer_zerop (arg1))
9058             return omit_one_operand (type, arg1, arg0);
9059           if (integer_onep (arg1))
9060             return non_lvalue (fold_convert (type, arg0));
9061           /* Transform x * -1 into -x.  */
9062           if (integer_all_onesp (arg1))
9063             return fold_convert (type, negate_expr (arg0));
9064           /* Transform x * -C into -x * C if x is easily negatable.  */
9065           if (TREE_CODE (arg1) == INTEGER_CST
9066               && tree_int_cst_sgn (arg1) == -1
9067               && negate_expr_p (arg0)
9068               && (tem = negate_expr (arg1)) != arg1
9069               && !TREE_OVERFLOW (tem))
9070             return fold_build2 (MULT_EXPR, type,
9071                                 negate_expr (arg0), tem);
9072
9073           /* (a * (1 << b)) is (a << b)  */
9074           if (TREE_CODE (arg1) == LSHIFT_EXPR
9075               && integer_onep (TREE_OPERAND (arg1, 0)))
9076             return fold_build2 (LSHIFT_EXPR, type, arg0,
9077                                 TREE_OPERAND (arg1, 1));
9078           if (TREE_CODE (arg0) == LSHIFT_EXPR
9079               && integer_onep (TREE_OPERAND (arg0, 0)))
9080             return fold_build2 (LSHIFT_EXPR, type, arg1,
9081                                 TREE_OPERAND (arg0, 1));
9082
9083           if (TREE_CODE (arg1) == INTEGER_CST
9084               && 0 != (tem = extract_muldiv (op0,
9085                                              fold_convert (type, arg1),
9086                                              code, NULL_TREE)))
9087             return fold_convert (type, tem);
9088
9089           /* Optimize z * conj(z) for integer complex numbers.  */
9090           if (TREE_CODE (arg0) == CONJ_EXPR
9091               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9092             return fold_mult_zconjz (type, arg1);
9093           if (TREE_CODE (arg1) == CONJ_EXPR
9094               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9095             return fold_mult_zconjz (type, arg0);
9096         }
9097       else
9098         {
9099           /* Maybe fold x * 0 to 0.  The expressions aren't the same
9100              when x is NaN, since x * 0 is also NaN.  Nor are they the
9101              same in modes with signed zeros, since multiplying a
9102              negative value by 0 gives -0, not +0.  */
9103           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9104               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
9105               && real_zerop (arg1))
9106             return omit_one_operand (type, arg1, arg0);
9107           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
9108           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9109               && real_onep (arg1))
9110             return non_lvalue (fold_convert (type, arg0));
9111
9112           /* Transform x * -1.0 into -x.  */
9113           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9114               && real_minus_onep (arg1))
9115             return fold_convert (type, negate_expr (arg0));
9116
9117           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
9118           if (flag_unsafe_math_optimizations
9119               && TREE_CODE (arg0) == RDIV_EXPR
9120               && TREE_CODE (arg1) == REAL_CST
9121               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
9122             {
9123               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
9124                                       arg1, 0);
9125               if (tem)
9126                 return fold_build2 (RDIV_EXPR, type, tem,
9127                                     TREE_OPERAND (arg0, 1));
9128             }
9129
9130           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
9131           if (operand_equal_p (arg0, arg1, 0))
9132             {
9133               tree tem = fold_strip_sign_ops (arg0);
9134               if (tem != NULL_TREE)
9135                 {
9136                   tem = fold_convert (type, tem);
9137                   return fold_build2 (MULT_EXPR, type, tem, tem);
9138                 }
9139             }
9140
9141           /* Optimize z * conj(z) for floating point complex numbers.
9142              Guarded by flag_unsafe_math_optimizations as non-finite
9143              imaginary components don't produce scalar results.  */
9144           if (flag_unsafe_math_optimizations
9145               && TREE_CODE (arg0) == CONJ_EXPR
9146               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9147             return fold_mult_zconjz (type, arg1);
9148           if (flag_unsafe_math_optimizations
9149               && TREE_CODE (arg1) == CONJ_EXPR
9150               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9151             return fold_mult_zconjz (type, arg0);
9152
9153           if (flag_unsafe_math_optimizations)
9154             {
9155               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
9156               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
9157
9158               /* Optimizations of root(...)*root(...).  */
9159               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
9160                 {
9161                   tree rootfn, arg, arglist;
9162                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9163                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9164
9165                   /* Optimize sqrt(x)*sqrt(x) as x.  */
9166                   if (BUILTIN_SQRT_P (fcode0)
9167                       && operand_equal_p (arg00, arg10, 0)
9168                       && ! HONOR_SNANS (TYPE_MODE (type)))
9169                     return arg00;
9170
9171                   /* Optimize root(x)*root(y) as root(x*y).  */
9172                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9173                   arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
9174                   arglist = build_tree_list (NULL_TREE, arg);
9175                   return build_function_call_expr (rootfn, arglist);
9176                 }
9177
9178               /* Optimize expN(x)*expN(y) as expN(x+y).  */
9179               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
9180                 {
9181                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9182                   tree arg = fold_build2 (PLUS_EXPR, type,
9183                                           TREE_VALUE (TREE_OPERAND (arg0, 1)),
9184                                           TREE_VALUE (TREE_OPERAND (arg1, 1)));
9185                   tree arglist = build_tree_list (NULL_TREE, arg);
9186                   return build_function_call_expr (expfn, arglist);
9187                 }
9188
9189               /* Optimizations of pow(...)*pow(...).  */
9190               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
9191                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
9192                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
9193                 {
9194                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9195                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9196                                                                      1)));
9197                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9198                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9199                                                                      1)));
9200
9201                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
9202                   if (operand_equal_p (arg01, arg11, 0))
9203                     {
9204                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9205                       tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
9206                       tree arglist = tree_cons (NULL_TREE, arg,
9207                                                 build_tree_list (NULL_TREE,
9208                                                                  arg01));
9209                       return build_function_call_expr (powfn, arglist);
9210                     }
9211
9212                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
9213                   if (operand_equal_p (arg00, arg10, 0))
9214                     {
9215                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9216                       tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
9217                       tree arglist = tree_cons (NULL_TREE, arg00,
9218                                                 build_tree_list (NULL_TREE,
9219                                                                  arg));
9220                       return build_function_call_expr (powfn, arglist);
9221                     }
9222                 }
9223
9224               /* Optimize tan(x)*cos(x) as sin(x).  */
9225               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
9226                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
9227                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
9228                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
9229                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
9230                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
9231                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9232                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9233                 {
9234                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
9235
9236                   if (sinfn != NULL_TREE)
9237                     return build_function_call_expr (sinfn,
9238                                                      TREE_OPERAND (arg0, 1));
9239                 }
9240
9241               /* Optimize x*pow(x,c) as pow(x,c+1).  */
9242               if (fcode1 == BUILT_IN_POW
9243                   || fcode1 == BUILT_IN_POWF
9244                   || fcode1 == BUILT_IN_POWL)
9245                 {
9246                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9247                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9248                                                                      1)));
9249                   if (TREE_CODE (arg11) == REAL_CST
9250                       && ! TREE_CONSTANT_OVERFLOW (arg11)
9251                       && operand_equal_p (arg0, arg10, 0))
9252                     {
9253                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9254                       REAL_VALUE_TYPE c;
9255                       tree arg, arglist;
9256
9257                       c = TREE_REAL_CST (arg11);
9258                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9259                       arg = build_real (type, c);
9260                       arglist = build_tree_list (NULL_TREE, arg);
9261                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9262                       return build_function_call_expr (powfn, arglist);
9263                     }
9264                 }
9265
9266               /* Optimize pow(x,c)*x as pow(x,c+1).  */
9267               if (fcode0 == BUILT_IN_POW
9268                   || fcode0 == BUILT_IN_POWF
9269                   || fcode0 == BUILT_IN_POWL)
9270                 {
9271                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9272                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9273                                                                      1)));
9274                   if (TREE_CODE (arg01) == REAL_CST
9275                       && ! TREE_CONSTANT_OVERFLOW (arg01)
9276                       && operand_equal_p (arg1, arg00, 0))
9277                     {
9278                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9279                       REAL_VALUE_TYPE c;
9280                       tree arg, arglist;
9281
9282                       c = TREE_REAL_CST (arg01);
9283                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9284                       arg = build_real (type, c);
9285                       arglist = build_tree_list (NULL_TREE, arg);
9286                       arglist = tree_cons (NULL_TREE, arg1, arglist);
9287                       return build_function_call_expr (powfn, arglist);
9288                     }
9289                 }
9290
9291               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
9292               if (! optimize_size
9293                   && operand_equal_p (arg0, arg1, 0))
9294                 {
9295                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
9296
9297                   if (powfn)
9298                     {
9299                       tree arg = build_real (type, dconst2);
9300                       tree arglist = build_tree_list (NULL_TREE, arg);
9301                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9302                       return build_function_call_expr (powfn, arglist);
9303                     }
9304                 }
9305             }
9306         }
9307       goto associate;
9308
9309     case BIT_IOR_EXPR:
9310     bit_ior:
9311       if (integer_all_onesp (arg1))
9312         return omit_one_operand (type, arg1, arg0);
9313       if (integer_zerop (arg1))
9314         return non_lvalue (fold_convert (type, arg0));
9315       if (operand_equal_p (arg0, arg1, 0))
9316         return non_lvalue (fold_convert (type, arg0));
9317
9318       /* ~X | X is -1.  */
9319       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9320           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9321         {
9322           t1 = build_int_cst (type, -1);
9323           t1 = force_fit_type (t1, 0, false, false);
9324           return omit_one_operand (type, t1, arg1);
9325         }
9326
9327       /* X | ~X is -1.  */
9328       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9329           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9330         {
9331           t1 = build_int_cst (type, -1);
9332           t1 = force_fit_type (t1, 0, false, false);
9333           return omit_one_operand (type, t1, arg0);
9334         }
9335
9336       /* Canonicalize (X & C1) | C2.  */
9337       if (TREE_CODE (arg0) == BIT_AND_EXPR
9338           && TREE_CODE (arg1) == INTEGER_CST
9339           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9340         {
9341           unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, mlo, mhi;
9342           int width = TYPE_PRECISION (type);
9343           hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
9344           lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
9345           hi2 = TREE_INT_CST_HIGH (arg1);
9346           lo2 = TREE_INT_CST_LOW (arg1);
9347
9348           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
9349           if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
9350             return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9351
9352           if (width > HOST_BITS_PER_WIDE_INT)
9353             {
9354               mhi = (unsigned HOST_WIDE_INT) -1
9355                     >> (2 * HOST_BITS_PER_WIDE_INT - width);
9356               mlo = -1;
9357             }
9358           else
9359             {
9360               mhi = 0;
9361               mlo = (unsigned HOST_WIDE_INT) -1
9362                     >> (HOST_BITS_PER_WIDE_INT - width);
9363             }
9364
9365           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
9366           if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
9367             return fold_build2 (BIT_IOR_EXPR, type,
9368                                 TREE_OPERAND (arg0, 0), arg1);
9369
9370           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2.  */
9371           hi1 &= mhi;
9372           lo1 &= mlo;
9373           if ((hi1 & ~hi2) != hi1 || (lo1 & ~lo2) != lo1)
9374             return fold_build2 (BIT_IOR_EXPR, type,
9375                                 fold_build2 (BIT_AND_EXPR, type,
9376                                              TREE_OPERAND (arg0, 0),
9377                                              build_int_cst_wide (type,
9378                                                                  lo1 & ~lo2,
9379                                                                  hi1 & ~hi2)),
9380                                 arg1);
9381         }
9382
9383       /* (X & Y) | Y is (X, Y).  */
9384       if (TREE_CODE (arg0) == BIT_AND_EXPR
9385           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9386         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9387       /* (X & Y) | X is (Y, X).  */
9388       if (TREE_CODE (arg0) == BIT_AND_EXPR
9389           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9390           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9391         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9392       /* X | (X & Y) is (Y, X).  */
9393       if (TREE_CODE (arg1) == BIT_AND_EXPR
9394           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9395           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9396         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9397       /* X | (Y & X) is (Y, X).  */
9398       if (TREE_CODE (arg1) == BIT_AND_EXPR
9399           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9400           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9401         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9402
9403       t1 = distribute_bit_expr (code, type, arg0, arg1);
9404       if (t1 != NULL_TREE)
9405         return t1;
9406
9407       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
9408
9409          This results in more efficient code for machines without a NAND
9410          instruction.  Combine will canonicalize to the first form
9411          which will allow use of NAND instructions provided by the
9412          backend if they exist.  */
9413       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9414           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9415         {
9416           return fold_build1 (BIT_NOT_EXPR, type,
9417                               build2 (BIT_AND_EXPR, type,
9418                                       TREE_OPERAND (arg0, 0),
9419                                       TREE_OPERAND (arg1, 0)));
9420         }
9421
9422       /* See if this can be simplified into a rotate first.  If that
9423          is unsuccessful continue in the association code.  */
9424       goto bit_rotate;
9425
9426     case BIT_XOR_EXPR:
9427       if (integer_zerop (arg1))
9428         return non_lvalue (fold_convert (type, arg0));
9429       if (integer_all_onesp (arg1))
9430         return fold_build1 (BIT_NOT_EXPR, type, arg0);
9431       if (operand_equal_p (arg0, arg1, 0))
9432         return omit_one_operand (type, integer_zero_node, arg0);
9433
9434       /* ~X ^ X is -1.  */
9435       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9436           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9437         {
9438           t1 = build_int_cst (type, -1);
9439           t1 = force_fit_type (t1, 0, false, false);
9440           return omit_one_operand (type, t1, arg1);
9441         }
9442
9443       /* X ^ ~X is -1.  */
9444       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9445           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9446         {
9447           t1 = build_int_cst (type, -1);
9448           t1 = force_fit_type (t1, 0, false, false);
9449           return omit_one_operand (type, t1, arg0);
9450         }
9451
9452       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
9453          with a constant, and the two constants have no bits in common,
9454          we should treat this as a BIT_IOR_EXPR since this may produce more
9455          simplifications.  */
9456       if (TREE_CODE (arg0) == BIT_AND_EXPR
9457           && TREE_CODE (arg1) == BIT_AND_EXPR
9458           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9459           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9460           && integer_zerop (const_binop (BIT_AND_EXPR,
9461                                          TREE_OPERAND (arg0, 1),
9462                                          TREE_OPERAND (arg1, 1), 0)))
9463         {
9464           code = BIT_IOR_EXPR;
9465           goto bit_ior;
9466         }
9467
9468       /* (X | Y) ^ X -> Y & ~ X*/
9469       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9470           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9471         {
9472           tree t2 = TREE_OPERAND (arg0, 1);
9473           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9474                             arg1);
9475           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9476                             fold_convert (type, t1));
9477           return t1;
9478         }
9479
9480       /* (Y | X) ^ X -> Y & ~ X*/
9481       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9482           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9483         {
9484           tree t2 = TREE_OPERAND (arg0, 0);
9485           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9486                             arg1);
9487           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9488                             fold_convert (type, t1));
9489           return t1;
9490         }
9491
9492       /* X ^ (X | Y) -> Y & ~ X*/
9493       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9494           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
9495         {
9496           tree t2 = TREE_OPERAND (arg1, 1);
9497           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9498                             arg0);
9499           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9500                             fold_convert (type, t1));
9501           return t1;
9502         }
9503
9504       /* X ^ (Y | X) -> Y & ~ X*/
9505       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9506           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
9507         {
9508           tree t2 = TREE_OPERAND (arg1, 0);
9509           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9510                             arg0);
9511           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9512                             fold_convert (type, t1));
9513           return t1;
9514         }
9515
9516       /* Convert ~X ^ ~Y to X ^ Y.  */
9517       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9518           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9519         return fold_build2 (code, type,
9520                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9521                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9522
9523       /* Convert ~X ^ C to X ^ ~C.  */
9524       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9525           && TREE_CODE (arg1) == INTEGER_CST)
9526         return fold_build2 (code, type,
9527                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9528                             fold_build1 (BIT_NOT_EXPR, type, arg1));
9529
9530       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
9531       if (TREE_CODE (arg0) == BIT_AND_EXPR
9532           && integer_onep (TREE_OPERAND (arg0, 1))
9533           && integer_onep (arg1))
9534         return fold_build2 (EQ_EXPR, type, arg0,
9535                             build_int_cst (TREE_TYPE (arg0), 0));
9536
9537       /* Fold (X & Y) ^ Y as ~X & Y.  */
9538       if (TREE_CODE (arg0) == BIT_AND_EXPR
9539           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9540         {
9541           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9542           return fold_build2 (BIT_AND_EXPR, type,
9543                               fold_build1 (BIT_NOT_EXPR, type, tem),
9544                               fold_convert (type, arg1));
9545         }
9546       /* Fold (X & Y) ^ X as ~Y & X.  */
9547       if (TREE_CODE (arg0) == BIT_AND_EXPR
9548           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9549           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9550         {
9551           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9552           return fold_build2 (BIT_AND_EXPR, type,
9553                               fold_build1 (BIT_NOT_EXPR, type, tem),
9554                               fold_convert (type, arg1));
9555         }
9556       /* Fold X ^ (X & Y) as X & ~Y.  */
9557       if (TREE_CODE (arg1) == BIT_AND_EXPR
9558           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9559         {
9560           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9561           return fold_build2 (BIT_AND_EXPR, type,
9562                               fold_convert (type, arg0),
9563                               fold_build1 (BIT_NOT_EXPR, type, tem));
9564         }
9565       /* Fold X ^ (Y & X) as ~Y & X.  */
9566       if (TREE_CODE (arg1) == BIT_AND_EXPR
9567           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9568           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9569         {
9570           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9571           return fold_build2 (BIT_AND_EXPR, type,
9572                               fold_build1 (BIT_NOT_EXPR, type, tem),
9573                               fold_convert (type, arg0));
9574         }
9575
9576       /* See if this can be simplified into a rotate first.  If that
9577          is unsuccessful continue in the association code.  */
9578       goto bit_rotate;
9579
9580     case BIT_AND_EXPR:
9581       if (integer_all_onesp (arg1))
9582         return non_lvalue (fold_convert (type, arg0));
9583       if (integer_zerop (arg1))
9584         return omit_one_operand (type, arg1, arg0);
9585       if (operand_equal_p (arg0, arg1, 0))
9586         return non_lvalue (fold_convert (type, arg0));
9587
9588       /* ~X & X is always zero.  */
9589       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9590           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9591         return omit_one_operand (type, integer_zero_node, arg1);
9592
9593       /* X & ~X is always zero.  */
9594       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9595           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9596         return omit_one_operand (type, integer_zero_node, arg0);
9597
9598       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
9599       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9600           && TREE_CODE (arg1) == INTEGER_CST
9601           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9602         return fold_build2 (BIT_IOR_EXPR, type,
9603                             fold_build2 (BIT_AND_EXPR, type,
9604                                          TREE_OPERAND (arg0, 0), arg1),
9605                             fold_build2 (BIT_AND_EXPR, type,
9606                                          TREE_OPERAND (arg0, 1), arg1));
9607
9608       /* (X | Y) & Y is (X, Y).  */
9609       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9610           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9611         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9612       /* (X | Y) & X is (Y, X).  */
9613       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9614           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9615           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9616         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9617       /* X & (X | Y) is (Y, X).  */
9618       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9619           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9620           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9621         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9622       /* X & (Y | X) is (Y, X).  */
9623       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9624           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9625           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9626         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9627
9628       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
9629       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9630           && integer_onep (TREE_OPERAND (arg0, 1))
9631           && integer_onep (arg1))
9632         {
9633           tem = TREE_OPERAND (arg0, 0);
9634           return fold_build2 (EQ_EXPR, type,
9635                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9636                                            build_int_cst (TREE_TYPE (tem), 1)),
9637                               build_int_cst (TREE_TYPE (tem), 0));
9638         }
9639       /* Fold ~X & 1 as (X & 1) == 0.  */
9640       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9641           && integer_onep (arg1))
9642         {
9643           tem = TREE_OPERAND (arg0, 0);
9644           return fold_build2 (EQ_EXPR, type,
9645                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9646                                            build_int_cst (TREE_TYPE (tem), 1)),
9647                               build_int_cst (TREE_TYPE (tem), 0));
9648         }
9649
9650       /* Fold (X ^ Y) & Y as ~X & Y.  */
9651       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9652           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9653         {
9654           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9655           return fold_build2 (BIT_AND_EXPR, type,
9656                               fold_build1 (BIT_NOT_EXPR, type, tem),
9657                               fold_convert (type, arg1));
9658         }
9659       /* Fold (X ^ Y) & X as ~Y & X.  */
9660       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9661           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9662           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9663         {
9664           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9665           return fold_build2 (BIT_AND_EXPR, type,
9666                               fold_build1 (BIT_NOT_EXPR, type, tem),
9667                               fold_convert (type, arg1));
9668         }
9669       /* Fold X & (X ^ Y) as X & ~Y.  */
9670       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9671           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9672         {
9673           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9674           return fold_build2 (BIT_AND_EXPR, type,
9675                               fold_convert (type, arg0),
9676                               fold_build1 (BIT_NOT_EXPR, type, tem));
9677         }
9678       /* Fold X & (Y ^ X) as ~Y & X.  */
9679       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9680           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9681           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9682         {
9683           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9684           return fold_build2 (BIT_AND_EXPR, type,
9685                               fold_build1 (BIT_NOT_EXPR, type, tem),
9686                               fold_convert (type, arg0));
9687         }
9688
9689       t1 = distribute_bit_expr (code, type, arg0, arg1);
9690       if (t1 != NULL_TREE)
9691         return t1;
9692       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
9693       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
9694           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
9695         {
9696           unsigned int prec
9697             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
9698
9699           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
9700               && (~TREE_INT_CST_LOW (arg1)
9701                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
9702             return fold_convert (type, TREE_OPERAND (arg0, 0));
9703         }
9704
9705       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
9706
9707          This results in more efficient code for machines without a NOR
9708          instruction.  Combine will canonicalize to the first form
9709          which will allow use of NOR instructions provided by the
9710          backend if they exist.  */
9711       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9712           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9713         {
9714           return fold_build1 (BIT_NOT_EXPR, type,
9715                               build2 (BIT_IOR_EXPR, type,
9716                                       TREE_OPERAND (arg0, 0),
9717                                       TREE_OPERAND (arg1, 0)));
9718         }
9719
9720       goto associate;
9721
9722     case RDIV_EXPR:
9723       /* Don't touch a floating-point divide by zero unless the mode
9724          of the constant can represent infinity.  */
9725       if (TREE_CODE (arg1) == REAL_CST
9726           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
9727           && real_zerop (arg1))
9728         return NULL_TREE;
9729
9730       /* Optimize A / A to 1.0 if we don't care about
9731          NaNs or Infinities.  Skip the transformation
9732          for non-real operands.  */
9733       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
9734           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9735           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
9736           && operand_equal_p (arg0, arg1, 0))
9737         {
9738           tree r = build_real (TREE_TYPE (arg0), dconst1);
9739
9740           return omit_two_operands (type, r, arg0, arg1);
9741         }
9742
9743       /* The complex version of the above A / A optimization.  */
9744       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
9745           && operand_equal_p (arg0, arg1, 0))
9746         {
9747           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
9748           if (! HONOR_NANS (TYPE_MODE (elem_type))
9749               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
9750             {
9751               tree r = build_real (elem_type, dconst1);
9752               /* omit_two_operands will call fold_convert for us.  */
9753               return omit_two_operands (type, r, arg0, arg1);
9754             }
9755         }
9756
9757       /* (-A) / (-B) -> A / B  */
9758       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9759         return fold_build2 (RDIV_EXPR, type,
9760                             TREE_OPERAND (arg0, 0),
9761                             negate_expr (arg1));
9762       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9763         return fold_build2 (RDIV_EXPR, type,
9764                             negate_expr (arg0),
9765                             TREE_OPERAND (arg1, 0));
9766
9767       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
9768       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9769           && real_onep (arg1))
9770         return non_lvalue (fold_convert (type, arg0));
9771
9772       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
9773       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9774           && real_minus_onep (arg1))
9775         return non_lvalue (fold_convert (type, negate_expr (arg0)));
9776
9777       /* If ARG1 is a constant, we can convert this to a multiply by the
9778          reciprocal.  This does not have the same rounding properties,
9779          so only do this if -funsafe-math-optimizations.  We can actually
9780          always safely do it if ARG1 is a power of two, but it's hard to
9781          tell if it is or not in a portable manner.  */
9782       if (TREE_CODE (arg1) == REAL_CST)
9783         {
9784           if (flag_unsafe_math_optimizations
9785               && 0 != (tem = const_binop (code, build_real (type, dconst1),
9786                                           arg1, 0)))
9787             return fold_build2 (MULT_EXPR, type, arg0, tem);
9788           /* Find the reciprocal if optimizing and the result is exact.  */
9789           if (optimize)
9790             {
9791               REAL_VALUE_TYPE r;
9792               r = TREE_REAL_CST (arg1);
9793               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
9794                 {
9795                   tem = build_real (type, r);
9796                   return fold_build2 (MULT_EXPR, type,
9797                                       fold_convert (type, arg0), tem);
9798                 }
9799             }
9800         }
9801       /* Convert A/B/C to A/(B*C).  */
9802       if (flag_unsafe_math_optimizations
9803           && TREE_CODE (arg0) == RDIV_EXPR)
9804         return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
9805                             fold_build2 (MULT_EXPR, type,
9806                                          TREE_OPERAND (arg0, 1), arg1));
9807
9808       /* Convert A/(B/C) to (A/B)*C.  */
9809       if (flag_unsafe_math_optimizations
9810           && TREE_CODE (arg1) == RDIV_EXPR)
9811         return fold_build2 (MULT_EXPR, type,
9812                             fold_build2 (RDIV_EXPR, type, arg0,
9813                                          TREE_OPERAND (arg1, 0)),
9814                             TREE_OPERAND (arg1, 1));
9815
9816       /* Convert C1/(X*C2) into (C1/C2)/X.  */
9817       if (flag_unsafe_math_optimizations
9818           && TREE_CODE (arg1) == MULT_EXPR
9819           && TREE_CODE (arg0) == REAL_CST
9820           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
9821         {
9822           tree tem = const_binop (RDIV_EXPR, arg0,
9823                                   TREE_OPERAND (arg1, 1), 0);
9824           if (tem)
9825             return fold_build2 (RDIV_EXPR, type, tem,
9826                                 TREE_OPERAND (arg1, 0));
9827         }
9828
9829       if (flag_unsafe_math_optimizations)
9830         {
9831           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
9832           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
9833
9834           /* Optimize sin(x)/cos(x) as tan(x).  */
9835           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
9836                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
9837                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
9838               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9839                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9840             {
9841               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9842
9843               if (tanfn != NULL_TREE)
9844                 return build_function_call_expr (tanfn,
9845                                                  TREE_OPERAND (arg0, 1));
9846             }
9847
9848           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
9849           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
9850                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
9851                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
9852               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9853                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9854             {
9855               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9856
9857               if (tanfn != NULL_TREE)
9858                 {
9859                   tree tmp = TREE_OPERAND (arg0, 1);
9860                   tmp = build_function_call_expr (tanfn, tmp);
9861                   return fold_build2 (RDIV_EXPR, type,
9862                                       build_real (type, dconst1), tmp);
9863                 }
9864             }
9865
9866           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
9867              NaNs or Infinities.  */
9868           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
9869                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
9870                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
9871             {
9872               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9873               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9874
9875               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9876                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9877                   && operand_equal_p (arg00, arg01, 0))
9878                 {
9879                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9880
9881                   if (cosfn != NULL_TREE)
9882                     return build_function_call_expr (cosfn,
9883                                                      TREE_OPERAND (arg0, 1));
9884                 }
9885             }
9886
9887           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
9888              NaNs or Infinities.  */
9889           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
9890                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
9891                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
9892             {
9893               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9894               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9895
9896               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9897                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9898                   && operand_equal_p (arg00, arg01, 0))
9899                 {
9900                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9901
9902                   if (cosfn != NULL_TREE)
9903                     {
9904                       tree tmp = TREE_OPERAND (arg0, 1);
9905                       tmp = build_function_call_expr (cosfn, tmp);
9906                       return fold_build2 (RDIV_EXPR, type,
9907                                           build_real (type, dconst1),
9908                                           tmp);
9909                     }
9910                 }
9911             }
9912
9913           /* Optimize pow(x,c)/x as pow(x,c-1).  */
9914           if (fcode0 == BUILT_IN_POW
9915               || fcode0 == BUILT_IN_POWF
9916               || fcode0 == BUILT_IN_POWL)
9917             {
9918               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9919               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
9920               if (TREE_CODE (arg01) == REAL_CST
9921                   && ! TREE_CONSTANT_OVERFLOW (arg01)
9922                   && operand_equal_p (arg1, arg00, 0))
9923                 {
9924                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9925                   REAL_VALUE_TYPE c;
9926                   tree arg, arglist;
9927
9928                   c = TREE_REAL_CST (arg01);
9929                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
9930                   arg = build_real (type, c);
9931                   arglist = build_tree_list (NULL_TREE, arg);
9932                   arglist = tree_cons (NULL_TREE, arg1, arglist);
9933                   return build_function_call_expr (powfn, arglist);
9934                 }
9935             }
9936
9937           /* Optimize x/expN(y) into x*expN(-y).  */
9938           if (BUILTIN_EXPONENT_P (fcode1))
9939             {
9940               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9941               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
9942               tree arglist = build_tree_list (NULL_TREE,
9943                                               fold_convert (type, arg));
9944               arg1 = build_function_call_expr (expfn, arglist);
9945               return fold_build2 (MULT_EXPR, type, arg0, arg1);
9946             }
9947
9948           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
9949           if (fcode1 == BUILT_IN_POW
9950               || fcode1 == BUILT_IN_POWF
9951               || fcode1 == BUILT_IN_POWL)
9952             {
9953               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9954               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9955               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
9956               tree neg11 = fold_convert (type, negate_expr (arg11));
9957               tree arglist = tree_cons(NULL_TREE, arg10,
9958                                        build_tree_list (NULL_TREE, neg11));
9959               arg1 = build_function_call_expr (powfn, arglist);
9960               return fold_build2 (MULT_EXPR, type, arg0, arg1);
9961             }
9962         }
9963       return NULL_TREE;
9964
9965     case TRUNC_DIV_EXPR:
9966     case FLOOR_DIV_EXPR:
9967       /* Simplify A / (B << N) where A and B are positive and B is
9968          a power of 2, to A >> (N + log2(B)).  */
9969       if (TREE_CODE (arg1) == LSHIFT_EXPR
9970           && (TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (arg0)))
9971         {
9972           tree sval = TREE_OPERAND (arg1, 0);
9973           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
9974             {
9975               tree sh_cnt = TREE_OPERAND (arg1, 1);
9976               unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
9977
9978               sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
9979                                     sh_cnt, build_int_cst (NULL_TREE, pow2));
9980               return fold_build2 (RSHIFT_EXPR, type,
9981                                   fold_convert (type, arg0), sh_cnt);
9982             }
9983         }
9984       /* Fall thru */
9985
9986     case ROUND_DIV_EXPR:
9987     case CEIL_DIV_EXPR:
9988     case EXACT_DIV_EXPR:
9989       if (integer_onep (arg1))
9990         return non_lvalue (fold_convert (type, arg0));
9991       if (integer_zerop (arg1))
9992         return NULL_TREE;
9993       /* X / -1 is -X.  */
9994       if (!TYPE_UNSIGNED (type)
9995           && TREE_CODE (arg1) == INTEGER_CST
9996           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
9997           && TREE_INT_CST_HIGH (arg1) == -1)
9998         return fold_convert (type, negate_expr (arg0));
9999
10000       /* Convert -A / -B to A / B when the type is signed and overflow is
10001          undefined.  */
10002       if (!TYPE_UNSIGNED (type) && !flag_wrapv
10003           && TREE_CODE (arg0) == NEGATE_EXPR
10004           && negate_expr_p (arg1))
10005         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10006                             negate_expr (arg1));
10007       if (!TYPE_UNSIGNED (type) && !flag_wrapv
10008           && TREE_CODE (arg1) == NEGATE_EXPR
10009           && negate_expr_p (arg0))
10010         return fold_build2 (code, type, negate_expr (arg0),
10011                             TREE_OPERAND (arg1, 0));
10012
10013       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10014          operation, EXACT_DIV_EXPR.
10015
10016          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10017          At one time others generated faster code, it's not clear if they do
10018          after the last round to changes to the DIV code in expmed.c.  */
10019       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
10020           && multiple_of_p (type, arg0, arg1))
10021         return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
10022
10023       if (TREE_CODE (arg1) == INTEGER_CST
10024           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
10025         return fold_convert (type, tem);
10026
10027       return NULL_TREE;
10028
10029     case CEIL_MOD_EXPR:
10030     case FLOOR_MOD_EXPR:
10031     case ROUND_MOD_EXPR:
10032     case TRUNC_MOD_EXPR:
10033       /* X % 1 is always zero, but be sure to preserve any side
10034          effects in X.  */
10035       if (integer_onep (arg1))
10036         return omit_one_operand (type, integer_zero_node, arg0);
10037
10038       /* X % 0, return X % 0 unchanged so that we can get the
10039          proper warnings and errors.  */
10040       if (integer_zerop (arg1))
10041         return NULL_TREE;
10042
10043       /* 0 % X is always zero, but be sure to preserve any side
10044          effects in X.  Place this after checking for X == 0.  */
10045       if (integer_zerop (arg0))
10046         return omit_one_operand (type, integer_zero_node, arg1);
10047
10048       /* X % -1 is zero.  */
10049       if (!TYPE_UNSIGNED (type)
10050           && TREE_CODE (arg1) == INTEGER_CST
10051           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
10052           && TREE_INT_CST_HIGH (arg1) == -1)
10053         return omit_one_operand (type, integer_zero_node, arg0);
10054
10055       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
10056          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
10057       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
10058           && (TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (arg0)))
10059         {
10060           tree c = arg1;
10061           /* Also optimize A % (C << N)  where C is a power of 2,
10062              to A & ((C << N) - 1).  */
10063           if (TREE_CODE (arg1) == LSHIFT_EXPR)
10064             c = TREE_OPERAND (arg1, 0);
10065
10066           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
10067             {
10068               tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1),
10069                                        arg1, integer_one_node);
10070               return fold_build2 (BIT_AND_EXPR, type,
10071                                   fold_convert (type, arg0),
10072                                   fold_convert (type, mask));
10073             }
10074         }
10075
10076       /* X % -C is the same as X % C.  */
10077       if (code == TRUNC_MOD_EXPR
10078           && !TYPE_UNSIGNED (type)
10079           && TREE_CODE (arg1) == INTEGER_CST
10080           && !TREE_CONSTANT_OVERFLOW (arg1)
10081           && TREE_INT_CST_HIGH (arg1) < 0
10082           && !flag_trapv
10083           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
10084           && !sign_bit_p (arg1, arg1))
10085         return fold_build2 (code, type, fold_convert (type, arg0),
10086                             fold_convert (type, negate_expr (arg1)));
10087
10088       /* X % -Y is the same as X % Y.  */
10089       if (code == TRUNC_MOD_EXPR
10090           && !TYPE_UNSIGNED (type)
10091           && TREE_CODE (arg1) == NEGATE_EXPR
10092           && !flag_trapv)
10093         return fold_build2 (code, type, fold_convert (type, arg0),
10094                             fold_convert (type, TREE_OPERAND (arg1, 0)));
10095
10096       if (TREE_CODE (arg1) == INTEGER_CST
10097           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
10098         return fold_convert (type, tem);
10099
10100       return NULL_TREE;
10101
10102     case LROTATE_EXPR:
10103     case RROTATE_EXPR:
10104       if (integer_all_onesp (arg0))
10105         return omit_one_operand (type, arg0, arg1);
10106       goto shift;
10107
10108     case RSHIFT_EXPR:
10109       /* Optimize -1 >> x for arithmetic right shifts.  */
10110       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
10111         return omit_one_operand (type, arg0, arg1);
10112       /* ... fall through ...  */
10113
10114     case LSHIFT_EXPR:
10115     shift:
10116       if (integer_zerop (arg1))
10117         return non_lvalue (fold_convert (type, arg0));
10118       if (integer_zerop (arg0))
10119         return omit_one_operand (type, arg0, arg1);
10120
10121       /* Since negative shift count is not well-defined,
10122          don't try to compute it in the compiler.  */
10123       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
10124         return NULL_TREE;
10125
10126       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
10127       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
10128           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
10129           && host_integerp (TREE_OPERAND (arg0, 1), false)
10130           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
10131         {
10132           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
10133                                + TREE_INT_CST_LOW (arg1));
10134
10135           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
10136              being well defined.  */
10137           if (low >= TYPE_PRECISION (type))
10138             {
10139               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
10140                 low = low % TYPE_PRECISION (type);
10141               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
10142                 return build_int_cst (type, 0);
10143               else
10144                 low = TYPE_PRECISION (type) - 1;
10145             }
10146
10147           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10148                               build_int_cst (type, low));
10149         }
10150
10151       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
10152          into x & ((unsigned)-1 >> c) for unsigned types.  */
10153       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
10154            || (TYPE_UNSIGNED (type)
10155                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
10156           && host_integerp (arg1, false)
10157           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
10158           && host_integerp (TREE_OPERAND (arg0, 1), false)
10159           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
10160         {
10161           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10162           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
10163           tree lshift;
10164           tree arg00;
10165
10166           if (low0 == low1)
10167             {
10168               arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10169
10170               lshift = build_int_cst (type, -1);
10171               lshift = int_const_binop (code, lshift, arg1, 0);
10172
10173               return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
10174             }
10175         }
10176
10177       /* Rewrite an LROTATE_EXPR by a constant into an
10178          RROTATE_EXPR by a new constant.  */
10179       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
10180         {
10181           tree tem = build_int_cst (NULL_TREE,
10182                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
10183           tem = fold_convert (TREE_TYPE (arg1), tem);
10184           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
10185           return fold_build2 (RROTATE_EXPR, type, arg0, tem);
10186         }
10187
10188       /* If we have a rotate of a bit operation with the rotate count and
10189          the second operand of the bit operation both constant,
10190          permute the two operations.  */
10191       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10192           && (TREE_CODE (arg0) == BIT_AND_EXPR
10193               || TREE_CODE (arg0) == BIT_IOR_EXPR
10194               || TREE_CODE (arg0) == BIT_XOR_EXPR)
10195           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10196         return fold_build2 (TREE_CODE (arg0), type,
10197                             fold_build2 (code, type,
10198                                          TREE_OPERAND (arg0, 0), arg1),
10199                             fold_build2 (code, type,
10200                                          TREE_OPERAND (arg0, 1), arg1));
10201
10202       /* Two consecutive rotates adding up to the width of the mode can
10203          be ignored.  */
10204       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10205           && TREE_CODE (arg0) == RROTATE_EXPR
10206           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10207           && TREE_INT_CST_HIGH (arg1) == 0
10208           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
10209           && ((TREE_INT_CST_LOW (arg1)
10210                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
10211               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
10212         return TREE_OPERAND (arg0, 0);
10213
10214       return NULL_TREE;
10215
10216     case MIN_EXPR:
10217       if (operand_equal_p (arg0, arg1, 0))
10218         return omit_one_operand (type, arg0, arg1);
10219       if (INTEGRAL_TYPE_P (type)
10220           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
10221         return omit_one_operand (type, arg1, arg0);
10222       tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
10223       if (tem)
10224         return tem;
10225       goto associate;
10226
10227     case MAX_EXPR:
10228       if (operand_equal_p (arg0, arg1, 0))
10229         return omit_one_operand (type, arg0, arg1);
10230       if (INTEGRAL_TYPE_P (type)
10231           && TYPE_MAX_VALUE (type)
10232           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
10233         return omit_one_operand (type, arg1, arg0);
10234       tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
10235       if (tem)
10236         return tem;
10237       goto associate;
10238
10239     case TRUTH_ANDIF_EXPR:
10240       /* Note that the operands of this must be ints
10241          and their values must be 0 or 1.
10242          ("true" is a fixed value perhaps depending on the language.)  */
10243       /* If first arg is constant zero, return it.  */
10244       if (integer_zerop (arg0))
10245         return fold_convert (type, arg0);
10246     case TRUTH_AND_EXPR:
10247       /* If either arg is constant true, drop it.  */
10248       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10249         return non_lvalue (fold_convert (type, arg1));
10250       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
10251           /* Preserve sequence points.  */
10252           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10253         return non_lvalue (fold_convert (type, arg0));
10254       /* If second arg is constant zero, result is zero, but first arg
10255          must be evaluated.  */
10256       if (integer_zerop (arg1))
10257         return omit_one_operand (type, arg1, arg0);
10258       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10259          case will be handled here.  */
10260       if (integer_zerop (arg0))
10261         return omit_one_operand (type, arg0, arg1);
10262
10263       /* !X && X is always false.  */
10264       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10265           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10266         return omit_one_operand (type, integer_zero_node, arg1);
10267       /* X && !X is always false.  */
10268       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10269           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10270         return omit_one_operand (type, integer_zero_node, arg0);
10271
10272       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
10273          means A >= Y && A != MAX, but in this case we know that
10274          A < X <= MAX.  */
10275
10276       if (!TREE_SIDE_EFFECTS (arg0)
10277           && !TREE_SIDE_EFFECTS (arg1))
10278         {
10279           tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
10280           if (tem && !operand_equal_p (tem, arg0, 0))
10281             return fold_build2 (code, type, tem, arg1);
10282
10283           tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
10284           if (tem && !operand_equal_p (tem, arg1, 0))
10285             return fold_build2 (code, type, arg0, tem);
10286         }
10287
10288     truth_andor:
10289       /* We only do these simplifications if we are optimizing.  */
10290       if (!optimize)
10291         return NULL_TREE;
10292
10293       /* Check for things like (A || B) && (A || C).  We can convert this
10294          to A || (B && C).  Note that either operator can be any of the four
10295          truth and/or operations and the transformation will still be
10296          valid.   Also note that we only care about order for the
10297          ANDIF and ORIF operators.  If B contains side effects, this
10298          might change the truth-value of A.  */
10299       if (TREE_CODE (arg0) == TREE_CODE (arg1)
10300           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
10301               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
10302               || TREE_CODE (arg0) == TRUTH_AND_EXPR
10303               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
10304           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
10305         {
10306           tree a00 = TREE_OPERAND (arg0, 0);
10307           tree a01 = TREE_OPERAND (arg0, 1);
10308           tree a10 = TREE_OPERAND (arg1, 0);
10309           tree a11 = TREE_OPERAND (arg1, 1);
10310           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
10311                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
10312                              && (code == TRUTH_AND_EXPR
10313                                  || code == TRUTH_OR_EXPR));
10314
10315           if (operand_equal_p (a00, a10, 0))
10316             return fold_build2 (TREE_CODE (arg0), type, a00,
10317                                 fold_build2 (code, type, a01, a11));
10318           else if (commutative && operand_equal_p (a00, a11, 0))
10319             return fold_build2 (TREE_CODE (arg0), type, a00,
10320                                 fold_build2 (code, type, a01, a10));
10321           else if (commutative && operand_equal_p (a01, a10, 0))
10322             return fold_build2 (TREE_CODE (arg0), type, a01,
10323                                 fold_build2 (code, type, a00, a11));
10324
10325           /* This case if tricky because we must either have commutative
10326              operators or else A10 must not have side-effects.  */
10327
10328           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
10329                    && operand_equal_p (a01, a11, 0))
10330             return fold_build2 (TREE_CODE (arg0), type,
10331                                 fold_build2 (code, type, a00, a10),
10332                                 a01);
10333         }
10334
10335       /* See if we can build a range comparison.  */
10336       if (0 != (tem = fold_range_test (code, type, op0, op1)))
10337         return tem;
10338
10339       /* Check for the possibility of merging component references.  If our
10340          lhs is another similar operation, try to merge its rhs with our
10341          rhs.  Then try to merge our lhs and rhs.  */
10342       if (TREE_CODE (arg0) == code
10343           && 0 != (tem = fold_truthop (code, type,
10344                                        TREE_OPERAND (arg0, 1), arg1)))
10345         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10346
10347       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
10348         return tem;
10349
10350       return NULL_TREE;
10351
10352     case TRUTH_ORIF_EXPR:
10353       /* Note that the operands of this must be ints
10354          and their values must be 0 or true.
10355          ("true" is a fixed value perhaps depending on the language.)  */
10356       /* If first arg is constant true, return it.  */
10357       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10358         return fold_convert (type, arg0);
10359     case TRUTH_OR_EXPR:
10360       /* If either arg is constant zero, drop it.  */
10361       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
10362         return non_lvalue (fold_convert (type, arg1));
10363       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
10364           /* Preserve sequence points.  */
10365           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10366         return non_lvalue (fold_convert (type, arg0));
10367       /* If second arg is constant true, result is true, but we must
10368          evaluate first arg.  */
10369       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
10370         return omit_one_operand (type, arg1, arg0);
10371       /* Likewise for first arg, but note this only occurs here for
10372          TRUTH_OR_EXPR.  */
10373       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10374         return omit_one_operand (type, arg0, arg1);
10375
10376       /* !X || X is always true.  */
10377       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10378           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10379         return omit_one_operand (type, integer_one_node, arg1);
10380       /* X || !X is always true.  */
10381       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10382           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10383         return omit_one_operand (type, integer_one_node, arg0);
10384
10385       goto truth_andor;
10386
10387     case TRUTH_XOR_EXPR:
10388       /* If the second arg is constant zero, drop it.  */
10389       if (integer_zerop (arg1))
10390         return non_lvalue (fold_convert (type, arg0));
10391       /* If the second arg is constant true, this is a logical inversion.  */
10392       if (integer_onep (arg1))
10393         {
10394           /* Only call invert_truthvalue if operand is a truth value.  */
10395           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
10396             tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
10397           else
10398             tem = invert_truthvalue (arg0);
10399           return non_lvalue (fold_convert (type, tem));
10400         }
10401       /* Identical arguments cancel to zero.  */
10402       if (operand_equal_p (arg0, arg1, 0))
10403         return omit_one_operand (type, integer_zero_node, arg0);
10404
10405       /* !X ^ X is always true.  */
10406       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10407           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10408         return omit_one_operand (type, integer_one_node, arg1);
10409
10410       /* X ^ !X is always true.  */
10411       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10412           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10413         return omit_one_operand (type, integer_one_node, arg0);
10414
10415       return NULL_TREE;
10416
10417     case EQ_EXPR:
10418     case NE_EXPR:
10419       tem = fold_comparison (code, type, op0, op1);
10420       if (tem != NULL_TREE)
10421         return tem;
10422
10423       /* bool_var != 0 becomes bool_var. */
10424       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10425           && code == NE_EXPR)
10426         return non_lvalue (fold_convert (type, arg0));
10427
10428       /* bool_var == 1 becomes bool_var. */
10429       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10430           && code == EQ_EXPR)
10431         return non_lvalue (fold_convert (type, arg0));
10432
10433       /* bool_var != 1 becomes !bool_var. */
10434       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10435           && code == NE_EXPR)
10436         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10437
10438       /* bool_var == 0 becomes !bool_var. */
10439       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10440           && code == EQ_EXPR)
10441         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10442
10443       /* If this is an equality comparison of the address of a non-weak
10444          object against zero, then we know the result.  */
10445       if (TREE_CODE (arg0) == ADDR_EXPR
10446           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10447           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10448           && integer_zerop (arg1))
10449         return constant_boolean_node (code != EQ_EXPR, type);
10450
10451       /* If this is an equality comparison of the address of two non-weak,
10452          unaliased symbols neither of which are extern (since we do not
10453          have access to attributes for externs), then we know the result.  */
10454       if (TREE_CODE (arg0) == ADDR_EXPR
10455           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10456           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10457           && ! lookup_attribute ("alias",
10458                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
10459           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
10460           && TREE_CODE (arg1) == ADDR_EXPR
10461           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
10462           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
10463           && ! lookup_attribute ("alias",
10464                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
10465           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
10466         {
10467           /* We know that we're looking at the address of two
10468              non-weak, unaliased, static _DECL nodes.
10469
10470              It is both wasteful and incorrect to call operand_equal_p
10471              to compare the two ADDR_EXPR nodes.  It is wasteful in that
10472              all we need to do is test pointer equality for the arguments
10473              to the two ADDR_EXPR nodes.  It is incorrect to use
10474              operand_equal_p as that function is NOT equivalent to a
10475              C equality test.  It can in fact return false for two
10476              objects which would test as equal using the C equality
10477              operator.  */
10478           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
10479           return constant_boolean_node (equal
10480                                         ? code == EQ_EXPR : code != EQ_EXPR,
10481                                         type);
10482         }
10483
10484       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
10485          a MINUS_EXPR of a constant, we can convert it into a comparison with
10486          a revised constant as long as no overflow occurs.  */
10487       if (TREE_CODE (arg1) == INTEGER_CST
10488           && (TREE_CODE (arg0) == PLUS_EXPR
10489               || TREE_CODE (arg0) == MINUS_EXPR)
10490           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10491           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
10492                                       ? MINUS_EXPR : PLUS_EXPR,
10493                                       fold_convert (TREE_TYPE (arg0), arg1),
10494                                       TREE_OPERAND (arg0, 1), 0))
10495           && ! TREE_CONSTANT_OVERFLOW (tem))
10496         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10497
10498       /* Similarly for a NEGATE_EXPR.  */
10499       if (TREE_CODE (arg0) == NEGATE_EXPR
10500           && TREE_CODE (arg1) == INTEGER_CST
10501           && 0 != (tem = negate_expr (arg1))
10502           && TREE_CODE (tem) == INTEGER_CST
10503           && ! TREE_CONSTANT_OVERFLOW (tem))
10504         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10505
10506       /* If we have X - Y == 0, we can convert that to X == Y and similarly
10507          for !=.  Don't do this for ordered comparisons due to overflow.  */
10508       if (TREE_CODE (arg0) == MINUS_EXPR
10509           && integer_zerop (arg1))
10510         return fold_build2 (code, type,
10511                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
10512
10513       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
10514       if (TREE_CODE (arg0) == ABS_EXPR
10515           && (integer_zerop (arg1) || real_zerop (arg1)))
10516         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
10517
10518       /* If this is an EQ or NE comparison with zero and ARG0 is
10519          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
10520          two operations, but the latter can be done in one less insn
10521          on machines that have only two-operand insns or on which a
10522          constant cannot be the first operand.  */
10523       if (TREE_CODE (arg0) == BIT_AND_EXPR
10524           && integer_zerop (arg1))
10525         {
10526           tree arg00 = TREE_OPERAND (arg0, 0);
10527           tree arg01 = TREE_OPERAND (arg0, 1);
10528           if (TREE_CODE (arg00) == LSHIFT_EXPR
10529               && integer_onep (TREE_OPERAND (arg00, 0)))
10530             return
10531               fold_build2 (code, type,
10532                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10533                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
10534                                            arg01, TREE_OPERAND (arg00, 1)),
10535                                    fold_convert (TREE_TYPE (arg0),
10536                                                  integer_one_node)),
10537                            arg1);
10538           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
10539                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
10540             return
10541               fold_build2 (code, type,
10542                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10543                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
10544                                            arg00, TREE_OPERAND (arg01, 1)),
10545                                    fold_convert (TREE_TYPE (arg0),
10546                                                  integer_one_node)),
10547                            arg1);
10548         }
10549
10550       /* If this is an NE or EQ comparison of zero against the result of a
10551          signed MOD operation whose second operand is a power of 2, make
10552          the MOD operation unsigned since it is simpler and equivalent.  */
10553       if (integer_zerop (arg1)
10554           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
10555           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
10556               || TREE_CODE (arg0) == CEIL_MOD_EXPR
10557               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
10558               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
10559           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10560         {
10561           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
10562           tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
10563                                      fold_convert (newtype,
10564                                                    TREE_OPERAND (arg0, 0)),
10565                                      fold_convert (newtype,
10566                                                    TREE_OPERAND (arg0, 1)));
10567
10568           return fold_build2 (code, type, newmod,
10569                               fold_convert (newtype, arg1));
10570         }
10571
10572       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10573          C1 is a valid shift constant, and C2 is a power of two, i.e.
10574          a single bit.  */
10575       if (TREE_CODE (arg0) == BIT_AND_EXPR
10576           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
10577           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
10578              == INTEGER_CST
10579           && integer_pow2p (TREE_OPERAND (arg0, 1))
10580           && integer_zerop (arg1))
10581         {
10582           tree itype = TREE_TYPE (arg0);
10583           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
10584           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
10585
10586           /* Check for a valid shift count.  */
10587           if (TREE_INT_CST_HIGH (arg001) == 0
10588               && TREE_INT_CST_LOW (arg001) < prec)
10589             {
10590               tree arg01 = TREE_OPERAND (arg0, 1);
10591               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10592               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
10593               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10594                  can be rewritten as (X & (C2 << C1)) != 0.  */
10595               if ((log2 + TREE_INT_CST_LOW (arg01)) < prec)
10596                 {
10597                   tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
10598                   tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
10599                   return fold_build2 (code, type, tem, arg1);
10600                 }
10601               /* Otherwise, for signed (arithmetic) shifts,
10602                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10603                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
10604               else if (!TYPE_UNSIGNED (itype))
10605                 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
10606                                     arg000, build_int_cst (itype, 0));
10607               /* Otherwise, of unsigned (logical) shifts,
10608                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10609                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
10610               else
10611                 return omit_one_operand (type,
10612                                          code == EQ_EXPR ? integer_one_node
10613                                                          : integer_zero_node,
10614                                          arg000);
10615             }
10616         }
10617
10618       /* If this is an NE comparison of zero with an AND of one, remove the
10619          comparison since the AND will give the correct value.  */
10620       if (code == NE_EXPR
10621           && integer_zerop (arg1)
10622           && TREE_CODE (arg0) == BIT_AND_EXPR
10623           && integer_onep (TREE_OPERAND (arg0, 1)))
10624         return fold_convert (type, arg0);
10625
10626       /* If we have (A & C) == C where C is a power of 2, convert this into
10627          (A & C) != 0.  Similarly for NE_EXPR.  */
10628       if (TREE_CODE (arg0) == BIT_AND_EXPR
10629           && integer_pow2p (TREE_OPERAND (arg0, 1))
10630           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10631         return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10632                             arg0, fold_convert (TREE_TYPE (arg0),
10633                                                 integer_zero_node));
10634
10635       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
10636          bit, then fold the expression into A < 0 or A >= 0.  */
10637       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
10638       if (tem)
10639         return tem;
10640
10641       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10642          Similarly for NE_EXPR.  */
10643       if (TREE_CODE (arg0) == BIT_AND_EXPR
10644           && TREE_CODE (arg1) == INTEGER_CST
10645           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10646         {
10647           tree notc = fold_build1 (BIT_NOT_EXPR,
10648                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
10649                                    TREE_OPERAND (arg0, 1));
10650           tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10651                                        arg1, notc);
10652           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10653           if (integer_nonzerop (dandnotc))
10654             return omit_one_operand (type, rslt, arg0);
10655         }
10656
10657       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
10658          Similarly for NE_EXPR.  */
10659       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10660           && TREE_CODE (arg1) == INTEGER_CST
10661           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10662         {
10663           tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
10664           tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10665                                        TREE_OPERAND (arg0, 1), notd);
10666           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10667           if (integer_nonzerop (candnotd))
10668             return omit_one_operand (type, rslt, arg0);
10669         }
10670
10671       /* If this is a comparison of a field, we may be able to simplify it.  */
10672       if (((TREE_CODE (arg0) == COMPONENT_REF
10673             && lang_hooks.can_use_bit_fields_p ())
10674            || TREE_CODE (arg0) == BIT_FIELD_REF)
10675           /* Handle the constant case even without -O
10676              to make sure the warnings are given.  */
10677           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
10678         {
10679           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
10680           if (t1)
10681             return t1;
10682         }
10683
10684       /* Optimize comparisons of strlen vs zero to a compare of the
10685          first character of the string vs zero.  To wit,
10686                 strlen(ptr) == 0   =>  *ptr == 0
10687                 strlen(ptr) != 0   =>  *ptr != 0
10688          Other cases should reduce to one of these two (or a constant)
10689          due to the return value of strlen being unsigned.  */
10690       if (TREE_CODE (arg0) == CALL_EXPR
10691           && integer_zerop (arg1))
10692         {
10693           tree fndecl = get_callee_fndecl (arg0);
10694           tree arglist;
10695
10696           if (fndecl
10697               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
10698               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
10699               && (arglist = TREE_OPERAND (arg0, 1))
10700               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
10701               && ! TREE_CHAIN (arglist))
10702             {
10703               tree iref = build_fold_indirect_ref (TREE_VALUE (arglist));
10704               return fold_build2 (code, type, iref,
10705                                   build_int_cst (TREE_TYPE (iref), 0));
10706             }
10707         }
10708
10709       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10710          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
10711       if (TREE_CODE (arg0) == RSHIFT_EXPR
10712           && integer_zerop (arg1)
10713           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10714         {
10715           tree arg00 = TREE_OPERAND (arg0, 0);
10716           tree arg01 = TREE_OPERAND (arg0, 1);
10717           tree itype = TREE_TYPE (arg00);
10718           if (TREE_INT_CST_HIGH (arg01) == 0
10719               && TREE_INT_CST_LOW (arg01)
10720                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
10721             {
10722               if (TYPE_UNSIGNED (itype))
10723                 {
10724                   itype = lang_hooks.types.signed_type (itype);
10725                   arg00 = fold_convert (itype, arg00);
10726                 }
10727               return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
10728                                   type, arg00, build_int_cst (itype, 0));
10729             }
10730         }
10731
10732       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
10733       if (integer_zerop (arg1)
10734           && TREE_CODE (arg0) == BIT_XOR_EXPR)
10735         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10736                             TREE_OPERAND (arg0, 1));
10737
10738       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
10739       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10740           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10741         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10742                             build_int_cst (TREE_TYPE (arg1), 0));
10743       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
10744       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10745           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10746           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10747         return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
10748                             build_int_cst (TREE_TYPE (arg1), 0));
10749
10750       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
10751       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10752           && TREE_CODE (arg1) == INTEGER_CST
10753           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10754         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10755                             fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
10756                                          TREE_OPERAND (arg0, 1), arg1));
10757
10758       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10759          (X & C) == 0 when C is a single bit.  */
10760       if (TREE_CODE (arg0) == BIT_AND_EXPR
10761           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
10762           && integer_zerop (arg1)
10763           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10764         {
10765           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10766                              TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
10767                              TREE_OPERAND (arg0, 1));
10768           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
10769                               type, tem, arg1);
10770         }
10771
10772       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10773          constant C is a power of two, i.e. a single bit.  */
10774       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10775           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
10776           && integer_zerop (arg1)
10777           && integer_pow2p (TREE_OPERAND (arg0, 1))
10778           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10779                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10780         {
10781           tree arg00 = TREE_OPERAND (arg0, 0);
10782           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10783                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
10784         }
10785
10786       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10787          when is C is a power of two, i.e. a single bit.  */
10788       if (TREE_CODE (arg0) == BIT_AND_EXPR
10789           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
10790           && integer_zerop (arg1)
10791           && integer_pow2p (TREE_OPERAND (arg0, 1))
10792           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10793                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10794         {
10795           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10796           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
10797                              arg000, TREE_OPERAND (arg0, 1));
10798           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10799                               tem, build_int_cst (TREE_TYPE (tem), 0));
10800         }
10801
10802       if (integer_zerop (arg1)
10803           && tree_expr_nonzero_p (arg0))
10804         {
10805           tree res = constant_boolean_node (code==NE_EXPR, type);
10806           return omit_one_operand (type, res, arg0);
10807         }
10808
10809       /* Fold -X op -Y as X op Y, where op is eq/ne.  */
10810       if (TREE_CODE (arg0) == NEGATE_EXPR
10811           && TREE_CODE (arg1) == NEGATE_EXPR)
10812         return fold_build2 (code, type,
10813                             TREE_OPERAND (arg0, 0),
10814                             TREE_OPERAND (arg1, 0));
10815
10816       return NULL_TREE;
10817
10818     case LT_EXPR:
10819     case GT_EXPR:
10820     case LE_EXPR:
10821     case GE_EXPR:
10822       tem = fold_comparison (code, type, op0, op1);
10823       if (tem != NULL_TREE)
10824         return tem;
10825
10826       /* Transform comparisons of the form X +- C CMP X.  */
10827       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
10828           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10829           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
10830                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
10831               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10832                   && !TYPE_UNSIGNED (TREE_TYPE (arg1))
10833                   && !(flag_wrapv || flag_trapv))))
10834         {
10835           tree arg01 = TREE_OPERAND (arg0, 1);
10836           enum tree_code code0 = TREE_CODE (arg0);
10837           int is_positive;
10838
10839           if (TREE_CODE (arg01) == REAL_CST)
10840             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
10841           else
10842             is_positive = tree_int_cst_sgn (arg01);
10843
10844           /* (X - c) > X becomes false.  */
10845           if (code == GT_EXPR
10846               && ((code0 == MINUS_EXPR && is_positive >= 0)
10847                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10848             return constant_boolean_node (0, type);
10849
10850           /* Likewise (X + c) < X becomes false.  */
10851           if (code == LT_EXPR
10852               && ((code0 == PLUS_EXPR && is_positive >= 0)
10853                   || (code0 == MINUS_EXPR && is_positive <= 0)))
10854             return constant_boolean_node (0, type);
10855
10856           /* Convert (X - c) <= X to true.  */
10857           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
10858               && code == LE_EXPR
10859               && ((code0 == MINUS_EXPR && is_positive >= 0)
10860                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10861             return constant_boolean_node (1, type);
10862
10863           /* Convert (X + c) >= X to true.  */
10864           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
10865               && code == GE_EXPR
10866               && ((code0 == PLUS_EXPR && is_positive >= 0)
10867                   || (code0 == MINUS_EXPR && is_positive <= 0)))
10868             return constant_boolean_node (1, type);
10869
10870           if (TREE_CODE (arg01) == INTEGER_CST)
10871             {
10872               /* Convert X + c > X and X - c < X to true for integers.  */
10873               if (code == GT_EXPR
10874                   && ((code0 == PLUS_EXPR && is_positive > 0)
10875                       || (code0 == MINUS_EXPR && is_positive < 0)))
10876                 return constant_boolean_node (1, type);
10877
10878               if (code == LT_EXPR
10879                   && ((code0 == MINUS_EXPR && is_positive > 0)
10880                       || (code0 == PLUS_EXPR && is_positive < 0)))
10881                 return constant_boolean_node (1, type);
10882
10883               /* Convert X + c <= X and X - c >= X to false for integers.  */
10884               if (code == LE_EXPR
10885                   && ((code0 == PLUS_EXPR && is_positive > 0)
10886                       || (code0 == MINUS_EXPR && is_positive < 0)))
10887                 return constant_boolean_node (0, type);
10888
10889               if (code == GE_EXPR
10890                   && ((code0 == MINUS_EXPR && is_positive > 0)
10891                       || (code0 == PLUS_EXPR && is_positive < 0)))
10892                 return constant_boolean_node (0, type);
10893             }
10894         }
10895
10896       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
10897          This transformation affects the cases which are handled in later
10898          optimizations involving comparisons with non-negative constants.  */
10899       if (TREE_CODE (arg1) == INTEGER_CST
10900           && TREE_CODE (arg0) != INTEGER_CST
10901           && tree_int_cst_sgn (arg1) > 0)
10902         {
10903           if (code == GE_EXPR)
10904             {
10905               arg1 = const_binop (MINUS_EXPR, arg1,
10906                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
10907               return fold_build2 (GT_EXPR, type, arg0,
10908                                   fold_convert (TREE_TYPE (arg0), arg1));
10909             }
10910           if (code == LT_EXPR)
10911             {
10912               arg1 = const_binop (MINUS_EXPR, arg1,
10913                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
10914               return fold_build2 (LE_EXPR, type, arg0,
10915                                   fold_convert (TREE_TYPE (arg0), arg1));
10916             }
10917         }
10918
10919       /* Comparisons with the highest or lowest possible integer of
10920          the specified size will have known values.  */
10921       {
10922         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
10923
10924         if (TREE_CODE (arg1) == INTEGER_CST
10925             && ! TREE_CONSTANT_OVERFLOW (arg1)
10926             && width <= 2 * HOST_BITS_PER_WIDE_INT
10927             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10928                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
10929           {
10930             HOST_WIDE_INT signed_max_hi;
10931             unsigned HOST_WIDE_INT signed_max_lo;
10932             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
10933
10934             if (width <= HOST_BITS_PER_WIDE_INT)
10935               {
10936                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
10937                                 - 1;
10938                 signed_max_hi = 0;
10939                 max_hi = 0;
10940
10941                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
10942                   {
10943                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
10944                     min_lo = 0;
10945                     min_hi = 0;
10946                   }
10947                 else
10948                   {
10949                     max_lo = signed_max_lo;
10950                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
10951                     min_hi = -1;
10952                   }
10953               }
10954             else
10955               {
10956                 width -= HOST_BITS_PER_WIDE_INT;
10957                 signed_max_lo = -1;
10958                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
10959                                 - 1;
10960                 max_lo = -1;
10961                 min_lo = 0;
10962
10963                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
10964                   {
10965                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
10966                     min_hi = 0;
10967                   }
10968                 else
10969                   {
10970                     max_hi = signed_max_hi;
10971                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
10972                   }
10973               }
10974
10975             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
10976                 && TREE_INT_CST_LOW (arg1) == max_lo)
10977               switch (code)
10978                 {
10979                 case GT_EXPR:
10980                   return omit_one_operand (type, integer_zero_node, arg0);
10981
10982                 case GE_EXPR:
10983                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
10984
10985                 case LE_EXPR:
10986                   return omit_one_operand (type, integer_one_node, arg0);
10987
10988                 case LT_EXPR:
10989                   return fold_build2 (NE_EXPR, type, arg0, arg1);
10990
10991                 /* The GE_EXPR and LT_EXPR cases above are not normally
10992                    reached because of previous transformations.  */
10993
10994                 default:
10995                   break;
10996                 }
10997             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
10998                      == max_hi
10999                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
11000               switch (code)
11001                 {
11002                 case GT_EXPR:
11003                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
11004                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
11005                 case LE_EXPR:
11006                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
11007                   return fold_build2 (NE_EXPR, type, arg0, arg1);
11008                 default:
11009                   break;
11010                 }
11011             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
11012                      == min_hi
11013                      && TREE_INT_CST_LOW (arg1) == min_lo)
11014               switch (code)
11015                 {
11016                 case LT_EXPR:
11017                   return omit_one_operand (type, integer_zero_node, arg0);
11018
11019                 case LE_EXPR:
11020                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
11021
11022                 case GE_EXPR:
11023                   return omit_one_operand (type, integer_one_node, arg0);
11024
11025                 case GT_EXPR:
11026                   return fold_build2 (NE_EXPR, type, op0, op1);
11027
11028                 default:
11029                   break;
11030                 }
11031             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
11032                      == min_hi
11033                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
11034               switch (code)
11035                 {
11036                 case GE_EXPR:
11037                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
11038                   return fold_build2 (NE_EXPR, type, arg0, arg1);
11039                 case LT_EXPR:
11040                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
11041                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
11042                 default:
11043                   break;
11044                 }
11045
11046             else if (!in_gimple_form
11047                      && TREE_INT_CST_HIGH (arg1) == signed_max_hi
11048                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
11049                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
11050                      /* signed_type does not work on pointer types.  */
11051                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
11052               {
11053                 /* The following case also applies to X < signed_max+1
11054                    and X >= signed_max+1 because previous transformations.  */
11055                 if (code == LE_EXPR || code == GT_EXPR)
11056                   {
11057                     tree st0, st1;
11058                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
11059                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
11060                     return fold_build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
11061                                         type, fold_convert (st0, arg0),
11062                                         build_int_cst (st1, 0));
11063                   }
11064               }
11065           }
11066       }
11067
11068       /* If we are comparing an ABS_EXPR with a constant, we can
11069          convert all the cases into explicit comparisons, but they may
11070          well not be faster than doing the ABS and one comparison.
11071          But ABS (X) <= C is a range comparison, which becomes a subtraction
11072          and a comparison, and is probably faster.  */
11073       if (code == LE_EXPR
11074           && TREE_CODE (arg1) == INTEGER_CST
11075           && TREE_CODE (arg0) == ABS_EXPR
11076           && ! TREE_SIDE_EFFECTS (arg0)
11077           && (0 != (tem = negate_expr (arg1)))
11078           && TREE_CODE (tem) == INTEGER_CST
11079           && ! TREE_CONSTANT_OVERFLOW (tem))
11080         return fold_build2 (TRUTH_ANDIF_EXPR, type,
11081                             build2 (GE_EXPR, type,
11082                                     TREE_OPERAND (arg0, 0), tem),
11083                             build2 (LE_EXPR, type,
11084                                     TREE_OPERAND (arg0, 0), arg1));
11085
11086       /* Convert ABS_EXPR<x> >= 0 to true.  */
11087       if (code == GE_EXPR
11088           && tree_expr_nonnegative_p (arg0)
11089           && (integer_zerop (arg1)
11090               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11091                   && real_zerop (arg1))))
11092         return omit_one_operand (type, integer_one_node, arg0);
11093
11094       /* Convert ABS_EXPR<x> < 0 to false.  */
11095       if (code == LT_EXPR
11096           && tree_expr_nonnegative_p (arg0)
11097           && (integer_zerop (arg1) || real_zerop (arg1)))
11098         return omit_one_operand (type, integer_zero_node, arg0);
11099
11100       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11101          and similarly for >= into !=.  */
11102       if ((code == LT_EXPR || code == GE_EXPR)
11103           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11104           && TREE_CODE (arg1) == LSHIFT_EXPR
11105           && integer_onep (TREE_OPERAND (arg1, 0)))
11106         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11107                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11108                                TREE_OPERAND (arg1, 1)),
11109                        build_int_cst (TREE_TYPE (arg0), 0));
11110
11111       if ((code == LT_EXPR || code == GE_EXPR)
11112           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11113           && (TREE_CODE (arg1) == NOP_EXPR
11114               || TREE_CODE (arg1) == CONVERT_EXPR)
11115           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
11116           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
11117         return
11118           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11119                   fold_convert (TREE_TYPE (arg0),
11120                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11121                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
11122                                                       1))),
11123                   build_int_cst (TREE_TYPE (arg0), 0));
11124
11125       return NULL_TREE;
11126
11127     case UNORDERED_EXPR:
11128     case ORDERED_EXPR:
11129     case UNLT_EXPR:
11130     case UNLE_EXPR:
11131     case UNGT_EXPR:
11132     case UNGE_EXPR:
11133     case UNEQ_EXPR:
11134     case LTGT_EXPR:
11135       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
11136         {
11137           t1 = fold_relational_const (code, type, arg0, arg1);
11138           if (t1 != NULL_TREE)
11139             return t1;
11140         }
11141
11142       /* If the first operand is NaN, the result is constant.  */
11143       if (TREE_CODE (arg0) == REAL_CST
11144           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
11145           && (code != LTGT_EXPR || ! flag_trapping_math))
11146         {
11147           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
11148                ? integer_zero_node
11149                : integer_one_node;
11150           return omit_one_operand (type, t1, arg1);
11151         }
11152
11153       /* If the second operand is NaN, the result is constant.  */
11154       if (TREE_CODE (arg1) == REAL_CST
11155           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
11156           && (code != LTGT_EXPR || ! flag_trapping_math))
11157         {
11158           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
11159                ? integer_zero_node
11160                : integer_one_node;
11161           return omit_one_operand (type, t1, arg0);
11162         }
11163
11164       /* Simplify unordered comparison of something with itself.  */
11165       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
11166           && operand_equal_p (arg0, arg1, 0))
11167         return constant_boolean_node (1, type);
11168
11169       if (code == LTGT_EXPR
11170           && !flag_trapping_math
11171           && operand_equal_p (arg0, arg1, 0))
11172         return constant_boolean_node (0, type);
11173
11174       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
11175       {
11176         tree targ0 = strip_float_extensions (arg0);
11177         tree targ1 = strip_float_extensions (arg1);
11178         tree newtype = TREE_TYPE (targ0);
11179
11180         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
11181           newtype = TREE_TYPE (targ1);
11182
11183         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
11184           return fold_build2 (code, type, fold_convert (newtype, targ0),
11185                               fold_convert (newtype, targ1));
11186       }
11187
11188       return NULL_TREE;
11189
11190     case COMPOUND_EXPR:
11191       /* When pedantic, a compound expression can be neither an lvalue
11192          nor an integer constant expression.  */
11193       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
11194         return NULL_TREE;
11195       /* Don't let (0, 0) be null pointer constant.  */
11196       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11197                                  : fold_convert (type, arg1);
11198       return pedantic_non_lvalue (tem);
11199
11200     case COMPLEX_EXPR:
11201       if ((TREE_CODE (arg0) == REAL_CST
11202            && TREE_CODE (arg1) == REAL_CST)
11203           || (TREE_CODE (arg0) == INTEGER_CST
11204               && TREE_CODE (arg1) == INTEGER_CST))
11205         return build_complex (type, arg0, arg1);
11206       return NULL_TREE;
11207
11208     case ASSERT_EXPR:
11209       /* An ASSERT_EXPR should never be passed to fold_binary.  */
11210       gcc_unreachable ();
11211
11212     default:
11213       return NULL_TREE;
11214     } /* switch (code) */
11215 }
11216
11217 /* Callback for walk_tree, looking for LABEL_EXPR.
11218    Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
11219    Do not check the sub-tree of GOTO_EXPR.  */
11220
11221 static tree
11222 contains_label_1 (tree *tp,
11223                   int *walk_subtrees,
11224                   void *data ATTRIBUTE_UNUSED)
11225 {
11226   switch (TREE_CODE (*tp))
11227     {
11228     case LABEL_EXPR:
11229       return *tp;
11230     case GOTO_EXPR:
11231       *walk_subtrees = 0;
11232     /* no break */
11233     default:
11234       return NULL_TREE;
11235     }
11236 }
11237
11238 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
11239    accessible from outside the sub-tree. Returns NULL_TREE if no
11240    addressable label is found.  */
11241
11242 static bool
11243 contains_label_p (tree st)
11244 {
11245   return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
11246 }
11247
11248 /* Fold a ternary expression of code CODE and type TYPE with operands
11249    OP0, OP1, and OP2.  Return the folded expression if folding is
11250    successful.  Otherwise, return NULL_TREE.  */
11251
11252 tree
11253 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
11254 {
11255   tree tem;
11256   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
11257   enum tree_code_class kind = TREE_CODE_CLASS (code);
11258
11259   gcc_assert (IS_EXPR_CODE_CLASS (kind)
11260               && TREE_CODE_LENGTH (code) == 3);
11261
11262   /* Strip any conversions that don't change the mode.  This is safe
11263      for every expression, except for a comparison expression because
11264      its signedness is derived from its operands.  So, in the latter
11265      case, only strip conversions that don't change the signedness.
11266
11267      Note that this is done as an internal manipulation within the
11268      constant folder, in order to find the simplest representation of
11269      the arguments so that their form can be studied.  In any cases,
11270      the appropriate type conversions should be put back in the tree
11271      that will get out of the constant folder.  */
11272   if (op0)
11273     {
11274       arg0 = op0;
11275       STRIP_NOPS (arg0);
11276     }
11277
11278   if (op1)
11279     {
11280       arg1 = op1;
11281       STRIP_NOPS (arg1);
11282     }
11283
11284   switch (code)
11285     {
11286     case COMPONENT_REF:
11287       if (TREE_CODE (arg0) == CONSTRUCTOR
11288           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
11289         {
11290           unsigned HOST_WIDE_INT idx;
11291           tree field, value;
11292           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
11293             if (field == arg1)
11294               return value;
11295         }
11296       return NULL_TREE;
11297
11298     case COND_EXPR:
11299       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11300          so all simple results must be passed through pedantic_non_lvalue.  */
11301       if (TREE_CODE (arg0) == INTEGER_CST)
11302         {
11303           tree unused_op = integer_zerop (arg0) ? op1 : op2;
11304           tem = integer_zerop (arg0) ? op2 : op1;
11305           /* Only optimize constant conditions when the selected branch
11306              has the same type as the COND_EXPR.  This avoids optimizing
11307              away "c ? x : throw", where the throw has a void type.
11308              Avoid throwing away that operand which contains label.  */
11309           if ((!TREE_SIDE_EFFECTS (unused_op)
11310                || !contains_label_p (unused_op))
11311               && (! VOID_TYPE_P (TREE_TYPE (tem))
11312                   || VOID_TYPE_P (type)))
11313             return pedantic_non_lvalue (tem);
11314           return NULL_TREE;
11315         }
11316       if (operand_equal_p (arg1, op2, 0))
11317         return pedantic_omit_one_operand (type, arg1, arg0);
11318
11319       /* If we have A op B ? A : C, we may be able to convert this to a
11320          simpler expression, depending on the operation and the values
11321          of B and C.  Signed zeros prevent all of these transformations,
11322          for reasons given above each one.
11323
11324          Also try swapping the arguments and inverting the conditional.  */
11325       if (COMPARISON_CLASS_P (arg0)
11326           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11327                                              arg1, TREE_OPERAND (arg0, 1))
11328           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
11329         {
11330           tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
11331           if (tem)
11332             return tem;
11333         }
11334
11335       if (COMPARISON_CLASS_P (arg0)
11336           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11337                                              op2,
11338                                              TREE_OPERAND (arg0, 1))
11339           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
11340         {
11341           tem = fold_truth_not_expr (arg0);
11342           if (tem && COMPARISON_CLASS_P (tem))
11343             {
11344               tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
11345               if (tem)
11346                 return tem;
11347             }
11348         }
11349
11350       /* If the second operand is simpler than the third, swap them
11351          since that produces better jump optimization results.  */
11352       if (truth_value_p (TREE_CODE (arg0))
11353           && tree_swap_operands_p (op1, op2, false))
11354         {
11355           /* See if this can be inverted.  If it can't, possibly because
11356              it was a floating-point inequality comparison, don't do
11357              anything.  */
11358           tem = fold_truth_not_expr (arg0);
11359           if (tem)
11360             return fold_build3 (code, type, tem, op2, op1);
11361         }
11362
11363       /* Convert A ? 1 : 0 to simply A.  */
11364       if (integer_onep (op1)
11365           && integer_zerop (op2)
11366           /* If we try to convert OP0 to our type, the
11367              call to fold will try to move the conversion inside
11368              a COND, which will recurse.  In that case, the COND_EXPR
11369              is probably the best choice, so leave it alone.  */
11370           && type == TREE_TYPE (arg0))
11371         return pedantic_non_lvalue (arg0);
11372
11373       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
11374          over COND_EXPR in cases such as floating point comparisons.  */
11375       if (integer_zerop (op1)
11376           && integer_onep (op2)
11377           && truth_value_p (TREE_CODE (arg0)))
11378         return pedantic_non_lvalue (fold_convert (type,
11379                                                   invert_truthvalue (arg0)));
11380
11381       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
11382       if (TREE_CODE (arg0) == LT_EXPR
11383           && integer_zerop (TREE_OPERAND (arg0, 1))
11384           && integer_zerop (op2)
11385           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11386         return fold_convert (type,
11387                              fold_build2 (BIT_AND_EXPR,
11388                                           TREE_TYPE (tem), tem,
11389                                           fold_convert (TREE_TYPE (tem), arg1)));
11390
11391       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
11392          already handled above.  */
11393       if (TREE_CODE (arg0) == BIT_AND_EXPR
11394           && integer_onep (TREE_OPERAND (arg0, 1))
11395           && integer_zerop (op2)
11396           && integer_pow2p (arg1))
11397         {
11398           tree tem = TREE_OPERAND (arg0, 0);
11399           STRIP_NOPS (tem);
11400           if (TREE_CODE (tem) == RSHIFT_EXPR
11401               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
11402               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
11403                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
11404             return fold_build2 (BIT_AND_EXPR, type,
11405                                 TREE_OPERAND (tem, 0), arg1);
11406         }
11407
11408       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
11409          is probably obsolete because the first operand should be a
11410          truth value (that's why we have the two cases above), but let's
11411          leave it in until we can confirm this for all front-ends.  */
11412       if (integer_zerop (op2)
11413           && TREE_CODE (arg0) == NE_EXPR
11414           && integer_zerop (TREE_OPERAND (arg0, 1))
11415           && integer_pow2p (arg1)
11416           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
11417           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11418                               arg1, OEP_ONLY_CONST))
11419         return pedantic_non_lvalue (fold_convert (type,
11420                                                   TREE_OPERAND (arg0, 0)));
11421
11422       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
11423       if (integer_zerop (op2)
11424           && truth_value_p (TREE_CODE (arg0))
11425           && truth_value_p (TREE_CODE (arg1)))
11426         return fold_build2 (TRUTH_ANDIF_EXPR, type,
11427                             fold_convert (type, arg0),
11428                             arg1);
11429
11430       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
11431       if (integer_onep (op2)
11432           && truth_value_p (TREE_CODE (arg0))
11433           && truth_value_p (TREE_CODE (arg1)))
11434         {
11435           /* Only perform transformation if ARG0 is easily inverted.  */
11436           tem = fold_truth_not_expr (arg0);
11437           if (tem)
11438             return fold_build2 (TRUTH_ORIF_EXPR, type,
11439                                 fold_convert (type, tem),
11440                                 arg1);
11441         }
11442
11443       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
11444       if (integer_zerop (arg1)
11445           && truth_value_p (TREE_CODE (arg0))
11446           && truth_value_p (TREE_CODE (op2)))
11447         {
11448           /* Only perform transformation if ARG0 is easily inverted.  */
11449           tem = fold_truth_not_expr (arg0);
11450           if (tem)
11451             return fold_build2 (TRUTH_ANDIF_EXPR, type,
11452                                 fold_convert (type, tem),
11453                                 op2);
11454         }
11455
11456       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
11457       if (integer_onep (arg1)
11458           && truth_value_p (TREE_CODE (arg0))
11459           && truth_value_p (TREE_CODE (op2)))
11460         return fold_build2 (TRUTH_ORIF_EXPR, type,
11461                             fold_convert (type, arg0),
11462                             op2);
11463
11464       return NULL_TREE;
11465
11466     case CALL_EXPR:
11467       /* Check for a built-in function.  */
11468       if (TREE_CODE (op0) == ADDR_EXPR
11469           && TREE_CODE (TREE_OPERAND (op0, 0)) == FUNCTION_DECL
11470           && DECL_BUILT_IN (TREE_OPERAND (op0, 0)))
11471         return fold_builtin (TREE_OPERAND (op0, 0), op1, false);
11472       return NULL_TREE;
11473
11474     case BIT_FIELD_REF:
11475       if (TREE_CODE (arg0) == VECTOR_CST
11476           && type == TREE_TYPE (TREE_TYPE (arg0))
11477           && host_integerp (arg1, 1)
11478           && host_integerp (op2, 1))
11479         {
11480           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
11481           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
11482
11483           if (width != 0
11484               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
11485               && (idx % width) == 0
11486               && (idx = idx / width)
11487                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
11488             {
11489               tree elements = TREE_VECTOR_CST_ELTS (arg0);
11490               while (idx-- > 0 && elements)
11491                 elements = TREE_CHAIN (elements);
11492               if (elements)
11493                 return TREE_VALUE (elements);
11494               else
11495                 return fold_convert (type, integer_zero_node);
11496             }
11497         }
11498       return NULL_TREE;
11499
11500     default:
11501       return NULL_TREE;
11502     } /* switch (code) */
11503 }
11504
11505 /* Perform constant folding and related simplification of EXPR.
11506    The related simplifications include x*1 => x, x*0 => 0, etc.,
11507    and application of the associative law.
11508    NOP_EXPR conversions may be removed freely (as long as we
11509    are careful not to change the type of the overall expression).
11510    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11511    but we can constant-fold them if they have constant operands.  */
11512
11513 #ifdef ENABLE_FOLD_CHECKING
11514 # define fold(x) fold_1 (x)
11515 static tree fold_1 (tree);
11516 static
11517 #endif
11518 tree
11519 fold (tree expr)
11520 {
11521   const tree t = expr;
11522   enum tree_code code = TREE_CODE (t);
11523   enum tree_code_class kind = TREE_CODE_CLASS (code);
11524   tree tem;
11525
11526   /* Return right away if a constant.  */
11527   if (kind == tcc_constant)
11528     return t;
11529
11530   if (IS_EXPR_CODE_CLASS (kind))
11531     {
11532       tree type = TREE_TYPE (t);
11533       tree op0, op1, op2;
11534
11535       switch (TREE_CODE_LENGTH (code))
11536         {
11537         case 1:
11538           op0 = TREE_OPERAND (t, 0);
11539           tem = fold_unary (code, type, op0);
11540           return tem ? tem : expr;
11541         case 2:
11542           op0 = TREE_OPERAND (t, 0);
11543           op1 = TREE_OPERAND (t, 1);
11544           tem = fold_binary (code, type, op0, op1);
11545           return tem ? tem : expr;
11546         case 3:
11547           op0 = TREE_OPERAND (t, 0);
11548           op1 = TREE_OPERAND (t, 1);
11549           op2 = TREE_OPERAND (t, 2);
11550           tem = fold_ternary (code, type, op0, op1, op2);
11551           return tem ? tem : expr;
11552         default:
11553           break;
11554         }
11555     }
11556
11557   switch (code)
11558     {
11559     case CONST_DECL:
11560       return fold (DECL_INITIAL (t));
11561
11562     default:
11563       return t;
11564     } /* switch (code) */
11565 }
11566
11567 #ifdef ENABLE_FOLD_CHECKING
11568 #undef fold
11569
11570 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
11571 static void fold_check_failed (tree, tree);
11572 void print_fold_checksum (tree);
11573
11574 /* When --enable-checking=fold, compute a digest of expr before
11575    and after actual fold call to see if fold did not accidentally
11576    change original expr.  */
11577
11578 tree
11579 fold (tree expr)
11580 {
11581   tree ret;
11582   struct md5_ctx ctx;
11583   unsigned char checksum_before[16], checksum_after[16];
11584   htab_t ht;
11585
11586   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11587   md5_init_ctx (&ctx);
11588   fold_checksum_tree (expr, &ctx, ht);
11589   md5_finish_ctx (&ctx, checksum_before);
11590   htab_empty (ht);
11591
11592   ret = fold_1 (expr);
11593
11594   md5_init_ctx (&ctx);
11595   fold_checksum_tree (expr, &ctx, ht);
11596   md5_finish_ctx (&ctx, checksum_after);
11597   htab_delete (ht);
11598
11599   if (memcmp (checksum_before, checksum_after, 16))
11600     fold_check_failed (expr, ret);
11601
11602   return ret;
11603 }
11604
11605 void
11606 print_fold_checksum (tree expr)
11607 {
11608   struct md5_ctx ctx;
11609   unsigned char checksum[16], cnt;
11610   htab_t ht;
11611
11612   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11613   md5_init_ctx (&ctx);
11614   fold_checksum_tree (expr, &ctx, ht);
11615   md5_finish_ctx (&ctx, checksum);
11616   htab_delete (ht);
11617   for (cnt = 0; cnt < 16; ++cnt)
11618     fprintf (stderr, "%02x", checksum[cnt]);
11619   putc ('\n', stderr);
11620 }
11621
11622 static void
11623 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
11624 {
11625   internal_error ("fold check: original tree changed by fold");
11626 }
11627
11628 static void
11629 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
11630 {
11631   void **slot;
11632   enum tree_code code;
11633   struct tree_function_decl buf;
11634   int i, len;
11635
11636 recursive_label:
11637
11638   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
11639                <= sizeof (struct tree_function_decl))
11640               && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
11641   if (expr == NULL)
11642     return;
11643   slot = htab_find_slot (ht, expr, INSERT);
11644   if (*slot != NULL)
11645     return;
11646   *slot = expr;
11647   code = TREE_CODE (expr);
11648   if (TREE_CODE_CLASS (code) == tcc_declaration
11649       && DECL_ASSEMBLER_NAME_SET_P (expr))
11650     {
11651       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
11652       memcpy ((char *) &buf, expr, tree_size (expr));
11653       expr = (tree) &buf;
11654       SET_DECL_ASSEMBLER_NAME (expr, NULL);
11655     }
11656   else if (TREE_CODE_CLASS (code) == tcc_type
11657            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
11658                || TYPE_CACHED_VALUES_P (expr)
11659                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)))
11660     {
11661       /* Allow these fields to be modified.  */
11662       memcpy ((char *) &buf, expr, tree_size (expr));
11663       expr = (tree) &buf;
11664       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr) = 0;
11665       TYPE_POINTER_TO (expr) = NULL;
11666       TYPE_REFERENCE_TO (expr) = NULL;
11667       if (TYPE_CACHED_VALUES_P (expr))
11668         {
11669           TYPE_CACHED_VALUES_P (expr) = 0;
11670           TYPE_CACHED_VALUES (expr) = NULL;
11671         }
11672     }
11673   md5_process_bytes (expr, tree_size (expr), ctx);
11674   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
11675   if (TREE_CODE_CLASS (code) != tcc_type
11676       && TREE_CODE_CLASS (code) != tcc_declaration
11677       && code != TREE_LIST)
11678     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
11679   switch (TREE_CODE_CLASS (code))
11680     {
11681     case tcc_constant:
11682       switch (code)
11683         {
11684         case STRING_CST:
11685           md5_process_bytes (TREE_STRING_POINTER (expr),
11686                              TREE_STRING_LENGTH (expr), ctx);
11687           break;
11688         case COMPLEX_CST:
11689           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
11690           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
11691           break;
11692         case VECTOR_CST:
11693           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
11694           break;
11695         default:
11696           break;
11697         }
11698       break;
11699     case tcc_exceptional:
11700       switch (code)
11701         {
11702         case TREE_LIST:
11703           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
11704           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
11705           expr = TREE_CHAIN (expr);
11706           goto recursive_label;
11707           break;
11708         case TREE_VEC:
11709           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
11710             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
11711           break;
11712         default:
11713           break;
11714         }
11715       break;
11716     case tcc_expression:
11717     case tcc_reference:
11718     case tcc_comparison:
11719     case tcc_unary:
11720     case tcc_binary:
11721     case tcc_statement:
11722       len = TREE_CODE_LENGTH (code);
11723       for (i = 0; i < len; ++i)
11724         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
11725       break;
11726     case tcc_declaration:
11727       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
11728       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
11729       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
11730         {
11731           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
11732           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
11733           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
11734           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
11735           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
11736         }
11737       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
11738         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
11739
11740       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
11741         {
11742           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
11743           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
11744           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
11745         }
11746       break;
11747     case tcc_type:
11748       if (TREE_CODE (expr) == ENUMERAL_TYPE)
11749         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
11750       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
11751       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
11752       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
11753       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
11754       if (INTEGRAL_TYPE_P (expr)
11755           || SCALAR_FLOAT_TYPE_P (expr))
11756         {
11757           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
11758           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
11759         }
11760       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
11761       if (TREE_CODE (expr) == RECORD_TYPE
11762           || TREE_CODE (expr) == UNION_TYPE
11763           || TREE_CODE (expr) == QUAL_UNION_TYPE)
11764         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
11765       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
11766       break;
11767     default:
11768       break;
11769     }
11770 }
11771
11772 #endif
11773
11774 /* Fold a unary tree expression with code CODE of type TYPE with an
11775    operand OP0.  Return a folded expression if successful.  Otherwise,
11776    return a tree expression with code CODE of type TYPE with an
11777    operand OP0.  */
11778
11779 tree
11780 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
11781 {
11782   tree tem;
11783 #ifdef ENABLE_FOLD_CHECKING
11784   unsigned char checksum_before[16], checksum_after[16];
11785   struct md5_ctx ctx;
11786   htab_t ht;
11787
11788   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11789   md5_init_ctx (&ctx);
11790   fold_checksum_tree (op0, &ctx, ht);
11791   md5_finish_ctx (&ctx, checksum_before);
11792   htab_empty (ht);
11793 #endif
11794
11795   tem = fold_unary (code, type, op0);
11796   if (!tem)
11797     tem = build1_stat (code, type, op0 PASS_MEM_STAT);
11798
11799 #ifdef ENABLE_FOLD_CHECKING
11800   md5_init_ctx (&ctx);
11801   fold_checksum_tree (op0, &ctx, ht);
11802   md5_finish_ctx (&ctx, checksum_after);
11803   htab_delete (ht);
11804
11805   if (memcmp (checksum_before, checksum_after, 16))
11806     fold_check_failed (op0, tem);
11807 #endif
11808   return tem;
11809 }
11810
11811 /* Fold a binary tree expression with code CODE of type TYPE with
11812    operands OP0 and OP1.  Return a folded expression if successful.
11813    Otherwise, return a tree expression with code CODE of type TYPE
11814    with operands OP0 and OP1.  */
11815
11816 tree
11817 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
11818                   MEM_STAT_DECL)
11819 {
11820   tree tem;
11821 #ifdef ENABLE_FOLD_CHECKING
11822   unsigned char checksum_before_op0[16],
11823                 checksum_before_op1[16],
11824                 checksum_after_op0[16],
11825                 checksum_after_op1[16];
11826   struct md5_ctx ctx;
11827   htab_t ht;
11828
11829   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11830   md5_init_ctx (&ctx);
11831   fold_checksum_tree (op0, &ctx, ht);
11832   md5_finish_ctx (&ctx, checksum_before_op0);
11833   htab_empty (ht);
11834
11835   md5_init_ctx (&ctx);
11836   fold_checksum_tree (op1, &ctx, ht);
11837   md5_finish_ctx (&ctx, checksum_before_op1);
11838   htab_empty (ht);
11839 #endif
11840
11841   tem = fold_binary (code, type, op0, op1);
11842   if (!tem)
11843     tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
11844
11845 #ifdef ENABLE_FOLD_CHECKING
11846   md5_init_ctx (&ctx);
11847   fold_checksum_tree (op0, &ctx, ht);
11848   md5_finish_ctx (&ctx, checksum_after_op0);
11849   htab_empty (ht);
11850
11851   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
11852     fold_check_failed (op0, tem);
11853
11854   md5_init_ctx (&ctx);
11855   fold_checksum_tree (op1, &ctx, ht);
11856   md5_finish_ctx (&ctx, checksum_after_op1);
11857   htab_delete (ht);
11858
11859   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
11860     fold_check_failed (op1, tem);
11861 #endif
11862   return tem;
11863 }
11864
11865 /* Fold a ternary tree expression with code CODE of type TYPE with
11866    operands OP0, OP1, and OP2.  Return a folded expression if
11867    successful.  Otherwise, return a tree expression with code CODE of
11868    type TYPE with operands OP0, OP1, and OP2.  */
11869
11870 tree
11871 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
11872              MEM_STAT_DECL)
11873 {
11874   tree tem;
11875 #ifdef ENABLE_FOLD_CHECKING
11876   unsigned char checksum_before_op0[16],
11877                 checksum_before_op1[16],
11878                 checksum_before_op2[16],
11879                 checksum_after_op0[16],
11880                 checksum_after_op1[16],
11881                 checksum_after_op2[16];
11882   struct md5_ctx ctx;
11883   htab_t ht;
11884
11885   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11886   md5_init_ctx (&ctx);
11887   fold_checksum_tree (op0, &ctx, ht);
11888   md5_finish_ctx (&ctx, checksum_before_op0);
11889   htab_empty (ht);
11890
11891   md5_init_ctx (&ctx);
11892   fold_checksum_tree (op1, &ctx, ht);
11893   md5_finish_ctx (&ctx, checksum_before_op1);
11894   htab_empty (ht);
11895
11896   md5_init_ctx (&ctx);
11897   fold_checksum_tree (op2, &ctx, ht);
11898   md5_finish_ctx (&ctx, checksum_before_op2);
11899   htab_empty (ht);
11900 #endif
11901
11902   tem = fold_ternary (code, type, op0, op1, op2);
11903   if (!tem)
11904     tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
11905
11906 #ifdef ENABLE_FOLD_CHECKING
11907   md5_init_ctx (&ctx);
11908   fold_checksum_tree (op0, &ctx, ht);
11909   md5_finish_ctx (&ctx, checksum_after_op0);
11910   htab_empty (ht);
11911
11912   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
11913     fold_check_failed (op0, tem);
11914
11915   md5_init_ctx (&ctx);
11916   fold_checksum_tree (op1, &ctx, ht);
11917   md5_finish_ctx (&ctx, checksum_after_op1);
11918   htab_empty (ht);
11919
11920   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
11921     fold_check_failed (op1, tem);
11922
11923   md5_init_ctx (&ctx);
11924   fold_checksum_tree (op2, &ctx, ht);
11925   md5_finish_ctx (&ctx, checksum_after_op2);
11926   htab_delete (ht);
11927
11928   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
11929     fold_check_failed (op2, tem);
11930 #endif
11931   return tem;
11932 }
11933
11934 /* Perform constant folding and related simplification of initializer
11935    expression EXPR.  These behave identically to "fold_buildN" but ignore
11936    potential run-time traps and exceptions that fold must preserve.  */
11937
11938 #define START_FOLD_INIT \
11939   int saved_signaling_nans = flag_signaling_nans;\
11940   int saved_trapping_math = flag_trapping_math;\
11941   int saved_rounding_math = flag_rounding_math;\
11942   int saved_trapv = flag_trapv;\
11943   int saved_folding_initializer = folding_initializer;\
11944   flag_signaling_nans = 0;\
11945   flag_trapping_math = 0;\
11946   flag_rounding_math = 0;\
11947   flag_trapv = 0;\
11948   folding_initializer = 1;
11949
11950 #define END_FOLD_INIT \
11951   flag_signaling_nans = saved_signaling_nans;\
11952   flag_trapping_math = saved_trapping_math;\
11953   flag_rounding_math = saved_rounding_math;\
11954   flag_trapv = saved_trapv;\
11955   folding_initializer = saved_folding_initializer;
11956
11957 tree
11958 fold_build1_initializer (enum tree_code code, tree type, tree op)
11959 {
11960   tree result;
11961   START_FOLD_INIT;
11962
11963   result = fold_build1 (code, type, op);
11964
11965   END_FOLD_INIT;
11966   return result;
11967 }
11968
11969 tree
11970 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
11971 {
11972   tree result;
11973   START_FOLD_INIT;
11974
11975   result = fold_build2 (code, type, op0, op1);
11976
11977   END_FOLD_INIT;
11978   return result;
11979 }
11980
11981 tree
11982 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
11983                          tree op2)
11984 {
11985   tree result;
11986   START_FOLD_INIT;
11987
11988   result = fold_build3 (code, type, op0, op1, op2);
11989
11990   END_FOLD_INIT;
11991   return result;
11992 }
11993
11994 #undef START_FOLD_INIT
11995 #undef END_FOLD_INIT
11996
11997 /* Determine if first argument is a multiple of second argument.  Return 0 if
11998    it is not, or we cannot easily determined it to be.
11999
12000    An example of the sort of thing we care about (at this point; this routine
12001    could surely be made more general, and expanded to do what the *_DIV_EXPR's
12002    fold cases do now) is discovering that
12003
12004      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12005
12006    is a multiple of
12007
12008      SAVE_EXPR (J * 8)
12009
12010    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12011
12012    This code also handles discovering that
12013
12014      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12015
12016    is a multiple of 8 so we don't have to worry about dealing with a
12017    possible remainder.
12018
12019    Note that we *look* inside a SAVE_EXPR only to determine how it was
12020    calculated; it is not safe for fold to do much of anything else with the
12021    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12022    at run time.  For example, the latter example above *cannot* be implemented
12023    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12024    evaluation time of the original SAVE_EXPR is not necessarily the same at
12025    the time the new expression is evaluated.  The only optimization of this
12026    sort that would be valid is changing
12027
12028      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12029
12030    divided by 8 to
12031
12032      SAVE_EXPR (I) * SAVE_EXPR (J)
12033
12034    (where the same SAVE_EXPR (J) is used in the original and the
12035    transformed version).  */
12036
12037 static int
12038 multiple_of_p (tree type, tree top, tree bottom)
12039 {
12040   if (operand_equal_p (top, bottom, 0))
12041     return 1;
12042
12043   if (TREE_CODE (type) != INTEGER_TYPE)
12044     return 0;
12045
12046   switch (TREE_CODE (top))
12047     {
12048     case BIT_AND_EXPR:
12049       /* Bitwise and provides a power of two multiple.  If the mask is
12050          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
12051       if (!integer_pow2p (bottom))
12052         return 0;
12053       /* FALLTHRU */
12054
12055     case MULT_EXPR:
12056       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12057               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12058
12059     case PLUS_EXPR:
12060     case MINUS_EXPR:
12061       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12062               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12063
12064     case LSHIFT_EXPR:
12065       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
12066         {
12067           tree op1, t1;
12068
12069           op1 = TREE_OPERAND (top, 1);
12070           /* const_binop may not detect overflow correctly,
12071              so check for it explicitly here.  */
12072           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
12073               > TREE_INT_CST_LOW (op1)
12074               && TREE_INT_CST_HIGH (op1) == 0
12075               && 0 != (t1 = fold_convert (type,
12076                                           const_binop (LSHIFT_EXPR,
12077                                                        size_one_node,
12078                                                        op1, 0)))
12079               && ! TREE_OVERFLOW (t1))
12080             return multiple_of_p (type, t1, bottom);
12081         }
12082       return 0;
12083
12084     case NOP_EXPR:
12085       /* Can't handle conversions from non-integral or wider integral type.  */
12086       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
12087           || (TYPE_PRECISION (type)
12088               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
12089         return 0;
12090
12091       /* .. fall through ...  */
12092
12093     case SAVE_EXPR:
12094       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
12095
12096     case INTEGER_CST:
12097       if (TREE_CODE (bottom) != INTEGER_CST
12098           || (TYPE_UNSIGNED (type)
12099               && (tree_int_cst_sgn (top) < 0
12100                   || tree_int_cst_sgn (bottom) < 0)))
12101         return 0;
12102       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
12103                                          top, bottom, 0));
12104
12105     default:
12106       return 0;
12107     }
12108 }
12109
12110 /* Return true if `t' is known to be non-negative.  */
12111
12112 int
12113 tree_expr_nonnegative_p (tree t)
12114 {
12115   if (t == error_mark_node)
12116     return 0;
12117
12118   if (TYPE_UNSIGNED (TREE_TYPE (t)))
12119     return 1;
12120
12121   switch (TREE_CODE (t))
12122     {
12123     case SSA_NAME:
12124       /* Query VRP to see if it has recorded any information about
12125          the range of this object.  */
12126       return ssa_name_nonnegative_p (t);
12127
12128     case ABS_EXPR:
12129       /* We can't return 1 if flag_wrapv is set because
12130          ABS_EXPR<INT_MIN> = INT_MIN.  */
12131       if (!(flag_wrapv && INTEGRAL_TYPE_P (TREE_TYPE (t))))
12132         return 1;
12133       break;
12134
12135     case INTEGER_CST:
12136       return tree_int_cst_sgn (t) >= 0;
12137
12138     case REAL_CST:
12139       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
12140
12141     case PLUS_EXPR:
12142       if (FLOAT_TYPE_P (TREE_TYPE (t)))
12143         return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12144                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12145
12146       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12147          both unsigned and at least 2 bits shorter than the result.  */
12148       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
12149           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
12150           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
12151         {
12152           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
12153           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
12154           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12155               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12156             {
12157               unsigned int prec = MAX (TYPE_PRECISION (inner1),
12158                                        TYPE_PRECISION (inner2)) + 1;
12159               return prec < TYPE_PRECISION (TREE_TYPE (t));
12160             }
12161         }
12162       break;
12163
12164     case MULT_EXPR:
12165       if (FLOAT_TYPE_P (TREE_TYPE (t)))
12166         {
12167           /* x * x for floating point x is always non-negative.  */
12168           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
12169             return 1;
12170           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12171                  && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12172         }
12173
12174       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12175          both unsigned and their total bits is shorter than the result.  */
12176       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
12177           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
12178           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
12179         {
12180           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
12181           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
12182           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12183               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12184             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
12185                    < TYPE_PRECISION (TREE_TYPE (t));
12186         }
12187       return 0;
12188
12189     case BIT_AND_EXPR:
12190     case MAX_EXPR:
12191       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12192              || tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12193
12194     case BIT_IOR_EXPR:
12195     case BIT_XOR_EXPR:
12196     case MIN_EXPR:
12197     case RDIV_EXPR:
12198     case TRUNC_DIV_EXPR:
12199     case CEIL_DIV_EXPR:
12200     case FLOOR_DIV_EXPR:
12201     case ROUND_DIV_EXPR:
12202       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12203              && tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12204
12205     case TRUNC_MOD_EXPR:
12206     case CEIL_MOD_EXPR:
12207     case FLOOR_MOD_EXPR:
12208     case ROUND_MOD_EXPR:
12209     case SAVE_EXPR:
12210     case NON_LVALUE_EXPR:
12211     case FLOAT_EXPR:
12212       return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12213
12214     case COMPOUND_EXPR:
12215     case MODIFY_EXPR:
12216       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12217
12218     case BIND_EXPR:
12219       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
12220
12221     case COND_EXPR:
12222       return tree_expr_nonnegative_p (TREE_OPERAND (t, 1))
12223              && tree_expr_nonnegative_p (TREE_OPERAND (t, 2));
12224
12225     case NOP_EXPR:
12226       {
12227         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12228         tree outer_type = TREE_TYPE (t);
12229
12230         if (TREE_CODE (outer_type) == REAL_TYPE)
12231           {
12232             if (TREE_CODE (inner_type) == REAL_TYPE)
12233               return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12234             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12235               {
12236                 if (TYPE_UNSIGNED (inner_type))
12237                   return 1;
12238                 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12239               }
12240           }
12241         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
12242           {
12243             if (TREE_CODE (inner_type) == REAL_TYPE)
12244               return tree_expr_nonnegative_p (TREE_OPERAND (t,0));
12245             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12246               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
12247                       && TYPE_UNSIGNED (inner_type);
12248           }
12249       }
12250       break;
12251
12252     case TARGET_EXPR:
12253       {
12254         tree temp = TARGET_EXPR_SLOT (t);
12255         t = TARGET_EXPR_INITIAL (t);
12256
12257         /* If the initializer is non-void, then it's a normal expression
12258            that will be assigned to the slot.  */
12259         if (!VOID_TYPE_P (t))
12260           return tree_expr_nonnegative_p (t);
12261
12262         /* Otherwise, the initializer sets the slot in some way.  One common
12263            way is an assignment statement at the end of the initializer.  */
12264         while (1)
12265           {
12266             if (TREE_CODE (t) == BIND_EXPR)
12267               t = expr_last (BIND_EXPR_BODY (t));
12268             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
12269                      || TREE_CODE (t) == TRY_CATCH_EXPR)
12270               t = expr_last (TREE_OPERAND (t, 0));
12271             else if (TREE_CODE (t) == STATEMENT_LIST)
12272               t = expr_last (t);
12273             else
12274               break;
12275           }
12276         if (TREE_CODE (t) == MODIFY_EXPR
12277             && TREE_OPERAND (t, 0) == temp)
12278           return tree_expr_nonnegative_p (TREE_OPERAND (t, 1));
12279
12280         return 0;
12281       }
12282
12283     case CALL_EXPR:
12284       {
12285         tree fndecl = get_callee_fndecl (t);
12286         tree arglist = TREE_OPERAND (t, 1);
12287         if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
12288           switch (DECL_FUNCTION_CODE (fndecl))
12289             {
12290             CASE_FLT_FN (BUILT_IN_ACOS):
12291             CASE_FLT_FN (BUILT_IN_ACOSH):
12292             CASE_FLT_FN (BUILT_IN_CABS):
12293             CASE_FLT_FN (BUILT_IN_COSH):
12294             CASE_FLT_FN (BUILT_IN_ERFC):
12295             CASE_FLT_FN (BUILT_IN_EXP):
12296             CASE_FLT_FN (BUILT_IN_EXP10):
12297             CASE_FLT_FN (BUILT_IN_EXP2):
12298             CASE_FLT_FN (BUILT_IN_FABS):
12299             CASE_FLT_FN (BUILT_IN_FDIM):
12300             CASE_FLT_FN (BUILT_IN_HYPOT):
12301             CASE_FLT_FN (BUILT_IN_POW10):
12302             CASE_INT_FN (BUILT_IN_FFS):
12303             CASE_INT_FN (BUILT_IN_PARITY):
12304             CASE_INT_FN (BUILT_IN_POPCOUNT):
12305               /* Always true.  */
12306               return 1;
12307
12308             CASE_FLT_FN (BUILT_IN_SQRT):
12309               /* sqrt(-0.0) is -0.0.  */
12310               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
12311                 return 1;
12312               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
12313
12314             CASE_FLT_FN (BUILT_IN_ASINH):
12315             CASE_FLT_FN (BUILT_IN_ATAN):
12316             CASE_FLT_FN (BUILT_IN_ATANH):
12317             CASE_FLT_FN (BUILT_IN_CBRT):
12318             CASE_FLT_FN (BUILT_IN_CEIL):
12319             CASE_FLT_FN (BUILT_IN_ERF):
12320             CASE_FLT_FN (BUILT_IN_EXPM1):
12321             CASE_FLT_FN (BUILT_IN_FLOOR):
12322             CASE_FLT_FN (BUILT_IN_FMOD):
12323             CASE_FLT_FN (BUILT_IN_FREXP):
12324             CASE_FLT_FN (BUILT_IN_LCEIL):
12325             CASE_FLT_FN (BUILT_IN_LDEXP):
12326             CASE_FLT_FN (BUILT_IN_LFLOOR):
12327             CASE_FLT_FN (BUILT_IN_LLCEIL):
12328             CASE_FLT_FN (BUILT_IN_LLFLOOR):
12329             CASE_FLT_FN (BUILT_IN_LLRINT):
12330             CASE_FLT_FN (BUILT_IN_LLROUND):
12331             CASE_FLT_FN (BUILT_IN_LRINT):
12332             CASE_FLT_FN (BUILT_IN_LROUND):
12333             CASE_FLT_FN (BUILT_IN_MODF):
12334             CASE_FLT_FN (BUILT_IN_NEARBYINT):
12335             CASE_FLT_FN (BUILT_IN_POW):
12336             CASE_FLT_FN (BUILT_IN_RINT):
12337             CASE_FLT_FN (BUILT_IN_ROUND):
12338             CASE_FLT_FN (BUILT_IN_SIGNBIT):
12339             CASE_FLT_FN (BUILT_IN_SINH):
12340             CASE_FLT_FN (BUILT_IN_TANH):
12341             CASE_FLT_FN (BUILT_IN_TRUNC):
12342               /* True if the 1st argument is nonnegative.  */
12343               return tree_expr_nonnegative_p (TREE_VALUE (arglist));
12344
12345             CASE_FLT_FN (BUILT_IN_FMAX):
12346               /* True if the 1st OR 2nd arguments are nonnegative.  */
12347               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
12348                 || tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12349
12350             CASE_FLT_FN (BUILT_IN_FMIN):
12351               /* True if the 1st AND 2nd arguments are nonnegative.  */
12352               return tree_expr_nonnegative_p (TREE_VALUE (arglist))
12353                 && tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12354
12355             CASE_FLT_FN (BUILT_IN_COPYSIGN):
12356               /* True if the 2nd argument is nonnegative.  */
12357               return tree_expr_nonnegative_p (TREE_VALUE (TREE_CHAIN (arglist)));
12358
12359             default:
12360               break;
12361             }
12362       }
12363
12364       /* ... fall through ...  */
12365
12366     default:
12367       if (truth_value_p (TREE_CODE (t)))
12368         /* Truth values evaluate to 0 or 1, which is nonnegative.  */
12369         return 1;
12370     }
12371
12372   /* We don't know sign of `t', so be conservative and return false.  */
12373   return 0;
12374 }
12375
12376 /* Return true when T is an address and is known to be nonzero.
12377    For floating point we further ensure that T is not denormal.
12378    Similar logic is present in nonzero_address in rtlanal.h.  */
12379
12380 bool
12381 tree_expr_nonzero_p (tree t)
12382 {
12383   tree type = TREE_TYPE (t);
12384
12385   /* Doing something useful for floating point would need more work.  */
12386   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
12387     return false;
12388
12389   switch (TREE_CODE (t))
12390     {
12391     case SSA_NAME:
12392       /* Query VRP to see if it has recorded any information about
12393          the range of this object.  */
12394       return ssa_name_nonzero_p (t);
12395
12396     case ABS_EXPR:
12397       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12398
12399     case INTEGER_CST:
12400       /* We used to test for !integer_zerop here.  This does not work correctly
12401          if TREE_CONSTANT_OVERFLOW (t).  */
12402       return (TREE_INT_CST_LOW (t) != 0
12403               || TREE_INT_CST_HIGH (t) != 0);
12404
12405     case PLUS_EXPR:
12406       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
12407         {
12408           /* With the presence of negative values it is hard
12409              to say something.  */
12410           if (!tree_expr_nonnegative_p (TREE_OPERAND (t, 0))
12411               || !tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
12412             return false;
12413           /* One of operands must be positive and the other non-negative.  */
12414           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12415                   || tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12416         }
12417       break;
12418
12419     case MULT_EXPR:
12420       if (!TYPE_UNSIGNED (type) && !flag_wrapv)
12421         {
12422           return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12423                   && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12424         }
12425       break;
12426
12427     case NOP_EXPR:
12428       {
12429         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12430         tree outer_type = TREE_TYPE (t);
12431
12432         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
12433                 && tree_expr_nonzero_p (TREE_OPERAND (t, 0)));
12434       }
12435       break;
12436
12437    case ADDR_EXPR:
12438       {
12439         tree base = get_base_address (TREE_OPERAND (t, 0));
12440
12441         if (!base)
12442           return false;
12443
12444         /* Weak declarations may link to NULL.  */
12445         if (VAR_OR_FUNCTION_DECL_P (base))
12446           return !DECL_WEAK (base);
12447
12448         /* Constants are never weak.  */
12449         if (CONSTANT_CLASS_P (base))
12450           return true;
12451
12452         return false;
12453       }
12454
12455     case COND_EXPR:
12456       return (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12457               && tree_expr_nonzero_p (TREE_OPERAND (t, 2)));
12458
12459     case MIN_EXPR:
12460       return (tree_expr_nonzero_p (TREE_OPERAND (t, 0))
12461               && tree_expr_nonzero_p (TREE_OPERAND (t, 1)));
12462
12463     case MAX_EXPR:
12464       if (tree_expr_nonzero_p (TREE_OPERAND (t, 0)))
12465         {
12466           /* When both operands are nonzero, then MAX must be too.  */
12467           if (tree_expr_nonzero_p (TREE_OPERAND (t, 1)))
12468             return true;
12469
12470           /* MAX where operand 0 is positive is positive.  */
12471           return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
12472         }
12473       /* MAX where operand 1 is positive is positive.  */
12474       else if (tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12475                && tree_expr_nonnegative_p (TREE_OPERAND (t, 1)))
12476         return true;
12477       break;
12478
12479     case COMPOUND_EXPR:
12480     case MODIFY_EXPR:
12481     case BIND_EXPR:
12482       return tree_expr_nonzero_p (TREE_OPERAND (t, 1));
12483
12484     case SAVE_EXPR:
12485     case NON_LVALUE_EXPR:
12486       return tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12487
12488     case BIT_IOR_EXPR:
12489       return tree_expr_nonzero_p (TREE_OPERAND (t, 1))
12490              || tree_expr_nonzero_p (TREE_OPERAND (t, 0));
12491
12492     case CALL_EXPR:
12493       return alloca_call_p (t);
12494
12495     default:
12496       break;
12497     }
12498   return false;
12499 }
12500
12501 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
12502    attempt to fold the expression to a constant without modifying TYPE,
12503    OP0 or OP1.
12504
12505    If the expression could be simplified to a constant, then return
12506    the constant.  If the expression would not be simplified to a
12507    constant, then return NULL_TREE.  */
12508
12509 tree
12510 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
12511 {
12512   tree tem = fold_binary (code, type, op0, op1);
12513   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12514 }
12515
12516 /* Given the components of a unary expression CODE, TYPE and OP0,
12517    attempt to fold the expression to a constant without modifying
12518    TYPE or OP0.
12519
12520    If the expression could be simplified to a constant, then return
12521    the constant.  If the expression would not be simplified to a
12522    constant, then return NULL_TREE.  */
12523
12524 tree
12525 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
12526 {
12527   tree tem = fold_unary (code, type, op0);
12528   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12529 }
12530
12531 /* If EXP represents referencing an element in a constant string
12532    (either via pointer arithmetic or array indexing), return the
12533    tree representing the value accessed, otherwise return NULL.  */
12534
12535 tree
12536 fold_read_from_constant_string (tree exp)
12537 {
12538   if (TREE_CODE (exp) == INDIRECT_REF || TREE_CODE (exp) == ARRAY_REF)
12539     {
12540       tree exp1 = TREE_OPERAND (exp, 0);
12541       tree index;
12542       tree string;
12543
12544       if (TREE_CODE (exp) == INDIRECT_REF)
12545         string = string_constant (exp1, &index);
12546       else
12547         {
12548           tree low_bound = array_ref_low_bound (exp);
12549           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
12550
12551           /* Optimize the special-case of a zero lower bound.
12552
12553              We convert the low_bound to sizetype to avoid some problems
12554              with constant folding.  (E.g. suppose the lower bound is 1,
12555              and its mode is QI.  Without the conversion,l (ARRAY
12556              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
12557              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
12558           if (! integer_zerop (low_bound))
12559             index = size_diffop (index, fold_convert (sizetype, low_bound));
12560
12561           string = exp1;
12562         }
12563
12564       if (string
12565           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
12566           && TREE_CODE (string) == STRING_CST
12567           && TREE_CODE (index) == INTEGER_CST
12568           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
12569           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
12570               == MODE_INT)
12571           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
12572         return fold_convert (TREE_TYPE (exp),
12573                              build_int_cst (NULL_TREE,
12574                                             (TREE_STRING_POINTER (string)
12575                                              [TREE_INT_CST_LOW (index)])));
12576     }
12577   return NULL;
12578 }
12579
12580 /* Return the tree for neg (ARG0) when ARG0 is known to be either
12581    an integer constant or real constant.
12582
12583    TYPE is the type of the result.  */
12584
12585 static tree
12586 fold_negate_const (tree arg0, tree type)
12587 {
12588   tree t = NULL_TREE;
12589
12590   switch (TREE_CODE (arg0))
12591     {
12592     case INTEGER_CST:
12593       {
12594         unsigned HOST_WIDE_INT low;
12595         HOST_WIDE_INT high;
12596         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
12597                                    TREE_INT_CST_HIGH (arg0),
12598                                    &low, &high);
12599         t = build_int_cst_wide (type, low, high);
12600         t = force_fit_type (t, 1,
12601                             (overflow | TREE_OVERFLOW (arg0))
12602                             && !TYPE_UNSIGNED (type),
12603                             TREE_CONSTANT_OVERFLOW (arg0));
12604         break;
12605       }
12606
12607     case REAL_CST:
12608       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
12609       break;
12610
12611     default:
12612       gcc_unreachable ();
12613     }
12614
12615   return t;
12616 }
12617
12618 /* Return the tree for abs (ARG0) when ARG0 is known to be either
12619    an integer constant or real constant.
12620
12621    TYPE is the type of the result.  */
12622
12623 tree
12624 fold_abs_const (tree arg0, tree type)
12625 {
12626   tree t = NULL_TREE;
12627
12628   switch (TREE_CODE (arg0))
12629     {
12630     case INTEGER_CST:
12631       /* If the value is unsigned, then the absolute value is
12632          the same as the ordinary value.  */
12633       if (TYPE_UNSIGNED (type))
12634         t = arg0;
12635       /* Similarly, if the value is non-negative.  */
12636       else if (INT_CST_LT (integer_minus_one_node, arg0))
12637         t = arg0;
12638       /* If the value is negative, then the absolute value is
12639          its negation.  */
12640       else
12641         {
12642           unsigned HOST_WIDE_INT low;
12643           HOST_WIDE_INT high;
12644           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
12645                                      TREE_INT_CST_HIGH (arg0),
12646                                      &low, &high);
12647           t = build_int_cst_wide (type, low, high);
12648           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
12649                               TREE_CONSTANT_OVERFLOW (arg0));
12650         }
12651       break;
12652
12653     case REAL_CST:
12654       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
12655         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
12656       else
12657         t =  arg0;
12658       break;
12659
12660     default:
12661       gcc_unreachable ();
12662     }
12663
12664   return t;
12665 }
12666
12667 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
12668    constant.  TYPE is the type of the result.  */
12669
12670 static tree
12671 fold_not_const (tree arg0, tree type)
12672 {
12673   tree t = NULL_TREE;
12674
12675   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
12676
12677   t = build_int_cst_wide (type,
12678                           ~ TREE_INT_CST_LOW (arg0),
12679                           ~ TREE_INT_CST_HIGH (arg0));
12680   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
12681                       TREE_CONSTANT_OVERFLOW (arg0));
12682
12683   return t;
12684 }
12685
12686 /* Given CODE, a relational operator, the target type, TYPE and two
12687    constant operands OP0 and OP1, return the result of the
12688    relational operation.  If the result is not a compile time
12689    constant, then return NULL_TREE.  */
12690
12691 static tree
12692 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
12693 {
12694   int result, invert;
12695
12696   /* From here on, the only cases we handle are when the result is
12697      known to be a constant.  */
12698
12699   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
12700     {
12701       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
12702       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
12703
12704       /* Handle the cases where either operand is a NaN.  */
12705       if (real_isnan (c0) || real_isnan (c1))
12706         {
12707           switch (code)
12708             {
12709             case EQ_EXPR:
12710             case ORDERED_EXPR:
12711               result = 0;
12712               break;
12713
12714             case NE_EXPR:
12715             case UNORDERED_EXPR:
12716             case UNLT_EXPR:
12717             case UNLE_EXPR:
12718             case UNGT_EXPR:
12719             case UNGE_EXPR:
12720             case UNEQ_EXPR:
12721               result = 1;
12722               break;
12723
12724             case LT_EXPR:
12725             case LE_EXPR:
12726             case GT_EXPR:
12727             case GE_EXPR:
12728             case LTGT_EXPR:
12729               if (flag_trapping_math)
12730                 return NULL_TREE;
12731               result = 0;
12732               break;
12733
12734             default:
12735               gcc_unreachable ();
12736             }
12737
12738           return constant_boolean_node (result, type);
12739         }
12740
12741       return constant_boolean_node (real_compare (code, c0, c1), type);
12742     }
12743
12744   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
12745
12746      To compute GT, swap the arguments and do LT.
12747      To compute GE, do LT and invert the result.
12748      To compute LE, swap the arguments, do LT and invert the result.
12749      To compute NE, do EQ and invert the result.
12750
12751      Therefore, the code below must handle only EQ and LT.  */
12752
12753   if (code == LE_EXPR || code == GT_EXPR)
12754     {
12755       tree tem = op0;
12756       op0 = op1;
12757       op1 = tem;
12758       code = swap_tree_comparison (code);
12759     }
12760
12761   /* Note that it is safe to invert for real values here because we
12762      have already handled the one case that it matters.  */
12763
12764   invert = 0;
12765   if (code == NE_EXPR || code == GE_EXPR)
12766     {
12767       invert = 1;
12768       code = invert_tree_comparison (code, false);
12769     }
12770
12771   /* Compute a result for LT or EQ if args permit;
12772      Otherwise return T.  */
12773   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
12774     {
12775       if (code == EQ_EXPR)
12776         result = tree_int_cst_equal (op0, op1);
12777       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
12778         result = INT_CST_LT_UNSIGNED (op0, op1);
12779       else
12780         result = INT_CST_LT (op0, op1);
12781     }
12782   else
12783     return NULL_TREE;
12784
12785   if (invert)
12786     result ^= 1;
12787   return constant_boolean_node (result, type);
12788 }
12789
12790 /* Build an expression for the a clean point containing EXPR with type TYPE.
12791    Don't build a cleanup point expression for EXPR which don't have side
12792    effects.  */
12793
12794 tree
12795 fold_build_cleanup_point_expr (tree type, tree expr)
12796 {
12797   /* If the expression does not have side effects then we don't have to wrap
12798      it with a cleanup point expression.  */
12799   if (!TREE_SIDE_EFFECTS (expr))
12800     return expr;
12801
12802   /* If the expression is a return, check to see if the expression inside the
12803      return has no side effects or the right hand side of the modify expression
12804      inside the return. If either don't have side effects set we don't need to
12805      wrap the expression in a cleanup point expression.  Note we don't check the
12806      left hand side of the modify because it should always be a return decl.  */
12807   if (TREE_CODE (expr) == RETURN_EXPR)
12808     {
12809       tree op = TREE_OPERAND (expr, 0);
12810       if (!op || !TREE_SIDE_EFFECTS (op))
12811         return expr;
12812       op = TREE_OPERAND (op, 1);
12813       if (!TREE_SIDE_EFFECTS (op))
12814         return expr;
12815     }
12816
12817   return build1 (CLEANUP_POINT_EXPR, type, expr);
12818 }
12819
12820 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
12821    avoid confusing the gimplify process.  */
12822
12823 tree
12824 build_fold_addr_expr_with_type (tree t, tree ptrtype)
12825 {
12826   /* The size of the object is not relevant when talking about its address.  */
12827   if (TREE_CODE (t) == WITH_SIZE_EXPR)
12828     t = TREE_OPERAND (t, 0);
12829
12830   /* Note: doesn't apply to ALIGN_INDIRECT_REF */
12831   if (TREE_CODE (t) == INDIRECT_REF
12832       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
12833     {
12834       t = TREE_OPERAND (t, 0);
12835       if (TREE_TYPE (t) != ptrtype)
12836         t = build1 (NOP_EXPR, ptrtype, t);
12837     }
12838   else
12839     {
12840       tree base = t;
12841
12842       while (handled_component_p (base))
12843         base = TREE_OPERAND (base, 0);
12844       if (DECL_P (base))
12845         TREE_ADDRESSABLE (base) = 1;
12846
12847       t = build1 (ADDR_EXPR, ptrtype, t);
12848     }
12849
12850   return t;
12851 }
12852
12853 tree
12854 build_fold_addr_expr (tree t)
12855 {
12856   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
12857 }
12858
12859 /* Given a pointer value OP0 and a type TYPE, return a simplified version
12860    of an indirection through OP0, or NULL_TREE if no simplification is
12861    possible.  */
12862
12863 tree
12864 fold_indirect_ref_1 (tree type, tree op0)
12865 {
12866   tree sub = op0;
12867   tree subtype;
12868
12869   STRIP_NOPS (sub);
12870   subtype = TREE_TYPE (sub);
12871   if (!POINTER_TYPE_P (subtype))
12872     return NULL_TREE;
12873
12874   if (TREE_CODE (sub) == ADDR_EXPR)
12875     {
12876       tree op = TREE_OPERAND (sub, 0);
12877       tree optype = TREE_TYPE (op);
12878       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
12879       if (type == optype)
12880         {
12881           tree fop = fold_read_from_constant_string (op);
12882           if (fop)
12883             return fop;
12884           else
12885             return op;
12886         }
12887       /* *(foo *)&fooarray => fooarray[0] */
12888       else if (TREE_CODE (optype) == ARRAY_TYPE
12889                && type == TREE_TYPE (optype))
12890         {
12891           tree type_domain = TYPE_DOMAIN (optype);
12892           tree min_val = size_zero_node;
12893           if (type_domain && TYPE_MIN_VALUE (type_domain))
12894             min_val = TYPE_MIN_VALUE (type_domain);
12895           return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
12896         }
12897       /* *(foo *)&complexfoo => __real__ complexfoo */
12898       else if (TREE_CODE (optype) == COMPLEX_TYPE
12899                && type == TREE_TYPE (optype))
12900         return fold_build1 (REALPART_EXPR, type, op);
12901     }
12902
12903   /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
12904   if (TREE_CODE (sub) == PLUS_EXPR
12905       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
12906     {
12907       tree op00 = TREE_OPERAND (sub, 0);
12908       tree op01 = TREE_OPERAND (sub, 1);
12909       tree op00type;
12910
12911       STRIP_NOPS (op00);
12912       op00type = TREE_TYPE (op00);
12913       if (TREE_CODE (op00) == ADDR_EXPR
12914           && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
12915           && type == TREE_TYPE (TREE_TYPE (op00type)))
12916         {
12917           tree size = TYPE_SIZE_UNIT (type);
12918           if (tree_int_cst_equal (size, op01))
12919             return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
12920         }
12921     }
12922
12923   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
12924   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
12925       && type == TREE_TYPE (TREE_TYPE (subtype)))
12926     {
12927       tree type_domain;
12928       tree min_val = size_zero_node;
12929       sub = build_fold_indirect_ref (sub);
12930       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
12931       if (type_domain && TYPE_MIN_VALUE (type_domain))
12932         min_val = TYPE_MIN_VALUE (type_domain);
12933       return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
12934     }
12935
12936   return NULL_TREE;
12937 }
12938
12939 /* Builds an expression for an indirection through T, simplifying some
12940    cases.  */
12941
12942 tree
12943 build_fold_indirect_ref (tree t)
12944 {
12945   tree type = TREE_TYPE (TREE_TYPE (t));
12946   tree sub = fold_indirect_ref_1 (type, t);
12947
12948   if (sub)
12949     return sub;
12950   else
12951     return build1 (INDIRECT_REF, type, t);
12952 }
12953
12954 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
12955
12956 tree
12957 fold_indirect_ref (tree t)
12958 {
12959   tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
12960
12961   if (sub)
12962     return sub;
12963   else
12964     return t;
12965 }
12966
12967 /* Strip non-trapping, non-side-effecting tree nodes from an expression
12968    whose result is ignored.  The type of the returned tree need not be
12969    the same as the original expression.  */
12970
12971 tree
12972 fold_ignored_result (tree t)
12973 {
12974   if (!TREE_SIDE_EFFECTS (t))
12975     return integer_zero_node;
12976
12977   for (;;)
12978     switch (TREE_CODE_CLASS (TREE_CODE (t)))
12979       {
12980       case tcc_unary:
12981         t = TREE_OPERAND (t, 0);
12982         break;
12983
12984       case tcc_binary:
12985       case tcc_comparison:
12986         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
12987           t = TREE_OPERAND (t, 0);
12988         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
12989           t = TREE_OPERAND (t, 1);
12990         else
12991           return t;
12992         break;
12993
12994       case tcc_expression:
12995         switch (TREE_CODE (t))
12996           {
12997           case COMPOUND_EXPR:
12998             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
12999               return t;
13000             t = TREE_OPERAND (t, 0);
13001             break;
13002
13003           case COND_EXPR:
13004             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
13005                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
13006               return t;
13007             t = TREE_OPERAND (t, 0);
13008             break;
13009
13010           default:
13011             return t;
13012           }
13013         break;
13014
13015       default:
13016         return t;
13017       }
13018 }
13019
13020 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
13021    This can only be applied to objects of a sizetype.  */
13022
13023 tree
13024 round_up (tree value, int divisor)
13025 {
13026   tree div = NULL_TREE;
13027
13028   gcc_assert (divisor > 0);
13029   if (divisor == 1)
13030     return value;
13031
13032   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
13033      have to do anything.  Only do this when we are not given a const,
13034      because in that case, this check is more expensive than just
13035      doing it.  */
13036   if (TREE_CODE (value) != INTEGER_CST)
13037     {
13038       div = build_int_cst (TREE_TYPE (value), divisor);
13039
13040       if (multiple_of_p (TREE_TYPE (value), value, div))
13041         return value;
13042     }
13043
13044   /* If divisor is a power of two, simplify this to bit manipulation.  */
13045   if (divisor == (divisor & -divisor))
13046     {
13047       tree t;
13048
13049       t = build_int_cst (TREE_TYPE (value), divisor - 1);
13050       value = size_binop (PLUS_EXPR, value, t);
13051       t = build_int_cst (TREE_TYPE (value), -divisor);
13052       value = size_binop (BIT_AND_EXPR, value, t);
13053     }
13054   else
13055     {
13056       if (!div)
13057         div = build_int_cst (TREE_TYPE (value), divisor);
13058       value = size_binop (CEIL_DIV_EXPR, value, div);
13059       value = size_binop (MULT_EXPR, value, div);
13060     }
13061
13062   return value;
13063 }
13064
13065 /* Likewise, but round down.  */
13066
13067 tree
13068 round_down (tree value, int divisor)
13069 {
13070   tree div = NULL_TREE;
13071
13072   gcc_assert (divisor > 0);
13073   if (divisor == 1)
13074     return value;
13075
13076   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
13077      have to do anything.  Only do this when we are not given a const,
13078      because in that case, this check is more expensive than just
13079      doing it.  */
13080   if (TREE_CODE (value) != INTEGER_CST)
13081     {
13082       div = build_int_cst (TREE_TYPE (value), divisor);
13083
13084       if (multiple_of_p (TREE_TYPE (value), value, div))
13085         return value;
13086     }
13087
13088   /* If divisor is a power of two, simplify this to bit manipulation.  */
13089   if (divisor == (divisor & -divisor))
13090     {
13091       tree t;
13092
13093       t = build_int_cst (TREE_TYPE (value), -divisor);
13094       value = size_binop (BIT_AND_EXPR, value, t);
13095     }
13096   else
13097     {
13098       if (!div)
13099         div = build_int_cst (TREE_TYPE (value), divisor);
13100       value = size_binop (FLOOR_DIV_EXPR, value, div);
13101       value = size_binop (MULT_EXPR, value, div);
13102     }
13103
13104   return value;
13105 }
13106
13107 /* Returns the pointer to the base of the object addressed by EXP and
13108    extracts the information about the offset of the access, storing it
13109    to PBITPOS and POFFSET.  */
13110
13111 static tree
13112 split_address_to_core_and_offset (tree exp,
13113                                   HOST_WIDE_INT *pbitpos, tree *poffset)
13114 {
13115   tree core;
13116   enum machine_mode mode;
13117   int unsignedp, volatilep;
13118   HOST_WIDE_INT bitsize;
13119
13120   if (TREE_CODE (exp) == ADDR_EXPR)
13121     {
13122       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
13123                                   poffset, &mode, &unsignedp, &volatilep,
13124                                   false);
13125       core = build_fold_addr_expr (core);
13126     }
13127   else
13128     {
13129       core = exp;
13130       *pbitpos = 0;
13131       *poffset = NULL_TREE;
13132     }
13133
13134   return core;
13135 }
13136
13137 /* Returns true if addresses of E1 and E2 differ by a constant, false
13138    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
13139
13140 bool
13141 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
13142 {
13143   tree core1, core2;
13144   HOST_WIDE_INT bitpos1, bitpos2;
13145   tree toffset1, toffset2, tdiff, type;
13146
13147   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
13148   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
13149
13150   if (bitpos1 % BITS_PER_UNIT != 0
13151       || bitpos2 % BITS_PER_UNIT != 0
13152       || !operand_equal_p (core1, core2, 0))
13153     return false;
13154
13155   if (toffset1 && toffset2)
13156     {
13157       type = TREE_TYPE (toffset1);
13158       if (type != TREE_TYPE (toffset2))
13159         toffset2 = fold_convert (type, toffset2);
13160
13161       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
13162       if (!cst_and_fits_in_hwi (tdiff))
13163         return false;
13164
13165       *diff = int_cst_value (tdiff);
13166     }
13167   else if (toffset1 || toffset2)
13168     {
13169       /* If only one of the offsets is non-constant, the difference cannot
13170          be a constant.  */
13171       return false;
13172     }
13173   else
13174     *diff = 0;
13175
13176   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
13177   return true;
13178 }
13179
13180 /* Simplify the floating point expression EXP when the sign of the
13181    result is not significant.  Return NULL_TREE if no simplification
13182    is possible.  */
13183
13184 tree
13185 fold_strip_sign_ops (tree exp)
13186 {
13187   tree arg0, arg1;
13188
13189   switch (TREE_CODE (exp))
13190     {
13191     case ABS_EXPR:
13192     case NEGATE_EXPR:
13193       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
13194       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
13195
13196     case MULT_EXPR:
13197     case RDIV_EXPR:
13198       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
13199         return NULL_TREE;
13200       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
13201       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
13202       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
13203         return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
13204                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
13205                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
13206       break;
13207
13208     default:
13209       break;
13210     }
13211   return NULL_TREE;
13212 }
13213