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, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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. */
30 /* The entry points in this file are fold, size_int_wide, size_binop
31 and force_fit_type_double.
33 fold takes a tree as argument and returns a simplified tree.
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'.
39 size_int takes an integer value, and creates a tree constant
40 with type from `sizetype'.
42 force_fit_type_double takes a constant, an overflowable flag and a
43 prior overflow indicator. It forces the value to fit the type and
46 Note: Since the folders get called on non-gimple code as well as
47 gimple code, we need to handle GIMPLE tuples as well as their
48 corresponding tree equivalents. */
52 #include "coretypes.h"
57 #include "fixed-value.h"
66 #include "langhooks.h"
70 /* Nonzero if we are folding constants inside an initializer; zero
72 int folding_initializer = 0;
74 /* The following constants represent a bit based encoding of GCC's
75 comparison operators. This encoding simplifies transformations
76 on relational comparison operators, such as AND and OR. */
77 enum comparison_code {
96 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
97 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
98 static bool negate_mathfn_p (enum built_in_function);
99 static bool negate_expr_p (tree);
100 static tree negate_expr (tree);
101 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
102 static tree associate_trees (tree, tree, enum tree_code, tree);
103 static tree const_binop (enum tree_code, tree, tree, int);
104 static enum comparison_code comparison_to_compcode (enum tree_code);
105 static enum tree_code compcode_to_comparison (enum comparison_code);
106 static int operand_equal_for_comparison_p (tree, tree, tree);
107 static int twoval_comparison_p (tree, tree *, tree *, int *);
108 static tree eval_subst (tree, tree, tree, tree, tree);
109 static tree pedantic_omit_one_operand (tree, tree, tree);
110 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
111 static tree make_bit_field_ref (tree, tree, HOST_WIDE_INT, HOST_WIDE_INT, int);
112 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
113 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
114 enum machine_mode *, int *, int *,
116 static int all_ones_mask_p (const_tree, int);
117 static tree sign_bit_p (tree, const_tree);
118 static int simple_operand_p (const_tree);
119 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
120 static tree range_predecessor (tree);
121 static tree range_successor (tree);
122 extern tree make_range (tree, int *, tree *, tree *, bool *);
123 extern tree build_range_check (tree, tree, int, tree, tree);
124 extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int,
126 static tree fold_range_test (enum tree_code, tree, tree, tree);
127 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
128 static tree unextend (tree, int, int, tree);
129 static tree fold_truthop (enum tree_code, tree, tree, tree);
130 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
131 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
132 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
133 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
136 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
138 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
139 static tree fold_div_compare (enum tree_code, tree, tree, tree);
140 static bool reorder_operands_p (const_tree, const_tree);
141 static tree fold_negate_const (tree, tree);
142 static tree fold_not_const (tree, tree);
143 static tree fold_relational_const (enum tree_code, tree, tree, tree);
144 static tree fold_convert_const (enum tree_code, tree, tree);
147 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
148 overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
149 and SUM1. Then this yields nonzero if overflow occurred during the
152 Overflow occurs if A and B have the same sign, but A and SUM differ in
153 sign. Use `^' to test whether signs differ, and `< 0' to isolate the
155 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
157 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
158 We do that by representing the two-word integer in 4 words, with only
159 HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
160 number. The value of the word is LOWPART + HIGHPART * BASE. */
163 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
164 #define HIGHPART(x) \
165 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
166 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
168 /* Unpack a two-word integer into 4 words.
169 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
170 WORDS points to the array of HOST_WIDE_INTs. */
173 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
175 words[0] = LOWPART (low);
176 words[1] = HIGHPART (low);
177 words[2] = LOWPART (hi);
178 words[3] = HIGHPART (hi);
181 /* Pack an array of 4 words into a two-word integer.
182 WORDS points to the array of words.
183 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
186 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
189 *low = words[0] + words[1] * BASE;
190 *hi = words[2] + words[3] * BASE;
193 /* Force the double-word integer L1, H1 to be within the range of the
194 integer type TYPE. Stores the properly truncated and sign-extended
195 double-word integer in *LV, *HV. Returns true if the operation
196 overflows, that is, argument and result are different. */
199 fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
200 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, const_tree type)
202 unsigned HOST_WIDE_INT low0 = l1;
203 HOST_WIDE_INT high0 = h1;
205 int sign_extended_type;
207 if (POINTER_TYPE_P (type)
208 || TREE_CODE (type) == OFFSET_TYPE)
211 prec = TYPE_PRECISION (type);
213 /* Size types *are* sign extended. */
214 sign_extended_type = (!TYPE_UNSIGNED (type)
215 || (TREE_CODE (type) == INTEGER_TYPE
216 && TYPE_IS_SIZETYPE (type)));
218 /* First clear all bits that are beyond the type's precision. */
219 if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
221 else if (prec > HOST_BITS_PER_WIDE_INT)
222 h1 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
226 if (prec < HOST_BITS_PER_WIDE_INT)
227 l1 &= ~((HOST_WIDE_INT) (-1) << prec);
230 /* Then do sign extension if necessary. */
231 if (!sign_extended_type)
232 /* No sign extension */;
233 else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
234 /* Correct width already. */;
235 else if (prec > HOST_BITS_PER_WIDE_INT)
237 /* Sign extend top half? */
238 if (h1 & ((unsigned HOST_WIDE_INT)1
239 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
240 h1 |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
242 else if (prec == HOST_BITS_PER_WIDE_INT)
244 if ((HOST_WIDE_INT)l1 < 0)
249 /* Sign extend bottom half? */
250 if (l1 & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
253 l1 |= (HOST_WIDE_INT)(-1) << prec;
260 /* If the value didn't fit, signal overflow. */
261 return l1 != low0 || h1 != high0;
264 /* We force the double-int HIGH:LOW to the range of the type TYPE by
265 sign or zero extending it.
266 OVERFLOWABLE indicates if we are interested
267 in overflow of the value, when >0 we are only interested in signed
268 overflow, for <0 we are interested in any overflow. OVERFLOWED
269 indicates whether overflow has already occurred. CONST_OVERFLOWED
270 indicates whether constant overflow has already occurred. We force
271 T's value to be within range of T's type (by setting to 0 or 1 all
272 the bits outside the type's range). We set TREE_OVERFLOWED if,
273 OVERFLOWED is nonzero,
274 or OVERFLOWABLE is >0 and signed overflow occurs
275 or OVERFLOWABLE is <0 and any overflow occurs
276 We return a new tree node for the extended double-int. The node
277 is shared if no overflow flags are set. */
280 force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
281 HOST_WIDE_INT high, int overflowable,
284 int sign_extended_type;
287 /* Size types *are* sign extended. */
288 sign_extended_type = (!TYPE_UNSIGNED (type)
289 || (TREE_CODE (type) == INTEGER_TYPE
290 && TYPE_IS_SIZETYPE (type)));
292 overflow = fit_double_type (low, high, &low, &high, type);
294 /* If we need to set overflow flags, return a new unshared node. */
295 if (overflowed || overflow)
299 || (overflowable > 0 && sign_extended_type))
301 tree t = make_node (INTEGER_CST);
302 TREE_INT_CST_LOW (t) = low;
303 TREE_INT_CST_HIGH (t) = high;
304 TREE_TYPE (t) = type;
305 TREE_OVERFLOW (t) = 1;
310 /* Else build a shared node. */
311 return build_int_cst_wide (type, low, high);
314 /* Add two doubleword integers with doubleword result.
315 Return nonzero if the operation overflows according to UNSIGNED_P.
316 Each argument is given as two `HOST_WIDE_INT' pieces.
317 One argument is L1 and H1; the other, L2 and H2.
318 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
321 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
322 unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
323 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
326 unsigned HOST_WIDE_INT l;
330 h = h1 + h2 + (l < l1);
336 return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
338 return OVERFLOW_SUM_SIGN (h1, h2, h);
341 /* Negate a doubleword integer with doubleword result.
342 Return nonzero if the operation overflows, assuming it's signed.
343 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
344 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
347 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
348 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
354 return (*hv & h1) < 0;
364 /* Multiply two doubleword integers with doubleword result.
365 Return nonzero if the operation overflows according to UNSIGNED_P.
366 Each argument is given as two `HOST_WIDE_INT' pieces.
367 One argument is L1 and H1; the other, L2 and H2.
368 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
371 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
372 unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
373 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
376 HOST_WIDE_INT arg1[4];
377 HOST_WIDE_INT arg2[4];
378 HOST_WIDE_INT prod[4 * 2];
379 unsigned HOST_WIDE_INT carry;
381 unsigned HOST_WIDE_INT toplow, neglow;
382 HOST_WIDE_INT tophigh, neghigh;
384 encode (arg1, l1, h1);
385 encode (arg2, l2, h2);
387 memset (prod, 0, sizeof prod);
389 for (i = 0; i < 4; i++)
392 for (j = 0; j < 4; j++)
395 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
396 carry += arg1[i] * arg2[j];
397 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
399 prod[k] = LOWPART (carry);
400 carry = HIGHPART (carry);
405 decode (prod, lv, hv);
406 decode (prod + 4, &toplow, &tophigh);
408 /* Unsigned overflow is immediate. */
410 return (toplow | tophigh) != 0;
412 /* Check for signed overflow by calculating the signed representation of the
413 top half of the result; it should agree with the low half's sign bit. */
416 neg_double (l2, h2, &neglow, &neghigh);
417 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
421 neg_double (l1, h1, &neglow, &neghigh);
422 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
424 return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
427 /* Shift the doubleword integer in L1, H1 left by COUNT places
428 keeping only PREC bits of result.
429 Shift right if COUNT is negative.
430 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
431 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
434 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
435 HOST_WIDE_INT count, unsigned int prec,
436 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
438 unsigned HOST_WIDE_INT signmask;
442 rshift_double (l1, h1, -count, prec, lv, hv, arith);
446 if (SHIFT_COUNT_TRUNCATED)
449 if (count >= 2 * HOST_BITS_PER_WIDE_INT)
451 /* Shifting by the host word size is undefined according to the
452 ANSI standard, so we must handle this as a special case. */
456 else if (count >= HOST_BITS_PER_WIDE_INT)
458 *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
463 *hv = (((unsigned HOST_WIDE_INT) h1 << count)
464 | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
468 /* Sign extend all bits that are beyond the precision. */
470 signmask = -((prec > HOST_BITS_PER_WIDE_INT
471 ? ((unsigned HOST_WIDE_INT) *hv
472 >> (prec - HOST_BITS_PER_WIDE_INT - 1))
473 : (*lv >> (prec - 1))) & 1);
475 if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
477 else if (prec >= HOST_BITS_PER_WIDE_INT)
479 *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
480 *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
485 *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
486 *lv |= signmask << prec;
490 /* Shift the doubleword integer in L1, H1 right by COUNT places
491 keeping only PREC bits of result. COUNT must be positive.
492 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
493 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
496 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
497 HOST_WIDE_INT count, unsigned int prec,
498 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
501 unsigned HOST_WIDE_INT signmask;
504 ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
507 if (SHIFT_COUNT_TRUNCATED)
510 if (count >= 2 * HOST_BITS_PER_WIDE_INT)
512 /* Shifting by the host word size is undefined according to the
513 ANSI standard, so we must handle this as a special case. */
517 else if (count >= HOST_BITS_PER_WIDE_INT)
520 *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
524 *hv = (unsigned HOST_WIDE_INT) h1 >> count;
526 | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
529 /* Zero / sign extend all bits that are beyond the precision. */
531 if (count >= (HOST_WIDE_INT)prec)
536 else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
538 else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
540 *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
541 *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
546 *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
547 *lv |= signmask << (prec - count);
551 /* Rotate the doubleword integer in L1, H1 left by COUNT places
552 keeping only PREC bits of result.
553 Rotate right if COUNT is negative.
554 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
557 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
558 HOST_WIDE_INT count, unsigned int prec,
559 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
561 unsigned HOST_WIDE_INT s1l, s2l;
562 HOST_WIDE_INT s1h, s2h;
568 lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
569 rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
574 /* Rotate the doubleword integer in L1, H1 left by COUNT places
575 keeping only PREC bits of result. COUNT must be positive.
576 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
579 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
580 HOST_WIDE_INT count, unsigned int prec,
581 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
583 unsigned HOST_WIDE_INT s1l, s2l;
584 HOST_WIDE_INT s1h, s2h;
590 rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
591 lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
596 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
597 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
598 CODE is a tree code for a kind of division, one of
599 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
601 It controls how the quotient is rounded to an integer.
602 Return nonzero if the operation overflows.
603 UNS nonzero says do unsigned division. */
606 div_and_round_double (enum tree_code code, int uns,
607 unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
608 HOST_WIDE_INT hnum_orig,
609 unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
610 HOST_WIDE_INT hden_orig,
611 unsigned HOST_WIDE_INT *lquo,
612 HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
616 HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
617 HOST_WIDE_INT den[4], quo[4];
619 unsigned HOST_WIDE_INT work;
620 unsigned HOST_WIDE_INT carry = 0;
621 unsigned HOST_WIDE_INT lnum = lnum_orig;
622 HOST_WIDE_INT hnum = hnum_orig;
623 unsigned HOST_WIDE_INT lden = lden_orig;
624 HOST_WIDE_INT hden = hden_orig;
627 if (hden == 0 && lden == 0)
628 overflow = 1, lden = 1;
630 /* Calculate quotient sign and convert operands to unsigned. */
636 /* (minimum integer) / (-1) is the only overflow case. */
637 if (neg_double (lnum, hnum, &lnum, &hnum)
638 && ((HOST_WIDE_INT) lden & hden) == -1)
644 neg_double (lden, hden, &lden, &hden);
648 if (hnum == 0 && hden == 0)
649 { /* single precision */
651 /* This unsigned division rounds toward zero. */
657 { /* trivial case: dividend < divisor */
658 /* hden != 0 already checked. */
665 memset (quo, 0, sizeof quo);
667 memset (num, 0, sizeof num); /* to zero 9th element */
668 memset (den, 0, sizeof den);
670 encode (num, lnum, hnum);
671 encode (den, lden, hden);
673 /* Special code for when the divisor < BASE. */
674 if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
676 /* hnum != 0 already checked. */
677 for (i = 4 - 1; i >= 0; i--)
679 work = num[i] + carry * BASE;
680 quo[i] = work / lden;
686 /* Full double precision division,
687 with thanks to Don Knuth's "Seminumerical Algorithms". */
688 int num_hi_sig, den_hi_sig;
689 unsigned HOST_WIDE_INT quo_est, scale;
691 /* Find the highest nonzero divisor digit. */
692 for (i = 4 - 1;; i--)
699 /* Insure that the first digit of the divisor is at least BASE/2.
700 This is required by the quotient digit estimation algorithm. */
702 scale = BASE / (den[den_hi_sig] + 1);
704 { /* scale divisor and dividend */
706 for (i = 0; i <= 4 - 1; i++)
708 work = (num[i] * scale) + carry;
709 num[i] = LOWPART (work);
710 carry = HIGHPART (work);
715 for (i = 0; i <= 4 - 1; i++)
717 work = (den[i] * scale) + carry;
718 den[i] = LOWPART (work);
719 carry = HIGHPART (work);
720 if (den[i] != 0) den_hi_sig = i;
727 for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
729 /* Guess the next quotient digit, quo_est, by dividing the first
730 two remaining dividend digits by the high order quotient digit.
731 quo_est is never low and is at most 2 high. */
732 unsigned HOST_WIDE_INT tmp;
734 num_hi_sig = i + den_hi_sig + 1;
735 work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
736 if (num[num_hi_sig] != den[den_hi_sig])
737 quo_est = work / den[den_hi_sig];
741 /* Refine quo_est so it's usually correct, and at most one high. */
742 tmp = work - quo_est * den[den_hi_sig];
744 && (den[den_hi_sig - 1] * quo_est
745 > (tmp * BASE + num[num_hi_sig - 2])))
748 /* Try QUO_EST as the quotient digit, by multiplying the
749 divisor by QUO_EST and subtracting from the remaining dividend.
750 Keep in mind that QUO_EST is the I - 1st digit. */
753 for (j = 0; j <= den_hi_sig; j++)
755 work = quo_est * den[j] + carry;
756 carry = HIGHPART (work);
757 work = num[i + j] - LOWPART (work);
758 num[i + j] = LOWPART (work);
759 carry += HIGHPART (work) != 0;
762 /* If quo_est was high by one, then num[i] went negative and
763 we need to correct things. */
764 if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
767 carry = 0; /* add divisor back in */
768 for (j = 0; j <= den_hi_sig; j++)
770 work = num[i + j] + den[j] + carry;
771 carry = HIGHPART (work);
772 num[i + j] = LOWPART (work);
775 num [num_hi_sig] += carry;
778 /* Store the quotient digit. */
783 decode (quo, lquo, hquo);
786 /* If result is negative, make it so. */
788 neg_double (*lquo, *hquo, lquo, hquo);
790 /* Compute trial remainder: rem = num - (quo * den) */
791 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
792 neg_double (*lrem, *hrem, lrem, hrem);
793 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
798 case TRUNC_MOD_EXPR: /* round toward zero */
799 case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
803 case FLOOR_MOD_EXPR: /* round toward negative infinity */
804 if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
807 add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
815 case CEIL_MOD_EXPR: /* round toward positive infinity */
816 if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
818 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
826 case ROUND_MOD_EXPR: /* round to closest integer */
828 unsigned HOST_WIDE_INT labs_rem = *lrem;
829 HOST_WIDE_INT habs_rem = *hrem;
830 unsigned HOST_WIDE_INT labs_den = lden, ltwice;
831 HOST_WIDE_INT habs_den = hden, htwice;
833 /* Get absolute values. */
835 neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
837 neg_double (lden, hden, &labs_den, &habs_den);
839 /* If (2 * abs (lrem) >= abs (lden)), adjust the quotient. */
840 mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
841 labs_rem, habs_rem, <wice, &htwice);
843 if (((unsigned HOST_WIDE_INT) habs_den
844 < (unsigned HOST_WIDE_INT) htwice)
845 || (((unsigned HOST_WIDE_INT) habs_den
846 == (unsigned HOST_WIDE_INT) htwice)
847 && (labs_den <= ltwice)))
851 add_double (*lquo, *hquo,
852 (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
855 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
867 /* Compute true remainder: rem = num - (quo * den) */
868 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
869 neg_double (*lrem, *hrem, lrem, hrem);
870 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
874 /* If ARG2 divides ARG1 with zero remainder, carries out the division
875 of type CODE and returns the quotient.
876 Otherwise returns NULL_TREE. */
879 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
881 unsigned HOST_WIDE_INT int1l, int2l;
882 HOST_WIDE_INT int1h, int2h;
883 unsigned HOST_WIDE_INT quol, reml;
884 HOST_WIDE_INT quoh, remh;
885 tree type = TREE_TYPE (arg1);
886 int uns = TYPE_UNSIGNED (type);
888 int1l = TREE_INT_CST_LOW (arg1);
889 int1h = TREE_INT_CST_HIGH (arg1);
890 /* &obj[0] + -128 really should be compiled as &obj[-8] rather than
891 &obj[some_exotic_number]. */
892 if (POINTER_TYPE_P (type))
895 type = signed_type_for (type);
896 fit_double_type (int1l, int1h, &int1l, &int1h,
900 fit_double_type (int1l, int1h, &int1l, &int1h, type);
901 int2l = TREE_INT_CST_LOW (arg2);
902 int2h = TREE_INT_CST_HIGH (arg2);
904 div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
905 &quol, &quoh, &reml, &remh);
906 if (remh != 0 || reml != 0)
909 return build_int_cst_wide (type, quol, quoh);
912 /* This is nonzero if we should defer warnings about undefined
913 overflow. This facility exists because these warnings are a
914 special case. The code to estimate loop iterations does not want
915 to issue any warnings, since it works with expressions which do not
916 occur in user code. Various bits of cleanup code call fold(), but
917 only use the result if it has certain characteristics (e.g., is a
918 constant); that code only wants to issue a warning if the result is
921 static int fold_deferring_overflow_warnings;
923 /* If a warning about undefined overflow is deferred, this is the
924 warning. Note that this may cause us to turn two warnings into
925 one, but that is fine since it is sufficient to only give one
926 warning per expression. */
928 static const char* fold_deferred_overflow_warning;
930 /* If a warning about undefined overflow is deferred, this is the
931 level at which the warning should be emitted. */
933 static enum warn_strict_overflow_code fold_deferred_overflow_code;
935 /* Start deferring overflow warnings. We could use a stack here to
936 permit nested calls, but at present it is not necessary. */
939 fold_defer_overflow_warnings (void)
941 ++fold_deferring_overflow_warnings;
944 /* Stop deferring overflow warnings. If there is a pending warning,
945 and ISSUE is true, then issue the warning if appropriate. STMT is
946 the statement with which the warning should be associated (used for
947 location information); STMT may be NULL. CODE is the level of the
948 warning--a warn_strict_overflow_code value. This function will use
949 the smaller of CODE and the deferred code when deciding whether to
950 issue the warning. CODE may be zero to mean to always use the
954 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
959 gcc_assert (fold_deferring_overflow_warnings > 0);
960 --fold_deferring_overflow_warnings;
961 if (fold_deferring_overflow_warnings > 0)
963 if (fold_deferred_overflow_warning != NULL
965 && code < (int) fold_deferred_overflow_code)
966 fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
970 warnmsg = fold_deferred_overflow_warning;
971 fold_deferred_overflow_warning = NULL;
973 if (!issue || warnmsg == NULL)
976 if (gimple_no_warning_p (stmt))
979 /* Use the smallest code level when deciding to issue the
981 if (code == 0 || code > (int) fold_deferred_overflow_code)
982 code = fold_deferred_overflow_code;
984 if (!issue_strict_overflow_warning (code))
988 locus = input_location;
990 locus = gimple_location (stmt);
991 warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
994 /* Stop deferring overflow warnings, ignoring any deferred
998 fold_undefer_and_ignore_overflow_warnings (void)
1000 fold_undefer_overflow_warnings (false, NULL, 0);
1003 /* Whether we are deferring overflow warnings. */
1006 fold_deferring_overflow_warnings_p (void)
1008 return fold_deferring_overflow_warnings > 0;
1011 /* This is called when we fold something based on the fact that signed
1012 overflow is undefined. */
1015 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
1017 if (fold_deferring_overflow_warnings > 0)
1019 if (fold_deferred_overflow_warning == NULL
1020 || wc < fold_deferred_overflow_code)
1022 fold_deferred_overflow_warning = gmsgid;
1023 fold_deferred_overflow_code = wc;
1026 else if (issue_strict_overflow_warning (wc))
1027 warning (OPT_Wstrict_overflow, gmsgid);
1030 /* Return true if the built-in mathematical function specified by CODE
1031 is odd, i.e. -f(x) == f(-x). */
1034 negate_mathfn_p (enum built_in_function code)
1038 CASE_FLT_FN (BUILT_IN_ASIN):
1039 CASE_FLT_FN (BUILT_IN_ASINH):
1040 CASE_FLT_FN (BUILT_IN_ATAN):
1041 CASE_FLT_FN (BUILT_IN_ATANH):
1042 CASE_FLT_FN (BUILT_IN_CASIN):
1043 CASE_FLT_FN (BUILT_IN_CASINH):
1044 CASE_FLT_FN (BUILT_IN_CATAN):
1045 CASE_FLT_FN (BUILT_IN_CATANH):
1046 CASE_FLT_FN (BUILT_IN_CBRT):
1047 CASE_FLT_FN (BUILT_IN_CPROJ):
1048 CASE_FLT_FN (BUILT_IN_CSIN):
1049 CASE_FLT_FN (BUILT_IN_CSINH):
1050 CASE_FLT_FN (BUILT_IN_CTAN):
1051 CASE_FLT_FN (BUILT_IN_CTANH):
1052 CASE_FLT_FN (BUILT_IN_ERF):
1053 CASE_FLT_FN (BUILT_IN_LLROUND):
1054 CASE_FLT_FN (BUILT_IN_LROUND):
1055 CASE_FLT_FN (BUILT_IN_ROUND):
1056 CASE_FLT_FN (BUILT_IN_SIN):
1057 CASE_FLT_FN (BUILT_IN_SINH):
1058 CASE_FLT_FN (BUILT_IN_TAN):
1059 CASE_FLT_FN (BUILT_IN_TANH):
1060 CASE_FLT_FN (BUILT_IN_TRUNC):
1063 CASE_FLT_FN (BUILT_IN_LLRINT):
1064 CASE_FLT_FN (BUILT_IN_LRINT):
1065 CASE_FLT_FN (BUILT_IN_NEARBYINT):
1066 CASE_FLT_FN (BUILT_IN_RINT):
1067 return !flag_rounding_math;
1075 /* Check whether we may negate an integer constant T without causing
1079 may_negate_without_overflow_p (const_tree t)
1081 unsigned HOST_WIDE_INT val;
1085 gcc_assert (TREE_CODE (t) == INTEGER_CST);
1087 type = TREE_TYPE (t);
1088 if (TYPE_UNSIGNED (type))
1091 prec = TYPE_PRECISION (type);
1092 if (prec > HOST_BITS_PER_WIDE_INT)
1094 if (TREE_INT_CST_LOW (t) != 0)
1096 prec -= HOST_BITS_PER_WIDE_INT;
1097 val = TREE_INT_CST_HIGH (t);
1100 val = TREE_INT_CST_LOW (t);
1101 if (prec < HOST_BITS_PER_WIDE_INT)
1102 val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1103 return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
1106 /* Determine whether an expression T can be cheaply negated using
1107 the function negate_expr without introducing undefined overflow. */
1110 negate_expr_p (tree t)
1117 type = TREE_TYPE (t);
1119 STRIP_SIGN_NOPS (t);
1120 switch (TREE_CODE (t))
1123 if (TYPE_OVERFLOW_WRAPS (type))
1126 /* Check that -CST will not overflow type. */
1127 return may_negate_without_overflow_p (t);
1129 return (INTEGRAL_TYPE_P (type)
1130 && TYPE_OVERFLOW_WRAPS (type));
1138 return negate_expr_p (TREE_REALPART (t))
1139 && negate_expr_p (TREE_IMAGPART (t));
1142 return negate_expr_p (TREE_OPERAND (t, 0))
1143 && negate_expr_p (TREE_OPERAND (t, 1));
1146 return negate_expr_p (TREE_OPERAND (t, 0));
1149 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1150 || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1152 /* -(A + B) -> (-B) - A. */
1153 if (negate_expr_p (TREE_OPERAND (t, 1))
1154 && reorder_operands_p (TREE_OPERAND (t, 0),
1155 TREE_OPERAND (t, 1)))
1157 /* -(A + B) -> (-A) - B. */
1158 return negate_expr_p (TREE_OPERAND (t, 0));
1161 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
1162 return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1163 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1164 && reorder_operands_p (TREE_OPERAND (t, 0),
1165 TREE_OPERAND (t, 1));
1168 if (TYPE_UNSIGNED (TREE_TYPE (t)))
1174 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
1175 return negate_expr_p (TREE_OPERAND (t, 1))
1176 || negate_expr_p (TREE_OPERAND (t, 0));
1179 case TRUNC_DIV_EXPR:
1180 case ROUND_DIV_EXPR:
1181 case FLOOR_DIV_EXPR:
1183 case EXACT_DIV_EXPR:
1184 /* In general we can't negate A / B, because if A is INT_MIN and
1185 B is 1, we may turn this into INT_MIN / -1 which is undefined
1186 and actually traps on some architectures. But if overflow is
1187 undefined, we can negate, because - (INT_MIN / 1) is an
1189 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
1190 && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
1192 return negate_expr_p (TREE_OPERAND (t, 1))
1193 || negate_expr_p (TREE_OPERAND (t, 0));
1196 /* Negate -((double)float) as (double)(-float). */
1197 if (TREE_CODE (type) == REAL_TYPE)
1199 tree tem = strip_float_extensions (t);
1201 return negate_expr_p (tem);
1206 /* Negate -f(x) as f(-x). */
1207 if (negate_mathfn_p (builtin_mathfn_code (t)))
1208 return negate_expr_p (CALL_EXPR_ARG (t, 0));
1212 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
1213 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1215 tree op1 = TREE_OPERAND (t, 1);
1216 if (TREE_INT_CST_HIGH (op1) == 0
1217 && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1218 == TREE_INT_CST_LOW (op1))
1229 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
1230 simplification is possible.
1231 If negate_expr_p would return true for T, NULL_TREE will never be
1235 fold_negate_expr (tree t)
1237 tree type = TREE_TYPE (t);
1240 switch (TREE_CODE (t))
1242 /* Convert - (~A) to A + 1. */
1244 if (INTEGRAL_TYPE_P (type))
1245 return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
1246 build_int_cst (type, 1));
1250 tem = fold_negate_const (t, type);
1251 if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
1252 || !TYPE_OVERFLOW_TRAPS (type))
1257 tem = fold_negate_const (t, type);
1258 /* Two's complement FP formats, such as c4x, may overflow. */
1259 if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
1264 tem = fold_negate_const (t, type);
1269 tree rpart = negate_expr (TREE_REALPART (t));
1270 tree ipart = negate_expr (TREE_IMAGPART (t));
1272 if ((TREE_CODE (rpart) == REAL_CST
1273 && TREE_CODE (ipart) == REAL_CST)
1274 || (TREE_CODE (rpart) == INTEGER_CST
1275 && TREE_CODE (ipart) == INTEGER_CST))
1276 return build_complex (type, rpart, ipart);
1281 if (negate_expr_p (t))
1282 return fold_build2 (COMPLEX_EXPR, type,
1283 fold_negate_expr (TREE_OPERAND (t, 0)),
1284 fold_negate_expr (TREE_OPERAND (t, 1)));
1288 if (negate_expr_p (t))
1289 return fold_build1 (CONJ_EXPR, type,
1290 fold_negate_expr (TREE_OPERAND (t, 0)));
1294 return TREE_OPERAND (t, 0);
1297 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1298 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1300 /* -(A + B) -> (-B) - A. */
1301 if (negate_expr_p (TREE_OPERAND (t, 1))
1302 && reorder_operands_p (TREE_OPERAND (t, 0),
1303 TREE_OPERAND (t, 1)))
1305 tem = negate_expr (TREE_OPERAND (t, 1));
1306 return fold_build2 (MINUS_EXPR, type,
1307 tem, TREE_OPERAND (t, 0));
1310 /* -(A + B) -> (-A) - B. */
1311 if (negate_expr_p (TREE_OPERAND (t, 0)))
1313 tem = negate_expr (TREE_OPERAND (t, 0));
1314 return fold_build2 (MINUS_EXPR, type,
1315 tem, TREE_OPERAND (t, 1));
1321 /* - (A - B) -> B - A */
1322 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1323 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1324 && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1325 return fold_build2 (MINUS_EXPR, type,
1326 TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
1330 if (TYPE_UNSIGNED (type))
1336 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
1338 tem = TREE_OPERAND (t, 1);
1339 if (negate_expr_p (tem))
1340 return fold_build2 (TREE_CODE (t), type,
1341 TREE_OPERAND (t, 0), negate_expr (tem));
1342 tem = TREE_OPERAND (t, 0);
1343 if (negate_expr_p (tem))
1344 return fold_build2 (TREE_CODE (t), type,
1345 negate_expr (tem), TREE_OPERAND (t, 1));
1349 case TRUNC_DIV_EXPR:
1350 case ROUND_DIV_EXPR:
1351 case FLOOR_DIV_EXPR:
1353 case EXACT_DIV_EXPR:
1354 /* In general we can't negate A / B, because if A is INT_MIN and
1355 B is 1, we may turn this into INT_MIN / -1 which is undefined
1356 and actually traps on some architectures. But if overflow is
1357 undefined, we can negate, because - (INT_MIN / 1) is an
1359 if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
1361 const char * const warnmsg = G_("assuming signed overflow does not "
1362 "occur when negating a division");
1363 tem = TREE_OPERAND (t, 1);
1364 if (negate_expr_p (tem))
1366 if (INTEGRAL_TYPE_P (type)
1367 && (TREE_CODE (tem) != INTEGER_CST
1368 || integer_onep (tem)))
1369 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1370 return fold_build2 (TREE_CODE (t), type,
1371 TREE_OPERAND (t, 0), negate_expr (tem));
1373 tem = TREE_OPERAND (t, 0);
1374 if (negate_expr_p (tem))
1376 if (INTEGRAL_TYPE_P (type)
1377 && (TREE_CODE (tem) != INTEGER_CST
1378 || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
1379 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1380 return fold_build2 (TREE_CODE (t), type,
1381 negate_expr (tem), TREE_OPERAND (t, 1));
1387 /* Convert -((double)float) into (double)(-float). */
1388 if (TREE_CODE (type) == REAL_TYPE)
1390 tem = strip_float_extensions (t);
1391 if (tem != t && negate_expr_p (tem))
1392 return fold_convert (type, negate_expr (tem));
1397 /* Negate -f(x) as f(-x). */
1398 if (negate_mathfn_p (builtin_mathfn_code (t))
1399 && negate_expr_p (CALL_EXPR_ARG (t, 0)))
1403 fndecl = get_callee_fndecl (t);
1404 arg = negate_expr (CALL_EXPR_ARG (t, 0));
1405 return build_call_expr (fndecl, 1, arg);
1410 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
1411 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1413 tree op1 = TREE_OPERAND (t, 1);
1414 if (TREE_INT_CST_HIGH (op1) == 0
1415 && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1416 == TREE_INT_CST_LOW (op1))
1418 tree ntype = TYPE_UNSIGNED (type)
1419 ? signed_type_for (type)
1420 : unsigned_type_for (type);
1421 tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1422 temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1423 return fold_convert (type, temp);
1435 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
1436 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
1437 return NULL_TREE. */
1440 negate_expr (tree t)
1447 type = TREE_TYPE (t);
1448 STRIP_SIGN_NOPS (t);
1450 tem = fold_negate_expr (t);
1452 tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1453 return fold_convert (type, tem);
1456 /* Split a tree IN into a constant, literal and variable parts that could be
1457 combined with CODE to make IN. "constant" means an expression with
1458 TREE_CONSTANT but that isn't an actual constant. CODE must be a
1459 commutative arithmetic operation. Store the constant part into *CONP,
1460 the literal in *LITP and return the variable part. If a part isn't
1461 present, set it to null. If the tree does not decompose in this way,
1462 return the entire tree as the variable part and the other parts as null.
1464 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
1465 case, we negate an operand that was subtracted. Except if it is a
1466 literal for which we use *MINUS_LITP instead.
1468 If NEGATE_P is true, we are negating all of IN, again except a literal
1469 for which we use *MINUS_LITP instead.
1471 If IN is itself a literal or constant, return it as appropriate.
1473 Note that we do not guarantee that any of the three values will be the
1474 same type as IN, but they will have the same signedness and mode. */
1477 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1478 tree *minus_litp, int negate_p)
1486 /* Strip any conversions that don't change the machine mode or signedness. */
1487 STRIP_SIGN_NOPS (in);
1489 if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
1490 || TREE_CODE (in) == FIXED_CST)
1492 else if (TREE_CODE (in) == code
1493 || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
1494 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
1495 /* We can associate addition and subtraction together (even
1496 though the C standard doesn't say so) for integers because
1497 the value is not affected. For reals, the value might be
1498 affected, so we can't. */
1499 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1500 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1502 tree op0 = TREE_OPERAND (in, 0);
1503 tree op1 = TREE_OPERAND (in, 1);
1504 int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1505 int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1507 /* First see if either of the operands is a literal, then a constant. */
1508 if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
1509 || TREE_CODE (op0) == FIXED_CST)
1510 *litp = op0, op0 = 0;
1511 else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
1512 || TREE_CODE (op1) == FIXED_CST)
1513 *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1515 if (op0 != 0 && TREE_CONSTANT (op0))
1516 *conp = op0, op0 = 0;
1517 else if (op1 != 0 && TREE_CONSTANT (op1))
1518 *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1520 /* If we haven't dealt with either operand, this is not a case we can
1521 decompose. Otherwise, VAR is either of the ones remaining, if any. */
1522 if (op0 != 0 && op1 != 0)
1527 var = op1, neg_var_p = neg1_p;
1529 /* Now do any needed negations. */
1531 *minus_litp = *litp, *litp = 0;
1533 *conp = negate_expr (*conp);
1535 var = negate_expr (var);
1537 else if (TREE_CONSTANT (in))
1545 *minus_litp = *litp, *litp = 0;
1546 else if (*minus_litp)
1547 *litp = *minus_litp, *minus_litp = 0;
1548 *conp = negate_expr (*conp);
1549 var = negate_expr (var);
1555 /* Re-associate trees split by the above function. T1 and T2 are either
1556 expressions to associate or null. Return the new expression, if any. If
1557 we build an operation, do it in TYPE and with CODE. */
1560 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1567 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1568 try to fold this since we will have infinite recursion. But do
1569 deal with any NEGATE_EXPRs. */
1570 if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1571 || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1573 if (code == PLUS_EXPR)
1575 if (TREE_CODE (t1) == NEGATE_EXPR)
1576 return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1577 fold_convert (type, TREE_OPERAND (t1, 0)));
1578 else if (TREE_CODE (t2) == NEGATE_EXPR)
1579 return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1580 fold_convert (type, TREE_OPERAND (t2, 0)));
1581 else if (integer_zerop (t2))
1582 return fold_convert (type, t1);
1584 else if (code == MINUS_EXPR)
1586 if (integer_zerop (t2))
1587 return fold_convert (type, t1);
1590 return build2 (code, type, fold_convert (type, t1),
1591 fold_convert (type, t2));
1594 return fold_build2 (code, type, fold_convert (type, t1),
1595 fold_convert (type, t2));
1598 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
1599 for use in int_const_binop, size_binop and size_diffop. */
1602 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
1604 if (TREE_CODE (type1) != INTEGER_TYPE && !POINTER_TYPE_P (type1))
1606 if (TREE_CODE (type2) != INTEGER_TYPE && !POINTER_TYPE_P (type2))
1621 return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
1622 && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
1623 && TYPE_MODE (type1) == TYPE_MODE (type2);
1627 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1628 to produce a new constant. Return NULL_TREE if we don't know how
1629 to evaluate CODE at compile-time.
1631 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1634 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2, int notrunc)
1636 unsigned HOST_WIDE_INT int1l, int2l;
1637 HOST_WIDE_INT int1h, int2h;
1638 unsigned HOST_WIDE_INT low;
1640 unsigned HOST_WIDE_INT garbagel;
1641 HOST_WIDE_INT garbageh;
1643 tree type = TREE_TYPE (arg1);
1644 int uns = TYPE_UNSIGNED (type);
1646 = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1649 int1l = TREE_INT_CST_LOW (arg1);
1650 int1h = TREE_INT_CST_HIGH (arg1);
1651 int2l = TREE_INT_CST_LOW (arg2);
1652 int2h = TREE_INT_CST_HIGH (arg2);
1657 low = int1l | int2l, hi = int1h | int2h;
1661 low = int1l ^ int2l, hi = int1h ^ int2h;
1665 low = int1l & int2l, hi = int1h & int2h;
1671 /* It's unclear from the C standard whether shifts can overflow.
1672 The following code ignores overflow; perhaps a C standard
1673 interpretation ruling is needed. */
1674 lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1681 lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1686 overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1690 neg_double (int2l, int2h, &low, &hi);
1691 add_double (int1l, int1h, low, hi, &low, &hi);
1692 overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1696 overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1699 case TRUNC_DIV_EXPR:
1700 case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1701 case EXACT_DIV_EXPR:
1702 /* This is a shortcut for a common special case. */
1703 if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1704 && !TREE_OVERFLOW (arg1)
1705 && !TREE_OVERFLOW (arg2)
1706 && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1708 if (code == CEIL_DIV_EXPR)
1711 low = int1l / int2l, hi = 0;
1715 /* ... fall through ... */
1717 case ROUND_DIV_EXPR:
1718 if (int2h == 0 && int2l == 0)
1720 if (int2h == 0 && int2l == 1)
1722 low = int1l, hi = int1h;
1725 if (int1l == int2l && int1h == int2h
1726 && ! (int1l == 0 && int1h == 0))
1731 overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1732 &low, &hi, &garbagel, &garbageh);
1735 case TRUNC_MOD_EXPR:
1736 case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1737 /* This is a shortcut for a common special case. */
1738 if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1739 && !TREE_OVERFLOW (arg1)
1740 && !TREE_OVERFLOW (arg2)
1741 && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1743 if (code == CEIL_MOD_EXPR)
1745 low = int1l % int2l, hi = 0;
1749 /* ... fall through ... */
1751 case ROUND_MOD_EXPR:
1752 if (int2h == 0 && int2l == 0)
1754 overflow = div_and_round_double (code, uns,
1755 int1l, int1h, int2l, int2h,
1756 &garbagel, &garbageh, &low, &hi);
1762 low = (((unsigned HOST_WIDE_INT) int1h
1763 < (unsigned HOST_WIDE_INT) int2h)
1764 || (((unsigned HOST_WIDE_INT) int1h
1765 == (unsigned HOST_WIDE_INT) int2h)
1768 low = (int1h < int2h
1769 || (int1h == int2h && int1l < int2l));
1771 if (low == (code == MIN_EXPR))
1772 low = int1l, hi = int1h;
1774 low = int2l, hi = int2h;
1783 t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1785 /* Propagate overflow flags ourselves. */
1786 if (((!uns || is_sizetype) && overflow)
1787 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1790 TREE_OVERFLOW (t) = 1;
1794 t = force_fit_type_double (TREE_TYPE (arg1), low, hi, 1,
1795 ((!uns || is_sizetype) && overflow)
1796 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1801 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1802 constant. We assume ARG1 and ARG2 have the same data type, or at least
1803 are the same kind of constant and the same machine mode. Return zero if
1804 combining the constants is not allowed in the current operating mode.
1806 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1809 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1811 /* Sanity check for the recursive cases. */
1818 if (TREE_CODE (arg1) == INTEGER_CST)
1819 return int_const_binop (code, arg1, arg2, notrunc);
1821 if (TREE_CODE (arg1) == REAL_CST)
1823 enum machine_mode mode;
1826 REAL_VALUE_TYPE value;
1827 REAL_VALUE_TYPE result;
1831 /* The following codes are handled by real_arithmetic. */
1846 d1 = TREE_REAL_CST (arg1);
1847 d2 = TREE_REAL_CST (arg2);
1849 type = TREE_TYPE (arg1);
1850 mode = TYPE_MODE (type);
1852 /* Don't perform operation if we honor signaling NaNs and
1853 either operand is a NaN. */
1854 if (HONOR_SNANS (mode)
1855 && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1858 /* Don't perform operation if it would raise a division
1859 by zero exception. */
1860 if (code == RDIV_EXPR
1861 && REAL_VALUES_EQUAL (d2, dconst0)
1862 && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1865 /* If either operand is a NaN, just return it. Otherwise, set up
1866 for floating-point trap; we return an overflow. */
1867 if (REAL_VALUE_ISNAN (d1))
1869 else if (REAL_VALUE_ISNAN (d2))
1872 inexact = real_arithmetic (&value, code, &d1, &d2);
1873 real_convert (&result, mode, &value);
1875 /* Don't constant fold this floating point operation if
1876 the result has overflowed and flag_trapping_math. */
1877 if (flag_trapping_math
1878 && MODE_HAS_INFINITIES (mode)
1879 && REAL_VALUE_ISINF (result)
1880 && !REAL_VALUE_ISINF (d1)
1881 && !REAL_VALUE_ISINF (d2))
1884 /* Don't constant fold this floating point operation if the
1885 result may dependent upon the run-time rounding mode and
1886 flag_rounding_math is set, or if GCC's software emulation
1887 is unable to accurately represent the result. */
1888 if ((flag_rounding_math
1889 || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1890 && (inexact || !real_identical (&result, &value)))
1893 t = build_real (type, result);
1895 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1899 if (TREE_CODE (arg1) == FIXED_CST)
1901 FIXED_VALUE_TYPE f1;
1902 FIXED_VALUE_TYPE f2;
1903 FIXED_VALUE_TYPE result;
1908 /* The following codes are handled by fixed_arithmetic. */
1914 case TRUNC_DIV_EXPR:
1915 f2 = TREE_FIXED_CST (arg2);
1920 f2.data.high = TREE_INT_CST_HIGH (arg2);
1921 f2.data.low = TREE_INT_CST_LOW (arg2);
1929 f1 = TREE_FIXED_CST (arg1);
1930 type = TREE_TYPE (arg1);
1931 sat_p = TYPE_SATURATING (type);
1932 overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1933 t = build_fixed (type, result);
1934 /* Propagate overflow flags. */
1935 if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1936 TREE_OVERFLOW (t) = 1;
1940 if (TREE_CODE (arg1) == COMPLEX_CST)
1942 tree type = TREE_TYPE (arg1);
1943 tree r1 = TREE_REALPART (arg1);
1944 tree i1 = TREE_IMAGPART (arg1);
1945 tree r2 = TREE_REALPART (arg2);
1946 tree i2 = TREE_IMAGPART (arg2);
1953 real = const_binop (code, r1, r2, notrunc);
1954 imag = const_binop (code, i1, i2, notrunc);
1958 real = const_binop (MINUS_EXPR,
1959 const_binop (MULT_EXPR, r1, r2, notrunc),
1960 const_binop (MULT_EXPR, i1, i2, notrunc),
1962 imag = const_binop (PLUS_EXPR,
1963 const_binop (MULT_EXPR, r1, i2, notrunc),
1964 const_binop (MULT_EXPR, i1, r2, notrunc),
1971 = const_binop (PLUS_EXPR,
1972 const_binop (MULT_EXPR, r2, r2, notrunc),
1973 const_binop (MULT_EXPR, i2, i2, notrunc),
1976 = const_binop (PLUS_EXPR,
1977 const_binop (MULT_EXPR, r1, r2, notrunc),
1978 const_binop (MULT_EXPR, i1, i2, notrunc),
1981 = const_binop (MINUS_EXPR,
1982 const_binop (MULT_EXPR, i1, r2, notrunc),
1983 const_binop (MULT_EXPR, r1, i2, notrunc),
1986 if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1987 code = TRUNC_DIV_EXPR;
1989 real = const_binop (code, t1, magsquared, notrunc);
1990 imag = const_binop (code, t2, magsquared, notrunc);
1999 return build_complex (type, real, imag);
2002 if (TREE_CODE (arg1) == VECTOR_CST)
2004 tree type = TREE_TYPE(arg1);
2005 int count = TYPE_VECTOR_SUBPARTS (type), i;
2006 tree elements1, elements2, list = NULL_TREE;
2008 if(TREE_CODE(arg2) != VECTOR_CST)
2011 elements1 = TREE_VECTOR_CST_ELTS (arg1);
2012 elements2 = TREE_VECTOR_CST_ELTS (arg2);
2014 for (i = 0; i < count; i++)
2016 tree elem1, elem2, elem;
2018 /* The trailing elements can be empty and should be treated as 0 */
2020 elem1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2023 elem1 = TREE_VALUE(elements1);
2024 elements1 = TREE_CHAIN (elements1);
2028 elem2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2031 elem2 = TREE_VALUE(elements2);
2032 elements2 = TREE_CHAIN (elements2);
2035 elem = const_binop (code, elem1, elem2, notrunc);
2037 /* It is possible that const_binop cannot handle the given
2038 code and return NULL_TREE */
2039 if(elem == NULL_TREE)
2042 list = tree_cons (NULL_TREE, elem, list);
2044 return build_vector(type, nreverse(list));
2049 /* Create a size type INT_CST node with NUMBER sign extended. KIND
2050 indicates which particular sizetype to create. */
2053 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
2055 return build_int_cst (sizetype_tab[(int) kind], number);
2058 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
2059 is a tree code. The type of the result is taken from the operands.
2060 Both must be equivalent integer types, ala int_binop_types_match_p.
2061 If the operands are constant, so is the result. */
2064 size_binop (enum tree_code code, tree arg0, tree arg1)
2066 tree type = TREE_TYPE (arg0);
2068 if (arg0 == error_mark_node || arg1 == error_mark_node)
2069 return error_mark_node;
2071 gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
2074 /* Handle the special case of two integer constants faster. */
2075 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2077 /* And some specific cases even faster than that. */
2078 if (code == PLUS_EXPR)
2080 if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
2082 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2085 else if (code == MINUS_EXPR)
2087 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2090 else if (code == MULT_EXPR)
2092 if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
2096 /* Handle general case of two integer constants. */
2097 return int_const_binop (code, arg0, arg1, 0);
2100 return fold_build2 (code, type, arg0, arg1);
2103 /* Given two values, either both of sizetype or both of bitsizetype,
2104 compute the difference between the two values. Return the value
2105 in signed type corresponding to the type of the operands. */
2108 size_diffop (tree arg0, tree arg1)
2110 tree type = TREE_TYPE (arg0);
2113 gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
2116 /* If the type is already signed, just do the simple thing. */
2117 if (!TYPE_UNSIGNED (type))
2118 return size_binop (MINUS_EXPR, arg0, arg1);
2120 if (type == sizetype)
2122 else if (type == bitsizetype)
2123 ctype = sbitsizetype;
2125 ctype = signed_type_for (type);
2127 /* If either operand is not a constant, do the conversions to the signed
2128 type and subtract. The hardware will do the right thing with any
2129 overflow in the subtraction. */
2130 if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
2131 return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
2132 fold_convert (ctype, arg1));
2134 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
2135 Otherwise, subtract the other way, convert to CTYPE (we know that can't
2136 overflow) and negate (which can't either). Special-case a result
2137 of zero while we're here. */
2138 if (tree_int_cst_equal (arg0, arg1))
2139 return build_int_cst (ctype, 0);
2140 else if (tree_int_cst_lt (arg1, arg0))
2141 return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
2143 return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
2144 fold_convert (ctype, size_binop (MINUS_EXPR,
2148 /* A subroutine of fold_convert_const handling conversions of an
2149 INTEGER_CST to another integer type. */
2152 fold_convert_const_int_from_int (tree type, const_tree arg1)
2156 /* Given an integer constant, make new constant with new type,
2157 appropriately sign-extended or truncated. */
2158 t = force_fit_type_double (type, TREE_INT_CST_LOW (arg1),
2159 TREE_INT_CST_HIGH (arg1),
2160 /* Don't set the overflow when
2161 converting from a pointer, */
2162 !POINTER_TYPE_P (TREE_TYPE (arg1))
2163 /* or to a sizetype with same signedness
2164 and the precision is unchanged.
2165 ??? sizetype is always sign-extended,
2166 but its signedness depends on the
2167 frontend. Thus we see spurious overflows
2168 here if we do not check this. */
2169 && !((TYPE_PRECISION (TREE_TYPE (arg1))
2170 == TYPE_PRECISION (type))
2171 && (TYPE_UNSIGNED (TREE_TYPE (arg1))
2172 == TYPE_UNSIGNED (type))
2173 && ((TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
2174 && TYPE_IS_SIZETYPE (TREE_TYPE (arg1)))
2175 || (TREE_CODE (type) == INTEGER_TYPE
2176 && TYPE_IS_SIZETYPE (type)))),
2177 (TREE_INT_CST_HIGH (arg1) < 0
2178 && (TYPE_UNSIGNED (type)
2179 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2180 | TREE_OVERFLOW (arg1));
2185 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2186 to an integer type. */
2189 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
2194 /* The following code implements the floating point to integer
2195 conversion rules required by the Java Language Specification,
2196 that IEEE NaNs are mapped to zero and values that overflow
2197 the target precision saturate, i.e. values greater than
2198 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2199 are mapped to INT_MIN. These semantics are allowed by the
2200 C and C++ standards that simply state that the behavior of
2201 FP-to-integer conversion is unspecified upon overflow. */
2203 HOST_WIDE_INT high, low;
2205 REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
2209 case FIX_TRUNC_EXPR:
2210 real_trunc (&r, VOIDmode, &x);
2217 /* If R is NaN, return zero and show we have an overflow. */
2218 if (REAL_VALUE_ISNAN (r))
2225 /* See if R is less than the lower bound or greater than the
2230 tree lt = TYPE_MIN_VALUE (type);
2231 REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
2232 if (REAL_VALUES_LESS (r, l))
2235 high = TREE_INT_CST_HIGH (lt);
2236 low = TREE_INT_CST_LOW (lt);
2242 tree ut = TYPE_MAX_VALUE (type);
2245 REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
2246 if (REAL_VALUES_LESS (u, r))
2249 high = TREE_INT_CST_HIGH (ut);
2250 low = TREE_INT_CST_LOW (ut);
2256 REAL_VALUE_TO_INT (&low, &high, r);
2258 t = force_fit_type_double (type, low, high, -1,
2259 overflow | TREE_OVERFLOW (arg1));
2263 /* A subroutine of fold_convert_const handling conversions of a
2264 FIXED_CST to an integer type. */
2267 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
2270 double_int temp, temp_trunc;
2273 /* Right shift FIXED_CST to temp by fbit. */
2274 temp = TREE_FIXED_CST (arg1).data;
2275 mode = TREE_FIXED_CST (arg1).mode;
2276 if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
2278 lshift_double (temp.low, temp.high,
2279 - GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2280 &temp.low, &temp.high, SIGNED_FIXED_POINT_MODE_P (mode));
2282 /* Left shift temp to temp_trunc by fbit. */
2283 lshift_double (temp.low, temp.high,
2284 GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2285 &temp_trunc.low, &temp_trunc.high,
2286 SIGNED_FIXED_POINT_MODE_P (mode));
2293 temp_trunc.high = 0;
2296 /* If FIXED_CST is negative, we need to round the value toward 0.
2297 By checking if the fractional bits are not zero to add 1 to temp. */
2298 if (SIGNED_FIXED_POINT_MODE_P (mode) && temp_trunc.high < 0
2299 && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
2304 temp = double_int_add (temp, one);
2307 /* Given a fixed-point constant, make new constant with new type,
2308 appropriately sign-extended or truncated. */
2309 t = force_fit_type_double (type, temp.low, temp.high, -1,
2311 && (TYPE_UNSIGNED (type)
2312 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2313 | TREE_OVERFLOW (arg1));
2318 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2319 to another floating point type. */
2322 fold_convert_const_real_from_real (tree type, const_tree arg1)
2324 REAL_VALUE_TYPE value;
2327 real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
2328 t = build_real (type, value);
2330 /* If converting an infinity or NAN to a representation that doesn't
2331 have one, set the overflow bit so that we can produce some kind of
2332 error message at the appropriate point if necessary. It's not the
2333 most user-friendly message, but it's better than nothing. */
2334 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
2335 && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
2336 TREE_OVERFLOW (t) = 1;
2337 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
2338 && !MODE_HAS_NANS (TYPE_MODE (type)))
2339 TREE_OVERFLOW (t) = 1;
2340 /* Regular overflow, conversion produced an infinity in a mode that
2341 can't represent them. */
2342 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
2343 && REAL_VALUE_ISINF (value)
2344 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
2345 TREE_OVERFLOW (t) = 1;
2347 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2351 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2352 to a floating point type. */
2355 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2357 REAL_VALUE_TYPE value;
2360 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2361 t = build_real (type, value);
2363 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2367 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2368 to another fixed-point type. */
2371 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2373 FIXED_VALUE_TYPE value;
2377 overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2378 TYPE_SATURATING (type));
2379 t = build_fixed (type, value);
2381 /* Propagate overflow flags. */
2382 if (overflow_p | TREE_OVERFLOW (arg1))
2383 TREE_OVERFLOW (t) = 1;
2387 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2388 to a fixed-point type. */
2391 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2393 FIXED_VALUE_TYPE value;
2397 overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
2398 TREE_INT_CST (arg1),
2399 TYPE_UNSIGNED (TREE_TYPE (arg1)),
2400 TYPE_SATURATING (type));
2401 t = build_fixed (type, value);
2403 /* Propagate overflow flags. */
2404 if (overflow_p | TREE_OVERFLOW (arg1))
2405 TREE_OVERFLOW (t) = 1;
2409 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2410 to a fixed-point type. */
2413 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2415 FIXED_VALUE_TYPE value;
2419 overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2420 &TREE_REAL_CST (arg1),
2421 TYPE_SATURATING (type));
2422 t = build_fixed (type, value);
2424 /* Propagate overflow flags. */
2425 if (overflow_p | TREE_OVERFLOW (arg1))
2426 TREE_OVERFLOW (t) = 1;
2430 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2431 type TYPE. If no simplification can be done return NULL_TREE. */
2434 fold_convert_const (enum tree_code code, tree type, tree arg1)
2436 if (TREE_TYPE (arg1) == type)
2439 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
2440 || TREE_CODE (type) == OFFSET_TYPE)
2442 if (TREE_CODE (arg1) == INTEGER_CST)
2443 return fold_convert_const_int_from_int (type, arg1);
2444 else if (TREE_CODE (arg1) == REAL_CST)
2445 return fold_convert_const_int_from_real (code, type, arg1);
2446 else if (TREE_CODE (arg1) == FIXED_CST)
2447 return fold_convert_const_int_from_fixed (type, arg1);
2449 else if (TREE_CODE (type) == REAL_TYPE)
2451 if (TREE_CODE (arg1) == INTEGER_CST)
2452 return build_real_from_int_cst (type, arg1);
2453 else if (TREE_CODE (arg1) == REAL_CST)
2454 return fold_convert_const_real_from_real (type, arg1);
2455 else if (TREE_CODE (arg1) == FIXED_CST)
2456 return fold_convert_const_real_from_fixed (type, arg1);
2458 else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2460 if (TREE_CODE (arg1) == FIXED_CST)
2461 return fold_convert_const_fixed_from_fixed (type, arg1);
2462 else if (TREE_CODE (arg1) == INTEGER_CST)
2463 return fold_convert_const_fixed_from_int (type, arg1);
2464 else if (TREE_CODE (arg1) == REAL_CST)
2465 return fold_convert_const_fixed_from_real (type, arg1);
2470 /* Construct a vector of zero elements of vector type TYPE. */
2473 build_zero_vector (tree type)
2478 elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2479 units = TYPE_VECTOR_SUBPARTS (type);
2482 for (i = 0; i < units; i++)
2483 list = tree_cons (NULL_TREE, elem, list);
2484 return build_vector (type, list);
2487 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2490 fold_convertible_p (const_tree type, const_tree arg)
2492 tree orig = TREE_TYPE (arg);
2497 if (TREE_CODE (arg) == ERROR_MARK
2498 || TREE_CODE (type) == ERROR_MARK
2499 || TREE_CODE (orig) == ERROR_MARK)
2502 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2505 switch (TREE_CODE (type))
2507 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2508 case POINTER_TYPE: case REFERENCE_TYPE:
2510 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2511 || TREE_CODE (orig) == OFFSET_TYPE)
2513 return (TREE_CODE (orig) == VECTOR_TYPE
2514 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2517 case FIXED_POINT_TYPE:
2521 return TREE_CODE (type) == TREE_CODE (orig);
2528 /* Convert expression ARG to type TYPE. Used by the middle-end for
2529 simple conversions in preference to calling the front-end's convert. */
2532 fold_convert (tree type, tree arg)
2534 tree orig = TREE_TYPE (arg);
2540 if (TREE_CODE (arg) == ERROR_MARK
2541 || TREE_CODE (type) == ERROR_MARK
2542 || TREE_CODE (orig) == ERROR_MARK)
2543 return error_mark_node;
2545 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2546 return fold_build1 (NOP_EXPR, type, arg);
2548 switch (TREE_CODE (type))
2550 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2551 case POINTER_TYPE: case REFERENCE_TYPE:
2553 if (TREE_CODE (arg) == INTEGER_CST)
2555 tem = fold_convert_const (NOP_EXPR, type, arg);
2556 if (tem != NULL_TREE)
2559 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2560 || TREE_CODE (orig) == OFFSET_TYPE)
2561 return fold_build1 (NOP_EXPR, type, arg);
2562 if (TREE_CODE (orig) == COMPLEX_TYPE)
2564 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2565 return fold_convert (type, tem);
2567 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2568 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2569 return fold_build1 (NOP_EXPR, type, arg);
2572 if (TREE_CODE (arg) == INTEGER_CST)
2574 tem = fold_convert_const (FLOAT_EXPR, type, arg);
2575 if (tem != NULL_TREE)
2578 else if (TREE_CODE (arg) == REAL_CST)
2580 tem = fold_convert_const (NOP_EXPR, type, arg);
2581 if (tem != NULL_TREE)
2584 else if (TREE_CODE (arg) == FIXED_CST)
2586 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2587 if (tem != NULL_TREE)
2591 switch (TREE_CODE (orig))
2594 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2595 case POINTER_TYPE: case REFERENCE_TYPE:
2596 return fold_build1 (FLOAT_EXPR, type, arg);
2599 return fold_build1 (NOP_EXPR, type, arg);
2601 case FIXED_POINT_TYPE:
2602 return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2605 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2606 return fold_convert (type, tem);
2612 case FIXED_POINT_TYPE:
2613 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2614 || TREE_CODE (arg) == REAL_CST)
2616 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2617 if (tem != NULL_TREE)
2621 switch (TREE_CODE (orig))
2623 case FIXED_POINT_TYPE:
2628 return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2631 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2632 return fold_convert (type, tem);
2639 switch (TREE_CODE (orig))
2642 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2643 case POINTER_TYPE: case REFERENCE_TYPE:
2645 case FIXED_POINT_TYPE:
2646 return fold_build2 (COMPLEX_EXPR, type,
2647 fold_convert (TREE_TYPE (type), arg),
2648 fold_convert (TREE_TYPE (type),
2649 integer_zero_node));
2654 if (TREE_CODE (arg) == COMPLEX_EXPR)
2656 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2657 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2658 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2661 arg = save_expr (arg);
2662 rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2663 ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2664 rpart = fold_convert (TREE_TYPE (type), rpart);
2665 ipart = fold_convert (TREE_TYPE (type), ipart);
2666 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2674 if (integer_zerop (arg))
2675 return build_zero_vector (type);
2676 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2677 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2678 || TREE_CODE (orig) == VECTOR_TYPE);
2679 return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2682 tem = fold_ignored_result (arg);
2683 if (TREE_CODE (tem) == MODIFY_EXPR)
2685 return fold_build1 (NOP_EXPR, type, tem);
2692 /* Return false if expr can be assumed not to be an lvalue, true
2696 maybe_lvalue_p (const_tree x)
2698 /* We only need to wrap lvalue tree codes. */
2699 switch (TREE_CODE (x))
2710 case ALIGN_INDIRECT_REF:
2711 case MISALIGNED_INDIRECT_REF:
2713 case ARRAY_RANGE_REF:
2719 case PREINCREMENT_EXPR:
2720 case PREDECREMENT_EXPR:
2722 case TRY_CATCH_EXPR:
2723 case WITH_CLEANUP_EXPR:
2734 /* Assume the worst for front-end tree codes. */
2735 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2743 /* Return an expr equal to X but certainly not valid as an lvalue. */
2748 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2753 if (! maybe_lvalue_p (x))
2755 return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2758 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2759 Zero means allow extended lvalues. */
2761 int pedantic_lvalues;
2763 /* When pedantic, return an expr equal to X but certainly not valid as a
2764 pedantic lvalue. Otherwise, return X. */
2767 pedantic_non_lvalue (tree x)
2769 if (pedantic_lvalues)
2770 return non_lvalue (x);
2775 /* Given a tree comparison code, return the code that is the logical inverse
2776 of the given code. It is not safe to do this for floating-point
2777 comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2778 as well: if reversing the comparison is unsafe, return ERROR_MARK. */
2781 invert_tree_comparison (enum tree_code code, bool honor_nans)
2783 if (honor_nans && flag_trapping_math)
2793 return honor_nans ? UNLE_EXPR : LE_EXPR;
2795 return honor_nans ? UNLT_EXPR : LT_EXPR;
2797 return honor_nans ? UNGE_EXPR : GE_EXPR;
2799 return honor_nans ? UNGT_EXPR : GT_EXPR;
2813 return UNORDERED_EXPR;
2814 case UNORDERED_EXPR:
2815 return ORDERED_EXPR;
2821 /* Similar, but return the comparison that results if the operands are
2822 swapped. This is safe for floating-point. */
2825 swap_tree_comparison (enum tree_code code)
2832 case UNORDERED_EXPR:
2858 /* Convert a comparison tree code from an enum tree_code representation
2859 into a compcode bit-based encoding. This function is the inverse of
2860 compcode_to_comparison. */
2862 static enum comparison_code
2863 comparison_to_compcode (enum tree_code code)
2880 return COMPCODE_ORD;
2881 case UNORDERED_EXPR:
2882 return COMPCODE_UNORD;
2884 return COMPCODE_UNLT;
2886 return COMPCODE_UNEQ;
2888 return COMPCODE_UNLE;
2890 return COMPCODE_UNGT;
2892 return COMPCODE_LTGT;
2894 return COMPCODE_UNGE;
2900 /* Convert a compcode bit-based encoding of a comparison operator back
2901 to GCC's enum tree_code representation. This function is the
2902 inverse of comparison_to_compcode. */
2904 static enum tree_code
2905 compcode_to_comparison (enum comparison_code code)
2922 return ORDERED_EXPR;
2923 case COMPCODE_UNORD:
2924 return UNORDERED_EXPR;
2942 /* Return a tree for the comparison which is the combination of
2943 doing the AND or OR (depending on CODE) of the two operations LCODE
2944 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2945 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2946 if this makes the transformation invalid. */
2949 combine_comparisons (enum tree_code code, enum tree_code lcode,
2950 enum tree_code rcode, tree truth_type,
2951 tree ll_arg, tree lr_arg)
2953 bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2954 enum comparison_code lcompcode = comparison_to_compcode (lcode);
2955 enum comparison_code rcompcode = comparison_to_compcode (rcode);
2960 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2961 compcode = lcompcode & rcompcode;
2964 case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2965 compcode = lcompcode | rcompcode;
2974 /* Eliminate unordered comparisons, as well as LTGT and ORD
2975 which are not used unless the mode has NaNs. */
2976 compcode &= ~COMPCODE_UNORD;
2977 if (compcode == COMPCODE_LTGT)
2978 compcode = COMPCODE_NE;
2979 else if (compcode == COMPCODE_ORD)
2980 compcode = COMPCODE_TRUE;
2982 else if (flag_trapping_math)
2984 /* Check that the original operation and the optimized ones will trap
2985 under the same condition. */
2986 bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2987 && (lcompcode != COMPCODE_EQ)
2988 && (lcompcode != COMPCODE_ORD);
2989 bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2990 && (rcompcode != COMPCODE_EQ)
2991 && (rcompcode != COMPCODE_ORD);
2992 bool trap = (compcode & COMPCODE_UNORD) == 0
2993 && (compcode != COMPCODE_EQ)
2994 && (compcode != COMPCODE_ORD);
2996 /* In a short-circuited boolean expression the LHS might be
2997 such that the RHS, if evaluated, will never trap. For
2998 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2999 if neither x nor y is NaN. (This is a mixed blessing: for
3000 example, the expression above will never trap, hence
3001 optimizing it to x < y would be invalid). */
3002 if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
3003 || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
3006 /* If the comparison was short-circuited, and only the RHS
3007 trapped, we may now generate a spurious trap. */
3009 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3012 /* If we changed the conditions that cause a trap, we lose. */
3013 if ((ltrap || rtrap) != trap)
3017 if (compcode == COMPCODE_TRUE)
3018 return constant_boolean_node (true, truth_type);
3019 else if (compcode == COMPCODE_FALSE)
3020 return constant_boolean_node (false, truth_type);
3023 enum tree_code tcode;
3025 tcode = compcode_to_comparison ((enum comparison_code) compcode);
3026 return fold_build2 (tcode, truth_type, ll_arg, lr_arg);
3030 /* Return nonzero if two operands (typically of the same tree node)
3031 are necessarily equal. If either argument has side-effects this
3032 function returns zero. FLAGS modifies behavior as follows:
3034 If OEP_ONLY_CONST is set, only return nonzero for constants.
3035 This function tests whether the operands are indistinguishable;
3036 it does not test whether they are equal using C's == operation.
3037 The distinction is important for IEEE floating point, because
3038 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
3039 (2) two NaNs may be indistinguishable, but NaN!=NaN.
3041 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
3042 even though it may hold multiple values during a function.
3043 This is because a GCC tree node guarantees that nothing else is
3044 executed between the evaluation of its "operands" (which may often
3045 be evaluated in arbitrary order). Hence if the operands themselves
3046 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
3047 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
3048 unset means assuming isochronic (or instantaneous) tree equivalence.
3049 Unless comparing arbitrary expression trees, such as from different
3050 statements, this flag can usually be left unset.
3052 If OEP_PURE_SAME is set, then pure functions with identical arguments
3053 are considered the same. It is used when the caller has other ways
3054 to ensure that global memory is unchanged in between. */
3057 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
3059 /* If either is ERROR_MARK, they aren't equal. */
3060 if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
3063 /* Check equality of integer constants before bailing out due to
3064 precision differences. */
3065 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
3066 return tree_int_cst_equal (arg0, arg1);
3068 /* If both types don't have the same signedness, then we can't consider
3069 them equal. We must check this before the STRIP_NOPS calls
3070 because they may change the signedness of the arguments. As pointers
3071 strictly don't have a signedness, require either two pointers or
3072 two non-pointers as well. */
3073 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
3074 || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
3077 /* If both types don't have the same precision, then it is not safe
3079 if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
3085 /* In case both args are comparisons but with different comparison
3086 code, try to swap the comparison operands of one arg to produce
3087 a match and compare that variant. */
3088 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3089 && COMPARISON_CLASS_P (arg0)
3090 && COMPARISON_CLASS_P (arg1))
3092 enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
3094 if (TREE_CODE (arg0) == swap_code)
3095 return operand_equal_p (TREE_OPERAND (arg0, 0),
3096 TREE_OPERAND (arg1, 1), flags)
3097 && operand_equal_p (TREE_OPERAND (arg0, 1),
3098 TREE_OPERAND (arg1, 0), flags);
3101 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3102 /* This is needed for conversions and for COMPONENT_REF.
3103 Might as well play it safe and always test this. */
3104 || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
3105 || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
3106 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
3109 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3110 We don't care about side effects in that case because the SAVE_EXPR
3111 takes care of that for us. In all other cases, two expressions are
3112 equal if they have no side effects. If we have two identical
3113 expressions with side effects that should be treated the same due
3114 to the only side effects being identical SAVE_EXPR's, that will
3115 be detected in the recursive calls below. */
3116 if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
3117 && (TREE_CODE (arg0) == SAVE_EXPR
3118 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
3121 /* Next handle constant cases, those for which we can return 1 even
3122 if ONLY_CONST is set. */
3123 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
3124 switch (TREE_CODE (arg0))
3127 return tree_int_cst_equal (arg0, arg1);
3130 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
3131 TREE_FIXED_CST (arg1));
3134 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
3135 TREE_REAL_CST (arg1)))
3139 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
3141 /* If we do not distinguish between signed and unsigned zero,
3142 consider them equal. */
3143 if (real_zerop (arg0) && real_zerop (arg1))
3152 v1 = TREE_VECTOR_CST_ELTS (arg0);
3153 v2 = TREE_VECTOR_CST_ELTS (arg1);
3156 if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
3159 v1 = TREE_CHAIN (v1);
3160 v2 = TREE_CHAIN (v2);
3167 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
3169 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
3173 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
3174 && ! memcmp (TREE_STRING_POINTER (arg0),
3175 TREE_STRING_POINTER (arg1),
3176 TREE_STRING_LENGTH (arg0)));
3179 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
3185 if (flags & OEP_ONLY_CONST)
3188 /* Define macros to test an operand from arg0 and arg1 for equality and a
3189 variant that allows null and views null as being different from any
3190 non-null value. In the latter case, if either is null, the both
3191 must be; otherwise, do the normal comparison. */
3192 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3193 TREE_OPERAND (arg1, N), flags)
3195 #define OP_SAME_WITH_NULL(N) \
3196 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3197 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3199 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
3202 /* Two conversions are equal only if signedness and modes match. */
3203 switch (TREE_CODE (arg0))
3206 case FIX_TRUNC_EXPR:
3207 if (TYPE_UNSIGNED (TREE_TYPE (arg0))
3208 != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3218 case tcc_comparison:
3220 if (OP_SAME (0) && OP_SAME (1))
3223 /* For commutative ops, allow the other order. */
3224 return (commutative_tree_code (TREE_CODE (arg0))
3225 && operand_equal_p (TREE_OPERAND (arg0, 0),
3226 TREE_OPERAND (arg1, 1), flags)
3227 && operand_equal_p (TREE_OPERAND (arg0, 1),
3228 TREE_OPERAND (arg1, 0), flags));
3231 /* If either of the pointer (or reference) expressions we are
3232 dereferencing contain a side effect, these cannot be equal. */
3233 if (TREE_SIDE_EFFECTS (arg0)
3234 || TREE_SIDE_EFFECTS (arg1))
3237 switch (TREE_CODE (arg0))
3240 case ALIGN_INDIRECT_REF:
3241 case MISALIGNED_INDIRECT_REF:
3247 case ARRAY_RANGE_REF:
3248 /* Operands 2 and 3 may be null.
3249 Compare the array index by value if it is constant first as we
3250 may have different types but same value here. */
3252 && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3253 TREE_OPERAND (arg1, 1))
3255 && OP_SAME_WITH_NULL (2)
3256 && OP_SAME_WITH_NULL (3));
3259 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3260 may be NULL when we're called to compare MEM_EXPRs. */
3261 return OP_SAME_WITH_NULL (0)
3263 && OP_SAME_WITH_NULL (2);
3266 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3272 case tcc_expression:
3273 switch (TREE_CODE (arg0))
3276 case TRUTH_NOT_EXPR:
3279 case TRUTH_ANDIF_EXPR:
3280 case TRUTH_ORIF_EXPR:
3281 return OP_SAME (0) && OP_SAME (1);
3283 case TRUTH_AND_EXPR:
3285 case TRUTH_XOR_EXPR:
3286 if (OP_SAME (0) && OP_SAME (1))
3289 /* Otherwise take into account this is a commutative operation. */
3290 return (operand_equal_p (TREE_OPERAND (arg0, 0),
3291 TREE_OPERAND (arg1, 1), flags)
3292 && operand_equal_p (TREE_OPERAND (arg0, 1),
3293 TREE_OPERAND (arg1, 0), flags));
3296 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3303 switch (TREE_CODE (arg0))
3306 /* If the CALL_EXPRs call different functions, then they
3307 clearly can not be equal. */
3308 if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3313 unsigned int cef = call_expr_flags (arg0);
3314 if (flags & OEP_PURE_SAME)
3315 cef &= ECF_CONST | ECF_PURE;
3322 /* Now see if all the arguments are the same. */
3324 const_call_expr_arg_iterator iter0, iter1;
3326 for (a0 = first_const_call_expr_arg (arg0, &iter0),
3327 a1 = first_const_call_expr_arg (arg1, &iter1);
3329 a0 = next_const_call_expr_arg (&iter0),
3330 a1 = next_const_call_expr_arg (&iter1))
3331 if (! operand_equal_p (a0, a1, flags))
3334 /* If we get here and both argument lists are exhausted
3335 then the CALL_EXPRs are equal. */
3336 return ! (a0 || a1);
3342 case tcc_declaration:
3343 /* Consider __builtin_sqrt equal to sqrt. */
3344 return (TREE_CODE (arg0) == FUNCTION_DECL
3345 && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3346 && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3347 && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3354 #undef OP_SAME_WITH_NULL
3357 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3358 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3360 When in doubt, return 0. */
3363 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3365 int unsignedp1, unsignedpo;
3366 tree primarg0, primarg1, primother;
3367 unsigned int correct_width;
3369 if (operand_equal_p (arg0, arg1, 0))
3372 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3373 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3376 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3377 and see if the inner values are the same. This removes any
3378 signedness comparison, which doesn't matter here. */
3379 primarg0 = arg0, primarg1 = arg1;
3380 STRIP_NOPS (primarg0);
3381 STRIP_NOPS (primarg1);
3382 if (operand_equal_p (primarg0, primarg1, 0))
3385 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3386 actual comparison operand, ARG0.
3388 First throw away any conversions to wider types
3389 already present in the operands. */
3391 primarg1 = get_narrower (arg1, &unsignedp1);
3392 primother = get_narrower (other, &unsignedpo);
3394 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3395 if (unsignedp1 == unsignedpo
3396 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3397 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3399 tree type = TREE_TYPE (arg0);
3401 /* Make sure shorter operand is extended the right way
3402 to match the longer operand. */
3403 primarg1 = fold_convert (signed_or_unsigned_type_for
3404 (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3406 if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3413 /* See if ARG is an expression that is either a comparison or is performing
3414 arithmetic on comparisons. The comparisons must only be comparing
3415 two different values, which will be stored in *CVAL1 and *CVAL2; if
3416 they are nonzero it means that some operands have already been found.
3417 No variables may be used anywhere else in the expression except in the
3418 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3419 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3421 If this is true, return 1. Otherwise, return zero. */
3424 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3426 enum tree_code code = TREE_CODE (arg);
3427 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3429 /* We can handle some of the tcc_expression cases here. */
3430 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3432 else if (tclass == tcc_expression
3433 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3434 || code == COMPOUND_EXPR))
3435 tclass = tcc_binary;
3437 else if (tclass == tcc_expression && code == SAVE_EXPR
3438 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3440 /* If we've already found a CVAL1 or CVAL2, this expression is
3441 two complex to handle. */
3442 if (*cval1 || *cval2)
3452 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3455 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3456 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3457 cval1, cval2, save_p));
3462 case tcc_expression:
3463 if (code == COND_EXPR)
3464 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3465 cval1, cval2, save_p)
3466 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3467 cval1, cval2, save_p)
3468 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3469 cval1, cval2, save_p));
3472 case tcc_comparison:
3473 /* First see if we can handle the first operand, then the second. For
3474 the second operand, we know *CVAL1 can't be zero. It must be that
3475 one side of the comparison is each of the values; test for the
3476 case where this isn't true by failing if the two operands
3479 if (operand_equal_p (TREE_OPERAND (arg, 0),
3480 TREE_OPERAND (arg, 1), 0))
3484 *cval1 = TREE_OPERAND (arg, 0);
3485 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3487 else if (*cval2 == 0)
3488 *cval2 = TREE_OPERAND (arg, 0);
3489 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3494 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3496 else if (*cval2 == 0)
3497 *cval2 = TREE_OPERAND (arg, 1);
3498 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3510 /* ARG is a tree that is known to contain just arithmetic operations and
3511 comparisons. Evaluate the operations in the tree substituting NEW0 for
3512 any occurrence of OLD0 as an operand of a comparison and likewise for
3516 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3518 tree type = TREE_TYPE (arg);
3519 enum tree_code code = TREE_CODE (arg);
3520 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3522 /* We can handle some of the tcc_expression cases here. */
3523 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3525 else if (tclass == tcc_expression
3526 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3527 tclass = tcc_binary;
3532 return fold_build1 (code, type,
3533 eval_subst (TREE_OPERAND (arg, 0),
3534 old0, new0, old1, new1));
3537 return fold_build2 (code, type,
3538 eval_subst (TREE_OPERAND (arg, 0),
3539 old0, new0, old1, new1),
3540 eval_subst (TREE_OPERAND (arg, 1),
3541 old0, new0, old1, new1));
3543 case tcc_expression:
3547 return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3550 return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3553 return fold_build3 (code, type,
3554 eval_subst (TREE_OPERAND (arg, 0),
3555 old0, new0, old1, new1),
3556 eval_subst (TREE_OPERAND (arg, 1),
3557 old0, new0, old1, new1),
3558 eval_subst (TREE_OPERAND (arg, 2),
3559 old0, new0, old1, new1));
3563 /* Fall through - ??? */
3565 case tcc_comparison:
3567 tree arg0 = TREE_OPERAND (arg, 0);
3568 tree arg1 = TREE_OPERAND (arg, 1);
3570 /* We need to check both for exact equality and tree equality. The
3571 former will be true if the operand has a side-effect. In that
3572 case, we know the operand occurred exactly once. */
3574 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3576 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3579 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3581 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3584 return fold_build2 (code, type, arg0, arg1);
3592 /* Return a tree for the case when the result of an expression is RESULT
3593 converted to TYPE and OMITTED was previously an operand of the expression
3594 but is now not needed (e.g., we folded OMITTED * 0).
3596 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3597 the conversion of RESULT to TYPE. */
3600 omit_one_operand (tree type, tree result, tree omitted)
3602 tree t = fold_convert (type, result);
3604 /* If the resulting operand is an empty statement, just return the omitted
3605 statement casted to void. */
3606 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3607 return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3609 if (TREE_SIDE_EFFECTS (omitted))
3610 return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3612 return non_lvalue (t);
3615 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
3618 pedantic_omit_one_operand (tree type, tree result, tree omitted)
3620 tree t = fold_convert (type, result);
3622 /* If the resulting operand is an empty statement, just return the omitted
3623 statement casted to void. */
3624 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3625 return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3627 if (TREE_SIDE_EFFECTS (omitted))
3628 return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3630 return pedantic_non_lvalue (t);
3633 /* Return a tree for the case when the result of an expression is RESULT
3634 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3635 of the expression but are now not needed.
3637 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3638 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3639 evaluated before OMITTED2. Otherwise, if neither has side effects,
3640 just do the conversion of RESULT to TYPE. */
3643 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3645 tree t = fold_convert (type, result);
3647 if (TREE_SIDE_EFFECTS (omitted2))
3648 t = build2 (COMPOUND_EXPR, type, omitted2, t);
3649 if (TREE_SIDE_EFFECTS (omitted1))
3650 t = build2 (COMPOUND_EXPR, type, omitted1, t);
3652 return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3656 /* Return a simplified tree node for the truth-negation of ARG. This
3657 never alters ARG itself. We assume that ARG is an operation that
3658 returns a truth value (0 or 1).
3660 FIXME: one would think we would fold the result, but it causes
3661 problems with the dominator optimizer. */
3664 fold_truth_not_expr (tree arg)
3666 tree t, type = TREE_TYPE (arg);
3667 enum tree_code code = TREE_CODE (arg);
3669 /* If this is a comparison, we can simply invert it, except for
3670 floating-point non-equality comparisons, in which case we just
3671 enclose a TRUTH_NOT_EXPR around what we have. */
3673 if (TREE_CODE_CLASS (code) == tcc_comparison)
3675 tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3676 if (FLOAT_TYPE_P (op_type)
3677 && flag_trapping_math
3678 && code != ORDERED_EXPR && code != UNORDERED_EXPR
3679 && code != NE_EXPR && code != EQ_EXPR)
3682 code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3683 if (code == ERROR_MARK)
3686 t = build2 (code, type, TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3687 if (EXPR_HAS_LOCATION (arg))
3688 SET_EXPR_LOCATION (t, EXPR_LOCATION (arg));
3695 return constant_boolean_node (integer_zerop (arg), type);
3697 case TRUTH_AND_EXPR:
3698 t = build2 (TRUTH_OR_EXPR, type,
3699 invert_truthvalue (TREE_OPERAND (arg, 0)),
3700 invert_truthvalue (TREE_OPERAND (arg, 1)));
3704 t = build2 (TRUTH_AND_EXPR, type,
3705 invert_truthvalue (TREE_OPERAND (arg, 0)),
3706 invert_truthvalue (TREE_OPERAND (arg, 1)));
3709 case TRUTH_XOR_EXPR:
3710 /* Here we can invert either operand. We invert the first operand
3711 unless the second operand is a TRUTH_NOT_EXPR in which case our
3712 result is the XOR of the first operand with the inside of the
3713 negation of the second operand. */
3715 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3716 t = build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3717 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3719 t = build2 (TRUTH_XOR_EXPR, type,
3720 invert_truthvalue (TREE_OPERAND (arg, 0)),
3721 TREE_OPERAND (arg, 1));
3724 case TRUTH_ANDIF_EXPR:
3725 t = build2 (TRUTH_ORIF_EXPR, type,
3726 invert_truthvalue (TREE_OPERAND (arg, 0)),
3727 invert_truthvalue (TREE_OPERAND (arg, 1)));
3730 case TRUTH_ORIF_EXPR:
3731 t = build2 (TRUTH_ANDIF_EXPR, type,
3732 invert_truthvalue (TREE_OPERAND (arg, 0)),
3733 invert_truthvalue (TREE_OPERAND (arg, 1)));
3736 case TRUTH_NOT_EXPR:
3737 return TREE_OPERAND (arg, 0);
3741 tree arg1 = TREE_OPERAND (arg, 1);
3742 tree arg2 = TREE_OPERAND (arg, 2);
3743 /* A COND_EXPR may have a throw as one operand, which
3744 then has void type. Just leave void operands
3746 t = build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3747 VOID_TYPE_P (TREE_TYPE (arg1))
3748 ? arg1 : invert_truthvalue (arg1),
3749 VOID_TYPE_P (TREE_TYPE (arg2))
3750 ? arg2 : invert_truthvalue (arg2));
3755 t = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3756 invert_truthvalue (TREE_OPERAND (arg, 1)));
3759 case NON_LVALUE_EXPR:
3760 return invert_truthvalue (TREE_OPERAND (arg, 0));
3763 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3765 t = build1 (TRUTH_NOT_EXPR, type, arg);
3769 /* ... fall through ... */
3772 t = build1 (TREE_CODE (arg), type,
3773 invert_truthvalue (TREE_OPERAND (arg, 0)));
3777 if (!integer_onep (TREE_OPERAND (arg, 1)))
3779 t = build2 (EQ_EXPR, type, arg, build_int_cst (type, 0));
3783 t = build1 (TRUTH_NOT_EXPR, type, arg);
3786 case CLEANUP_POINT_EXPR:
3787 t = build1 (CLEANUP_POINT_EXPR, type,
3788 invert_truthvalue (TREE_OPERAND (arg, 0)));
3796 if (t && EXPR_HAS_LOCATION (arg))
3797 SET_EXPR_LOCATION (t, EXPR_LOCATION (arg));
3802 /* Return a simplified tree node for the truth-negation of ARG. This
3803 never alters ARG itself. We assume that ARG is an operation that
3804 returns a truth value (0 or 1).
3806 FIXME: one would think we would fold the result, but it causes
3807 problems with the dominator optimizer. */
3810 invert_truthvalue (tree arg)
3814 if (TREE_CODE (arg) == ERROR_MARK)
3817 tem = fold_truth_not_expr (arg);
3819 tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3824 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3825 operands are another bit-wise operation with a common input. If so,
3826 distribute the bit operations to save an operation and possibly two if
3827 constants are involved. For example, convert
3828 (A | B) & (A | C) into A | (B & C)
3829 Further simplification will occur if B and C are constants.
3831 If this optimization cannot be done, 0 will be returned. */
3834 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3839 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3840 || TREE_CODE (arg0) == code
3841 || (TREE_CODE (arg0) != BIT_AND_EXPR
3842 && TREE_CODE (arg0) != BIT_IOR_EXPR))
3845 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3847 common = TREE_OPERAND (arg0, 0);
3848 left = TREE_OPERAND (arg0, 1);
3849 right = TREE_OPERAND (arg1, 1);
3851 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3853 common = TREE_OPERAND (arg0, 0);
3854 left = TREE_OPERAND (arg0, 1);
3855 right = TREE_OPERAND (arg1, 0);
3857 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3859 common = TREE_OPERAND (arg0, 1);
3860 left = TREE_OPERAND (arg0, 0);
3861 right = TREE_OPERAND (arg1, 1);
3863 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3865 common = TREE_OPERAND (arg0, 1);
3866 left = TREE_OPERAND (arg0, 0);
3867 right = TREE_OPERAND (arg1, 0);
3872 common = fold_convert (type, common);
3873 left = fold_convert (type, left);
3874 right = fold_convert (type, right);
3875 return fold_build2 (TREE_CODE (arg0), type, common,
3876 fold_build2 (code, type, left, right));
3879 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3880 with code CODE. This optimization is unsafe. */
3882 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3884 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3885 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3887 /* (A / C) +- (B / C) -> (A +- B) / C. */
3889 && operand_equal_p (TREE_OPERAND (arg0, 1),
3890 TREE_OPERAND (arg1, 1), 0))
3891 return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3892 fold_build2 (code, type,
3893 TREE_OPERAND (arg0, 0),
3894 TREE_OPERAND (arg1, 0)),
3895 TREE_OPERAND (arg0, 1));
3897 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3898 if (operand_equal_p (TREE_OPERAND (arg0, 0),
3899 TREE_OPERAND (arg1, 0), 0)
3900 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3901 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3903 REAL_VALUE_TYPE r0, r1;
3904 r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3905 r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3907 real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3909 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3910 real_arithmetic (&r0, code, &r0, &r1);
3911 return fold_build2 (MULT_EXPR, type,
3912 TREE_OPERAND (arg0, 0),
3913 build_real (type, r0));
3919 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3920 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3923 make_bit_field_ref (tree inner, tree type, HOST_WIDE_INT bitsize,
3924 HOST_WIDE_INT bitpos, int unsignedp)
3926 tree result, bftype;
3930 tree size = TYPE_SIZE (TREE_TYPE (inner));
3931 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3932 || POINTER_TYPE_P (TREE_TYPE (inner)))
3933 && host_integerp (size, 0)
3934 && tree_low_cst (size, 0) == bitsize)
3935 return fold_convert (type, inner);
3939 if (TYPE_PRECISION (bftype) != bitsize
3940 || TYPE_UNSIGNED (bftype) == !unsignedp)
3941 bftype = build_nonstandard_integer_type (bitsize, 0);
3943 result = build3 (BIT_FIELD_REF, bftype, inner,
3944 size_int (bitsize), bitsize_int (bitpos));
3947 result = fold_convert (type, result);
3952 /* Optimize a bit-field compare.
3954 There are two cases: First is a compare against a constant and the
3955 second is a comparison of two items where the fields are at the same
3956 bit position relative to the start of a chunk (byte, halfword, word)
3957 large enough to contain it. In these cases we can avoid the shift
3958 implicit in bitfield extractions.
3960 For constants, we emit a compare of the shifted constant with the
3961 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3962 compared. For two fields at the same position, we do the ANDs with the
3963 similar mask and compare the result of the ANDs.
3965 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3966 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3967 are the left and right operands of the comparison, respectively.
3969 If the optimization described above can be done, we return the resulting
3970 tree. Otherwise we return zero. */
3973 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3976 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3977 tree type = TREE_TYPE (lhs);
3978 tree signed_type, unsigned_type;
3979 int const_p = TREE_CODE (rhs) == INTEGER_CST;
3980 enum machine_mode lmode, rmode, nmode;
3981 int lunsignedp, runsignedp;
3982 int lvolatilep = 0, rvolatilep = 0;
3983 tree linner, rinner = NULL_TREE;
3987 /* Get all the information about the extractions being done. If the bit size
3988 if the same as the size of the underlying object, we aren't doing an
3989 extraction at all and so can do nothing. We also don't want to
3990 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3991 then will no longer be able to replace it. */
3992 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3993 &lunsignedp, &lvolatilep, false);
3994 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3995 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
4000 /* If this is not a constant, we can only do something if bit positions,
4001 sizes, and signedness are the same. */
4002 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
4003 &runsignedp, &rvolatilep, false);
4005 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
4006 || lunsignedp != runsignedp || offset != 0
4007 || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
4011 /* See if we can find a mode to refer to this field. We should be able to,
4012 but fail if we can't. */
4013 nmode = get_best_mode (lbitsize, lbitpos,
4014 const_p ? TYPE_ALIGN (TREE_TYPE (linner))
4015 : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
4016 TYPE_ALIGN (TREE_TYPE (rinner))),
4017 word_mode, lvolatilep || rvolatilep);
4018 if (nmode == VOIDmode)
4021 /* Set signed and unsigned types of the precision of this mode for the
4023 signed_type = lang_hooks.types.type_for_mode (nmode, 0);
4024 unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
4026 /* Compute the bit position and size for the new reference and our offset
4027 within it. If the new reference is the same size as the original, we
4028 won't optimize anything, so return zero. */
4029 nbitsize = GET_MODE_BITSIZE (nmode);
4030 nbitpos = lbitpos & ~ (nbitsize - 1);
4032 if (nbitsize == lbitsize)
4035 if (BYTES_BIG_ENDIAN)
4036 lbitpos = nbitsize - lbitsize - lbitpos;
4038 /* Make the mask to be used against the extracted field. */
4039 mask = build_int_cst_type (unsigned_type, -1);
4040 mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
4041 mask = const_binop (RSHIFT_EXPR, mask,
4042 size_int (nbitsize - lbitsize - lbitpos), 0);
4045 /* If not comparing with constant, just rework the comparison
4047 return fold_build2 (code, compare_type,
4048 fold_build2 (BIT_AND_EXPR, unsigned_type,
4049 make_bit_field_ref (linner,
4054 fold_build2 (BIT_AND_EXPR, unsigned_type,
4055 make_bit_field_ref (rinner,
4061 /* Otherwise, we are handling the constant case. See if the constant is too
4062 big for the field. Warn and return a tree of for 0 (false) if so. We do
4063 this not only for its own sake, but to avoid having to test for this
4064 error case below. If we didn't, we might generate wrong code.
4066 For unsigned fields, the constant shifted right by the field length should
4067 be all zero. For signed fields, the high-order bits should agree with
4072 if (! integer_zerop (const_binop (RSHIFT_EXPR,
4073 fold_convert (unsigned_type, rhs),
4074 size_int (lbitsize), 0)))
4076 warning (0, "comparison is always %d due to width of bit-field",
4078 return constant_boolean_node (code == NE_EXPR, compare_type);
4083 tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
4084 size_int (lbitsize - 1), 0);
4085 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
4087 warning (0, "comparison is always %d due to width of bit-field",
4089 return constant_boolean_node (code == NE_EXPR, compare_type);
4093 /* Single-bit compares should always be against zero. */
4094 if (lbitsize == 1 && ! integer_zerop (rhs))
4096 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
4097 rhs = build_int_cst (type, 0);
4100 /* Make a new bitfield reference, shift the constant over the
4101 appropriate number of bits and mask it with the computed mask
4102 (in case this was a signed field). If we changed it, make a new one. */
4103 lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
4106 TREE_SIDE_EFFECTS (lhs) = 1;
4107 TREE_THIS_VOLATILE (lhs) = 1;
4110 rhs = const_binop (BIT_AND_EXPR,
4111 const_binop (LSHIFT_EXPR,
4112 fold_convert (unsigned_type, rhs),
4113 size_int (lbitpos), 0),
4116 return build2 (code, compare_type,
4117 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
4121 /* Subroutine for fold_truthop: decode a field reference.
4123 If EXP is a comparison reference, we return the innermost reference.
4125 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4126 set to the starting bit number.
4128 If the innermost field can be completely contained in a mode-sized
4129 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4131 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4132 otherwise it is not changed.
4134 *PUNSIGNEDP is set to the signedness of the field.
4136 *PMASK is set to the mask used. This is either contained in a
4137 BIT_AND_EXPR or derived from the width of the field.
4139 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4141 Return 0 if this is not a component reference or is one that we can't
4142 do anything with. */
4145 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
4146 HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
4147 int *punsignedp, int *pvolatilep,
4148 tree *pmask, tree *pand_mask)
4150 tree outer_type = 0;
4152 tree mask, inner, offset;
4154 unsigned int precision;
4156 /* All the optimizations using this function assume integer fields.
4157 There are problems with FP fields since the type_for_size call
4158 below can fail for, e.g., XFmode. */
4159 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
4162 /* We are interested in the bare arrangement of bits, so strip everything
4163 that doesn't affect the machine mode. However, record the type of the
4164 outermost expression if it may matter below. */
4165 if (CONVERT_EXPR_P (exp)
4166 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4167 outer_type = TREE_TYPE (exp);
4170 if (TREE_CODE (exp) == BIT_AND_EXPR)
4172 and_mask = TREE_OPERAND (exp, 1);
4173 exp = TREE_OPERAND (exp, 0);
4174 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
4175 if (TREE_CODE (and_mask) != INTEGER_CST)
4179 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
4180 punsignedp, pvolatilep, false);
4181 if ((inner == exp && and_mask == 0)
4182 || *pbitsize < 0 || offset != 0
4183 || TREE_CODE (inner) == PLACEHOLDER_EXPR)
4186 /* If the number of bits in the reference is the same as the bitsize of
4187 the outer type, then the outer type gives the signedness. Otherwise
4188 (in case of a small bitfield) the signedness is unchanged. */
4189 if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
4190 *punsignedp = TYPE_UNSIGNED (outer_type);
4192 /* Compute the mask to access the bitfield. */
4193 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
4194 precision = TYPE_PRECISION (unsigned_type);
4196 mask = build_int_cst_type (unsigned_type, -1);
4198 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4199 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4201 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4203 mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
4204 fold_convert (unsigned_type, and_mask), mask);
4207 *pand_mask = and_mask;
4211 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4215 all_ones_mask_p (const_tree mask, int size)
4217 tree type = TREE_TYPE (mask);
4218 unsigned int precision = TYPE_PRECISION (type);
4221 tmask = build_int_cst_type (signed_type_for (type), -1);
4224 tree_int_cst_equal (mask,
4225 const_binop (RSHIFT_EXPR,
4226 const_binop (LSHIFT_EXPR, tmask,
4227 size_int (precision - size),
4229 size_int (precision - size), 0));
4232 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4233 represents the sign bit of EXP's type. If EXP represents a sign
4234 or zero extension, also test VAL against the unextended type.
4235 The return value is the (sub)expression whose sign bit is VAL,
4236 or NULL_TREE otherwise. */
4239 sign_bit_p (tree exp, const_tree val)
4241 unsigned HOST_WIDE_INT mask_lo, lo;
4242 HOST_WIDE_INT mask_hi, hi;
4246 /* Tree EXP must have an integral type. */
4247 t = TREE_TYPE (exp);
4248 if (! INTEGRAL_TYPE_P (t))
4251 /* Tree VAL must be an integer constant. */
4252 if (TREE_CODE (val) != INTEGER_CST
4253 || TREE_OVERFLOW (val))
4256 width = TYPE_PRECISION (t);
4257 if (width > HOST_BITS_PER_WIDE_INT)
4259 hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
4262 mask_hi = ((unsigned HOST_WIDE_INT) -1
4263 >> (2 * HOST_BITS_PER_WIDE_INT - width));
4269 lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
4272 mask_lo = ((unsigned HOST_WIDE_INT) -1
4273 >> (HOST_BITS_PER_WIDE_INT - width));
4276 /* We mask off those bits beyond TREE_TYPE (exp) so that we can
4277 treat VAL as if it were unsigned. */
4278 if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
4279 && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
4282 /* Handle extension from a narrower type. */
4283 if (TREE_CODE (exp) == NOP_EXPR
4284 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
4285 return sign_bit_p (TREE_OPERAND (exp, 0), val);
4290 /* Subroutine for fold_truthop: determine if an operand is simple enough
4291 to be evaluated unconditionally. */
4294 simple_operand_p (const_tree exp)
4296 /* Strip any conversions that don't change the machine mode. */
4299 return (CONSTANT_CLASS_P (exp)
4300 || TREE_CODE (exp) == SSA_NAME
4302 && ! TREE_ADDRESSABLE (exp)
4303 && ! TREE_THIS_VOLATILE (exp)
4304 && ! DECL_NONLOCAL (exp)
4305 /* Don't regard global variables as simple. They may be
4306 allocated in ways unknown to the compiler (shared memory,
4307 #pragma weak, etc). */
4308 && ! TREE_PUBLIC (exp)
4309 && ! DECL_EXTERNAL (exp)
4310 /* Loading a static variable is unduly expensive, but global
4311 registers aren't expensive. */
4312 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
4315 /* The following functions are subroutines to fold_range_test and allow it to
4316 try to change a logical combination of comparisons into a range test.
4319 X == 2 || X == 3 || X == 4 || X == 5
4323 (unsigned) (X - 2) <= 3
4325 We describe each set of comparisons as being either inside or outside
4326 a range, using a variable named like IN_P, and then describe the
4327 range with a lower and upper bound. If one of the bounds is omitted,
4328 it represents either the highest or lowest value of the type.
4330 In the comments below, we represent a range by two numbers in brackets
4331 preceded by a "+" to designate being inside that range, or a "-" to
4332 designate being outside that range, so the condition can be inverted by
4333 flipping the prefix. An omitted bound is represented by a "-". For
4334 example, "- [-, 10]" means being outside the range starting at the lowest
4335 possible value and ending at 10, in other words, being greater than 10.
4336 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4339 We set up things so that the missing bounds are handled in a consistent
4340 manner so neither a missing bound nor "true" and "false" need to be
4341 handled using a special case. */
4343 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4344 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4345 and UPPER1_P are nonzero if the respective argument is an upper bound
4346 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4347 must be specified for a comparison. ARG1 will be converted to ARG0's
4348 type if both are specified. */
4351 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4352 tree arg1, int upper1_p)
4358 /* If neither arg represents infinity, do the normal operation.
4359 Else, if not a comparison, return infinity. Else handle the special
4360 comparison rules. Note that most of the cases below won't occur, but
4361 are handled for consistency. */
4363 if (arg0 != 0 && arg1 != 0)
4365 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4366 arg0, fold_convert (TREE_TYPE (arg0), arg1));
4368 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4371 if (TREE_CODE_CLASS (code) != tcc_comparison)
4374 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4375 for neither. In real maths, we cannot assume open ended ranges are
4376 the same. But, this is computer arithmetic, where numbers are finite.
4377 We can therefore make the transformation of any unbounded range with
4378 the value Z, Z being greater than any representable number. This permits
4379 us to treat unbounded ranges as equal. */
4380 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4381 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4385 result = sgn0 == sgn1;
4388 result = sgn0 != sgn1;
4391 result = sgn0 < sgn1;
4394 result = sgn0 <= sgn1;
4397 result = sgn0 > sgn1;
4400 result = sgn0 >= sgn1;
4406 return constant_boolean_node (result, type);
4409 /* Given EXP, a logical expression, set the range it is testing into
4410 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4411 actually being tested. *PLOW and *PHIGH will be made of the same
4412 type as the returned expression. If EXP is not a comparison, we
4413 will most likely not be returning a useful value and range. Set
4414 *STRICT_OVERFLOW_P to true if the return value is only valid
4415 because signed overflow is undefined; otherwise, do not change
4416 *STRICT_OVERFLOW_P. */
4419 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4420 bool *strict_overflow_p)
4422 enum tree_code code;
4423 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4424 tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
4426 tree low, high, n_low, n_high;
4428 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4429 and see if we can refine the range. Some of the cases below may not
4430 happen, but it doesn't seem worth worrying about this. We "continue"
4431 the outer loop when we've changed something; otherwise we "break"
4432 the switch, which will "break" the while. */
4435 low = high = build_int_cst (TREE_TYPE (exp), 0);
4439 code = TREE_CODE (exp);
4440 exp_type = TREE_TYPE (exp);
4442 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4444 if (TREE_OPERAND_LENGTH (exp) > 0)
4445 arg0 = TREE_OPERAND (exp, 0);
4446 if (TREE_CODE_CLASS (code) == tcc_comparison
4447 || TREE_CODE_CLASS (code) == tcc_unary
4448 || TREE_CODE_CLASS (code) == tcc_binary)
4449 arg0_type = TREE_TYPE (arg0);
4450 if (TREE_CODE_CLASS (code) == tcc_binary
4451 || TREE_CODE_CLASS (code) == tcc_comparison
4452 || (TREE_CODE_CLASS (code) == tcc_expression
4453 && TREE_OPERAND_LENGTH (exp) > 1))
4454 arg1 = TREE_OPERAND (exp, 1);
4459 case TRUTH_NOT_EXPR:
4460 in_p = ! in_p, exp = arg0;
4463 case EQ_EXPR: case NE_EXPR:
4464 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
4465 /* We can only do something if the range is testing for zero
4466 and if the second operand is an integer constant. Note that
4467 saying something is "in" the range we make is done by
4468 complementing IN_P since it will set in the initial case of
4469 being not equal to zero; "out" is leaving it alone. */
4470 if (low == 0 || high == 0
4471 || ! integer_zerop (low) || ! integer_zerop (high)
4472 || TREE_CODE (arg1) != INTEGER_CST)
4477 case NE_EXPR: /* - [c, c] */
4480 case EQ_EXPR: /* + [c, c] */
4481 in_p = ! in_p, low = high = arg1;
4483 case GT_EXPR: /* - [-, c] */
4484 low = 0, high = arg1;
4486 case GE_EXPR: /* + [c, -] */
4487 in_p = ! in_p, low = arg1, high = 0;
4489 case LT_EXPR: /* - [c, -] */
4490 low = arg1, high = 0;
4492 case LE_EXPR: /* + [-, c] */
4493 in_p = ! in_p, low = 0, high = arg1;
4499 /* If this is an unsigned comparison, we also know that EXP is
4500 greater than or equal to zero. We base the range tests we make
4501 on that fact, so we record it here so we can parse existing
4502 range tests. We test arg0_type since often the return type
4503 of, e.g. EQ_EXPR, is boolean. */
4504 if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4506 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4508 build_int_cst (arg0_type, 0),
4512 in_p = n_in_p, low = n_low, high = n_high;
4514 /* If the high bound is missing, but we have a nonzero low
4515 bound, reverse the range so it goes from zero to the low bound
4517 if (high == 0 && low && ! integer_zerop (low))
4520 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4521 integer_one_node, 0);
4522 low = build_int_cst (arg0_type, 0);
4530 /* (-x) IN [a,b] -> x in [-b, -a] */
4531 n_low = range_binop (MINUS_EXPR, exp_type,
4532 build_int_cst (exp_type, 0),
4534 n_high = range_binop (MINUS_EXPR, exp_type,
4535 build_int_cst (exp_type, 0),
4537 low = n_low, high = n_high;
4543 exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
4544 build_int_cst (exp_type, 1));
4547 case PLUS_EXPR: case MINUS_EXPR:
4548 if (TREE_CODE (arg1) != INTEGER_CST)
4551 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4552 move a constant to the other side. */
4553 if (!TYPE_UNSIGNED (arg0_type)
4554 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4557 /* If EXP is signed, any overflow in the computation is undefined,
4558 so we don't worry about it so long as our computations on
4559 the bounds don't overflow. For unsigned, overflow is defined
4560 and this is exactly the right thing. */
4561 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4562 arg0_type, low, 0, arg1, 0);
4563 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4564 arg0_type, high, 1, arg1, 0);
4565 if ((n_low != 0 && TREE_OVERFLOW (n_low))
4566 || (n_high != 0 && TREE_OVERFLOW (n_high)))
4569 if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4570 *strict_overflow_p = true;
4572 /* Check for an unsigned range which has wrapped around the maximum
4573 value thus making n_high < n_low, and normalize it. */
4574 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4576 low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4577 integer_one_node, 0);
4578 high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4579 integer_one_node, 0);
4581 /* If the range is of the form +/- [ x+1, x ], we won't
4582 be able to normalize it. But then, it represents the
4583 whole range or the empty set, so make it
4585 if (tree_int_cst_equal (n_low, low)
4586 && tree_int_cst_equal (n_high, high))
4592 low = n_low, high = n_high;
4597 CASE_CONVERT: case NON_LVALUE_EXPR:
4598 if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4601 if (! INTEGRAL_TYPE_P (arg0_type)
4602 || (low != 0 && ! int_fits_type_p (low, arg0_type))
4603 || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4606 n_low = low, n_high = high;
4609 n_low = fold_convert (arg0_type, n_low);
4612 n_high = fold_convert (arg0_type, n_high);
4615 /* If we're converting arg0 from an unsigned type, to exp,
4616 a signed type, we will be doing the comparison as unsigned.
4617 The tests above have already verified that LOW and HIGH
4620 So we have to ensure that we will handle large unsigned
4621 values the same way that the current signed bounds treat
4624 if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4628 /* For fixed-point modes, we need to pass the saturating flag
4629 as the 2nd parameter. */
4630 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4631 equiv_type = lang_hooks.types.type_for_mode
4632 (TYPE_MODE (arg0_type),
4633 TYPE_SATURATING (arg0_type));
4635 equiv_type = lang_hooks.types.type_for_mode
4636 (TYPE_MODE (arg0_type), 1);
4638 /* A range without an upper bound is, naturally, unbounded.
4639 Since convert would have cropped a very large value, use
4640 the max value for the destination type. */
4642 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4643 : TYPE_MAX_VALUE (arg0_type);
4645 if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4646 high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
4647 fold_convert (arg0_type,
4649 build_int_cst (arg0_type, 1));
4651 /* If the low bound is specified, "and" the range with the
4652 range for which the original unsigned value will be
4656 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4657 1, n_low, n_high, 1,
4658 fold_convert (arg0_type,
4663 in_p = (n_in_p == in_p);
4667 /* Otherwise, "or" the range with the range of the input
4668 that will be interpreted as negative. */
4669 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4670 0, n_low, n_high, 1,
4671 fold_convert (arg0_type,
4676 in_p = (in_p != n_in_p);
4681 low = n_low, high = n_high;
4691 /* If EXP is a constant, we can evaluate whether this is true or false. */
4692 if (TREE_CODE (exp) == INTEGER_CST)
4694 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4696 && integer_onep (range_binop (LE_EXPR, integer_type_node,
4702 *pin_p = in_p, *plow = low, *phigh = high;
4706 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4707 type, TYPE, return an expression to test if EXP is in (or out of, depending
4708 on IN_P) the range. Return 0 if the test couldn't be created. */
4711 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
4713 tree etype = TREE_TYPE (exp), value;
4715 #ifdef HAVE_canonicalize_funcptr_for_compare
4716 /* Disable this optimization for function pointer expressions
4717 on targets that require function pointer canonicalization. */
4718 if (HAVE_canonicalize_funcptr_for_compare
4719 && TREE_CODE (etype) == POINTER_TYPE
4720 && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4726 value = build_range_check (type, exp, 1, low, high);
4728 return invert_truthvalue (value);
4733 if (low == 0 && high == 0)
4734 return build_int_cst (type, 1);
4737 return fold_build2 (LE_EXPR, type, exp,
4738 fold_convert (etype, high));
4741 return fold_build2 (GE_EXPR, type, exp,
4742 fold_convert (etype, low));
4744 if (operand_equal_p (low, high, 0))
4745 return fold_build2 (EQ_EXPR, type, exp,
4746 fold_convert (etype, low));
4748 if (integer_zerop (low))
4750 if (! TYPE_UNSIGNED (etype))
4752 etype = unsigned_type_for (etype);
4753 high = fold_convert (etype, high);
4754 exp = fold_convert (etype, exp);
4756 return build_range_check (type, exp, 1, 0, high);
4759 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4760 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4762 unsigned HOST_WIDE_INT lo;
4766 prec = TYPE_PRECISION (etype);
4767 if (prec <= HOST_BITS_PER_WIDE_INT)
4770 lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4774 hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4775 lo = (unsigned HOST_WIDE_INT) -1;
4778 if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4780 if (TYPE_UNSIGNED (etype))
4782 tree signed_etype = signed_type_for (etype);
4783 if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4785 = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4787 etype = signed_etype;
4788 exp = fold_convert (etype, exp);
4790 return fold_build2 (GT_EXPR, type, exp,
4791 build_int_cst (etype, 0));
4795 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4796 This requires wrap-around arithmetics for the type of the expression.
4797 First make sure that arithmetics in this type is valid, then make sure
4798 that it wraps around. */
4799 if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4800 etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4801 TYPE_UNSIGNED (etype));
4803 if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4805 tree utype, minv, maxv;
4807 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4808 for the type in question, as we rely on this here. */
4809 utype = unsigned_type_for (etype);
4810 maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
4811 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4812 integer_one_node, 1);
4813 minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
4815 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4822 high = fold_convert (etype, high);
4823 low = fold_convert (etype, low);
4824 exp = fold_convert (etype, exp);
4826 value = const_binop (MINUS_EXPR, high, low, 0);
4829 if (POINTER_TYPE_P (etype))
4831 if (value != 0 && !TREE_OVERFLOW (value))
4833 low = fold_convert (sizetype, low);
4834 low = fold_build1 (NEGATE_EXPR, sizetype, low);
4835 return build_range_check (type,
4836 fold_build2 (POINTER_PLUS_EXPR, etype, exp, low),
4837 1, build_int_cst (etype, 0), value);
4842 if (value != 0 && !TREE_OVERFLOW (value))
4843 return build_range_check (type,
4844 fold_build2 (MINUS_EXPR, etype, exp, low),
4845 1, build_int_cst (etype, 0), value);
4850 /* Return the predecessor of VAL in its type, handling the infinite case. */
4853 range_predecessor (tree val)
4855 tree type = TREE_TYPE (val);
4857 if (INTEGRAL_TYPE_P (type)
4858 && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4861 return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4864 /* Return the successor of VAL in its type, handling the infinite case. */
4867 range_successor (tree val)
4869 tree type = TREE_TYPE (val);
4871 if (INTEGRAL_TYPE_P (type)
4872 && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4875 return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4878 /* Given two ranges, see if we can merge them into one. Return 1 if we
4879 can, 0 if we can't. Set the output range into the specified parameters. */
4882 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4883 tree high0, int in1_p, tree low1, tree high1)
4891 int lowequal = ((low0 == 0 && low1 == 0)
4892 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4893 low0, 0, low1, 0)));
4894 int highequal = ((high0 == 0 && high1 == 0)
4895 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4896 high0, 1, high1, 1)));
4898 /* Make range 0 be the range that starts first, or ends last if they
4899 start at the same value. Swap them if it isn't. */
4900 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4903 && integer_onep (range_binop (GT_EXPR, integer_type_node,
4904 high1, 1, high0, 1))))
4906 temp = in0_p, in0_p = in1_p, in1_p = temp;
4907 tem = low0, low0 = low1, low1 = tem;
4908 tem = high0, high0 = high1, high1 = tem;
4911 /* Now flag two cases, whether the ranges are disjoint or whether the
4912 second range is totally subsumed in the first. Note that the tests
4913 below are simplified by the ones above. */
4914 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4915 high0, 1, low1, 0));
4916 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4917 high1, 1, high0, 1));
4919 /* We now have four cases, depending on whether we are including or
4920 excluding the two ranges. */
4923 /* If they don't overlap, the result is false. If the second range
4924 is a subset it is the result. Otherwise, the range is from the start
4925 of the second to the end of the first. */
4927 in_p = 0, low = high = 0;
4929 in_p = 1, low = low1, high = high1;
4931 in_p = 1, low = low1, high = high0;
4934 else if (in0_p && ! in1_p)
4936 /* If they don't overlap, the result is the first range. If they are
4937 equal, the result is false. If the second range is a subset of the
4938 first, and the ranges begin at the same place, we go from just after
4939 the end of the second range to the end of the first. If the second
4940 range is not a subset of the first, or if it is a subset and both
4941 ranges end at the same place, the range starts at the start of the
4942 first range and ends just before the second range.
4943 Otherwise, we can't describe this as a single range. */
4945 in_p = 1, low = low0, high = high0;
4946 else if (lowequal && highequal)
4947 in_p = 0, low = high = 0;
4948 else if (subset && lowequal)
4950 low = range_successor (high1);
4955 /* We are in the weird situation where high0 > high1 but
4956 high1 has no successor. Punt. */
4960 else if (! subset || highequal)
4963 high = range_predecessor (low1);
4967 /* low0 < low1 but low1 has no predecessor. Punt. */
4975 else if (! in0_p && in1_p)
4977 /* If they don't overlap, the result is the second range. If the second
4978 is a subset of the first, the result is false. Otherwise,
4979 the range starts just after the first range and ends at the
4980 end of the second. */
4982 in_p = 1, low = low1, high = high1;
4983 else if (subset || highequal)
4984 in_p = 0, low = high = 0;
4987 low = range_successor (high0);
4992 /* high1 > high0 but high0 has no successor. Punt. */
5000 /* The case where we are excluding both ranges. Here the complex case
5001 is if they don't overlap. In that case, the only time we have a
5002 range is if they are adjacent. If the second is a subset of the
5003 first, the result is the first. Otherwise, the range to exclude
5004 starts at the beginning of the first range and ends at the end of the
5008 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
5009 range_successor (high0),
5011 in_p = 0, low = low0, high = high1;
5014 /* Canonicalize - [min, x] into - [-, x]. */
5015 if (low0 && TREE_CODE (low0) == INTEGER_CST)
5016 switch (TREE_CODE (TREE_TYPE (low0)))
5019 if (TYPE_PRECISION (TREE_TYPE (low0))
5020 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
5024 if (tree_int_cst_equal (low0,
5025 TYPE_MIN_VALUE (TREE_TYPE (low0))))
5029 if (TYPE_UNSIGNED (TREE_TYPE (low0))
5030 && integer_zerop (low0))
5037 /* Canonicalize - [x, max] into - [x, -]. */
5038 if (high1 && TREE_CODE (high1) == INTEGER_CST)
5039 switch (TREE_CODE (TREE_TYPE (high1)))
5042 if (TYPE_PRECISION (TREE_TYPE (high1))
5043 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
5047 if (tree_int_cst_equal (high1,
5048 TYPE_MAX_VALUE (TREE_TYPE (high1))))
5052 if (TYPE_UNSIGNED (TREE_TYPE (high1))
5053 && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
5055 integer_one_node, 1)))
5062 /* The ranges might be also adjacent between the maximum and
5063 minimum values of the given type. For
5064 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5065 return + [x + 1, y - 1]. */
5066 if (low0 == 0 && high1 == 0)
5068 low = range_successor (high0);
5069 high = range_predecessor (low1);
5070 if (low == 0 || high == 0)
5080 in_p = 0, low = low0, high = high0;
5082 in_p = 0, low = low0, high = high1;
5085 *pin_p = in_p, *plow = low, *phigh = high;
5090 /* Subroutine of fold, looking inside expressions of the form
5091 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5092 of the COND_EXPR. This function is being used also to optimize
5093 A op B ? C : A, by reversing the comparison first.
5095 Return a folded expression whose code is not a COND_EXPR
5096 anymore, or NULL_TREE if no folding opportunity is found. */
5099 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
5101 enum tree_code comp_code = TREE_CODE (arg0);
5102 tree arg00 = TREE_OPERAND (arg0, 0);
5103 tree arg01 = TREE_OPERAND (arg0, 1);
5104 tree arg1_type = TREE_TYPE (arg1);
5110 /* If we have A op 0 ? A : -A, consider applying the following
5113 A == 0? A : -A same as -A
5114 A != 0? A : -A same as A
5115 A >= 0? A : -A same as abs (A)
5116 A > 0? A : -A same as abs (A)
5117 A <= 0? A : -A same as -abs (A)
5118 A < 0? A : -A same as -abs (A)
5120 None of these transformations work for modes with signed
5121 zeros. If A is +/-0, the first two transformations will
5122 change the sign of the result (from +0 to -0, or vice
5123 versa). The last four will fix the sign of the result,
5124 even though the original expressions could be positive or
5125 negative, depending on the sign of A.
5127 Note that all these transformations are correct if A is
5128 NaN, since the two alternatives (A and -A) are also NaNs. */
5129 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5130 && (FLOAT_TYPE_P (TREE_TYPE (arg01))
5131 ? real_zerop (arg01)
5132 : integer_zerop (arg01))
5133 && ((TREE_CODE (arg2) == NEGATE_EXPR
5134 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5135 /* In the case that A is of the form X-Y, '-A' (arg2) may
5136 have already been folded to Y-X, check for that. */
5137 || (TREE_CODE (arg1) == MINUS_EXPR
5138 && TREE_CODE (arg2) == MINUS_EXPR
5139 && operand_equal_p (TREE_OPERAND (arg1, 0),
5140 TREE_OPERAND (arg2, 1), 0)
5141 && operand_equal_p (TREE_OPERAND (arg1, 1),
5142 TREE_OPERAND (arg2, 0), 0))))
5147 tem = fold_convert (arg1_type, arg1);
5148 return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
5151 return pedantic_non_lvalue (fold_convert (type, arg1));
5154 if (flag_trapping_math)
5159 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5160 arg1 = fold_convert (signed_type_for
5161 (TREE_TYPE (arg1)), arg1);
5162 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5163 return pedantic_non_lvalue (fold_convert (type, tem));
5166 if (flag_trapping_math)
5170 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5171 arg1 = fold_convert (signed_type_for
5172 (TREE_TYPE (arg1)), arg1);
5173 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5174 return negate_expr (fold_convert (type, tem));
5176 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5180 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5181 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5182 both transformations are correct when A is NaN: A != 0
5183 is then true, and A == 0 is false. */
5185 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5186 && integer_zerop (arg01) && integer_zerop (arg2))
5188 if (comp_code == NE_EXPR)
5189 return pedantic_non_lvalue (fold_convert (type, arg1));
5190 else if (comp_code == EQ_EXPR)
5191 return build_int_cst (type, 0);
5194 /* Try some transformations of A op B ? A : B.
5196 A == B? A : B same as B
5197 A != B? A : B same as A
5198 A >= B? A : B same as max (A, B)
5199 A > B? A : B same as max (B, A)
5200 A <= B? A : B same as min (A, B)
5201 A < B? A : B same as min (B, A)
5203 As above, these transformations don't work in the presence
5204 of signed zeros. For example, if A and B are zeros of
5205 opposite sign, the first two transformations will change
5206 the sign of the result. In the last four, the original
5207 expressions give different results for (A=+0, B=-0) and
5208 (A=-0, B=+0), but the transformed expressions do not.
5210 The first two transformations are correct if either A or B
5211 is a NaN. In the first transformation, the condition will
5212 be false, and B will indeed be chosen. In the case of the
5213 second transformation, the condition A != B will be true,
5214 and A will be chosen.
5216 The conversions to max() and min() are not correct if B is
5217 a number and A is not. The conditions in the original
5218 expressions will be false, so all four give B. The min()
5219 and max() versions would give a NaN instead. */
5220 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5221 && operand_equal_for_comparison_p (arg01, arg2, arg00)
5222 /* Avoid these transformations if the COND_EXPR may be used
5223 as an lvalue in the C++ front-end. PR c++/19199. */
5225 || (strcmp (lang_hooks.name, "GNU C++") != 0
5226 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
5227 || ! maybe_lvalue_p (arg1)
5228 || ! maybe_lvalue_p (arg2)))
5230 tree comp_op0 = arg00;
5231 tree comp_op1 = arg01;
5232 tree comp_type = TREE_TYPE (comp_op0);
5234 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5235 if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
5245 return pedantic_non_lvalue (fold_convert (type, arg2));
5247 return pedantic_non_lvalue (fold_convert (type, arg1));
5252 /* In C++ a ?: expression can be an lvalue, so put the
5253 operand which will be used if they are equal first
5254 so that we can convert this back to the
5255 corresponding COND_EXPR. */
5256 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5258 comp_op0 = fold_convert (comp_type, comp_op0);
5259 comp_op1 = fold_convert (comp_type, comp_op1);
5260 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
5261 ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
5262 : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
5263 return pedantic_non_lvalue (fold_convert (type, tem));
5270 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5272 comp_op0 = fold_convert (comp_type, comp_op0);
5273 comp_op1 = fold_convert (comp_type, comp_op1);
5274 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
5275 ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
5276 : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
5277 return pedantic_non_lvalue (fold_convert (type, tem));
5281 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5282 return pedantic_non_lvalue (fold_convert (type, arg2));
5285 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5286 return pedantic_non_lvalue (fold_convert (type, arg1));
5289 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5294 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5295 we might still be able to simplify this. For example,
5296 if C1 is one less or one more than C2, this might have started
5297 out as a MIN or MAX and been transformed by this function.
5298 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5300 if (INTEGRAL_TYPE_P (type)
5301 && TREE_CODE (arg01) == INTEGER_CST
5302 && TREE_CODE (arg2) == INTEGER_CST)
5306 /* We can replace A with C1 in this case. */
5307 arg1 = fold_convert (type, arg01);
5308 return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
5311 /* If C1 is C2 + 1, this is min(A, C2). */
5312 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5314 && operand_equal_p (arg01,
5315 const_binop (PLUS_EXPR, arg2,
5316 build_int_cst (type, 1), 0),
5318 return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5320 fold_convert (type, arg1),
5325 /* If C1 is C2 - 1, this is min(A, C2). */
5326 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5328 && operand_equal_p (arg01,
5329 const_binop (MINUS_EXPR, arg2,
5330 build_int_cst (type, 1), 0),
5332 return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5334 fold_convert (type, arg1),
5339 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5340 MAX_EXPR, to preserve the signedness of the comparison. */
5341 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5343 && operand_equal_p (arg01,
5344 const_binop (MINUS_EXPR, arg2,
5345 build_int_cst (type, 1), 0),
5347 return pedantic_non_lvalue (fold_convert (type,
5348 fold_build2 (MAX_EXPR, TREE_TYPE (arg00),
5350 fold_convert (TREE_TYPE (arg00),
5355 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5356 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5358 && operand_equal_p (arg01,
5359 const_binop (PLUS_EXPR, arg2,
5360 build_int_cst (type, 1), 0),
5362 return pedantic_non_lvalue (fold_convert (type,
5363 fold_build2 (MAX_EXPR, TREE_TYPE (arg00),
5365 fold_convert (TREE_TYPE (arg00),
5379 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5380 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5381 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5385 /* EXP is some logical combination of boolean tests. See if we can
5386 merge it into some range test. Return the new tree if so. */
5389 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
5391 int or_op = (code == TRUTH_ORIF_EXPR
5392 || code == TRUTH_OR_EXPR);
5393 int in0_p, in1_p, in_p;
5394 tree low0, low1, low, high0, high1, high;
5395 bool strict_overflow_p = false;
5396 tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5397 tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5399 const char * const warnmsg = G_("assuming signed overflow does not occur "
5400 "when simplifying range test");
5402 /* If this is an OR operation, invert both sides; we will invert
5403 again at the end. */
5405 in0_p = ! in0_p, in1_p = ! in1_p;
5407 /* If both expressions are the same, if we can merge the ranges, and we
5408 can build the range test, return it or it inverted. If one of the
5409 ranges is always true or always false, consider it to be the same
5410 expression as the other. */
5411 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5412 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5414 && 0 != (tem = (build_range_check (type,
5416 : rhs != 0 ? rhs : integer_zero_node,
5419 if (strict_overflow_p)
5420 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5421 return or_op ? invert_truthvalue (tem) : tem;
5424 /* On machines where the branch cost is expensive, if this is a
5425 short-circuited branch and the underlying object on both sides
5426 is the same, make a non-short-circuit operation. */
5427 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5428 && lhs != 0 && rhs != 0
5429 && (code == TRUTH_ANDIF_EXPR
5430 || code == TRUTH_ORIF_EXPR)
5431 && operand_equal_p (lhs, rhs, 0))
5433 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5434 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5435 which cases we can't do this. */
5436 if (simple_operand_p (lhs))
5437 return build2 (code == TRUTH_ANDIF_EXPR
5438 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5441 else if (lang_hooks.decls.global_bindings_p () == 0
5442 && ! CONTAINS_PLACEHOLDER_P (lhs))
5444 tree common = save_expr (lhs);
5446 if (0 != (lhs = build_range_check (type, common,
5447 or_op ? ! in0_p : in0_p,
5449 && (0 != (rhs = build_range_check (type, common,
5450 or_op ? ! in1_p : in1_p,
5453 if (strict_overflow_p)
5454 fold_overflow_warning (warnmsg,
5455 WARN_STRICT_OVERFLOW_COMPARISON);
5456 return build2 (code == TRUTH_ANDIF_EXPR
5457 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5466 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
5467 bit value. Arrange things so the extra bits will be set to zero if and
5468 only if C is signed-extended to its full width. If MASK is nonzero,
5469 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5472 unextend (tree c, int p, int unsignedp, tree mask)
5474 tree type = TREE_TYPE (c);
5475 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5478 if (p == modesize || unsignedp)
5481 /* We work by getting just the sign bit into the low-order bit, then
5482 into the high-order bit, then sign-extend. We then XOR that value
5484 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
5485 temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
5487 /* We must use a signed type in order to get an arithmetic right shift.
5488 However, we must also avoid introducing accidental overflows, so that
5489 a subsequent call to integer_zerop will work. Hence we must
5490 do the type conversion here. At this point, the constant is either
5491 zero or one, and the conversion to a signed type can never overflow.
5492 We could get an overflow if this conversion is done anywhere else. */
5493 if (TYPE_UNSIGNED (type))
5494 temp = fold_convert (signed_type_for (type), temp);
5496 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
5497 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
5499 temp = const_binop (BIT_AND_EXPR, temp,
5500 fold_convert (TREE_TYPE (c), mask), 0);
5501 /* If necessary, convert the type back to match the type of C. */
5502 if (TYPE_UNSIGNED (type))
5503 temp = fold_convert (type, temp);
5505 return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
5508 /* Find ways of folding logical expressions of LHS and RHS:
5509 Try to merge two comparisons to the same innermost item.
5510 Look for range tests like "ch >= '0' && ch <= '9'".
5511 Look for combinations of simple terms on machines with expensive branches
5512 and evaluate the RHS unconditionally.
5514 For example, if we have p->a == 2 && p->b == 4 and we can make an
5515 object large enough to span both A and B, we can do this with a comparison
5516 against the object ANDed with the a mask.
5518 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5519 operations to do this with one comparison.
5521 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5522 function and the one above.
5524 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5525 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5527 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5530 We return the simplified tree or 0 if no optimization is possible. */
5533 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
5535 /* If this is the "or" of two comparisons, we can do something if
5536 the comparisons are NE_EXPR. If this is the "and", we can do something
5537 if the comparisons are EQ_EXPR. I.e.,
5538 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5540 WANTED_CODE is this operation code. For single bit fields, we can
5541 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5542 comparison for one-bit fields. */
5544 enum tree_code wanted_code;
5545 enum tree_code lcode, rcode;
5546 tree ll_arg, lr_arg, rl_arg, rr_arg;
5547 tree ll_inner, lr_inner, rl_inner, rr_inner;
5548 HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5549 HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5550 HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5551 HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5552 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5553 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5554 enum machine_mode lnmode, rnmode;
5555 tree ll_mask, lr_mask, rl_mask, rr_mask;
5556 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5557 tree l_const, r_const;
5558 tree lntype, rntype, result;
5559 HOST_WIDE_INT first_bit, end_bit;
5561 tree orig_lhs = lhs, orig_rhs = rhs;
5562 enum tree_code orig_code = code;
5564 /* Start by getting the comparison codes. Fail if anything is volatile.
5565 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5566 it were surrounded with a NE_EXPR. */
5568 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5571 lcode = TREE_CODE (lhs);
5572 rcode = TREE_CODE (rhs);
5574 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5576 lhs = build2 (NE_EXPR, truth_type, lhs,
5577 build_int_cst (TREE_TYPE (lhs), 0));
5581 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5583 rhs = build2 (NE_EXPR, truth_type, rhs,
5584 build_int_cst (TREE_TYPE (rhs), 0));
5588 if (TREE_CODE_CLASS (lcode) != tcc_comparison
5589 || TREE_CODE_CLASS (rcode) != tcc_comparison)
5592 ll_arg = TREE_OPERAND (lhs, 0);
5593 lr_arg = TREE_OPERAND (lhs, 1);
5594 rl_arg = TREE_OPERAND (rhs, 0);
5595 rr_arg = TREE_OPERAND (rhs, 1);
5597 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5598 if (simple_operand_p (ll_arg)
5599 && simple_operand_p (lr_arg))
5602 if (operand_equal_p (ll_arg, rl_arg, 0)
5603 && operand_equal_p (lr_arg, rr_arg, 0))
5605 result = combine_comparisons (code, lcode, rcode,
5606 truth_type, ll_arg, lr_arg);
5610 else if (operand_equal_p (ll_arg, rr_arg, 0)
5611 && operand_equal_p (lr_arg, rl_arg, 0))
5613 result = combine_comparisons (code, lcode,
5614 swap_tree_comparison (rcode),
5615 truth_type, ll_arg, lr_arg);
5621 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5622 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5624 /* If the RHS can be evaluated unconditionally and its operands are
5625 simple, it wins to evaluate the RHS unconditionally on machines
5626 with expensive branches. In this case, this isn't a comparison
5627 that can be merged. Avoid doing this if the RHS is a floating-point
5628 comparison since those can trap. */
5630 if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5632 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5633 && simple_operand_p (rl_arg)
5634 && simple_operand_p (rr_arg))
5636 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5637 if (code == TRUTH_OR_EXPR
5638 && lcode == NE_EXPR && integer_zerop (lr_arg)
5639 && rcode == NE_EXPR && integer_zerop (rr_arg)
5640 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5641 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5642 return build2 (NE_EXPR, truth_type,
5643 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5645 build_int_cst (TREE_TYPE (ll_arg), 0));
5647 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5648 if (code == TRUTH_AND_EXPR
5649 && lcode == EQ_EXPR && integer_zerop (lr_arg)
5650 && rcode == EQ_EXPR && integer_zerop (rr_arg)
5651 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5652 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5653 return build2 (EQ_EXPR, truth_type,
5654 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5656 build_int_cst (TREE_TYPE (ll_arg), 0));
5658 if (LOGICAL_OP_NON_SHORT_CIRCUIT)
5660 if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
5661 return build2 (code, truth_type, lhs, rhs);
5666 /* See if the comparisons can be merged. Then get all the parameters for
5669 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5670 || (rcode != EQ_EXPR && rcode != NE_EXPR))
5674 ll_inner = decode_field_reference (ll_arg,
5675 &ll_bitsize, &ll_bitpos, &ll_mode,
5676 &ll_unsignedp, &volatilep, &ll_mask,
5678 lr_inner = decode_field_reference (lr_arg,
5679 &lr_bitsize, &lr_bitpos, &lr_mode,
5680 &lr_unsignedp, &volatilep, &lr_mask,
5682 rl_inner = decode_field_reference (rl_arg,
5683 &rl_bitsize, &rl_bitpos, &rl_mode,
5684 &rl_unsignedp, &volatilep, &rl_mask,
5686 rr_inner = decode_field_reference (rr_arg,
5687 &rr_bitsize, &rr_bitpos, &rr_mode,
5688 &rr_unsignedp, &volatilep, &rr_mask,
5691 /* It must be true that the inner operation on the lhs of each
5692 comparison must be the same if we are to be able to do anything.
5693 Then see if we have constants. If not, the same must be true for
5695 if (volatilep || ll_inner == 0 || rl_inner == 0
5696 || ! operand_equal_p (ll_inner, rl_inner, 0))
5699 if (TREE_CODE (lr_arg) == INTEGER_CST
5700 && TREE_CODE (rr_arg) == INTEGER_CST)
5701 l_const = lr_arg, r_const = rr_arg;
5702 else if (lr_inner == 0 || rr_inner == 0
5703 || ! operand_equal_p (lr_inner, rr_inner, 0))
5706 l_const = r_const = 0;
5708 /* If either comparison code is not correct for our logical operation,
5709 fail. However, we can convert a one-bit comparison against zero into
5710 the opposite comparison against that bit being set in the field. */
5712 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5713 if (lcode != wanted_code)
5715 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5717 /* Make the left operand unsigned, since we are only interested
5718 in the value of one bit. Otherwise we are doing the wrong
5727 /* This is analogous to the code for l_const above. */
5728 if (rcode != wanted_code)
5730 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5739 /* See if we can find a mode that contains both fields being compared on
5740 the left. If we can't, fail. Otherwise, update all constants and masks
5741 to be relative to a field of that size. */
5742 first_bit = MIN (ll_bitpos, rl_bitpos);
5743 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5744 lnmode = get_best_mode (end_bit - first_bit, first_bit,
5745 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5747 if (lnmode == VOIDmode)
5750 lnbitsize = GET_MODE_BITSIZE (lnmode);
5751 lnbitpos = first_bit & ~ (lnbitsize - 1);
5752 lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5753 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5755 if (BYTES_BIG_ENDIAN)
5757 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5758 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5761 ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
5762 size_int (xll_bitpos), 0);
5763 rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
5764 size_int (xrl_bitpos), 0);
5768 l_const = fold_convert (lntype, l_const);
5769 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5770 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
5771 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5772 fold_build1 (BIT_NOT_EXPR,
5776 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5778 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5783 r_const = fold_convert (lntype, r_const);
5784 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5785 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
5786 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5787 fold_build1 (BIT_NOT_EXPR,
5791 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5793 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5797 /* If the right sides are not constant, do the same for it. Also,
5798 disallow this optimization if a size or signedness mismatch occurs
5799 between the left and right sides. */
5802 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5803 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5804 /* Make sure the two fields on the right
5805 correspond to the left without being swapped. */
5806 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5809 first_bit = MIN (lr_bitpos, rr_bitpos);
5810 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5811 rnmode = get_best_mode (end_bit - first_bit, first_bit,
5812 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5814 if (rnmode == VOIDmode)
5817 rnbitsize = GET_MODE_BITSIZE (rnmode);
5818 rnbitpos = first_bit & ~ (rnbitsize - 1);
5819 rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5820 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5822 if (BYTES_BIG_ENDIAN)
5824 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5825 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5828 lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
5829 size_int (xlr_bitpos), 0);
5830 rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
5831 size_int (xrr_bitpos), 0);
5833 /* Make a mask that corresponds to both fields being compared.
5834 Do this for both items being compared. If the operands are the
5835 same size and the bits being compared are in the same position
5836 then we can do this by masking both and comparing the masked
5838 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5839 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
5840 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5842 lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5843 ll_unsignedp || rl_unsignedp);
5844 if (! all_ones_mask_p (ll_mask, lnbitsize))
5845 lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5847 rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
5848 lr_unsignedp || rr_unsignedp);
5849 if (! all_ones_mask_p (lr_mask, rnbitsize))
5850 rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5852 return build2 (wanted_code, truth_type, lhs, rhs);
5855 /* There is still another way we can do something: If both pairs of
5856 fields being compared are adjacent, we may be able to make a wider
5857 field containing them both.
5859 Note that we still must mask the lhs/rhs expressions. Furthermore,
5860 the mask must be shifted to account for the shift done by
5861 make_bit_field_ref. */
5862 if ((ll_bitsize + ll_bitpos == rl_bitpos
5863 && lr_bitsize + lr_bitpos == rr_bitpos)
5864 || (ll_bitpos == rl_bitpos + rl_bitsize
5865 && lr_bitpos == rr_bitpos + rr_bitsize))
5869 lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
5870 MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5871 rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
5872 MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5874 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5875 size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
5876 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5877 size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
5879 /* Convert to the smaller type before masking out unwanted bits. */
5881 if (lntype != rntype)
5883 if (lnbitsize > rnbitsize)
5885 lhs = fold_convert (rntype, lhs);
5886 ll_mask = fold_convert (rntype, ll_mask);
5889 else if (lnbitsize < rnbitsize)
5891 rhs = fold_convert (lntype, rhs);
5892 lr_mask = fold_convert (lntype, lr_mask);
5897 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5898 lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5900 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5901 rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5903 return build2 (wanted_code, truth_type, lhs, rhs);
5909 /* Handle the case of comparisons with constants. If there is something in
5910 common between the masks, those bits of the constants must be the same.
5911 If not, the condition is always false. Test for this to avoid generating
5912 incorrect code below. */
5913 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
5914 if (! integer_zerop (result)
5915 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
5916 const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
5918 if (wanted_code == NE_EXPR)
5920 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5921 return constant_boolean_node (true, truth_type);
5925 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5926 return constant_boolean_node (false, truth_type);
5930 /* Construct the expression we will return. First get the component
5931 reference we will make. Unless the mask is all ones the width of
5932 that field, perform the mask operation. Then compare with the
5934 result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5935 ll_unsignedp || rl_unsignedp);
5937 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5938 if (! all_ones_mask_p (ll_mask, lnbitsize))
5939 result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
5941 return build2 (wanted_code, truth_type, result,
5942 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
5945 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5949 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5952 enum tree_code op_code;
5955 int consts_equal, consts_lt;
5958 STRIP_SIGN_NOPS (arg0);
5960 op_code = TREE_CODE (arg0);
5961 minmax_const = TREE_OPERAND (arg0, 1);
5962 comp_const = fold_convert (TREE_TYPE (arg0), op1);
5963 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5964 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5965 inner = TREE_OPERAND (arg0, 0);
5967 /* If something does not permit us to optimize, return the original tree. */
5968 if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5969 || TREE_CODE (comp_const) != INTEGER_CST
5970 || TREE_OVERFLOW (comp_const)
5971 || TREE_CODE (minmax_const) != INTEGER_CST
5972 || TREE_OVERFLOW (minmax_const))
5975 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5976 and GT_EXPR, doing the rest with recursive calls using logical
5980 case NE_EXPR: case LT_EXPR: case LE_EXPR:
5982 tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5985 return invert_truthvalue (tem);
5991 fold_build2 (TRUTH_ORIF_EXPR, type,
5992 optimize_minmax_comparison
5993 (EQ_EXPR, type, arg0, comp_const),
5994 optimize_minmax_comparison
5995 (GT_EXPR, type, arg0, comp_const));
5998 if (op_code == MAX_EXPR && consts_equal)
5999 /* MAX (X, 0) == 0 -> X <= 0 */
6000 return fold_build2 (LE_EXPR, type, inner, comp_const);
6002 else if (op_code == MAX_EXPR && consts_lt)
6003 /* MAX (X, 0) == 5 -> X == 5 */
6004 return fold_build2 (EQ_EXPR, type, inner, comp_const);
6006 else if (op_code == MAX_EXPR)
6007 /* MAX (X, 0) == -1 -> false */
6008 return omit_one_operand (type, integer_zero_node, inner);
6010 else if (consts_equal)
6011 /* MIN (X, 0) == 0 -> X >= 0 */
6012 return fold_build2 (GE_EXPR, type, inner, comp_const);
6015 /* MIN (X, 0) == 5 -> false */
6016 return omit_one_operand (type, integer_zero_node, inner);
6019 /* MIN (X, 0) == -1 -> X == -1 */
6020 return fold_build2 (EQ_EXPR, type, inner, comp_const);
6023 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
6024 /* MAX (X, 0) > 0 -> X > 0
6025 MAX (X, 0) > 5 -> X > 5 */
6026 return fold_build2 (GT_EXPR, type, inner, comp_const);
6028 else if (op_code == MAX_EXPR)
6029 /* MAX (X, 0) > -1 -> true */
6030 return omit_one_operand (type, integer_one_node, inner);
6032 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
6033 /* MIN (X, 0) > 0 -> false
6034 MIN (X, 0) > 5 -> false */
6035 return omit_one_operand (type, integer_zero_node, inner);
6038 /* MIN (X, 0) > -1 -> X > -1 */
6039 return fold_build2 (GT_EXPR, type, inner, comp_const);
6046 /* T is an integer expression that is being multiplied, divided, or taken a
6047 modulus (CODE says which and what kind of divide or modulus) by a
6048 constant C. See if we can eliminate that operation by folding it with
6049 other operations already in T. WIDE_TYPE, if non-null, is a type that
6050 should be used for the computation if wider than our type.
6052 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6053 (X * 2) + (Y * 4). We must, however, be assured that either the original
6054 expression would not overflow or that overflow is undefined for the type
6055 in the language in question.
6057 If we return a non-null expression, it is an equivalent form of the
6058 original computation, but need not be in the original type.
6060 We set *STRICT_OVERFLOW_P to true if the return values depends on
6061 signed overflow being undefined. Otherwise we do not change
6062 *STRICT_OVERFLOW_P. */
6065 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
6066 bool *strict_overflow_p)
6068 /* To avoid exponential search depth, refuse to allow recursion past
6069 three levels. Beyond that (1) it's highly unlikely that we'll find
6070 something interesting and (2) we've probably processed it before
6071 when we built the inner expression. */
6080 ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
6087 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
6088 bool *strict_overflow_p)
6090 tree type = TREE_TYPE (t);
6091 enum tree_code tcode = TREE_CODE (t);
6092 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
6093 > GET_MODE_SIZE (TYPE_MODE (type)))
6094 ? wide_type : type);
6096 int same_p = tcode == code;
6097 tree op0 = NULL_TREE, op1 = NULL_TREE;
6098 bool sub_strict_overflow_p;
6100 /* Don't deal with constants of zero here; they confuse the code below. */
6101 if (integer_zerop (c))
6104 if (TREE_CODE_CLASS (tcode) == tcc_unary)
6105 op0 = TREE_OPERAND (t, 0);
6107 if (TREE_CODE_CLASS (tcode) == tcc_binary)
6108 op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
6110 /* Note that we need not handle conditional operations here since fold
6111 already handles those cases. So just do arithmetic here. */
6115 /* For a constant, we can always simplify if we are a multiply
6116 or (for divide and modulus) if it is a multiple of our constant. */
6117 if (code == MULT_EXPR
6118 || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
6119 return const_binop (code, fold_convert (ctype, t),
6120 fold_convert (ctype, c), 0);
6123 CASE_CONVERT: case NON_LVALUE_EXPR:
6124 /* If op0 is an expression ... */
6125 if ((COMPARISON_CLASS_P (op0)
6126 || UNARY_CLASS_P (op0)
6127 || BINARY_CLASS_P (op0)
6128 || VL_EXP_CLASS_P (op0)
6129 || EXPRESSION_CLASS_P (op0))
6130 /* ... and has wrapping overflow, and its type is smaller
6131 than ctype, then we cannot pass through as widening. */
6132 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
6133 && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
6134 && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
6135 && (TYPE_PRECISION (ctype)
6136 > TYPE_PRECISION (TREE_TYPE (op0))))
6137 /* ... or this is a truncation (t is narrower than op0),
6138 then we cannot pass through this narrowing. */
6139 || (TYPE_PRECISION (type)
6140 < TYPE_PRECISION (TREE_TYPE (op0)))
6141 /* ... or signedness changes for division or modulus,
6142 then we cannot pass through this conversion. */
6143 || (code != MULT_EXPR
6144 && (TYPE_UNSIGNED (ctype)
6145 != TYPE_UNSIGNED (TREE_TYPE (op0))))
6146 /* ... or has undefined overflow while the converted to
6147 type has not, we cannot do the operation in the inner type
6148 as that would introduce undefined overflow. */
6149 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
6150 && !TYPE_OVERFLOW_UNDEFINED (type))))
6153 /* Pass the constant down and see if we can make a simplification. If
6154 we can, replace this expression with the inner simplification for
6155 possible later conversion to our or some other type. */
6156 if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
6157 && TREE_CODE (t2) == INTEGER_CST
6158 && !TREE_OVERFLOW (t2)
6159 && (0 != (t1 = extract_muldiv (op0, t2, code,
6161 ? ctype : NULL_TREE,
6162 strict_overflow_p))))
6167 /* If widening the type changes it from signed to unsigned, then we
6168 must avoid building ABS_EXPR itself as unsigned. */
6169 if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
6171 tree cstype = (*signed_type_for) (ctype);
6172 if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
6175 t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
6176 return fold_convert (ctype, t1);
6180 /* If the constant is negative, we cannot simplify this. */
6181 if (tree_int_cst_sgn (c) == -1)
6185 if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
6187 return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
6190 case MIN_EXPR: case MAX_EXPR:
6191 /* If widening the type changes the signedness, then we can't perform
6192 this optimization as that changes the result. */
6193 if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
6196 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6197 sub_strict_overflow_p = false;
6198 if ((t1 = extract_muldiv (op0, c, code, wide_type,
6199 &sub_strict_overflow_p)) != 0
6200 && (t2 = extract_muldiv (op1, c, code, wide_type,
6201 &sub_strict_overflow_p)) != 0)
6203 if (tree_int_cst_sgn (c) < 0)
6204 tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
6205 if (sub_strict_overflow_p)
6206 *strict_overflow_p = true;
6207 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6208 fold_convert (ctype, t2));
6212 case LSHIFT_EXPR: case RSHIFT_EXPR:
6213 /* If the second operand is constant, this is a multiplication
6214 or floor division, by a power of two, so we can treat it that
6215 way unless the multiplier or divisor overflows. Signed
6216 left-shift overflow is implementation-defined rather than
6217 undefined in C90, so do not convert signed left shift into
6219 if (TREE_CODE (op1) == INTEGER_CST
6220 && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
6221 /* const_binop may not detect overflow correctly,
6222 so check for it explicitly here. */
6223 && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
6224 && TREE_INT_CST_HIGH (op1) == 0
6225 && 0 != (t1 = fold_convert (ctype,
6226 const_binop (LSHIFT_EXPR,
6229 && !TREE_OVERFLOW (t1))
6230 return extract_muldiv (build2 (tcode == LSHIFT_EXPR
6231 ? MULT_EXPR : FLOOR_DIV_EXPR,
6232 ctype, fold_convert (ctype, op0), t1),
6233 c, code, wide_type, strict_overflow_p);
6236 case PLUS_EXPR: case MINUS_EXPR:
6237 /* See if we can eliminate the operation on both sides. If we can, we
6238 can return a new PLUS or MINUS. If we can't, the only remaining
6239 cases where we can do anything are if the second operand is a
6241 sub_strict_overflow_p = false;
6242 t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
6243 t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
6244 if (t1 != 0 && t2 != 0
6245 && (code == MULT_EXPR
6246 /* If not multiplication, we can only do this if both operands
6247 are divisible by c. */
6248 || (multiple_of_p (ctype, op0, c)
6249 && multiple_of_p (ctype, op1, c))))
6251 if (sub_strict_overflow_p)
6252 *strict_overflow_p = true;
6253 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6254 fold_convert (ctype, t2));
6257 /* If this was a subtraction, negate OP1 and set it to be an addition.
6258 This simplifies the logic below. */
6259 if (tcode == MINUS_EXPR)
6260 tcode = PLUS_EXPR, op1 = negate_expr (op1);
6262 if (TREE_CODE (op1) != INTEGER_CST)
6265 /* If either OP1 or C are negative, this optimization is not safe for
6266 some of the division and remainder types while for others we need
6267 to change the code. */
6268 if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
6270 if (code == CEIL_DIV_EXPR)
6271 code = FLOOR_DIV_EXPR;
6272 else if (code == FLOOR_DIV_EXPR)
6273 code = CEIL_DIV_EXPR;
6274 else if (code != MULT_EXPR
6275 && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
6279 /* If it's a multiply or a division/modulus operation of a multiple
6280 of our constant, do the operation and verify it doesn't overflow. */
6281 if (code == MULT_EXPR
6282 || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6284 op1 = const_binop (code, fold_convert (ctype, op1),
6285 fold_convert (ctype, c), 0);
6286 /* We allow the constant to overflow with wrapping semantics. */
6288 || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
6294 /* If we have an unsigned type is not a sizetype, we cannot widen
6295 the operation since it will change the result if the original
6296 computation overflowed. */
6297 if (TYPE_UNSIGNED (ctype)
6298 && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
6302 /* If we were able to eliminate our operation from the first side,
6303 apply our operation to the second side and reform the PLUS. */
6304 if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
6305 return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
6307 /* The last case is if we are a multiply. In that case, we can
6308 apply the distributive law to commute the multiply and addition
6309 if the multiplication of the constants doesn't overflow. */
6310 if (code == MULT_EXPR)
6311 return fold_build2 (tcode, ctype,
6312 fold_build2 (code, ctype,
6313 fold_convert (ctype, op0),
6314 fold_convert (ctype, c)),
6320 /* We have a special case here if we are doing something like
6321 (C * 8) % 4 since we know that's zero. */
6322 if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6323 || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6324 /* If the multiplication can overflow we cannot optimize this.
6325 ??? Until we can properly mark individual operations as
6326 not overflowing we need to treat sizetype special here as
6327 stor-layout relies on this opimization to make
6328 DECL_FIELD_BIT_OFFSET always a constant. */
6329 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
6330 || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6331 && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
6332 && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6333 && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6335 *strict_overflow_p = true;
6336 return omit_one_operand (type, integer_zero_node, op0);
6339 /* ... fall through ... */
6341 case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
6342 case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
6343 /* If we can extract our operation from the LHS, do so and return a
6344 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6345 do something only if the second operand is a constant. */
6347 && (t1 = extract_muldiv (op0, c, code, wide_type,
6348 strict_overflow_p)) != 0)
6349 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6350 fold_convert (ctype, op1));
6351 else if (tcode == MULT_EXPR && code == MULT_EXPR
6352 && (t1 = extract_muldiv (op1, c, code, wide_type,
6353 strict_overflow_p)) != 0)
6354 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6355 fold_convert (ctype, t1));
6356 else if (TREE_CODE (op1) != INTEGER_CST)
6359 /* If these are the same operation types, we can associate them
6360 assuming no overflow. */
6362 && 0 != (t1 = int_const_binop (MULT_EXPR, fold_convert (ctype, op1),
6363 fold_convert (ctype, c), 1))
6364 && 0 != (t1 = force_fit_type_double (ctype, TREE_INT_CST_LOW (t1),
6365 TREE_INT_CST_HIGH (t1),
6366 (TYPE_UNSIGNED (ctype)
6367 && tcode != MULT_EXPR) ? -1 : 1,
6368 TREE_OVERFLOW (t1)))
6369 && !TREE_OVERFLOW (t1))
6370 return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
6372 /* If these operations "cancel" each other, we have the main
6373 optimizations of this pass, which occur when either constant is a
6374 multiple of the other, in which case we replace this with either an
6375 operation or CODE or TCODE.
6377 If we have an unsigned type that is not a sizetype, we cannot do
6378 this since it will change the result if the original computation
6380 if ((TYPE_OVERFLOW_UNDEFINED (ctype)
6381 || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
6382 && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6383 || (tcode == MULT_EXPR
6384 && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6385 && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6386 && code != MULT_EXPR)))
6388 if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6390 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6391 *strict_overflow_p = true;
6392 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6393 fold_convert (ctype,
6394 const_binop (TRUNC_DIV_EXPR,
6397 else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
6399 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6400 *strict_overflow_p = true;
6401 return fold_build2 (code, ctype, fold_convert (ctype, op0),
6402 fold_convert (ctype,
6403 const_binop (TRUNC_DIV_EXPR,
6416 /* Return a node which has the indicated constant VALUE (either 0 or
6417 1), and is of the indicated TYPE. */
6420 constant_boolean_node (int value, tree type)
6422 if (type == integer_type_node)
6423 return value ? integer_one_node : integer_zero_node;
6424 else if (type == boolean_type_node)
6425 return value ? boolean_true_node : boolean_false_node;
6427 return build_int_cst (type, value);
6431 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6432 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6433 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6434 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6435 COND is the first argument to CODE; otherwise (as in the example
6436 given here), it is the second argument. TYPE is the type of the
6437 original expression. Return NULL_TREE if no simplification is
6441 fold_binary_op_with_conditional_arg (enum tree_code code,
6442 tree type, tree op0, tree op1,
6443 tree cond, tree arg, int cond_first_p)
6445 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6446 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6447 tree test, true_value, false_value;
6448 tree lhs = NULL_TREE;
6449 tree rhs = NULL_TREE;
6451 /* This transformation is only worthwhile if we don't have to wrap
6452 arg in a SAVE_EXPR, and the operation can be simplified on at least
6453 one of the branches once its pushed inside the COND_EXPR. */
6454 if (!TREE_CONSTANT (arg))
6457 if (TREE_CODE (cond) == COND_EXPR)
6459 test = TREE_OPERAND (cond, 0);
6460 true_value = TREE_OPERAND (cond, 1);
6461 false_value = TREE_OPERAND (cond, 2);
6462 /* If this operand throws an expression, then it does not make
6463 sense to try to perform a logical or arithmetic operation
6465 if (VOID_TYPE_P (TREE_TYPE (true_value)))
6467 if (VOID_TYPE_P (TREE_TYPE (false_value)))
6472 tree testtype = TREE_TYPE (cond);
6474 true_value = constant_boolean_node (true, testtype);
6475 false_value = constant_boolean_node (false, testtype);
6478 arg = fold_convert (arg_type, arg);
6481 true_value = fold_convert (cond_type, true_value);
6483 lhs = fold_build2 (code, type, true_value, arg);
6485 lhs = fold_build2 (code, type, arg, true_value);
6489 false_value = fold_convert (cond_type, false_value);
6491 rhs = fold_build2 (code, type, false_value, arg);
6493 rhs = fold_build2 (code, type, arg, false_value);
6496 test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
6497 return fold_convert (type, test);
6501 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6503 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6504 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6505 ADDEND is the same as X.
6507 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6508 and finite. The problematic cases are when X is zero, and its mode
6509 has signed zeros. In the case of rounding towards -infinity,
6510 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6511 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6514 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6516 if (!real_zerop (addend))
6519 /* Don't allow the fold with -fsignaling-nans. */
6520 if (HONOR_SNANS (TYPE_MODE (type)))
6523 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6524 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6527 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6528 if (TREE_CODE (addend) == REAL_CST
6529 && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6532 /* The mode has signed zeros, and we have to honor their sign.
6533 In this situation, there is only one case we can return true for.
6534 X - 0 is the same as X unless rounding towards -infinity is
6536 return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6539 /* Subroutine of fold() that checks comparisons of built-in math
6540 functions against real constants.
6542 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6543 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6544 is the type of the result and ARG0 and ARG1 are the operands of the
6545 comparison. ARG1 must be a TREE_REAL_CST.
6547 The function returns the constant folded tree if a simplification
6548 can be made, and NULL_TREE otherwise. */
6551 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
6552 tree type, tree arg0, tree arg1)
6556 if (BUILTIN_SQRT_P (fcode))
6558 tree arg = CALL_EXPR_ARG (arg0, 0);
6559 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6561 c = TREE_REAL_CST (arg1);
6562 if (REAL_VALUE_NEGATIVE (c))
6564 /* sqrt(x) < y is always false, if y is negative. */
6565 if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6566 return omit_one_operand (type, integer_zero_node, arg);
6568 /* sqrt(x) > y is always true, if y is negative and we
6569 don't care about NaNs, i.e. negative values of x. */
6570 if (code == NE_EXPR || !HONOR_NANS (mode))
6571 return omit_one_operand (type, integer_one_node, arg);
6573 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6574 return fold_build2 (GE_EXPR, type, arg,
6575 build_real (TREE_TYPE (arg), dconst0));
6577 else if (code == GT_EXPR || code == GE_EXPR)
6581 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6582 real_convert (&c2, mode, &c2);
6584 if (REAL_VALUE_ISINF (c2))
6586 /* sqrt(x) > y is x == +Inf, when y is very large. */
6587 if (HONOR_INFINITIES (mode))
6588 return fold_build2 (EQ_EXPR, type, arg,
6589 build_real (TREE_TYPE (arg), c2));
6591 /* sqrt(x) > y is always false, when y is very large
6592 and we don't care about infinities. */
6593 return omit_one_operand (type, integer_zero_node, arg);
6596 /* sqrt(x) > c is the same as x > c*c. */
6597 return fold_build2 (code, type, arg,
6598 build_real (TREE_TYPE (arg), c2));
6600 else if (code == LT_EXPR || code == LE_EXPR)
6604 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6605 real_convert (&c2, mode, &c2);
6607 if (REAL_VALUE_ISINF (c2))
6609 /* sqrt(x) < y is always true, when y is a very large
6610 value and we don't care about NaNs or Infinities. */
6611 if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6612 return omit_one_operand (type, integer_one_node, arg);
6614 /* sqrt(x) < y is x != +Inf when y is very large and we
6615 don't care about NaNs. */
6616 if (! HONOR_NANS (mode))
6617 return fold_build2 (NE_EXPR, type, arg,
6618 build_real (TREE_TYPE (arg), c2));
6620 /* sqrt(x) < y is x >= 0 when y is very large and we
6621 don't care about Infinities. */
6622 if (! HONOR_INFINITIES (mode))
6623 return fold_build2 (GE_EXPR, type, arg,
6624 build_real (TREE_TYPE (arg), dconst0));
6626 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6627 if (lang_hooks.decls.global_bindings_p () != 0
6628 || CONTAINS_PLACEHOLDER_P (arg))
6631 arg = save_expr (arg);
6632 return fold_build2 (TRUTH_ANDIF_EXPR, type,
6633 fold_build2 (GE_EXPR, type, arg,
6634 build_real (TREE_TYPE (arg),
6636 fold_build2 (NE_EXPR, type, arg,
6637 build_real (TREE_TYPE (arg),
6641 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6642 if (! HONOR_NANS (mode))
6643 return fold_build2 (code, type, arg,
6644 build_real (TREE_TYPE (arg), c2));
6646 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6647 if (lang_hooks.decls.global_bindings_p () == 0
6648 && ! CONTAINS_PLACEHOLDER_P (arg))
6650 arg = save_expr (arg);
6651 return fold_build2 (TRUTH_ANDIF_EXPR, type,
6652 fold_build2 (GE_EXPR, type, arg,
6653 build_real (TREE_TYPE (arg),
6655 fold_build2 (code, type, arg,
6656 build_real (TREE_TYPE (arg),
6665 /* Subroutine of fold() that optimizes comparisons against Infinities,
6666 either +Inf or -Inf.
6668 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6669 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6670 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6672 The function returns the constant folded tree if a simplification
6673 can be made, and NULL_TREE otherwise. */
6676 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6678 enum machine_mode mode;
6679 REAL_VALUE_TYPE max;
6683 mode = TYPE_MODE (TREE_TYPE (arg0));
6685 /* For negative infinity swap the sense of the comparison. */
6686 neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6688 code = swap_tree_comparison (code);
6693 /* x > +Inf is always false, if with ignore sNANs. */
6694 if (HONOR_SNANS (mode))
6696 return omit_one_operand (type, integer_zero_node, arg0);
6699 /* x <= +Inf is always true, if we don't case about NaNs. */
6700 if (! HONOR_NANS (mode))
6701 return omit_one_operand (type, integer_one_node, arg0);
6703 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6704 if (lang_hooks.decls.global_bindings_p () == 0
6705 && ! CONTAINS_PLACEHOLDER_P (arg0))
6707 arg0 = save_expr (arg0);
6708 return fold_build2 (EQ_EXPR, type, arg0, arg0);
6714 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6715 real_maxval (&max, neg, mode);
6716 return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6717 arg0, build_real (TREE_TYPE (arg0), max));
6720 /* x < +Inf is always equal to x <= DBL_MAX. */
6721 real_maxval (&max, neg, mode);
6722 return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6723 arg0, build_real (TREE_TYPE (arg0), max));
6726 /* x != +Inf is always equal to !(x > DBL_MAX). */
6727 real_maxval (&max, neg, mode);
6728 if (! HONOR_NANS (mode))
6729 return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6730 arg0, build_real (TREE_TYPE (arg0), max));
6732 temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6733 arg0, build_real (TREE_TYPE (arg0), max));
6734 return fold_build1 (TRUTH_NOT_EXPR, type, temp);
6743 /* Subroutine of fold() that optimizes comparisons of a division by
6744 a nonzero integer constant against an integer constant, i.e.
6747 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6748 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6749 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6751 The function returns the constant folded tree if a simplification
6752 can be made, and NULL_TREE otherwise. */
6755 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6757 tree prod, tmp, hi, lo;
6758 tree arg00 = TREE_OPERAND (arg0, 0);
6759 tree arg01 = TREE_OPERAND (arg0, 1);
6760 unsigned HOST_WIDE_INT lpart;
6761 HOST_WIDE_INT hpart;
6762 bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6766 /* We have to do this the hard way to detect unsigned overflow.
6767 prod = int_const_binop (MULT_EXPR, arg01, arg1, 0); */
6768 overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6769 TREE_INT_CST_HIGH (arg01),
6770 TREE_INT_CST_LOW (arg1),
6771 TREE_INT_CST_HIGH (arg1),
6772 &lpart, &hpart, unsigned_p);
6773 prod = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6775 neg_overflow = false;
6779 tmp = int_const_binop (MINUS_EXPR, arg01,
6780 build_int_cst (TREE_TYPE (arg01), 1), 0);
6783 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0). */
6784 overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6785 TREE_INT_CST_HIGH (prod),
6786 TREE_INT_CST_LOW (tmp),
6787 TREE_INT_CST_HIGH (tmp),
6788 &lpart, &hpart, unsigned_p);
6789 hi = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6790 -1, overflow | TREE_OVERFLOW (prod));
6792 else if (tree_int_cst_sgn (arg01) >= 0)
6794 tmp = int_const_binop (MINUS_EXPR, arg01,
6795 build_int_cst (TREE_TYPE (arg01), 1), 0);
6796 switch (tree_int_cst_sgn (arg1))
6799 neg_overflow = true;
6800 lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6805 lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6810 hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6820 /* A negative divisor reverses the relational operators. */
6821 code = swap_tree_comparison (code);
6823 tmp = int_const_binop (PLUS_EXPR, arg01,
6824 build_int_cst (TREE_TYPE (arg01), 1), 0);
6825 switch (tree_int_cst_sgn (arg1))
6828 hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6833 hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6838 neg_overflow = true;
6839 lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6851 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6852 return omit_one_operand (type, integer_zero_node, arg00);
6853 if (TREE_OVERFLOW (hi))
6854 return fold_build2 (GE_EXPR, type, arg00, lo);
6855 if (TREE_OVERFLOW (lo))
6856 return fold_build2 (LE_EXPR, type, arg00, hi);
6857 return build_range_check (type, arg00, 1, lo, hi);
6860 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6861 return omit_one_operand (type, integer_one_node, arg00);
6862 if (TREE_OVERFLOW (hi))
6863 return fold_build2 (LT_EXPR, type, arg00, lo);
6864 if (TREE_OVERFLOW (lo))
6865 return fold_build2 (GT_EXPR, type, arg00, hi);
6866 return build_range_check (type, arg00, 0, lo, hi);
6869 if (TREE_OVERFLOW (lo))
6871 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6872 return omit_one_operand (type, tmp, arg00);
6874 return fold_build2 (LT_EXPR, type, arg00, lo);
6877 if (TREE_OVERFLOW (hi))
6879 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6880 return omit_one_operand (type, tmp, arg00);
6882 return fold_build2 (LE_EXPR, type, arg00, hi);
6885 if (TREE_OVERFLOW (hi))
6887 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6888 return omit_one_operand (type, tmp, arg00);
6890 return fold_build2 (GT_EXPR, type, arg00, hi);
6893 if (TREE_OVERFLOW (lo))
6895 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6896 return omit_one_operand (type, tmp, arg00);
6898 return fold_build2 (GE_EXPR, type, arg00, lo);
6908 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6909 equality/inequality test, then return a simplified form of the test
6910 using a sign testing. Otherwise return NULL. TYPE is the desired
6914 fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
6917 /* If this is testing a single bit, we can optimize the test. */
6918 if ((code == NE_EXPR || code == EQ_EXPR)
6919 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6920 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6922 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6923 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6924 tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6926 if (arg00 != NULL_TREE
6927 /* This is only a win if casting to a signed type is cheap,
6928 i.e. when arg00's type is not a partial mode. */
6929 && TYPE_PRECISION (TREE_TYPE (arg00))
6930 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6932 tree stype = signed_type_for (TREE_TYPE (arg00));
6933 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6934 result_type, fold_convert (stype, arg00),
6935 build_int_cst (stype, 0));
6942 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6943 equality/inequality test, then return a simplified form of
6944 the test using shifts and logical operations. Otherwise return
6945 NULL. TYPE is the desired result type. */
6948 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
6951 /* If this is testing a single bit, we can optimize the test. */
6952 if ((code == NE_EXPR || code == EQ_EXPR)
6953 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6954 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6956 tree inner = TREE_OPERAND (arg0, 0);
6957 tree type = TREE_TYPE (arg0);
6958 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6959 enum machine_mode operand_mode = TYPE_MODE (type);
6961 tree signed_type, unsigned_type, intermediate_type;
6964 /* First, see if we can fold the single bit test into a sign-bit
6966 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6971 /* Otherwise we have (A & C) != 0 where C is a single bit,
6972 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6973 Similarly for (A & C) == 0. */
6975 /* If INNER is a right shift of a constant and it plus BITNUM does
6976 not overflow, adjust BITNUM and INNER. */
6977 if (TREE_CODE (inner) == RSHIFT_EXPR
6978 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6979 && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6980 && bitnum < TYPE_PRECISION (type)
6981 && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6982 bitnum - TYPE_PRECISION (type)))
6984 bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6985 inner = TREE_OPERAND (inner, 0);
6988 /* If we are going to be able to omit the AND below, we must do our
6989 operations as unsigned. If we must use the AND, we have a choice.
6990 Normally unsigned is faster, but for some machines signed is. */
6991 #ifdef LOAD_EXTEND_OP
6992 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6993 && !flag_syntax_only) ? 0 : 1;
6998 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6999 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
7000 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
7001 inner = fold_convert (intermediate_type, inner);
7004 inner = build2 (RSHIFT_EXPR, intermediate_type,
7005 inner, size_int (bitnum));
7007 one = build_int_cst (intermediate_type, 1);
7009 if (code == EQ_EXPR)
7010 inner = fold_build2 (BIT_XOR_EXPR, intermediate_type, inner, one);
7012 /* Put the AND last so it can combine with more things. */
7013 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
7015 /* Make sure to return the proper type. */
7016 inner = fold_convert (result_type, inner);
7023 /* Check whether we are allowed to reorder operands arg0 and arg1,
7024 such that the evaluation of arg1 occurs before arg0. */
7027 reorder_operands_p (const_tree arg0, const_tree arg1)
7029 if (! flag_evaluation_order)
7031 if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
7033 return ! TREE_SIDE_EFFECTS (arg0)
7034 && ! TREE_SIDE_EFFECTS (arg1);
7037 /* Test whether it is preferable two swap two operands, ARG0 and
7038 ARG1, for example because ARG0 is an integer constant and ARG1
7039 isn't. If REORDER is true, only recommend swapping if we can
7040 evaluate the operands in reverse order. */
7043 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
7045 STRIP_SIGN_NOPS (arg0);
7046 STRIP_SIGN_NOPS (arg1);
7048 if (TREE_CODE (arg1) == INTEGER_CST)
7050 if (TREE_CODE (arg0) == INTEGER_CST)
7053 if (TREE_CODE (arg1) == REAL_CST)
7055 if (TREE_CODE (arg0) == REAL_CST)
7058 if (TREE_CODE (arg1) == FIXED_CST)
7060 if (TREE_CODE (arg0) == FIXED_CST)
7063 if (TREE_CODE (arg1) == COMPLEX_CST)
7065 if (TREE_CODE (arg0) == COMPLEX_CST)
7068 if (TREE_CONSTANT (arg1))
7070 if (TREE_CONSTANT (arg0))
7073 if (optimize_function_for_size_p (cfun))
7076 if (reorder && flag_evaluation_order
7077 && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
7080 /* It is preferable to swap two SSA_NAME to ensure a canonical form
7081 for commutative and comparison operators. Ensuring a canonical
7082 form allows the optimizers to find additional redundancies without
7083 having to explicitly check for both orderings. */
7084 if (TREE_CODE (arg0) == SSA_NAME
7085 && TREE_CODE (arg1) == SSA_NAME
7086 && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
7089 /* Put SSA_NAMEs last. */
7090 if (TREE_CODE (arg1) == SSA_NAME)
7092 if (TREE_CODE (arg0) == SSA_NAME)
7095 /* Put variables last. */
7104 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
7105 ARG0 is extended to a wider type. */
7108 fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
7110 tree arg0_unw = get_unwidened (arg0, NULL_TREE);
7112 tree shorter_type, outer_type;
7116 if (arg0_unw == arg0)
7118 shorter_type = TREE_TYPE (arg0_unw);
7120 #ifdef HAVE_canonicalize_funcptr_for_compare
7121 /* Disable this optimization if we're casting a function pointer
7122 type on targets that require function pointer canonicalization. */
7123 if (HAVE_canonicalize_funcptr_for_compare
7124 && TREE_CODE (shorter_type) == POINTER_TYPE
7125 && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
7129 if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
7132 arg1_unw = get_unwidened (arg1, NULL_TREE);
7134 /* If possible, express the comparison in the shorter mode. */
7135 if ((code == EQ_EXPR || code == NE_EXPR
7136 || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
7137 && (TREE_TYPE (arg1_unw) == shorter_type
7138 || ((TYPE_PRECISION (shorter_type)
7139 >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
7140 && (TYPE_UNSIGNED (shorter_type)
7141 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
7142 || (TREE_CODE (arg1_unw) == INTEGER_CST
7143 && (TREE_CODE (shorter_type) == INTEGER_TYPE
7144 || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
7145 && int_fits_type_p (arg1_unw, shorter_type))))
7146 return fold_build2 (code, type, arg0_unw,
7147 fold_convert (shorter_type, arg1_unw));
7149 if (TREE_CODE (arg1_unw) != INTEGER_CST
7150 || TREE_CODE (shorter_type) != INTEGER_TYPE
7151 || !int_fits_type_p (arg1_unw, shorter_type))
7154 /* If we are comparing with the integer that does not fit into the range
7155 of the shorter type, the result is known. */
7156 outer_type = TREE_TYPE (arg1_unw);
7157 min = lower_bound_in_type (outer_type, shorter_type);
7158 max = upper_bound_in_type (outer_type, shorter_type);
7160 above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7162 below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7169 return omit_one_operand (type, integer_zero_node, arg0);
7174 return omit_one_operand (type, integer_one_node, arg0);
7180 return omit_one_operand (type, integer_one_node, arg0);
7182 return omit_one_operand (type, integer_zero_node, arg0);
7187 return omit_one_operand (type, integer_zero_node, arg0);
7189 return omit_one_operand (type, integer_one_node, arg0);
7198 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
7199 ARG0 just the signedness is changed. */
7202 fold_sign_changed_comparison (enum tree_code code, tree type,
7203 tree arg0, tree arg1)
7206 tree inner_type, outer_type;
7208 if (!CONVERT_EXPR_P (arg0))
7211 outer_type = TREE_TYPE (arg0);
7212 arg0_inner = TREE_OPERAND (arg0, 0);
7213 inner_type = TREE_TYPE (arg0_inner);
7215 #ifdef HAVE_canonicalize_funcptr_for_compare
7216 /* Disable this optimization if we're casting a function pointer
7217 type on targets that require function pointer canonicalization. */
7218 if (HAVE_canonicalize_funcptr_for_compare
7219 && TREE_CODE (inner_type) == POINTER_TYPE
7220 && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
7224 if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
7227 if (TREE_CODE (arg1) != INTEGER_CST
7228 && !(CONVERT_EXPR_P (arg1)
7229 && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
7232 if ((TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
7233 || POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
7238 if (TREE_CODE (arg1) == INTEGER_CST)
7239 arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
7240 TREE_INT_CST_HIGH (arg1), 0,
7241 TREE_OVERFLOW (arg1));
7243 arg1 = fold_convert (inner_type, arg1);
7245 return fold_build2 (code, type, arg0_inner, arg1);
7248 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
7249 step of the array. Reconstructs s and delta in the case of s * delta
7250 being an integer constant (and thus already folded).
7251 ADDR is the address. MULT is the multiplicative expression.
7252 If the function succeeds, the new address expression is returned. Otherwise
7253 NULL_TREE is returned. */
7256 try_move_mult_to_index (tree addr, tree op1)
7258 tree s, delta, step;
7259 tree ref = TREE_OPERAND (addr, 0), pref;
7264 /* Strip the nops that might be added when converting op1 to sizetype. */
7267 /* Canonicalize op1 into a possibly non-constant delta
7268 and an INTEGER_CST s. */
7269 if (TREE_CODE (op1) == MULT_EXPR)
7271 tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
7276 if (TREE_CODE (arg0) == INTEGER_CST)
7281 else if (TREE_CODE (arg1) == INTEGER_CST)
7289 else if (TREE_CODE (op1) == INTEGER_CST)
7296 /* Simulate we are delta * 1. */
7298 s = integer_one_node;
7301 for (;; ref = TREE_OPERAND (ref, 0))
7303 if (TREE_CODE (ref) == ARRAY_REF)
7305 /* Remember if this was a multi-dimensional array. */
7306 if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
7309 itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
7313 step = array_ref_element_size (ref);
7314 if (TREE_CODE (step) != INTEGER_CST)
7319 if (! tree_int_cst_equal (step, s))
7324 /* Try if delta is a multiple of step. */
7325 tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
7331 /* Only fold here if we can verify we do not overflow one
7332 dimension of a multi-dimensional array. */
7337 if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
7338 || !INTEGRAL_TYPE_P (itype)
7339 || !TYPE_MAX_VALUE (itype)
7340 || TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST)
7343 tmp = fold_binary (PLUS_EXPR, itype,
7344 fold_convert (itype,
7345 TREE_OPERAND (ref, 1)),
7346 fold_convert (itype, delta));
7348 || TREE_CODE (tmp) != INTEGER_CST
7349 || tree_int_cst_lt (TYPE_MAX_VALUE (itype), tmp))
7358 if (!handled_component_p (ref))
7362 /* We found the suitable array reference. So copy everything up to it,
7363 and replace the index. */
7365 pref = TREE_OPERAND (addr, 0);
7366 ret = copy_node (pref);
7371 pref = TREE_OPERAND (pref, 0);
7372 TREE_OPERAND (pos, 0) = copy_node (pref);
7373 pos = TREE_OPERAND (pos, 0);
7376 TREE_OPERAND (pos, 1) = fold_build2 (PLUS_EXPR, itype,
7377 fold_convert (itype,
7378 TREE_OPERAND (pos, 1)),
7379 fold_convert (itype, delta));
7381 return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
7385 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
7386 means A >= Y && A != MAX, but in this case we know that
7387 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
7390 fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
7392 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
7394 if (TREE_CODE (bound) == LT_EXPR)
7395 a = TREE_OPERAND (bound, 0);
7396 else if (TREE_CODE (bound) == GT_EXPR)
7397 a = TREE_OPERAND (bound, 1);
7401 typea = TREE_TYPE (a);
7402 if (!INTEGRAL_TYPE_P (typea)
7403 && !POINTER_TYPE_P (typea))
7406 if (TREE_CODE (ineq) == LT_EXPR)
7408 a1 = TREE_OPERAND (ineq, 1);
7409 y = TREE_OPERAND (ineq, 0);
7411 else if (TREE_CODE (ineq) == GT_EXPR)
7413 a1 = TREE_OPERAND (ineq, 0);
7414 y = TREE_OPERAND (ineq, 1);
7419 if (TREE_TYPE (a1) != typea)
7422 if (POINTER_TYPE_P (typea))
7424 /* Convert the pointer types into integer before taking the difference. */
7425 tree ta = fold_convert (ssizetype, a);
7426 tree ta1 = fold_convert (ssizetype, a1);
7427 diff = fold_binary (MINUS_EXPR, ssizetype, ta1, ta);
7430 diff = fold_binary (MINUS_EXPR, typea, a1, a);
7432 if (!diff || !integer_onep (diff))
7435 return fold_build2 (GE_EXPR, type, a, y);
7438 /* Fold a sum or difference of at least one multiplication.
7439 Returns the folded tree or NULL if no simplification could be made. */
7442 fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
7444 tree arg00, arg01, arg10, arg11;
7445 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7447 /* (A * C) +- (B * C) -> (A+-B) * C.
7448 (A * C) +- A -> A * (C+-1).
7449 We are most concerned about the case where C is a constant,
7450 but other combinations show up during loop reduction. Since
7451 it is not difficult, try all four possibilities. */
7453 if (TREE_CODE (arg0) == MULT_EXPR)
7455 arg00 = TREE_OPERAND (arg0, 0);
7456 arg01 = TREE_OPERAND (arg0, 1);
7458 else if (TREE_CODE (arg0) == INTEGER_CST)
7460 arg00 = build_one_cst (type);
7465 /* We cannot generate constant 1 for fract. */
7466 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7469 arg01 = build_one_cst (type);
7471 if (TREE_CODE (arg1) == MULT_EXPR)
7473 arg10 = TREE_OPERAND (arg1, 0);
7474 arg11 = TREE_OPERAND (arg1, 1);
7476 else if (TREE_CODE (arg1) == INTEGER_CST)
7478 arg10 = build_one_cst (type);
7479 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7480 the purpose of this canonicalization. */
7481 if (TREE_INT_CST_HIGH (arg1) == -1
7482 && negate_expr_p (arg1)
7483 && code == PLUS_EXPR)
7485 arg11 = negate_expr (arg1);
7493 /* We cannot generate constant 1 for fract. */
7494 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7497 arg11 = build_one_cst (type);
7501 if (operand_equal_p (arg01, arg11, 0))
7502 same = arg01, alt0 = arg00, alt1 = arg10;
7503 else if (operand_equal_p (arg00, arg10, 0))
7504 same = arg00, alt0 = arg01, alt1 = arg11;
7505 else if (operand_equal_p (arg00, arg11, 0))
7506 same = arg00, alt0 = arg01, alt1 = arg10;
7507 else if (operand_equal_p (arg01, arg10, 0))
7508 same = arg01, alt0 = arg00, alt1 = arg11;
7510 /* No identical multiplicands; see if we can find a common
7511 power-of-two factor in non-power-of-two multiplies. This
7512 can help in multi-dimensional array access. */
7513 else if (host_integerp (arg01, 0)
7514 && host_integerp (arg11, 0))
7516 HOST_WIDE_INT int01, int11, tmp;
7519 int01 = TREE_INT_CST_LOW (arg01);
7520 int11 = TREE_INT_CST_LOW (arg11);
7522 /* Move min of absolute values to int11. */
7523 if ((int01 >= 0 ? int01 : -int01)
7524 < (int11 >= 0 ? int11 : -int11))
7526 tmp = int01, int01 = int11, int11 = tmp;
7527 alt0 = arg00, arg00 = arg10, arg10 = alt0;
7534 if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0
7535 /* The remainder should not be a constant, otherwise we
7536 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7537 increased the number of multiplications necessary. */
7538 && TREE_CODE (arg10) != INTEGER_CST)
7540 alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
7541 build_int_cst (TREE_TYPE (arg00),
7546 maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7551 return fold_build2 (MULT_EXPR, type,
7552 fold_build2 (code, type,
7553 fold_convert (type, alt0),
7554 fold_convert (type, alt1)),
7555 fold_convert (type, same));
7560 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7561 specified by EXPR into the buffer PTR of length LEN bytes.
7562 Return the number of bytes placed in the buffer, or zero
7566 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7568 tree type = TREE_TYPE (expr);
7569 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7570 int byte, offset, word, words;
7571 unsigned char value;
7573 if (total_bytes > len)
7575 words = total_bytes / UNITS_PER_WORD;
7577 for (byte = 0; byte < total_bytes; byte++)
7579 int bitpos = byte * BITS_PER_UNIT;
7580 if (bitpos < HOST_BITS_PER_WIDE_INT)
7581 value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7583 value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7584 >> (bitpos - HOST_BITS_PER_WIDE_INT));
7586 if (total_bytes > UNITS_PER_WORD)
7588 word = byte / UNITS_PER_WORD;
7589 if (WORDS_BIG_ENDIAN)
7590 word = (words - 1) - word;
7591 offset = word * UNITS_PER_WORD;
7592 if (BYTES_BIG_ENDIAN)
7593 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7595 offset += byte % UNITS_PER_WORD;
7598 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7599 ptr[offset] = value;
7605 /* Subroutine of native_encode_expr. Encode the REAL_CST
7606 specified by EXPR into the buffer PTR of length LEN bytes.
7607 Return the number of bytes placed in the buffer, or zero
7611 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7613 tree type = TREE_TYPE (expr);
7614 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7615 int byte, offset, word, words, bitpos;
7616 unsigned char value;
7618 /* There are always 32 bits in each long, no matter the size of
7619 the hosts long. We handle floating point representations with
7623 if (total_bytes > len)
7625 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7627 real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7629 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7630 bitpos += BITS_PER_UNIT)
7632 byte = (bitpos / BITS_PER_UNIT) & 3;
7633 value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7635 if (UNITS_PER_WORD < 4)
7637 word = byte / UNITS_PER_WORD;
7638 if (WORDS_BIG_ENDIAN)
7639 word = (words - 1) - word;
7640 offset = word * UNITS_PER_WORD;
7641 if (BYTES_BIG_ENDIAN)
7642 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7644 offset += byte % UNITS_PER_WORD;
7647 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7648 ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7653 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7654 specified by EXPR into the buffer PTR of length LEN bytes.
7655 Return the number of bytes placed in the buffer, or zero
7659 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7664 part = TREE_REALPART (expr);
7665 rsize = native_encode_expr (part, ptr, len);
7668 part = TREE_IMAGPART (expr);
7669 isize = native_encode_expr (part, ptr+rsize, len-rsize);
7672 return rsize + isize;
7676 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7677 specified by EXPR into the buffer PTR of length LEN bytes.
7678 Return the number of bytes placed in the buffer, or zero
7682 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7684 int i, size, offset, count;
7685 tree itype, elem, elements;
7688 elements = TREE_VECTOR_CST_ELTS (expr);
7689 count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7690 itype = TREE_TYPE (TREE_TYPE (expr));
7691 size = GET_MODE_SIZE (TYPE_MODE (itype));
7692 for (i = 0; i < count; i++)
7696 elem = TREE_VALUE (elements);
7697 elements = TREE_CHAIN (elements);
7704 if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7709 if (offset + size > len)
7711 memset (ptr+offset, 0, size);
7719 /* Subroutine of native_encode_expr. Encode the STRING_CST
7720 specified by EXPR into the buffer PTR of length LEN bytes.
7721 Return the number of bytes placed in the buffer, or zero
7725 native_encode_string (const_tree expr, unsigned char *ptr, int len)
7727 tree type = TREE_TYPE (expr);
7728 HOST_WIDE_INT total_bytes;
7730 if (TREE_CODE (type) != ARRAY_TYPE
7731 || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7732 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7733 || !host_integerp (TYPE_SIZE_UNIT (type), 0))
7735 total_bytes = tree_low_cst (TYPE_SIZE_UNIT (type), 0);
7736 if (total_bytes > len)
7738 if (TREE_STRING_LENGTH (expr) < total_bytes)
7740 memcpy (ptr, TREE_STRING_POINTER (expr), TREE_STRING_LENGTH (expr));
7741 memset (ptr + TREE_STRING_LENGTH (expr), 0,
7742 total_bytes - TREE_STRING_LENGTH (expr));
7745 memcpy (ptr, TREE_STRING_POINTER (expr), total_bytes);
7750 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7751 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7752 buffer PTR of length LEN bytes. Return the number of bytes
7753 placed in the buffer, or zero upon failure. */
7756 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7758 switch (TREE_CODE (expr))
7761 return native_encode_int (expr, ptr, len);
7764 return native_encode_real (expr, ptr, len);
7767 return native_encode_complex (expr, ptr, len);
7770 return native_encode_vector (expr, ptr, len);
7773 return native_encode_string (expr, ptr, len);
7781 /* Subroutine of native_interpret_expr. Interpret the contents of
7782 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7783 If the buffer cannot be interpreted, return NULL_TREE. */
7786 native_interpret_int (tree type, const unsigned char *ptr, int len)
7788 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7789 int byte, offset, word, words;
7790 unsigned char value;
7791 unsigned int HOST_WIDE_INT lo = 0;
7792 HOST_WIDE_INT hi = 0;
7794 if (total_bytes > len)
7796 if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7798 words = total_bytes / UNITS_PER_WORD;
7800 for (byte = 0; byte < total_bytes; byte++)
7802 int bitpos = byte * BITS_PER_UNIT;
7803 if (total_bytes > UNITS_PER_WORD)
7805 word = byte / UNITS_PER_WORD;
7806 if (WORDS_BIG_ENDIAN)
7807 word = (words - 1) - word;
7808 offset = word * UNITS_PER_WORD;
7809 if (BYTES_BIG_ENDIAN)
7810 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7812 offset += byte % UNITS_PER_WORD;
7815 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7816 value = ptr[offset];
7818 if (bitpos < HOST_BITS_PER_WIDE_INT)
7819 lo |= (unsigned HOST_WIDE_INT) value << bitpos;
7821 hi |= (unsigned HOST_WIDE_INT) value
7822 << (bitpos - HOST_BITS_PER_WIDE_INT);
7825 return build_int_cst_wide_type (type, lo, hi);
7829 /* Subroutine of native_interpret_expr. Interpret the contents of
7830 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7831 If the buffer cannot be interpreted, return NULL_TREE. */
7834 native_interpret_real (tree type, const unsigned char *ptr, int len)
7836 enum machine_mode mode = TYPE_MODE (type);
7837 int total_bytes = GET_MODE_SIZE (mode);
7838 int byte, offset, word, words, bitpos;
7839 unsigned char value;
7840 /* There are always 32 bits in each long, no matter the size of
7841 the hosts long. We handle floating point representations with
7846 total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7847 if (total_bytes > len || total_bytes > 24)
7849 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7851 memset (tmp, 0, sizeof (tmp));
7852 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7853 bitpos += BITS_PER_UNIT)
7855 byte = (bitpos / BITS_PER_UNIT) & 3;
7856 if (UNITS_PER_WORD < 4)
7858 word = byte / UNITS_PER_WORD;
7859 if (WORDS_BIG_ENDIAN)
7860 word = (words - 1) - word;
7861 offset = word * UNITS_PER_WORD;
7862 if (BYTES_BIG_ENDIAN)
7863 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7865 offset += byte % UNITS_PER_WORD;
7868 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7869 value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7871 tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7874 real_from_target (&r, tmp, mode);
7875 return build_real (type, r);
7879 /* Subroutine of native_interpret_expr. Interpret the contents of
7880 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7881 If the buffer cannot be interpreted, return NULL_TREE. */
7884 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7886 tree etype, rpart, ipart;
7889 etype = TREE_TYPE (type);
7890 size = GET_MODE_SIZE (TYPE_MODE (etype));
7893 rpart = native_interpret_expr (etype, ptr, size);
7896 ipart = native_interpret_expr (etype, ptr+size, size);
7899 return build_complex (type, rpart, ipart);
7903 /* Subroutine of native_interpret_expr. Interpret the contents of
7904 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7905 If the buffer cannot be interpreted, return NULL_TREE. */
7908 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7910 tree etype, elem, elements;
7913 etype = TREE_TYPE (type);
7914 size = GET_MODE_SIZE (TYPE_MODE (etype));
7915 count = TYPE_VECTOR_SUBPARTS (type);
7916 if (size * count > len)
7919 elements = NULL_TREE;
7920 for (i = count - 1; i >= 0; i--)
7922 elem = native_interpret_expr (etype, ptr+(i*size), size);
7925 elements = tree_cons (NULL_TREE, elem, elements);
7927 return build_vector (type, elements);
7931 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7932 the buffer PTR of length LEN as a constant of type TYPE. For
7933 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7934 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7935 return NULL_TREE. */
7938 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7940 switch (TREE_CODE (type))
7945 return native_interpret_int (type, ptr, len);
7948 return native_interpret_real (type, ptr, len);
7951 return native_interpret_complex (type, ptr, len);
7954 return native_interpret_vector (type, ptr, len);
7962 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7963 TYPE at compile-time. If we're unable to perform the conversion
7964 return NULL_TREE. */
7967 fold_view_convert_expr (tree type, tree expr)
7969 /* We support up to 512-bit values (for V8DFmode). */
7970 unsigned char buffer[64];
7973 /* Check that the host and target are sane. */
7974 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7977 len = native_encode_expr (expr, buffer, sizeof (buffer));
7981 return native_interpret_expr (type, buffer, len);
7984 /* Build an expression for the address of T. Folds away INDIRECT_REF
7985 to avoid confusing the gimplify process. */
7988 build_fold_addr_expr_with_type (tree t, tree ptrtype)
7990 /* The size of the object is not relevant when talking about its address. */
7991 if (TREE_CODE (t) == WITH_SIZE_EXPR)
7992 t = TREE_OPERAND (t, 0);
7994 /* Note: doesn't apply to ALIGN_INDIRECT_REF */
7995 if (TREE_CODE (t) == INDIRECT_REF
7996 || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
7998 t = TREE_OPERAND (t, 0);
8000 if (TREE_TYPE (t) != ptrtype)
8001 t = build1 (NOP_EXPR, ptrtype, t);
8003 else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
8005 t = build_fold_addr_expr (TREE_OPERAND (t, 0));
8007 if (TREE_TYPE (t) != ptrtype)
8008 t = fold_convert (ptrtype, t);
8011 t = build1 (ADDR_EXPR, ptrtype, t);
8016 /* Build an expression for the address of T. */
8019 build_fold_addr_expr (tree t)
8021 tree ptrtype = build_pointer_type (TREE_TYPE (t));
8023 return build_fold_addr_expr_with_type (t, ptrtype);
8026 /* Fold a unary expression of code CODE and type TYPE with operand
8027 OP0. Return the folded expression if folding is successful.
8028 Otherwise, return NULL_TREE. */
8031 fold_unary (enum tree_code code, tree type, tree op0)
8035 enum tree_code_class kind = TREE_CODE_CLASS (code);
8037 gcc_assert (IS_EXPR_CODE_CLASS (kind)
8038 && TREE_CODE_LENGTH (code) == 1);
8043 if (CONVERT_EXPR_CODE_P (code)
8044 || code == FLOAT_EXPR || code == ABS_EXPR)
8046 /* Don't use STRIP_NOPS, because signedness of argument type
8048 STRIP_SIGN_NOPS (arg0);
8052 /* Strip any conversions that don't change the mode. This
8053 is safe for every expression, except for a comparison
8054 expression because its signedness is derived from its
8057 Note that this is done as an internal manipulation within
8058 the constant folder, in order to find the simplest
8059 representation of the arguments so that their form can be
8060 studied. In any cases, the appropriate type conversions
8061 should be put back in the tree that will get out of the
8067 if (TREE_CODE_CLASS (code) == tcc_unary)
8069 if (TREE_CODE (arg0) == COMPOUND_EXPR)
8070 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
8071 fold_build1 (code, type,
8072 fold_convert (TREE_TYPE (op0),
8073 TREE_OPERAND (arg0, 1))));
8074 else if (TREE_CODE (arg0) == COND_EXPR)
8076 tree arg01 = TREE_OPERAND (arg0, 1);
8077 tree arg02 = TREE_OPERAND (arg0, 2);
8078 if (! VOID_TYPE_P (TREE_TYPE (arg01)))
8079 arg01 = fold_build1 (code, type,
8080 fold_convert (TREE_TYPE (op0), arg01));
8081 if (! VOID_TYPE_P (TREE_TYPE (arg02)))
8082 arg02 = fold_build1 (code, type,
8083 fold_convert (TREE_TYPE (op0), arg02));
8084 tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
8087 /* If this was a conversion, and all we did was to move into
8088 inside the COND_EXPR, bring it back out. But leave it if
8089 it is a conversion from integer to integer and the
8090 result precision is no wider than a word since such a
8091 conversion is cheap and may be optimized away by combine,
8092 while it couldn't if it were outside the COND_EXPR. Then return
8093 so we don't get into an infinite recursion loop taking the
8094 conversion out and then back in. */
8096 if ((CONVERT_EXPR_CODE_P (code)
8097 || code == NON_LVALUE_EXPR)
8098 && TREE_CODE (tem) == COND_EXPR
8099 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
8100 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
8101 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
8102 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
8103 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
8104 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
8105 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8107 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
8108 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
8109 || flag_syntax_only))
8110 tem = build1 (code, type,
8112 TREE_TYPE (TREE_OPERAND
8113 (TREE_OPERAND (tem, 1), 0)),
8114 TREE_OPERAND (tem, 0),
8115 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
8116 TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
8119 else if (COMPARISON_CLASS_P (arg0))
8121 if (TREE_CODE (type) == BOOLEAN_TYPE)
8123 arg0 = copy_node (arg0);
8124 TREE_TYPE (arg0) = type;
8127 else if (TREE_CODE (type) != INTEGER_TYPE)
8128 return fold_build3 (COND_EXPR, type, arg0,
8129 fold_build1 (code, type,
8131 fold_build1 (code, type,
8132 integer_zero_node));
8139 /* Re-association barriers around constants and other re-association
8140 barriers can be removed. */
8141 if (CONSTANT_CLASS_P (op0)
8142 || TREE_CODE (op0) == PAREN_EXPR)
8143 return fold_convert (type, op0);
8148 case FIX_TRUNC_EXPR:
8149 if (TREE_TYPE (op0) == type)
8152 /* If we have (type) (a CMP b) and type is an integral type, return
8153 new expression involving the new type. */
8154 if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
8155 return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
8156 TREE_OPERAND (op0, 1));
8158 /* Handle cases of two conversions in a row. */
8159 if (CONVERT_EXPR_P (op0))
8161 tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
8162 tree inter_type = TREE_TYPE (op0);
8163 int inside_int = INTEGRAL_TYPE_P (inside_type);
8164 int inside_ptr = POINTER_TYPE_P (inside_type);
8165 int inside_float = FLOAT_TYPE_P (inside_type);
8166 int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
8167 unsigned int inside_prec = TYPE_PRECISION (inside_type);
8168 int inside_unsignedp = TYPE_UNSIGNED (inside_type);
8169 int inter_int = INTEGRAL_TYPE_P (inter_type);
8170 int inter_ptr = POINTER_TYPE_P (inter_type);
8171 int inter_float = FLOAT_TYPE_P (inter_type);
8172 int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
8173 unsigned int inter_prec = TYPE_PRECISION (inter_type);
8174 int inter_unsignedp = TYPE_UNSIGNED (inter_type);
8175 int final_int = INTEGRAL_TYPE_P (type);
8176 int final_ptr = POINTER_TYPE_P (type);
8177 int final_float = FLOAT_TYPE_P (type);
8178 int final_vec = TREE_CODE (type) == VECTOR_TYPE;
8179 unsigned int final_prec = TYPE_PRECISION (type);
8180 int final_unsignedp = TYPE_UNSIGNED (type);
8182 /* In addition to the cases of two conversions in a row
8183 handled below, if we are converting something to its own
8184 type via an object of identical or wider precision, neither
8185 conversion is needed. */
8186 if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
8187 && (((inter_int || inter_ptr) && final_int)
8188 || (inter_float && final_float))
8189 && inter_prec >= final_prec)
8190 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8192 /* Likewise, if the intermediate and initial types are either both
8193 float or both integer, we don't need the middle conversion if the
8194 former is wider than the latter and doesn't change the signedness
8195 (for integers). Avoid this if the final type is a pointer since
8196 then we sometimes need the middle conversion. Likewise if the
8197 final type has a precision not equal to the size of its mode. */
8198 if (((inter_int && inside_int)
8199 || (inter_float && inside_float)
8200 || (inter_vec && inside_vec))
8201 && inter_prec >= inside_prec
8202 && (inter_float || inter_vec
8203 || inter_unsignedp == inside_unsignedp)
8204 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8205 && TYPE_MODE (type) == TYPE_MODE (inter_type))
8207 && (! final_vec || inter_prec == inside_prec))
8208 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8210 /* If we have a sign-extension of a zero-extended value, we can
8211 replace that by a single zero-extension. */
8212 if (inside_int && inter_int && final_int
8213 && inside_prec < inter_prec && inter_prec < final_prec
8214 && inside_unsignedp && !inter_unsignedp)
8215 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8217 /* Two conversions in a row are not needed unless:
8218 - some conversion is floating-point (overstrict for now), or
8219 - some conversion is a vector (overstrict for now), or
8220 - the intermediate type is narrower than both initial and
8222 - the intermediate type and innermost type differ in signedness,
8223 and the outermost type is wider than the intermediate, or
8224 - the initial type is a pointer type and the precisions of the
8225 intermediate and final types differ, or
8226 - the final type is a pointer type and the precisions of the
8227 initial and intermediate types differ. */
8228 if (! inside_float && ! inter_float && ! final_float
8229 && ! inside_vec && ! inter_vec && ! final_vec
8230 && (inter_prec >= inside_prec || inter_prec >= final_prec)
8231 && ! (inside_int && inter_int
8232 && inter_unsignedp != inside_unsignedp
8233 && inter_prec < final_prec)
8234 && ((inter_unsignedp && inter_prec > inside_prec)
8235 == (final_unsignedp && final_prec > inter_prec))
8236 && ! (inside_ptr && inter_prec != final_prec)
8237 && ! (final_ptr && inside_prec != inter_prec)
8238 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8239 && TYPE_MODE (type) == TYPE_MODE (inter_type)))
8240 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8243 /* Handle (T *)&A.B.C for A being of type T and B and C
8244 living at offset zero. This occurs frequently in
8245 C++ upcasting and then accessing the base. */
8246 if (TREE_CODE (op0) == ADDR_EXPR
8247 && POINTER_TYPE_P (type)
8248 && handled_component_p (TREE_OPERAND (op0, 0)))
8250 HOST_WIDE_INT bitsize, bitpos;
8252 enum machine_mode mode;
8253 int unsignedp, volatilep;
8254 tree base = TREE_OPERAND (op0, 0);
8255 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
8256 &mode, &unsignedp, &volatilep, false);
8257 /* If the reference was to a (constant) zero offset, we can use
8258 the address of the base if it has the same base type
8259 as the result type. */
8260 if (! offset && bitpos == 0
8261 && TYPE_MAIN_VARIANT (TREE_TYPE (type))
8262 == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
8263 return fold_convert (type, build_fold_addr_expr (base));
8266 if (TREE_CODE (op0) == MODIFY_EXPR
8267 && TREE_CONSTANT (TREE_OPERAND (op0, 1))
8268 /* Detect assigning a bitfield. */
8269 && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
8271 (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
8273 /* Don't leave an assignment inside a conversion
8274 unless assigning a bitfield. */
8275 tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
8276 /* First do the assignment, then return converted constant. */
8277 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
8278 TREE_NO_WARNING (tem) = 1;
8279 TREE_USED (tem) = 1;
8283 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
8284 constants (if x has signed type, the sign bit cannot be set
8285 in c). This folds extension into the BIT_AND_EXPR.
8286 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
8287 very likely don't have maximal range for their precision and this
8288 transformation effectively doesn't preserve non-maximal ranges. */
8289 if (TREE_CODE (type) == INTEGER_TYPE
8290 && TREE_CODE (op0) == BIT_AND_EXPR
8291 && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
8294 tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
8297 if (TYPE_UNSIGNED (TREE_TYPE (and))
8298 || (TYPE_PRECISION (type)
8299 <= TYPE_PRECISION (TREE_TYPE (and))))
8301 else if (TYPE_PRECISION (TREE_TYPE (and1))
8302 <= HOST_BITS_PER_WIDE_INT
8303 && host_integerp (and1, 1))
8305 unsigned HOST_WIDE_INT cst;
8307 cst = tree_low_cst (and1, 1);
8308 cst &= (HOST_WIDE_INT) -1
8309 << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
8310 change = (cst == 0);
8311 #ifdef LOAD_EXTEND_OP
8313 && !flag_syntax_only
8314 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
8317 tree uns = unsigned_type_for (TREE_TYPE (and0));
8318 and0 = fold_convert (uns, and0);
8319 and1 = fold_convert (uns, and1);
8325 tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
8326 TREE_INT_CST_HIGH (and1), 0,
8327 TREE_OVERFLOW (and1));
8328 return fold_build2 (BIT_AND_EXPR, type,
8329 fold_convert (type, and0), tem);
8333 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
8334 when one of the new casts will fold away. Conservatively we assume
8335 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
8336 if (POINTER_TYPE_P (type)
8337 && TREE_CODE (arg0) == POINTER_PLUS_EXPR
8338 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8339 || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
8340 || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
8342 tree arg00 = TREE_OPERAND (arg0, 0);
8343 tree arg01 = TREE_OPERAND (arg0, 1);
8345 return fold_build2 (TREE_CODE (arg0), type, fold_convert (type, arg00),
8346 fold_convert (sizetype, arg01));
8349 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
8350 of the same precision, and X is an integer type not narrower than
8351 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
8352 if (INTEGRAL_TYPE_P (type)
8353 && TREE_CODE (op0) == BIT_NOT_EXPR
8354 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8355 && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
8356 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8358 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
8359 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8360 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
8361 return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
8364 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
8365 type of X and Y (integer types only). */
8366 if (INTEGRAL_TYPE_P (type)
8367 && TREE_CODE (op0) == MULT_EXPR
8368 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8369 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
8371 /* Be careful not to introduce new overflows. */
8373 if (TYPE_OVERFLOW_WRAPS (type))
8376 mult_type = unsigned_type_for (type);
8378 if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
8380 tem = fold_build2 (MULT_EXPR, mult_type,
8381 fold_convert (mult_type,
8382 TREE_OPERAND (op0, 0)),
8383 fold_convert (mult_type,
8384 TREE_OPERAND (op0, 1)));
8385 return fold_convert (type, tem);
8389 tem = fold_convert_const (code, type, op0);
8390 return tem ? tem : NULL_TREE;
8392 case FIXED_CONVERT_EXPR:
8393 tem = fold_convert_const (code, type, arg0);
8394 return tem ? tem : NULL_TREE;
8396 case VIEW_CONVERT_EXPR:
8397 if (TREE_TYPE (op0) == type)
8399 if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
8400 return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
8402 /* For integral conversions with the same precision or pointer
8403 conversions use a NOP_EXPR instead. */
8404 if ((INTEGRAL_TYPE_P (type)
8405 || POINTER_TYPE_P (type))
8406 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8407 || POINTER_TYPE_P (TREE_TYPE (op0)))
8408 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8409 return fold_convert (type, op0);
8411 /* Strip inner integral conversions that do not change the precision. */
8412 if (CONVERT_EXPR_P (op0)
8413 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8414 || POINTER_TYPE_P (TREE_TYPE (op0)))
8415 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
8416 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
8417 && (TYPE_PRECISION (TREE_TYPE (op0))
8418 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
8419 return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
8421 return fold_view_convert_expr (type, op0);
8424 tem = fold_negate_expr (arg0);
8426 return fold_convert (type, tem);
8430 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
8431 return fold_abs_const (arg0, type);
8432 else if (TREE_CODE (arg0) == NEGATE_EXPR)
8433 return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8434 /* Convert fabs((double)float) into (double)fabsf(float). */
8435 else if (TREE_CODE (arg0) == NOP_EXPR
8436 && TREE_CODE (type) == REAL_TYPE)
8438 tree targ0 = strip_float_extensions (arg0);
8440 return fold_convert (type, fold_build1 (ABS_EXPR,
8444 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
8445 else if (TREE_CODE (arg0) == ABS_EXPR)
8447 else if (tree_expr_nonnegative_p (arg0))
8450 /* Strip sign ops from argument. */
8451 if (TREE_CODE (type) == REAL_TYPE)
8453 tem = fold_strip_sign_ops (arg0);
8455 return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
8460 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8461 return fold_convert (type, arg0);
8462 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8464 tree itype = TREE_TYPE (type);
8465 tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
8466 tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
8467 return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
8469 if (TREE_CODE (arg0) == COMPLEX_CST)
8471 tree itype = TREE_TYPE (type);
8472 tree rpart = fold_convert (itype, TREE_REALPART (arg0));
8473 tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
8474 return build_complex (type, rpart, negate_expr (ipart));
8476 if (TREE_CODE (arg0) == CONJ_EXPR)
8477 return fold_convert (type, TREE_OPERAND (arg0, 0));
8481 if (TREE_CODE (arg0) == INTEGER_CST)
8482 return fold_not_const (arg0, type);
8483 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8484 return fold_convert (type, TREE_OPERAND (arg0, 0));
8485 /* Convert ~ (-A) to A - 1. */
8486 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8487 return fold_build2 (MINUS_EXPR, type,
8488 fold_convert (type, TREE_OPERAND (arg0, 0)),
8489 build_int_cst (type, 1));
8490 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8491 else if (INTEGRAL_TYPE_P (type)
8492 && ((TREE_CODE (arg0) == MINUS_EXPR
8493 && integer_onep (TREE_OPERAND (arg0, 1)))
8494 || (TREE_CODE (arg0) == PLUS_EXPR
8495 && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8496 return fold_build1 (NEGATE_EXPR, type,
8497 fold_convert (type, TREE_OPERAND (arg0, 0)));
8498 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8499 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8500 && (tem = fold_unary (BIT_NOT_EXPR, type,
8502 TREE_OPERAND (arg0, 0)))))
8503 return fold_build2 (BIT_XOR_EXPR, type, tem,
8504 fold_convert (type, TREE_OPERAND (arg0, 1)));
8505 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8506 && (tem = fold_unary (BIT_NOT_EXPR, type,
8508 TREE_OPERAND (arg0, 1)))))
8509 return fold_build2 (BIT_XOR_EXPR, type,
8510 fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
8511 /* Perform BIT_NOT_EXPR on each element individually. */
8512 else if (TREE_CODE (arg0) == VECTOR_CST)
8514 tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
8515 int count = TYPE_VECTOR_SUBPARTS (type), i;
8517 for (i = 0; i < count; i++)
8521 elem = TREE_VALUE (elements);
8522 elem = fold_unary (BIT_NOT_EXPR, TREE_TYPE (type), elem);
8523 if (elem == NULL_TREE)
8525 elements = TREE_CHAIN (elements);
8528 elem = build_int_cst (TREE_TYPE (type), -1);
8529 list = tree_cons (NULL_TREE, elem, list);
8532 return build_vector (type, nreverse (list));
8537 case TRUTH_NOT_EXPR:
8538 /* The argument to invert_truthvalue must have Boolean type. */
8539 if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8540 arg0 = fold_convert (boolean_type_node, arg0);
8542 /* Note that the operand of this must be an int
8543 and its values must be 0 or 1.
8544 ("true" is a fixed value perhaps depending on the language,
8545 but we don't handle values other than 1 correctly yet.) */
8546 tem = fold_truth_not_expr (arg0);
8549 return fold_convert (type, tem);
8552 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8553 return fold_convert (type, arg0);
8554 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8555 return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8556 TREE_OPERAND (arg0, 1));
8557 if (TREE_CODE (arg0) == COMPLEX_CST)
8558 return fold_convert (type, TREE_REALPART (arg0));
8559 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8561 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8562 tem = fold_build2 (TREE_CODE (arg0), itype,
8563 fold_build1 (REALPART_EXPR, itype,
8564 TREE_OPERAND (arg0, 0)),
8565 fold_build1 (REALPART_EXPR, itype,
8566 TREE_OPERAND (arg0, 1)));
8567 return fold_convert (type, tem);
8569 if (TREE_CODE (arg0) == CONJ_EXPR)
8571 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8572 tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8573 return fold_convert (type, tem);
8575 if (TREE_CODE (arg0) == CALL_EXPR)
8577 tree fn = get_callee_fndecl (arg0);
8578 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8579 switch (DECL_FUNCTION_CODE (fn))
8581 CASE_FLT_FN (BUILT_IN_CEXPI):
8582 fn = mathfn_built_in (type, BUILT_IN_COS);
8584 return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8594 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8595 return fold_convert (type, integer_zero_node);
8596 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8597 return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8598 TREE_OPERAND (arg0, 0));
8599 if (TREE_CODE (arg0) == COMPLEX_CST)
8600 return fold_convert (type, TREE_IMAGPART (arg0));
8601 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8603 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8604 tem = fold_build2 (TREE_CODE (arg0), itype,
8605 fold_build1 (IMAGPART_EXPR, itype,
8606 TREE_OPERAND (arg0, 0)),
8607 fold_build1 (IMAGPART_EXPR, itype,
8608 TREE_OPERAND (arg0, 1)));
8609 return fold_convert (type, tem);
8611 if (TREE_CODE (arg0) == CONJ_EXPR)
8613 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8614 tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8615 return fold_convert (type, negate_expr (tem));
8617 if (TREE_CODE (arg0) == CALL_EXPR)
8619 tree fn = get_callee_fndecl (arg0);
8620 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8621 switch (DECL_FUNCTION_CODE (fn))
8623 CASE_FLT_FN (BUILT_IN_CEXPI):
8624 fn = mathfn_built_in (type, BUILT_IN_SIN);
8626 return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8637 } /* switch (code) */
8641 /* If the operation was a conversion do _not_ mark a resulting constant
8642 with TREE_OVERFLOW if the original constant was not. These conversions
8643 have implementation defined behavior and retaining the TREE_OVERFLOW
8644 flag here would confuse later passes such as VRP. */
8646 fold_unary_ignore_overflow (enum tree_code code, tree type, tree op0)
8648 tree res = fold_unary (code, type, op0);
8650 && TREE_CODE (res) == INTEGER_CST
8651 && TREE_CODE (op0) == INTEGER_CST
8652 && CONVERT_EXPR_CODE_P (code))
8653 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8658 /* Fold a binary expression of code CODE and type TYPE with operands
8659 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8660 Return the folded expression if folding is successful. Otherwise,
8661 return NULL_TREE. */
8664 fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
8666 enum tree_code compl_code;
8668 if (code == MIN_EXPR)
8669 compl_code = MAX_EXPR;
8670 else if (code == MAX_EXPR)
8671 compl_code = MIN_EXPR;
8675 /* MIN (MAX (a, b), b) == b. */
8676 if (TREE_CODE (op0) == compl_code
8677 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8678 return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
8680 /* MIN (MAX (b, a), b) == b. */
8681 if (TREE_CODE (op0) == compl_code
8682 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8683 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8684 return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
8686 /* MIN (a, MAX (a, b)) == a. */
8687 if (TREE_CODE (op1) == compl_code
8688 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8689 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8690 return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
8692 /* MIN (a, MAX (b, a)) == a. */
8693 if (TREE_CODE (op1) == compl_code
8694 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8695 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8696 return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
8701 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8702 by changing CODE to reduce the magnitude of constants involved in
8703 ARG0 of the comparison.
8704 Returns a canonicalized comparison tree if a simplification was
8705 possible, otherwise returns NULL_TREE.
8706 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8707 valid if signed overflow is undefined. */
8710 maybe_canonicalize_comparison_1 (enum tree_code code, tree type,
8711 tree arg0, tree arg1,
8712 bool *strict_overflow_p)
8714 enum tree_code code0 = TREE_CODE (arg0);
8715 tree t, cst0 = NULL_TREE;
8719 /* Match A +- CST code arg1 and CST code arg1. We can change the
8720 first form only if overflow is undefined. */
8721 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8722 /* In principle pointers also have undefined overflow behavior,
8723 but that causes problems elsewhere. */
8724 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8725 && (code0 == MINUS_EXPR
8726 || code0 == PLUS_EXPR)
8727 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8728 || code0 == INTEGER_CST))
8731 /* Identify the constant in arg0 and its sign. */
8732 if (code0 == INTEGER_CST)
8735 cst0 = TREE_OPERAND (arg0, 1);
8736 sgn0 = tree_int_cst_sgn (cst0);
8738 /* Overflowed constants and zero will cause problems. */
8739 if (integer_zerop (cst0)
8740 || TREE_OVERFLOW (cst0))
8743 /* See if we can reduce the magnitude of the constant in
8744 arg0 by changing the comparison code. */
8745 if (code0 == INTEGER_CST)
8747 /* CST <= arg1 -> CST-1 < arg1. */
8748 if (code == LE_EXPR && sgn0 == 1)
8750 /* -CST < arg1 -> -CST-1 <= arg1. */
8751 else if (code == LT_EXPR && sgn0 == -1)
8753 /* CST > arg1 -> CST-1 >= arg1. */
8754 else if (code == GT_EXPR && sgn0 == 1)
8756 /* -CST >= arg1 -> -CST-1 > arg1. */
8757 else if (code == GE_EXPR && sgn0 == -1)
8761 /* arg1 code' CST' might be more canonical. */
8766 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8768 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8770 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8771 else if (code == GT_EXPR
8772 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8774 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8775 else if (code == LE_EXPR
8776 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8778 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8779 else if (code == GE_EXPR
8780 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8784 *strict_overflow_p = true;
8787 /* Now build the constant reduced in magnitude. But not if that
8788 would produce one outside of its types range. */
8789 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8791 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8792 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8794 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8795 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8796 /* We cannot swap the comparison here as that would cause us to
8797 endlessly recurse. */
8800 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8801 cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
8802 if (code0 != INTEGER_CST)
8803 t = fold_build2 (code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8805 /* If swapping might yield to a more canonical form, do so. */
8807 return fold_build2 (swap_tree_comparison (code), type, arg1, t);
8809 return fold_build2 (code, type, t, arg1);
8812 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8813 overflow further. Try to decrease the magnitude of constants involved
8814 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8815 and put sole constants at the second argument position.
8816 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8819 maybe_canonicalize_comparison (enum tree_code code, tree type,
8820 tree arg0, tree arg1)
8823 bool strict_overflow_p;
8824 const char * const warnmsg = G_("assuming signed overflow does not occur "
8825 "when reducing constant in comparison");
8827 /* Try canonicalization by simplifying arg0. */
8828 strict_overflow_p = false;
8829 t = maybe_canonicalize_comparison_1 (code, type, arg0, arg1,
8830 &strict_overflow_p);
8833 if (strict_overflow_p)
8834 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8838 /* Try canonicalization by simplifying arg1 using the swapped
8840 code = swap_tree_comparison (code);
8841 strict_overflow_p = false;
8842 t = maybe_canonicalize_comparison_1 (code, type, arg1, arg0,
8843 &strict_overflow_p);
8844 if (t && strict_overflow_p)
8845 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8849 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8850 space. This is used to avoid issuing overflow warnings for
8851 expressions like &p->x which can not wrap. */
8854 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8856 unsigned HOST_WIDE_INT offset_low, total_low;
8857 HOST_WIDE_INT size, offset_high, total_high;
8859 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8865 if (offset == NULL_TREE)
8870 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8874 offset_low = TREE_INT_CST_LOW (offset);
8875 offset_high = TREE_INT_CST_HIGH (offset);
8878 if (add_double_with_sign (offset_low, offset_high,
8879 bitpos / BITS_PER_UNIT, 0,
8880 &total_low, &total_high,
8884 if (total_high != 0)
8887 size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8891 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8893 if (TREE_CODE (base) == ADDR_EXPR)
8895 HOST_WIDE_INT base_size;
8897 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8898 if (base_size > 0 && size < base_size)
8902 return total_low > (unsigned HOST_WIDE_INT) size;
8905 /* Subroutine of fold_binary. This routine performs all of the
8906 transformations that are common to the equality/inequality
8907 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8908 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8909 fold_binary should call fold_binary. Fold a comparison with
8910 tree code CODE and type TYPE with operands OP0 and OP1. Return
8911 the folded comparison or NULL_TREE. */
8914 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
8916 tree arg0, arg1, tem;
8921 STRIP_SIGN_NOPS (arg0);
8922 STRIP_SIGN_NOPS (arg1);
8924 tem = fold_relational_const (code, type, arg0, arg1);
8925 if (tem != NULL_TREE)
8928 /* If one arg is a real or integer constant, put it last. */
8929 if (tree_swap_operands_p (arg0, arg1, true))
8930 return fold_build2 (swap_tree_comparison (code), type, op1, op0);
8932 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1. */
8933 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8934 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8935 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8936 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
8937 && (TREE_CODE (arg1) == INTEGER_CST
8938 && !TREE_OVERFLOW (arg1)))
8940 tree const1 = TREE_OPERAND (arg0, 1);
8942 tree variable = TREE_OPERAND (arg0, 0);
8945 lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8947 lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
8948 TREE_TYPE (arg1), const2, const1);
8950 /* If the constant operation overflowed this can be
8951 simplified as a comparison against INT_MAX/INT_MIN. */
8952 if (TREE_CODE (lhs) == INTEGER_CST
8953 && TREE_OVERFLOW (lhs))
8955 int const1_sgn = tree_int_cst_sgn (const1);
8956 enum tree_code code2 = code;
8958 /* Get the sign of the constant on the lhs if the
8959 operation were VARIABLE + CONST1. */
8960 if (TREE_CODE (arg0) == MINUS_EXPR)
8961 const1_sgn = -const1_sgn;
8963 /* The sign of the constant determines if we overflowed
8964 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8965 Canonicalize to the INT_MIN overflow by swapping the comparison
8967 if (const1_sgn == -1)
8968 code2 = swap_tree_comparison (code);
8970 /* We now can look at the canonicalized case
8971 VARIABLE + 1 CODE2 INT_MIN
8972 and decide on the result. */
8973 if (code2 == LT_EXPR
8975 || code2 == EQ_EXPR)
8976 return omit_one_operand (type, boolean_false_node, variable);
8977 else if (code2 == NE_EXPR
8979 || code2 == GT_EXPR)
8980 return omit_one_operand (type, boolean_true_node, variable);
8983 if (TREE_CODE (lhs) == TREE_CODE (arg1)
8984 && (TREE_CODE (lhs) != INTEGER_CST
8985 || !TREE_OVERFLOW (lhs)))
8987 fold_overflow_warning (("assuming signed overflow does not occur "
8988 "when changing X +- C1 cmp C2 to "
8990 WARN_STRICT_OVERFLOW_COMPARISON);
8991 return fold_build2 (code, type, variable, lhs);
8995 /* For comparisons of pointers we can decompose it to a compile time
8996 comparison of the base objects and the offsets into the object.
8997 This requires at least one operand being an ADDR_EXPR or a
8998 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8999 if (POINTER_TYPE_P (TREE_TYPE (arg0))
9000 && (TREE_CODE (arg0) == ADDR_EXPR
9001 || TREE_CODE (arg1) == ADDR_EXPR
9002 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
9003 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
9005 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
9006 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
9007 enum machine_mode mode;
9008 int volatilep, unsignedp;
9009 bool indirect_base0 = false, indirect_base1 = false;
9011 /* Get base and offset for the access. Strip ADDR_EXPR for
9012 get_inner_reference, but put it back by stripping INDIRECT_REF
9013 off the base object if possible. indirect_baseN will be true
9014 if baseN is not an address but refers to the object itself. */
9016 if (TREE_CODE (arg0) == ADDR_EXPR)
9018 base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
9019 &bitsize, &bitpos0, &offset0, &mode,
9020 &unsignedp, &volatilep, false);
9021 if (TREE_CODE (base0) == INDIRECT_REF)
9022 base0 = TREE_OPERAND (base0, 0);
9024 indirect_base0 = true;
9026 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9028 base0 = TREE_OPERAND (arg0, 0);
9029 offset0 = TREE_OPERAND (arg0, 1);
9033 if (TREE_CODE (arg1) == ADDR_EXPR)
9035 base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
9036 &bitsize, &bitpos1, &offset1, &mode,
9037 &unsignedp, &volatilep, false);
9038 if (TREE_CODE (base1) == INDIRECT_REF)
9039 base1 = TREE_OPERAND (base1, 0);
9041 indirect_base1 = true;
9043 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
9045 base1 = TREE_OPERAND (arg1, 0);
9046 offset1 = TREE_OPERAND (arg1, 1);
9049 /* If we have equivalent bases we might be able to simplify. */
9050 if (indirect_base0 == indirect_base1
9051 && operand_equal_p (base0, base1, 0))
9053 /* We can fold this expression to a constant if the non-constant
9054 offset parts are equal. */
9055 if ((offset0 == offset1
9056 || (offset0 && offset1
9057 && operand_equal_p (offset0, offset1, 0)))
9060 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9065 && bitpos0 != bitpos1
9066 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9067 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9068 fold_overflow_warning (("assuming pointer wraparound does not "
9069 "occur when comparing P +- C1 with "
9071 WARN_STRICT_OVERFLOW_CONDITIONAL);
9076 return constant_boolean_node (bitpos0 == bitpos1, type);
9078 return constant_boolean_node (bitpos0 != bitpos1, type);
9080 return constant_boolean_node (bitpos0 < bitpos1, type);
9082 return constant_boolean_node (bitpos0 <= bitpos1, type);
9084 return constant_boolean_node (bitpos0 >= bitpos1, type);
9086 return constant_boolean_node (bitpos0 > bitpos1, type);
9090 /* We can simplify the comparison to a comparison of the variable
9091 offset parts if the constant offset parts are equal.
9092 Be careful to use signed size type here because otherwise we
9093 mess with array offsets in the wrong way. This is possible
9094 because pointer arithmetic is restricted to retain within an
9095 object and overflow on pointer differences is undefined as of
9096 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
9097 else if (bitpos0 == bitpos1
9098 && ((code == EQ_EXPR || code == NE_EXPR)
9099 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9101 tree signed_size_type_node;
9102 signed_size_type_node = signed_type_for (size_type_node);
9104 /* By converting to signed size type we cover middle-end pointer
9105 arithmetic which operates on unsigned pointer types of size
9106 type size and ARRAY_REF offsets which are properly sign or
9107 zero extended from their type in case it is narrower than
9109 if (offset0 == NULL_TREE)
9110 offset0 = build_int_cst (signed_size_type_node, 0);
9112 offset0 = fold_convert (signed_size_type_node, offset0);
9113 if (offset1 == NULL_TREE)
9114 offset1 = build_int_cst (signed_size_type_node, 0);
9116 offset1 = fold_convert (signed_size_type_node, offset1);
9120 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9121 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9122 fold_overflow_warning (("assuming pointer wraparound does not "
9123 "occur when comparing P +- C1 with "
9125 WARN_STRICT_OVERFLOW_COMPARISON);
9127 return fold_build2 (code, type, offset0, offset1);
9130 /* For non-equal bases we can simplify if they are addresses
9131 of local binding decls or constants. */
9132 else if (indirect_base0 && indirect_base1
9133 /* We know that !operand_equal_p (base0, base1, 0)
9134 because the if condition was false. But make
9135 sure two decls are not the same. */
9137 && TREE_CODE (arg0) == ADDR_EXPR
9138 && TREE_CODE (arg1) == ADDR_EXPR
9139 && (((TREE_CODE (base0) == VAR_DECL
9140 || TREE_CODE (base0) == PARM_DECL)
9141 && (targetm.binds_local_p (base0)
9142 || CONSTANT_CLASS_P (base1)))
9143 || CONSTANT_CLASS_P (base0))
9144 && (((TREE_CODE (base1) == VAR_DECL
9145 || TREE_CODE (base1) == PARM_DECL)
9146 && (targetm.binds_local_p (base1)
9147 || CONSTANT_CLASS_P (base0)))
9148 || CONSTANT_CLASS_P (base1)))
9150 if (code == EQ_EXPR)
9151 return omit_two_operands (type, boolean_false_node, arg0, arg1);
9152 else if (code == NE_EXPR)
9153 return omit_two_operands (type, boolean_true_node, arg0, arg1);
9155 /* For equal offsets we can simplify to a comparison of the
9157 else if (bitpos0 == bitpos1
9159 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9161 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9162 && ((offset0 == offset1)
9163 || (offset0 && offset1
9164 && operand_equal_p (offset0, offset1, 0))))
9167 base0 = build_fold_addr_expr (base0);
9169 base1 = build_fold_addr_expr (base1);
9170 return fold_build2 (code, type, base0, base1);
9174 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9175 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9176 the resulting offset is smaller in absolute value than the
9178 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9179 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9180 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9181 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9182 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9183 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9184 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9186 tree const1 = TREE_OPERAND (arg0, 1);
9187 tree const2 = TREE_OPERAND (arg1, 1);
9188 tree variable1 = TREE_OPERAND (arg0, 0);
9189 tree variable2 = TREE_OPERAND (arg1, 0);
9191 const char * const warnmsg = G_("assuming signed overflow does not "
9192 "occur when combining constants around "
9195 /* Put the constant on the side where it doesn't overflow and is
9196 of lower absolute value than before. */
9197 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9198 ? MINUS_EXPR : PLUS_EXPR,
9200 if (!TREE_OVERFLOW (cst)
9201 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
9203 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9204 return fold_build2 (code, type,
9206 fold_build2 (TREE_CODE (arg1), TREE_TYPE (arg1),
9210 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9211 ? MINUS_EXPR : PLUS_EXPR,
9213 if (!TREE_OVERFLOW (cst)
9214 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
9216 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9217 return fold_build2 (code, type,
9218 fold_build2 (TREE_CODE (arg0), TREE_TYPE (arg0),
9224 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9225 signed arithmetic case. That form is created by the compiler
9226 often enough for folding it to be of value. One example is in
9227 computing loop trip counts after Operator Strength Reduction. */
9228 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9229 && TREE_CODE (arg0) == MULT_EXPR
9230 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9231 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9232 && integer_zerop (arg1))
9234 tree const1 = TREE_OPERAND (arg0, 1);
9235 tree const2 = arg1; /* zero */
9236 tree variable1 = TREE_OPERAND (arg0, 0);
9237 enum tree_code cmp_code = code;
9239 gcc_assert (!integer_zerop (const1));
9241 fold_overflow_warning (("assuming signed overflow does not occur when "
9242 "eliminating multiplication in comparison "
9244 WARN_STRICT_OVERFLOW_COMPARISON);
9246 /* If const1 is negative we swap the sense of the comparison. */
9247 if (tree_int_cst_sgn (const1) < 0)
9248 cmp_code = swap_tree_comparison (cmp_code);
9250 return fold_build2 (cmp_code, type, variable1, const2);
9253 tem = maybe_canonicalize_comparison (code, type, op0, op1);
9257 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9259 tree targ0 = strip_float_extensions (arg0);
9260 tree targ1 = strip_float_extensions (arg1);
9261 tree newtype = TREE_TYPE (targ0);
9263 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9264 newtype = TREE_TYPE (targ1);
9266 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9267 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9268 return fold_build2 (code, type, fold_convert (newtype, targ0),
9269 fold_convert (newtype, targ1));
9271 /* (-a) CMP (-b) -> b CMP a */
9272 if (TREE_CODE (arg0) == NEGATE_EXPR
9273 && TREE_CODE (arg1) == NEGATE_EXPR)
9274 return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
9275 TREE_OPERAND (arg0, 0));
9277 if (TREE_CODE (arg1) == REAL_CST)
9279 REAL_VALUE_TYPE cst;
9280 cst = TREE_REAL_CST (arg1);
9282 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9283 if (TREE_CODE (arg0) == NEGATE_EXPR)
9284 return fold_build2 (swap_tree_comparison (code), type,
9285 TREE_OPERAND (arg0, 0),
9286 build_real (TREE_TYPE (arg1),
9287 REAL_VALUE_NEGATE (cst)));
9289 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9290 /* a CMP (-0) -> a CMP 0 */
9291 if (REAL_VALUE_MINUS_ZERO (cst))
9292 return fold_build2 (code, type, arg0,
9293 build_real (TREE_TYPE (arg1), dconst0));
9295 /* x != NaN is always true, other ops are always false. */
9296 if (REAL_VALUE_ISNAN (cst)
9297 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9299 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9300 return omit_one_operand (type, tem, arg0);
9303 /* Fold comparisons against infinity. */
9304 if (REAL_VALUE_ISINF (cst)
9305 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9307 tem = fold_inf_compare (code, type, arg0, arg1);
9308 if (tem != NULL_TREE)
9313 /* If this is a comparison of a real constant with a PLUS_EXPR
9314 or a MINUS_EXPR of a real constant, we can convert it into a
9315 comparison with a revised real constant as long as no overflow
9316 occurs when unsafe_math_optimizations are enabled. */
9317 if (flag_unsafe_math_optimizations
9318 && TREE_CODE (arg1) == REAL_CST
9319 && (TREE_CODE (arg0) == PLUS_EXPR
9320 || TREE_CODE (arg0) == MINUS_EXPR)
9321 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9322 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9323 ? MINUS_EXPR : PLUS_EXPR,
9324 arg1, TREE_OPERAND (arg0, 1), 0))
9325 && !TREE_OVERFLOW (tem))
9326 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9328 /* Likewise, we can simplify a comparison of a real constant with
9329 a MINUS_EXPR whose first operand is also a real constant, i.e.
9330 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9331 floating-point types only if -fassociative-math is set. */
9332 if (flag_associative_math
9333 && TREE_CODE (arg1) == REAL_CST
9334 && TREE_CODE (arg0) == MINUS_EXPR
9335 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9336 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9338 && !TREE_OVERFLOW (tem))
9339 return fold_build2 (swap_tree_comparison (code), type,
9340 TREE_OPERAND (arg0, 1), tem);
9342 /* Fold comparisons against built-in math functions. */
9343 if (TREE_CODE (arg1) == REAL_CST
9344 && flag_unsafe_math_optimizations
9345 && ! flag_errno_math)
9347 enum built_in_function fcode = builtin_mathfn_code (arg0);
9349 if (fcode != END_BUILTINS)
9351 tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
9352 if (tem != NULL_TREE)
9358 if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9359 && CONVERT_EXPR_P (arg0))
9361 /* If we are widening one operand of an integer comparison,
9362 see if the other operand is similarly being widened. Perhaps we
9363 can do the comparison in the narrower type. */
9364 tem = fold_widened_comparison (code, type, arg0, arg1);
9368 /* Or if we are changing signedness. */
9369 tem = fold_sign_changed_comparison (code, type, arg0, arg1);
9374 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9375 constant, we can simplify it. */
9376 if (TREE_CODE (arg1) == INTEGER_CST
9377 && (TREE_CODE (arg0) == MIN_EXPR
9378 || TREE_CODE (arg0) == MAX_EXPR)
9379 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9381 tem = optimize_minmax_comparison (code, type, op0, op1);
9386 /* Simplify comparison of something with itself. (For IEEE
9387 floating-point, we can only do some of these simplifications.) */
9388 if (operand_equal_p (arg0, arg1, 0))
9393 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9394 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9395 return constant_boolean_node (1, type);
9400 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9401 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9402 return constant_boolean_node (1, type);
9403 return fold_build2 (EQ_EXPR, type, arg0, arg1);
9406 /* For NE, we can only do this simplification if integer
9407 or we don't honor IEEE floating point NaNs. */
9408 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9409 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9411 /* ... fall through ... */
9414 return constant_boolean_node (0, type);
9420 /* If we are comparing an expression that just has comparisons
9421 of two integer values, arithmetic expressions of those comparisons,
9422 and constants, we can simplify it. There are only three cases
9423 to check: the two values can either be equal, the first can be
9424 greater, or the second can be greater. Fold the expression for
9425 those three values. Since each value must be 0 or 1, we have
9426 eight possibilities, each of which corresponds to the constant 0
9427 or 1 or one of the six possible comparisons.
9429 This handles common cases like (a > b) == 0 but also handles
9430 expressions like ((x > y) - (y > x)) > 0, which supposedly
9431 occur in macroized code. */
9433 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9435 tree cval1 = 0, cval2 = 0;
9438 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9439 /* Don't handle degenerate cases here; they should already
9440 have been handled anyway. */
9441 && cval1 != 0 && cval2 != 0
9442 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9443 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9444 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9445 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9446 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9447 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9448 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9450 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9451 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9453 /* We can't just pass T to eval_subst in case cval1 or cval2
9454 was the same as ARG1. */
9457 = fold_build2 (code, type,
9458 eval_subst (arg0, cval1, maxval,
9462 = fold_build2 (code, type,
9463 eval_subst (arg0, cval1, maxval,
9467 = fold_build2 (code, type,
9468 eval_subst (arg0, cval1, minval,
9472 /* All three of these results should be 0 or 1. Confirm they are.
9473 Then use those values to select the proper code to use. */
9475 if (TREE_CODE (high_result) == INTEGER_CST
9476 && TREE_CODE (equal_result) == INTEGER_CST
9477 && TREE_CODE (low_result) == INTEGER_CST)
9479 /* Make a 3-bit mask with the high-order bit being the
9480 value for `>', the next for '=', and the low for '<'. */
9481 switch ((integer_onep (high_result) * 4)
9482 + (integer_onep (equal_result) * 2)
9483 + integer_onep (low_result))
9487 return omit_one_operand (type, integer_zero_node, arg0);
9508 return omit_one_operand (type, integer_one_node, arg0);
9512 return save_expr (build2 (code, type, cval1, cval2));
9513 return fold_build2 (code, type, cval1, cval2);
9518 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9519 into a single range test. */
9520 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9521 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9522 && TREE_CODE (arg1) == INTEGER_CST
9523 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9524 && !integer_zerop (TREE_OPERAND (arg0, 1))
9525 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9526 && !TREE_OVERFLOW (arg1))
9528 tem = fold_div_compare (code, type, arg0, arg1);
9529 if (tem != NULL_TREE)
9533 /* Fold ~X op ~Y as Y op X. */
9534 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9535 && TREE_CODE (arg1) == BIT_NOT_EXPR)
9537 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9538 return fold_build2 (code, type,
9539 fold_convert (cmp_type, TREE_OPERAND (arg1, 0)),
9540 TREE_OPERAND (arg0, 0));
9543 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9544 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9545 && TREE_CODE (arg1) == INTEGER_CST)
9547 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9548 return fold_build2 (swap_tree_comparison (code), type,
9549 TREE_OPERAND (arg0, 0),
9550 fold_build1 (BIT_NOT_EXPR, cmp_type,
9551 fold_convert (cmp_type, arg1)));
9558 /* Subroutine of fold_binary. Optimize complex multiplications of the
9559 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9560 argument EXPR represents the expression "z" of type TYPE. */
9563 fold_mult_zconjz (tree type, tree expr)
9565 tree itype = TREE_TYPE (type);
9566 tree rpart, ipart, tem;
9568 if (TREE_CODE (expr) == COMPLEX_EXPR)
9570 rpart = TREE_OPERAND (expr, 0);
9571 ipart = TREE_OPERAND (expr, 1);
9573 else if (TREE_CODE (expr) == COMPLEX_CST)
9575 rpart = TREE_REALPART (expr);
9576 ipart = TREE_IMAGPART (expr);
9580 expr = save_expr (expr);
9581 rpart = fold_build1 (REALPART_EXPR, itype, expr);
9582 ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
9585 rpart = save_expr (rpart);
9586 ipart = save_expr (ipart);
9587 tem = fold_build2 (PLUS_EXPR, itype,
9588 fold_build2 (MULT_EXPR, itype, rpart, rpart),
9589 fold_build2 (MULT_EXPR, itype, ipart, ipart));
9590 return fold_build2 (COMPLEX_EXPR, type, tem,
9591 fold_convert (itype, integer_zero_node));
9595 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9596 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9597 guarantees that P and N have the same least significant log2(M) bits.
9598 N is not otherwise constrained. In particular, N is not normalized to
9599 0 <= N < M as is common. In general, the precise value of P is unknown.
9600 M is chosen as large as possible such that constant N can be determined.
9602 Returns M and sets *RESIDUE to N.
9604 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9605 account. This is not always possible due to PR 35705.
9608 static unsigned HOST_WIDE_INT
9609 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9610 bool allow_func_align)
9612 enum tree_code code;
9616 code = TREE_CODE (expr);
9617 if (code == ADDR_EXPR)
9619 expr = TREE_OPERAND (expr, 0);
9620 if (handled_component_p (expr))
9622 HOST_WIDE_INT bitsize, bitpos;
9624 enum machine_mode mode;
9625 int unsignedp, volatilep;
9627 expr = get_inner_reference (expr, &bitsize, &bitpos, &offset,
9628 &mode, &unsignedp, &volatilep, false);
9629 *residue = bitpos / BITS_PER_UNIT;
9632 if (TREE_CODE (offset) == INTEGER_CST)
9633 *residue += TREE_INT_CST_LOW (offset);
9635 /* We don't handle more complicated offset expressions. */
9641 && (allow_func_align || TREE_CODE (expr) != FUNCTION_DECL))
9642 return DECL_ALIGN_UNIT (expr);
9644 else if (code == POINTER_PLUS_EXPR)
9647 unsigned HOST_WIDE_INT modulus;
9648 enum tree_code inner_code;
9650 op0 = TREE_OPERAND (expr, 0);
9652 modulus = get_pointer_modulus_and_residue (op0, residue,
9655 op1 = TREE_OPERAND (expr, 1);
9657 inner_code = TREE_CODE (op1);
9658 if (inner_code == INTEGER_CST)
9660 *residue += TREE_INT_CST_LOW (op1);
9663 else if (inner_code == MULT_EXPR)
9665 op1 = TREE_OPERAND (op1, 1);
9666 if (TREE_CODE (op1) == INTEGER_CST)
9668 unsigned HOST_WIDE_INT align;
9670 /* Compute the greatest power-of-2 divisor of op1. */
9671 align = TREE_INT_CST_LOW (op1);
9674 /* If align is non-zero and less than *modulus, replace
9675 *modulus with align., If align is 0, then either op1 is 0
9676 or the greatest power-of-2 divisor of op1 doesn't fit in an
9677 unsigned HOST_WIDE_INT. In either case, no additional
9678 constraint is imposed. */
9680 modulus = MIN (modulus, align);
9687 /* If we get here, we were unable to determine anything useful about the
9693 /* Fold a binary expression of code CODE and type TYPE with operands
9694 OP0 and OP1. Return the folded expression if folding is
9695 successful. Otherwise, return NULL_TREE. */
9698 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
9700 enum tree_code_class kind = TREE_CODE_CLASS (code);
9701 tree arg0, arg1, tem;
9702 tree t1 = NULL_TREE;
9703 bool strict_overflow_p;
9705 gcc_assert (IS_EXPR_CODE_CLASS (kind)
9706 && TREE_CODE_LENGTH (code) == 2
9708 && op1 != NULL_TREE);
9713 /* Strip any conversions that don't change the mode. This is
9714 safe for every expression, except for a comparison expression
9715 because its signedness is derived from its operands. So, in
9716 the latter case, only strip conversions that don't change the
9717 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9720 Note that this is done as an internal manipulation within the
9721 constant folder, in order to find the simplest representation
9722 of the arguments so that their form can be studied. In any
9723 cases, the appropriate type conversions should be put back in
9724 the tree that will get out of the constant folder. */
9726 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9728 STRIP_SIGN_NOPS (arg0);
9729 STRIP_SIGN_NOPS (arg1);
9737 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9738 constant but we can't do arithmetic on them. */
9739 if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9740 || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9741 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9742 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9743 || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9744 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
9746 if (kind == tcc_binary)
9748 /* Make sure type and arg0 have the same saturating flag. */
9749 gcc_assert (TYPE_SATURATING (type)
9750 == TYPE_SATURATING (TREE_TYPE (arg0)));
9751 tem = const_binop (code, arg0, arg1, 0);
9753 else if (kind == tcc_comparison)
9754 tem = fold_relational_const (code, type, arg0, arg1);
9758 if (tem != NULL_TREE)
9760 if (TREE_TYPE (tem) != type)
9761 tem = fold_convert (type, tem);
9766 /* If this is a commutative operation, and ARG0 is a constant, move it
9767 to ARG1 to reduce the number of tests below. */
9768 if (commutative_tree_code (code)
9769 && tree_swap_operands_p (arg0, arg1, true))
9770 return fold_build2 (code, type, op1, op0);
9772 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9774 First check for cases where an arithmetic operation is applied to a
9775 compound, conditional, or comparison operation. Push the arithmetic
9776 operation inside the compound or conditional to see if any folding
9777 can then be done. Convert comparison to conditional for this purpose.
9778 The also optimizes non-constant cases that used to be done in
9781 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9782 one of the operands is a comparison and the other is a comparison, a
9783 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9784 code below would make the expression more complex. Change it to a
9785 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9786 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9788 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9789 || code == EQ_EXPR || code == NE_EXPR)
9790 && ((truth_value_p (TREE_CODE (arg0))
9791 && (truth_value_p (TREE_CODE (arg1))
9792 || (TREE_CODE (arg1) == BIT_AND_EXPR
9793 && integer_onep (TREE_OPERAND (arg1, 1)))))
9794 || (truth_value_p (TREE_CODE (arg1))
9795 && (truth_value_p (TREE_CODE (arg0))
9796 || (TREE_CODE (arg0) == BIT_AND_EXPR
9797 && integer_onep (TREE_OPERAND (arg0, 1)))))))
9799 tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9800 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9803 fold_convert (boolean_type_node, arg0),
9804 fold_convert (boolean_type_node, arg1));
9806 if (code == EQ_EXPR)
9807 tem = invert_truthvalue (tem);
9809 return fold_convert (type, tem);
9812 if (TREE_CODE_CLASS (code) == tcc_binary
9813 || TREE_CODE_CLASS (code) == tcc_comparison)
9815 if (TREE_CODE (arg0) == COMPOUND_EXPR)
9816 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9817 fold_build2 (code, type,
9818 fold_convert (TREE_TYPE (op0),
9819 TREE_OPERAND (arg0, 1)),
9821 if (TREE_CODE (arg1) == COMPOUND_EXPR
9822 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9823 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9824 fold_build2 (code, type, op0,
9825 fold_convert (TREE_TYPE (op1),
9826 TREE_OPERAND (arg1, 1))));
9828 if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
9830 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9832 /*cond_first_p=*/1);
9833 if (tem != NULL_TREE)
9837 if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
9839 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9841 /*cond_first_p=*/0);
9842 if (tem != NULL_TREE)
9849 case POINTER_PLUS_EXPR:
9850 /* 0 +p index -> (type)index */
9851 if (integer_zerop (arg0))
9852 return non_lvalue (fold_convert (type, arg1));
9854 /* PTR +p 0 -> PTR */
9855 if (integer_zerop (arg1))
9856 return non_lvalue (fold_convert (type, arg0));
9858 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9859 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9860 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9861 return fold_convert (type, fold_build2 (PLUS_EXPR, sizetype,
9862 fold_convert (sizetype, arg1),
9863 fold_convert (sizetype, arg0)));
9865 /* index +p PTR -> PTR +p index */
9866 if (POINTER_TYPE_P (TREE_TYPE (arg1))
9867 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9868 return fold_build2 (POINTER_PLUS_EXPR, type,
9869 fold_convert (type, arg1),
9870 fold_convert (sizetype, arg0));
9872 /* (PTR +p B) +p A -> PTR +p (B + A) */
9873 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9876 tree arg01 = fold_convert (sizetype, TREE_OPERAND (arg0, 1));
9877 tree arg00 = TREE_OPERAND (arg0, 0);
9878 inner = fold_build2 (PLUS_EXPR, sizetype,
9879 arg01, fold_convert (sizetype, arg1));
9880 return fold_convert (type,
9881 fold_build2 (POINTER_PLUS_EXPR,
9882 TREE_TYPE (arg00), arg00, inner));
9885 /* PTR_CST +p CST -> CST1 */
9886 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9887 return fold_build2 (PLUS_EXPR, type, arg0, fold_convert (type, arg1));
9889 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9890 of the array. Loop optimizer sometimes produce this type of
9892 if (TREE_CODE (arg0) == ADDR_EXPR)
9894 tem = try_move_mult_to_index (arg0, fold_convert (sizetype, arg1));
9896 return fold_convert (type, tem);
9902 /* A + (-B) -> A - B */
9903 if (TREE_CODE (arg1) == NEGATE_EXPR)
9904 return fold_build2 (MINUS_EXPR, type,
9905 fold_convert (type, arg0),
9906 fold_convert (type, TREE_OPERAND (arg1, 0)));
9907 /* (-A) + B -> B - A */
9908 if (TREE_CODE (arg0) == NEGATE_EXPR
9909 && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
9910 return fold_build2 (MINUS_EXPR, type,
9911 fold_convert (type, arg1),
9912 fold_convert (type, TREE_OPERAND (arg0, 0)));
9914 if (INTEGRAL_TYPE_P (type))
9916 /* Convert ~A + 1 to -A. */
9917 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9918 && integer_onep (arg1))
9919 return fold_build1 (NEGATE_EXPR, type,
9920 fold_convert (type, TREE_OPERAND (arg0, 0)));
9923 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9924 && !TYPE_OVERFLOW_TRAPS (type))
9926 tree tem = TREE_OPERAND (arg0, 0);
9929 if (operand_equal_p (tem, arg1, 0))
9931 t1 = build_int_cst_type (type, -1);
9932 return omit_one_operand (type, t1, arg1);
9937 if (TREE_CODE (arg1) == BIT_NOT_EXPR
9938 && !TYPE_OVERFLOW_TRAPS (type))
9940 tree tem = TREE_OPERAND (arg1, 0);
9943 if (operand_equal_p (arg0, tem, 0))
9945 t1 = build_int_cst_type (type, -1);
9946 return omit_one_operand (type, t1, arg0);
9950 /* X + (X / CST) * -CST is X % CST. */
9951 if (TREE_CODE (arg1) == MULT_EXPR
9952 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9953 && operand_equal_p (arg0,
9954 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9956 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9957 tree cst1 = TREE_OPERAND (arg1, 1);
9958 tree sum = fold_binary (PLUS_EXPR, TREE_TYPE (cst1), cst1, cst0);
9959 if (sum && integer_zerop (sum))
9960 return fold_convert (type,
9961 fold_build2 (TRUNC_MOD_EXPR,
9962 TREE_TYPE (arg0), arg0, cst0));
9966 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
9967 same or one. Make sure type is not saturating.
9968 fold_plusminus_mult_expr will re-associate. */
9969 if ((TREE_CODE (arg0) == MULT_EXPR
9970 || TREE_CODE (arg1) == MULT_EXPR)
9971 && !TYPE_SATURATING (type)
9972 && (!FLOAT_TYPE_P (type) || flag_associative_math))
9974 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9979 if (! FLOAT_TYPE_P (type))
9981 if (integer_zerop (arg1))
9982 return non_lvalue (fold_convert (type, arg0));
9984 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
9985 with a constant, and the two constants have no bits in common,
9986 we should treat this as a BIT_IOR_EXPR since this may produce more
9988 if (TREE_CODE (arg0) == BIT_AND_EXPR
9989 && TREE_CODE (arg1) == BIT_AND_EXPR
9990 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9991 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9992 && integer_zerop (const_binop (BIT_AND_EXPR,
9993 TREE_OPERAND (arg0, 1),
9994 TREE_OPERAND (arg1, 1), 0)))
9996 code = BIT_IOR_EXPR;
10000 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10001 (plus (plus (mult) (mult)) (foo)) so that we can
10002 take advantage of the factoring cases below. */
10003 if (((TREE_CODE (arg0) == PLUS_EXPR
10004 || TREE_CODE (arg0) == MINUS_EXPR)
10005 && TREE_CODE (arg1) == MULT_EXPR)
10006 || ((TREE_CODE (arg1) == PLUS_EXPR
10007 || TREE_CODE (arg1) == MINUS_EXPR)
10008 && TREE_CODE (arg0) == MULT_EXPR))
10010 tree parg0, parg1, parg, marg;
10011 enum tree_code pcode;
10013 if (TREE_CODE (arg1) == MULT_EXPR)
10014 parg = arg0, marg = arg1;
10016 parg = arg1, marg = arg0;
10017 pcode = TREE_CODE (parg);
10018 parg0 = TREE_OPERAND (parg, 0);
10019 parg1 = TREE_OPERAND (parg, 1);
10020 STRIP_NOPS (parg0);
10021 STRIP_NOPS (parg1);
10023 if (TREE_CODE (parg0) == MULT_EXPR
10024 && TREE_CODE (parg1) != MULT_EXPR)
10025 return fold_build2 (pcode, type,
10026 fold_build2 (PLUS_EXPR, type,
10027 fold_convert (type, parg0),
10028 fold_convert (type, marg)),
10029 fold_convert (type, parg1));
10030 if (TREE_CODE (parg0) != MULT_EXPR
10031 && TREE_CODE (parg1) == MULT_EXPR)
10032 return fold_build2 (PLUS_EXPR, type,
10033 fold_convert (type, parg0),
10034 fold_build2 (pcode, type,
10035 fold_convert (type, marg),
10036 fold_convert (type,
10042 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10043 if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10044 return non_lvalue (fold_convert (type, arg0));
10046 /* Likewise if the operands are reversed. */
10047 if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10048 return non_lvalue (fold_convert (type, arg1));
10050 /* Convert X + -C into X - C. */
10051 if (TREE_CODE (arg1) == REAL_CST
10052 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10054 tem = fold_negate_const (arg1, type);
10055 if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10056 return fold_build2 (MINUS_EXPR, type,
10057 fold_convert (type, arg0),
10058 fold_convert (type, tem));
10061 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10062 to __complex__ ( x, y ). This is not the same for SNaNs or
10063 if signed zeros are involved. */
10064 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10065 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10066 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10068 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10069 tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
10070 tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
10071 bool arg0rz = false, arg0iz = false;
10072 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10073 || (arg0i && (arg0iz = real_zerop (arg0i))))
10075 tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
10076 tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
10077 if (arg0rz && arg1i && real_zerop (arg1i))
10079 tree rp = arg1r ? arg1r
10080 : build1 (REALPART_EXPR, rtype, arg1);
10081 tree ip = arg0i ? arg0i
10082 : build1 (IMAGPART_EXPR, rtype, arg0);
10083 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10085 else if (arg0iz && arg1r && real_zerop (arg1r))
10087 tree rp = arg0r ? arg0r
10088 : build1 (REALPART_EXPR, rtype, arg0);
10089 tree ip = arg1i ? arg1i
10090 : build1 (IMAGPART_EXPR, rtype, arg1);
10091 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10096 if (flag_unsafe_math_optimizations
10097 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10098 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10099 && (tem = distribute_real_division (code, type, arg0, arg1)))
10102 /* Convert x+x into x*2.0. */
10103 if (operand_equal_p (arg0, arg1, 0)
10104 && SCALAR_FLOAT_TYPE_P (type))
10105 return fold_build2 (MULT_EXPR, type, arg0,
10106 build_real (type, dconst2));
10108 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10109 We associate floats only if the user has specified
10110 -fassociative-math. */
10111 if (flag_associative_math
10112 && TREE_CODE (arg1) == PLUS_EXPR
10113 && TREE_CODE (arg0) != MULT_EXPR)
10115 tree tree10 = TREE_OPERAND (arg1, 0);
10116 tree tree11 = TREE_OPERAND (arg1, 1);
10117 if (TREE_CODE (tree11) == MULT_EXPR
10118 && TREE_CODE (tree10) == MULT_EXPR)
10121 tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
10122 return fold_build2 (PLUS_EXPR, type, tree0, tree11);
10125 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10126 We associate floats only if the user has specified
10127 -fassociative-math. */
10128 if (flag_associative_math
10129 && TREE_CODE (arg0) == PLUS_EXPR
10130 && TREE_CODE (arg1) != MULT_EXPR)
10132 tree tree00 = TREE_OPERAND (arg0, 0);
10133 tree tree01 = TREE_OPERAND (arg0, 1);
10134 if (TREE_CODE (tree01) == MULT_EXPR
10135 && TREE_CODE (tree00) == MULT_EXPR)
10138 tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
10139 return fold_build2 (PLUS_EXPR, type, tree00, tree0);
10145 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10146 is a rotate of A by C1 bits. */
10147 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10148 is a rotate of A by B bits. */
10150 enum tree_code code0, code1;
10152 code0 = TREE_CODE (arg0);
10153 code1 = TREE_CODE (arg1);
10154 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10155 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10156 && operand_equal_p (TREE_OPERAND (arg0, 0),
10157 TREE_OPERAND (arg1, 0), 0)
10158 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10159 TYPE_UNSIGNED (rtype))
10160 /* Only create rotates in complete modes. Other cases are not
10161 expanded properly. */
10162 && TYPE_PRECISION (rtype) == GET_MODE_PRECISION (TYPE_MODE (rtype)))
10164 tree tree01, tree11;
10165 enum tree_code code01, code11;
10167 tree01 = TREE_OPERAND (arg0, 1);
10168 tree11 = TREE_OPERAND (arg1, 1);
10169 STRIP_NOPS (tree01);
10170 STRIP_NOPS (tree11);
10171 code01 = TREE_CODE (tree01);
10172 code11 = TREE_CODE (tree11);
10173 if (code01 == INTEGER_CST
10174 && code11 == INTEGER_CST
10175 && TREE_INT_CST_HIGH (tree01) == 0
10176 && TREE_INT_CST_HIGH (tree11) == 0
10177 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
10178 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10179 return fold_convert (type,
10180 build2 (LROTATE_EXPR,
10181 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10182 TREE_OPERAND (arg0, 0),
10183 code0 == LSHIFT_EXPR
10184 ? tree01 : tree11));
10185 else if (code11 == MINUS_EXPR)
10187 tree tree110, tree111;
10188 tree110 = TREE_OPERAND (tree11, 0);
10189 tree111 = TREE_OPERAND (tree11, 1);
10190 STRIP_NOPS (tree110);
10191 STRIP_NOPS (tree111);
10192 if (TREE_CODE (tree110) == INTEGER_CST
10193 && 0 == compare_tree_int (tree110,
10195 (TREE_TYPE (TREE_OPERAND
10197 && operand_equal_p (tree01, tree111, 0))
10198 return fold_convert (type,
10199 build2 ((code0 == LSHIFT_EXPR
10202 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10203 TREE_OPERAND (arg0, 0), tree01));
10205 else if (code01 == MINUS_EXPR)
10207 tree tree010, tree011;
10208 tree010 = TREE_OPERAND (tree01, 0);
10209 tree011 = TREE_OPERAND (tree01, 1);
10210 STRIP_NOPS (tree010);
10211 STRIP_NOPS (tree011);
10212 if (TREE_CODE (tree010) == INTEGER_CST
10213 && 0 == compare_tree_int (tree010,
10215 (TREE_TYPE (TREE_OPERAND
10217 && operand_equal_p (tree11, tree011, 0))
10218 return fold_convert (type,
10219 build2 ((code0 != LSHIFT_EXPR
10222 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10223 TREE_OPERAND (arg0, 0), tree11));
10229 /* In most languages, can't associate operations on floats through
10230 parentheses. Rather than remember where the parentheses were, we
10231 don't associate floats at all, unless the user has specified
10232 -fassociative-math.
10233 And, we need to make sure type is not saturating. */
10235 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10236 && !TYPE_SATURATING (type))
10238 tree var0, con0, lit0, minus_lit0;
10239 tree var1, con1, lit1, minus_lit1;
10242 /* Split both trees into variables, constants, and literals. Then
10243 associate each group together, the constants with literals,
10244 then the result with variables. This increases the chances of
10245 literals being recombined later and of generating relocatable
10246 expressions for the sum of a constant and literal. */
10247 var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10248 var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10249 code == MINUS_EXPR);
10251 /* With undefined overflow we can only associate constants
10252 with one variable. */
10253 if (((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10254 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10260 if (TREE_CODE (tmp0) == NEGATE_EXPR)
10261 tmp0 = TREE_OPERAND (tmp0, 0);
10262 if (TREE_CODE (tmp1) == NEGATE_EXPR)
10263 tmp1 = TREE_OPERAND (tmp1, 0);
10264 /* The only case we can still associate with two variables
10265 is if they are the same, modulo negation. */
10266 if (!operand_equal_p (tmp0, tmp1, 0))
10270 /* Only do something if we found more than two objects. Otherwise,
10271 nothing has changed and we risk infinite recursion. */
10273 && (2 < ((var0 != 0) + (var1 != 0)
10274 + (con0 != 0) + (con1 != 0)
10275 + (lit0 != 0) + (lit1 != 0)
10276 + (minus_lit0 != 0) + (minus_lit1 != 0))))
10278 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10279 if (code == MINUS_EXPR)
10282 var0 = associate_trees (var0, var1, code, type);
10283 con0 = associate_trees (con0, con1, code, type);
10284 lit0 = associate_trees (lit0, lit1, code, type);
10285 minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
10287 /* Preserve the MINUS_EXPR if the negative part of the literal is
10288 greater than the positive part. Otherwise, the multiplicative
10289 folding code (i.e extract_muldiv) may be fooled in case
10290 unsigned constants are subtracted, like in the following
10291 example: ((X*2 + 4) - 8U)/2. */
10292 if (minus_lit0 && lit0)
10294 if (TREE_CODE (lit0) == INTEGER_CST
10295 && TREE_CODE (minus_lit0) == INTEGER_CST
10296 && tree_int_cst_lt (lit0, minus_lit0))
10298 minus_lit0 = associate_trees (minus_lit0, lit0,
10304 lit0 = associate_trees (lit0, minus_lit0,
10312 return fold_convert (type,
10313 associate_trees (var0, minus_lit0,
10314 MINUS_EXPR, type));
10317 con0 = associate_trees (con0, minus_lit0,
10319 return fold_convert (type,
10320 associate_trees (var0, con0,
10325 con0 = associate_trees (con0, lit0, code, type);
10326 return fold_convert (type, associate_trees (var0, con0,
10334 /* Pointer simplifications for subtraction, simple reassociations. */
10335 if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10337 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10338 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10339 && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10341 tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10342 tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10343 tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10344 tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10345 return fold_build2 (PLUS_EXPR, type,
10346 fold_build2 (MINUS_EXPR, type, arg00, arg10),
10347 fold_build2 (MINUS_EXPR, type, arg01, arg11));
10349 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10350 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10352 tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10353 tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10354 tree tmp = fold_binary (MINUS_EXPR, type, arg00, fold_convert (type, arg1));
10356 return fold_build2 (PLUS_EXPR, type, tmp, arg01);
10359 /* A - (-B) -> A + B */
10360 if (TREE_CODE (arg1) == NEGATE_EXPR)
10361 return fold_build2 (PLUS_EXPR, type, op0,
10362 fold_convert (type, TREE_OPERAND (arg1, 0)));
10363 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10364 if (TREE_CODE (arg0) == NEGATE_EXPR
10365 && (FLOAT_TYPE_P (type)
10366 || INTEGRAL_TYPE_P (type))
10367 && negate_expr_p (arg1)
10368 && reorder_operands_p (arg0, arg1))
10369 return fold_build2 (MINUS_EXPR, type,
10370 fold_convert (type, negate_expr (arg1)),
10371 fold_convert (type, TREE_OPERAND (arg0, 0)));
10372 /* Convert -A - 1 to ~A. */
10373 if (INTEGRAL_TYPE_P (type)
10374 && TREE_CODE (arg0) == NEGATE_EXPR
10375 && integer_onep (arg1)
10376 && !TYPE_OVERFLOW_TRAPS (type))
10377 return fold_build1 (BIT_NOT_EXPR, type,
10378 fold_convert (type, TREE_OPERAND (arg0, 0)));
10380 /* Convert -1 - A to ~A. */
10381 if (INTEGRAL_TYPE_P (type)
10382 && integer_all_onesp (arg0))
10383 return fold_build1 (BIT_NOT_EXPR, type, op1);
10386 /* X - (X / CST) * CST is X % CST. */
10387 if (INTEGRAL_TYPE_P (type)
10388 && TREE_CODE (arg1) == MULT_EXPR
10389 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10390 && operand_equal_p (arg0,
10391 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10392 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10393 TREE_OPERAND (arg1, 1), 0))
10394 return fold_convert (type,
10395 fold_build2 (TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10396 arg0, TREE_OPERAND (arg1, 1)));
10398 if (! FLOAT_TYPE_P (type))
10400 if (integer_zerop (arg0))
10401 return negate_expr (fold_convert (type, arg1));
10402 if (integer_zerop (arg1))
10403 return non_lvalue (fold_convert (type, arg0));
10405 /* Fold A - (A & B) into ~B & A. */
10406 if (!TREE_SIDE_EFFECTS (arg0)
10407 && TREE_CODE (arg1) == BIT_AND_EXPR)
10409 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10411 tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10412 return fold_build2 (BIT_AND_EXPR, type,
10413 fold_build1 (BIT_NOT_EXPR, type, arg10),
10414 fold_convert (type, arg0));
10416 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10418 tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10419 return fold_build2 (BIT_AND_EXPR, type,
10420 fold_build1 (BIT_NOT_EXPR, type, arg11),
10421 fold_convert (type, arg0));
10425 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10426 any power of 2 minus 1. */
10427 if (TREE_CODE (arg0) == BIT_AND_EXPR
10428 && TREE_CODE (arg1) == BIT_AND_EXPR
10429 && operand_equal_p (TREE_OPERAND (arg0, 0),
10430 TREE_OPERAND (arg1, 0), 0))
10432 tree mask0 = TREE_OPERAND (arg0, 1);
10433 tree mask1 = TREE_OPERAND (arg1, 1);
10434 tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
10436 if (operand_equal_p (tem, mask1, 0))
10438 tem = fold_build2 (BIT_XOR_EXPR, type,
10439 TREE_OPERAND (arg0, 0), mask1);
10440 return fold_build2 (MINUS_EXPR, type, tem, mask1);
10445 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10446 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10447 return non_lvalue (fold_convert (type, arg0));
10449 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10450 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10451 (-ARG1 + ARG0) reduces to -ARG1. */
10452 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10453 return negate_expr (fold_convert (type, arg1));
10455 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10456 __complex__ ( x, -y ). This is not the same for SNaNs or if
10457 signed zeros are involved. */
10458 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10459 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10460 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10462 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10463 tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
10464 tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
10465 bool arg0rz = false, arg0iz = false;
10466 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10467 || (arg0i && (arg0iz = real_zerop (arg0i))))
10469 tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
10470 tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
10471 if (arg0rz && arg1i && real_zerop (arg1i))
10473 tree rp = fold_build1 (NEGATE_EXPR, rtype,
10475 : build1 (REALPART_EXPR, rtype, arg1));
10476 tree ip = arg0i ? arg0i
10477 : build1 (IMAGPART_EXPR, rtype, arg0);
10478 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10480 else if (arg0iz && arg1r && real_zerop (arg1r))
10482 tree rp = arg0r ? arg0r
10483 : build1 (REALPART_EXPR, rtype, arg0);
10484 tree ip = fold_build1 (NEGATE_EXPR, rtype,
10486 : build1 (IMAGPART_EXPR, rtype, arg1));
10487 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10492 /* Fold &x - &x. This can happen from &x.foo - &x.
10493 This is unsafe for certain floats even in non-IEEE formats.
10494 In IEEE, it is unsafe because it does wrong for NaNs.
10495 Also note that operand_equal_p is always false if an operand
10498 if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
10499 && operand_equal_p (arg0, arg1, 0))
10500 return fold_convert (type, integer_zero_node);
10502 /* A - B -> A + (-B) if B is easily negatable. */
10503 if (negate_expr_p (arg1)
10504 && ((FLOAT_TYPE_P (type)
10505 /* Avoid this transformation if B is a positive REAL_CST. */
10506 && (TREE_CODE (arg1) != REAL_CST
10507 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10508 || INTEGRAL_TYPE_P (type)))
10509 return fold_build2 (PLUS_EXPR, type,
10510 fold_convert (type, arg0),
10511 fold_convert (type, negate_expr (arg1)));
10513 /* Try folding difference of addresses. */
10515 HOST_WIDE_INT diff;
10517 if ((TREE_CODE (arg0) == ADDR_EXPR
10518 || TREE_CODE (arg1) == ADDR_EXPR)
10519 && ptr_difference_const (arg0, arg1, &diff))
10520 return build_int_cst_type (type, diff);
10523 /* Fold &a[i] - &a[j] to i-j. */
10524 if (TREE_CODE (arg0) == ADDR_EXPR
10525 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10526 && TREE_CODE (arg1) == ADDR_EXPR
10527 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10529 tree aref0 = TREE_OPERAND (arg0, 0);
10530 tree aref1 = TREE_OPERAND (arg1, 0);
10531 if (operand_equal_p (TREE_OPERAND (aref0, 0),
10532 TREE_OPERAND (aref1, 0), 0))
10534 tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
10535 tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
10536 tree esz = array_ref_element_size (aref0);
10537 tree diff = build2 (MINUS_EXPR, type, op0, op1);
10538 return fold_build2 (MULT_EXPR, type, diff,
10539 fold_convert (type, esz));
10544 if (FLOAT_TYPE_P (type)
10545 && flag_unsafe_math_optimizations
10546 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10547 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10548 && (tem = distribute_real_division (code, type, arg0, arg1)))
10551 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
10552 same or one. Make sure type is not saturating.
10553 fold_plusminus_mult_expr will re-associate. */
10554 if ((TREE_CODE (arg0) == MULT_EXPR
10555 || TREE_CODE (arg1) == MULT_EXPR)
10556 && !TYPE_SATURATING (type)
10557 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10559 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
10567 /* (-A) * (-B) -> A * B */
10568 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10569 return fold_build2 (MULT_EXPR, type,
10570 fold_convert (type, TREE_OPERAND (arg0, 0)),
10571 fold_convert (type, negate_expr (arg1)));
10572 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10573 return fold_build2 (MULT_EXPR, type,
10574 fold_convert (type, negate_expr (arg0)),
10575 fold_convert (type, TREE_OPERAND (arg1, 0)));
10577 if (! FLOAT_TYPE_P (type))
10579 if (integer_zerop (arg1))
10580 return omit_one_operand (type, arg1, arg0);
10581 if (integer_onep (arg1))
10582 return non_lvalue (fold_convert (type, arg0));
10583 /* Transform x * -1 into -x. Make sure to do the negation
10584 on the original operand with conversions not stripped
10585 because we can only strip non-sign-changing conversions. */
10586 if (integer_all_onesp (arg1))
10587 return fold_convert (type, negate_expr (op0));
10588 /* Transform x * -C into -x * C if x is easily negatable. */
10589 if (TREE_CODE (arg1) == INTEGER_CST
10590 && tree_int_cst_sgn (arg1) == -1
10591 && negate_expr_p (arg0)
10592 && (tem = negate_expr (arg1)) != arg1
10593 && !TREE_OVERFLOW (tem))
10594 return fold_build2 (MULT_EXPR, type,
10595 fold_convert (type, negate_expr (arg0)), tem);
10597 /* (a * (1 << b)) is (a << b) */
10598 if (TREE_CODE (arg1) == LSHIFT_EXPR
10599 && integer_onep (TREE_OPERAND (arg1, 0)))
10600 return fold_build2 (LSHIFT_EXPR, type, op0,
10601 TREE_OPERAND (arg1, 1));
10602 if (TREE_CODE (arg0) == LSHIFT_EXPR
10603 && integer_onep (TREE_OPERAND (arg0, 0)))
10604 return fold_build2 (LSHIFT_EXPR, type, op1,
10605 TREE_OPERAND (arg0, 1));
10607 /* (A + A) * C -> A * 2 * C */
10608 if (TREE_CODE (arg0) == PLUS_EXPR
10609 && TREE_CODE (arg1) == INTEGER_CST
10610 && operand_equal_p (TREE_OPERAND (arg0, 0),
10611 TREE_OPERAND (arg0, 1), 0))
10612 return fold_build2 (MULT_EXPR, type,
10613 omit_one_operand (type, TREE_OPERAND (arg0, 0),
10614 TREE_OPERAND (arg0, 1)),
10615 fold_build2 (MULT_EXPR, type,
10616 build_int_cst (type, 2) , arg1));
10618 strict_overflow_p = false;
10619 if (TREE_CODE (arg1) == INTEGER_CST
10620 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10621 &strict_overflow_p)))
10623 if (strict_overflow_p)
10624 fold_overflow_warning (("assuming signed overflow does not "
10625 "occur when simplifying "
10627 WARN_STRICT_OVERFLOW_MISC);
10628 return fold_convert (type, tem);
10631 /* Optimize z * conj(z) for integer complex numbers. */
10632 if (TREE_CODE (arg0) == CONJ_EXPR
10633 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10634 return fold_mult_zconjz (type, arg1);
10635 if (TREE_CODE (arg1) == CONJ_EXPR
10636 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10637 return fold_mult_zconjz (type, arg0);
10641 /* Maybe fold x * 0 to 0. The expressions aren't the same
10642 when x is NaN, since x * 0 is also NaN. Nor are they the
10643 same in modes with signed zeros, since multiplying a
10644 negative value by 0 gives -0, not +0. */
10645 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10646 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10647 && real_zerop (arg1))
10648 return omit_one_operand (type, arg1, arg0);
10649 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10650 Likewise for complex arithmetic with signed zeros. */
10651 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10652 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10653 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10654 && real_onep (arg1))
10655 return non_lvalue (fold_convert (type, arg0));
10657 /* Transform x * -1.0 into -x. */
10658 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10659 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10660 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10661 && real_minus_onep (arg1))
10662 return fold_convert (type, negate_expr (arg0));
10664 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10665 the result for floating point types due to rounding so it is applied
10666 only if -fassociative-math was specify. */
10667 if (flag_associative_math
10668 && TREE_CODE (arg0) == RDIV_EXPR
10669 && TREE_CODE (arg1) == REAL_CST
10670 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10672 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10675 return fold_build2 (RDIV_EXPR, type, tem,
10676 TREE_OPERAND (arg0, 1));
10679 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10680 if (operand_equal_p (arg0, arg1, 0))
10682 tree tem = fold_strip_sign_ops (arg0);
10683 if (tem != NULL_TREE)
10685 tem = fold_convert (type, tem);
10686 return fold_build2 (MULT_EXPR, type, tem, tem);
10690 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10691 This is not the same for NaNs or if signed zeros are
10693 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10694 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10695 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10696 && TREE_CODE (arg1) == COMPLEX_CST
10697 && real_zerop (TREE_REALPART (arg1)))
10699 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10700 if (real_onep (TREE_IMAGPART (arg1)))
10701 return fold_build2 (COMPLEX_EXPR, type,
10702 negate_expr (fold_build1 (IMAGPART_EXPR,
10704 fold_build1 (REALPART_EXPR, rtype, arg0));
10705 else if (real_minus_onep (TREE_IMAGPART (arg1)))
10706 return fold_build2 (COMPLEX_EXPR, type,
10707 fold_build1 (IMAGPART_EXPR, rtype, arg0),
10708 negate_expr (fold_build1 (REALPART_EXPR,
10712 /* Optimize z * conj(z) for floating point complex numbers.
10713 Guarded by flag_unsafe_math_optimizations as non-finite
10714 imaginary components don't produce scalar results. */
10715 if (flag_unsafe_math_optimizations
10716 && TREE_CODE (arg0) == CONJ_EXPR
10717 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10718 return fold_mult_zconjz (type, arg1);
10719 if (flag_unsafe_math_optimizations
10720 && TREE_CODE (arg1) == CONJ_EXPR
10721 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10722 return fold_mult_zconjz (type, arg0);
10724 if (flag_unsafe_math_optimizations)
10726 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10727 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10729 /* Optimizations of root(...)*root(...). */
10730 if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10733 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10734 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10736 /* Optimize sqrt(x)*sqrt(x) as x. */
10737 if (BUILTIN_SQRT_P (fcode0)
10738 && operand_equal_p (arg00, arg10, 0)
10739 && ! HONOR_SNANS (TYPE_MODE (type)))
10742 /* Optimize root(x)*root(y) as root(x*y). */
10743 rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10744 arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10745 return build_call_expr (rootfn, 1, arg);
10748 /* Optimize expN(x)*expN(y) as expN(x+y). */
10749 if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10751 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10752 tree arg = fold_build2 (PLUS_EXPR, type,
10753 CALL_EXPR_ARG (arg0, 0),
10754 CALL_EXPR_ARG (arg1, 0));
10755 return build_call_expr (expfn, 1, arg);
10758 /* Optimizations of pow(...)*pow(...). */
10759 if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10760 || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10761 || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10763 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10764 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10765 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10766 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10768 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
10769 if (operand_equal_p (arg01, arg11, 0))
10771 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10772 tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10773 return build_call_expr (powfn, 2, arg, arg01);
10776 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
10777 if (operand_equal_p (arg00, arg10, 0))
10779 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10780 tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
10781 return build_call_expr (powfn, 2, arg00, arg);
10785 /* Optimize tan(x)*cos(x) as sin(x). */
10786 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
10787 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
10788 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
10789 || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
10790 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
10791 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
10792 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
10793 CALL_EXPR_ARG (arg1, 0), 0))
10795 tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
10797 if (sinfn != NULL_TREE)
10798 return build_call_expr (sinfn, 1, CALL_EXPR_ARG (arg0, 0));
10801 /* Optimize x*pow(x,c) as pow(x,c+1). */
10802 if (fcode1 == BUILT_IN_POW
10803 || fcode1 == BUILT_IN_POWF
10804 || fcode1 == BUILT_IN_POWL)
10806 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10807 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10808 if (TREE_CODE (arg11) == REAL_CST
10809 && !TREE_OVERFLOW (arg11)
10810 && operand_equal_p (arg0, arg10, 0))
10812 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
10816 c = TREE_REAL_CST (arg11);
10817 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10818 arg = build_real (type, c);
10819 return build_call_expr (powfn, 2, arg0, arg);
10823 /* Optimize pow(x,c)*x as pow(x,c+1). */
10824 if (fcode0 == BUILT_IN_POW
10825 || fcode0 == BUILT_IN_POWF
10826 || fcode0 == BUILT_IN_POWL)
10828 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10829 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10830 if (TREE_CODE (arg01) == REAL_CST
10831 && !TREE_OVERFLOW (arg01)
10832 && operand_equal_p (arg1, arg00, 0))
10834 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10838 c = TREE_REAL_CST (arg01);
10839 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10840 arg = build_real (type, c);
10841 return build_call_expr (powfn, 2, arg1, arg);
10845 /* Optimize x*x as pow(x,2.0), which is expanded as x*x. */
10846 if (optimize_function_for_speed_p (cfun)
10847 && operand_equal_p (arg0, arg1, 0))
10849 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10853 tree arg = build_real (type, dconst2);
10854 return build_call_expr (powfn, 2, arg0, arg);
10863 if (integer_all_onesp (arg1))
10864 return omit_one_operand (type, arg1, arg0);
10865 if (integer_zerop (arg1))
10866 return non_lvalue (fold_convert (type, arg0));
10867 if (operand_equal_p (arg0, arg1, 0))
10868 return non_lvalue (fold_convert (type, arg0));
10870 /* ~X | X is -1. */
10871 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10872 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10874 t1 = fold_convert (type, integer_zero_node);
10875 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10876 return omit_one_operand (type, t1, arg1);
10879 /* X | ~X is -1. */
10880 if (TREE_CODE (arg1) == BIT_NOT_EXPR
10881 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10883 t1 = fold_convert (type, integer_zero_node);
10884 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10885 return omit_one_operand (type, t1, arg0);
10888 /* Canonicalize (X & C1) | C2. */
10889 if (TREE_CODE (arg0) == BIT_AND_EXPR
10890 && TREE_CODE (arg1) == INTEGER_CST
10891 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10893 unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, hi3, lo3, mlo, mhi;
10894 int width = TYPE_PRECISION (type), w;
10895 hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
10896 lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10897 hi2 = TREE_INT_CST_HIGH (arg1);
10898 lo2 = TREE_INT_CST_LOW (arg1);
10900 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
10901 if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
10902 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10904 if (width > HOST_BITS_PER_WIDE_INT)
10906 mhi = (unsigned HOST_WIDE_INT) -1
10907 >> (2 * HOST_BITS_PER_WIDE_INT - width);
10913 mlo = (unsigned HOST_WIDE_INT) -1
10914 >> (HOST_BITS_PER_WIDE_INT - width);
10917 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
10918 if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
10919 return fold_build2 (BIT_IOR_EXPR, type,
10920 TREE_OPERAND (arg0, 0), arg1);
10922 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10923 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10924 mode which allows further optimizations. */
10931 for (w = BITS_PER_UNIT;
10932 w <= width && w <= HOST_BITS_PER_WIDE_INT;
10935 unsigned HOST_WIDE_INT mask
10936 = (unsigned HOST_WIDE_INT) -1 >> (HOST_BITS_PER_WIDE_INT - w);
10937 if (((lo1 | lo2) & mask) == mask
10938 && (lo1 & ~mask) == 0 && hi1 == 0)
10945 if (hi3 != hi1 || lo3 != lo1)
10946 return fold_build2 (BIT_IOR_EXPR, type,
10947 fold_build2 (BIT_AND_EXPR, type,
10948 TREE_OPERAND (arg0, 0),
10949 build_int_cst_wide (type,
10954 /* (X & Y) | Y is (X, Y). */
10955 if (TREE_CODE (arg0) == BIT_AND_EXPR
10956 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10957 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10958 /* (X & Y) | X is (Y, X). */
10959 if (TREE_CODE (arg0) == BIT_AND_EXPR
10960 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10961 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10962 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
10963 /* X | (X & Y) is (Y, X). */
10964 if (TREE_CODE (arg1) == BIT_AND_EXPR
10965 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10966 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10967 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
10968 /* X | (Y & X) is (Y, X). */
10969 if (TREE_CODE (arg1) == BIT_AND_EXPR
10970 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10971 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10972 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
10974 t1 = distribute_bit_expr (code, type, arg0, arg1);
10975 if (t1 != NULL_TREE)
10978 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
10980 This results in more efficient code for machines without a NAND
10981 instruction. Combine will canonicalize to the first form
10982 which will allow use of NAND instructions provided by the
10983 backend if they exist. */
10984 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10985 && TREE_CODE (arg1) == BIT_NOT_EXPR)
10987 return fold_build1 (BIT_NOT_EXPR, type,
10988 build2 (BIT_AND_EXPR, type,
10989 fold_convert (type,
10990 TREE_OPERAND (arg0, 0)),
10991 fold_convert (type,
10992 TREE_OPERAND (arg1, 0))));
10995 /* See if this can be simplified into a rotate first. If that
10996 is unsuccessful continue in the association code. */
11000 if (integer_zerop (arg1))
11001 return non_lvalue (fold_convert (type, arg0));
11002 if (integer_all_onesp (arg1))
11003 return fold_build1 (BIT_NOT_EXPR, type, op0);
11004 if (operand_equal_p (arg0, arg1, 0))
11005 return omit_one_operand (type, integer_zero_node, arg0);
11007 /* ~X ^ X is -1. */
11008 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11009 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11011 t1 = fold_convert (type, integer_zero_node);
11012 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
11013 return omit_one_operand (type, t1, arg1);
11016 /* X ^ ~X is -1. */
11017 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11018 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11020 t1 = fold_convert (type, integer_zero_node);
11021 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
11022 return omit_one_operand (type, t1, arg0);
11025 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11026 with a constant, and the two constants have no bits in common,
11027 we should treat this as a BIT_IOR_EXPR since this may produce more
11028 simplifications. */
11029 if (TREE_CODE (arg0) == BIT_AND_EXPR
11030 && TREE_CODE (arg1) == BIT_AND_EXPR
11031 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11032 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11033 && integer_zerop (const_binop (BIT_AND_EXPR,
11034 TREE_OPERAND (arg0, 1),
11035 TREE_OPERAND (arg1, 1), 0)))
11037 code = BIT_IOR_EXPR;
11041 /* (X | Y) ^ X -> Y & ~ X*/
11042 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11043 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11045 tree t2 = TREE_OPERAND (arg0, 1);
11046 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
11048 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11049 fold_convert (type, t1));
11053 /* (Y | X) ^ X -> Y & ~ X*/
11054 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11055 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11057 tree t2 = TREE_OPERAND (arg0, 0);
11058 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
11060 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11061 fold_convert (type, t1));
11065 /* X ^ (X | Y) -> Y & ~ X*/
11066 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11067 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11069 tree t2 = TREE_OPERAND (arg1, 1);
11070 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
11072 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11073 fold_convert (type, t1));
11077 /* X ^ (Y | X) -> Y & ~ X*/
11078 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11079 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11081 tree t2 = TREE_OPERAND (arg1, 0);
11082 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
11084 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11085 fold_convert (type, t1));
11089 /* Convert ~X ^ ~Y to X ^ Y. */
11090 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11091 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11092 return fold_build2 (code, type,
11093 fold_convert (type, TREE_OPERAND (arg0, 0)),
11094 fold_convert (type, TREE_OPERAND (arg1, 0)));
11096 /* Convert ~X ^ C to X ^ ~C. */
11097 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11098 && TREE_CODE (arg1) == INTEGER_CST)
11099 return fold_build2 (code, type,
11100 fold_convert (type, TREE_OPERAND (arg0, 0)),
11101 fold_build1 (BIT_NOT_EXPR, type, arg1));
11103 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11104 if (TREE_CODE (arg0) == BIT_AND_EXPR
11105 && integer_onep (TREE_OPERAND (arg0, 1))
11106 && integer_onep (arg1))
11107 return fold_build2 (EQ_EXPR, type, arg0,
11108 build_int_cst (TREE_TYPE (arg0), 0));
11110 /* Fold (X & Y) ^ Y as ~X & Y. */
11111 if (TREE_CODE (arg0) == BIT_AND_EXPR
11112 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11114 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
11115 return fold_build2 (BIT_AND_EXPR, type,
11116 fold_build1 (BIT_NOT_EXPR, type, tem),
11117 fold_convert (type, arg1));
11119 /* Fold (X & Y) ^ X as ~Y & X. */
11120 if (TREE_CODE (arg0) == BIT_AND_EXPR
11121 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11122 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11124 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
11125 return fold_build2 (BIT_AND_EXPR, type,
11126 fold_build1 (BIT_NOT_EXPR, type, tem),
11127 fold_convert (type, arg1));
11129 /* Fold X ^ (X & Y) as X & ~Y. */
11130 if (TREE_CODE (arg1) == BIT_AND_EXPR
11131 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11133 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
11134 return fold_build2 (BIT_AND_EXPR, type,
11135 fold_convert (type, arg0),
11136 fold_build1 (BIT_NOT_EXPR, type, tem));
11138 /* Fold X ^ (Y & X) as ~Y & X. */
11139 if (TREE_CODE (arg1) == BIT_AND_EXPR
11140 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11141 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11143 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
11144 return fold_build2 (BIT_AND_EXPR, type,
11145 fold_build1 (BIT_NOT_EXPR, type, tem),
11146 fold_convert (type, arg0));
11149 /* See if this can be simplified into a rotate first. If that
11150 is unsuccessful continue in the association code. */
11154 if (integer_all_onesp (arg1))
11155 return non_lvalue (fold_convert (type, arg0));
11156 if (integer_zerop (arg1))
11157 return omit_one_operand (type, arg1, arg0);
11158 if (operand_equal_p (arg0, arg1, 0))
11159 return non_lvalue (fold_convert (type, arg0));
11161 /* ~X & X is always zero. */
11162 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11163 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11164 return omit_one_operand (type, integer_zero_node, arg1);
11166 /* X & ~X is always zero. */
11167 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11168 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11169 return omit_one_operand (type, integer_zero_node, arg0);
11171 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11172 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11173 && TREE_CODE (arg1) == INTEGER_CST
11174 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11176 tree tmp1 = fold_convert (type, arg1);
11177 tree tmp2 = fold_convert (type, TREE_OPERAND (arg0, 0));
11178 tree tmp3 = fold_convert (type, TREE_OPERAND (arg0, 1));
11179 tmp2 = fold_build2 (BIT_AND_EXPR, type, tmp2, tmp1);
11180 tmp3 = fold_build2 (BIT_AND_EXPR, type, tmp3, tmp1);
11181 return fold_convert (type,
11182 fold_build2 (BIT_IOR_EXPR, type, tmp2, tmp3));
11185 /* (X | Y) & Y is (X, Y). */
11186 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11187 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11188 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
11189 /* (X | Y) & X is (Y, X). */
11190 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11191 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11192 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11193 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
11194 /* X & (X | Y) is (Y, X). */
11195 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11196 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11197 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11198 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
11199 /* X & (Y | X) is (Y, X). */
11200 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11201 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11202 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11203 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
11205 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11206 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11207 && integer_onep (TREE_OPERAND (arg0, 1))
11208 && integer_onep (arg1))
11210 tem = TREE_OPERAND (arg0, 0);
11211 return fold_build2 (EQ_EXPR, type,
11212 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
11213 build_int_cst (TREE_TYPE (tem), 1)),
11214 build_int_cst (TREE_TYPE (tem), 0));
11216 /* Fold ~X & 1 as (X & 1) == 0. */
11217 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11218 && integer_onep (arg1))
11220 tem = TREE_OPERAND (arg0, 0);
11221 return fold_build2 (EQ_EXPR, type,
11222 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
11223 build_int_cst (TREE_TYPE (tem), 1)),
11224 build_int_cst (TREE_TYPE (tem), 0));
11227 /* Fold (X ^ Y) & Y as ~X & Y. */
11228 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11229 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11231 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
11232 return fold_build2 (BIT_AND_EXPR, type,
11233 fold_build1 (BIT_NOT_EXPR, type, tem),
11234 fold_convert (type, arg1));
11236 /* Fold (X ^ Y) & X as ~Y & X. */
11237 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11238 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11239 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11241 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
11242 return fold_build2 (BIT_AND_EXPR, type,
11243 fold_build1 (BIT_NOT_EXPR, type, tem),
11244 fold_convert (type, arg1));
11246 /* Fold X & (X ^ Y) as X & ~Y. */
11247 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11248 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11250 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
11251 return fold_build2 (BIT_AND_EXPR, type,
11252 fold_convert (type, arg0),
11253 fold_build1 (BIT_NOT_EXPR, type, tem));
11255 /* Fold X & (Y ^ X) as ~Y & X. */
11256 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11257 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11258 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11260 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
11261 return fold_build2 (BIT_AND_EXPR, type,
11262 fold_build1 (BIT_NOT_EXPR, type, tem),
11263 fold_convert (type, arg0));
11266 t1 = distribute_bit_expr (code, type, arg0, arg1);
11267 if (t1 != NULL_TREE)
11269 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11270 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11271 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11274 = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11276 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
11277 && (~TREE_INT_CST_LOW (arg1)
11278 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
11279 return fold_convert (type, TREE_OPERAND (arg0, 0));
11282 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11284 This results in more efficient code for machines without a NOR
11285 instruction. Combine will canonicalize to the first form
11286 which will allow use of NOR instructions provided by the
11287 backend if they exist. */
11288 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11289 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11291 return fold_build1 (BIT_NOT_EXPR, type,
11292 build2 (BIT_IOR_EXPR, type,
11293 fold_convert (type,
11294 TREE_OPERAND (arg0, 0)),
11295 fold_convert (type,
11296 TREE_OPERAND (arg1, 0))));
11299 /* If arg0 is derived from the address of an object or function, we may
11300 be able to fold this expression using the object or function's
11302 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
11304 unsigned HOST_WIDE_INT modulus, residue;
11305 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
11307 modulus = get_pointer_modulus_and_residue (arg0, &residue,
11308 integer_onep (arg1));
11310 /* This works because modulus is a power of 2. If this weren't the
11311 case, we'd have to replace it by its greatest power-of-2
11312 divisor: modulus & -modulus. */
11314 return build_int_cst (type, residue & low);
11317 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11318 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11319 if the new mask might be further optimized. */
11320 if ((TREE_CODE (arg0) == LSHIFT_EXPR
11321 || TREE_CODE (arg0) == RSHIFT_EXPR)
11322 && host_integerp (TREE_OPERAND (arg0, 1), 1)
11323 && host_integerp (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)))
11324 && tree_low_cst (TREE_OPERAND (arg0, 1), 1)
11325 < TYPE_PRECISION (TREE_TYPE (arg0))
11326 && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11327 && tree_low_cst (TREE_OPERAND (arg0, 1), 1) > 0)
11329 unsigned int shiftc = tree_low_cst (TREE_OPERAND (arg0, 1), 1);
11330 unsigned HOST_WIDE_INT mask
11331 = tree_low_cst (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)));
11332 unsigned HOST_WIDE_INT newmask, zerobits = 0;
11333 tree shift_type = TREE_TYPE (arg0);
11335 if (TREE_CODE (arg0) == LSHIFT_EXPR)
11336 zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11337 else if (TREE_CODE (arg0) == RSHIFT_EXPR
11338 && TYPE_PRECISION (TREE_TYPE (arg0))
11339 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0))))
11341 unsigned int prec = TYPE_PRECISION (TREE_TYPE (arg0));
11342 tree arg00 = TREE_OPERAND (arg0, 0);
11343 /* See if more bits can be proven as zero because of
11345 if (TREE_CODE (arg00) == NOP_EXPR
11346 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11348 tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11349 if (TYPE_PRECISION (inner_type)
11350 == GET_MODE_BITSIZE (TYPE_MODE (inner_type))
11351 && TYPE_PRECISION (inner_type) < prec)
11353 prec = TYPE_PRECISION (inner_type);
11354 /* See if we can shorten the right shift. */
11356 shift_type = inner_type;
11359 zerobits = ~(unsigned HOST_WIDE_INT) 0;
11360 zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11361 zerobits <<= prec - shiftc;
11362 /* For arithmetic shift if sign bit could be set, zerobits
11363 can contain actually sign bits, so no transformation is
11364 possible, unless MASK masks them all away. In that
11365 case the shift needs to be converted into logical shift. */
11366 if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11367 && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11369 if ((mask & zerobits) == 0)
11370 shift_type = unsigned_type_for (TREE_TYPE (arg0));
11376 /* ((X << 16) & 0xff00) is (X, 0). */
11377 if ((mask & zerobits) == mask)
11378 return omit_one_operand (type, build_int_cst (type, 0), arg0);
11380 newmask = mask | zerobits;
11381 if (newmask != mask && (newmask & (newmask + 1)) == 0)
11385 /* Only do the transformation if NEWMASK is some integer
11387 for (prec = BITS_PER_UNIT;
11388 prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11389 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11391 if (prec < HOST_BITS_PER_WIDE_INT
11392 || newmask == ~(unsigned HOST_WIDE_INT) 0)
11396 if (shift_type != TREE_TYPE (arg0))
11398 tem = fold_build2 (TREE_CODE (arg0), shift_type,
11399 fold_convert (shift_type,
11400 TREE_OPERAND (arg0, 0)),
11401 TREE_OPERAND (arg0, 1));
11402 tem = fold_convert (type, tem);
11406 newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
11407 if (!tree_int_cst_equal (newmaskt, arg1))
11408 return fold_build2 (BIT_AND_EXPR, type, tem, newmaskt);
11416 /* Don't touch a floating-point divide by zero unless the mode
11417 of the constant can represent infinity. */
11418 if (TREE_CODE (arg1) == REAL_CST
11419 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11420 && real_zerop (arg1))
11423 /* Optimize A / A to 1.0 if we don't care about
11424 NaNs or Infinities. Skip the transformation
11425 for non-real operands. */
11426 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11427 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11428 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11429 && operand_equal_p (arg0, arg1, 0))
11431 tree r = build_real (TREE_TYPE (arg0), dconst1);
11433 return omit_two_operands (type, r, arg0, arg1);
11436 /* The complex version of the above A / A optimization. */
11437 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11438 && operand_equal_p (arg0, arg1, 0))
11440 tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11441 if (! HONOR_NANS (TYPE_MODE (elem_type))
11442 && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11444 tree r = build_real (elem_type, dconst1);
11445 /* omit_two_operands will call fold_convert for us. */
11446 return omit_two_operands (type, r, arg0, arg1);
11450 /* (-A) / (-B) -> A / B */
11451 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11452 return fold_build2 (RDIV_EXPR, type,
11453 TREE_OPERAND (arg0, 0),
11454 negate_expr (arg1));
11455 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11456 return fold_build2 (RDIV_EXPR, type,
11457 negate_expr (arg0),
11458 TREE_OPERAND (arg1, 0));
11460 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11461 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11462 && real_onep (arg1))
11463 return non_lvalue (fold_convert (type, arg0));
11465 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11466 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11467 && real_minus_onep (arg1))
11468 return non_lvalue (fold_convert (type, negate_expr (arg0)));
11470 /* If ARG1 is a constant, we can convert this to a multiply by the
11471 reciprocal. This does not have the same rounding properties,
11472 so only do this if -freciprocal-math. We can actually
11473 always safely do it if ARG1 is a power of two, but it's hard to
11474 tell if it is or not in a portable manner. */
11475 if (TREE_CODE (arg1) == REAL_CST)
11477 if (flag_reciprocal_math
11478 && 0 != (tem = const_binop (code, build_real (type, dconst1),
11480 return fold_build2 (MULT_EXPR, type, arg0, tem);
11481 /* Find the reciprocal if optimizing and the result is exact. */
11485 r = TREE_REAL_CST (arg1);
11486 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
11488 tem = build_real (type, r);
11489 return fold_build2 (MULT_EXPR, type,
11490 fold_convert (type, arg0), tem);
11494 /* Convert A/B/C to A/(B*C). */
11495 if (flag_reciprocal_math
11496 && TREE_CODE (arg0) == RDIV_EXPR)
11497 return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11498 fold_build2 (MULT_EXPR, type,
11499 TREE_OPERAND (arg0, 1), arg1));
11501 /* Convert A/(B/C) to (A/B)*C. */
11502 if (flag_reciprocal_math
11503 && TREE_CODE (arg1) == RDIV_EXPR)
11504 return fold_build2 (MULT_EXPR, type,
11505 fold_build2 (RDIV_EXPR, type, arg0,
11506 TREE_OPERAND (arg1, 0)),
11507 TREE_OPERAND (arg1, 1));
11509 /* Convert C1/(X*C2) into (C1/C2)/X. */
11510 if (flag_reciprocal_math
11511 && TREE_CODE (arg1) == MULT_EXPR
11512 && TREE_CODE (arg0) == REAL_CST
11513 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11515 tree tem = const_binop (RDIV_EXPR, arg0,
11516 TREE_OPERAND (arg1, 1), 0);
11518 return fold_build2 (RDIV_EXPR, type, tem,
11519 TREE_OPERAND (arg1, 0));
11522 if (flag_unsafe_math_optimizations)
11524 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11525 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11527 /* Optimize sin(x)/cos(x) as tan(x). */
11528 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11529 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11530 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11531 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11532 CALL_EXPR_ARG (arg1, 0), 0))
11534 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11536 if (tanfn != NULL_TREE)
11537 return build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11540 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
11541 if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11542 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11543 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11544 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11545 CALL_EXPR_ARG (arg1, 0), 0))
11547 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11549 if (tanfn != NULL_TREE)
11551 tree tmp = build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11552 return fold_build2 (RDIV_EXPR, type,
11553 build_real (type, dconst1), tmp);
11557 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11558 NaNs or Infinities. */
11559 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11560 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11561 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11563 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11564 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11566 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11567 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11568 && operand_equal_p (arg00, arg01, 0))
11570 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11572 if (cosfn != NULL_TREE)
11573 return build_call_expr (cosfn, 1, arg00);
11577 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11578 NaNs or Infinities. */
11579 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11580 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11581 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11583 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11584 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11586 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11587 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11588 && operand_equal_p (arg00, arg01, 0))
11590 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11592 if (cosfn != NULL_TREE)
11594 tree tmp = build_call_expr (cosfn, 1, arg00);
11595 return fold_build2 (RDIV_EXPR, type,
11596 build_real (type, dconst1),
11602 /* Optimize pow(x,c)/x as pow(x,c-1). */
11603 if (fcode0 == BUILT_IN_POW
11604 || fcode0 == BUILT_IN_POWF
11605 || fcode0 == BUILT_IN_POWL)
11607 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11608 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11609 if (TREE_CODE (arg01) == REAL_CST
11610 && !TREE_OVERFLOW (arg01)
11611 && operand_equal_p (arg1, arg00, 0))
11613 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11617 c = TREE_REAL_CST (arg01);
11618 real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11619 arg = build_real (type, c);
11620 return build_call_expr (powfn, 2, arg1, arg);
11624 /* Optimize a/root(b/c) into a*root(c/b). */
11625 if (BUILTIN_ROOT_P (fcode1))
11627 tree rootarg = CALL_EXPR_ARG (arg1, 0);
11629 if (TREE_CODE (rootarg) == RDIV_EXPR)
11631 tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11632 tree b = TREE_OPERAND (rootarg, 0);
11633 tree c = TREE_OPERAND (rootarg, 1);
11635 tree tmp = fold_build2 (RDIV_EXPR, type, c, b);
11637 tmp = build_call_expr (rootfn, 1, tmp);
11638 return fold_build2 (MULT_EXPR, type, arg0, tmp);
11642 /* Optimize x/expN(y) into x*expN(-y). */
11643 if (BUILTIN_EXPONENT_P (fcode1))
11645 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11646 tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11647 arg1 = build_call_expr (expfn, 1, fold_convert (type, arg));
11648 return fold_build2 (MULT_EXPR, type, arg0, arg1);
11651 /* Optimize x/pow(y,z) into x*pow(y,-z). */
11652 if (fcode1 == BUILT_IN_POW
11653 || fcode1 == BUILT_IN_POWF
11654 || fcode1 == BUILT_IN_POWL)
11656 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11657 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11658 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11659 tree neg11 = fold_convert (type, negate_expr (arg11));
11660 arg1 = build_call_expr (powfn, 2, arg10, neg11);
11661 return fold_build2 (MULT_EXPR, type, arg0, arg1);
11666 case TRUNC_DIV_EXPR:
11667 case FLOOR_DIV_EXPR:
11668 /* Simplify A / (B << N) where A and B are positive and B is
11669 a power of 2, to A >> (N + log2(B)). */
11670 strict_overflow_p = false;
11671 if (TREE_CODE (arg1) == LSHIFT_EXPR
11672 && (TYPE_UNSIGNED (type)
11673 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11675 tree sval = TREE_OPERAND (arg1, 0);
11676 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
11678 tree sh_cnt = TREE_OPERAND (arg1, 1);
11679 unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
11681 if (strict_overflow_p)
11682 fold_overflow_warning (("assuming signed overflow does not "
11683 "occur when simplifying A / (B << N)"),
11684 WARN_STRICT_OVERFLOW_MISC);
11686 sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
11687 sh_cnt, build_int_cst (NULL_TREE, pow2));
11688 return fold_build2 (RSHIFT_EXPR, type,
11689 fold_convert (type, arg0), sh_cnt);
11693 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
11694 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
11695 if (INTEGRAL_TYPE_P (type)
11696 && TYPE_UNSIGNED (type)
11697 && code == FLOOR_DIV_EXPR)
11698 return fold_build2 (TRUNC_DIV_EXPR, type, op0, op1);
11702 case ROUND_DIV_EXPR:
11703 case CEIL_DIV_EXPR:
11704 case EXACT_DIV_EXPR:
11705 if (integer_onep (arg1))
11706 return non_lvalue (fold_convert (type, arg0));
11707 if (integer_zerop (arg1))
11709 /* X / -1 is -X. */
11710 if (!TYPE_UNSIGNED (type)
11711 && TREE_CODE (arg1) == INTEGER_CST
11712 && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11713 && TREE_INT_CST_HIGH (arg1) == -1)
11714 return fold_convert (type, negate_expr (arg0));
11716 /* Convert -A / -B to A / B when the type is signed and overflow is
11718 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11719 && TREE_CODE (arg0) == NEGATE_EXPR
11720 && negate_expr_p (arg1))
11722 if (INTEGRAL_TYPE_P (type))
11723 fold_overflow_warning (("assuming signed overflow does not occur "
11724 "when distributing negation across "
11726 WARN_STRICT_OVERFLOW_MISC);
11727 return fold_build2 (code, type,
11728 fold_convert (type, TREE_OPERAND (arg0, 0)),
11729 fold_convert (type, negate_expr (arg1)));
11731 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11732 && TREE_CODE (arg1) == NEGATE_EXPR
11733 && negate_expr_p (arg0))
11735 if (INTEGRAL_TYPE_P (type))
11736 fold_overflow_warning (("assuming signed overflow does not occur "
11737 "when distributing negation across "
11739 WARN_STRICT_OVERFLOW_MISC);
11740 return fold_build2 (code, type,
11741 fold_convert (type, negate_expr (arg0)),
11742 fold_convert (type, TREE_OPERAND (arg1, 0)));
11745 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
11746 operation, EXACT_DIV_EXPR.
11748 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
11749 At one time others generated faster code, it's not clear if they do
11750 after the last round to changes to the DIV code in expmed.c. */
11751 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
11752 && multiple_of_p (type, arg0, arg1))
11753 return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
11755 strict_overflow_p = false;
11756 if (TREE_CODE (arg1) == INTEGER_CST
11757 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11758 &strict_overflow_p)))
11760 if (strict_overflow_p)
11761 fold_overflow_warning (("assuming signed overflow does not occur "
11762 "when simplifying division"),
11763 WARN_STRICT_OVERFLOW_MISC);
11764 return fold_convert (type, tem);
11769 case CEIL_MOD_EXPR:
11770 case FLOOR_MOD_EXPR:
11771 case ROUND_MOD_EXPR:
11772 case TRUNC_MOD_EXPR:
11773 /* X % 1 is always zero, but be sure to preserve any side
11775 if (integer_onep (arg1))
11776 return omit_one_operand (type, integer_zero_node, arg0);
11778 /* X % 0, return X % 0 unchanged so that we can get the
11779 proper warnings and errors. */
11780 if (integer_zerop (arg1))
11783 /* 0 % X is always zero, but be sure to preserve any side
11784 effects in X. Place this after checking for X == 0. */
11785 if (integer_zerop (arg0))
11786 return omit_one_operand (type, integer_zero_node, arg1);
11788 /* X % -1 is zero. */
11789 if (!TYPE_UNSIGNED (type)
11790 && TREE_CODE (arg1) == INTEGER_CST
11791 && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11792 && TREE_INT_CST_HIGH (arg1) == -1)
11793 return omit_one_operand (type, integer_zero_node, arg0);
11795 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
11796 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
11797 strict_overflow_p = false;
11798 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
11799 && (TYPE_UNSIGNED (type)
11800 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11803 /* Also optimize A % (C << N) where C is a power of 2,
11804 to A & ((C << N) - 1). */
11805 if (TREE_CODE (arg1) == LSHIFT_EXPR)
11806 c = TREE_OPERAND (arg1, 0);
11808 if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
11810 tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1), arg1,
11811 build_int_cst (TREE_TYPE (arg1), 1));
11812 if (strict_overflow_p)
11813 fold_overflow_warning (("assuming signed overflow does not "
11814 "occur when simplifying "
11815 "X % (power of two)"),
11816 WARN_STRICT_OVERFLOW_MISC);
11817 return fold_build2 (BIT_AND_EXPR, type,
11818 fold_convert (type, arg0),
11819 fold_convert (type, mask));
11823 /* X % -C is the same as X % C. */
11824 if (code == TRUNC_MOD_EXPR
11825 && !TYPE_UNSIGNED (type)
11826 && TREE_CODE (arg1) == INTEGER_CST
11827 && !TREE_OVERFLOW (arg1)
11828 && TREE_INT_CST_HIGH (arg1) < 0
11829 && !TYPE_OVERFLOW_TRAPS (type)
11830 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
11831 && !sign_bit_p (arg1, arg1))
11832 return fold_build2 (code, type, fold_convert (type, arg0),
11833 fold_convert (type, negate_expr (arg1)));
11835 /* X % -Y is the same as X % Y. */
11836 if (code == TRUNC_MOD_EXPR
11837 && !TYPE_UNSIGNED (type)
11838 && TREE_CODE (arg1) == NEGATE_EXPR
11839 && !TYPE_OVERFLOW_TRAPS (type))
11840 return fold_build2 (code, type, fold_convert (type, arg0),
11841 fold_convert (type, TREE_OPERAND (arg1, 0)));
11843 if (TREE_CODE (arg1) == INTEGER_CST
11844 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11845 &strict_overflow_p)))
11847 if (strict_overflow_p)
11848 fold_overflow_warning (("assuming signed overflow does not occur "
11849 "when simplifying modulus"),
11850 WARN_STRICT_OVERFLOW_MISC);
11851 return fold_convert (type, tem);
11858 if (integer_all_onesp (arg0))
11859 return omit_one_operand (type, arg0, arg1);
11863 /* Optimize -1 >> x for arithmetic right shifts. */
11864 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
11865 && tree_expr_nonnegative_p (arg1))
11866 return omit_one_operand (type, arg0, arg1);
11867 /* ... fall through ... */
11871 if (integer_zerop (arg1))
11872 return non_lvalue (fold_convert (type, arg0));
11873 if (integer_zerop (arg0))
11874 return omit_one_operand (type, arg0, arg1);
11876 /* Since negative shift count is not well-defined,
11877 don't try to compute it in the compiler. */
11878 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
11881 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
11882 if (TREE_CODE (op0) == code && host_integerp (arg1, false)
11883 && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11884 && host_integerp (TREE_OPERAND (arg0, 1), false)
11885 && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11887 HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
11888 + TREE_INT_CST_LOW (arg1));
11890 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
11891 being well defined. */
11892 if (low >= TYPE_PRECISION (type))
11894 if (code == LROTATE_EXPR || code == RROTATE_EXPR)
11895 low = low % TYPE_PRECISION (type);
11896 else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
11897 return omit_one_operand (type, build_int_cst (type, 0),
11898 TREE_OPERAND (arg0, 0));
11900 low = TYPE_PRECISION (type) - 1;
11903 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
11904 build_int_cst (type, low));
11907 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
11908 into x & ((unsigned)-1 >> c) for unsigned types. */
11909 if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
11910 || (TYPE_UNSIGNED (type)
11911 && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
11912 && host_integerp (arg1, false)
11913 && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11914 && host_integerp (TREE_OPERAND (arg0, 1), false)
11915 && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11917 HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
11918 HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
11924 arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
11926 lshift = build_int_cst (type, -1);
11927 lshift = int_const_binop (code, lshift, arg1, 0);
11929 return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
11933 /* Rewrite an LROTATE_EXPR by a constant into an
11934 RROTATE_EXPR by a new constant. */
11935 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
11937 tree tem = build_int_cst (TREE_TYPE (arg1),
11938 TYPE_PRECISION (type));
11939 tem = const_binop (MINUS_EXPR, tem, arg1, 0);
11940 return fold_build2 (RROTATE_EXPR, type, op0, tem);
11943 /* If we have a rotate of a bit operation with the rotate count and
11944 the second operand of the bit operation both constant,
11945 permute the two operations. */
11946 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11947 && (TREE_CODE (arg0) == BIT_AND_EXPR
11948 || TREE_CODE (arg0) == BIT_IOR_EXPR
11949 || TREE_CODE (arg0) == BIT_XOR_EXPR)
11950 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11951 return fold_build2 (TREE_CODE (arg0), type,
11952 fold_build2 (code, type,
11953 TREE_OPERAND (arg0, 0), arg1),
11954 fold_build2 (code, type,
11955 TREE_OPERAND (arg0, 1), arg1));
11957 /* Two consecutive rotates adding up to the precision of the
11958 type can be ignored. */
11959 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11960 && TREE_CODE (arg0) == RROTATE_EXPR
11961 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11962 && TREE_INT_CST_HIGH (arg1) == 0
11963 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
11964 && ((TREE_INT_CST_LOW (arg1)
11965 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
11966 == (unsigned int) TYPE_PRECISION (type)))
11967 return TREE_OPERAND (arg0, 0);
11969 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
11970 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
11971 if the latter can be further optimized. */
11972 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
11973 && TREE_CODE (arg0) == BIT_AND_EXPR
11974 && TREE_CODE (arg1) == INTEGER_CST
11975 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11977 tree mask = fold_build2 (code, type,
11978 fold_convert (type, TREE_OPERAND (arg0, 1)),
11980 tree shift = fold_build2 (code, type,
11981 fold_convert (type, TREE_OPERAND (arg0, 0)),
11983 tem = fold_binary (BIT_AND_EXPR, type, shift, mask);
11991 if (operand_equal_p (arg0, arg1, 0))
11992 return omit_one_operand (type, arg0, arg1);
11993 if (INTEGRAL_TYPE_P (type)
11994 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
11995 return omit_one_operand (type, arg1, arg0);
11996 tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
12002 if (operand_equal_p (arg0, arg1, 0))
12003 return omit_one_operand (type, arg0, arg1);
12004 if (INTEGRAL_TYPE_P (type)
12005 && TYPE_MAX_VALUE (type)
12006 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12007 return omit_one_operand (type, arg1, arg0);
12008 tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
12013 case TRUTH_ANDIF_EXPR:
12014 /* Note that the operands of this must be ints
12015 and their values must be 0 or 1.
12016 ("true" is a fixed value perhaps depending on the language.) */
12017 /* If first arg is constant zero, return it. */
12018 if (integer_zerop (arg0))
12019 return fold_convert (type, arg0);
12020 case TRUTH_AND_EXPR:
12021 /* If either arg is constant true, drop it. */
12022 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12023 return non_lvalue (fold_convert (type, arg1));
12024 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12025 /* Preserve sequence points. */
12026 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12027 return non_lvalue (fold_convert (type, arg0));
12028 /* If second arg is constant zero, result is zero, but first arg
12029 must be evaluated. */
12030 if (integer_zerop (arg1))
12031 return omit_one_operand (type, arg1, arg0);
12032 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12033 case will be handled here. */
12034 if (integer_zerop (arg0))
12035 return omit_one_operand (type, arg0, arg1);
12037 /* !X && X is always false. */
12038 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12039 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12040 return omit_one_operand (type, integer_zero_node, arg1);
12041 /* X && !X is always false. */
12042 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12043 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12044 return omit_one_operand (type, integer_zero_node, arg0);
12046 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12047 means A >= Y && A != MAX, but in this case we know that
12050 if (!TREE_SIDE_EFFECTS (arg0)
12051 && !TREE_SIDE_EFFECTS (arg1))
12053 tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
12054 if (tem && !operand_equal_p (tem, arg0, 0))
12055 return fold_build2 (code, type, tem, arg1);
12057 tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
12058 if (tem && !operand_equal_p (tem, arg1, 0))
12059 return fold_build2 (code, type, arg0, tem);
12063 /* We only do these simplifications if we are optimizing. */
12067 /* Check for things like (A || B) && (A || C). We can convert this
12068 to A || (B && C). Note that either operator can be any of the four
12069 truth and/or operations and the transformation will still be
12070 valid. Also note that we only care about order for the
12071 ANDIF and ORIF operators. If B contains side effects, this
12072 might change the truth-value of A. */
12073 if (TREE_CODE (arg0) == TREE_CODE (arg1)
12074 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
12075 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
12076 || TREE_CODE (arg0) == TRUTH_AND_EXPR
12077 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
12078 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
12080 tree a00 = TREE_OPERAND (arg0, 0);
12081 tree a01 = TREE_OPERAND (arg0, 1);
12082 tree a10 = TREE_OPERAND (arg1, 0);
12083 tree a11 = TREE_OPERAND (arg1, 1);
12084 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
12085 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
12086 && (code == TRUTH_AND_EXPR
12087 || code == TRUTH_OR_EXPR));
12089 if (operand_equal_p (a00, a10, 0))
12090 return fold_build2 (TREE_CODE (arg0), type, a00,
12091 fold_build2 (code, type, a01, a11));
12092 else if (commutative && operand_equal_p (a00, a11, 0))
12093 return fold_build2 (TREE_CODE (arg0), type, a00,
12094 fold_build2 (code, type, a01, a10));
12095 else if (commutative && operand_equal_p (a01, a10, 0))
12096 return fold_build2 (TREE_CODE (arg0), type, a01,
12097 fold_build2 (code, type, a00, a11));
12099 /* This case if tricky because we must either have commutative
12100 operators or else A10 must not have side-effects. */
12102 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
12103 && operand_equal_p (a01, a11, 0))
12104 return fold_build2 (TREE_CODE (arg0), type,
12105 fold_build2 (code, type, a00, a10),
12109 /* See if we can build a range comparison. */
12110 if (0 != (tem = fold_range_test (code, type, op0, op1)))
12113 /* Check for the possibility of merging component references. If our
12114 lhs is another similar operation, try to merge its rhs with our
12115 rhs. Then try to merge our lhs and rhs. */
12116 if (TREE_CODE (arg0) == code
12117 && 0 != (tem = fold_truthop (code, type,
12118 TREE_OPERAND (arg0, 1), arg1)))
12119 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12121 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
12126 case TRUTH_ORIF_EXPR:
12127 /* Note that the operands of this must be ints
12128 and their values must be 0 or true.
12129 ("true" is a fixed value perhaps depending on the language.) */
12130 /* If first arg is constant true, return it. */
12131 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12132 return fold_convert (type, arg0);
12133 case TRUTH_OR_EXPR:
12134 /* If either arg is constant zero, drop it. */
12135 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12136 return non_lvalue (fold_convert (type, arg1));
12137 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12138 /* Preserve sequence points. */
12139 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12140 return non_lvalue (fold_convert (type, arg0));
12141 /* If second arg is constant true, result is true, but we must
12142 evaluate first arg. */
12143 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12144 return omit_one_operand (type, arg1, arg0);
12145 /* Likewise for first arg, but note this only occurs here for
12147 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12148 return omit_one_operand (type, arg0, arg1);
12150 /* !X || X is always true. */
12151 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12152 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12153 return omit_one_operand (type, integer_one_node, arg1);
12154 /* X || !X is always true. */
12155 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12156 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12157 return omit_one_operand (type, integer_one_node, arg0);
12161 case TRUTH_XOR_EXPR:
12162 /* If the second arg is constant zero, drop it. */
12163 if (integer_zerop (arg1))
12164 return non_lvalue (fold_convert (type, arg0));
12165 /* If the second arg is constant true, this is a logical inversion. */
12166 if (integer_onep (arg1))
12168 /* Only call invert_truthvalue if operand is a truth value. */
12169 if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
12170 tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
12172 tem = invert_truthvalue (arg0);
12173 return non_lvalue (fold_convert (type, tem));
12175 /* Identical arguments cancel to zero. */
12176 if (operand_equal_p (arg0, arg1, 0))
12177 return omit_one_operand (type, integer_zero_node, arg0);
12179 /* !X ^ X is always true. */
12180 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12181 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12182 return omit_one_operand (type, integer_one_node, arg1);
12184 /* X ^ !X is always true. */
12185 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12186 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12187 return omit_one_operand (type, integer_one_node, arg0);
12193 tem = fold_comparison (code, type, op0, op1);
12194 if (tem != NULL_TREE)
12197 /* bool_var != 0 becomes bool_var. */
12198 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12199 && code == NE_EXPR)
12200 return non_lvalue (fold_convert (type, arg0));
12202 /* bool_var == 1 becomes bool_var. */
12203 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12204 && code == EQ_EXPR)
12205 return non_lvalue (fold_convert (type, arg0));
12207 /* bool_var != 1 becomes !bool_var. */
12208 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12209 && code == NE_EXPR)
12210 return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
12212 /* bool_var == 0 becomes !bool_var. */
12213 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12214 && code == EQ_EXPR)
12215 return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
12217 /* If this is an equality comparison of the address of two non-weak,
12218 unaliased symbols neither of which are extern (since we do not
12219 have access to attributes for externs), then we know the result. */
12220 if (TREE_CODE (arg0) == ADDR_EXPR
12221 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12222 && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12223 && ! lookup_attribute ("alias",
12224 DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12225 && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12226 && TREE_CODE (arg1) == ADDR_EXPR
12227 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12228 && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12229 && ! lookup_attribute ("alias",
12230 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12231 && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12233 /* We know that we're looking at the address of two
12234 non-weak, unaliased, static _DECL nodes.
12236 It is both wasteful and incorrect to call operand_equal_p
12237 to compare the two ADDR_EXPR nodes. It is wasteful in that
12238 all we need to do is test pointer equality for the arguments
12239 to the two ADDR_EXPR nodes. It is incorrect to use
12240 operand_equal_p as that function is NOT equivalent to a
12241 C equality test. It can in fact return false for two
12242 objects which would test as equal using the C equality
12244 bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12245 return constant_boolean_node (equal
12246 ? code == EQ_EXPR : code != EQ_EXPR,
12250 /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
12251 a MINUS_EXPR of a constant, we can convert it into a comparison with
12252 a revised constant as long as no overflow occurs. */
12253 if (TREE_CODE (arg1) == INTEGER_CST
12254 && (TREE_CODE (arg0) == PLUS_EXPR
12255 || TREE_CODE (arg0) == MINUS_EXPR)
12256 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12257 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
12258 ? MINUS_EXPR : PLUS_EXPR,
12259 fold_convert (TREE_TYPE (arg0), arg1),
12260 TREE_OPERAND (arg0, 1), 0))
12261 && !TREE_OVERFLOW (tem))
12262 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12264 /* Similarly for a NEGATE_EXPR. */
12265 if (TREE_CODE (arg0) == NEGATE_EXPR
12266 && TREE_CODE (arg1) == INTEGER_CST
12267 && 0 != (tem = negate_expr (arg1))
12268 && TREE_CODE (tem) == INTEGER_CST
12269 && !TREE_OVERFLOW (tem))
12270 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12272 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12273 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12274 && TREE_CODE (arg1) == INTEGER_CST
12275 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12276 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12277 fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg0),
12278 fold_convert (TREE_TYPE (arg0), arg1),
12279 TREE_OPERAND (arg0, 1)));
12281 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12282 if ((TREE_CODE (arg0) == PLUS_EXPR
12283 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12284 || TREE_CODE (arg0) == MINUS_EXPR)
12285 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12286 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12287 || POINTER_TYPE_P (TREE_TYPE (arg0))))
12289 tree val = TREE_OPERAND (arg0, 1);
12290 return omit_two_operands (type,
12291 fold_build2 (code, type,
12293 build_int_cst (TREE_TYPE (val),
12295 TREE_OPERAND (arg0, 0), arg1);
12298 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12299 if (TREE_CODE (arg0) == MINUS_EXPR
12300 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12301 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0)
12302 && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
12304 return omit_two_operands (type,
12306 ? boolean_true_node : boolean_false_node,
12307 TREE_OPERAND (arg0, 1), arg1);
12310 /* If we have X - Y == 0, we can convert that to X == Y and similarly
12311 for !=. Don't do this for ordered comparisons due to overflow. */
12312 if (TREE_CODE (arg0) == MINUS_EXPR
12313 && integer_zerop (arg1))
12314 return fold_build2 (code, type,
12315 TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
12317 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12318 if (TREE_CODE (arg0) == ABS_EXPR
12319 && (integer_zerop (arg1) || real_zerop (arg1)))
12320 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
12322 /* If this is an EQ or NE comparison with zero and ARG0 is
12323 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12324 two operations, but the latter can be done in one less insn
12325 on machines that have only two-operand insns or on which a
12326 constant cannot be the first operand. */
12327 if (TREE_CODE (arg0) == BIT_AND_EXPR
12328 && integer_zerop (arg1))
12330 tree arg00 = TREE_OPERAND (arg0, 0);
12331 tree arg01 = TREE_OPERAND (arg0, 1);
12332 if (TREE_CODE (arg00) == LSHIFT_EXPR
12333 && integer_onep (TREE_OPERAND (arg00, 0)))
12335 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
12336 arg01, TREE_OPERAND (arg00, 1));
12337 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12338 build_int_cst (TREE_TYPE (arg0), 1));
12339 return fold_build2 (code, type,
12340 fold_convert (TREE_TYPE (arg1), tem), arg1);
12342 else if (TREE_CODE (arg01) == LSHIFT_EXPR
12343 && integer_onep (TREE_OPERAND (arg01, 0)))
12345 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
12346 arg00, TREE_OPERAND (arg01, 1));
12347 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12348 build_int_cst (TREE_TYPE (arg0), 1));
12349 return fold_build2 (code, type,
12350 fold_convert (TREE_TYPE (arg1), tem), arg1);
12354 /* If this is an NE or EQ comparison of zero against the result of a
12355 signed MOD operation whose second operand is a power of 2, make
12356 the MOD operation unsigned since it is simpler and equivalent. */
12357 if (integer_zerop (arg1)
12358 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12359 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12360 || TREE_CODE (arg0) == CEIL_MOD_EXPR
12361 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12362 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12363 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12365 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12366 tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
12367 fold_convert (newtype,
12368 TREE_OPERAND (arg0, 0)),
12369 fold_convert (newtype,
12370 TREE_OPERAND (arg0, 1)));
12372 return fold_build2 (code, type, newmod,
12373 fold_convert (newtype, arg1));
12376 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12377 C1 is a valid shift constant, and C2 is a power of two, i.e.
12379 if (TREE_CODE (arg0) == BIT_AND_EXPR
12380 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12381 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12383 && integer_pow2p (TREE_OPERAND (arg0, 1))
12384 && integer_zerop (arg1))
12386 tree itype = TREE_TYPE (arg0);
12387 unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
12388 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12390 /* Check for a valid shift count. */
12391 if (TREE_INT_CST_HIGH (arg001) == 0
12392 && TREE_INT_CST_LOW (arg001) < prec)
12394 tree arg01 = TREE_OPERAND (arg0, 1);
12395 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12396 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12397 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12398 can be rewritten as (X & (C2 << C1)) != 0. */
12399 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12401 tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
12402 tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
12403 return fold_build2 (code, type, tem, arg1);
12405 /* Otherwise, for signed (arithmetic) shifts,
12406 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12407 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12408 else if (!TYPE_UNSIGNED (itype))
12409 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12410 arg000, build_int_cst (itype, 0));
12411 /* Otherwise, of unsigned (logical) shifts,
12412 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12413 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12415 return omit_one_operand (type,
12416 code == EQ_EXPR ? integer_one_node
12417 : integer_zero_node,
12422 /* If this is an NE comparison of zero with an AND of one, remove the
12423 comparison since the AND will give the correct value. */
12424 if (code == NE_EXPR
12425 && integer_zerop (arg1)
12426 && TREE_CODE (arg0) == BIT_AND_EXPR
12427 && integer_onep (TREE_OPERAND (arg0, 1)))
12428 return fold_convert (type, arg0);
12430 /* If we have (A & C) == C where C is a power of 2, convert this into
12431 (A & C) != 0. Similarly for NE_EXPR. */
12432 if (TREE_CODE (arg0) == BIT_AND_EXPR
12433 && integer_pow2p (TREE_OPERAND (arg0, 1))
12434 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12435 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12436 arg0, fold_convert (TREE_TYPE (arg0),
12437 integer_zero_node));
12439 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12440 bit, then fold the expression into A < 0 or A >= 0. */
12441 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
12445 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12446 Similarly for NE_EXPR. */
12447 if (TREE_CODE (arg0) == BIT_AND_EXPR
12448 && TREE_CODE (arg1) == INTEGER_CST
12449 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12451 tree notc = fold_build1 (BIT_NOT_EXPR,
12452 TREE_TYPE (TREE_OPERAND (arg0, 1)),
12453 TREE_OPERAND (arg0, 1));
12454 tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12456 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12457 if (integer_nonzerop (dandnotc))
12458 return omit_one_operand (type, rslt, arg0);
12461 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12462 Similarly for NE_EXPR. */
12463 if (TREE_CODE (arg0) == BIT_IOR_EXPR
12464 && TREE_CODE (arg1) == INTEGER_CST
12465 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12467 tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12468 tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12469 TREE_OPERAND (arg0, 1), notd);
12470 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12471 if (integer_nonzerop (candnotd))
12472 return omit_one_operand (type, rslt, arg0);
12475 /* If this is a comparison of a field, we may be able to simplify it. */
12476 if ((TREE_CODE (arg0) == COMPONENT_REF
12477 || TREE_CODE (arg0) == BIT_FIELD_REF)
12478 /* Handle the constant case even without -O
12479 to make sure the warnings are given. */
12480 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12482 t1 = optimize_bit_field_compare (code, type, arg0, arg1);
12487 /* Optimize comparisons of strlen vs zero to a compare of the
12488 first character of the string vs zero. To wit,
12489 strlen(ptr) == 0 => *ptr == 0
12490 strlen(ptr) != 0 => *ptr != 0
12491 Other cases should reduce to one of these two (or a constant)
12492 due to the return value of strlen being unsigned. */
12493 if (TREE_CODE (arg0) == CALL_EXPR
12494 && integer_zerop (arg1))
12496 tree fndecl = get_callee_fndecl (arg0);
12499 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12500 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12501 && call_expr_nargs (arg0) == 1
12502 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12504 tree iref = build_fold_indirect_ref (CALL_EXPR_ARG (arg0, 0));
12505 return fold_build2 (code, type, iref,
12506 build_int_cst (TREE_TYPE (iref), 0));
12510 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12511 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12512 if (TREE_CODE (arg0) == RSHIFT_EXPR
12513 && integer_zerop (arg1)
12514 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12516 tree arg00 = TREE_OPERAND (arg0, 0);
12517 tree arg01 = TREE_OPERAND (arg0, 1);
12518 tree itype = TREE_TYPE (arg00);
12519 if (TREE_INT_CST_HIGH (arg01) == 0
12520 && TREE_INT_CST_LOW (arg01)
12521 == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
12523 if (TYPE_UNSIGNED (itype))
12525 itype = signed_type_for (itype);
12526 arg00 = fold_convert (itype, arg00);
12528 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12529 type, arg00, build_int_cst (itype, 0));
12533 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12534 if (integer_zerop (arg1)
12535 && TREE_CODE (arg0) == BIT_XOR_EXPR)
12536 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12537 TREE_OPERAND (arg0, 1));
12539 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12540 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12541 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12542 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12543 build_int_cst (TREE_TYPE (arg1), 0));
12544 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12545 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12546 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12547 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12548 return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
12549 build_int_cst (TREE_TYPE (arg1), 0));
12551 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
12552 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12553 && TREE_CODE (arg1) == INTEGER_CST
12554 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12555 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12556 fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
12557 TREE_OPERAND (arg0, 1), arg1));
12559 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12560 (X & C) == 0 when C is a single bit. */
12561 if (TREE_CODE (arg0) == BIT_AND_EXPR
12562 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12563 && integer_zerop (arg1)
12564 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12566 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12567 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12568 TREE_OPERAND (arg0, 1));
12569 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12573 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12574 constant C is a power of two, i.e. a single bit. */
12575 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12576 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12577 && integer_zerop (arg1)
12578 && integer_pow2p (TREE_OPERAND (arg0, 1))
12579 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12580 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12582 tree arg00 = TREE_OPERAND (arg0, 0);
12583 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12584 arg00, build_int_cst (TREE_TYPE (arg00), 0));
12587 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12588 when is C is a power of two, i.e. a single bit. */
12589 if (TREE_CODE (arg0) == BIT_AND_EXPR
12590 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12591 && integer_zerop (arg1)
12592 && integer_pow2p (TREE_OPERAND (arg0, 1))
12593 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12594 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12596 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12597 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
12598 arg000, TREE_OPERAND (arg0, 1));
12599 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12600 tem, build_int_cst (TREE_TYPE (tem), 0));
12603 if (integer_zerop (arg1)
12604 && tree_expr_nonzero_p (arg0))
12606 tree res = constant_boolean_node (code==NE_EXPR, type);
12607 return omit_one_operand (type, res, arg0);
12610 /* Fold -X op -Y as X op Y, where op is eq/ne. */
12611 if (TREE_CODE (arg0) == NEGATE_EXPR
12612 && TREE_CODE (arg1) == NEGATE_EXPR)
12613 return fold_build2 (code, type,
12614 TREE_OPERAND (arg0, 0),
12615 TREE_OPERAND (arg1, 0));
12617 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
12618 if (TREE_CODE (arg0) == BIT_AND_EXPR
12619 && TREE_CODE (arg1) == BIT_AND_EXPR)
12621 tree arg00 = TREE_OPERAND (arg0, 0);
12622 tree arg01 = TREE_OPERAND (arg0, 1);
12623 tree arg10 = TREE_OPERAND (arg1, 0);
12624 tree arg11 = TREE_OPERAND (arg1, 1);
12625 tree itype = TREE_TYPE (arg0);
12627 if (operand_equal_p (arg01, arg11, 0))
12628 return fold_build2 (code, type,
12629 fold_build2 (BIT_AND_EXPR, itype,
12630 fold_build2 (BIT_XOR_EXPR, itype,
12633 build_int_cst (itype, 0));
12635 if (operand_equal_p (arg01, arg10, 0))
12636 return fold_build2 (code, type,
12637 fold_build2 (BIT_AND_EXPR, itype,
12638 fold_build2 (BIT_XOR_EXPR, itype,
12641 build_int_cst (itype, 0));
12643 if (operand_equal_p (arg00, arg11, 0))
12644 return fold_build2 (code, type,
12645 fold_build2 (BIT_AND_EXPR, itype,
12646 fold_build2 (BIT_XOR_EXPR, itype,
12649 build_int_cst (itype, 0));
12651 if (operand_equal_p (arg00, arg10, 0))
12652 return fold_build2 (code, type,
12653 fold_build2 (BIT_AND_EXPR, itype,
12654 fold_build2 (BIT_XOR_EXPR, itype,
12657 build_int_cst (itype, 0));
12660 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12661 && TREE_CODE (arg1) == BIT_XOR_EXPR)
12663 tree arg00 = TREE_OPERAND (arg0, 0);
12664 tree arg01 = TREE_OPERAND (arg0, 1);
12665 tree arg10 = TREE_OPERAND (arg1, 0);
12666 tree arg11 = TREE_OPERAND (arg1, 1);
12667 tree itype = TREE_TYPE (arg0);
12669 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12670 operand_equal_p guarantees no side-effects so we don't need
12671 to use omit_one_operand on Z. */
12672 if (operand_equal_p (arg01, arg11, 0))
12673 return fold_build2 (code, type, arg00, arg10);
12674 if (operand_equal_p (arg01, arg10, 0))
12675 return fold_build2 (code, type, arg00, arg11);
12676 if (operand_equal_p (arg00, arg11, 0))
12677 return fold_build2 (code, type, arg01, arg10);
12678 if (operand_equal_p (arg00, arg10, 0))
12679 return fold_build2 (code, type, arg01, arg11);
12681 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
12682 if (TREE_CODE (arg01) == INTEGER_CST
12683 && TREE_CODE (arg11) == INTEGER_CST)
12684 return fold_build2 (code, type,
12685 fold_build2 (BIT_XOR_EXPR, itype, arg00,
12686 fold_build2 (BIT_XOR_EXPR, itype,
12691 /* Attempt to simplify equality/inequality comparisons of complex
12692 values. Only lower the comparison if the result is known or
12693 can be simplified to a single scalar comparison. */
12694 if ((TREE_CODE (arg0) == COMPLEX_EXPR
12695 || TREE_CODE (arg0) == COMPLEX_CST)
12696 && (TREE_CODE (arg1) == COMPLEX_EXPR
12697 || TREE_CODE (arg1) == COMPLEX_CST))
12699 tree real0, imag0, real1, imag1;
12702 if (TREE_CODE (arg0) == COMPLEX_EXPR)
12704 real0 = TREE_OPERAND (arg0, 0);
12705 imag0 = TREE_OPERAND (arg0, 1);
12709 real0 = TREE_REALPART (arg0);
12710 imag0 = TREE_IMAGPART (arg0);
12713 if (TREE_CODE (arg1) == COMPLEX_EXPR)
12715 real1 = TREE_OPERAND (arg1, 0);
12716 imag1 = TREE_OPERAND (arg1, 1);
12720 real1 = TREE_REALPART (arg1);
12721 imag1 = TREE_IMAGPART (arg1);
12724 rcond = fold_binary (code, type, real0, real1);
12725 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
12727 if (integer_zerop (rcond))
12729 if (code == EQ_EXPR)
12730 return omit_two_operands (type, boolean_false_node,
12732 return fold_build2 (NE_EXPR, type, imag0, imag1);
12736 if (code == NE_EXPR)
12737 return omit_two_operands (type, boolean_true_node,
12739 return fold_build2 (EQ_EXPR, type, imag0, imag1);
12743 icond = fold_binary (code, type, imag0, imag1);
12744 if (icond && TREE_CODE (icond) == INTEGER_CST)
12746 if (integer_zerop (icond))
12748 if (code == EQ_EXPR)
12749 return omit_two_operands (type, boolean_false_node,
12751 return fold_build2 (NE_EXPR, type, real0, real1);
12755 if (code == NE_EXPR)
12756 return omit_two_operands (type, boolean_true_node,
12758 return fold_build2 (EQ_EXPR, type, real0, real1);
12769 tem = fold_comparison (code, type, op0, op1);
12770 if (tem != NULL_TREE)
12773 /* Transform comparisons of the form X +- C CMP X. */
12774 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
12775 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12776 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
12777 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
12778 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12779 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
12781 tree arg01 = TREE_OPERAND (arg0, 1);
12782 enum tree_code code0 = TREE_CODE (arg0);
12785 if (TREE_CODE (arg01) == REAL_CST)
12786 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
12788 is_positive = tree_int_cst_sgn (arg01);
12790 /* (X - c) > X becomes false. */
12791 if (code == GT_EXPR
12792 && ((code0 == MINUS_EXPR && is_positive >= 0)
12793 || (code0 == PLUS_EXPR && is_positive <= 0)))
12795 if (TREE_CODE (arg01) == INTEGER_CST
12796 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12797 fold_overflow_warning (("assuming signed overflow does not "
12798 "occur when assuming that (X - c) > X "
12799 "is always false"),
12800 WARN_STRICT_OVERFLOW_ALL);
12801 return constant_boolean_node (0, type);
12804 /* Likewise (X + c) < X becomes false. */
12805 if (code == LT_EXPR
12806 && ((code0 == PLUS_EXPR && is_positive >= 0)
12807 || (code0 == MINUS_EXPR && is_positive <= 0)))
12809 if (TREE_CODE (arg01) == INTEGER_CST
12810 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12811 fold_overflow_warning (("assuming signed overflow does not "
12812 "occur when assuming that "
12813 "(X + c) < X is always false"),
12814 WARN_STRICT_OVERFLOW_ALL);
12815 return constant_boolean_node (0, type);
12818 /* Convert (X - c) <= X to true. */
12819 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12821 && ((code0 == MINUS_EXPR && is_positive >= 0)
12822 || (code0 == PLUS_EXPR && is_positive <= 0)))
12824 if (TREE_CODE (arg01) == INTEGER_CST
12825 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12826 fold_overflow_warning (("assuming signed overflow does not "
12827 "occur when assuming that "
12828 "(X - c) <= X is always true"),
12829 WARN_STRICT_OVERFLOW_ALL);
12830 return constant_boolean_node (1, type);
12833 /* Convert (X + c) >= X to true. */
12834 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12836 && ((code0 == PLUS_EXPR && is_positive >= 0)
12837 || (code0 == MINUS_EXPR && is_positive <= 0)))
12839 if (TREE_CODE (arg01) == INTEGER_CST
12840 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12841 fold_overflow_warning (("assuming signed overflow does not "
12842 "occur when assuming that "
12843 "(X + c) >= X is always true"),
12844 WARN_STRICT_OVERFLOW_ALL);
12845 return constant_boolean_node (1, type);
12848 if (TREE_CODE (arg01) == INTEGER_CST)
12850 /* Convert X + c > X and X - c < X to true for integers. */
12851 if (code == GT_EXPR
12852 && ((code0 == PLUS_EXPR && is_positive > 0)
12853 || (code0 == MINUS_EXPR && is_positive < 0)))
12855 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12856 fold_overflow_warning (("assuming signed overflow does "
12857 "not occur when assuming that "
12858 "(X + c) > X is always true"),
12859 WARN_STRICT_OVERFLOW_ALL);
12860 return constant_boolean_node (1, type);
12863 if (code == LT_EXPR
12864 && ((code0 == MINUS_EXPR && is_positive > 0)
12865 || (code0 == PLUS_EXPR && is_positive < 0)))
12867 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12868 fold_overflow_warning (("assuming signed overflow does "
12869 "not occur when assuming that "
12870 "(X - c) < X is always true"),
12871 WARN_STRICT_OVERFLOW_ALL);
12872 return constant_boolean_node (1, type);
12875 /* Convert X + c <= X and X - c >= X to false for integers. */
12876 if (code == LE_EXPR
12877 && ((code0 == PLUS_EXPR && is_positive > 0)
12878 || (code0 == MINUS_EXPR && is_positive < 0)))
12880 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12881 fold_overflow_warning (("assuming signed overflow does "
12882 "not occur when assuming that "
12883 "(X + c) <= X is always false"),
12884 WARN_STRICT_OVERFLOW_ALL);
12885 return constant_boolean_node (0, type);
12888 if (code == GE_EXPR
12889 && ((code0 == MINUS_EXPR && is_positive > 0)
12890 || (code0 == PLUS_EXPR && is_positive < 0)))
12892 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12893 fold_overflow_warning (("assuming signed overflow does "
12894 "not occur when assuming that "
12895 "(X - c) >= X is always false"),
12896 WARN_STRICT_OVERFLOW_ALL);
12897 return constant_boolean_node (0, type);
12902 /* Comparisons with the highest or lowest possible integer of
12903 the specified precision will have known values. */
12905 tree arg1_type = TREE_TYPE (arg1);
12906 unsigned int width = TYPE_PRECISION (arg1_type);
12908 if (TREE_CODE (arg1) == INTEGER_CST
12909 && width <= 2 * HOST_BITS_PER_WIDE_INT
12910 && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
12912 HOST_WIDE_INT signed_max_hi;
12913 unsigned HOST_WIDE_INT signed_max_lo;
12914 unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
12916 if (width <= HOST_BITS_PER_WIDE_INT)
12918 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12923 if (TYPE_UNSIGNED (arg1_type))
12925 max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12931 max_lo = signed_max_lo;
12932 min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12938 width -= HOST_BITS_PER_WIDE_INT;
12939 signed_max_lo = -1;
12940 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12945 if (TYPE_UNSIGNED (arg1_type))
12947 max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12952 max_hi = signed_max_hi;
12953 min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12957 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
12958 && TREE_INT_CST_LOW (arg1) == max_lo)
12962 return omit_one_operand (type, integer_zero_node, arg0);
12965 return fold_build2 (EQ_EXPR, type, op0, op1);
12968 return omit_one_operand (type, integer_one_node, arg0);
12971 return fold_build2 (NE_EXPR, type, op0, op1);
12973 /* The GE_EXPR and LT_EXPR cases above are not normally
12974 reached because of previous transformations. */
12979 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12981 && TREE_INT_CST_LOW (arg1) == max_lo - 1)
12985 arg1 = const_binop (PLUS_EXPR, arg1,
12986 build_int_cst (TREE_TYPE (arg1), 1), 0);
12987 return fold_build2 (EQ_EXPR, type,
12988 fold_convert (TREE_TYPE (arg1), arg0),
12991 arg1 = const_binop (PLUS_EXPR, arg1,
12992 build_int_cst (TREE_TYPE (arg1), 1), 0);
12993 return fold_build2 (NE_EXPR, type,
12994 fold_convert (TREE_TYPE (arg1), arg0),
12999 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13001 && TREE_INT_CST_LOW (arg1) == min_lo)
13005 return omit_one_operand (type, integer_zero_node, arg0);
13008 return fold_build2 (EQ_EXPR, type, op0, op1);
13011 return omit_one_operand (type, integer_one_node, arg0);
13014 return fold_build2 (NE_EXPR, type, op0, op1);
13019 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13021 && TREE_INT_CST_LOW (arg1) == min_lo + 1)
13025 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
13026 return fold_build2 (NE_EXPR, type,
13027 fold_convert (TREE_TYPE (arg1), arg0),
13030 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
13031 return fold_build2 (EQ_EXPR, type,
13032 fold_convert (TREE_TYPE (arg1), arg0),
13038 else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
13039 && TREE_INT_CST_LOW (arg1) == signed_max_lo
13040 && TYPE_UNSIGNED (arg1_type)
13041 /* We will flip the signedness of the comparison operator
13042 associated with the mode of arg1, so the sign bit is
13043 specified by this mode. Check that arg1 is the signed
13044 max associated with this sign bit. */
13045 && width == GET_MODE_BITSIZE (TYPE_MODE (arg1_type))
13046 /* signed_type does not work on pointer types. */
13047 && INTEGRAL_TYPE_P (arg1_type))
13049 /* The following case also applies to X < signed_max+1
13050 and X >= signed_max+1 because previous transformations. */
13051 if (code == LE_EXPR || code == GT_EXPR)
13054 st = signed_type_for (TREE_TYPE (arg1));
13055 return fold_build2 (code == LE_EXPR ? GE_EXPR : LT_EXPR,
13056 type, fold_convert (st, arg0),
13057 build_int_cst (st, 0));
13063 /* If we are comparing an ABS_EXPR with a constant, we can
13064 convert all the cases into explicit comparisons, but they may
13065 well not be faster than doing the ABS and one comparison.
13066 But ABS (X) <= C is a range comparison, which becomes a subtraction
13067 and a comparison, and is probably faster. */
13068 if (code == LE_EXPR
13069 && TREE_CODE (arg1) == INTEGER_CST
13070 && TREE_CODE (arg0) == ABS_EXPR
13071 && ! TREE_SIDE_EFFECTS (arg0)
13072 && (0 != (tem = negate_expr (arg1)))
13073 && TREE_CODE (tem) == INTEGER_CST
13074 && !TREE_OVERFLOW (tem))
13075 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13076 build2 (GE_EXPR, type,
13077 TREE_OPERAND (arg0, 0), tem),
13078 build2 (LE_EXPR, type,
13079 TREE_OPERAND (arg0, 0), arg1));
13081 /* Convert ABS_EXPR<x> >= 0 to true. */
13082 strict_overflow_p = false;
13083 if (code == GE_EXPR
13084 && (integer_zerop (arg1)
13085 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13086 && real_zerop (arg1)))
13087 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13089 if (strict_overflow_p)
13090 fold_overflow_warning (("assuming signed overflow does not occur "
13091 "when simplifying comparison of "
13092 "absolute value and zero"),
13093 WARN_STRICT_OVERFLOW_CONDITIONAL);
13094 return omit_one_operand (type, integer_one_node, arg0);
13097 /* Convert ABS_EXPR<x> < 0 to false. */
13098 strict_overflow_p = false;
13099 if (code == LT_EXPR
13100 && (integer_zerop (arg1) || real_zerop (arg1))
13101 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13103 if (strict_overflow_p)
13104 fold_overflow_warning (("assuming signed overflow does not occur "
13105 "when simplifying comparison of "
13106 "absolute value and zero"),
13107 WARN_STRICT_OVERFLOW_CONDITIONAL);
13108 return omit_one_operand (type, integer_zero_node, arg0);
13111 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13112 and similarly for >= into !=. */
13113 if ((code == LT_EXPR || code == GE_EXPR)
13114 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13115 && TREE_CODE (arg1) == LSHIFT_EXPR
13116 && integer_onep (TREE_OPERAND (arg1, 0)))
13117 return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13118 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13119 TREE_OPERAND (arg1, 1)),
13120 build_int_cst (TREE_TYPE (arg0), 0));
13122 if ((code == LT_EXPR || code == GE_EXPR)
13123 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13124 && CONVERT_EXPR_P (arg1)
13125 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13126 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13128 build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13129 fold_convert (TREE_TYPE (arg0),
13130 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13131 TREE_OPERAND (TREE_OPERAND (arg1, 0),
13133 build_int_cst (TREE_TYPE (arg0), 0));
13137 case UNORDERED_EXPR:
13145 if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13147 t1 = fold_relational_const (code, type, arg0, arg1);
13148 if (t1 != NULL_TREE)
13152 /* If the first operand is NaN, the result is constant. */
13153 if (TREE_CODE (arg0) == REAL_CST
13154 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13155 && (code != LTGT_EXPR || ! flag_trapping_math))
13157 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13158 ? integer_zero_node
13159 : integer_one_node;
13160 return omit_one_operand (type, t1, arg1);
13163 /* If the second operand is NaN, the result is constant. */
13164 if (TREE_CODE (arg1) == REAL_CST
13165 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13166 && (code != LTGT_EXPR || ! flag_trapping_math))
13168 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13169 ? integer_zero_node
13170 : integer_one_node;
13171 return omit_one_operand (type, t1, arg0);
13174 /* Simplify unordered comparison of something with itself. */
13175 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13176 && operand_equal_p (arg0, arg1, 0))
13177 return constant_boolean_node (1, type);
13179 if (code == LTGT_EXPR
13180 && !flag_trapping_math
13181 && operand_equal_p (arg0, arg1, 0))
13182 return constant_boolean_node (0, type);
13184 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13186 tree targ0 = strip_float_extensions (arg0);
13187 tree targ1 = strip_float_extensions (arg1);
13188 tree newtype = TREE_TYPE (targ0);
13190 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13191 newtype = TREE_TYPE (targ1);
13193 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13194 return fold_build2 (code, type, fold_convert (newtype, targ0),
13195 fold_convert (newtype, targ1));
13200 case COMPOUND_EXPR:
13201 /* When pedantic, a compound expression can be neither an lvalue
13202 nor an integer constant expression. */
13203 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13205 /* Don't let (0, 0) be null pointer constant. */
13206 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13207 : fold_convert (type, arg1);
13208 return pedantic_non_lvalue (tem);
13211 if ((TREE_CODE (arg0) == REAL_CST
13212 && TREE_CODE (arg1) == REAL_CST)
13213 || (TREE_CODE (arg0) == INTEGER_CST
13214 && TREE_CODE (arg1) == INTEGER_CST))
13215 return build_complex (type, arg0, arg1);
13219 /* An ASSERT_EXPR should never be passed to fold_binary. */
13220 gcc_unreachable ();
13224 } /* switch (code) */
13227 /* Callback for walk_tree, looking for LABEL_EXPR.
13228 Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
13229 Do not check the sub-tree of GOTO_EXPR. */
13232 contains_label_1 (tree *tp,
13233 int *walk_subtrees,
13234 void *data ATTRIBUTE_UNUSED)
13236 switch (TREE_CODE (*tp))
13241 *walk_subtrees = 0;
13248 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
13249 accessible from outside the sub-tree. Returns NULL_TREE if no
13250 addressable label is found. */
13253 contains_label_p (tree st)
13255 return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
13258 /* Fold a ternary expression of code CODE and type TYPE with operands
13259 OP0, OP1, and OP2. Return the folded expression if folding is
13260 successful. Otherwise, return NULL_TREE. */
13263 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
13266 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
13267 enum tree_code_class kind = TREE_CODE_CLASS (code);
13269 gcc_assert (IS_EXPR_CODE_CLASS (kind)
13270 && TREE_CODE_LENGTH (code) == 3);
13272 /* Strip any conversions that don't change the mode. This is safe
13273 for every expression, except for a comparison expression because
13274 its signedness is derived from its operands. So, in the latter
13275 case, only strip conversions that don't change the signedness.
13277 Note that this is done as an internal manipulation within the
13278 constant folder, in order to find the simplest representation of
13279 the arguments so that their form can be studied. In any cases,
13280 the appropriate type conversions should be put back in the tree
13281 that will get out of the constant folder. */
13296 case COMPONENT_REF:
13297 if (TREE_CODE (arg0) == CONSTRUCTOR
13298 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13300 unsigned HOST_WIDE_INT idx;
13302 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13309 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13310 so all simple results must be passed through pedantic_non_lvalue. */
13311 if (TREE_CODE (arg0) == INTEGER_CST)
13313 tree unused_op = integer_zerop (arg0) ? op1 : op2;
13314 tem = integer_zerop (arg0) ? op2 : op1;
13315 /* Only optimize constant conditions when the selected branch
13316 has the same type as the COND_EXPR. This avoids optimizing
13317 away "c ? x : throw", where the throw has a void type.
13318 Avoid throwing away that operand which contains label. */
13319 if ((!TREE_SIDE_EFFECTS (unused_op)
13320 || !contains_label_p (unused_op))
13321 && (! VOID_TYPE_P (TREE_TYPE (tem))
13322 || VOID_TYPE_P (type)))
13323 return pedantic_non_lvalue (tem);
13326 if (operand_equal_p (arg1, op2, 0))
13327 return pedantic_omit_one_operand (type, arg1, arg0);
13329 /* If we have A op B ? A : C, we may be able to convert this to a
13330 simpler expression, depending on the operation and the values
13331 of B and C. Signed zeros prevent all of these transformations,
13332 for reasons given above each one.
13334 Also try swapping the arguments and inverting the conditional. */
13335 if (COMPARISON_CLASS_P (arg0)
13336 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13337 arg1, TREE_OPERAND (arg0, 1))
13338 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13340 tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
13345 if (COMPARISON_CLASS_P (arg0)
13346 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13348 TREE_OPERAND (arg0, 1))
13349 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13351 tem = fold_truth_not_expr (arg0);
13352 if (tem && COMPARISON_CLASS_P (tem))
13354 tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
13360 /* If the second operand is simpler than the third, swap them
13361 since that produces better jump optimization results. */
13362 if (truth_value_p (TREE_CODE (arg0))
13363 && tree_swap_operands_p (op1, op2, false))
13365 /* See if this can be inverted. If it can't, possibly because
13366 it was a floating-point inequality comparison, don't do
13368 tem = fold_truth_not_expr (arg0);
13370 return fold_build3 (code, type, tem, op2, op1);
13373 /* Convert A ? 1 : 0 to simply A. */
13374 if (integer_onep (op1)
13375 && integer_zerop (op2)
13376 /* If we try to convert OP0 to our type, the
13377 call to fold will try to move the conversion inside
13378 a COND, which will recurse. In that case, the COND_EXPR
13379 is probably the best choice, so leave it alone. */
13380 && type == TREE_TYPE (arg0))
13381 return pedantic_non_lvalue (arg0);
13383 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13384 over COND_EXPR in cases such as floating point comparisons. */
13385 if (integer_zerop (op1)
13386 && integer_onep (op2)
13387 && truth_value_p (TREE_CODE (arg0)))
13388 return pedantic_non_lvalue (fold_convert (type,
13389 invert_truthvalue (arg0)));
13391 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13392 if (TREE_CODE (arg0) == LT_EXPR
13393 && integer_zerop (TREE_OPERAND (arg0, 1))
13394 && integer_zerop (op2)
13395 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13397 /* sign_bit_p only checks ARG1 bits within A's precision.
13398 If <sign bit of A> has wider type than A, bits outside
13399 of A's precision in <sign bit of A> need to be checked.
13400 If they are all 0, this optimization needs to be done
13401 in unsigned A's type, if they are all 1 in signed A's type,
13402 otherwise this can't be done. */
13403 if (TYPE_PRECISION (TREE_TYPE (tem))
13404 < TYPE_PRECISION (TREE_TYPE (arg1))
13405 && TYPE_PRECISION (TREE_TYPE (tem))
13406 < TYPE_PRECISION (type))
13408 unsigned HOST_WIDE_INT mask_lo;
13409 HOST_WIDE_INT mask_hi;
13410 int inner_width, outer_width;
13413 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13414 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13415 if (outer_width > TYPE_PRECISION (type))
13416 outer_width = TYPE_PRECISION (type);
13418 if (outer_width > HOST_BITS_PER_WIDE_INT)
13420 mask_hi = ((unsigned HOST_WIDE_INT) -1
13421 >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
13427 mask_lo = ((unsigned HOST_WIDE_INT) -1
13428 >> (HOST_BITS_PER_WIDE_INT - outer_width));
13430 if (inner_width > HOST_BITS_PER_WIDE_INT)
13432 mask_hi &= ~((unsigned HOST_WIDE_INT) -1
13433 >> (HOST_BITS_PER_WIDE_INT - inner_width));
13437 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
13438 >> (HOST_BITS_PER_WIDE_INT - inner_width));
13440 if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
13441 && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
13443 tem_type = signed_type_for (TREE_TYPE (tem));
13444 tem = fold_convert (tem_type, tem);
13446 else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
13447 && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
13449 tem_type = unsigned_type_for (TREE_TYPE (tem));
13450 tem = fold_convert (tem_type, tem);
13457 return fold_convert (type,
13458 fold_build2 (BIT_AND_EXPR,
13459 TREE_TYPE (tem), tem,
13460 fold_convert (TREE_TYPE (tem),
13464 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13465 already handled above. */
13466 if (TREE_CODE (arg0) == BIT_AND_EXPR
13467 && integer_onep (TREE_OPERAND (arg0, 1))
13468 && integer_zerop (op2)
13469 && integer_pow2p (arg1))
13471 tree tem = TREE_OPERAND (arg0, 0);
13473 if (TREE_CODE (tem) == RSHIFT_EXPR
13474 && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
13475 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13476 TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
13477 return fold_build2 (BIT_AND_EXPR, type,
13478 TREE_OPERAND (tem, 0), arg1);
13481 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13482 is probably obsolete because the first operand should be a
13483 truth value (that's why we have the two cases above), but let's
13484 leave it in until we can confirm this for all front-ends. */
13485 if (integer_zerop (op2)
13486 && TREE_CODE (arg0) == NE_EXPR
13487 && integer_zerop (TREE_OPERAND (arg0, 1))
13488 && integer_pow2p (arg1)
13489 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13490 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13491 arg1, OEP_ONLY_CONST))
13492 return pedantic_non_lvalue (fold_convert (type,
13493 TREE_OPERAND (arg0, 0)));
13495 /* Convert A ? B : 0 into A && B if A and B are truth values. */
13496 if (integer_zerop (op2)
13497 && truth_value_p (TREE_CODE (arg0))
13498 && truth_value_p (TREE_CODE (arg1)))
13499 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13500 fold_convert (type, arg0),
13503 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
13504 if (integer_onep (op2)
13505 && truth_value_p (TREE_CODE (arg0))
13506 && truth_value_p (TREE_CODE (arg1)))
13508 /* Only perform transformation if ARG0 is easily inverted. */
13509 tem = fold_truth_not_expr (arg0);
13511 return fold_build2 (TRUTH_ORIF_EXPR, type,
13512 fold_convert (type, tem),
13516 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
13517 if (integer_zerop (arg1)
13518 && truth_value_p (TREE_CODE (arg0))
13519 && truth_value_p (TREE_CODE (op2)))
13521 /* Only perform transformation if ARG0 is easily inverted. */
13522 tem = fold_truth_not_expr (arg0);
13524 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13525 fold_convert (type, tem),
13529 /* Convert A ? 1 : B into A || B if A and B are truth values. */
13530 if (integer_onep (arg1)
13531 && truth_value_p (TREE_CODE (arg0))
13532 && truth_value_p (TREE_CODE (op2)))
13533 return fold_build2 (TRUTH_ORIF_EXPR, type,
13534 fold_convert (type, arg0),
13540 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
13541 of fold_ternary on them. */
13542 gcc_unreachable ();
13544 case BIT_FIELD_REF:
13545 if ((TREE_CODE (arg0) == VECTOR_CST
13546 || (TREE_CODE (arg0) == CONSTRUCTOR && TREE_CONSTANT (arg0)))
13547 && type == TREE_TYPE (TREE_TYPE (arg0)))
13549 unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
13550 unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
13553 && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
13554 && (idx % width) == 0
13555 && (idx = idx / width)
13556 < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
13558 tree elements = NULL_TREE;
13560 if (TREE_CODE (arg0) == VECTOR_CST)
13561 elements = TREE_VECTOR_CST_ELTS (arg0);
13564 unsigned HOST_WIDE_INT idx;
13567 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg0), idx, value)
13568 elements = tree_cons (NULL_TREE, value, elements);
13570 while (idx-- > 0 && elements)
13571 elements = TREE_CHAIN (elements);
13573 return TREE_VALUE (elements);
13575 return fold_convert (type, integer_zero_node);
13579 /* A bit-field-ref that referenced the full argument can be stripped. */
13580 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
13581 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_low_cst (arg1, 1)
13582 && integer_zerop (op2))
13583 return fold_convert (type, arg0);
13589 } /* switch (code) */
13592 /* Perform constant folding and related simplification of EXPR.
13593 The related simplifications include x*1 => x, x*0 => 0, etc.,
13594 and application of the associative law.
13595 NOP_EXPR conversions may be removed freely (as long as we
13596 are careful not to change the type of the overall expression).
13597 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
13598 but we can constant-fold them if they have constant operands. */
13600 #ifdef ENABLE_FOLD_CHECKING
13601 # define fold(x) fold_1 (x)
13602 static tree fold_1 (tree);
13608 const tree t = expr;
13609 enum tree_code code = TREE_CODE (t);
13610 enum tree_code_class kind = TREE_CODE_CLASS (code);
13613 /* Return right away if a constant. */
13614 if (kind == tcc_constant)
13617 /* CALL_EXPR-like objects with variable numbers of operands are
13618 treated specially. */
13619 if (kind == tcc_vl_exp)
13621 if (code == CALL_EXPR)
13623 tem = fold_call_expr (expr, false);
13624 return tem ? tem : expr;
13629 if (IS_EXPR_CODE_CLASS (kind))
13631 tree type = TREE_TYPE (t);
13632 tree op0, op1, op2;
13634 switch (TREE_CODE_LENGTH (code))
13637 op0 = TREE_OPERAND (t, 0);
13638 tem = fold_unary (code, type, op0);
13639 return tem ? tem : expr;
13641 op0 = TREE_OPERAND (t, 0);
13642 op1 = TREE_OPERAND (t, 1);
13643 tem = fold_binary (code, type, op0, op1);
13644 return tem ? tem : expr;
13646 op0 = TREE_OPERAND (t, 0);
13647 op1 = TREE_OPERAND (t, 1);
13648 op2 = TREE_OPERAND (t, 2);
13649 tem = fold_ternary (code, type, op0, op1, op2);
13650 return tem ? tem : expr;
13660 tree op0 = TREE_OPERAND (t, 0);
13661 tree op1 = TREE_OPERAND (t, 1);
13663 if (TREE_CODE (op1) == INTEGER_CST
13664 && TREE_CODE (op0) == CONSTRUCTOR
13665 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
13667 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (op0);
13668 unsigned HOST_WIDE_INT end = VEC_length (constructor_elt, elts);
13669 unsigned HOST_WIDE_INT begin = 0;
13671 /* Find a matching index by means of a binary search. */
13672 while (begin != end)
13674 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
13675 tree index = VEC_index (constructor_elt, elts, middle)->index;
13677 if (TREE_CODE (index) == INTEGER_CST
13678 && tree_int_cst_lt (index, op1))
13679 begin = middle + 1;
13680 else if (TREE_CODE (index) == INTEGER_CST
13681 && tree_int_cst_lt (op1, index))
13683 else if (TREE_CODE (index) == RANGE_EXPR
13684 && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
13685 begin = middle + 1;
13686 else if (TREE_CODE (index) == RANGE_EXPR
13687 && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
13690 return VEC_index (constructor_elt, elts, middle)->value;
13698 return fold (DECL_INITIAL (t));
13702 } /* switch (code) */
13705 #ifdef ENABLE_FOLD_CHECKING
13708 static void fold_checksum_tree (const_tree, struct md5_ctx *, htab_t);
13709 static void fold_check_failed (const_tree, const_tree);
13710 void print_fold_checksum (const_tree);
13712 /* When --enable-checking=fold, compute a digest of expr before
13713 and after actual fold call to see if fold did not accidentally
13714 change original expr. */
13720 struct md5_ctx ctx;
13721 unsigned char checksum_before[16], checksum_after[16];
13724 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13725 md5_init_ctx (&ctx);
13726 fold_checksum_tree (expr, &ctx, ht);
13727 md5_finish_ctx (&ctx, checksum_before);
13730 ret = fold_1 (expr);
13732 md5_init_ctx (&ctx);
13733 fold_checksum_tree (expr, &ctx, ht);
13734 md5_finish_ctx (&ctx, checksum_after);
13737 if (memcmp (checksum_before, checksum_after, 16))
13738 fold_check_failed (expr, ret);
13744 print_fold_checksum (const_tree expr)
13746 struct md5_ctx ctx;
13747 unsigned char checksum[16], cnt;
13750 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13751 md5_init_ctx (&ctx);
13752 fold_checksum_tree (expr, &ctx, ht);
13753 md5_finish_ctx (&ctx, checksum);
13755 for (cnt = 0; cnt < 16; ++cnt)
13756 fprintf (stderr, "%02x", checksum[cnt]);
13757 putc ('\n', stderr);
13761 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
13763 internal_error ("fold check: original tree changed by fold");
13767 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, htab_t ht)
13770 enum tree_code code;
13771 union tree_node buf;
13776 gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
13777 <= sizeof (struct tree_function_decl))
13778 && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
13781 slot = (const void **) htab_find_slot (ht, expr, INSERT);
13785 code = TREE_CODE (expr);
13786 if (TREE_CODE_CLASS (code) == tcc_declaration
13787 && DECL_ASSEMBLER_NAME_SET_P (expr))
13789 /* Allow DECL_ASSEMBLER_NAME to be modified. */
13790 memcpy ((char *) &buf, expr, tree_size (expr));
13791 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
13792 expr = (tree) &buf;
13794 else if (TREE_CODE_CLASS (code) == tcc_type
13795 && (TYPE_POINTER_TO (expr)
13796 || TYPE_REFERENCE_TO (expr)
13797 || TYPE_CACHED_VALUES_P (expr)
13798 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
13799 || TYPE_NEXT_VARIANT (expr)))
13801 /* Allow these fields to be modified. */
13803 memcpy ((char *) &buf, expr, tree_size (expr));
13804 expr = tmp = (tree) &buf;
13805 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
13806 TYPE_POINTER_TO (tmp) = NULL;
13807 TYPE_REFERENCE_TO (tmp) = NULL;
13808 TYPE_NEXT_VARIANT (tmp) = NULL;
13809 if (TYPE_CACHED_VALUES_P (tmp))
13811 TYPE_CACHED_VALUES_P (tmp) = 0;
13812 TYPE_CACHED_VALUES (tmp) = NULL;
13815 md5_process_bytes (expr, tree_size (expr), ctx);
13816 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
13817 if (TREE_CODE_CLASS (code) != tcc_type
13818 && TREE_CODE_CLASS (code) != tcc_declaration
13819 && code != TREE_LIST
13820 && code != SSA_NAME)
13821 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
13822 switch (TREE_CODE_CLASS (code))
13828 md5_process_bytes (TREE_STRING_POINTER (expr),
13829 TREE_STRING_LENGTH (expr), ctx);
13832 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
13833 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
13836 fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
13842 case tcc_exceptional:
13846 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
13847 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
13848 expr = TREE_CHAIN (expr);
13849 goto recursive_label;
13852 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
13853 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
13859 case tcc_expression:
13860 case tcc_reference:
13861 case tcc_comparison:
13864 case tcc_statement:
13866 len = TREE_OPERAND_LENGTH (expr);
13867 for (i = 0; i < len; ++i)
13868 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
13870 case tcc_declaration:
13871 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
13872 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
13873 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
13875 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
13876 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
13877 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
13878 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
13879 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
13881 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
13882 fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
13884 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
13886 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
13887 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
13888 fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
13892 if (TREE_CODE (expr) == ENUMERAL_TYPE)
13893 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
13894 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
13895 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
13896 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
13897 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
13898 if (INTEGRAL_TYPE_P (expr)
13899 || SCALAR_FLOAT_TYPE_P (expr))
13901 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
13902 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
13904 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
13905 if (TREE_CODE (expr) == RECORD_TYPE
13906 || TREE_CODE (expr) == UNION_TYPE
13907 || TREE_CODE (expr) == QUAL_UNION_TYPE)
13908 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
13909 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
13916 /* Helper function for outputting the checksum of a tree T. When
13917 debugging with gdb, you can "define mynext" to be "next" followed
13918 by "call debug_fold_checksum (op0)", then just trace down till the
13922 debug_fold_checksum (const_tree t)
13925 unsigned char checksum[16];
13926 struct md5_ctx ctx;
13927 htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13929 md5_init_ctx (&ctx);
13930 fold_checksum_tree (t, &ctx, ht);
13931 md5_finish_ctx (&ctx, checksum);
13934 for (i = 0; i < 16; i++)
13935 fprintf (stderr, "%d ", checksum[i]);
13937 fprintf (stderr, "\n");
13942 /* Fold a unary tree expression with code CODE of type TYPE with an
13943 operand OP0. Return a folded expression if successful. Otherwise,
13944 return a tree expression with code CODE of type TYPE with an
13948 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
13951 #ifdef ENABLE_FOLD_CHECKING
13952 unsigned char checksum_before[16], checksum_after[16];
13953 struct md5_ctx ctx;
13956 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13957 md5_init_ctx (&ctx);
13958 fold_checksum_tree (op0, &ctx, ht);
13959 md5_finish_ctx (&ctx, checksum_before);
13963 tem = fold_unary (code, type, op0);
13965 tem = build1_stat (code, type, op0 PASS_MEM_STAT);
13967 #ifdef ENABLE_FOLD_CHECKING
13968 md5_init_ctx (&ctx);
13969 fold_checksum_tree (op0, &ctx, ht);
13970 md5_finish_ctx (&ctx, checksum_after);
13973 if (memcmp (checksum_before, checksum_after, 16))
13974 fold_check_failed (op0, tem);
13979 /* Fold a binary tree expression with code CODE of type TYPE with
13980 operands OP0 and OP1. Return a folded expression if successful.
13981 Otherwise, return a tree expression with code CODE of type TYPE
13982 with operands OP0 and OP1. */
13985 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
13989 #ifdef ENABLE_FOLD_CHECKING
13990 unsigned char checksum_before_op0[16],
13991 checksum_before_op1[16],
13992 checksum_after_op0[16],
13993 checksum_after_op1[16];
13994 struct md5_ctx ctx;
13997 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13998 md5_init_ctx (&ctx);
13999 fold_checksum_tree (op0, &ctx, ht);
14000 md5_finish_ctx (&ctx, checksum_before_op0);
14003 md5_init_ctx (&ctx);
14004 fold_checksum_tree (op1, &ctx, ht);
14005 md5_finish_ctx (&ctx, checksum_before_op1);
14009 tem = fold_binary (code, type, op0, op1);
14011 tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
14013 #ifdef ENABLE_FOLD_CHECKING
14014 md5_init_ctx (&ctx);
14015 fold_checksum_tree (op0, &ctx, ht);
14016 md5_finish_ctx (&ctx, checksum_after_op0);
14019 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14020 fold_check_failed (op0, tem);
14022 md5_init_ctx (&ctx);
14023 fold_checksum_tree (op1, &ctx, ht);
14024 md5_finish_ctx (&ctx, checksum_after_op1);
14027 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14028 fold_check_failed (op1, tem);
14033 /* Fold a ternary tree expression with code CODE of type TYPE with
14034 operands OP0, OP1, and OP2. Return a folded expression if
14035 successful. Otherwise, return a tree expression with code CODE of
14036 type TYPE with operands OP0, OP1, and OP2. */
14039 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
14043 #ifdef ENABLE_FOLD_CHECKING
14044 unsigned char checksum_before_op0[16],
14045 checksum_before_op1[16],
14046 checksum_before_op2[16],
14047 checksum_after_op0[16],
14048 checksum_after_op1[16],
14049 checksum_after_op2[16];
14050 struct md5_ctx ctx;
14053 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14054 md5_init_ctx (&ctx);
14055 fold_checksum_tree (op0, &ctx, ht);
14056 md5_finish_ctx (&ctx, checksum_before_op0);
14059 md5_init_ctx (&ctx);
14060 fold_checksum_tree (op1, &ctx, ht);
14061 md5_finish_ctx (&ctx, checksum_before_op1);
14064 md5_init_ctx (&ctx);
14065 fold_checksum_tree (op2, &ctx, ht);
14066 md5_finish_ctx (&ctx, checksum_before_op2);
14070 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14071 tem = fold_ternary (code, type, op0, op1, op2);
14073 tem = build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
14075 #ifdef ENABLE_FOLD_CHECKING
14076 md5_init_ctx (&ctx);
14077 fold_checksum_tree (op0, &ctx, ht);
14078 md5_finish_ctx (&ctx, checksum_after_op0);
14081 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14082 fold_check_failed (op0, tem);
14084 md5_init_ctx (&ctx);
14085 fold_checksum_tree (op1, &ctx, ht);
14086 md5_finish_ctx (&ctx, checksum_after_op1);
14089 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14090 fold_check_failed (op1, tem);
14092 md5_init_ctx (&ctx);
14093 fold_checksum_tree (op2, &ctx, ht);
14094 md5_finish_ctx (&ctx, checksum_after_op2);
14097 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14098 fold_check_failed (op2, tem);
14103 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14104 arguments in ARGARRAY, and a null static chain.
14105 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14106 of type TYPE from the given operands as constructed by build_call_array. */
14109 fold_build_call_array (tree type, tree fn, int nargs, tree *argarray)
14112 #ifdef ENABLE_FOLD_CHECKING
14113 unsigned char checksum_before_fn[16],
14114 checksum_before_arglist[16],
14115 checksum_after_fn[16],
14116 checksum_after_arglist[16];
14117 struct md5_ctx ctx;
14121 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14122 md5_init_ctx (&ctx);
14123 fold_checksum_tree (fn, &ctx, ht);
14124 md5_finish_ctx (&ctx, checksum_before_fn);
14127 md5_init_ctx (&ctx);
14128 for (i = 0; i < nargs; i++)
14129 fold_checksum_tree (argarray[i], &ctx, ht);
14130 md5_finish_ctx (&ctx, checksum_before_arglist);
14134 tem = fold_builtin_call_array (type, fn, nargs, argarray);
14136 #ifdef ENABLE_FOLD_CHECKING
14137 md5_init_ctx (&ctx);
14138 fold_checksum_tree (fn, &ctx, ht);
14139 md5_finish_ctx (&ctx, checksum_after_fn);
14142 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14143 fold_check_failed (fn, tem);
14145 md5_init_ctx (&ctx);
14146 for (i = 0; i < nargs; i++)
14147 fold_checksum_tree (argarray[i], &ctx, ht);
14148 md5_finish_ctx (&ctx, checksum_after_arglist);
14151 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14152 fold_check_failed (NULL_TREE, tem);
14157 /* Perform constant folding and related simplification of initializer
14158 expression EXPR. These behave identically to "fold_buildN" but ignore
14159 potential run-time traps and exceptions that fold must preserve. */
14161 #define START_FOLD_INIT \
14162 int saved_signaling_nans = flag_signaling_nans;\
14163 int saved_trapping_math = flag_trapping_math;\
14164 int saved_rounding_math = flag_rounding_math;\
14165 int saved_trapv = flag_trapv;\
14166 int saved_folding_initializer = folding_initializer;\
14167 flag_signaling_nans = 0;\
14168 flag_trapping_math = 0;\
14169 flag_rounding_math = 0;\
14171 folding_initializer = 1;
14173 #define END_FOLD_INIT \
14174 flag_signaling_nans = saved_signaling_nans;\
14175 flag_trapping_math = saved_trapping_math;\
14176 flag_rounding_math = saved_rounding_math;\
14177 flag_trapv = saved_trapv;\
14178 folding_initializer = saved_folding_initializer;
14181 fold_build1_initializer (enum tree_code code, tree type, tree op)
14186 result = fold_build1 (code, type, op);
14193 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
14198 result = fold_build2 (code, type, op0, op1);
14205 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
14211 result = fold_build3 (code, type, op0, op1, op2);
14218 fold_build_call_array_initializer (tree type, tree fn,
14219 int nargs, tree *argarray)
14224 result = fold_build_call_array (type, fn, nargs, argarray);
14230 #undef START_FOLD_INIT
14231 #undef END_FOLD_INIT
14233 /* Determine if first argument is a multiple of second argument. Return 0 if
14234 it is not, or we cannot easily determined it to be.
14236 An example of the sort of thing we care about (at this point; this routine
14237 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14238 fold cases do now) is discovering that
14240 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14246 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14248 This code also handles discovering that
14250 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14252 is a multiple of 8 so we don't have to worry about dealing with a
14253 possible remainder.
14255 Note that we *look* inside a SAVE_EXPR only to determine how it was
14256 calculated; it is not safe for fold to do much of anything else with the
14257 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14258 at run time. For example, the latter example above *cannot* be implemented
14259 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14260 evaluation time of the original SAVE_EXPR is not necessarily the same at
14261 the time the new expression is evaluated. The only optimization of this
14262 sort that would be valid is changing
14264 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14268 SAVE_EXPR (I) * SAVE_EXPR (J)
14270 (where the same SAVE_EXPR (J) is used in the original and the
14271 transformed version). */
14274 multiple_of_p (tree type, const_tree top, const_tree bottom)
14276 if (operand_equal_p (top, bottom, 0))
14279 if (TREE_CODE (type) != INTEGER_TYPE)
14282 switch (TREE_CODE (top))
14285 /* Bitwise and provides a power of two multiple. If the mask is
14286 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
14287 if (!integer_pow2p (bottom))
14292 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14293 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14297 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14298 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14301 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
14305 op1 = TREE_OPERAND (top, 1);
14306 /* const_binop may not detect overflow correctly,
14307 so check for it explicitly here. */
14308 if (TYPE_PRECISION (TREE_TYPE (size_one_node))
14309 > TREE_INT_CST_LOW (op1)
14310 && TREE_INT_CST_HIGH (op1) == 0
14311 && 0 != (t1 = fold_convert (type,
14312 const_binop (LSHIFT_EXPR,
14315 && !TREE_OVERFLOW (t1))
14316 return multiple_of_p (type, t1, bottom);
14321 /* Can't handle conversions from non-integral or wider integral type. */
14322 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
14323 || (TYPE_PRECISION (type)
14324 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
14327 /* .. fall through ... */
14330 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
14333 if (TREE_CODE (bottom) != INTEGER_CST
14334 || integer_zerop (bottom)
14335 || (TYPE_UNSIGNED (type)
14336 && (tree_int_cst_sgn (top) < 0
14337 || tree_int_cst_sgn (bottom) < 0)))
14339 return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
14347 /* Return true if CODE or TYPE is known to be non-negative. */
14350 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
14352 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
14353 && truth_value_p (code))
14354 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14355 have a signed:1 type (where the value is -1 and 0). */
14360 /* Return true if (CODE OP0) is known to be non-negative. If the return
14361 value is based on the assumption that signed overflow is undefined,
14362 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14363 *STRICT_OVERFLOW_P. */
14366 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14367 bool *strict_overflow_p)
14369 if (TYPE_UNSIGNED (type))
14375 /* We can't return 1 if flag_wrapv is set because
14376 ABS_EXPR<INT_MIN> = INT_MIN. */
14377 if (!INTEGRAL_TYPE_P (type))
14379 if (TYPE_OVERFLOW_UNDEFINED (type))
14381 *strict_overflow_p = true;
14386 case NON_LVALUE_EXPR:
14388 case FIX_TRUNC_EXPR:
14389 return tree_expr_nonnegative_warnv_p (op0,
14390 strict_overflow_p);
14394 tree inner_type = TREE_TYPE (op0);
14395 tree outer_type = type;
14397 if (TREE_CODE (outer_type) == REAL_TYPE)
14399 if (TREE_CODE (inner_type) == REAL_TYPE)
14400 return tree_expr_nonnegative_warnv_p (op0,
14401 strict_overflow_p);
14402 if (TREE_CODE (inner_type) == INTEGER_TYPE)
14404 if (TYPE_UNSIGNED (inner_type))
14406 return tree_expr_nonnegative_warnv_p (op0,
14407 strict_overflow_p);
14410 else if (TREE_CODE (outer_type) == INTEGER_TYPE)
14412 if (TREE_CODE (inner_type) == REAL_TYPE)
14413 return tree_expr_nonnegative_warnv_p (op0,
14414 strict_overflow_p);
14415 if (TREE_CODE (inner_type) == INTEGER_TYPE)
14416 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
14417 && TYPE_UNSIGNED (inner_type);
14423 return tree_simple_nonnegative_warnv_p (code, type);
14426 /* We don't know sign of `t', so be conservative and return false. */
14430 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
14431 value is based on the assumption that signed overflow is undefined,
14432 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14433 *STRICT_OVERFLOW_P. */
14436 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14437 tree op1, bool *strict_overflow_p)
14439 if (TYPE_UNSIGNED (type))
14444 case POINTER_PLUS_EXPR:
14446 if (FLOAT_TYPE_P (type))
14447 return (tree_expr_nonnegative_warnv_p (op0,
14449 && tree_expr_nonnegative_warnv_p (op1,
14450 strict_overflow_p));
14452 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14453 both unsigned and at least 2 bits shorter than the result. */
14454 if (TREE_CODE (type) == INTEGER_TYPE
14455 && TREE_CODE (op0) == NOP_EXPR
14456 && TREE_CODE (op1) == NOP_EXPR)
14458 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
14459 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
14460 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14461 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14463 unsigned int prec = MAX (TYPE_PRECISION (inner1),
14464 TYPE_PRECISION (inner2)) + 1;
14465 return prec < TYPE_PRECISION (type);
14471 if (FLOAT_TYPE_P (type))
14473 /* x * x for floating point x is always non-negative. */
14474 if (operand_equal_p (op0, op1, 0))
14476 return (tree_expr_nonnegative_warnv_p (op0,
14478 && tree_expr_nonnegative_warnv_p (op1,
14479 strict_overflow_p));
14482 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14483 both unsigned and their total bits is shorter than the result. */
14484 if (TREE_CODE (type) == INTEGER_TYPE
14485 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
14486 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
14488 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
14489 ? TREE_TYPE (TREE_OPERAND (op0, 0))
14491 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
14492 ? TREE_TYPE (TREE_OPERAND (op1, 0))
14495 bool unsigned0 = TYPE_UNSIGNED (inner0);
14496 bool unsigned1 = TYPE_UNSIGNED (inner1);
14498 if (TREE_CODE (op0) == INTEGER_CST)
14499 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
14501 if (TREE_CODE (op1) == INTEGER_CST)
14502 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
14504 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
14505 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
14507 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
14508 ? tree_int_cst_min_precision (op0, /*unsignedp=*/true)
14509 : TYPE_PRECISION (inner0);
14511 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
14512 ? tree_int_cst_min_precision (op1, /*unsignedp=*/true)
14513 : TYPE_PRECISION (inner1);
14515 return precision0 + precision1 < TYPE_PRECISION (type);
14522 return (tree_expr_nonnegative_warnv_p (op0,
14524 || tree_expr_nonnegative_warnv_p (op1,
14525 strict_overflow_p));
14531 case TRUNC_DIV_EXPR:
14532 case CEIL_DIV_EXPR:
14533 case FLOOR_DIV_EXPR:
14534 case ROUND_DIV_EXPR:
14535 return (tree_expr_nonnegative_warnv_p (op0,
14537 && tree_expr_nonnegative_warnv_p (op1,
14538 strict_overflow_p));
14540 case TRUNC_MOD_EXPR:
14541 case CEIL_MOD_EXPR:
14542 case FLOOR_MOD_EXPR:
14543 case ROUND_MOD_EXPR:
14544 return tree_expr_nonnegative_warnv_p (op0,
14545 strict_overflow_p);
14547 return tree_simple_nonnegative_warnv_p (code, type);
14550 /* We don't know sign of `t', so be conservative and return false. */
14554 /* Return true if T is known to be non-negative. If the return
14555 value is based on the assumption that signed overflow is undefined,
14556 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14557 *STRICT_OVERFLOW_P. */
14560 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14562 if (TYPE_UNSIGNED (TREE_TYPE (t)))
14565 switch (TREE_CODE (t))
14568 return tree_int_cst_sgn (t) >= 0;
14571 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
14574 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
14577 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14579 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
14580 strict_overflow_p));
14582 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14585 /* We don't know sign of `t', so be conservative and return false. */
14589 /* Return true if T is known to be non-negative. If the return
14590 value is based on the assumption that signed overflow is undefined,
14591 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14592 *STRICT_OVERFLOW_P. */
14595 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
14596 tree arg0, tree arg1, bool *strict_overflow_p)
14598 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
14599 switch (DECL_FUNCTION_CODE (fndecl))
14601 CASE_FLT_FN (BUILT_IN_ACOS):
14602 CASE_FLT_FN (BUILT_IN_ACOSH):
14603 CASE_FLT_FN (BUILT_IN_CABS):
14604 CASE_FLT_FN (BUILT_IN_COSH):
14605 CASE_FLT_FN (BUILT_IN_ERFC):
14606 CASE_FLT_FN (BUILT_IN_EXP):
14607 CASE_FLT_FN (BUILT_IN_EXP10):
14608 CASE_FLT_FN (BUILT_IN_EXP2):
14609 CASE_FLT_FN (BUILT_IN_FABS):
14610 CASE_FLT_FN (BUILT_IN_FDIM):
14611 CASE_FLT_FN (BUILT_IN_HYPOT):
14612 CASE_FLT_FN (BUILT_IN_POW10):
14613 CASE_INT_FN (BUILT_IN_FFS):
14614 CASE_INT_FN (BUILT_IN_PARITY):
14615 CASE_INT_FN (BUILT_IN_POPCOUNT):
14616 case BUILT_IN_BSWAP32:
14617 case BUILT_IN_BSWAP64:
14621 CASE_FLT_FN (BUILT_IN_SQRT):
14622 /* sqrt(-0.0) is -0.0. */
14623 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
14625 return tree_expr_nonnegative_warnv_p (arg0,
14626 strict_overflow_p);
14628 CASE_FLT_FN (BUILT_IN_ASINH):
14629 CASE_FLT_FN (BUILT_IN_ATAN):
14630 CASE_FLT_FN (BUILT_IN_ATANH):
14631 CASE_FLT_FN (BUILT_IN_CBRT):
14632 CASE_FLT_FN (BUILT_IN_CEIL):
14633 CASE_FLT_FN (BUILT_IN_ERF):
14634 CASE_FLT_FN (BUILT_IN_EXPM1):
14635 CASE_FLT_FN (BUILT_IN_FLOOR):
14636 CASE_FLT_FN (BUILT_IN_FMOD):
14637 CASE_FLT_FN (BUILT_IN_FREXP):
14638 CASE_FLT_FN (BUILT_IN_LCEIL):
14639 CASE_FLT_FN (BUILT_IN_LDEXP):
14640 CASE_FLT_FN (BUILT_IN_LFLOOR):
14641 CASE_FLT_FN (BUILT_IN_LLCEIL):
14642 CASE_FLT_FN (BUILT_IN_LLFLOOR):
14643 CASE_FLT_FN (BUILT_IN_LLRINT):
14644 CASE_FLT_FN (BUILT_IN_LLROUND):
14645 CASE_FLT_FN (BUILT_IN_LRINT):
14646 CASE_FLT_FN (BUILT_IN_LROUND):
14647 CASE_FLT_FN (BUILT_IN_MODF):
14648 CASE_FLT_FN (BUILT_IN_NEARBYINT):
14649 CASE_FLT_FN (BUILT_IN_RINT):
14650 CASE_FLT_FN (BUILT_IN_ROUND):
14651 CASE_FLT_FN (BUILT_IN_SCALB):
14652 CASE_FLT_FN (BUILT_IN_SCALBLN):
14653 CASE_FLT_FN (BUILT_IN_SCALBN):
14654 CASE_FLT_FN (BUILT_IN_SIGNBIT):
14655 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
14656 CASE_FLT_FN (BUILT_IN_SINH):
14657 CASE_FLT_FN (BUILT_IN_TANH):
14658 CASE_FLT_FN (BUILT_IN_TRUNC):
14659 /* True if the 1st argument is nonnegative. */
14660 return tree_expr_nonnegative_warnv_p (arg0,
14661 strict_overflow_p);
14663 CASE_FLT_FN (BUILT_IN_FMAX):
14664 /* True if the 1st OR 2nd arguments are nonnegative. */
14665 return (tree_expr_nonnegative_warnv_p (arg0,
14667 || (tree_expr_nonnegative_warnv_p (arg1,
14668 strict_overflow_p)));
14670 CASE_FLT_FN (BUILT_IN_FMIN):
14671 /* True if the 1st AND 2nd arguments are nonnegative. */
14672 return (tree_expr_nonnegative_warnv_p (arg0,
14674 && (tree_expr_nonnegative_warnv_p (arg1,
14675 strict_overflow_p)));
14677 CASE_FLT_FN (BUILT_IN_COPYSIGN):
14678 /* True if the 2nd argument is nonnegative. */
14679 return tree_expr_nonnegative_warnv_p (arg1,
14680 strict_overflow_p);
14682 CASE_FLT_FN (BUILT_IN_POWI):
14683 /* True if the 1st argument is nonnegative or the second
14684 argument is an even integer. */
14685 if (TREE_CODE (arg1) == INTEGER_CST
14686 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
14688 return tree_expr_nonnegative_warnv_p (arg0,
14689 strict_overflow_p);
14691 CASE_FLT_FN (BUILT_IN_POW):
14692 /* True if the 1st argument is nonnegative or the second
14693 argument is an even integer valued real. */
14694 if (TREE_CODE (arg1) == REAL_CST)
14699 c = TREE_REAL_CST (arg1);
14700 n = real_to_integer (&c);
14703 REAL_VALUE_TYPE cint;
14704 real_from_integer (&cint, VOIDmode, n,
14705 n < 0 ? -1 : 0, 0);
14706 if (real_identical (&c, &cint))
14710 return tree_expr_nonnegative_warnv_p (arg0,
14711 strict_overflow_p);
14716 return tree_simple_nonnegative_warnv_p (CALL_EXPR,
14720 /* Return true if T is known to be non-negative. If the return
14721 value is based on the assumption that signed overflow is undefined,
14722 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14723 *STRICT_OVERFLOW_P. */
14726 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14728 enum tree_code code = TREE_CODE (t);
14729 if (TYPE_UNSIGNED (TREE_TYPE (t)))
14736 tree temp = TARGET_EXPR_SLOT (t);
14737 t = TARGET_EXPR_INITIAL (t);
14739 /* If the initializer is non-void, then it's a normal expression
14740 that will be assigned to the slot. */
14741 if (!VOID_TYPE_P (t))
14742 return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
14744 /* Otherwise, the initializer sets the slot in some way. One common
14745 way is an assignment statement at the end of the initializer. */
14748 if (TREE_CODE (t) == BIND_EXPR)
14749 t = expr_last (BIND_EXPR_BODY (t));
14750 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
14751 || TREE_CODE (t) == TRY_CATCH_EXPR)
14752 t = expr_last (TREE_OPERAND (t, 0));
14753 else if (TREE_CODE (t) == STATEMENT_LIST)
14758 if (TREE_CODE (t) == MODIFY_EXPR
14759 && TREE_OPERAND (t, 0) == temp)
14760 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14761 strict_overflow_p);
14768 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
14769 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
14771 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
14772 get_callee_fndecl (t),
14775 strict_overflow_p);
14777 case COMPOUND_EXPR:
14779 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14780 strict_overflow_p);
14782 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
14783 strict_overflow_p);
14785 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14786 strict_overflow_p);
14789 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14793 /* We don't know sign of `t', so be conservative and return false. */
14797 /* Return true if T is known to be non-negative. If the return
14798 value is based on the assumption that signed overflow is undefined,
14799 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14800 *STRICT_OVERFLOW_P. */
14803 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14805 enum tree_code code;
14806 if (t == error_mark_node)
14809 code = TREE_CODE (t);
14810 switch (TREE_CODE_CLASS (code))
14813 case tcc_comparison:
14814 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14816 TREE_OPERAND (t, 0),
14817 TREE_OPERAND (t, 1),
14818 strict_overflow_p);
14821 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14823 TREE_OPERAND (t, 0),
14824 strict_overflow_p);
14827 case tcc_declaration:
14828 case tcc_reference:
14829 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14837 case TRUTH_AND_EXPR:
14838 case TRUTH_OR_EXPR:
14839 case TRUTH_XOR_EXPR:
14840 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14842 TREE_OPERAND (t, 0),
14843 TREE_OPERAND (t, 1),
14844 strict_overflow_p);
14845 case TRUTH_NOT_EXPR:
14846 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14848 TREE_OPERAND (t, 0),
14849 strict_overflow_p);
14856 case WITH_SIZE_EXPR:
14860 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14863 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
14867 /* Return true if `t' is known to be non-negative. Handle warnings
14868 about undefined signed overflow. */
14871 tree_expr_nonnegative_p (tree t)
14873 bool ret, strict_overflow_p;
14875 strict_overflow_p = false;
14876 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
14877 if (strict_overflow_p)
14878 fold_overflow_warning (("assuming signed overflow does not occur when "
14879 "determining that expression is always "
14881 WARN_STRICT_OVERFLOW_MISC);
14886 /* Return true when (CODE OP0) is an address and is known to be nonzero.
14887 For floating point we further ensure that T is not denormal.
14888 Similar logic is present in nonzero_address in rtlanal.h.
14890 If the return value is based on the assumption that signed overflow
14891 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14892 change *STRICT_OVERFLOW_P. */
14895 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
14896 bool *strict_overflow_p)
14901 return tree_expr_nonzero_warnv_p (op0,
14902 strict_overflow_p);
14906 tree inner_type = TREE_TYPE (op0);
14907 tree outer_type = type;
14909 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
14910 && tree_expr_nonzero_warnv_p (op0,
14911 strict_overflow_p));
14915 case NON_LVALUE_EXPR:
14916 return tree_expr_nonzero_warnv_p (op0,
14917 strict_overflow_p);
14926 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
14927 For floating point we further ensure that T is not denormal.
14928 Similar logic is present in nonzero_address in rtlanal.h.
14930 If the return value is based on the assumption that signed overflow
14931 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14932 change *STRICT_OVERFLOW_P. */
14935 tree_binary_nonzero_warnv_p (enum tree_code code,
14938 tree op1, bool *strict_overflow_p)
14940 bool sub_strict_overflow_p;
14943 case POINTER_PLUS_EXPR:
14945 if (TYPE_OVERFLOW_UNDEFINED (type))
14947 /* With the presence of negative values it is hard
14948 to say something. */
14949 sub_strict_overflow_p = false;
14950 if (!tree_expr_nonnegative_warnv_p (op0,
14951 &sub_strict_overflow_p)
14952 || !tree_expr_nonnegative_warnv_p (op1,
14953 &sub_strict_overflow_p))
14955 /* One of operands must be positive and the other non-negative. */
14956 /* We don't set *STRICT_OVERFLOW_P here: even if this value
14957 overflows, on a twos-complement machine the sum of two
14958 nonnegative numbers can never be zero. */
14959 return (tree_expr_nonzero_warnv_p (op0,
14961 || tree_expr_nonzero_warnv_p (op1,
14962 strict_overflow_p));
14967 if (TYPE_OVERFLOW_UNDEFINED (type))
14969 if (tree_expr_nonzero_warnv_p (op0,
14971 && tree_expr_nonzero_warnv_p (op1,
14972 strict_overflow_p))
14974 *strict_overflow_p = true;
14981 sub_strict_overflow_p = false;
14982 if (tree_expr_nonzero_warnv_p (op0,
14983 &sub_strict_overflow_p)
14984 && tree_expr_nonzero_warnv_p (op1,
14985 &sub_strict_overflow_p))
14987 if (sub_strict_overflow_p)
14988 *strict_overflow_p = true;
14993 sub_strict_overflow_p = false;
14994 if (tree_expr_nonzero_warnv_p (op0,
14995 &sub_strict_overflow_p))
14997 if (sub_strict_overflow_p)
14998 *strict_overflow_p = true;
15000 /* When both operands are nonzero, then MAX must be too. */
15001 if (tree_expr_nonzero_warnv_p (op1,
15002 strict_overflow_p))
15005 /* MAX where operand 0 is positive is positive. */
15006 return tree_expr_nonnegative_warnv_p (op0,
15007 strict_overflow_p);
15009 /* MAX where operand 1 is positive is positive. */
15010 else if (tree_expr_nonzero_warnv_p (op1,
15011 &sub_strict_overflow_p)
15012 && tree_expr_nonnegative_warnv_p (op1,
15013 &sub_strict_overflow_p))
15015 if (sub_strict_overflow_p)
15016 *strict_overflow_p = true;
15022 return (tree_expr_nonzero_warnv_p (op1,
15024 || tree_expr_nonzero_warnv_p (op0,
15025 strict_overflow_p));
15034 /* Return true when T is an address and is known to be nonzero.
15035 For floating point we further ensure that T is not denormal.
15036 Similar logic is present in nonzero_address in rtlanal.h.
15038 If the return value is based on the assumption that signed overflow
15039 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15040 change *STRICT_OVERFLOW_P. */
15043 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15045 bool sub_strict_overflow_p;
15046 switch (TREE_CODE (t))
15049 return !integer_zerop (t);
15053 tree base = get_base_address (TREE_OPERAND (t, 0));
15058 /* Weak declarations may link to NULL. Other things may also be NULL
15059 so protect with -fdelete-null-pointer-checks; but not variables
15060 allocated on the stack. */
15062 && (flag_delete_null_pointer_checks
15063 || (TREE_CODE (base) == VAR_DECL && !TREE_STATIC (base))))
15064 return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
15066 /* Constants are never weak. */
15067 if (CONSTANT_CLASS_P (base))
15074 sub_strict_overflow_p = false;
15075 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15076 &sub_strict_overflow_p)
15077 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15078 &sub_strict_overflow_p))
15080 if (sub_strict_overflow_p)
15081 *strict_overflow_p = true;
15092 /* Return true when T is an address and is known to be nonzero.
15093 For floating point we further ensure that T is not denormal.
15094 Similar logic is present in nonzero_address in rtlanal.h.
15096 If the return value is based on the assumption that signed overflow
15097 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15098 change *STRICT_OVERFLOW_P. */
15101 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15103 tree type = TREE_TYPE (t);
15104 enum tree_code code;
15106 /* Doing something useful for floating point would need more work. */
15107 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
15110 code = TREE_CODE (t);
15111 switch (TREE_CODE_CLASS (code))
15114 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15115 strict_overflow_p);
15117 case tcc_comparison:
15118 return tree_binary_nonzero_warnv_p (code, type,
15119 TREE_OPERAND (t, 0),
15120 TREE_OPERAND (t, 1),
15121 strict_overflow_p);
15123 case tcc_declaration:
15124 case tcc_reference:
15125 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15133 case TRUTH_NOT_EXPR:
15134 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15135 strict_overflow_p);
15137 case TRUTH_AND_EXPR:
15138 case TRUTH_OR_EXPR:
15139 case TRUTH_XOR_EXPR:
15140 return tree_binary_nonzero_warnv_p (code, type,
15141 TREE_OPERAND (t, 0),
15142 TREE_OPERAND (t, 1),
15143 strict_overflow_p);
15150 case WITH_SIZE_EXPR:
15154 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15156 case COMPOUND_EXPR:
15159 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15160 strict_overflow_p);
15163 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
15164 strict_overflow_p);
15167 return alloca_call_p (t);
15175 /* Return true when T is an address and is known to be nonzero.
15176 Handle warnings about undefined signed overflow. */
15179 tree_expr_nonzero_p (tree t)
15181 bool ret, strict_overflow_p;
15183 strict_overflow_p = false;
15184 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
15185 if (strict_overflow_p)
15186 fold_overflow_warning (("assuming signed overflow does not occur when "
15187 "determining that expression is always "
15189 WARN_STRICT_OVERFLOW_MISC);
15193 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15194 attempt to fold the expression to a constant without modifying TYPE,
15197 If the expression could be simplified to a constant, then return
15198 the constant. If the expression would not be simplified to a
15199 constant, then return NULL_TREE. */
15202 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15204 tree tem = fold_binary (code, type, op0, op1);
15205 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15208 /* Given the components of a unary expression CODE, TYPE and OP0,
15209 attempt to fold the expression to a constant without modifying
15212 If the expression could be simplified to a constant, then return
15213 the constant. If the expression would not be simplified to a
15214 constant, then return NULL_TREE. */
15217 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15219 tree tem = fold_unary (code, type, op0);
15220 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15223 /* If EXP represents referencing an element in a constant string
15224 (either via pointer arithmetic or array indexing), return the
15225 tree representing the value accessed, otherwise return NULL. */
15228 fold_read_from_constant_string (tree exp)
15230 if ((TREE_CODE (exp) == INDIRECT_REF
15231 || TREE_CODE (exp) == ARRAY_REF)
15232 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15234 tree exp1 = TREE_OPERAND (exp, 0);
15238 if (TREE_CODE (exp) == INDIRECT_REF)
15239 string = string_constant (exp1, &index);
15242 tree low_bound = array_ref_low_bound (exp);
15243 index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
15245 /* Optimize the special-case of a zero lower bound.
15247 We convert the low_bound to sizetype to avoid some problems
15248 with constant folding. (E.g. suppose the lower bound is 1,
15249 and its mode is QI. Without the conversion,l (ARRAY
15250 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15251 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15252 if (! integer_zerop (low_bound))
15253 index = size_diffop (index, fold_convert (sizetype, low_bound));
15259 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15260 && TREE_CODE (string) == STRING_CST
15261 && TREE_CODE (index) == INTEGER_CST
15262 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15263 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15265 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15266 return build_int_cst_type (TREE_TYPE (exp),
15267 (TREE_STRING_POINTER (string)
15268 [TREE_INT_CST_LOW (index)]));
15273 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15274 an integer constant, real, or fixed-point constant.
15276 TYPE is the type of the result. */
15279 fold_negate_const (tree arg0, tree type)
15281 tree t = NULL_TREE;
15283 switch (TREE_CODE (arg0))
15287 unsigned HOST_WIDE_INT low;
15288 HOST_WIDE_INT high;
15289 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
15290 TREE_INT_CST_HIGH (arg0),
15292 t = force_fit_type_double (type, low, high, 1,
15293 (overflow | TREE_OVERFLOW (arg0))
15294 && !TYPE_UNSIGNED (type));
15299 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
15304 FIXED_VALUE_TYPE f;
15305 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15306 &(TREE_FIXED_CST (arg0)), NULL,
15307 TYPE_SATURATING (type));
15308 t = build_fixed (type, f);
15309 /* Propagate overflow flags. */
15310 if (overflow_p | TREE_OVERFLOW (arg0))
15311 TREE_OVERFLOW (t) = 1;
15316 gcc_unreachable ();
15322 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15323 an integer constant or real constant.
15325 TYPE is the type of the result. */
15328 fold_abs_const (tree arg0, tree type)
15330 tree t = NULL_TREE;
15332 switch (TREE_CODE (arg0))
15335 /* If the value is unsigned, then the absolute value is
15336 the same as the ordinary value. */
15337 if (TYPE_UNSIGNED (type))
15339 /* Similarly, if the value is non-negative. */
15340 else if (INT_CST_LT (integer_minus_one_node, arg0))
15342 /* If the value is negative, then the absolute value is
15346 unsigned HOST_WIDE_INT low;
15347 HOST_WIDE_INT high;
15348 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
15349 TREE_INT_CST_HIGH (arg0),
15351 t = force_fit_type_double (type, low, high, -1,
15352 overflow | TREE_OVERFLOW (arg0));
15357 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15358 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
15364 gcc_unreachable ();
15370 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15371 constant. TYPE is the type of the result. */
15374 fold_not_const (tree arg0, tree type)
15376 tree t = NULL_TREE;
15378 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
15380 t = force_fit_type_double (type, ~TREE_INT_CST_LOW (arg0),
15381 ~TREE_INT_CST_HIGH (arg0), 0,
15382 TREE_OVERFLOW (arg0));
15387 /* Given CODE, a relational operator, the target type, TYPE and two
15388 constant operands OP0 and OP1, return the result of the
15389 relational operation. If the result is not a compile time
15390 constant, then return NULL_TREE. */
15393 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
15395 int result, invert;
15397 /* From here on, the only cases we handle are when the result is
15398 known to be a constant. */
15400 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
15402 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
15403 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
15405 /* Handle the cases where either operand is a NaN. */
15406 if (real_isnan (c0) || real_isnan (c1))
15416 case UNORDERED_EXPR:
15430 if (flag_trapping_math)
15436 gcc_unreachable ();
15439 return constant_boolean_node (result, type);
15442 return constant_boolean_node (real_compare (code, c0, c1), type);
15445 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
15447 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
15448 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
15449 return constant_boolean_node (fixed_compare (code, c0, c1), type);
15452 /* Handle equality/inequality of complex constants. */
15453 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
15455 tree rcond = fold_relational_const (code, type,
15456 TREE_REALPART (op0),
15457 TREE_REALPART (op1));
15458 tree icond = fold_relational_const (code, type,
15459 TREE_IMAGPART (op0),
15460 TREE_IMAGPART (op1));
15461 if (code == EQ_EXPR)
15462 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
15463 else if (code == NE_EXPR)
15464 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
15469 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
15471 To compute GT, swap the arguments and do LT.
15472 To compute GE, do LT and invert the result.
15473 To compute LE, swap the arguments, do LT and invert the result.
15474 To compute NE, do EQ and invert the result.
15476 Therefore, the code below must handle only EQ and LT. */
15478 if (code == LE_EXPR || code == GT_EXPR)
15483 code = swap_tree_comparison (code);
15486 /* Note that it is safe to invert for real values here because we
15487 have already handled the one case that it matters. */
15490 if (code == NE_EXPR || code == GE_EXPR)
15493 code = invert_tree_comparison (code, false);
15496 /* Compute a result for LT or EQ if args permit;
15497 Otherwise return T. */
15498 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
15500 if (code == EQ_EXPR)
15501 result = tree_int_cst_equal (op0, op1);
15502 else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
15503 result = INT_CST_LT_UNSIGNED (op0, op1);
15505 result = INT_CST_LT (op0, op1);
15512 return constant_boolean_node (result, type);
15515 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
15516 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
15520 fold_build_cleanup_point_expr (tree type, tree expr)
15522 /* If the expression does not have side effects then we don't have to wrap
15523 it with a cleanup point expression. */
15524 if (!TREE_SIDE_EFFECTS (expr))
15527 /* If the expression is a return, check to see if the expression inside the
15528 return has no side effects or the right hand side of the modify expression
15529 inside the return. If either don't have side effects set we don't need to
15530 wrap the expression in a cleanup point expression. Note we don't check the
15531 left hand side of the modify because it should always be a return decl. */
15532 if (TREE_CODE (expr) == RETURN_EXPR)
15534 tree op = TREE_OPERAND (expr, 0);
15535 if (!op || !TREE_SIDE_EFFECTS (op))
15537 op = TREE_OPERAND (op, 1);
15538 if (!TREE_SIDE_EFFECTS (op))
15542 return build1 (CLEANUP_POINT_EXPR, type, expr);
15545 /* Given a pointer value OP0 and a type TYPE, return a simplified version
15546 of an indirection through OP0, or NULL_TREE if no simplification is
15550 fold_indirect_ref_1 (tree type, tree op0)
15556 subtype = TREE_TYPE (sub);
15557 if (!POINTER_TYPE_P (subtype))
15560 if (TREE_CODE (sub) == ADDR_EXPR)
15562 tree op = TREE_OPERAND (sub, 0);
15563 tree optype = TREE_TYPE (op);
15564 /* *&CONST_DECL -> to the value of the const decl. */
15565 if (TREE_CODE (op) == CONST_DECL)
15566 return DECL_INITIAL (op);
15567 /* *&p => p; make sure to handle *&"str"[cst] here. */
15568 if (type == optype)
15570 tree fop = fold_read_from_constant_string (op);
15576 /* *(foo *)&fooarray => fooarray[0] */
15577 else if (TREE_CODE (optype) == ARRAY_TYPE
15578 && type == TREE_TYPE (optype))
15580 tree type_domain = TYPE_DOMAIN (optype);
15581 tree min_val = size_zero_node;
15582 if (type_domain && TYPE_MIN_VALUE (type_domain))
15583 min_val = TYPE_MIN_VALUE (type_domain);
15584 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
15586 /* *(foo *)&complexfoo => __real__ complexfoo */
15587 else if (TREE_CODE (optype) == COMPLEX_TYPE
15588 && type == TREE_TYPE (optype))
15589 return fold_build1 (REALPART_EXPR, type, op);
15590 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
15591 else if (TREE_CODE (optype) == VECTOR_TYPE
15592 && type == TREE_TYPE (optype))
15594 tree part_width = TYPE_SIZE (type);
15595 tree index = bitsize_int (0);
15596 return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
15600 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
15601 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
15602 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
15604 tree op00 = TREE_OPERAND (sub, 0);
15605 tree op01 = TREE_OPERAND (sub, 1);
15609 op00type = TREE_TYPE (op00);
15610 if (TREE_CODE (op00) == ADDR_EXPR
15611 && TREE_CODE (TREE_TYPE (op00type)) == VECTOR_TYPE
15612 && type == TREE_TYPE (TREE_TYPE (op00type)))
15614 HOST_WIDE_INT offset = tree_low_cst (op01, 0);
15615 tree part_width = TYPE_SIZE (type);
15616 unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
15617 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
15618 tree index = bitsize_int (indexi);
15620 if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (op00type)))
15621 return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (op00, 0),
15622 part_width, index);
15628 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
15629 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
15630 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
15632 tree op00 = TREE_OPERAND (sub, 0);
15633 tree op01 = TREE_OPERAND (sub, 1);
15637 op00type = TREE_TYPE (op00);
15638 if (TREE_CODE (op00) == ADDR_EXPR
15639 && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
15640 && type == TREE_TYPE (TREE_TYPE (op00type)))
15642 tree size = TYPE_SIZE_UNIT (type);
15643 if (tree_int_cst_equal (size, op01))
15644 return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
15648 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
15649 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
15650 && type == TREE_TYPE (TREE_TYPE (subtype)))
15653 tree min_val = size_zero_node;
15654 sub = build_fold_indirect_ref (sub);
15655 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
15656 if (type_domain && TYPE_MIN_VALUE (type_domain))
15657 min_val = TYPE_MIN_VALUE (type_domain);
15658 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
15664 /* Builds an expression for an indirection through T, simplifying some
15668 build_fold_indirect_ref (tree t)
15670 tree type = TREE_TYPE (TREE_TYPE (t));
15671 tree sub = fold_indirect_ref_1 (type, t);
15676 return build1 (INDIRECT_REF, type, t);
15679 /* Given an INDIRECT_REF T, return either T or a simplified version. */
15682 fold_indirect_ref (tree t)
15684 tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
15692 /* Strip non-trapping, non-side-effecting tree nodes from an expression
15693 whose result is ignored. The type of the returned tree need not be
15694 the same as the original expression. */
15697 fold_ignored_result (tree t)
15699 if (!TREE_SIDE_EFFECTS (t))
15700 return integer_zero_node;
15703 switch (TREE_CODE_CLASS (TREE_CODE (t)))
15706 t = TREE_OPERAND (t, 0);
15710 case tcc_comparison:
15711 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15712 t = TREE_OPERAND (t, 0);
15713 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
15714 t = TREE_OPERAND (t, 1);
15719 case tcc_expression:
15720 switch (TREE_CODE (t))
15722 case COMPOUND_EXPR:
15723 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15725 t = TREE_OPERAND (t, 0);
15729 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
15730 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
15732 t = TREE_OPERAND (t, 0);
15745 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
15746 This can only be applied to objects of a sizetype. */
15749 round_up (tree value, int divisor)
15751 tree div = NULL_TREE;
15753 gcc_assert (divisor > 0);
15757 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
15758 have to do anything. Only do this when we are not given a const,
15759 because in that case, this check is more expensive than just
15761 if (TREE_CODE (value) != INTEGER_CST)
15763 div = build_int_cst (TREE_TYPE (value), divisor);
15765 if (multiple_of_p (TREE_TYPE (value), value, div))
15769 /* If divisor is a power of two, simplify this to bit manipulation. */
15770 if (divisor == (divisor & -divisor))
15772 if (TREE_CODE (value) == INTEGER_CST)
15774 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (value);
15775 unsigned HOST_WIDE_INT high;
15778 if ((low & (divisor - 1)) == 0)
15781 overflow_p = TREE_OVERFLOW (value);
15782 high = TREE_INT_CST_HIGH (value);
15783 low &= ~(divisor - 1);
15792 return force_fit_type_double (TREE_TYPE (value), low, high,
15799 t = build_int_cst (TREE_TYPE (value), divisor - 1);
15800 value = size_binop (PLUS_EXPR, value, t);
15801 t = build_int_cst (TREE_TYPE (value), -divisor);
15802 value = size_binop (BIT_AND_EXPR, value, t);
15808 div = build_int_cst (TREE_TYPE (value), divisor);
15809 value = size_binop (CEIL_DIV_EXPR, value, div);
15810 value = size_binop (MULT_EXPR, value, div);
15816 /* Likewise, but round down. */
15819 round_down (tree value, int divisor)
15821 tree div = NULL_TREE;
15823 gcc_assert (divisor > 0);
15827 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
15828 have to do anything. Only do this when we are not given a const,
15829 because in that case, this check is more expensive than just
15831 if (TREE_CODE (value) != INTEGER_CST)
15833 div = build_int_cst (TREE_TYPE (value), divisor);
15835 if (multiple_of_p (TREE_TYPE (value), value, div))
15839 /* If divisor is a power of two, simplify this to bit manipulation. */
15840 if (divisor == (divisor & -divisor))
15844 t = build_int_cst (TREE_TYPE (value), -divisor);
15845 value = size_binop (BIT_AND_EXPR, value, t);
15850 div = build_int_cst (TREE_TYPE (value), divisor);
15851 value = size_binop (FLOOR_DIV_EXPR, value, div);
15852 value = size_binop (MULT_EXPR, value, div);
15858 /* Returns the pointer to the base of the object addressed by EXP and
15859 extracts the information about the offset of the access, storing it
15860 to PBITPOS and POFFSET. */
15863 split_address_to_core_and_offset (tree exp,
15864 HOST_WIDE_INT *pbitpos, tree *poffset)
15867 enum machine_mode mode;
15868 int unsignedp, volatilep;
15869 HOST_WIDE_INT bitsize;
15871 if (TREE_CODE (exp) == ADDR_EXPR)
15873 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
15874 poffset, &mode, &unsignedp, &volatilep,
15876 core = build_fold_addr_expr (core);
15882 *poffset = NULL_TREE;
15888 /* Returns true if addresses of E1 and E2 differ by a constant, false
15889 otherwise. If they do, E1 - E2 is stored in *DIFF. */
15892 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
15895 HOST_WIDE_INT bitpos1, bitpos2;
15896 tree toffset1, toffset2, tdiff, type;
15898 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
15899 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
15901 if (bitpos1 % BITS_PER_UNIT != 0
15902 || bitpos2 % BITS_PER_UNIT != 0
15903 || !operand_equal_p (core1, core2, 0))
15906 if (toffset1 && toffset2)
15908 type = TREE_TYPE (toffset1);
15909 if (type != TREE_TYPE (toffset2))
15910 toffset2 = fold_convert (type, toffset2);
15912 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
15913 if (!cst_and_fits_in_hwi (tdiff))
15916 *diff = int_cst_value (tdiff);
15918 else if (toffset1 || toffset2)
15920 /* If only one of the offsets is non-constant, the difference cannot
15927 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
15931 /* Simplify the floating point expression EXP when the sign of the
15932 result is not significant. Return NULL_TREE if no simplification
15936 fold_strip_sign_ops (tree exp)
15940 switch (TREE_CODE (exp))
15944 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15945 return arg0 ? arg0 : TREE_OPERAND (exp, 0);
15949 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
15951 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15952 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15953 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
15954 return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
15955 arg0 ? arg0 : TREE_OPERAND (exp, 0),
15956 arg1 ? arg1 : TREE_OPERAND (exp, 1));
15959 case COMPOUND_EXPR:
15960 arg0 = TREE_OPERAND (exp, 0);
15961 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15963 return fold_build2 (COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
15967 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15968 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
15970 return fold_build3 (COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
15971 arg0 ? arg0 : TREE_OPERAND (exp, 1),
15972 arg1 ? arg1 : TREE_OPERAND (exp, 2));
15977 const enum built_in_function fcode = builtin_mathfn_code (exp);
15980 CASE_FLT_FN (BUILT_IN_COPYSIGN):
15981 /* Strip copysign function call, return the 1st argument. */
15982 arg0 = CALL_EXPR_ARG (exp, 0);
15983 arg1 = CALL_EXPR_ARG (exp, 1);
15984 return omit_one_operand (TREE_TYPE (exp), arg0, arg1);
15987 /* Strip sign ops from the argument of "odd" math functions. */
15988 if (negate_mathfn_p (fcode))
15990 arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
15992 return build_call_expr (get_callee_fndecl (exp), 1, arg0);