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 static tree make_range (tree, int *, tree *, tree *, bool *);
123 static tree build_range_check (tree, tree, int, tree, tree);
124 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
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 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2334 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2335 to a floating point type. */
2338 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2340 REAL_VALUE_TYPE value;
2343 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2344 t = build_real (type, value);
2346 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2350 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2351 to another fixed-point type. */
2354 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2356 FIXED_VALUE_TYPE value;
2360 overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2361 TYPE_SATURATING (type));
2362 t = build_fixed (type, value);
2364 /* Propagate overflow flags. */
2365 if (overflow_p | TREE_OVERFLOW (arg1))
2366 TREE_OVERFLOW (t) = 1;
2370 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2371 to a fixed-point type. */
2374 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2376 FIXED_VALUE_TYPE value;
2380 overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
2381 TREE_INT_CST (arg1),
2382 TYPE_UNSIGNED (TREE_TYPE (arg1)),
2383 TYPE_SATURATING (type));
2384 t = build_fixed (type, value);
2386 /* Propagate overflow flags. */
2387 if (overflow_p | TREE_OVERFLOW (arg1))
2388 TREE_OVERFLOW (t) = 1;
2392 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2393 to a fixed-point type. */
2396 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2398 FIXED_VALUE_TYPE value;
2402 overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2403 &TREE_REAL_CST (arg1),
2404 TYPE_SATURATING (type));
2405 t = build_fixed (type, value);
2407 /* Propagate overflow flags. */
2408 if (overflow_p | TREE_OVERFLOW (arg1))
2409 TREE_OVERFLOW (t) = 1;
2413 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2414 type TYPE. If no simplification can be done return NULL_TREE. */
2417 fold_convert_const (enum tree_code code, tree type, tree arg1)
2419 if (TREE_TYPE (arg1) == type)
2422 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
2423 || TREE_CODE (type) == OFFSET_TYPE)
2425 if (TREE_CODE (arg1) == INTEGER_CST)
2426 return fold_convert_const_int_from_int (type, arg1);
2427 else if (TREE_CODE (arg1) == REAL_CST)
2428 return fold_convert_const_int_from_real (code, type, arg1);
2429 else if (TREE_CODE (arg1) == FIXED_CST)
2430 return fold_convert_const_int_from_fixed (type, arg1);
2432 else if (TREE_CODE (type) == REAL_TYPE)
2434 if (TREE_CODE (arg1) == INTEGER_CST)
2435 return build_real_from_int_cst (type, arg1);
2436 else if (TREE_CODE (arg1) == REAL_CST)
2437 return fold_convert_const_real_from_real (type, arg1);
2438 else if (TREE_CODE (arg1) == FIXED_CST)
2439 return fold_convert_const_real_from_fixed (type, arg1);
2441 else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2443 if (TREE_CODE (arg1) == FIXED_CST)
2444 return fold_convert_const_fixed_from_fixed (type, arg1);
2445 else if (TREE_CODE (arg1) == INTEGER_CST)
2446 return fold_convert_const_fixed_from_int (type, arg1);
2447 else if (TREE_CODE (arg1) == REAL_CST)
2448 return fold_convert_const_fixed_from_real (type, arg1);
2453 /* Construct a vector of zero elements of vector type TYPE. */
2456 build_zero_vector (tree type)
2461 elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2462 units = TYPE_VECTOR_SUBPARTS (type);
2465 for (i = 0; i < units; i++)
2466 list = tree_cons (NULL_TREE, elem, list);
2467 return build_vector (type, list);
2470 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2473 fold_convertible_p (const_tree type, const_tree arg)
2475 tree orig = TREE_TYPE (arg);
2480 if (TREE_CODE (arg) == ERROR_MARK
2481 || TREE_CODE (type) == ERROR_MARK
2482 || TREE_CODE (orig) == ERROR_MARK)
2485 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2488 switch (TREE_CODE (type))
2490 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2491 case POINTER_TYPE: case REFERENCE_TYPE:
2493 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2494 || TREE_CODE (orig) == OFFSET_TYPE)
2496 return (TREE_CODE (orig) == VECTOR_TYPE
2497 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2500 case FIXED_POINT_TYPE:
2504 return TREE_CODE (type) == TREE_CODE (orig);
2511 /* Convert expression ARG to type TYPE. Used by the middle-end for
2512 simple conversions in preference to calling the front-end's convert. */
2515 fold_convert (tree type, tree arg)
2517 tree orig = TREE_TYPE (arg);
2523 if (TREE_CODE (arg) == ERROR_MARK
2524 || TREE_CODE (type) == ERROR_MARK
2525 || TREE_CODE (orig) == ERROR_MARK)
2526 return error_mark_node;
2528 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2529 return fold_build1 (NOP_EXPR, type, arg);
2531 switch (TREE_CODE (type))
2533 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2534 case POINTER_TYPE: case REFERENCE_TYPE:
2536 if (TREE_CODE (arg) == INTEGER_CST)
2538 tem = fold_convert_const (NOP_EXPR, type, arg);
2539 if (tem != NULL_TREE)
2542 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2543 || TREE_CODE (orig) == OFFSET_TYPE)
2544 return fold_build1 (NOP_EXPR, type, arg);
2545 if (TREE_CODE (orig) == COMPLEX_TYPE)
2547 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2548 return fold_convert (type, tem);
2550 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2551 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2552 return fold_build1 (NOP_EXPR, type, arg);
2555 if (TREE_CODE (arg) == INTEGER_CST)
2557 tem = fold_convert_const (FLOAT_EXPR, type, arg);
2558 if (tem != NULL_TREE)
2561 else if (TREE_CODE (arg) == REAL_CST)
2563 tem = fold_convert_const (NOP_EXPR, type, arg);
2564 if (tem != NULL_TREE)
2567 else if (TREE_CODE (arg) == FIXED_CST)
2569 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2570 if (tem != NULL_TREE)
2574 switch (TREE_CODE (orig))
2577 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2578 case POINTER_TYPE: case REFERENCE_TYPE:
2579 return fold_build1 (FLOAT_EXPR, type, arg);
2582 return fold_build1 (NOP_EXPR, type, arg);
2584 case FIXED_POINT_TYPE:
2585 return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2588 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2589 return fold_convert (type, tem);
2595 case FIXED_POINT_TYPE:
2596 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2597 || TREE_CODE (arg) == REAL_CST)
2599 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2600 if (tem != NULL_TREE)
2604 switch (TREE_CODE (orig))
2606 case FIXED_POINT_TYPE:
2611 return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2614 tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2615 return fold_convert (type, tem);
2622 switch (TREE_CODE (orig))
2625 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2626 case POINTER_TYPE: case REFERENCE_TYPE:
2628 case FIXED_POINT_TYPE:
2629 return build2 (COMPLEX_EXPR, type,
2630 fold_convert (TREE_TYPE (type), arg),
2631 fold_convert (TREE_TYPE (type), integer_zero_node));
2636 if (TREE_CODE (arg) == COMPLEX_EXPR)
2638 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2639 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2640 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2643 arg = save_expr (arg);
2644 rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2645 ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2646 rpart = fold_convert (TREE_TYPE (type), rpart);
2647 ipart = fold_convert (TREE_TYPE (type), ipart);
2648 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2656 if (integer_zerop (arg))
2657 return build_zero_vector (type);
2658 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2659 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2660 || TREE_CODE (orig) == VECTOR_TYPE);
2661 return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2664 tem = fold_ignored_result (arg);
2665 if (TREE_CODE (tem) == MODIFY_EXPR)
2667 return fold_build1 (NOP_EXPR, type, tem);
2674 /* Return false if expr can be assumed not to be an lvalue, true
2678 maybe_lvalue_p (const_tree x)
2680 /* We only need to wrap lvalue tree codes. */
2681 switch (TREE_CODE (x))
2692 case ALIGN_INDIRECT_REF:
2693 case MISALIGNED_INDIRECT_REF:
2695 case ARRAY_RANGE_REF:
2701 case PREINCREMENT_EXPR:
2702 case PREDECREMENT_EXPR:
2704 case TRY_CATCH_EXPR:
2705 case WITH_CLEANUP_EXPR:
2716 /* Assume the worst for front-end tree codes. */
2717 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2725 /* Return an expr equal to X but certainly not valid as an lvalue. */
2730 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2735 if (! maybe_lvalue_p (x))
2737 return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2740 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2741 Zero means allow extended lvalues. */
2743 int pedantic_lvalues;
2745 /* When pedantic, return an expr equal to X but certainly not valid as a
2746 pedantic lvalue. Otherwise, return X. */
2749 pedantic_non_lvalue (tree x)
2751 if (pedantic_lvalues)
2752 return non_lvalue (x);
2757 /* Given a tree comparison code, return the code that is the logical inverse
2758 of the given code. It is not safe to do this for floating-point
2759 comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2760 as well: if reversing the comparison is unsafe, return ERROR_MARK. */
2763 invert_tree_comparison (enum tree_code code, bool honor_nans)
2765 if (honor_nans && flag_trapping_math)
2775 return honor_nans ? UNLE_EXPR : LE_EXPR;
2777 return honor_nans ? UNLT_EXPR : LT_EXPR;
2779 return honor_nans ? UNGE_EXPR : GE_EXPR;
2781 return honor_nans ? UNGT_EXPR : GT_EXPR;
2795 return UNORDERED_EXPR;
2796 case UNORDERED_EXPR:
2797 return ORDERED_EXPR;
2803 /* Similar, but return the comparison that results if the operands are
2804 swapped. This is safe for floating-point. */
2807 swap_tree_comparison (enum tree_code code)
2814 case UNORDERED_EXPR:
2840 /* Convert a comparison tree code from an enum tree_code representation
2841 into a compcode bit-based encoding. This function is the inverse of
2842 compcode_to_comparison. */
2844 static enum comparison_code
2845 comparison_to_compcode (enum tree_code code)
2862 return COMPCODE_ORD;
2863 case UNORDERED_EXPR:
2864 return COMPCODE_UNORD;
2866 return COMPCODE_UNLT;
2868 return COMPCODE_UNEQ;
2870 return COMPCODE_UNLE;
2872 return COMPCODE_UNGT;
2874 return COMPCODE_LTGT;
2876 return COMPCODE_UNGE;
2882 /* Convert a compcode bit-based encoding of a comparison operator back
2883 to GCC's enum tree_code representation. This function is the
2884 inverse of comparison_to_compcode. */
2886 static enum tree_code
2887 compcode_to_comparison (enum comparison_code code)
2904 return ORDERED_EXPR;
2905 case COMPCODE_UNORD:
2906 return UNORDERED_EXPR;
2924 /* Return a tree for the comparison which is the combination of
2925 doing the AND or OR (depending on CODE) of the two operations LCODE
2926 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2927 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2928 if this makes the transformation invalid. */
2931 combine_comparisons (enum tree_code code, enum tree_code lcode,
2932 enum tree_code rcode, tree truth_type,
2933 tree ll_arg, tree lr_arg)
2935 bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2936 enum comparison_code lcompcode = comparison_to_compcode (lcode);
2937 enum comparison_code rcompcode = comparison_to_compcode (rcode);
2942 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2943 compcode = lcompcode & rcompcode;
2946 case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2947 compcode = lcompcode | rcompcode;
2956 /* Eliminate unordered comparisons, as well as LTGT and ORD
2957 which are not used unless the mode has NaNs. */
2958 compcode &= ~COMPCODE_UNORD;
2959 if (compcode == COMPCODE_LTGT)
2960 compcode = COMPCODE_NE;
2961 else if (compcode == COMPCODE_ORD)
2962 compcode = COMPCODE_TRUE;
2964 else if (flag_trapping_math)
2966 /* Check that the original operation and the optimized ones will trap
2967 under the same condition. */
2968 bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2969 && (lcompcode != COMPCODE_EQ)
2970 && (lcompcode != COMPCODE_ORD);
2971 bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2972 && (rcompcode != COMPCODE_EQ)
2973 && (rcompcode != COMPCODE_ORD);
2974 bool trap = (compcode & COMPCODE_UNORD) == 0
2975 && (compcode != COMPCODE_EQ)
2976 && (compcode != COMPCODE_ORD);
2978 /* In a short-circuited boolean expression the LHS might be
2979 such that the RHS, if evaluated, will never trap. For
2980 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2981 if neither x nor y is NaN. (This is a mixed blessing: for
2982 example, the expression above will never trap, hence
2983 optimizing it to x < y would be invalid). */
2984 if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2985 || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2988 /* If the comparison was short-circuited, and only the RHS
2989 trapped, we may now generate a spurious trap. */
2991 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2994 /* If we changed the conditions that cause a trap, we lose. */
2995 if ((ltrap || rtrap) != trap)
2999 if (compcode == COMPCODE_TRUE)
3000 return constant_boolean_node (true, truth_type);
3001 else if (compcode == COMPCODE_FALSE)
3002 return constant_boolean_node (false, truth_type);
3005 enum tree_code tcode;
3007 tcode = compcode_to_comparison ((enum comparison_code) compcode);
3008 return fold_build2 (tcode, truth_type, ll_arg, lr_arg);
3012 /* Return nonzero if two operands (typically of the same tree node)
3013 are necessarily equal. If either argument has side-effects this
3014 function returns zero. FLAGS modifies behavior as follows:
3016 If OEP_ONLY_CONST is set, only return nonzero for constants.
3017 This function tests whether the operands are indistinguishable;
3018 it does not test whether they are equal using C's == operation.
3019 The distinction is important for IEEE floating point, because
3020 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
3021 (2) two NaNs may be indistinguishable, but NaN!=NaN.
3023 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
3024 even though it may hold multiple values during a function.
3025 This is because a GCC tree node guarantees that nothing else is
3026 executed between the evaluation of its "operands" (which may often
3027 be evaluated in arbitrary order). Hence if the operands themselves
3028 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
3029 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
3030 unset means assuming isochronic (or instantaneous) tree equivalence.
3031 Unless comparing arbitrary expression trees, such as from different
3032 statements, this flag can usually be left unset.
3034 If OEP_PURE_SAME is set, then pure functions with identical arguments
3035 are considered the same. It is used when the caller has other ways
3036 to ensure that global memory is unchanged in between. */
3039 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
3041 /* If either is ERROR_MARK, they aren't equal. */
3042 if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
3045 /* Check equality of integer constants before bailing out due to
3046 precision differences. */
3047 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
3048 return tree_int_cst_equal (arg0, arg1);
3050 /* If both types don't have the same signedness, then we can't consider
3051 them equal. We must check this before the STRIP_NOPS calls
3052 because they may change the signedness of the arguments. As pointers
3053 strictly don't have a signedness, require either two pointers or
3054 two non-pointers as well. */
3055 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
3056 || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
3059 /* If both types don't have the same precision, then it is not safe
3061 if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
3067 /* In case both args are comparisons but with different comparison
3068 code, try to swap the comparison operands of one arg to produce
3069 a match and compare that variant. */
3070 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3071 && COMPARISON_CLASS_P (arg0)
3072 && COMPARISON_CLASS_P (arg1))
3074 enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
3076 if (TREE_CODE (arg0) == swap_code)
3077 return operand_equal_p (TREE_OPERAND (arg0, 0),
3078 TREE_OPERAND (arg1, 1), flags)
3079 && operand_equal_p (TREE_OPERAND (arg0, 1),
3080 TREE_OPERAND (arg1, 0), flags);
3083 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3084 /* This is needed for conversions and for COMPONENT_REF.
3085 Might as well play it safe and always test this. */
3086 || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
3087 || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
3088 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
3091 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3092 We don't care about side effects in that case because the SAVE_EXPR
3093 takes care of that for us. In all other cases, two expressions are
3094 equal if they have no side effects. If we have two identical
3095 expressions with side effects that should be treated the same due
3096 to the only side effects being identical SAVE_EXPR's, that will
3097 be detected in the recursive calls below. */
3098 if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
3099 && (TREE_CODE (arg0) == SAVE_EXPR
3100 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
3103 /* Next handle constant cases, those for which we can return 1 even
3104 if ONLY_CONST is set. */
3105 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
3106 switch (TREE_CODE (arg0))
3109 return tree_int_cst_equal (arg0, arg1);
3112 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
3113 TREE_FIXED_CST (arg1));
3116 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
3117 TREE_REAL_CST (arg1)))
3121 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
3123 /* If we do not distinguish between signed and unsigned zero,
3124 consider them equal. */
3125 if (real_zerop (arg0) && real_zerop (arg1))
3134 v1 = TREE_VECTOR_CST_ELTS (arg0);
3135 v2 = TREE_VECTOR_CST_ELTS (arg1);
3138 if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
3141 v1 = TREE_CHAIN (v1);
3142 v2 = TREE_CHAIN (v2);
3149 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
3151 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
3155 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
3156 && ! memcmp (TREE_STRING_POINTER (arg0),
3157 TREE_STRING_POINTER (arg1),
3158 TREE_STRING_LENGTH (arg0)));
3161 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
3167 if (flags & OEP_ONLY_CONST)
3170 /* Define macros to test an operand from arg0 and arg1 for equality and a
3171 variant that allows null and views null as being different from any
3172 non-null value. In the latter case, if either is null, the both
3173 must be; otherwise, do the normal comparison. */
3174 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3175 TREE_OPERAND (arg1, N), flags)
3177 #define OP_SAME_WITH_NULL(N) \
3178 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3179 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3181 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
3184 /* Two conversions are equal only if signedness and modes match. */
3185 switch (TREE_CODE (arg0))
3188 case FIX_TRUNC_EXPR:
3189 if (TYPE_UNSIGNED (TREE_TYPE (arg0))
3190 != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3200 case tcc_comparison:
3202 if (OP_SAME (0) && OP_SAME (1))
3205 /* For commutative ops, allow the other order. */
3206 return (commutative_tree_code (TREE_CODE (arg0))
3207 && operand_equal_p (TREE_OPERAND (arg0, 0),
3208 TREE_OPERAND (arg1, 1), flags)
3209 && operand_equal_p (TREE_OPERAND (arg0, 1),
3210 TREE_OPERAND (arg1, 0), flags));
3213 /* If either of the pointer (or reference) expressions we are
3214 dereferencing contain a side effect, these cannot be equal. */
3215 if (TREE_SIDE_EFFECTS (arg0)
3216 || TREE_SIDE_EFFECTS (arg1))
3219 switch (TREE_CODE (arg0))
3222 case ALIGN_INDIRECT_REF:
3223 case MISALIGNED_INDIRECT_REF:
3229 case ARRAY_RANGE_REF:
3230 /* Operands 2 and 3 may be null.
3231 Compare the array index by value if it is constant first as we
3232 may have different types but same value here. */
3234 && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3235 TREE_OPERAND (arg1, 1))
3237 && OP_SAME_WITH_NULL (2)
3238 && OP_SAME_WITH_NULL (3));
3241 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3242 may be NULL when we're called to compare MEM_EXPRs. */
3243 return OP_SAME_WITH_NULL (0)
3245 && OP_SAME_WITH_NULL (2);
3248 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3254 case tcc_expression:
3255 switch (TREE_CODE (arg0))
3258 case TRUTH_NOT_EXPR:
3261 case TRUTH_ANDIF_EXPR:
3262 case TRUTH_ORIF_EXPR:
3263 return OP_SAME (0) && OP_SAME (1);
3265 case TRUTH_AND_EXPR:
3267 case TRUTH_XOR_EXPR:
3268 if (OP_SAME (0) && OP_SAME (1))
3271 /* Otherwise take into account this is a commutative operation. */
3272 return (operand_equal_p (TREE_OPERAND (arg0, 0),
3273 TREE_OPERAND (arg1, 1), flags)
3274 && operand_equal_p (TREE_OPERAND (arg0, 1),
3275 TREE_OPERAND (arg1, 0), flags));
3278 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3285 switch (TREE_CODE (arg0))
3288 /* If the CALL_EXPRs call different functions, then they
3289 clearly can not be equal. */
3290 if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3295 unsigned int cef = call_expr_flags (arg0);
3296 if (flags & OEP_PURE_SAME)
3297 cef &= ECF_CONST | ECF_PURE;
3304 /* Now see if all the arguments are the same. */
3306 const_call_expr_arg_iterator iter0, iter1;
3308 for (a0 = first_const_call_expr_arg (arg0, &iter0),
3309 a1 = first_const_call_expr_arg (arg1, &iter1);
3311 a0 = next_const_call_expr_arg (&iter0),
3312 a1 = next_const_call_expr_arg (&iter1))
3313 if (! operand_equal_p (a0, a1, flags))
3316 /* If we get here and both argument lists are exhausted
3317 then the CALL_EXPRs are equal. */
3318 return ! (a0 || a1);
3324 case tcc_declaration:
3325 /* Consider __builtin_sqrt equal to sqrt. */
3326 return (TREE_CODE (arg0) == FUNCTION_DECL
3327 && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3328 && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3329 && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3336 #undef OP_SAME_WITH_NULL
3339 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3340 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3342 When in doubt, return 0. */
3345 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3347 int unsignedp1, unsignedpo;
3348 tree primarg0, primarg1, primother;
3349 unsigned int correct_width;
3351 if (operand_equal_p (arg0, arg1, 0))
3354 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3355 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3358 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3359 and see if the inner values are the same. This removes any
3360 signedness comparison, which doesn't matter here. */
3361 primarg0 = arg0, primarg1 = arg1;
3362 STRIP_NOPS (primarg0);
3363 STRIP_NOPS (primarg1);
3364 if (operand_equal_p (primarg0, primarg1, 0))
3367 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3368 actual comparison operand, ARG0.
3370 First throw away any conversions to wider types
3371 already present in the operands. */
3373 primarg1 = get_narrower (arg1, &unsignedp1);
3374 primother = get_narrower (other, &unsignedpo);
3376 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3377 if (unsignedp1 == unsignedpo
3378 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3379 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3381 tree type = TREE_TYPE (arg0);
3383 /* Make sure shorter operand is extended the right way
3384 to match the longer operand. */
3385 primarg1 = fold_convert (signed_or_unsigned_type_for
3386 (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3388 if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3395 /* See if ARG is an expression that is either a comparison or is performing
3396 arithmetic on comparisons. The comparisons must only be comparing
3397 two different values, which will be stored in *CVAL1 and *CVAL2; if
3398 they are nonzero it means that some operands have already been found.
3399 No variables may be used anywhere else in the expression except in the
3400 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3401 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3403 If this is true, return 1. Otherwise, return zero. */
3406 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3408 enum tree_code code = TREE_CODE (arg);
3409 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3411 /* We can handle some of the tcc_expression cases here. */
3412 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3414 else if (tclass == tcc_expression
3415 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3416 || code == COMPOUND_EXPR))
3417 tclass = tcc_binary;
3419 else if (tclass == tcc_expression && code == SAVE_EXPR
3420 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3422 /* If we've already found a CVAL1 or CVAL2, this expression is
3423 two complex to handle. */
3424 if (*cval1 || *cval2)
3434 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3437 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3438 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3439 cval1, cval2, save_p));
3444 case tcc_expression:
3445 if (code == COND_EXPR)
3446 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3447 cval1, cval2, save_p)
3448 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3449 cval1, cval2, save_p)
3450 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3451 cval1, cval2, save_p));
3454 case tcc_comparison:
3455 /* First see if we can handle the first operand, then the second. For
3456 the second operand, we know *CVAL1 can't be zero. It must be that
3457 one side of the comparison is each of the values; test for the
3458 case where this isn't true by failing if the two operands
3461 if (operand_equal_p (TREE_OPERAND (arg, 0),
3462 TREE_OPERAND (arg, 1), 0))
3466 *cval1 = TREE_OPERAND (arg, 0);
3467 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3469 else if (*cval2 == 0)
3470 *cval2 = TREE_OPERAND (arg, 0);
3471 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3476 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3478 else if (*cval2 == 0)
3479 *cval2 = TREE_OPERAND (arg, 1);
3480 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3492 /* ARG is a tree that is known to contain just arithmetic operations and
3493 comparisons. Evaluate the operations in the tree substituting NEW0 for
3494 any occurrence of OLD0 as an operand of a comparison and likewise for
3498 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3500 tree type = TREE_TYPE (arg);
3501 enum tree_code code = TREE_CODE (arg);
3502 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3504 /* We can handle some of the tcc_expression cases here. */
3505 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3507 else if (tclass == tcc_expression
3508 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3509 tclass = tcc_binary;
3514 return fold_build1 (code, type,
3515 eval_subst (TREE_OPERAND (arg, 0),
3516 old0, new0, old1, new1));
3519 return fold_build2 (code, type,
3520 eval_subst (TREE_OPERAND (arg, 0),
3521 old0, new0, old1, new1),
3522 eval_subst (TREE_OPERAND (arg, 1),
3523 old0, new0, old1, new1));
3525 case tcc_expression:
3529 return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3532 return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3535 return fold_build3 (code, type,
3536 eval_subst (TREE_OPERAND (arg, 0),
3537 old0, new0, old1, new1),
3538 eval_subst (TREE_OPERAND (arg, 1),
3539 old0, new0, old1, new1),
3540 eval_subst (TREE_OPERAND (arg, 2),
3541 old0, new0, old1, new1));
3545 /* Fall through - ??? */
3547 case tcc_comparison:
3549 tree arg0 = TREE_OPERAND (arg, 0);
3550 tree arg1 = TREE_OPERAND (arg, 1);
3552 /* We need to check both for exact equality and tree equality. The
3553 former will be true if the operand has a side-effect. In that
3554 case, we know the operand occurred exactly once. */
3556 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3558 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3561 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3563 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3566 return fold_build2 (code, type, arg0, arg1);
3574 /* Return a tree for the case when the result of an expression is RESULT
3575 converted to TYPE and OMITTED was previously an operand of the expression
3576 but is now not needed (e.g., we folded OMITTED * 0).
3578 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3579 the conversion of RESULT to TYPE. */
3582 omit_one_operand (tree type, tree result, tree omitted)
3584 tree t = fold_convert (type, result);
3586 /* If the resulting operand is an empty statement, just return the omitted
3587 statement casted to void. */
3588 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3589 return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3591 if (TREE_SIDE_EFFECTS (omitted))
3592 return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3594 return non_lvalue (t);
3597 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
3600 pedantic_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 pedantic_non_lvalue (t);
3615 /* Return a tree for the case when the result of an expression is RESULT
3616 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3617 of the expression but are now not needed.
3619 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3620 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3621 evaluated before OMITTED2. Otherwise, if neither has side effects,
3622 just do the conversion of RESULT to TYPE. */
3625 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3627 tree t = fold_convert (type, result);
3629 if (TREE_SIDE_EFFECTS (omitted2))
3630 t = build2 (COMPOUND_EXPR, type, omitted2, t);
3631 if (TREE_SIDE_EFFECTS (omitted1))
3632 t = build2 (COMPOUND_EXPR, type, omitted1, t);
3634 return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3638 /* Return a simplified tree node for the truth-negation of ARG. This
3639 never alters ARG itself. We assume that ARG is an operation that
3640 returns a truth value (0 or 1).
3642 FIXME: one would think we would fold the result, but it causes
3643 problems with the dominator optimizer. */
3646 fold_truth_not_expr (tree arg)
3648 tree t, type = TREE_TYPE (arg);
3649 enum tree_code code = TREE_CODE (arg);
3651 /* If this is a comparison, we can simply invert it, except for
3652 floating-point non-equality comparisons, in which case we just
3653 enclose a TRUTH_NOT_EXPR around what we have. */
3655 if (TREE_CODE_CLASS (code) == tcc_comparison)
3657 tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3658 if (FLOAT_TYPE_P (op_type)
3659 && flag_trapping_math
3660 && code != ORDERED_EXPR && code != UNORDERED_EXPR
3661 && code != NE_EXPR && code != EQ_EXPR)
3664 code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3665 if (code == ERROR_MARK)
3668 t = build2 (code, type, TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3669 if (EXPR_HAS_LOCATION (arg))
3670 SET_EXPR_LOCATION (t, EXPR_LOCATION (arg));
3677 return constant_boolean_node (integer_zerop (arg), type);
3679 case TRUTH_AND_EXPR:
3680 t = build2 (TRUTH_OR_EXPR, type,
3681 invert_truthvalue (TREE_OPERAND (arg, 0)),
3682 invert_truthvalue (TREE_OPERAND (arg, 1)));
3686 t = build2 (TRUTH_AND_EXPR, type,
3687 invert_truthvalue (TREE_OPERAND (arg, 0)),
3688 invert_truthvalue (TREE_OPERAND (arg, 1)));
3691 case TRUTH_XOR_EXPR:
3692 /* Here we can invert either operand. We invert the first operand
3693 unless the second operand is a TRUTH_NOT_EXPR in which case our
3694 result is the XOR of the first operand with the inside of the
3695 negation of the second operand. */
3697 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3698 t = build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3699 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3701 t = build2 (TRUTH_XOR_EXPR, type,
3702 invert_truthvalue (TREE_OPERAND (arg, 0)),
3703 TREE_OPERAND (arg, 1));
3706 case TRUTH_ANDIF_EXPR:
3707 t = build2 (TRUTH_ORIF_EXPR, type,
3708 invert_truthvalue (TREE_OPERAND (arg, 0)),
3709 invert_truthvalue (TREE_OPERAND (arg, 1)));
3712 case TRUTH_ORIF_EXPR:
3713 t = build2 (TRUTH_ANDIF_EXPR, type,
3714 invert_truthvalue (TREE_OPERAND (arg, 0)),
3715 invert_truthvalue (TREE_OPERAND (arg, 1)));
3718 case TRUTH_NOT_EXPR:
3719 return TREE_OPERAND (arg, 0);
3723 tree arg1 = TREE_OPERAND (arg, 1);
3724 tree arg2 = TREE_OPERAND (arg, 2);
3725 /* A COND_EXPR may have a throw as one operand, which
3726 then has void type. Just leave void operands
3728 t = build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3729 VOID_TYPE_P (TREE_TYPE (arg1))
3730 ? arg1 : invert_truthvalue (arg1),
3731 VOID_TYPE_P (TREE_TYPE (arg2))
3732 ? arg2 : invert_truthvalue (arg2));
3737 t = build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3738 invert_truthvalue (TREE_OPERAND (arg, 1)));
3741 case NON_LVALUE_EXPR:
3742 return invert_truthvalue (TREE_OPERAND (arg, 0));
3745 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3747 t = build1 (TRUTH_NOT_EXPR, type, arg);
3751 /* ... fall through ... */
3755 t = build1 (TREE_CODE (arg), type,
3756 invert_truthvalue (TREE_OPERAND (arg, 0)));
3760 if (!integer_onep (TREE_OPERAND (arg, 1)))
3762 t = build2 (EQ_EXPR, type, arg, build_int_cst (type, 0));
3766 t = build1 (TRUTH_NOT_EXPR, type, arg);
3769 case CLEANUP_POINT_EXPR:
3770 t = build1 (CLEANUP_POINT_EXPR, type,
3771 invert_truthvalue (TREE_OPERAND (arg, 0)));
3779 if (t && EXPR_HAS_LOCATION (arg))
3780 SET_EXPR_LOCATION (t, EXPR_LOCATION (arg));
3785 /* Return a simplified tree node for the truth-negation of ARG. This
3786 never alters ARG itself. We assume that ARG is an operation that
3787 returns a truth value (0 or 1).
3789 FIXME: one would think we would fold the result, but it causes
3790 problems with the dominator optimizer. */
3793 invert_truthvalue (tree arg)
3797 if (TREE_CODE (arg) == ERROR_MARK)
3800 tem = fold_truth_not_expr (arg);
3802 tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3807 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3808 operands are another bit-wise operation with a common input. If so,
3809 distribute the bit operations to save an operation and possibly two if
3810 constants are involved. For example, convert
3811 (A | B) & (A | C) into A | (B & C)
3812 Further simplification will occur if B and C are constants.
3814 If this optimization cannot be done, 0 will be returned. */
3817 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3822 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3823 || TREE_CODE (arg0) == code
3824 || (TREE_CODE (arg0) != BIT_AND_EXPR
3825 && TREE_CODE (arg0) != BIT_IOR_EXPR))
3828 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3830 common = TREE_OPERAND (arg0, 0);
3831 left = TREE_OPERAND (arg0, 1);
3832 right = TREE_OPERAND (arg1, 1);
3834 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3836 common = TREE_OPERAND (arg0, 0);
3837 left = TREE_OPERAND (arg0, 1);
3838 right = TREE_OPERAND (arg1, 0);
3840 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3842 common = TREE_OPERAND (arg0, 1);
3843 left = TREE_OPERAND (arg0, 0);
3844 right = TREE_OPERAND (arg1, 1);
3846 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3848 common = TREE_OPERAND (arg0, 1);
3849 left = TREE_OPERAND (arg0, 0);
3850 right = TREE_OPERAND (arg1, 0);
3855 common = fold_convert (type, common);
3856 left = fold_convert (type, left);
3857 right = fold_convert (type, right);
3858 return fold_build2 (TREE_CODE (arg0), type, common,
3859 fold_build2 (code, type, left, right));
3862 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3863 with code CODE. This optimization is unsafe. */
3865 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3867 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3868 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3870 /* (A / C) +- (B / C) -> (A +- B) / C. */
3872 && operand_equal_p (TREE_OPERAND (arg0, 1),
3873 TREE_OPERAND (arg1, 1), 0))
3874 return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3875 fold_build2 (code, type,
3876 TREE_OPERAND (arg0, 0),
3877 TREE_OPERAND (arg1, 0)),
3878 TREE_OPERAND (arg0, 1));
3880 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3881 if (operand_equal_p (TREE_OPERAND (arg0, 0),
3882 TREE_OPERAND (arg1, 0), 0)
3883 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3884 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3886 REAL_VALUE_TYPE r0, r1;
3887 r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3888 r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3890 real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3892 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3893 real_arithmetic (&r0, code, &r0, &r1);
3894 return fold_build2 (MULT_EXPR, type,
3895 TREE_OPERAND (arg0, 0),
3896 build_real (type, r0));
3902 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3903 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3906 make_bit_field_ref (tree inner, tree type, HOST_WIDE_INT bitsize,
3907 HOST_WIDE_INT bitpos, int unsignedp)
3909 tree result, bftype;
3913 tree size = TYPE_SIZE (TREE_TYPE (inner));
3914 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3915 || POINTER_TYPE_P (TREE_TYPE (inner)))
3916 && host_integerp (size, 0)
3917 && tree_low_cst (size, 0) == bitsize)
3918 return fold_convert (type, inner);
3922 if (TYPE_PRECISION (bftype) != bitsize
3923 || TYPE_UNSIGNED (bftype) == !unsignedp)
3924 bftype = build_nonstandard_integer_type (bitsize, 0);
3926 result = build3 (BIT_FIELD_REF, bftype, inner,
3927 size_int (bitsize), bitsize_int (bitpos));
3930 result = fold_convert (type, result);
3935 /* Optimize a bit-field compare.
3937 There are two cases: First is a compare against a constant and the
3938 second is a comparison of two items where the fields are at the same
3939 bit position relative to the start of a chunk (byte, halfword, word)
3940 large enough to contain it. In these cases we can avoid the shift
3941 implicit in bitfield extractions.
3943 For constants, we emit a compare of the shifted constant with the
3944 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3945 compared. For two fields at the same position, we do the ANDs with the
3946 similar mask and compare the result of the ANDs.
3948 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3949 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3950 are the left and right operands of the comparison, respectively.
3952 If the optimization described above can be done, we return the resulting
3953 tree. Otherwise we return zero. */
3956 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3959 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3960 tree type = TREE_TYPE (lhs);
3961 tree signed_type, unsigned_type;
3962 int const_p = TREE_CODE (rhs) == INTEGER_CST;
3963 enum machine_mode lmode, rmode, nmode;
3964 int lunsignedp, runsignedp;
3965 int lvolatilep = 0, rvolatilep = 0;
3966 tree linner, rinner = NULL_TREE;
3970 /* Get all the information about the extractions being done. If the bit size
3971 if the same as the size of the underlying object, we aren't doing an
3972 extraction at all and so can do nothing. We also don't want to
3973 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3974 then will no longer be able to replace it. */
3975 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3976 &lunsignedp, &lvolatilep, false);
3977 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3978 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3983 /* If this is not a constant, we can only do something if bit positions,
3984 sizes, and signedness are the same. */
3985 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3986 &runsignedp, &rvolatilep, false);
3988 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3989 || lunsignedp != runsignedp || offset != 0
3990 || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3994 /* See if we can find a mode to refer to this field. We should be able to,
3995 but fail if we can't. */
3996 nmode = get_best_mode (lbitsize, lbitpos,
3997 const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3998 : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3999 TYPE_ALIGN (TREE_TYPE (rinner))),
4000 word_mode, lvolatilep || rvolatilep);
4001 if (nmode == VOIDmode)
4004 /* Set signed and unsigned types of the precision of this mode for the
4006 signed_type = lang_hooks.types.type_for_mode (nmode, 0);
4007 unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
4009 /* Compute the bit position and size for the new reference and our offset
4010 within it. If the new reference is the same size as the original, we
4011 won't optimize anything, so return zero. */
4012 nbitsize = GET_MODE_BITSIZE (nmode);
4013 nbitpos = lbitpos & ~ (nbitsize - 1);
4015 if (nbitsize == lbitsize)
4018 if (BYTES_BIG_ENDIAN)
4019 lbitpos = nbitsize - lbitsize - lbitpos;
4021 /* Make the mask to be used against the extracted field. */
4022 mask = build_int_cst_type (unsigned_type, -1);
4023 mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
4024 mask = const_binop (RSHIFT_EXPR, mask,
4025 size_int (nbitsize - lbitsize - lbitpos), 0);
4028 /* If not comparing with constant, just rework the comparison
4030 return fold_build2 (code, compare_type,
4031 fold_build2 (BIT_AND_EXPR, unsigned_type,
4032 make_bit_field_ref (linner,
4037 fold_build2 (BIT_AND_EXPR, unsigned_type,
4038 make_bit_field_ref (rinner,
4044 /* Otherwise, we are handling the constant case. See if the constant is too
4045 big for the field. Warn and return a tree of for 0 (false) if so. We do
4046 this not only for its own sake, but to avoid having to test for this
4047 error case below. If we didn't, we might generate wrong code.
4049 For unsigned fields, the constant shifted right by the field length should
4050 be all zero. For signed fields, the high-order bits should agree with
4055 if (! integer_zerop (const_binop (RSHIFT_EXPR,
4056 fold_convert (unsigned_type, rhs),
4057 size_int (lbitsize), 0)))
4059 warning (0, "comparison is always %d due to width of bit-field",
4061 return constant_boolean_node (code == NE_EXPR, compare_type);
4066 tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
4067 size_int (lbitsize - 1), 0);
4068 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
4070 warning (0, "comparison is always %d due to width of bit-field",
4072 return constant_boolean_node (code == NE_EXPR, compare_type);
4076 /* Single-bit compares should always be against zero. */
4077 if (lbitsize == 1 && ! integer_zerop (rhs))
4079 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
4080 rhs = build_int_cst (type, 0);
4083 /* Make a new bitfield reference, shift the constant over the
4084 appropriate number of bits and mask it with the computed mask
4085 (in case this was a signed field). If we changed it, make a new one. */
4086 lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
4089 TREE_SIDE_EFFECTS (lhs) = 1;
4090 TREE_THIS_VOLATILE (lhs) = 1;
4093 rhs = const_binop (BIT_AND_EXPR,
4094 const_binop (LSHIFT_EXPR,
4095 fold_convert (unsigned_type, rhs),
4096 size_int (lbitpos), 0),
4099 return build2 (code, compare_type,
4100 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
4104 /* Subroutine for fold_truthop: decode a field reference.
4106 If EXP is a comparison reference, we return the innermost reference.
4108 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4109 set to the starting bit number.
4111 If the innermost field can be completely contained in a mode-sized
4112 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4114 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4115 otherwise it is not changed.
4117 *PUNSIGNEDP is set to the signedness of the field.
4119 *PMASK is set to the mask used. This is either contained in a
4120 BIT_AND_EXPR or derived from the width of the field.
4122 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4124 Return 0 if this is not a component reference or is one that we can't
4125 do anything with. */
4128 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
4129 HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
4130 int *punsignedp, int *pvolatilep,
4131 tree *pmask, tree *pand_mask)
4133 tree outer_type = 0;
4135 tree mask, inner, offset;
4137 unsigned int precision;
4139 /* All the optimizations using this function assume integer fields.
4140 There are problems with FP fields since the type_for_size call
4141 below can fail for, e.g., XFmode. */
4142 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
4145 /* We are interested in the bare arrangement of bits, so strip everything
4146 that doesn't affect the machine mode. However, record the type of the
4147 outermost expression if it may matter below. */
4148 if (CONVERT_EXPR_P (exp)
4149 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4150 outer_type = TREE_TYPE (exp);
4153 if (TREE_CODE (exp) == BIT_AND_EXPR)
4155 and_mask = TREE_OPERAND (exp, 1);
4156 exp = TREE_OPERAND (exp, 0);
4157 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
4158 if (TREE_CODE (and_mask) != INTEGER_CST)
4162 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
4163 punsignedp, pvolatilep, false);
4164 if ((inner == exp && and_mask == 0)
4165 || *pbitsize < 0 || offset != 0
4166 || TREE_CODE (inner) == PLACEHOLDER_EXPR)
4169 /* If the number of bits in the reference is the same as the bitsize of
4170 the outer type, then the outer type gives the signedness. Otherwise
4171 (in case of a small bitfield) the signedness is unchanged. */
4172 if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
4173 *punsignedp = TYPE_UNSIGNED (outer_type);
4175 /* Compute the mask to access the bitfield. */
4176 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
4177 precision = TYPE_PRECISION (unsigned_type);
4179 mask = build_int_cst_type (unsigned_type, -1);
4181 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4182 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4184 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4186 mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
4187 fold_convert (unsigned_type, and_mask), mask);
4190 *pand_mask = and_mask;
4194 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4198 all_ones_mask_p (const_tree mask, int size)
4200 tree type = TREE_TYPE (mask);
4201 unsigned int precision = TYPE_PRECISION (type);
4204 tmask = build_int_cst_type (signed_type_for (type), -1);
4207 tree_int_cst_equal (mask,
4208 const_binop (RSHIFT_EXPR,
4209 const_binop (LSHIFT_EXPR, tmask,
4210 size_int (precision - size),
4212 size_int (precision - size), 0));
4215 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4216 represents the sign bit of EXP's type. If EXP represents a sign
4217 or zero extension, also test VAL against the unextended type.
4218 The return value is the (sub)expression whose sign bit is VAL,
4219 or NULL_TREE otherwise. */
4222 sign_bit_p (tree exp, const_tree val)
4224 unsigned HOST_WIDE_INT mask_lo, lo;
4225 HOST_WIDE_INT mask_hi, hi;
4229 /* Tree EXP must have an integral type. */
4230 t = TREE_TYPE (exp);
4231 if (! INTEGRAL_TYPE_P (t))
4234 /* Tree VAL must be an integer constant. */
4235 if (TREE_CODE (val) != INTEGER_CST
4236 || TREE_OVERFLOW (val))
4239 width = TYPE_PRECISION (t);
4240 if (width > HOST_BITS_PER_WIDE_INT)
4242 hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
4245 mask_hi = ((unsigned HOST_WIDE_INT) -1
4246 >> (2 * HOST_BITS_PER_WIDE_INT - width));
4252 lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
4255 mask_lo = ((unsigned HOST_WIDE_INT) -1
4256 >> (HOST_BITS_PER_WIDE_INT - width));
4259 /* We mask off those bits beyond TREE_TYPE (exp) so that we can
4260 treat VAL as if it were unsigned. */
4261 if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
4262 && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
4265 /* Handle extension from a narrower type. */
4266 if (TREE_CODE (exp) == NOP_EXPR
4267 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
4268 return sign_bit_p (TREE_OPERAND (exp, 0), val);
4273 /* Subroutine for fold_truthop: determine if an operand is simple enough
4274 to be evaluated unconditionally. */
4277 simple_operand_p (const_tree exp)
4279 /* Strip any conversions that don't change the machine mode. */
4282 return (CONSTANT_CLASS_P (exp)
4283 || TREE_CODE (exp) == SSA_NAME
4285 && ! TREE_ADDRESSABLE (exp)
4286 && ! TREE_THIS_VOLATILE (exp)
4287 && ! DECL_NONLOCAL (exp)
4288 /* Don't regard global variables as simple. They may be
4289 allocated in ways unknown to the compiler (shared memory,
4290 #pragma weak, etc). */
4291 && ! TREE_PUBLIC (exp)
4292 && ! DECL_EXTERNAL (exp)
4293 /* Loading a static variable is unduly expensive, but global
4294 registers aren't expensive. */
4295 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
4298 /* The following functions are subroutines to fold_range_test and allow it to
4299 try to change a logical combination of comparisons into a range test.
4302 X == 2 || X == 3 || X == 4 || X == 5
4306 (unsigned) (X - 2) <= 3
4308 We describe each set of comparisons as being either inside or outside
4309 a range, using a variable named like IN_P, and then describe the
4310 range with a lower and upper bound. If one of the bounds is omitted,
4311 it represents either the highest or lowest value of the type.
4313 In the comments below, we represent a range by two numbers in brackets
4314 preceded by a "+" to designate being inside that range, or a "-" to
4315 designate being outside that range, so the condition can be inverted by
4316 flipping the prefix. An omitted bound is represented by a "-". For
4317 example, "- [-, 10]" means being outside the range starting at the lowest
4318 possible value and ending at 10, in other words, being greater than 10.
4319 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4322 We set up things so that the missing bounds are handled in a consistent
4323 manner so neither a missing bound nor "true" and "false" need to be
4324 handled using a special case. */
4326 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4327 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4328 and UPPER1_P are nonzero if the respective argument is an upper bound
4329 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4330 must be specified for a comparison. ARG1 will be converted to ARG0's
4331 type if both are specified. */
4334 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4335 tree arg1, int upper1_p)
4341 /* If neither arg represents infinity, do the normal operation.
4342 Else, if not a comparison, return infinity. Else handle the special
4343 comparison rules. Note that most of the cases below won't occur, but
4344 are handled for consistency. */
4346 if (arg0 != 0 && arg1 != 0)
4348 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4349 arg0, fold_convert (TREE_TYPE (arg0), arg1));
4351 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4354 if (TREE_CODE_CLASS (code) != tcc_comparison)
4357 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4358 for neither. In real maths, we cannot assume open ended ranges are
4359 the same. But, this is computer arithmetic, where numbers are finite.
4360 We can therefore make the transformation of any unbounded range with
4361 the value Z, Z being greater than any representable number. This permits
4362 us to treat unbounded ranges as equal. */
4363 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4364 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4368 result = sgn0 == sgn1;
4371 result = sgn0 != sgn1;
4374 result = sgn0 < sgn1;
4377 result = sgn0 <= sgn1;
4380 result = sgn0 > sgn1;
4383 result = sgn0 >= sgn1;
4389 return constant_boolean_node (result, type);
4392 /* Given EXP, a logical expression, set the range it is testing into
4393 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4394 actually being tested. *PLOW and *PHIGH will be made of the same
4395 type as the returned expression. If EXP is not a comparison, we
4396 will most likely not be returning a useful value and range. Set
4397 *STRICT_OVERFLOW_P to true if the return value is only valid
4398 because signed overflow is undefined; otherwise, do not change
4399 *STRICT_OVERFLOW_P. */
4402 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4403 bool *strict_overflow_p)
4405 enum tree_code code;
4406 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4407 tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
4409 tree low, high, n_low, n_high;
4411 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4412 and see if we can refine the range. Some of the cases below may not
4413 happen, but it doesn't seem worth worrying about this. We "continue"
4414 the outer loop when we've changed something; otherwise we "break"
4415 the switch, which will "break" the while. */
4418 low = high = build_int_cst (TREE_TYPE (exp), 0);
4422 code = TREE_CODE (exp);
4423 exp_type = TREE_TYPE (exp);
4425 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4427 if (TREE_OPERAND_LENGTH (exp) > 0)
4428 arg0 = TREE_OPERAND (exp, 0);
4429 if (TREE_CODE_CLASS (code) == tcc_comparison
4430 || TREE_CODE_CLASS (code) == tcc_unary
4431 || TREE_CODE_CLASS (code) == tcc_binary)
4432 arg0_type = TREE_TYPE (arg0);
4433 if (TREE_CODE_CLASS (code) == tcc_binary
4434 || TREE_CODE_CLASS (code) == tcc_comparison
4435 || (TREE_CODE_CLASS (code) == tcc_expression
4436 && TREE_OPERAND_LENGTH (exp) > 1))
4437 arg1 = TREE_OPERAND (exp, 1);
4442 case TRUTH_NOT_EXPR:
4443 in_p = ! in_p, exp = arg0;
4446 case EQ_EXPR: case NE_EXPR:
4447 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
4448 /* We can only do something if the range is testing for zero
4449 and if the second operand is an integer constant. Note that
4450 saying something is "in" the range we make is done by
4451 complementing IN_P since it will set in the initial case of
4452 being not equal to zero; "out" is leaving it alone. */
4453 if (low == 0 || high == 0
4454 || ! integer_zerop (low) || ! integer_zerop (high)
4455 || TREE_CODE (arg1) != INTEGER_CST)
4460 case NE_EXPR: /* - [c, c] */
4463 case EQ_EXPR: /* + [c, c] */
4464 in_p = ! in_p, low = high = arg1;
4466 case GT_EXPR: /* - [-, c] */
4467 low = 0, high = arg1;
4469 case GE_EXPR: /* + [c, -] */
4470 in_p = ! in_p, low = arg1, high = 0;
4472 case LT_EXPR: /* - [c, -] */
4473 low = arg1, high = 0;
4475 case LE_EXPR: /* + [-, c] */
4476 in_p = ! in_p, low = 0, high = arg1;
4482 /* If this is an unsigned comparison, we also know that EXP is
4483 greater than or equal to zero. We base the range tests we make
4484 on that fact, so we record it here so we can parse existing
4485 range tests. We test arg0_type since often the return type
4486 of, e.g. EQ_EXPR, is boolean. */
4487 if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4489 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4491 build_int_cst (arg0_type, 0),
4495 in_p = n_in_p, low = n_low, high = n_high;
4497 /* If the high bound is missing, but we have a nonzero low
4498 bound, reverse the range so it goes from zero to the low bound
4500 if (high == 0 && low && ! integer_zerop (low))
4503 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4504 integer_one_node, 0);
4505 low = build_int_cst (arg0_type, 0);
4513 /* (-x) IN [a,b] -> x in [-b, -a] */
4514 n_low = range_binop (MINUS_EXPR, exp_type,
4515 build_int_cst (exp_type, 0),
4517 n_high = range_binop (MINUS_EXPR, exp_type,
4518 build_int_cst (exp_type, 0),
4520 low = n_low, high = n_high;
4526 exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
4527 build_int_cst (exp_type, 1));
4530 case PLUS_EXPR: case MINUS_EXPR:
4531 if (TREE_CODE (arg1) != INTEGER_CST)
4534 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4535 move a constant to the other side. */
4536 if (!TYPE_UNSIGNED (arg0_type)
4537 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4540 /* If EXP is signed, any overflow in the computation is undefined,
4541 so we don't worry about it so long as our computations on
4542 the bounds don't overflow. For unsigned, overflow is defined
4543 and this is exactly the right thing. */
4544 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4545 arg0_type, low, 0, arg1, 0);
4546 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4547 arg0_type, high, 1, arg1, 0);
4548 if ((n_low != 0 && TREE_OVERFLOW (n_low))
4549 || (n_high != 0 && TREE_OVERFLOW (n_high)))
4552 if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4553 *strict_overflow_p = true;
4555 /* Check for an unsigned range which has wrapped around the maximum
4556 value thus making n_high < n_low, and normalize it. */
4557 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4559 low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4560 integer_one_node, 0);
4561 high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4562 integer_one_node, 0);
4564 /* If the range is of the form +/- [ x+1, x ], we won't
4565 be able to normalize it. But then, it represents the
4566 whole range or the empty set, so make it
4568 if (tree_int_cst_equal (n_low, low)
4569 && tree_int_cst_equal (n_high, high))
4575 low = n_low, high = n_high;
4580 CASE_CONVERT: case NON_LVALUE_EXPR:
4581 if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4584 if (! INTEGRAL_TYPE_P (arg0_type)
4585 || (low != 0 && ! int_fits_type_p (low, arg0_type))
4586 || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4589 n_low = low, n_high = high;
4592 n_low = fold_convert (arg0_type, n_low);
4595 n_high = fold_convert (arg0_type, n_high);
4598 /* If we're converting arg0 from an unsigned type, to exp,
4599 a signed type, we will be doing the comparison as unsigned.
4600 The tests above have already verified that LOW and HIGH
4603 So we have to ensure that we will handle large unsigned
4604 values the same way that the current signed bounds treat
4607 if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4611 /* For fixed-point modes, we need to pass the saturating flag
4612 as the 2nd parameter. */
4613 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4614 equiv_type = lang_hooks.types.type_for_mode
4615 (TYPE_MODE (arg0_type),
4616 TYPE_SATURATING (arg0_type));
4618 equiv_type = lang_hooks.types.type_for_mode
4619 (TYPE_MODE (arg0_type), 1);
4621 /* A range without an upper bound is, naturally, unbounded.
4622 Since convert would have cropped a very large value, use
4623 the max value for the destination type. */
4625 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4626 : TYPE_MAX_VALUE (arg0_type);
4628 if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4629 high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
4630 fold_convert (arg0_type,
4632 build_int_cst (arg0_type, 1));
4634 /* If the low bound is specified, "and" the range with the
4635 range for which the original unsigned value will be
4639 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4640 1, n_low, n_high, 1,
4641 fold_convert (arg0_type,
4646 in_p = (n_in_p == in_p);
4650 /* Otherwise, "or" the range with the range of the input
4651 that will be interpreted as negative. */
4652 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4653 0, n_low, n_high, 1,
4654 fold_convert (arg0_type,
4659 in_p = (in_p != n_in_p);
4664 low = n_low, high = n_high;
4674 /* If EXP is a constant, we can evaluate whether this is true or false. */
4675 if (TREE_CODE (exp) == INTEGER_CST)
4677 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4679 && integer_onep (range_binop (LE_EXPR, integer_type_node,
4685 *pin_p = in_p, *plow = low, *phigh = high;
4689 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4690 type, TYPE, return an expression to test if EXP is in (or out of, depending
4691 on IN_P) the range. Return 0 if the test couldn't be created. */
4694 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
4696 tree etype = TREE_TYPE (exp), value;
4697 enum tree_code code;
4699 #ifdef HAVE_canonicalize_funcptr_for_compare
4700 /* Disable this optimization for function pointer expressions
4701 on targets that require function pointer canonicalization. */
4702 if (HAVE_canonicalize_funcptr_for_compare
4703 && TREE_CODE (etype) == POINTER_TYPE
4704 && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4710 value = build_range_check (type, exp, 1, low, high);
4712 return invert_truthvalue (value);
4717 if (low == 0 && high == 0)
4718 return build_int_cst (type, 1);
4721 return fold_build2 (LE_EXPR, type, exp,
4722 fold_convert (etype, high));
4725 return fold_build2 (GE_EXPR, type, exp,
4726 fold_convert (etype, low));
4728 if (operand_equal_p (low, high, 0))
4729 return fold_build2 (EQ_EXPR, type, exp,
4730 fold_convert (etype, low));
4732 if (integer_zerop (low))
4734 if (! TYPE_UNSIGNED (etype))
4736 etype = unsigned_type_for (etype);
4737 high = fold_convert (etype, high);
4738 exp = fold_convert (etype, exp);
4740 return build_range_check (type, exp, 1, 0, high);
4743 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4744 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4746 unsigned HOST_WIDE_INT lo;
4750 prec = TYPE_PRECISION (etype);
4751 if (prec <= HOST_BITS_PER_WIDE_INT)
4754 lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4758 hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4759 lo = (unsigned HOST_WIDE_INT) -1;
4762 if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4764 if (TYPE_UNSIGNED (etype))
4766 tree signed_etype = signed_type_for (etype);
4767 if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4769 = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4771 etype = signed_etype;
4772 exp = fold_convert (etype, exp);
4774 return fold_build2 (GT_EXPR, type, exp,
4775 build_int_cst (etype, 0));
4779 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4780 This requires wrap-around arithmetics for the type of the expression. */
4781 code = TREE_CODE (etype);
4787 /* There is no requirement that LOW be within the range of ETYPE
4788 if the latter is a subtype. It must, however, be within the base
4789 type of ETYPE. So be sure we do the subtraction in that type. */
4790 if (code == INTEGER_TYPE && TREE_TYPE (etype))
4792 etype = TREE_TYPE (etype);
4793 /* But not in an enumeral or boolean type though. */
4794 code = TREE_CODE (etype);
4797 if (code != INTEGER_TYPE)
4798 etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4799 TYPE_UNSIGNED (etype));
4806 /* If we don't have wrap-around arithmetics upfront, try to force it. */
4807 if (TREE_CODE (etype) == INTEGER_TYPE
4808 && !TYPE_OVERFLOW_WRAPS (etype))
4810 tree utype, minv, maxv;
4812 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4813 for the type in question, as we rely on this here. */
4814 utype = unsigned_type_for (etype);
4815 maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
4816 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4817 integer_one_node, 1);
4818 minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
4820 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4827 high = fold_convert (etype, high);
4828 low = fold_convert (etype, low);
4829 exp = fold_convert (etype, exp);
4831 value = const_binop (MINUS_EXPR, high, low, 0);
4834 if (POINTER_TYPE_P (etype))
4836 if (value != 0 && !TREE_OVERFLOW (value))
4838 low = fold_convert (sizetype, low);
4839 low = fold_build1 (NEGATE_EXPR, sizetype, low);
4840 return build_range_check (type,
4841 fold_build2 (POINTER_PLUS_EXPR, etype, exp, low),
4842 1, build_int_cst (etype, 0), value);
4847 if (value != 0 && !TREE_OVERFLOW (value))
4848 return build_range_check (type,
4849 fold_build2 (MINUS_EXPR, etype, exp, low),
4850 1, build_int_cst (etype, 0), value);
4855 /* Return the predecessor of VAL in its type, handling the infinite case. */
4858 range_predecessor (tree val)
4860 tree type = TREE_TYPE (val);
4862 if (INTEGRAL_TYPE_P (type)
4863 && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4866 return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4869 /* Return the successor of VAL in its type, handling the infinite case. */
4872 range_successor (tree val)
4874 tree type = TREE_TYPE (val);
4876 if (INTEGRAL_TYPE_P (type)
4877 && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4880 return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4883 /* Given two ranges, see if we can merge them into one. Return 1 if we
4884 can, 0 if we can't. Set the output range into the specified parameters. */
4887 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4888 tree high0, int in1_p, tree low1, tree high1)
4896 int lowequal = ((low0 == 0 && low1 == 0)
4897 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4898 low0, 0, low1, 0)));
4899 int highequal = ((high0 == 0 && high1 == 0)
4900 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4901 high0, 1, high1, 1)));
4903 /* Make range 0 be the range that starts first, or ends last if they
4904 start at the same value. Swap them if it isn't. */
4905 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4908 && integer_onep (range_binop (GT_EXPR, integer_type_node,
4909 high1, 1, high0, 1))))
4911 temp = in0_p, in0_p = in1_p, in1_p = temp;
4912 tem = low0, low0 = low1, low1 = tem;
4913 tem = high0, high0 = high1, high1 = tem;
4916 /* Now flag two cases, whether the ranges are disjoint or whether the
4917 second range is totally subsumed in the first. Note that the tests
4918 below are simplified by the ones above. */
4919 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4920 high0, 1, low1, 0));
4921 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4922 high1, 1, high0, 1));
4924 /* We now have four cases, depending on whether we are including or
4925 excluding the two ranges. */
4928 /* If they don't overlap, the result is false. If the second range
4929 is a subset it is the result. Otherwise, the range is from the start
4930 of the second to the end of the first. */
4932 in_p = 0, low = high = 0;
4934 in_p = 1, low = low1, high = high1;
4936 in_p = 1, low = low1, high = high0;
4939 else if (in0_p && ! in1_p)
4941 /* If they don't overlap, the result is the first range. If they are
4942 equal, the result is false. If the second range is a subset of the
4943 first, and the ranges begin at the same place, we go from just after
4944 the end of the second range to the end of the first. If the second
4945 range is not a subset of the first, or if it is a subset and both
4946 ranges end at the same place, the range starts at the start of the
4947 first range and ends just before the second range.
4948 Otherwise, we can't describe this as a single range. */
4950 in_p = 1, low = low0, high = high0;
4951 else if (lowequal && highequal)
4952 in_p = 0, low = high = 0;
4953 else if (subset && lowequal)
4955 low = range_successor (high1);
4960 /* We are in the weird situation where high0 > high1 but
4961 high1 has no successor. Punt. */
4965 else if (! subset || highequal)
4968 high = range_predecessor (low1);
4972 /* low0 < low1 but low1 has no predecessor. Punt. */
4980 else if (! in0_p && in1_p)
4982 /* If they don't overlap, the result is the second range. If the second
4983 is a subset of the first, the result is false. Otherwise,
4984 the range starts just after the first range and ends at the
4985 end of the second. */
4987 in_p = 1, low = low1, high = high1;
4988 else if (subset || highequal)
4989 in_p = 0, low = high = 0;
4992 low = range_successor (high0);
4997 /* high1 > high0 but high0 has no successor. Punt. */
5005 /* The case where we are excluding both ranges. Here the complex case
5006 is if they don't overlap. In that case, the only time we have a
5007 range is if they are adjacent. If the second is a subset of the
5008 first, the result is the first. Otherwise, the range to exclude
5009 starts at the beginning of the first range and ends at the end of the
5013 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
5014 range_successor (high0),
5016 in_p = 0, low = low0, high = high1;
5019 /* Canonicalize - [min, x] into - [-, x]. */
5020 if (low0 && TREE_CODE (low0) == INTEGER_CST)
5021 switch (TREE_CODE (TREE_TYPE (low0)))
5024 if (TYPE_PRECISION (TREE_TYPE (low0))
5025 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
5029 if (tree_int_cst_equal (low0,
5030 TYPE_MIN_VALUE (TREE_TYPE (low0))))
5034 if (TYPE_UNSIGNED (TREE_TYPE (low0))
5035 && integer_zerop (low0))
5042 /* Canonicalize - [x, max] into - [x, -]. */
5043 if (high1 && TREE_CODE (high1) == INTEGER_CST)
5044 switch (TREE_CODE (TREE_TYPE (high1)))
5047 if (TYPE_PRECISION (TREE_TYPE (high1))
5048 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
5052 if (tree_int_cst_equal (high1,
5053 TYPE_MAX_VALUE (TREE_TYPE (high1))))
5057 if (TYPE_UNSIGNED (TREE_TYPE (high1))
5058 && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
5060 integer_one_node, 1)))
5067 /* The ranges might be also adjacent between the maximum and
5068 minimum values of the given type. For
5069 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5070 return + [x + 1, y - 1]. */
5071 if (low0 == 0 && high1 == 0)
5073 low = range_successor (high0);
5074 high = range_predecessor (low1);
5075 if (low == 0 || high == 0)
5085 in_p = 0, low = low0, high = high0;
5087 in_p = 0, low = low0, high = high1;
5090 *pin_p = in_p, *plow = low, *phigh = high;
5095 /* Subroutine of fold, looking inside expressions of the form
5096 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5097 of the COND_EXPR. This function is being used also to optimize
5098 A op B ? C : A, by reversing the comparison first.
5100 Return a folded expression whose code is not a COND_EXPR
5101 anymore, or NULL_TREE if no folding opportunity is found. */
5104 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
5106 enum tree_code comp_code = TREE_CODE (arg0);
5107 tree arg00 = TREE_OPERAND (arg0, 0);
5108 tree arg01 = TREE_OPERAND (arg0, 1);
5109 tree arg1_type = TREE_TYPE (arg1);
5115 /* If we have A op 0 ? A : -A, consider applying the following
5118 A == 0? A : -A same as -A
5119 A != 0? A : -A same as A
5120 A >= 0? A : -A same as abs (A)
5121 A > 0? A : -A same as abs (A)
5122 A <= 0? A : -A same as -abs (A)
5123 A < 0? A : -A same as -abs (A)
5125 None of these transformations work for modes with signed
5126 zeros. If A is +/-0, the first two transformations will
5127 change the sign of the result (from +0 to -0, or vice
5128 versa). The last four will fix the sign of the result,
5129 even though the original expressions could be positive or
5130 negative, depending on the sign of A.
5132 Note that all these transformations are correct if A is
5133 NaN, since the two alternatives (A and -A) are also NaNs. */
5134 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5135 && (FLOAT_TYPE_P (TREE_TYPE (arg01))
5136 ? real_zerop (arg01)
5137 : integer_zerop (arg01))
5138 && ((TREE_CODE (arg2) == NEGATE_EXPR
5139 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5140 /* In the case that A is of the form X-Y, '-A' (arg2) may
5141 have already been folded to Y-X, check for that. */
5142 || (TREE_CODE (arg1) == MINUS_EXPR
5143 && TREE_CODE (arg2) == MINUS_EXPR
5144 && operand_equal_p (TREE_OPERAND (arg1, 0),
5145 TREE_OPERAND (arg2, 1), 0)
5146 && operand_equal_p (TREE_OPERAND (arg1, 1),
5147 TREE_OPERAND (arg2, 0), 0))))
5152 tem = fold_convert (arg1_type, arg1);
5153 return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
5156 return pedantic_non_lvalue (fold_convert (type, arg1));
5159 if (flag_trapping_math)
5164 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5165 arg1 = fold_convert (signed_type_for
5166 (TREE_TYPE (arg1)), arg1);
5167 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5168 return pedantic_non_lvalue (fold_convert (type, tem));
5171 if (flag_trapping_math)
5175 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5176 arg1 = fold_convert (signed_type_for
5177 (TREE_TYPE (arg1)), arg1);
5178 tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5179 return negate_expr (fold_convert (type, tem));
5181 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5185 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5186 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5187 both transformations are correct when A is NaN: A != 0
5188 is then true, and A == 0 is false. */
5190 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5191 && integer_zerop (arg01) && integer_zerop (arg2))
5193 if (comp_code == NE_EXPR)
5194 return pedantic_non_lvalue (fold_convert (type, arg1));
5195 else if (comp_code == EQ_EXPR)
5196 return build_int_cst (type, 0);
5199 /* Try some transformations of A op B ? A : B.
5201 A == B? A : B same as B
5202 A != B? A : B same as A
5203 A >= B? A : B same as max (A, B)
5204 A > B? A : B same as max (B, A)
5205 A <= B? A : B same as min (A, B)
5206 A < B? A : B same as min (B, A)
5208 As above, these transformations don't work in the presence
5209 of signed zeros. For example, if A and B are zeros of
5210 opposite sign, the first two transformations will change
5211 the sign of the result. In the last four, the original
5212 expressions give different results for (A=+0, B=-0) and
5213 (A=-0, B=+0), but the transformed expressions do not.
5215 The first two transformations are correct if either A or B
5216 is a NaN. In the first transformation, the condition will
5217 be false, and B will indeed be chosen. In the case of the
5218 second transformation, the condition A != B will be true,
5219 and A will be chosen.
5221 The conversions to max() and min() are not correct if B is
5222 a number and A is not. The conditions in the original
5223 expressions will be false, so all four give B. The min()
5224 and max() versions would give a NaN instead. */
5225 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
5226 && operand_equal_for_comparison_p (arg01, arg2, arg00)
5227 /* Avoid these transformations if the COND_EXPR may be used
5228 as an lvalue in the C++ front-end. PR c++/19199. */
5230 || (strcmp (lang_hooks.name, "GNU C++") != 0
5231 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
5232 || ! maybe_lvalue_p (arg1)
5233 || ! maybe_lvalue_p (arg2)))
5235 tree comp_op0 = arg00;
5236 tree comp_op1 = arg01;
5237 tree comp_type = TREE_TYPE (comp_op0);
5239 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5240 if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
5250 return pedantic_non_lvalue (fold_convert (type, arg2));
5252 return pedantic_non_lvalue (fold_convert (type, arg1));
5257 /* In C++ a ?: expression can be an lvalue, so put the
5258 operand which will be used if they are equal first
5259 so that we can convert this back to the
5260 corresponding COND_EXPR. */
5261 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5263 comp_op0 = fold_convert (comp_type, comp_op0);
5264 comp_op1 = fold_convert (comp_type, comp_op1);
5265 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
5266 ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
5267 : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
5268 return pedantic_non_lvalue (fold_convert (type, tem));
5275 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5277 comp_op0 = fold_convert (comp_type, comp_op0);
5278 comp_op1 = fold_convert (comp_type, comp_op1);
5279 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
5280 ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
5281 : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
5282 return pedantic_non_lvalue (fold_convert (type, tem));
5286 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5287 return pedantic_non_lvalue (fold_convert (type, arg2));
5290 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5291 return pedantic_non_lvalue (fold_convert (type, arg1));
5294 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5299 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5300 we might still be able to simplify this. For example,
5301 if C1 is one less or one more than C2, this might have started
5302 out as a MIN or MAX and been transformed by this function.
5303 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5305 if (INTEGRAL_TYPE_P (type)
5306 && TREE_CODE (arg01) == INTEGER_CST
5307 && TREE_CODE (arg2) == INTEGER_CST)
5311 /* We can replace A with C1 in this case. */
5312 arg1 = fold_convert (type, arg01);
5313 return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
5316 /* If C1 is C2 + 1, this is min(A, C2). */
5317 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5319 && operand_equal_p (arg01,
5320 const_binop (PLUS_EXPR, arg2,
5321 build_int_cst (type, 1), 0),
5323 return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5325 fold_convert (type, arg1),
5330 /* If C1 is C2 - 1, this is min(A, C2). */
5331 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5333 && operand_equal_p (arg01,
5334 const_binop (MINUS_EXPR, arg2,
5335 build_int_cst (type, 1), 0),
5337 return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5339 fold_convert (type, arg1),
5344 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5345 MAX_EXPR, to preserve the signedness of the comparison. */
5346 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5348 && operand_equal_p (arg01,
5349 const_binop (MINUS_EXPR, arg2,
5350 build_int_cst (type, 1), 0),
5352 return pedantic_non_lvalue (fold_convert (type,
5353 fold_build2 (MAX_EXPR, TREE_TYPE (arg00),
5355 fold_convert (TREE_TYPE (arg00),
5360 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5361 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5363 && operand_equal_p (arg01,
5364 const_binop (PLUS_EXPR, arg2,
5365 build_int_cst (type, 1), 0),
5367 return pedantic_non_lvalue (fold_convert (type,
5368 fold_build2 (MAX_EXPR, TREE_TYPE (arg00),
5370 fold_convert (TREE_TYPE (arg00),
5384 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5385 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5386 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5390 /* EXP is some logical combination of boolean tests. See if we can
5391 merge it into some range test. Return the new tree if so. */
5394 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
5396 int or_op = (code == TRUTH_ORIF_EXPR
5397 || code == TRUTH_OR_EXPR);
5398 int in0_p, in1_p, in_p;
5399 tree low0, low1, low, high0, high1, high;
5400 bool strict_overflow_p = false;
5401 tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5402 tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5404 const char * const warnmsg = G_("assuming signed overflow does not occur "
5405 "when simplifying range test");
5407 /* If this is an OR operation, invert both sides; we will invert
5408 again at the end. */
5410 in0_p = ! in0_p, in1_p = ! in1_p;
5412 /* If both expressions are the same, if we can merge the ranges, and we
5413 can build the range test, return it or it inverted. If one of the
5414 ranges is always true or always false, consider it to be the same
5415 expression as the other. */
5416 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5417 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5419 && 0 != (tem = (build_range_check (type,
5421 : rhs != 0 ? rhs : integer_zero_node,
5424 if (strict_overflow_p)
5425 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5426 return or_op ? invert_truthvalue (tem) : tem;
5429 /* On machines where the branch cost is expensive, if this is a
5430 short-circuited branch and the underlying object on both sides
5431 is the same, make a non-short-circuit operation. */
5432 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5433 && lhs != 0 && rhs != 0
5434 && (code == TRUTH_ANDIF_EXPR
5435 || code == TRUTH_ORIF_EXPR)
5436 && operand_equal_p (lhs, rhs, 0))
5438 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5439 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5440 which cases we can't do this. */
5441 if (simple_operand_p (lhs))
5442 return build2 (code == TRUTH_ANDIF_EXPR
5443 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5446 else if (lang_hooks.decls.global_bindings_p () == 0
5447 && ! CONTAINS_PLACEHOLDER_P (lhs))
5449 tree common = save_expr (lhs);
5451 if (0 != (lhs = build_range_check (type, common,
5452 or_op ? ! in0_p : in0_p,
5454 && (0 != (rhs = build_range_check (type, common,
5455 or_op ? ! in1_p : in1_p,
5458 if (strict_overflow_p)
5459 fold_overflow_warning (warnmsg,
5460 WARN_STRICT_OVERFLOW_COMPARISON);
5461 return build2 (code == TRUTH_ANDIF_EXPR
5462 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5471 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
5472 bit value. Arrange things so the extra bits will be set to zero if and
5473 only if C is signed-extended to its full width. If MASK is nonzero,
5474 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5477 unextend (tree c, int p, int unsignedp, tree mask)
5479 tree type = TREE_TYPE (c);
5480 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5483 if (p == modesize || unsignedp)
5486 /* We work by getting just the sign bit into the low-order bit, then
5487 into the high-order bit, then sign-extend. We then XOR that value
5489 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
5490 temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
5492 /* We must use a signed type in order to get an arithmetic right shift.
5493 However, we must also avoid introducing accidental overflows, so that
5494 a subsequent call to integer_zerop will work. Hence we must
5495 do the type conversion here. At this point, the constant is either
5496 zero or one, and the conversion to a signed type can never overflow.
5497 We could get an overflow if this conversion is done anywhere else. */
5498 if (TYPE_UNSIGNED (type))
5499 temp = fold_convert (signed_type_for (type), temp);
5501 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
5502 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
5504 temp = const_binop (BIT_AND_EXPR, temp,
5505 fold_convert (TREE_TYPE (c), mask), 0);
5506 /* If necessary, convert the type back to match the type of C. */
5507 if (TYPE_UNSIGNED (type))
5508 temp = fold_convert (type, temp);
5510 return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
5513 /* Find ways of folding logical expressions of LHS and RHS:
5514 Try to merge two comparisons to the same innermost item.
5515 Look for range tests like "ch >= '0' && ch <= '9'".
5516 Look for combinations of simple terms on machines with expensive branches
5517 and evaluate the RHS unconditionally.
5519 For example, if we have p->a == 2 && p->b == 4 and we can make an
5520 object large enough to span both A and B, we can do this with a comparison
5521 against the object ANDed with the a mask.
5523 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5524 operations to do this with one comparison.
5526 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5527 function and the one above.
5529 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5530 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5532 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5535 We return the simplified tree or 0 if no optimization is possible. */
5538 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
5540 /* If this is the "or" of two comparisons, we can do something if
5541 the comparisons are NE_EXPR. If this is the "and", we can do something
5542 if the comparisons are EQ_EXPR. I.e.,
5543 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5545 WANTED_CODE is this operation code. For single bit fields, we can
5546 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5547 comparison for one-bit fields. */
5549 enum tree_code wanted_code;
5550 enum tree_code lcode, rcode;
5551 tree ll_arg, lr_arg, rl_arg, rr_arg;
5552 tree ll_inner, lr_inner, rl_inner, rr_inner;
5553 HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5554 HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5555 HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5556 HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5557 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5558 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5559 enum machine_mode lnmode, rnmode;
5560 tree ll_mask, lr_mask, rl_mask, rr_mask;
5561 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5562 tree l_const, r_const;
5563 tree lntype, rntype, result;
5564 HOST_WIDE_INT first_bit, end_bit;
5566 tree orig_lhs = lhs, orig_rhs = rhs;
5567 enum tree_code orig_code = code;
5569 /* Start by getting the comparison codes. Fail if anything is volatile.
5570 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5571 it were surrounded with a NE_EXPR. */
5573 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5576 lcode = TREE_CODE (lhs);
5577 rcode = TREE_CODE (rhs);
5579 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5581 lhs = build2 (NE_EXPR, truth_type, lhs,
5582 build_int_cst (TREE_TYPE (lhs), 0));
5586 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5588 rhs = build2 (NE_EXPR, truth_type, rhs,
5589 build_int_cst (TREE_TYPE (rhs), 0));
5593 if (TREE_CODE_CLASS (lcode) != tcc_comparison
5594 || TREE_CODE_CLASS (rcode) != tcc_comparison)
5597 ll_arg = TREE_OPERAND (lhs, 0);
5598 lr_arg = TREE_OPERAND (lhs, 1);
5599 rl_arg = TREE_OPERAND (rhs, 0);
5600 rr_arg = TREE_OPERAND (rhs, 1);
5602 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5603 if (simple_operand_p (ll_arg)
5604 && simple_operand_p (lr_arg))
5607 if (operand_equal_p (ll_arg, rl_arg, 0)
5608 && operand_equal_p (lr_arg, rr_arg, 0))
5610 result = combine_comparisons (code, lcode, rcode,
5611 truth_type, ll_arg, lr_arg);
5615 else if (operand_equal_p (ll_arg, rr_arg, 0)
5616 && operand_equal_p (lr_arg, rl_arg, 0))
5618 result = combine_comparisons (code, lcode,
5619 swap_tree_comparison (rcode),
5620 truth_type, ll_arg, lr_arg);
5626 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5627 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5629 /* If the RHS can be evaluated unconditionally and its operands are
5630 simple, it wins to evaluate the RHS unconditionally on machines
5631 with expensive branches. In this case, this isn't a comparison
5632 that can be merged. Avoid doing this if the RHS is a floating-point
5633 comparison since those can trap. */
5635 if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5637 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5638 && simple_operand_p (rl_arg)
5639 && simple_operand_p (rr_arg))
5641 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5642 if (code == TRUTH_OR_EXPR
5643 && lcode == NE_EXPR && integer_zerop (lr_arg)
5644 && rcode == NE_EXPR && integer_zerop (rr_arg)
5645 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5646 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5647 return build2 (NE_EXPR, truth_type,
5648 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5650 build_int_cst (TREE_TYPE (ll_arg), 0));
5652 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5653 if (code == TRUTH_AND_EXPR
5654 && lcode == EQ_EXPR && integer_zerop (lr_arg)
5655 && rcode == EQ_EXPR && integer_zerop (rr_arg)
5656 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5657 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5658 return build2 (EQ_EXPR, truth_type,
5659 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5661 build_int_cst (TREE_TYPE (ll_arg), 0));
5663 if (LOGICAL_OP_NON_SHORT_CIRCUIT)
5665 if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
5666 return build2 (code, truth_type, lhs, rhs);
5671 /* See if the comparisons can be merged. Then get all the parameters for
5674 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5675 || (rcode != EQ_EXPR && rcode != NE_EXPR))
5679 ll_inner = decode_field_reference (ll_arg,
5680 &ll_bitsize, &ll_bitpos, &ll_mode,
5681 &ll_unsignedp, &volatilep, &ll_mask,
5683 lr_inner = decode_field_reference (lr_arg,
5684 &lr_bitsize, &lr_bitpos, &lr_mode,
5685 &lr_unsignedp, &volatilep, &lr_mask,
5687 rl_inner = decode_field_reference (rl_arg,
5688 &rl_bitsize, &rl_bitpos, &rl_mode,
5689 &rl_unsignedp, &volatilep, &rl_mask,
5691 rr_inner = decode_field_reference (rr_arg,
5692 &rr_bitsize, &rr_bitpos, &rr_mode,
5693 &rr_unsignedp, &volatilep, &rr_mask,
5696 /* It must be true that the inner operation on the lhs of each
5697 comparison must be the same if we are to be able to do anything.
5698 Then see if we have constants. If not, the same must be true for
5700 if (volatilep || ll_inner == 0 || rl_inner == 0
5701 || ! operand_equal_p (ll_inner, rl_inner, 0))
5704 if (TREE_CODE (lr_arg) == INTEGER_CST
5705 && TREE_CODE (rr_arg) == INTEGER_CST)
5706 l_const = lr_arg, r_const = rr_arg;
5707 else if (lr_inner == 0 || rr_inner == 0
5708 || ! operand_equal_p (lr_inner, rr_inner, 0))
5711 l_const = r_const = 0;
5713 /* If either comparison code is not correct for our logical operation,
5714 fail. However, we can convert a one-bit comparison against zero into
5715 the opposite comparison against that bit being set in the field. */
5717 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5718 if (lcode != wanted_code)
5720 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5722 /* Make the left operand unsigned, since we are only interested
5723 in the value of one bit. Otherwise we are doing the wrong
5732 /* This is analogous to the code for l_const above. */
5733 if (rcode != wanted_code)
5735 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5744 /* See if we can find a mode that contains both fields being compared on
5745 the left. If we can't, fail. Otherwise, update all constants and masks
5746 to be relative to a field of that size. */
5747 first_bit = MIN (ll_bitpos, rl_bitpos);
5748 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5749 lnmode = get_best_mode (end_bit - first_bit, first_bit,
5750 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5752 if (lnmode == VOIDmode)
5755 lnbitsize = GET_MODE_BITSIZE (lnmode);
5756 lnbitpos = first_bit & ~ (lnbitsize - 1);
5757 lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5758 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5760 if (BYTES_BIG_ENDIAN)
5762 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5763 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5766 ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
5767 size_int (xll_bitpos), 0);
5768 rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
5769 size_int (xrl_bitpos), 0);
5773 l_const = fold_convert (lntype, l_const);
5774 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5775 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
5776 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5777 fold_build1 (BIT_NOT_EXPR,
5781 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5783 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5788 r_const = fold_convert (lntype, r_const);
5789 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5790 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
5791 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5792 fold_build1 (BIT_NOT_EXPR,
5796 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5798 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5802 /* If the right sides are not constant, do the same for it. Also,
5803 disallow this optimization if a size or signedness mismatch occurs
5804 between the left and right sides. */
5807 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5808 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5809 /* Make sure the two fields on the right
5810 correspond to the left without being swapped. */
5811 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5814 first_bit = MIN (lr_bitpos, rr_bitpos);
5815 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5816 rnmode = get_best_mode (end_bit - first_bit, first_bit,
5817 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5819 if (rnmode == VOIDmode)
5822 rnbitsize = GET_MODE_BITSIZE (rnmode);
5823 rnbitpos = first_bit & ~ (rnbitsize - 1);
5824 rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5825 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5827 if (BYTES_BIG_ENDIAN)
5829 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5830 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5833 lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
5834 size_int (xlr_bitpos), 0);
5835 rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
5836 size_int (xrr_bitpos), 0);
5838 /* Make a mask that corresponds to both fields being compared.
5839 Do this for both items being compared. If the operands are the
5840 same size and the bits being compared are in the same position
5841 then we can do this by masking both and comparing the masked
5843 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5844 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
5845 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5847 lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5848 ll_unsignedp || rl_unsignedp);
5849 if (! all_ones_mask_p (ll_mask, lnbitsize))
5850 lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5852 rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
5853 lr_unsignedp || rr_unsignedp);
5854 if (! all_ones_mask_p (lr_mask, rnbitsize))
5855 rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5857 return build2 (wanted_code, truth_type, lhs, rhs);
5860 /* There is still another way we can do something: If both pairs of
5861 fields being compared are adjacent, we may be able to make a wider
5862 field containing them both.
5864 Note that we still must mask the lhs/rhs expressions. Furthermore,
5865 the mask must be shifted to account for the shift done by
5866 make_bit_field_ref. */
5867 if ((ll_bitsize + ll_bitpos == rl_bitpos
5868 && lr_bitsize + lr_bitpos == rr_bitpos)
5869 || (ll_bitpos == rl_bitpos + rl_bitsize
5870 && lr_bitpos == rr_bitpos + rr_bitsize))
5874 lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
5875 MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5876 rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
5877 MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5879 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5880 size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
5881 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5882 size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
5884 /* Convert to the smaller type before masking out unwanted bits. */
5886 if (lntype != rntype)
5888 if (lnbitsize > rnbitsize)
5890 lhs = fold_convert (rntype, lhs);
5891 ll_mask = fold_convert (rntype, ll_mask);
5894 else if (lnbitsize < rnbitsize)
5896 rhs = fold_convert (lntype, rhs);
5897 lr_mask = fold_convert (lntype, lr_mask);
5902 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5903 lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5905 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5906 rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5908 return build2 (wanted_code, truth_type, lhs, rhs);
5914 /* Handle the case of comparisons with constants. If there is something in
5915 common between the masks, those bits of the constants must be the same.
5916 If not, the condition is always false. Test for this to avoid generating
5917 incorrect code below. */
5918 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
5919 if (! integer_zerop (result)
5920 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
5921 const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
5923 if (wanted_code == NE_EXPR)
5925 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5926 return constant_boolean_node (true, truth_type);
5930 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5931 return constant_boolean_node (false, truth_type);
5935 /* Construct the expression we will return. First get the component
5936 reference we will make. Unless the mask is all ones the width of
5937 that field, perform the mask operation. Then compare with the
5939 result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5940 ll_unsignedp || rl_unsignedp);
5942 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5943 if (! all_ones_mask_p (ll_mask, lnbitsize))
5944 result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
5946 return build2 (wanted_code, truth_type, result,
5947 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
5950 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5954 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5957 enum tree_code op_code;
5960 int consts_equal, consts_lt;
5963 STRIP_SIGN_NOPS (arg0);
5965 op_code = TREE_CODE (arg0);
5966 minmax_const = TREE_OPERAND (arg0, 1);
5967 comp_const = fold_convert (TREE_TYPE (arg0), op1);
5968 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5969 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5970 inner = TREE_OPERAND (arg0, 0);
5972 /* If something does not permit us to optimize, return the original tree. */
5973 if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5974 || TREE_CODE (comp_const) != INTEGER_CST
5975 || TREE_OVERFLOW (comp_const)
5976 || TREE_CODE (minmax_const) != INTEGER_CST
5977 || TREE_OVERFLOW (minmax_const))
5980 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5981 and GT_EXPR, doing the rest with recursive calls using logical
5985 case NE_EXPR: case LT_EXPR: case LE_EXPR:
5987 tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5990 return invert_truthvalue (tem);
5996 fold_build2 (TRUTH_ORIF_EXPR, type,
5997 optimize_minmax_comparison
5998 (EQ_EXPR, type, arg0, comp_const),
5999 optimize_minmax_comparison
6000 (GT_EXPR, type, arg0, comp_const));
6003 if (op_code == MAX_EXPR && consts_equal)
6004 /* MAX (X, 0) == 0 -> X <= 0 */
6005 return fold_build2 (LE_EXPR, type, inner, comp_const);
6007 else if (op_code == MAX_EXPR && consts_lt)
6008 /* MAX (X, 0) == 5 -> X == 5 */
6009 return fold_build2 (EQ_EXPR, type, inner, comp_const);
6011 else if (op_code == MAX_EXPR)
6012 /* MAX (X, 0) == -1 -> false */
6013 return omit_one_operand (type, integer_zero_node, inner);
6015 else if (consts_equal)
6016 /* MIN (X, 0) == 0 -> X >= 0 */
6017 return fold_build2 (GE_EXPR, type, inner, comp_const);
6020 /* MIN (X, 0) == 5 -> false */
6021 return omit_one_operand (type, integer_zero_node, inner);
6024 /* MIN (X, 0) == -1 -> X == -1 */
6025 return fold_build2 (EQ_EXPR, type, inner, comp_const);
6028 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
6029 /* MAX (X, 0) > 0 -> X > 0
6030 MAX (X, 0) > 5 -> X > 5 */
6031 return fold_build2 (GT_EXPR, type, inner, comp_const);
6033 else if (op_code == MAX_EXPR)
6034 /* MAX (X, 0) > -1 -> true */
6035 return omit_one_operand (type, integer_one_node, inner);
6037 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
6038 /* MIN (X, 0) > 0 -> false
6039 MIN (X, 0) > 5 -> false */
6040 return omit_one_operand (type, integer_zero_node, inner);
6043 /* MIN (X, 0) > -1 -> X > -1 */
6044 return fold_build2 (GT_EXPR, type, inner, comp_const);
6051 /* T is an integer expression that is being multiplied, divided, or taken a
6052 modulus (CODE says which and what kind of divide or modulus) by a
6053 constant C. See if we can eliminate that operation by folding it with
6054 other operations already in T. WIDE_TYPE, if non-null, is a type that
6055 should be used for the computation if wider than our type.
6057 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6058 (X * 2) + (Y * 4). We must, however, be assured that either the original
6059 expression would not overflow or that overflow is undefined for the type
6060 in the language in question.
6062 If we return a non-null expression, it is an equivalent form of the
6063 original computation, but need not be in the original type.
6065 We set *STRICT_OVERFLOW_P to true if the return values depends on
6066 signed overflow being undefined. Otherwise we do not change
6067 *STRICT_OVERFLOW_P. */
6070 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
6071 bool *strict_overflow_p)
6073 /* To avoid exponential search depth, refuse to allow recursion past
6074 three levels. Beyond that (1) it's highly unlikely that we'll find
6075 something interesting and (2) we've probably processed it before
6076 when we built the inner expression. */
6085 ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
6092 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
6093 bool *strict_overflow_p)
6095 tree type = TREE_TYPE (t);
6096 enum tree_code tcode = TREE_CODE (t);
6097 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
6098 > GET_MODE_SIZE (TYPE_MODE (type)))
6099 ? wide_type : type);
6101 int same_p = tcode == code;
6102 tree op0 = NULL_TREE, op1 = NULL_TREE;
6103 bool sub_strict_overflow_p;
6105 /* Don't deal with constants of zero here; they confuse the code below. */
6106 if (integer_zerop (c))
6109 if (TREE_CODE_CLASS (tcode) == tcc_unary)
6110 op0 = TREE_OPERAND (t, 0);
6112 if (TREE_CODE_CLASS (tcode) == tcc_binary)
6113 op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
6115 /* Note that we need not handle conditional operations here since fold
6116 already handles those cases. So just do arithmetic here. */
6120 /* For a constant, we can always simplify if we are a multiply
6121 or (for divide and modulus) if it is a multiple of our constant. */
6122 if (code == MULT_EXPR
6123 || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
6124 return const_binop (code, fold_convert (ctype, t),
6125 fold_convert (ctype, c), 0);
6128 CASE_CONVERT: case NON_LVALUE_EXPR:
6129 /* If op0 is an expression ... */
6130 if ((COMPARISON_CLASS_P (op0)
6131 || UNARY_CLASS_P (op0)
6132 || BINARY_CLASS_P (op0)
6133 || VL_EXP_CLASS_P (op0)
6134 || EXPRESSION_CLASS_P (op0))
6135 /* ... and has wrapping overflow, and its type is smaller
6136 than ctype, then we cannot pass through as widening. */
6137 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
6138 && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
6139 && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
6140 && (TYPE_PRECISION (ctype)
6141 > TYPE_PRECISION (TREE_TYPE (op0))))
6142 /* ... or this is a truncation (t is narrower than op0),
6143 then we cannot pass through this narrowing. */
6144 || (TYPE_PRECISION (type)
6145 < TYPE_PRECISION (TREE_TYPE (op0)))
6146 /* ... or signedness changes for division or modulus,
6147 then we cannot pass through this conversion. */
6148 || (code != MULT_EXPR
6149 && (TYPE_UNSIGNED (ctype)
6150 != TYPE_UNSIGNED (TREE_TYPE (op0))))
6151 /* ... or has undefined overflow while the converted to
6152 type has not, we cannot do the operation in the inner type
6153 as that would introduce undefined overflow. */
6154 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
6155 && !TYPE_OVERFLOW_UNDEFINED (type))))
6158 /* Pass the constant down and see if we can make a simplification. If
6159 we can, replace this expression with the inner simplification for
6160 possible later conversion to our or some other type. */
6161 if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
6162 && TREE_CODE (t2) == INTEGER_CST
6163 && !TREE_OVERFLOW (t2)
6164 && (0 != (t1 = extract_muldiv (op0, t2, code,
6166 ? ctype : NULL_TREE,
6167 strict_overflow_p))))
6172 /* If widening the type changes it from signed to unsigned, then we
6173 must avoid building ABS_EXPR itself as unsigned. */
6174 if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
6176 tree cstype = (*signed_type_for) (ctype);
6177 if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
6180 t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
6181 return fold_convert (ctype, t1);
6185 /* If the constant is negative, we cannot simplify this. */
6186 if (tree_int_cst_sgn (c) == -1)
6190 if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
6192 return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
6195 case MIN_EXPR: case MAX_EXPR:
6196 /* If widening the type changes the signedness, then we can't perform
6197 this optimization as that changes the result. */
6198 if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
6201 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6202 sub_strict_overflow_p = false;
6203 if ((t1 = extract_muldiv (op0, c, code, wide_type,
6204 &sub_strict_overflow_p)) != 0
6205 && (t2 = extract_muldiv (op1, c, code, wide_type,
6206 &sub_strict_overflow_p)) != 0)
6208 if (tree_int_cst_sgn (c) < 0)
6209 tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
6210 if (sub_strict_overflow_p)
6211 *strict_overflow_p = true;
6212 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6213 fold_convert (ctype, t2));
6217 case LSHIFT_EXPR: case RSHIFT_EXPR:
6218 /* If the second operand is constant, this is a multiplication
6219 or floor division, by a power of two, so we can treat it that
6220 way unless the multiplier or divisor overflows. Signed
6221 left-shift overflow is implementation-defined rather than
6222 undefined in C90, so do not convert signed left shift into
6224 if (TREE_CODE (op1) == INTEGER_CST
6225 && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
6226 /* const_binop may not detect overflow correctly,
6227 so check for it explicitly here. */
6228 && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
6229 && TREE_INT_CST_HIGH (op1) == 0
6230 && 0 != (t1 = fold_convert (ctype,
6231 const_binop (LSHIFT_EXPR,
6234 && !TREE_OVERFLOW (t1))
6235 return extract_muldiv (build2 (tcode == LSHIFT_EXPR
6236 ? MULT_EXPR : FLOOR_DIV_EXPR,
6237 ctype, fold_convert (ctype, op0), t1),
6238 c, code, wide_type, strict_overflow_p);
6241 case PLUS_EXPR: case MINUS_EXPR:
6242 /* See if we can eliminate the operation on both sides. If we can, we
6243 can return a new PLUS or MINUS. If we can't, the only remaining
6244 cases where we can do anything are if the second operand is a
6246 sub_strict_overflow_p = false;
6247 t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
6248 t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
6249 if (t1 != 0 && t2 != 0
6250 && (code == MULT_EXPR
6251 /* If not multiplication, we can only do this if both operands
6252 are divisible by c. */
6253 || (multiple_of_p (ctype, op0, c)
6254 && multiple_of_p (ctype, op1, c))))
6256 if (sub_strict_overflow_p)
6257 *strict_overflow_p = true;
6258 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6259 fold_convert (ctype, t2));
6262 /* If this was a subtraction, negate OP1 and set it to be an addition.
6263 This simplifies the logic below. */
6264 if (tcode == MINUS_EXPR)
6265 tcode = PLUS_EXPR, op1 = negate_expr (op1);
6267 if (TREE_CODE (op1) != INTEGER_CST)
6270 /* If either OP1 or C are negative, this optimization is not safe for
6271 some of the division and remainder types while for others we need
6272 to change the code. */
6273 if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
6275 if (code == CEIL_DIV_EXPR)
6276 code = FLOOR_DIV_EXPR;
6277 else if (code == FLOOR_DIV_EXPR)
6278 code = CEIL_DIV_EXPR;
6279 else if (code != MULT_EXPR
6280 && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
6284 /* If it's a multiply or a division/modulus operation of a multiple
6285 of our constant, do the operation and verify it doesn't overflow. */
6286 if (code == MULT_EXPR
6287 || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6289 op1 = const_binop (code, fold_convert (ctype, op1),
6290 fold_convert (ctype, c), 0);
6291 /* We allow the constant to overflow with wrapping semantics. */
6293 || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
6299 /* If we have an unsigned type is not a sizetype, we cannot widen
6300 the operation since it will change the result if the original
6301 computation overflowed. */
6302 if (TYPE_UNSIGNED (ctype)
6303 && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
6307 /* If we were able to eliminate our operation from the first side,
6308 apply our operation to the second side and reform the PLUS. */
6309 if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
6310 return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
6312 /* The last case is if we are a multiply. In that case, we can
6313 apply the distributive law to commute the multiply and addition
6314 if the multiplication of the constants doesn't overflow. */
6315 if (code == MULT_EXPR)
6316 return fold_build2 (tcode, ctype,
6317 fold_build2 (code, ctype,
6318 fold_convert (ctype, op0),
6319 fold_convert (ctype, c)),
6325 /* We have a special case here if we are doing something like
6326 (C * 8) % 4 since we know that's zero. */
6327 if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6328 || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6329 /* If the multiplication can overflow we cannot optimize this.
6330 ??? Until we can properly mark individual operations as
6331 not overflowing we need to treat sizetype special here as
6332 stor-layout relies on this opimization to make
6333 DECL_FIELD_BIT_OFFSET always a constant. */
6334 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
6335 || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6336 && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
6337 && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6338 && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6340 *strict_overflow_p = true;
6341 return omit_one_operand (type, integer_zero_node, op0);
6344 /* ... fall through ... */
6346 case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
6347 case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
6348 /* If we can extract our operation from the LHS, do so and return a
6349 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6350 do something only if the second operand is a constant. */
6352 && (t1 = extract_muldiv (op0, c, code, wide_type,
6353 strict_overflow_p)) != 0)
6354 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6355 fold_convert (ctype, op1));
6356 else if (tcode == MULT_EXPR && code == MULT_EXPR
6357 && (t1 = extract_muldiv (op1, c, code, wide_type,
6358 strict_overflow_p)) != 0)
6359 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6360 fold_convert (ctype, t1));
6361 else if (TREE_CODE (op1) != INTEGER_CST)
6364 /* If these are the same operation types, we can associate them
6365 assuming no overflow. */
6367 && 0 != (t1 = int_const_binop (MULT_EXPR, fold_convert (ctype, op1),
6368 fold_convert (ctype, c), 1))
6369 && 0 != (t1 = force_fit_type_double (ctype, TREE_INT_CST_LOW (t1),
6370 TREE_INT_CST_HIGH (t1),
6371 (TYPE_UNSIGNED (ctype)
6372 && tcode != MULT_EXPR) ? -1 : 1,
6373 TREE_OVERFLOW (t1)))
6374 && !TREE_OVERFLOW (t1))
6375 return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
6377 /* If these operations "cancel" each other, we have the main
6378 optimizations of this pass, which occur when either constant is a
6379 multiple of the other, in which case we replace this with either an
6380 operation or CODE or TCODE.
6382 If we have an unsigned type that is not a sizetype, we cannot do
6383 this since it will change the result if the original computation
6385 if ((TYPE_OVERFLOW_UNDEFINED (ctype)
6386 || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
6387 && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6388 || (tcode == MULT_EXPR
6389 && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6390 && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6391 && code != MULT_EXPR)))
6393 if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6395 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6396 *strict_overflow_p = true;
6397 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6398 fold_convert (ctype,
6399 const_binop (TRUNC_DIV_EXPR,
6402 else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
6404 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6405 *strict_overflow_p = true;
6406 return fold_build2 (code, ctype, fold_convert (ctype, op0),
6407 fold_convert (ctype,
6408 const_binop (TRUNC_DIV_EXPR,
6421 /* Return a node which has the indicated constant VALUE (either 0 or
6422 1), and is of the indicated TYPE. */
6425 constant_boolean_node (int value, tree type)
6427 if (type == integer_type_node)
6428 return value ? integer_one_node : integer_zero_node;
6429 else if (type == boolean_type_node)
6430 return value ? boolean_true_node : boolean_false_node;
6432 return build_int_cst (type, value);
6436 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6437 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6438 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6439 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6440 COND is the first argument to CODE; otherwise (as in the example
6441 given here), it is the second argument. TYPE is the type of the
6442 original expression. Return NULL_TREE if no simplification is
6446 fold_binary_op_with_conditional_arg (enum tree_code code,
6447 tree type, tree op0, tree op1,
6448 tree cond, tree arg, int cond_first_p)
6450 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6451 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6452 tree test, true_value, false_value;
6453 tree lhs = NULL_TREE;
6454 tree rhs = NULL_TREE;
6456 /* This transformation is only worthwhile if we don't have to wrap
6457 arg in a SAVE_EXPR, and the operation can be simplified on at least
6458 one of the branches once its pushed inside the COND_EXPR. */
6459 if (!TREE_CONSTANT (arg))
6462 if (TREE_CODE (cond) == COND_EXPR)
6464 test = TREE_OPERAND (cond, 0);
6465 true_value = TREE_OPERAND (cond, 1);
6466 false_value = TREE_OPERAND (cond, 2);
6467 /* If this operand throws an expression, then it does not make
6468 sense to try to perform a logical or arithmetic operation
6470 if (VOID_TYPE_P (TREE_TYPE (true_value)))
6472 if (VOID_TYPE_P (TREE_TYPE (false_value)))
6477 tree testtype = TREE_TYPE (cond);
6479 true_value = constant_boolean_node (true, testtype);
6480 false_value = constant_boolean_node (false, testtype);
6483 arg = fold_convert (arg_type, arg);
6486 true_value = fold_convert (cond_type, true_value);
6488 lhs = fold_build2 (code, type, true_value, arg);
6490 lhs = fold_build2 (code, type, arg, true_value);
6494 false_value = fold_convert (cond_type, false_value);
6496 rhs = fold_build2 (code, type, false_value, arg);
6498 rhs = fold_build2 (code, type, arg, false_value);
6501 test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
6502 return fold_convert (type, test);
6506 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6508 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6509 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6510 ADDEND is the same as X.
6512 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6513 and finite. The problematic cases are when X is zero, and its mode
6514 has signed zeros. In the case of rounding towards -infinity,
6515 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6516 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6519 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6521 if (!real_zerop (addend))
6524 /* Don't allow the fold with -fsignaling-nans. */
6525 if (HONOR_SNANS (TYPE_MODE (type)))
6528 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6529 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6532 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6533 if (TREE_CODE (addend) == REAL_CST
6534 && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6537 /* The mode has signed zeros, and we have to honor their sign.
6538 In this situation, there is only one case we can return true for.
6539 X - 0 is the same as X unless rounding towards -infinity is
6541 return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6544 /* Subroutine of fold() that checks comparisons of built-in math
6545 functions against real constants.
6547 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6548 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6549 is the type of the result and ARG0 and ARG1 are the operands of the
6550 comparison. ARG1 must be a TREE_REAL_CST.
6552 The function returns the constant folded tree if a simplification
6553 can be made, and NULL_TREE otherwise. */
6556 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
6557 tree type, tree arg0, tree arg1)
6561 if (BUILTIN_SQRT_P (fcode))
6563 tree arg = CALL_EXPR_ARG (arg0, 0);
6564 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6566 c = TREE_REAL_CST (arg1);
6567 if (REAL_VALUE_NEGATIVE (c))
6569 /* sqrt(x) < y is always false, if y is negative. */
6570 if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6571 return omit_one_operand (type, integer_zero_node, arg);
6573 /* sqrt(x) > y is always true, if y is negative and we
6574 don't care about NaNs, i.e. negative values of x. */
6575 if (code == NE_EXPR || !HONOR_NANS (mode))
6576 return omit_one_operand (type, integer_one_node, arg);
6578 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6579 return fold_build2 (GE_EXPR, type, arg,
6580 build_real (TREE_TYPE (arg), dconst0));
6582 else if (code == GT_EXPR || code == GE_EXPR)
6586 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6587 real_convert (&c2, mode, &c2);
6589 if (REAL_VALUE_ISINF (c2))
6591 /* sqrt(x) > y is x == +Inf, when y is very large. */
6592 if (HONOR_INFINITIES (mode))
6593 return fold_build2 (EQ_EXPR, type, arg,
6594 build_real (TREE_TYPE (arg), c2));
6596 /* sqrt(x) > y is always false, when y is very large
6597 and we don't care about infinities. */
6598 return omit_one_operand (type, integer_zero_node, arg);
6601 /* sqrt(x) > c is the same as x > c*c. */
6602 return fold_build2 (code, type, arg,
6603 build_real (TREE_TYPE (arg), c2));
6605 else if (code == LT_EXPR || code == LE_EXPR)
6609 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6610 real_convert (&c2, mode, &c2);
6612 if (REAL_VALUE_ISINF (c2))
6614 /* sqrt(x) < y is always true, when y is a very large
6615 value and we don't care about NaNs or Infinities. */
6616 if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6617 return omit_one_operand (type, integer_one_node, arg);
6619 /* sqrt(x) < y is x != +Inf when y is very large and we
6620 don't care about NaNs. */
6621 if (! HONOR_NANS (mode))
6622 return fold_build2 (NE_EXPR, type, arg,
6623 build_real (TREE_TYPE (arg), c2));
6625 /* sqrt(x) < y is x >= 0 when y is very large and we
6626 don't care about Infinities. */
6627 if (! HONOR_INFINITIES (mode))
6628 return fold_build2 (GE_EXPR, type, arg,
6629 build_real (TREE_TYPE (arg), dconst0));
6631 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6632 if (lang_hooks.decls.global_bindings_p () != 0
6633 || CONTAINS_PLACEHOLDER_P (arg))
6636 arg = save_expr (arg);
6637 return fold_build2 (TRUTH_ANDIF_EXPR, type,
6638 fold_build2 (GE_EXPR, type, arg,
6639 build_real (TREE_TYPE (arg),
6641 fold_build2 (NE_EXPR, type, arg,
6642 build_real (TREE_TYPE (arg),
6646 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6647 if (! HONOR_NANS (mode))
6648 return fold_build2 (code, type, arg,
6649 build_real (TREE_TYPE (arg), c2));
6651 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6652 if (lang_hooks.decls.global_bindings_p () == 0
6653 && ! CONTAINS_PLACEHOLDER_P (arg))
6655 arg = save_expr (arg);
6656 return fold_build2 (TRUTH_ANDIF_EXPR, type,
6657 fold_build2 (GE_EXPR, type, arg,
6658 build_real (TREE_TYPE (arg),
6660 fold_build2 (code, type, arg,
6661 build_real (TREE_TYPE (arg),
6670 /* Subroutine of fold() that optimizes comparisons against Infinities,
6671 either +Inf or -Inf.
6673 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6674 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6675 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6677 The function returns the constant folded tree if a simplification
6678 can be made, and NULL_TREE otherwise. */
6681 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6683 enum machine_mode mode;
6684 REAL_VALUE_TYPE max;
6688 mode = TYPE_MODE (TREE_TYPE (arg0));
6690 /* For negative infinity swap the sense of the comparison. */
6691 neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6693 code = swap_tree_comparison (code);
6698 /* x > +Inf is always false, if with ignore sNANs. */
6699 if (HONOR_SNANS (mode))
6701 return omit_one_operand (type, integer_zero_node, arg0);
6704 /* x <= +Inf is always true, if we don't case about NaNs. */
6705 if (! HONOR_NANS (mode))
6706 return omit_one_operand (type, integer_one_node, arg0);
6708 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6709 if (lang_hooks.decls.global_bindings_p () == 0
6710 && ! CONTAINS_PLACEHOLDER_P (arg0))
6712 arg0 = save_expr (arg0);
6713 return fold_build2 (EQ_EXPR, type, arg0, arg0);
6719 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6720 real_maxval (&max, neg, mode);
6721 return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6722 arg0, build_real (TREE_TYPE (arg0), max));
6725 /* x < +Inf is always equal to x <= DBL_MAX. */
6726 real_maxval (&max, neg, mode);
6727 return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6728 arg0, build_real (TREE_TYPE (arg0), max));
6731 /* x != +Inf is always equal to !(x > DBL_MAX). */
6732 real_maxval (&max, neg, mode);
6733 if (! HONOR_NANS (mode))
6734 return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6735 arg0, build_real (TREE_TYPE (arg0), max));
6737 temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6738 arg0, build_real (TREE_TYPE (arg0), max));
6739 return fold_build1 (TRUTH_NOT_EXPR, type, temp);
6748 /* Subroutine of fold() that optimizes comparisons of a division by
6749 a nonzero integer constant against an integer constant, i.e.
6752 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6753 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6754 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6756 The function returns the constant folded tree if a simplification
6757 can be made, and NULL_TREE otherwise. */
6760 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6762 tree prod, tmp, hi, lo;
6763 tree arg00 = TREE_OPERAND (arg0, 0);
6764 tree arg01 = TREE_OPERAND (arg0, 1);
6765 unsigned HOST_WIDE_INT lpart;
6766 HOST_WIDE_INT hpart;
6767 bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6771 /* We have to do this the hard way to detect unsigned overflow.
6772 prod = int_const_binop (MULT_EXPR, arg01, arg1, 0); */
6773 overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6774 TREE_INT_CST_HIGH (arg01),
6775 TREE_INT_CST_LOW (arg1),
6776 TREE_INT_CST_HIGH (arg1),
6777 &lpart, &hpart, unsigned_p);
6778 prod = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6780 neg_overflow = false;
6784 tmp = int_const_binop (MINUS_EXPR, arg01,
6785 build_int_cst (TREE_TYPE (arg01), 1), 0);
6788 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0). */
6789 overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6790 TREE_INT_CST_HIGH (prod),
6791 TREE_INT_CST_LOW (tmp),
6792 TREE_INT_CST_HIGH (tmp),
6793 &lpart, &hpart, unsigned_p);
6794 hi = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6795 -1, overflow | TREE_OVERFLOW (prod));
6797 else if (tree_int_cst_sgn (arg01) >= 0)
6799 tmp = int_const_binop (MINUS_EXPR, arg01,
6800 build_int_cst (TREE_TYPE (arg01), 1), 0);
6801 switch (tree_int_cst_sgn (arg1))
6804 neg_overflow = true;
6805 lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6810 lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6815 hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6825 /* A negative divisor reverses the relational operators. */
6826 code = swap_tree_comparison (code);
6828 tmp = int_const_binop (PLUS_EXPR, arg01,
6829 build_int_cst (TREE_TYPE (arg01), 1), 0);
6830 switch (tree_int_cst_sgn (arg1))
6833 hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6838 hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6843 neg_overflow = true;
6844 lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6856 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6857 return omit_one_operand (type, integer_zero_node, arg00);
6858 if (TREE_OVERFLOW (hi))
6859 return fold_build2 (GE_EXPR, type, arg00, lo);
6860 if (TREE_OVERFLOW (lo))
6861 return fold_build2 (LE_EXPR, type, arg00, hi);
6862 return build_range_check (type, arg00, 1, lo, hi);
6865 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6866 return omit_one_operand (type, integer_one_node, arg00);
6867 if (TREE_OVERFLOW (hi))
6868 return fold_build2 (LT_EXPR, type, arg00, lo);
6869 if (TREE_OVERFLOW (lo))
6870 return fold_build2 (GT_EXPR, type, arg00, hi);
6871 return build_range_check (type, arg00, 0, lo, hi);
6874 if (TREE_OVERFLOW (lo))
6876 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6877 return omit_one_operand (type, tmp, arg00);
6879 return fold_build2 (LT_EXPR, type, arg00, lo);
6882 if (TREE_OVERFLOW (hi))
6884 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6885 return omit_one_operand (type, tmp, arg00);
6887 return fold_build2 (LE_EXPR, type, arg00, hi);
6890 if (TREE_OVERFLOW (hi))
6892 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6893 return omit_one_operand (type, tmp, arg00);
6895 return fold_build2 (GT_EXPR, type, arg00, hi);
6898 if (TREE_OVERFLOW (lo))
6900 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6901 return omit_one_operand (type, tmp, arg00);
6903 return fold_build2 (GE_EXPR, type, arg00, lo);
6913 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6914 equality/inequality test, then return a simplified form of the test
6915 using a sign testing. Otherwise return NULL. TYPE is the desired
6919 fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
6922 /* If this is testing a single bit, we can optimize the test. */
6923 if ((code == NE_EXPR || code == EQ_EXPR)
6924 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6925 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6927 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6928 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6929 tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6931 if (arg00 != NULL_TREE
6932 /* This is only a win if casting to a signed type is cheap,
6933 i.e. when arg00's type is not a partial mode. */
6934 && TYPE_PRECISION (TREE_TYPE (arg00))
6935 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6937 tree stype = signed_type_for (TREE_TYPE (arg00));
6938 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6939 result_type, fold_convert (stype, arg00),
6940 build_int_cst (stype, 0));
6947 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6948 equality/inequality test, then return a simplified form of
6949 the test using shifts and logical operations. Otherwise return
6950 NULL. TYPE is the desired result type. */
6953 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
6956 /* If this is testing a single bit, we can optimize the test. */
6957 if ((code == NE_EXPR || code == EQ_EXPR)
6958 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6959 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6961 tree inner = TREE_OPERAND (arg0, 0);
6962 tree type = TREE_TYPE (arg0);
6963 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6964 enum machine_mode operand_mode = TYPE_MODE (type);
6966 tree signed_type, unsigned_type, intermediate_type;
6969 /* First, see if we can fold the single bit test into a sign-bit
6971 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6976 /* Otherwise we have (A & C) != 0 where C is a single bit,
6977 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6978 Similarly for (A & C) == 0. */
6980 /* If INNER is a right shift of a constant and it plus BITNUM does
6981 not overflow, adjust BITNUM and INNER. */
6982 if (TREE_CODE (inner) == RSHIFT_EXPR
6983 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6984 && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6985 && bitnum < TYPE_PRECISION (type)
6986 && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6987 bitnum - TYPE_PRECISION (type)))
6989 bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6990 inner = TREE_OPERAND (inner, 0);
6993 /* If we are going to be able to omit the AND below, we must do our
6994 operations as unsigned. If we must use the AND, we have a choice.
6995 Normally unsigned is faster, but for some machines signed is. */
6996 #ifdef LOAD_EXTEND_OP
6997 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6998 && !flag_syntax_only) ? 0 : 1;
7003 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
7004 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
7005 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
7006 inner = fold_convert (intermediate_type, inner);
7009 inner = build2 (RSHIFT_EXPR, intermediate_type,
7010 inner, size_int (bitnum));
7012 one = build_int_cst (intermediate_type, 1);
7014 if (code == EQ_EXPR)
7015 inner = fold_build2 (BIT_XOR_EXPR, intermediate_type, inner, one);
7017 /* Put the AND last so it can combine with more things. */
7018 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
7020 /* Make sure to return the proper type. */
7021 inner = fold_convert (result_type, inner);
7028 /* Check whether we are allowed to reorder operands arg0 and arg1,
7029 such that the evaluation of arg1 occurs before arg0. */
7032 reorder_operands_p (const_tree arg0, const_tree arg1)
7034 if (! flag_evaluation_order)
7036 if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
7038 return ! TREE_SIDE_EFFECTS (arg0)
7039 && ! TREE_SIDE_EFFECTS (arg1);
7042 /* Test whether it is preferable two swap two operands, ARG0 and
7043 ARG1, for example because ARG0 is an integer constant and ARG1
7044 isn't. If REORDER is true, only recommend swapping if we can
7045 evaluate the operands in reverse order. */
7048 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
7050 STRIP_SIGN_NOPS (arg0);
7051 STRIP_SIGN_NOPS (arg1);
7053 if (TREE_CODE (arg1) == INTEGER_CST)
7055 if (TREE_CODE (arg0) == INTEGER_CST)
7058 if (TREE_CODE (arg1) == REAL_CST)
7060 if (TREE_CODE (arg0) == REAL_CST)
7063 if (TREE_CODE (arg1) == FIXED_CST)
7065 if (TREE_CODE (arg0) == FIXED_CST)
7068 if (TREE_CODE (arg1) == COMPLEX_CST)
7070 if (TREE_CODE (arg0) == COMPLEX_CST)
7073 if (TREE_CONSTANT (arg1))
7075 if (TREE_CONSTANT (arg0))
7078 if (optimize_function_for_size_p (cfun))
7081 if (reorder && flag_evaluation_order
7082 && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
7085 /* It is preferable to swap two SSA_NAME to ensure a canonical form
7086 for commutative and comparison operators. Ensuring a canonical
7087 form allows the optimizers to find additional redundancies without
7088 having to explicitly check for both orderings. */
7089 if (TREE_CODE (arg0) == SSA_NAME
7090 && TREE_CODE (arg1) == SSA_NAME
7091 && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
7094 /* Put SSA_NAMEs last. */
7095 if (TREE_CODE (arg1) == SSA_NAME)
7097 if (TREE_CODE (arg0) == SSA_NAME)
7100 /* Put variables last. */
7109 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
7110 ARG0 is extended to a wider type. */
7113 fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
7115 tree arg0_unw = get_unwidened (arg0, NULL_TREE);
7117 tree shorter_type, outer_type;
7121 if (arg0_unw == arg0)
7123 shorter_type = TREE_TYPE (arg0_unw);
7125 #ifdef HAVE_canonicalize_funcptr_for_compare
7126 /* Disable this optimization if we're casting a function pointer
7127 type on targets that require function pointer canonicalization. */
7128 if (HAVE_canonicalize_funcptr_for_compare
7129 && TREE_CODE (shorter_type) == POINTER_TYPE
7130 && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
7134 if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
7137 arg1_unw = get_unwidened (arg1, NULL_TREE);
7139 /* If possible, express the comparison in the shorter mode. */
7140 if ((code == EQ_EXPR || code == NE_EXPR
7141 || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
7142 && (TREE_TYPE (arg1_unw) == shorter_type
7143 || ((TYPE_PRECISION (shorter_type)
7144 >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
7145 && (TYPE_UNSIGNED (shorter_type)
7146 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
7147 || (TREE_CODE (arg1_unw) == INTEGER_CST
7148 && (TREE_CODE (shorter_type) == INTEGER_TYPE
7149 || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
7150 && int_fits_type_p (arg1_unw, shorter_type))))
7151 return fold_build2 (code, type, arg0_unw,
7152 fold_convert (shorter_type, arg1_unw));
7154 if (TREE_CODE (arg1_unw) != INTEGER_CST
7155 || TREE_CODE (shorter_type) != INTEGER_TYPE
7156 || !int_fits_type_p (arg1_unw, shorter_type))
7159 /* If we are comparing with the integer that does not fit into the range
7160 of the shorter type, the result is known. */
7161 outer_type = TREE_TYPE (arg1_unw);
7162 min = lower_bound_in_type (outer_type, shorter_type);
7163 max = upper_bound_in_type (outer_type, shorter_type);
7165 above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7167 below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7174 return omit_one_operand (type, integer_zero_node, arg0);
7179 return omit_one_operand (type, integer_one_node, arg0);
7185 return omit_one_operand (type, integer_one_node, arg0);
7187 return omit_one_operand (type, integer_zero_node, arg0);
7192 return omit_one_operand (type, integer_zero_node, arg0);
7194 return omit_one_operand (type, integer_one_node, arg0);
7203 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
7204 ARG0 just the signedness is changed. */
7207 fold_sign_changed_comparison (enum tree_code code, tree type,
7208 tree arg0, tree arg1)
7211 tree inner_type, outer_type;
7213 if (!CONVERT_EXPR_P (arg0))
7216 outer_type = TREE_TYPE (arg0);
7217 arg0_inner = TREE_OPERAND (arg0, 0);
7218 inner_type = TREE_TYPE (arg0_inner);
7220 #ifdef HAVE_canonicalize_funcptr_for_compare
7221 /* Disable this optimization if we're casting a function pointer
7222 type on targets that require function pointer canonicalization. */
7223 if (HAVE_canonicalize_funcptr_for_compare
7224 && TREE_CODE (inner_type) == POINTER_TYPE
7225 && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
7229 if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
7232 /* If the conversion is from an integral subtype to its basetype
7234 if (TREE_TYPE (inner_type) == outer_type)
7237 if (TREE_CODE (arg1) != INTEGER_CST
7238 && !(CONVERT_EXPR_P (arg1)
7239 && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
7242 if ((TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
7243 || POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
7248 if (TREE_CODE (arg1) == INTEGER_CST)
7249 arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
7250 TREE_INT_CST_HIGH (arg1), 0,
7251 TREE_OVERFLOW (arg1));
7253 arg1 = fold_convert (inner_type, arg1);
7255 return fold_build2 (code, type, arg0_inner, arg1);
7258 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
7259 step of the array. Reconstructs s and delta in the case of s * delta
7260 being an integer constant (and thus already folded).
7261 ADDR is the address. MULT is the multiplicative expression.
7262 If the function succeeds, the new address expression is returned. Otherwise
7263 NULL_TREE is returned. */
7266 try_move_mult_to_index (tree addr, tree op1)
7268 tree s, delta, step;
7269 tree ref = TREE_OPERAND (addr, 0), pref;
7274 /* Strip the nops that might be added when converting op1 to sizetype. */
7277 /* Canonicalize op1 into a possibly non-constant delta
7278 and an INTEGER_CST s. */
7279 if (TREE_CODE (op1) == MULT_EXPR)
7281 tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
7286 if (TREE_CODE (arg0) == INTEGER_CST)
7291 else if (TREE_CODE (arg1) == INTEGER_CST)
7299 else if (TREE_CODE (op1) == INTEGER_CST)
7306 /* Simulate we are delta * 1. */
7308 s = integer_one_node;
7311 for (;; ref = TREE_OPERAND (ref, 0))
7313 if (TREE_CODE (ref) == ARRAY_REF)
7315 /* Remember if this was a multi-dimensional array. */
7316 if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
7319 itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
7323 step = array_ref_element_size (ref);
7324 if (TREE_CODE (step) != INTEGER_CST)
7329 if (! tree_int_cst_equal (step, s))
7334 /* Try if delta is a multiple of step. */
7335 tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
7341 /* Only fold here if we can verify we do not overflow one
7342 dimension of a multi-dimensional array. */
7347 if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
7348 || !INTEGRAL_TYPE_P (itype)
7349 || !TYPE_MAX_VALUE (itype)
7350 || TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST)
7353 tmp = fold_binary (PLUS_EXPR, itype,
7354 fold_convert (itype,
7355 TREE_OPERAND (ref, 1)),
7356 fold_convert (itype, delta));
7358 || TREE_CODE (tmp) != INTEGER_CST
7359 || tree_int_cst_lt (TYPE_MAX_VALUE (itype), tmp))
7368 if (!handled_component_p (ref))
7372 /* We found the suitable array reference. So copy everything up to it,
7373 and replace the index. */
7375 pref = TREE_OPERAND (addr, 0);
7376 ret = copy_node (pref);
7381 pref = TREE_OPERAND (pref, 0);
7382 TREE_OPERAND (pos, 0) = copy_node (pref);
7383 pos = TREE_OPERAND (pos, 0);
7386 TREE_OPERAND (pos, 1) = fold_build2 (PLUS_EXPR, itype,
7387 fold_convert (itype,
7388 TREE_OPERAND (pos, 1)),
7389 fold_convert (itype, delta));
7391 return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
7395 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
7396 means A >= Y && A != MAX, but in this case we know that
7397 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
7400 fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
7402 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
7404 if (TREE_CODE (bound) == LT_EXPR)
7405 a = TREE_OPERAND (bound, 0);
7406 else if (TREE_CODE (bound) == GT_EXPR)
7407 a = TREE_OPERAND (bound, 1);
7411 typea = TREE_TYPE (a);
7412 if (!INTEGRAL_TYPE_P (typea)
7413 && !POINTER_TYPE_P (typea))
7416 if (TREE_CODE (ineq) == LT_EXPR)
7418 a1 = TREE_OPERAND (ineq, 1);
7419 y = TREE_OPERAND (ineq, 0);
7421 else if (TREE_CODE (ineq) == GT_EXPR)
7423 a1 = TREE_OPERAND (ineq, 0);
7424 y = TREE_OPERAND (ineq, 1);
7429 if (TREE_TYPE (a1) != typea)
7432 if (POINTER_TYPE_P (typea))
7434 /* Convert the pointer types into integer before taking the difference. */
7435 tree ta = fold_convert (ssizetype, a);
7436 tree ta1 = fold_convert (ssizetype, a1);
7437 diff = fold_binary (MINUS_EXPR, ssizetype, ta1, ta);
7440 diff = fold_binary (MINUS_EXPR, typea, a1, a);
7442 if (!diff || !integer_onep (diff))
7445 return fold_build2 (GE_EXPR, type, a, y);
7448 /* Fold a sum or difference of at least one multiplication.
7449 Returns the folded tree or NULL if no simplification could be made. */
7452 fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
7454 tree arg00, arg01, arg10, arg11;
7455 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7457 /* (A * C) +- (B * C) -> (A+-B) * C.
7458 (A * C) +- A -> A * (C+-1).
7459 We are most concerned about the case where C is a constant,
7460 but other combinations show up during loop reduction. Since
7461 it is not difficult, try all four possibilities. */
7463 if (TREE_CODE (arg0) == MULT_EXPR)
7465 arg00 = TREE_OPERAND (arg0, 0);
7466 arg01 = TREE_OPERAND (arg0, 1);
7468 else if (TREE_CODE (arg0) == INTEGER_CST)
7470 arg00 = build_one_cst (type);
7475 /* We cannot generate constant 1 for fract. */
7476 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7479 arg01 = build_one_cst (type);
7481 if (TREE_CODE (arg1) == MULT_EXPR)
7483 arg10 = TREE_OPERAND (arg1, 0);
7484 arg11 = TREE_OPERAND (arg1, 1);
7486 else if (TREE_CODE (arg1) == INTEGER_CST)
7488 arg10 = build_one_cst (type);
7489 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7490 the purpose of this canonicalization. */
7491 if (TREE_INT_CST_HIGH (arg1) == -1
7492 && negate_expr_p (arg1)
7493 && code == PLUS_EXPR)
7495 arg11 = negate_expr (arg1);
7503 /* We cannot generate constant 1 for fract. */
7504 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7507 arg11 = build_one_cst (type);
7511 if (operand_equal_p (arg01, arg11, 0))
7512 same = arg01, alt0 = arg00, alt1 = arg10;
7513 else if (operand_equal_p (arg00, arg10, 0))
7514 same = arg00, alt0 = arg01, alt1 = arg11;
7515 else if (operand_equal_p (arg00, arg11, 0))
7516 same = arg00, alt0 = arg01, alt1 = arg10;
7517 else if (operand_equal_p (arg01, arg10, 0))
7518 same = arg01, alt0 = arg00, alt1 = arg11;
7520 /* No identical multiplicands; see if we can find a common
7521 power-of-two factor in non-power-of-two multiplies. This
7522 can help in multi-dimensional array access. */
7523 else if (host_integerp (arg01, 0)
7524 && host_integerp (arg11, 0))
7526 HOST_WIDE_INT int01, int11, tmp;
7529 int01 = TREE_INT_CST_LOW (arg01);
7530 int11 = TREE_INT_CST_LOW (arg11);
7532 /* Move min of absolute values to int11. */
7533 if ((int01 >= 0 ? int01 : -int01)
7534 < (int11 >= 0 ? int11 : -int11))
7536 tmp = int01, int01 = int11, int11 = tmp;
7537 alt0 = arg00, arg00 = arg10, arg10 = alt0;
7544 if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0
7545 /* The remainder should not be a constant, otherwise we
7546 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7547 increased the number of multiplications necessary. */
7548 && TREE_CODE (arg10) != INTEGER_CST)
7550 alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
7551 build_int_cst (TREE_TYPE (arg00),
7556 maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7561 return fold_build2 (MULT_EXPR, type,
7562 fold_build2 (code, type,
7563 fold_convert (type, alt0),
7564 fold_convert (type, alt1)),
7565 fold_convert (type, same));
7570 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7571 specified by EXPR into the buffer PTR of length LEN bytes.
7572 Return the number of bytes placed in the buffer, or zero
7576 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7578 tree type = TREE_TYPE (expr);
7579 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7580 int byte, offset, word, words;
7581 unsigned char value;
7583 if (total_bytes > len)
7585 words = total_bytes / UNITS_PER_WORD;
7587 for (byte = 0; byte < total_bytes; byte++)
7589 int bitpos = byte * BITS_PER_UNIT;
7590 if (bitpos < HOST_BITS_PER_WIDE_INT)
7591 value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7593 value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7594 >> (bitpos - HOST_BITS_PER_WIDE_INT));
7596 if (total_bytes > UNITS_PER_WORD)
7598 word = byte / UNITS_PER_WORD;
7599 if (WORDS_BIG_ENDIAN)
7600 word = (words - 1) - word;
7601 offset = word * UNITS_PER_WORD;
7602 if (BYTES_BIG_ENDIAN)
7603 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7605 offset += byte % UNITS_PER_WORD;
7608 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7609 ptr[offset] = value;
7615 /* Subroutine of native_encode_expr. Encode the REAL_CST
7616 specified by EXPR into the buffer PTR of length LEN bytes.
7617 Return the number of bytes placed in the buffer, or zero
7621 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7623 tree type = TREE_TYPE (expr);
7624 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7625 int byte, offset, word, words, bitpos;
7626 unsigned char value;
7628 /* There are always 32 bits in each long, no matter the size of
7629 the hosts long. We handle floating point representations with
7633 if (total_bytes > len)
7635 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7637 real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7639 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7640 bitpos += BITS_PER_UNIT)
7642 byte = (bitpos / BITS_PER_UNIT) & 3;
7643 value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7645 if (UNITS_PER_WORD < 4)
7647 word = byte / UNITS_PER_WORD;
7648 if (WORDS_BIG_ENDIAN)
7649 word = (words - 1) - word;
7650 offset = word * UNITS_PER_WORD;
7651 if (BYTES_BIG_ENDIAN)
7652 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7654 offset += byte % UNITS_PER_WORD;
7657 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7658 ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7663 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7664 specified by EXPR into the buffer PTR of length LEN bytes.
7665 Return the number of bytes placed in the buffer, or zero
7669 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7674 part = TREE_REALPART (expr);
7675 rsize = native_encode_expr (part, ptr, len);
7678 part = TREE_IMAGPART (expr);
7679 isize = native_encode_expr (part, ptr+rsize, len-rsize);
7682 return rsize + isize;
7686 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7687 specified by EXPR into the buffer PTR of length LEN bytes.
7688 Return the number of bytes placed in the buffer, or zero
7692 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7694 int i, size, offset, count;
7695 tree itype, elem, elements;
7698 elements = TREE_VECTOR_CST_ELTS (expr);
7699 count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7700 itype = TREE_TYPE (TREE_TYPE (expr));
7701 size = GET_MODE_SIZE (TYPE_MODE (itype));
7702 for (i = 0; i < count; i++)
7706 elem = TREE_VALUE (elements);
7707 elements = TREE_CHAIN (elements);
7714 if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7719 if (offset + size > len)
7721 memset (ptr+offset, 0, size);
7729 /* Subroutine of native_encode_expr. Encode the STRING_CST
7730 specified by EXPR into the buffer PTR of length LEN bytes.
7731 Return the number of bytes placed in the buffer, or zero
7735 native_encode_string (const_tree expr, unsigned char *ptr, int len)
7737 tree type = TREE_TYPE (expr);
7738 HOST_WIDE_INT total_bytes;
7740 if (TREE_CODE (type) != ARRAY_TYPE
7741 || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7742 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7743 || !host_integerp (TYPE_SIZE_UNIT (type), 0))
7745 total_bytes = tree_low_cst (TYPE_SIZE_UNIT (type), 0);
7746 if (total_bytes > len)
7748 if (TREE_STRING_LENGTH (expr) < total_bytes)
7750 memcpy (ptr, TREE_STRING_POINTER (expr), TREE_STRING_LENGTH (expr));
7751 memset (ptr + TREE_STRING_LENGTH (expr), 0,
7752 total_bytes - TREE_STRING_LENGTH (expr));
7755 memcpy (ptr, TREE_STRING_POINTER (expr), total_bytes);
7760 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7761 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7762 buffer PTR of length LEN bytes. Return the number of bytes
7763 placed in the buffer, or zero upon failure. */
7766 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7768 switch (TREE_CODE (expr))
7771 return native_encode_int (expr, ptr, len);
7774 return native_encode_real (expr, ptr, len);
7777 return native_encode_complex (expr, ptr, len);
7780 return native_encode_vector (expr, ptr, len);
7783 return native_encode_string (expr, ptr, len);
7791 /* Subroutine of native_interpret_expr. Interpret the contents of
7792 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7793 If the buffer cannot be interpreted, return NULL_TREE. */
7796 native_interpret_int (tree type, const unsigned char *ptr, int len)
7798 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7799 int byte, offset, word, words;
7800 unsigned char value;
7801 unsigned int HOST_WIDE_INT lo = 0;
7802 HOST_WIDE_INT hi = 0;
7804 if (total_bytes > len)
7806 if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7808 words = total_bytes / UNITS_PER_WORD;
7810 for (byte = 0; byte < total_bytes; byte++)
7812 int bitpos = byte * BITS_PER_UNIT;
7813 if (total_bytes > UNITS_PER_WORD)
7815 word = byte / UNITS_PER_WORD;
7816 if (WORDS_BIG_ENDIAN)
7817 word = (words - 1) - word;
7818 offset = word * UNITS_PER_WORD;
7819 if (BYTES_BIG_ENDIAN)
7820 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7822 offset += byte % UNITS_PER_WORD;
7825 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7826 value = ptr[offset];
7828 if (bitpos < HOST_BITS_PER_WIDE_INT)
7829 lo |= (unsigned HOST_WIDE_INT) value << bitpos;
7831 hi |= (unsigned HOST_WIDE_INT) value
7832 << (bitpos - HOST_BITS_PER_WIDE_INT);
7835 return build_int_cst_wide_type (type, lo, hi);
7839 /* Subroutine of native_interpret_expr. Interpret the contents of
7840 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7841 If the buffer cannot be interpreted, return NULL_TREE. */
7844 native_interpret_real (tree type, const unsigned char *ptr, int len)
7846 enum machine_mode mode = TYPE_MODE (type);
7847 int total_bytes = GET_MODE_SIZE (mode);
7848 int byte, offset, word, words, bitpos;
7849 unsigned char value;
7850 /* There are always 32 bits in each long, no matter the size of
7851 the hosts long. We handle floating point representations with
7856 total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7857 if (total_bytes > len || total_bytes > 24)
7859 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7861 memset (tmp, 0, sizeof (tmp));
7862 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7863 bitpos += BITS_PER_UNIT)
7865 byte = (bitpos / BITS_PER_UNIT) & 3;
7866 if (UNITS_PER_WORD < 4)
7868 word = byte / UNITS_PER_WORD;
7869 if (WORDS_BIG_ENDIAN)
7870 word = (words - 1) - word;
7871 offset = word * UNITS_PER_WORD;
7872 if (BYTES_BIG_ENDIAN)
7873 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7875 offset += byte % UNITS_PER_WORD;
7878 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7879 value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7881 tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7884 real_from_target (&r, tmp, mode);
7885 return build_real (type, r);
7889 /* Subroutine of native_interpret_expr. Interpret the contents of
7890 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7891 If the buffer cannot be interpreted, return NULL_TREE. */
7894 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7896 tree etype, rpart, ipart;
7899 etype = TREE_TYPE (type);
7900 size = GET_MODE_SIZE (TYPE_MODE (etype));
7903 rpart = native_interpret_expr (etype, ptr, size);
7906 ipart = native_interpret_expr (etype, ptr+size, size);
7909 return build_complex (type, rpart, ipart);
7913 /* Subroutine of native_interpret_expr. Interpret the contents of
7914 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7915 If the buffer cannot be interpreted, return NULL_TREE. */
7918 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7920 tree etype, elem, elements;
7923 etype = TREE_TYPE (type);
7924 size = GET_MODE_SIZE (TYPE_MODE (etype));
7925 count = TYPE_VECTOR_SUBPARTS (type);
7926 if (size * count > len)
7929 elements = NULL_TREE;
7930 for (i = count - 1; i >= 0; i--)
7932 elem = native_interpret_expr (etype, ptr+(i*size), size);
7935 elements = tree_cons (NULL_TREE, elem, elements);
7937 return build_vector (type, elements);
7941 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7942 the buffer PTR of length LEN as a constant of type TYPE. For
7943 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7944 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7945 return NULL_TREE. */
7948 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7950 switch (TREE_CODE (type))
7955 return native_interpret_int (type, ptr, len);
7958 return native_interpret_real (type, ptr, len);
7961 return native_interpret_complex (type, ptr, len);
7964 return native_interpret_vector (type, ptr, len);
7972 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7973 TYPE at compile-time. If we're unable to perform the conversion
7974 return NULL_TREE. */
7977 fold_view_convert_expr (tree type, tree expr)
7979 /* We support up to 512-bit values (for V8DFmode). */
7980 unsigned char buffer[64];
7983 /* Check that the host and target are sane. */
7984 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7987 len = native_encode_expr (expr, buffer, sizeof (buffer));
7991 return native_interpret_expr (type, buffer, len);
7994 /* Build an expression for the address of T. Folds away INDIRECT_REF
7995 to avoid confusing the gimplify process. */
7998 build_fold_addr_expr_with_type (tree t, tree ptrtype)
8000 /* The size of the object is not relevant when talking about its address. */
8001 if (TREE_CODE (t) == WITH_SIZE_EXPR)
8002 t = TREE_OPERAND (t, 0);
8004 /* Note: doesn't apply to ALIGN_INDIRECT_REF */
8005 if (TREE_CODE (t) == INDIRECT_REF
8006 || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
8008 t = TREE_OPERAND (t, 0);
8010 if (TREE_TYPE (t) != ptrtype)
8011 t = build1 (NOP_EXPR, ptrtype, t);
8014 t = build1 (ADDR_EXPR, ptrtype, t);
8019 /* Build an expression for the address of T. */
8022 build_fold_addr_expr (tree t)
8024 tree ptrtype = build_pointer_type (TREE_TYPE (t));
8026 return build_fold_addr_expr_with_type (t, ptrtype);
8029 /* Fold a unary expression of code CODE and type TYPE with operand
8030 OP0. Return the folded expression if folding is successful.
8031 Otherwise, return NULL_TREE. */
8034 fold_unary (enum tree_code code, tree type, tree op0)
8038 enum tree_code_class kind = TREE_CODE_CLASS (code);
8040 gcc_assert (IS_EXPR_CODE_CLASS (kind)
8041 && TREE_CODE_LENGTH (code) == 1);
8046 if (CONVERT_EXPR_CODE_P (code)
8047 || code == FLOAT_EXPR || code == ABS_EXPR)
8049 /* Don't use STRIP_NOPS, because signedness of argument type
8051 STRIP_SIGN_NOPS (arg0);
8055 /* Strip any conversions that don't change the mode. This
8056 is safe for every expression, except for a comparison
8057 expression because its signedness is derived from its
8060 Note that this is done as an internal manipulation within
8061 the constant folder, in order to find the simplest
8062 representation of the arguments so that their form can be
8063 studied. In any cases, the appropriate type conversions
8064 should be put back in the tree that will get out of the
8070 if (TREE_CODE_CLASS (code) == tcc_unary)
8072 if (TREE_CODE (arg0) == COMPOUND_EXPR)
8073 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
8074 fold_build1 (code, type,
8075 fold_convert (TREE_TYPE (op0),
8076 TREE_OPERAND (arg0, 1))));
8077 else if (TREE_CODE (arg0) == COND_EXPR)
8079 tree arg01 = TREE_OPERAND (arg0, 1);
8080 tree arg02 = TREE_OPERAND (arg0, 2);
8081 if (! VOID_TYPE_P (TREE_TYPE (arg01)))
8082 arg01 = fold_build1 (code, type,
8083 fold_convert (TREE_TYPE (op0), arg01));
8084 if (! VOID_TYPE_P (TREE_TYPE (arg02)))
8085 arg02 = fold_build1 (code, type,
8086 fold_convert (TREE_TYPE (op0), arg02));
8087 tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
8090 /* If this was a conversion, and all we did was to move into
8091 inside the COND_EXPR, bring it back out. But leave it if
8092 it is a conversion from integer to integer and the
8093 result precision is no wider than a word since such a
8094 conversion is cheap and may be optimized away by combine,
8095 while it couldn't if it were outside the COND_EXPR. Then return
8096 so we don't get into an infinite recursion loop taking the
8097 conversion out and then back in. */
8099 if ((CONVERT_EXPR_CODE_P (code)
8100 || code == NON_LVALUE_EXPR)
8101 && TREE_CODE (tem) == COND_EXPR
8102 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
8103 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
8104 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
8105 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
8106 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
8107 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
8108 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8110 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
8111 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
8112 || flag_syntax_only))
8113 tem = build1 (code, type,
8115 TREE_TYPE (TREE_OPERAND
8116 (TREE_OPERAND (tem, 1), 0)),
8117 TREE_OPERAND (tem, 0),
8118 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
8119 TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
8122 else if (COMPARISON_CLASS_P (arg0))
8124 if (TREE_CODE (type) == BOOLEAN_TYPE)
8126 arg0 = copy_node (arg0);
8127 TREE_TYPE (arg0) = type;
8130 else if (TREE_CODE (type) != INTEGER_TYPE)
8131 return fold_build3 (COND_EXPR, type, arg0,
8132 fold_build1 (code, type,
8134 fold_build1 (code, type,
8135 integer_zero_node));
8142 /* Re-association barriers around constants and other re-association
8143 barriers can be removed. */
8144 if (CONSTANT_CLASS_P (op0)
8145 || TREE_CODE (op0) == PAREN_EXPR)
8146 return fold_convert (type, op0);
8151 case FIX_TRUNC_EXPR:
8152 if (TREE_TYPE (op0) == type)
8155 /* If we have (type) (a CMP b) and type is an integral type, return
8156 new expression involving the new type. */
8157 if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
8158 return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
8159 TREE_OPERAND (op0, 1));
8161 /* Handle cases of two conversions in a row. */
8162 if (CONVERT_EXPR_P (op0))
8164 tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
8165 tree inter_type = TREE_TYPE (op0);
8166 int inside_int = INTEGRAL_TYPE_P (inside_type);
8167 int inside_ptr = POINTER_TYPE_P (inside_type);
8168 int inside_float = FLOAT_TYPE_P (inside_type);
8169 int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
8170 unsigned int inside_prec = TYPE_PRECISION (inside_type);
8171 int inside_unsignedp = TYPE_UNSIGNED (inside_type);
8172 int inter_int = INTEGRAL_TYPE_P (inter_type);
8173 int inter_ptr = POINTER_TYPE_P (inter_type);
8174 int inter_float = FLOAT_TYPE_P (inter_type);
8175 int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
8176 unsigned int inter_prec = TYPE_PRECISION (inter_type);
8177 int inter_unsignedp = TYPE_UNSIGNED (inter_type);
8178 int final_int = INTEGRAL_TYPE_P (type);
8179 int final_ptr = POINTER_TYPE_P (type);
8180 int final_float = FLOAT_TYPE_P (type);
8181 int final_vec = TREE_CODE (type) == VECTOR_TYPE;
8182 unsigned int final_prec = TYPE_PRECISION (type);
8183 int final_unsignedp = TYPE_UNSIGNED (type);
8185 /* In addition to the cases of two conversions in a row
8186 handled below, if we are converting something to its own
8187 type via an object of identical or wider precision, neither
8188 conversion is needed. */
8189 if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
8190 && (((inter_int || inter_ptr) && final_int)
8191 || (inter_float && final_float))
8192 && inter_prec >= final_prec)
8193 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8195 /* Likewise, if the intermediate and initial types are either both
8196 float or both integer, we don't need the middle conversion if the
8197 former is wider than the latter and doesn't change the signedness
8198 (for integers). Avoid this if the final type is a pointer since
8199 then we sometimes need the middle conversion. Likewise if the
8200 final type has a precision not equal to the size of its mode. */
8201 if (((inter_int && inside_int)
8202 || (inter_float && inside_float)
8203 || (inter_vec && inside_vec))
8204 && inter_prec >= inside_prec
8205 && (inter_float || inter_vec
8206 || inter_unsignedp == inside_unsignedp)
8207 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8208 && TYPE_MODE (type) == TYPE_MODE (inter_type))
8210 && (! final_vec || inter_prec == inside_prec))
8211 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8213 /* If we have a sign-extension of a zero-extended value, we can
8214 replace that by a single zero-extension. */
8215 if (inside_int && inter_int && final_int
8216 && inside_prec < inter_prec && inter_prec < final_prec
8217 && inside_unsignedp && !inter_unsignedp)
8218 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8220 /* Two conversions in a row are not needed unless:
8221 - some conversion is floating-point (overstrict for now), or
8222 - some conversion is a vector (overstrict for now), or
8223 - the intermediate type is narrower than both initial and
8225 - the intermediate type and innermost type differ in signedness,
8226 and the outermost type is wider than the intermediate, or
8227 - the initial type is a pointer type and the precisions of the
8228 intermediate and final types differ, or
8229 - the final type is a pointer type and the precisions of the
8230 initial and intermediate types differ. */
8231 if (! inside_float && ! inter_float && ! final_float
8232 && ! inside_vec && ! inter_vec && ! final_vec
8233 && (inter_prec >= inside_prec || inter_prec >= final_prec)
8234 && ! (inside_int && inter_int
8235 && inter_unsignedp != inside_unsignedp
8236 && inter_prec < final_prec)
8237 && ((inter_unsignedp && inter_prec > inside_prec)
8238 == (final_unsignedp && final_prec > inter_prec))
8239 && ! (inside_ptr && inter_prec != final_prec)
8240 && ! (final_ptr && inside_prec != inter_prec)
8241 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8242 && TYPE_MODE (type) == TYPE_MODE (inter_type)))
8243 return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8246 /* Handle (T *)&A.B.C for A being of type T and B and C
8247 living at offset zero. This occurs frequently in
8248 C++ upcasting and then accessing the base. */
8249 if (TREE_CODE (op0) == ADDR_EXPR
8250 && POINTER_TYPE_P (type)
8251 && handled_component_p (TREE_OPERAND (op0, 0)))
8253 HOST_WIDE_INT bitsize, bitpos;
8255 enum machine_mode mode;
8256 int unsignedp, volatilep;
8257 tree base = TREE_OPERAND (op0, 0);
8258 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
8259 &mode, &unsignedp, &volatilep, false);
8260 /* If the reference was to a (constant) zero offset, we can use
8261 the address of the base if it has the same base type
8262 as the result type. */
8263 if (! offset && bitpos == 0
8264 && TYPE_MAIN_VARIANT (TREE_TYPE (type))
8265 == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
8266 return fold_convert (type, build_fold_addr_expr (base));
8269 if (TREE_CODE (op0) == MODIFY_EXPR
8270 && TREE_CONSTANT (TREE_OPERAND (op0, 1))
8271 /* Detect assigning a bitfield. */
8272 && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
8274 (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
8276 /* Don't leave an assignment inside a conversion
8277 unless assigning a bitfield. */
8278 tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
8279 /* First do the assignment, then return converted constant. */
8280 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
8281 TREE_NO_WARNING (tem) = 1;
8282 TREE_USED (tem) = 1;
8286 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
8287 constants (if x has signed type, the sign bit cannot be set
8288 in c). This folds extension into the BIT_AND_EXPR.
8289 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
8290 very likely don't have maximal range for their precision and this
8291 transformation effectively doesn't preserve non-maximal ranges. */
8292 if (TREE_CODE (type) == INTEGER_TYPE
8293 && TREE_CODE (op0) == BIT_AND_EXPR
8294 && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST
8295 /* Not if the conversion is to the sub-type. */
8296 && TREE_TYPE (type) != TREE_TYPE (op0))
8299 tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
8302 if (TYPE_UNSIGNED (TREE_TYPE (and))
8303 || (TYPE_PRECISION (type)
8304 <= TYPE_PRECISION (TREE_TYPE (and))))
8306 else if (TYPE_PRECISION (TREE_TYPE (and1))
8307 <= HOST_BITS_PER_WIDE_INT
8308 && host_integerp (and1, 1))
8310 unsigned HOST_WIDE_INT cst;
8312 cst = tree_low_cst (and1, 1);
8313 cst &= (HOST_WIDE_INT) -1
8314 << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
8315 change = (cst == 0);
8316 #ifdef LOAD_EXTEND_OP
8318 && !flag_syntax_only
8319 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
8322 tree uns = unsigned_type_for (TREE_TYPE (and0));
8323 and0 = fold_convert (uns, and0);
8324 and1 = fold_convert (uns, and1);
8330 tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
8331 TREE_INT_CST_HIGH (and1), 0,
8332 TREE_OVERFLOW (and1));
8333 return fold_build2 (BIT_AND_EXPR, type,
8334 fold_convert (type, and0), tem);
8338 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
8339 when one of the new casts will fold away. Conservatively we assume
8340 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
8341 if (POINTER_TYPE_P (type)
8342 && TREE_CODE (arg0) == POINTER_PLUS_EXPR
8343 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8344 || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
8345 || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
8347 tree arg00 = TREE_OPERAND (arg0, 0);
8348 tree arg01 = TREE_OPERAND (arg0, 1);
8350 return fold_build2 (TREE_CODE (arg0), type, fold_convert (type, arg00),
8351 fold_convert (sizetype, arg01));
8354 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
8355 of the same precision, and X is an integer type not narrower than
8356 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
8357 if (INTEGRAL_TYPE_P (type)
8358 && TREE_CODE (op0) == BIT_NOT_EXPR
8359 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8360 && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
8361 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8363 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
8364 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8365 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
8366 return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
8369 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
8370 type of X and Y (integer types only). */
8371 if (INTEGRAL_TYPE_P (type)
8372 && TREE_CODE (op0) == MULT_EXPR
8373 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8374 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
8376 /* Be careful not to introduce new overflows. */
8378 if (TYPE_OVERFLOW_WRAPS (type))
8381 mult_type = unsigned_type_for (type);
8383 if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
8385 tem = fold_build2 (MULT_EXPR, mult_type,
8386 fold_convert (mult_type,
8387 TREE_OPERAND (op0, 0)),
8388 fold_convert (mult_type,
8389 TREE_OPERAND (op0, 1)));
8390 return fold_convert (type, tem);
8394 tem = fold_convert_const (code, type, op0);
8395 return tem ? tem : NULL_TREE;
8397 case FIXED_CONVERT_EXPR:
8398 tem = fold_convert_const (code, type, arg0);
8399 return tem ? tem : NULL_TREE;
8401 case VIEW_CONVERT_EXPR:
8402 if (TREE_TYPE (op0) == type)
8404 if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
8405 return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
8407 /* For integral conversions with the same precision or pointer
8408 conversions use a NOP_EXPR instead. */
8409 if ((INTEGRAL_TYPE_P (type)
8410 || POINTER_TYPE_P (type))
8411 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8412 || POINTER_TYPE_P (TREE_TYPE (op0)))
8413 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0))
8414 /* Do not muck with VIEW_CONVERT_EXPRs that convert from
8415 a sub-type to its base type as generated by the Ada FE. */
8416 && !(INTEGRAL_TYPE_P (TREE_TYPE (op0))
8417 && TREE_TYPE (TREE_TYPE (op0))))
8418 return fold_convert (type, op0);
8420 /* Strip inner integral conversions that do not change the precision. */
8421 if (CONVERT_EXPR_P (op0)
8422 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8423 || POINTER_TYPE_P (TREE_TYPE (op0)))
8424 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
8425 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
8426 && (TYPE_PRECISION (TREE_TYPE (op0))
8427 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
8428 return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
8430 return fold_view_convert_expr (type, op0);
8433 tem = fold_negate_expr (arg0);
8435 return fold_convert (type, tem);
8439 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
8440 return fold_abs_const (arg0, type);
8441 else if (TREE_CODE (arg0) == NEGATE_EXPR)
8442 return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8443 /* Convert fabs((double)float) into (double)fabsf(float). */
8444 else if (TREE_CODE (arg0) == NOP_EXPR
8445 && TREE_CODE (type) == REAL_TYPE)
8447 tree targ0 = strip_float_extensions (arg0);
8449 return fold_convert (type, fold_build1 (ABS_EXPR,
8453 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
8454 else if (TREE_CODE (arg0) == ABS_EXPR)
8456 else if (tree_expr_nonnegative_p (arg0))
8459 /* Strip sign ops from argument. */
8460 if (TREE_CODE (type) == REAL_TYPE)
8462 tem = fold_strip_sign_ops (arg0);
8464 return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
8469 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8470 return fold_convert (type, arg0);
8471 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8473 tree itype = TREE_TYPE (type);
8474 tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
8475 tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
8476 return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
8478 if (TREE_CODE (arg0) == COMPLEX_CST)
8480 tree itype = TREE_TYPE (type);
8481 tree rpart = fold_convert (itype, TREE_REALPART (arg0));
8482 tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
8483 return build_complex (type, rpart, negate_expr (ipart));
8485 if (TREE_CODE (arg0) == CONJ_EXPR)
8486 return fold_convert (type, TREE_OPERAND (arg0, 0));
8490 if (TREE_CODE (arg0) == INTEGER_CST)
8491 return fold_not_const (arg0, type);
8492 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8493 return fold_convert (type, TREE_OPERAND (arg0, 0));
8494 /* Convert ~ (-A) to A - 1. */
8495 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8496 return fold_build2 (MINUS_EXPR, type,
8497 fold_convert (type, TREE_OPERAND (arg0, 0)),
8498 build_int_cst (type, 1));
8499 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8500 else if (INTEGRAL_TYPE_P (type)
8501 && ((TREE_CODE (arg0) == MINUS_EXPR
8502 && integer_onep (TREE_OPERAND (arg0, 1)))
8503 || (TREE_CODE (arg0) == PLUS_EXPR
8504 && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8505 return fold_build1 (NEGATE_EXPR, type,
8506 fold_convert (type, TREE_OPERAND (arg0, 0)));
8507 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8508 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8509 && (tem = fold_unary (BIT_NOT_EXPR, type,
8511 TREE_OPERAND (arg0, 0)))))
8512 return fold_build2 (BIT_XOR_EXPR, type, tem,
8513 fold_convert (type, TREE_OPERAND (arg0, 1)));
8514 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8515 && (tem = fold_unary (BIT_NOT_EXPR, type,
8517 TREE_OPERAND (arg0, 1)))))
8518 return fold_build2 (BIT_XOR_EXPR, type,
8519 fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
8520 /* Perform BIT_NOT_EXPR on each element individually. */
8521 else if (TREE_CODE (arg0) == VECTOR_CST)
8523 tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
8524 int count = TYPE_VECTOR_SUBPARTS (type), i;
8526 for (i = 0; i < count; i++)
8530 elem = TREE_VALUE (elements);
8531 elem = fold_unary (BIT_NOT_EXPR, TREE_TYPE (type), elem);
8532 if (elem == NULL_TREE)
8534 elements = TREE_CHAIN (elements);
8537 elem = build_int_cst (TREE_TYPE (type), -1);
8538 list = tree_cons (NULL_TREE, elem, list);
8541 return build_vector (type, nreverse (list));
8546 case TRUTH_NOT_EXPR:
8547 /* The argument to invert_truthvalue must have Boolean type. */
8548 if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8549 arg0 = fold_convert (boolean_type_node, arg0);
8551 /* Note that the operand of this must be an int
8552 and its values must be 0 or 1.
8553 ("true" is a fixed value perhaps depending on the language,
8554 but we don't handle values other than 1 correctly yet.) */
8555 tem = fold_truth_not_expr (arg0);
8558 return fold_convert (type, tem);
8561 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8562 return fold_convert (type, arg0);
8563 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8564 return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8565 TREE_OPERAND (arg0, 1));
8566 if (TREE_CODE (arg0) == COMPLEX_CST)
8567 return fold_convert (type, TREE_REALPART (arg0));
8568 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8570 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8571 tem = fold_build2 (TREE_CODE (arg0), itype,
8572 fold_build1 (REALPART_EXPR, itype,
8573 TREE_OPERAND (arg0, 0)),
8574 fold_build1 (REALPART_EXPR, itype,
8575 TREE_OPERAND (arg0, 1)));
8576 return fold_convert (type, tem);
8578 if (TREE_CODE (arg0) == CONJ_EXPR)
8580 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8581 tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8582 return fold_convert (type, tem);
8584 if (TREE_CODE (arg0) == CALL_EXPR)
8586 tree fn = get_callee_fndecl (arg0);
8587 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8588 switch (DECL_FUNCTION_CODE (fn))
8590 CASE_FLT_FN (BUILT_IN_CEXPI):
8591 fn = mathfn_built_in (type, BUILT_IN_COS);
8593 return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8603 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8604 return fold_convert (type, integer_zero_node);
8605 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8606 return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8607 TREE_OPERAND (arg0, 0));
8608 if (TREE_CODE (arg0) == COMPLEX_CST)
8609 return fold_convert (type, TREE_IMAGPART (arg0));
8610 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8612 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8613 tem = fold_build2 (TREE_CODE (arg0), itype,
8614 fold_build1 (IMAGPART_EXPR, itype,
8615 TREE_OPERAND (arg0, 0)),
8616 fold_build1 (IMAGPART_EXPR, itype,
8617 TREE_OPERAND (arg0, 1)));
8618 return fold_convert (type, tem);
8620 if (TREE_CODE (arg0) == CONJ_EXPR)
8622 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8623 tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8624 return fold_convert (type, negate_expr (tem));
8626 if (TREE_CODE (arg0) == CALL_EXPR)
8628 tree fn = get_callee_fndecl (arg0);
8629 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8630 switch (DECL_FUNCTION_CODE (fn))
8632 CASE_FLT_FN (BUILT_IN_CEXPI):
8633 fn = mathfn_built_in (type, BUILT_IN_SIN);
8635 return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8646 } /* switch (code) */
8650 /* If the operation was a conversion do _not_ mark a resulting constant
8651 with TREE_OVERFLOW if the original constant was not. These conversions
8652 have implementation defined behavior and retaining the TREE_OVERFLOW
8653 flag here would confuse later passes such as VRP. */
8655 fold_unary_ignore_overflow (enum tree_code code, tree type, tree op0)
8657 tree res = fold_unary (code, type, op0);
8659 && TREE_CODE (res) == INTEGER_CST
8660 && TREE_CODE (op0) == INTEGER_CST
8661 && CONVERT_EXPR_CODE_P (code))
8662 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8667 /* Fold a binary expression of code CODE and type TYPE with operands
8668 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8669 Return the folded expression if folding is successful. Otherwise,
8670 return NULL_TREE. */
8673 fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
8675 enum tree_code compl_code;
8677 if (code == MIN_EXPR)
8678 compl_code = MAX_EXPR;
8679 else if (code == MAX_EXPR)
8680 compl_code = MIN_EXPR;
8684 /* MIN (MAX (a, b), b) == b. */
8685 if (TREE_CODE (op0) == compl_code
8686 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8687 return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
8689 /* MIN (MAX (b, a), b) == b. */
8690 if (TREE_CODE (op0) == compl_code
8691 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8692 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8693 return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
8695 /* MIN (a, MAX (a, b)) == a. */
8696 if (TREE_CODE (op1) == compl_code
8697 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8698 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8699 return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
8701 /* MIN (a, MAX (b, a)) == a. */
8702 if (TREE_CODE (op1) == compl_code
8703 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8704 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8705 return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
8710 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8711 by changing CODE to reduce the magnitude of constants involved in
8712 ARG0 of the comparison.
8713 Returns a canonicalized comparison tree if a simplification was
8714 possible, otherwise returns NULL_TREE.
8715 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8716 valid if signed overflow is undefined. */
8719 maybe_canonicalize_comparison_1 (enum tree_code code, tree type,
8720 tree arg0, tree arg1,
8721 bool *strict_overflow_p)
8723 enum tree_code code0 = TREE_CODE (arg0);
8724 tree t, cst0 = NULL_TREE;
8728 /* Match A +- CST code arg1 and CST code arg1. We can change the
8729 first form only if overflow is undefined. */
8730 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8731 /* In principle pointers also have undefined overflow behavior,
8732 but that causes problems elsewhere. */
8733 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8734 && (code0 == MINUS_EXPR
8735 || code0 == PLUS_EXPR)
8736 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8737 || code0 == INTEGER_CST))
8740 /* Identify the constant in arg0 and its sign. */
8741 if (code0 == INTEGER_CST)
8744 cst0 = TREE_OPERAND (arg0, 1);
8745 sgn0 = tree_int_cst_sgn (cst0);
8747 /* Overflowed constants and zero will cause problems. */
8748 if (integer_zerop (cst0)
8749 || TREE_OVERFLOW (cst0))
8752 /* See if we can reduce the magnitude of the constant in
8753 arg0 by changing the comparison code. */
8754 if (code0 == INTEGER_CST)
8756 /* CST <= arg1 -> CST-1 < arg1. */
8757 if (code == LE_EXPR && sgn0 == 1)
8759 /* -CST < arg1 -> -CST-1 <= arg1. */
8760 else if (code == LT_EXPR && sgn0 == -1)
8762 /* CST > arg1 -> CST-1 >= arg1. */
8763 else if (code == GT_EXPR && sgn0 == 1)
8765 /* -CST >= arg1 -> -CST-1 > arg1. */
8766 else if (code == GE_EXPR && sgn0 == -1)
8770 /* arg1 code' CST' might be more canonical. */
8775 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8777 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8779 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8780 else if (code == GT_EXPR
8781 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8783 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8784 else if (code == LE_EXPR
8785 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8787 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8788 else if (code == GE_EXPR
8789 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8793 *strict_overflow_p = true;
8796 /* Now build the constant reduced in magnitude. But not if that
8797 would produce one outside of its types range. */
8798 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8800 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8801 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8803 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8804 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8805 /* We cannot swap the comparison here as that would cause us to
8806 endlessly recurse. */
8809 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8810 cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
8811 if (code0 != INTEGER_CST)
8812 t = fold_build2 (code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8814 /* If swapping might yield to a more canonical form, do so. */
8816 return fold_build2 (swap_tree_comparison (code), type, arg1, t);
8818 return fold_build2 (code, type, t, arg1);
8821 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8822 overflow further. Try to decrease the magnitude of constants involved
8823 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8824 and put sole constants at the second argument position.
8825 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8828 maybe_canonicalize_comparison (enum tree_code code, tree type,
8829 tree arg0, tree arg1)
8832 bool strict_overflow_p;
8833 const char * const warnmsg = G_("assuming signed overflow does not occur "
8834 "when reducing constant in comparison");
8836 /* Try canonicalization by simplifying arg0. */
8837 strict_overflow_p = false;
8838 t = maybe_canonicalize_comparison_1 (code, type, arg0, arg1,
8839 &strict_overflow_p);
8842 if (strict_overflow_p)
8843 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8847 /* Try canonicalization by simplifying arg1 using the swapped
8849 code = swap_tree_comparison (code);
8850 strict_overflow_p = false;
8851 t = maybe_canonicalize_comparison_1 (code, type, arg1, arg0,
8852 &strict_overflow_p);
8853 if (t && strict_overflow_p)
8854 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8858 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8859 space. This is used to avoid issuing overflow warnings for
8860 expressions like &p->x which can not wrap. */
8863 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8865 unsigned HOST_WIDE_INT offset_low, total_low;
8866 HOST_WIDE_INT size, offset_high, total_high;
8868 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8874 if (offset == NULL_TREE)
8879 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8883 offset_low = TREE_INT_CST_LOW (offset);
8884 offset_high = TREE_INT_CST_HIGH (offset);
8887 if (add_double_with_sign (offset_low, offset_high,
8888 bitpos / BITS_PER_UNIT, 0,
8889 &total_low, &total_high,
8893 if (total_high != 0)
8896 size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8900 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8902 if (TREE_CODE (base) == ADDR_EXPR)
8904 HOST_WIDE_INT base_size;
8906 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8907 if (base_size > 0 && size < base_size)
8911 return total_low > (unsigned HOST_WIDE_INT) size;
8914 /* Subroutine of fold_binary. This routine performs all of the
8915 transformations that are common to the equality/inequality
8916 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8917 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8918 fold_binary should call fold_binary. Fold a comparison with
8919 tree code CODE and type TYPE with operands OP0 and OP1. Return
8920 the folded comparison or NULL_TREE. */
8923 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
8925 tree arg0, arg1, tem;
8930 STRIP_SIGN_NOPS (arg0);
8931 STRIP_SIGN_NOPS (arg1);
8933 tem = fold_relational_const (code, type, arg0, arg1);
8934 if (tem != NULL_TREE)
8937 /* If one arg is a real or integer constant, put it last. */
8938 if (tree_swap_operands_p (arg0, arg1, true))
8939 return fold_build2 (swap_tree_comparison (code), type, op1, op0);
8941 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1. */
8942 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8943 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8944 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8945 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
8946 && (TREE_CODE (arg1) == INTEGER_CST
8947 && !TREE_OVERFLOW (arg1)))
8949 tree const1 = TREE_OPERAND (arg0, 1);
8951 tree variable = TREE_OPERAND (arg0, 0);
8954 lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8956 lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
8957 TREE_TYPE (arg1), const2, const1);
8959 /* If the constant operation overflowed this can be
8960 simplified as a comparison against INT_MAX/INT_MIN. */
8961 if (TREE_CODE (lhs) == INTEGER_CST
8962 && TREE_OVERFLOW (lhs))
8964 int const1_sgn = tree_int_cst_sgn (const1);
8965 enum tree_code code2 = code;
8967 /* Get the sign of the constant on the lhs if the
8968 operation were VARIABLE + CONST1. */
8969 if (TREE_CODE (arg0) == MINUS_EXPR)
8970 const1_sgn = -const1_sgn;
8972 /* The sign of the constant determines if we overflowed
8973 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8974 Canonicalize to the INT_MIN overflow by swapping the comparison
8976 if (const1_sgn == -1)
8977 code2 = swap_tree_comparison (code);
8979 /* We now can look at the canonicalized case
8980 VARIABLE + 1 CODE2 INT_MIN
8981 and decide on the result. */
8982 if (code2 == LT_EXPR
8984 || code2 == EQ_EXPR)
8985 return omit_one_operand (type, boolean_false_node, variable);
8986 else if (code2 == NE_EXPR
8988 || code2 == GT_EXPR)
8989 return omit_one_operand (type, boolean_true_node, variable);
8992 if (TREE_CODE (lhs) == TREE_CODE (arg1)
8993 && (TREE_CODE (lhs) != INTEGER_CST
8994 || !TREE_OVERFLOW (lhs)))
8996 fold_overflow_warning (("assuming signed overflow does not occur "
8997 "when changing X +- C1 cmp C2 to "
8999 WARN_STRICT_OVERFLOW_COMPARISON);
9000 return fold_build2 (code, type, variable, lhs);
9004 /* For comparisons of pointers we can decompose it to a compile time
9005 comparison of the base objects and the offsets into the object.
9006 This requires at least one operand being an ADDR_EXPR or a
9007 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
9008 if (POINTER_TYPE_P (TREE_TYPE (arg0))
9009 && (TREE_CODE (arg0) == ADDR_EXPR
9010 || TREE_CODE (arg1) == ADDR_EXPR
9011 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
9012 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
9014 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
9015 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
9016 enum machine_mode mode;
9017 int volatilep, unsignedp;
9018 bool indirect_base0 = false, indirect_base1 = false;
9020 /* Get base and offset for the access. Strip ADDR_EXPR for
9021 get_inner_reference, but put it back by stripping INDIRECT_REF
9022 off the base object if possible. indirect_baseN will be true
9023 if baseN is not an address but refers to the object itself. */
9025 if (TREE_CODE (arg0) == ADDR_EXPR)
9027 base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
9028 &bitsize, &bitpos0, &offset0, &mode,
9029 &unsignedp, &volatilep, false);
9030 if (TREE_CODE (base0) == INDIRECT_REF)
9031 base0 = TREE_OPERAND (base0, 0);
9033 indirect_base0 = true;
9035 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9037 base0 = TREE_OPERAND (arg0, 0);
9038 offset0 = TREE_OPERAND (arg0, 1);
9042 if (TREE_CODE (arg1) == ADDR_EXPR)
9044 base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
9045 &bitsize, &bitpos1, &offset1, &mode,
9046 &unsignedp, &volatilep, false);
9047 if (TREE_CODE (base1) == INDIRECT_REF)
9048 base1 = TREE_OPERAND (base1, 0);
9050 indirect_base1 = true;
9052 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
9054 base1 = TREE_OPERAND (arg1, 0);
9055 offset1 = TREE_OPERAND (arg1, 1);
9058 /* If we have equivalent bases we might be able to simplify. */
9059 if (indirect_base0 == indirect_base1
9060 && operand_equal_p (base0, base1, 0))
9062 /* We can fold this expression to a constant if the non-constant
9063 offset parts are equal. */
9064 if ((offset0 == offset1
9065 || (offset0 && offset1
9066 && operand_equal_p (offset0, offset1, 0)))
9069 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9074 && bitpos0 != bitpos1
9075 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9076 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9077 fold_overflow_warning (("assuming pointer wraparound does not "
9078 "occur when comparing P +- C1 with "
9080 WARN_STRICT_OVERFLOW_CONDITIONAL);
9085 return constant_boolean_node (bitpos0 == bitpos1, type);
9087 return constant_boolean_node (bitpos0 != bitpos1, type);
9089 return constant_boolean_node (bitpos0 < bitpos1, type);
9091 return constant_boolean_node (bitpos0 <= bitpos1, type);
9093 return constant_boolean_node (bitpos0 >= bitpos1, type);
9095 return constant_boolean_node (bitpos0 > bitpos1, type);
9099 /* We can simplify the comparison to a comparison of the variable
9100 offset parts if the constant offset parts are equal.
9101 Be careful to use signed size type here because otherwise we
9102 mess with array offsets in the wrong way. This is possible
9103 because pointer arithmetic is restricted to retain within an
9104 object and overflow on pointer differences is undefined as of
9105 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
9106 else if (bitpos0 == bitpos1
9107 && ((code == EQ_EXPR || code == NE_EXPR)
9108 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9110 tree signed_size_type_node;
9111 signed_size_type_node = signed_type_for (size_type_node);
9113 /* By converting to signed size type we cover middle-end pointer
9114 arithmetic which operates on unsigned pointer types of size
9115 type size and ARRAY_REF offsets which are properly sign or
9116 zero extended from their type in case it is narrower than
9118 if (offset0 == NULL_TREE)
9119 offset0 = build_int_cst (signed_size_type_node, 0);
9121 offset0 = fold_convert (signed_size_type_node, offset0);
9122 if (offset1 == NULL_TREE)
9123 offset1 = build_int_cst (signed_size_type_node, 0);
9125 offset1 = fold_convert (signed_size_type_node, offset1);
9129 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9130 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9131 fold_overflow_warning (("assuming pointer wraparound does not "
9132 "occur when comparing P +- C1 with "
9134 WARN_STRICT_OVERFLOW_COMPARISON);
9136 return fold_build2 (code, type, offset0, offset1);
9139 /* For non-equal bases we can simplify if they are addresses
9140 of local binding decls or constants. */
9141 else if (indirect_base0 && indirect_base1
9142 /* We know that !operand_equal_p (base0, base1, 0)
9143 because the if condition was false. But make
9144 sure two decls are not the same. */
9146 && TREE_CODE (arg0) == ADDR_EXPR
9147 && TREE_CODE (arg1) == ADDR_EXPR
9148 && (((TREE_CODE (base0) == VAR_DECL
9149 || TREE_CODE (base0) == PARM_DECL)
9150 && (targetm.binds_local_p (base0)
9151 || CONSTANT_CLASS_P (base1)))
9152 || CONSTANT_CLASS_P (base0))
9153 && (((TREE_CODE (base1) == VAR_DECL
9154 || TREE_CODE (base1) == PARM_DECL)
9155 && (targetm.binds_local_p (base1)
9156 || CONSTANT_CLASS_P (base0)))
9157 || CONSTANT_CLASS_P (base1)))
9159 if (code == EQ_EXPR)
9160 return omit_two_operands (type, boolean_false_node, arg0, arg1);
9161 else if (code == NE_EXPR)
9162 return omit_two_operands (type, boolean_true_node, arg0, arg1);
9164 /* For equal offsets we can simplify to a comparison of the
9166 else if (bitpos0 == bitpos1
9168 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9170 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9171 && ((offset0 == offset1)
9172 || (offset0 && offset1
9173 && operand_equal_p (offset0, offset1, 0))))
9176 base0 = build_fold_addr_expr (base0);
9178 base1 = build_fold_addr_expr (base1);
9179 return fold_build2 (code, type, base0, base1);
9183 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9184 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9185 the resulting offset is smaller in absolute value than the
9187 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9188 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9189 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9190 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9191 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9192 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9193 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9195 tree const1 = TREE_OPERAND (arg0, 1);
9196 tree const2 = TREE_OPERAND (arg1, 1);
9197 tree variable1 = TREE_OPERAND (arg0, 0);
9198 tree variable2 = TREE_OPERAND (arg1, 0);
9200 const char * const warnmsg = G_("assuming signed overflow does not "
9201 "occur when combining constants around "
9204 /* Put the constant on the side where it doesn't overflow and is
9205 of lower absolute value than before. */
9206 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9207 ? MINUS_EXPR : PLUS_EXPR,
9209 if (!TREE_OVERFLOW (cst)
9210 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
9212 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9213 return fold_build2 (code, type,
9215 fold_build2 (TREE_CODE (arg1), TREE_TYPE (arg1),
9219 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9220 ? MINUS_EXPR : PLUS_EXPR,
9222 if (!TREE_OVERFLOW (cst)
9223 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
9225 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9226 return fold_build2 (code, type,
9227 fold_build2 (TREE_CODE (arg0), TREE_TYPE (arg0),
9233 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9234 signed arithmetic case. That form is created by the compiler
9235 often enough for folding it to be of value. One example is in
9236 computing loop trip counts after Operator Strength Reduction. */
9237 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9238 && TREE_CODE (arg0) == MULT_EXPR
9239 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9240 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9241 && integer_zerop (arg1))
9243 tree const1 = TREE_OPERAND (arg0, 1);
9244 tree const2 = arg1; /* zero */
9245 tree variable1 = TREE_OPERAND (arg0, 0);
9246 enum tree_code cmp_code = code;
9248 gcc_assert (!integer_zerop (const1));
9250 fold_overflow_warning (("assuming signed overflow does not occur when "
9251 "eliminating multiplication in comparison "
9253 WARN_STRICT_OVERFLOW_COMPARISON);
9255 /* If const1 is negative we swap the sense of the comparison. */
9256 if (tree_int_cst_sgn (const1) < 0)
9257 cmp_code = swap_tree_comparison (cmp_code);
9259 return fold_build2 (cmp_code, type, variable1, const2);
9262 tem = maybe_canonicalize_comparison (code, type, op0, op1);
9266 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9268 tree targ0 = strip_float_extensions (arg0);
9269 tree targ1 = strip_float_extensions (arg1);
9270 tree newtype = TREE_TYPE (targ0);
9272 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9273 newtype = TREE_TYPE (targ1);
9275 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9276 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9277 return fold_build2 (code, type, fold_convert (newtype, targ0),
9278 fold_convert (newtype, targ1));
9280 /* (-a) CMP (-b) -> b CMP a */
9281 if (TREE_CODE (arg0) == NEGATE_EXPR
9282 && TREE_CODE (arg1) == NEGATE_EXPR)
9283 return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
9284 TREE_OPERAND (arg0, 0));
9286 if (TREE_CODE (arg1) == REAL_CST)
9288 REAL_VALUE_TYPE cst;
9289 cst = TREE_REAL_CST (arg1);
9291 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9292 if (TREE_CODE (arg0) == NEGATE_EXPR)
9293 return fold_build2 (swap_tree_comparison (code), type,
9294 TREE_OPERAND (arg0, 0),
9295 build_real (TREE_TYPE (arg1),
9296 REAL_VALUE_NEGATE (cst)));
9298 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9299 /* a CMP (-0) -> a CMP 0 */
9300 if (REAL_VALUE_MINUS_ZERO (cst))
9301 return fold_build2 (code, type, arg0,
9302 build_real (TREE_TYPE (arg1), dconst0));
9304 /* x != NaN is always true, other ops are always false. */
9305 if (REAL_VALUE_ISNAN (cst)
9306 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9308 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9309 return omit_one_operand (type, tem, arg0);
9312 /* Fold comparisons against infinity. */
9313 if (REAL_VALUE_ISINF (cst)
9314 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9316 tem = fold_inf_compare (code, type, arg0, arg1);
9317 if (tem != NULL_TREE)
9322 /* If this is a comparison of a real constant with a PLUS_EXPR
9323 or a MINUS_EXPR of a real constant, we can convert it into a
9324 comparison with a revised real constant as long as no overflow
9325 occurs when unsafe_math_optimizations are enabled. */
9326 if (flag_unsafe_math_optimizations
9327 && TREE_CODE (arg1) == REAL_CST
9328 && (TREE_CODE (arg0) == PLUS_EXPR
9329 || TREE_CODE (arg0) == MINUS_EXPR)
9330 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9331 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9332 ? MINUS_EXPR : PLUS_EXPR,
9333 arg1, TREE_OPERAND (arg0, 1), 0))
9334 && !TREE_OVERFLOW (tem))
9335 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9337 /* Likewise, we can simplify a comparison of a real constant with
9338 a MINUS_EXPR whose first operand is also a real constant, i.e.
9339 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9340 floating-point types only if -fassociative-math is set. */
9341 if (flag_associative_math
9342 && TREE_CODE (arg1) == REAL_CST
9343 && TREE_CODE (arg0) == MINUS_EXPR
9344 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9345 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9347 && !TREE_OVERFLOW (tem))
9348 return fold_build2 (swap_tree_comparison (code), type,
9349 TREE_OPERAND (arg0, 1), tem);
9351 /* Fold comparisons against built-in math functions. */
9352 if (TREE_CODE (arg1) == REAL_CST
9353 && flag_unsafe_math_optimizations
9354 && ! flag_errno_math)
9356 enum built_in_function fcode = builtin_mathfn_code (arg0);
9358 if (fcode != END_BUILTINS)
9360 tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
9361 if (tem != NULL_TREE)
9367 if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9368 && CONVERT_EXPR_P (arg0))
9370 /* If we are widening one operand of an integer comparison,
9371 see if the other operand is similarly being widened. Perhaps we
9372 can do the comparison in the narrower type. */
9373 tem = fold_widened_comparison (code, type, arg0, arg1);
9377 /* Or if we are changing signedness. */
9378 tem = fold_sign_changed_comparison (code, type, arg0, arg1);
9383 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9384 constant, we can simplify it. */
9385 if (TREE_CODE (arg1) == INTEGER_CST
9386 && (TREE_CODE (arg0) == MIN_EXPR
9387 || TREE_CODE (arg0) == MAX_EXPR)
9388 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9390 tem = optimize_minmax_comparison (code, type, op0, op1);
9395 /* Simplify comparison of something with itself. (For IEEE
9396 floating-point, we can only do some of these simplifications.) */
9397 if (operand_equal_p (arg0, arg1, 0))
9402 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9403 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9404 return constant_boolean_node (1, type);
9409 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9410 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9411 return constant_boolean_node (1, type);
9412 return fold_build2 (EQ_EXPR, type, arg0, arg1);
9415 /* For NE, we can only do this simplification if integer
9416 or we don't honor IEEE floating point NaNs. */
9417 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9418 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9420 /* ... fall through ... */
9423 return constant_boolean_node (0, type);
9429 /* If we are comparing an expression that just has comparisons
9430 of two integer values, arithmetic expressions of those comparisons,
9431 and constants, we can simplify it. There are only three cases
9432 to check: the two values can either be equal, the first can be
9433 greater, or the second can be greater. Fold the expression for
9434 those three values. Since each value must be 0 or 1, we have
9435 eight possibilities, each of which corresponds to the constant 0
9436 or 1 or one of the six possible comparisons.
9438 This handles common cases like (a > b) == 0 but also handles
9439 expressions like ((x > y) - (y > x)) > 0, which supposedly
9440 occur in macroized code. */
9442 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9444 tree cval1 = 0, cval2 = 0;
9447 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9448 /* Don't handle degenerate cases here; they should already
9449 have been handled anyway. */
9450 && cval1 != 0 && cval2 != 0
9451 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9452 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9453 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9454 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9455 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9456 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9457 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9459 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9460 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9462 /* We can't just pass T to eval_subst in case cval1 or cval2
9463 was the same as ARG1. */
9466 = fold_build2 (code, type,
9467 eval_subst (arg0, cval1, maxval,
9471 = fold_build2 (code, type,
9472 eval_subst (arg0, cval1, maxval,
9476 = fold_build2 (code, type,
9477 eval_subst (arg0, cval1, minval,
9481 /* All three of these results should be 0 or 1. Confirm they are.
9482 Then use those values to select the proper code to use. */
9484 if (TREE_CODE (high_result) == INTEGER_CST
9485 && TREE_CODE (equal_result) == INTEGER_CST
9486 && TREE_CODE (low_result) == INTEGER_CST)
9488 /* Make a 3-bit mask with the high-order bit being the
9489 value for `>', the next for '=', and the low for '<'. */
9490 switch ((integer_onep (high_result) * 4)
9491 + (integer_onep (equal_result) * 2)
9492 + integer_onep (low_result))
9496 return omit_one_operand (type, integer_zero_node, arg0);
9517 return omit_one_operand (type, integer_one_node, arg0);
9521 return save_expr (build2 (code, type, cval1, cval2));
9522 return fold_build2 (code, type, cval1, cval2);
9527 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9528 into a single range test. */
9529 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9530 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9531 && TREE_CODE (arg1) == INTEGER_CST
9532 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9533 && !integer_zerop (TREE_OPERAND (arg0, 1))
9534 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9535 && !TREE_OVERFLOW (arg1))
9537 tem = fold_div_compare (code, type, arg0, arg1);
9538 if (tem != NULL_TREE)
9542 /* Fold ~X op ~Y as Y op X. */
9543 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9544 && TREE_CODE (arg1) == BIT_NOT_EXPR)
9546 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9547 return fold_build2 (code, type,
9548 fold_convert (cmp_type, TREE_OPERAND (arg1, 0)),
9549 TREE_OPERAND (arg0, 0));
9552 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9553 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9554 && TREE_CODE (arg1) == INTEGER_CST)
9556 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9557 return fold_build2 (swap_tree_comparison (code), type,
9558 TREE_OPERAND (arg0, 0),
9559 fold_build1 (BIT_NOT_EXPR, cmp_type,
9560 fold_convert (cmp_type, arg1)));
9567 /* Subroutine of fold_binary. Optimize complex multiplications of the
9568 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9569 argument EXPR represents the expression "z" of type TYPE. */
9572 fold_mult_zconjz (tree type, tree expr)
9574 tree itype = TREE_TYPE (type);
9575 tree rpart, ipart, tem;
9577 if (TREE_CODE (expr) == COMPLEX_EXPR)
9579 rpart = TREE_OPERAND (expr, 0);
9580 ipart = TREE_OPERAND (expr, 1);
9582 else if (TREE_CODE (expr) == COMPLEX_CST)
9584 rpart = TREE_REALPART (expr);
9585 ipart = TREE_IMAGPART (expr);
9589 expr = save_expr (expr);
9590 rpart = fold_build1 (REALPART_EXPR, itype, expr);
9591 ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
9594 rpart = save_expr (rpart);
9595 ipart = save_expr (ipart);
9596 tem = fold_build2 (PLUS_EXPR, itype,
9597 fold_build2 (MULT_EXPR, itype, rpart, rpart),
9598 fold_build2 (MULT_EXPR, itype, ipart, ipart));
9599 return fold_build2 (COMPLEX_EXPR, type, tem,
9600 fold_convert (itype, integer_zero_node));
9604 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9605 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9606 guarantees that P and N have the same least significant log2(M) bits.
9607 N is not otherwise constrained. In particular, N is not normalized to
9608 0 <= N < M as is common. In general, the precise value of P is unknown.
9609 M is chosen as large as possible such that constant N can be determined.
9611 Returns M and sets *RESIDUE to N.
9613 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9614 account. This is not always possible due to PR 35705.
9617 static unsigned HOST_WIDE_INT
9618 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9619 bool allow_func_align)
9621 enum tree_code code;
9625 code = TREE_CODE (expr);
9626 if (code == ADDR_EXPR)
9628 expr = TREE_OPERAND (expr, 0);
9629 if (handled_component_p (expr))
9631 HOST_WIDE_INT bitsize, bitpos;
9633 enum machine_mode mode;
9634 int unsignedp, volatilep;
9636 expr = get_inner_reference (expr, &bitsize, &bitpos, &offset,
9637 &mode, &unsignedp, &volatilep, false);
9638 *residue = bitpos / BITS_PER_UNIT;
9641 if (TREE_CODE (offset) == INTEGER_CST)
9642 *residue += TREE_INT_CST_LOW (offset);
9644 /* We don't handle more complicated offset expressions. */
9650 && (allow_func_align || TREE_CODE (expr) != FUNCTION_DECL))
9651 return DECL_ALIGN_UNIT (expr);
9653 else if (code == POINTER_PLUS_EXPR)
9656 unsigned HOST_WIDE_INT modulus;
9657 enum tree_code inner_code;
9659 op0 = TREE_OPERAND (expr, 0);
9661 modulus = get_pointer_modulus_and_residue (op0, residue,
9664 op1 = TREE_OPERAND (expr, 1);
9666 inner_code = TREE_CODE (op1);
9667 if (inner_code == INTEGER_CST)
9669 *residue += TREE_INT_CST_LOW (op1);
9672 else if (inner_code == MULT_EXPR)
9674 op1 = TREE_OPERAND (op1, 1);
9675 if (TREE_CODE (op1) == INTEGER_CST)
9677 unsigned HOST_WIDE_INT align;
9679 /* Compute the greatest power-of-2 divisor of op1. */
9680 align = TREE_INT_CST_LOW (op1);
9683 /* If align is non-zero and less than *modulus, replace
9684 *modulus with align., If align is 0, then either op1 is 0
9685 or the greatest power-of-2 divisor of op1 doesn't fit in an
9686 unsigned HOST_WIDE_INT. In either case, no additional
9687 constraint is imposed. */
9689 modulus = MIN (modulus, align);
9696 /* If we get here, we were unable to determine anything useful about the
9702 /* Fold a binary expression of code CODE and type TYPE with operands
9703 OP0 and OP1. Return the folded expression if folding is
9704 successful. Otherwise, return NULL_TREE. */
9707 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
9709 enum tree_code_class kind = TREE_CODE_CLASS (code);
9710 tree arg0, arg1, tem;
9711 tree t1 = NULL_TREE;
9712 bool strict_overflow_p;
9714 gcc_assert (IS_EXPR_CODE_CLASS (kind)
9715 && TREE_CODE_LENGTH (code) == 2
9717 && op1 != NULL_TREE);
9722 /* Strip any conversions that don't change the mode. This is
9723 safe for every expression, except for a comparison expression
9724 because its signedness is derived from its operands. So, in
9725 the latter case, only strip conversions that don't change the
9726 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9729 Note that this is done as an internal manipulation within the
9730 constant folder, in order to find the simplest representation
9731 of the arguments so that their form can be studied. In any
9732 cases, the appropriate type conversions should be put back in
9733 the tree that will get out of the constant folder. */
9735 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9737 STRIP_SIGN_NOPS (arg0);
9738 STRIP_SIGN_NOPS (arg1);
9746 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9747 constant but we can't do arithmetic on them. */
9748 if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9749 || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9750 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9751 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9752 || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9753 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
9755 if (kind == tcc_binary)
9757 /* Make sure type and arg0 have the same saturating flag. */
9758 gcc_assert (TYPE_SATURATING (type)
9759 == TYPE_SATURATING (TREE_TYPE (arg0)));
9760 tem = const_binop (code, arg0, arg1, 0);
9762 else if (kind == tcc_comparison)
9763 tem = fold_relational_const (code, type, arg0, arg1);
9767 if (tem != NULL_TREE)
9769 if (TREE_TYPE (tem) != type)
9770 tem = fold_convert (type, tem);
9775 /* If this is a commutative operation, and ARG0 is a constant, move it
9776 to ARG1 to reduce the number of tests below. */
9777 if (commutative_tree_code (code)
9778 && tree_swap_operands_p (arg0, arg1, true))
9779 return fold_build2 (code, type, op1, op0);
9781 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9783 First check for cases where an arithmetic operation is applied to a
9784 compound, conditional, or comparison operation. Push the arithmetic
9785 operation inside the compound or conditional to see if any folding
9786 can then be done. Convert comparison to conditional for this purpose.
9787 The also optimizes non-constant cases that used to be done in
9790 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9791 one of the operands is a comparison and the other is a comparison, a
9792 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9793 code below would make the expression more complex. Change it to a
9794 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9795 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9797 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9798 || code == EQ_EXPR || code == NE_EXPR)
9799 && ((truth_value_p (TREE_CODE (arg0))
9800 && (truth_value_p (TREE_CODE (arg1))
9801 || (TREE_CODE (arg1) == BIT_AND_EXPR
9802 && integer_onep (TREE_OPERAND (arg1, 1)))))
9803 || (truth_value_p (TREE_CODE (arg1))
9804 && (truth_value_p (TREE_CODE (arg0))
9805 || (TREE_CODE (arg0) == BIT_AND_EXPR
9806 && integer_onep (TREE_OPERAND (arg0, 1)))))))
9808 tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9809 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9812 fold_convert (boolean_type_node, arg0),
9813 fold_convert (boolean_type_node, arg1));
9815 if (code == EQ_EXPR)
9816 tem = invert_truthvalue (tem);
9818 return fold_convert (type, tem);
9821 if (TREE_CODE_CLASS (code) == tcc_binary
9822 || TREE_CODE_CLASS (code) == tcc_comparison)
9824 if (TREE_CODE (arg0) == COMPOUND_EXPR)
9825 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9826 fold_build2 (code, type,
9827 fold_convert (TREE_TYPE (op0),
9828 TREE_OPERAND (arg0, 1)),
9830 if (TREE_CODE (arg1) == COMPOUND_EXPR
9831 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9832 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9833 fold_build2 (code, type, op0,
9834 fold_convert (TREE_TYPE (op1),
9835 TREE_OPERAND (arg1, 1))));
9837 if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
9839 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9841 /*cond_first_p=*/1);
9842 if (tem != NULL_TREE)
9846 if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
9848 tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9850 /*cond_first_p=*/0);
9851 if (tem != NULL_TREE)
9858 case POINTER_PLUS_EXPR:
9859 /* 0 +p index -> (type)index */
9860 if (integer_zerop (arg0))
9861 return non_lvalue (fold_convert (type, arg1));
9863 /* PTR +p 0 -> PTR */
9864 if (integer_zerop (arg1))
9865 return non_lvalue (fold_convert (type, arg0));
9867 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9868 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9869 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9870 return fold_convert (type, fold_build2 (PLUS_EXPR, sizetype,
9871 fold_convert (sizetype, arg1),
9872 fold_convert (sizetype, arg0)));
9874 /* index +p PTR -> PTR +p index */
9875 if (POINTER_TYPE_P (TREE_TYPE (arg1))
9876 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9877 return fold_build2 (POINTER_PLUS_EXPR, type,
9878 fold_convert (type, arg1),
9879 fold_convert (sizetype, arg0));
9881 /* (PTR +p B) +p A -> PTR +p (B + A) */
9882 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9885 tree arg01 = fold_convert (sizetype, TREE_OPERAND (arg0, 1));
9886 tree arg00 = TREE_OPERAND (arg0, 0);
9887 inner = fold_build2 (PLUS_EXPR, sizetype,
9888 arg01, fold_convert (sizetype, arg1));
9889 return fold_convert (type,
9890 fold_build2 (POINTER_PLUS_EXPR,
9891 TREE_TYPE (arg00), arg00, inner));
9894 /* PTR_CST +p CST -> CST1 */
9895 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9896 return fold_build2 (PLUS_EXPR, type, arg0, fold_convert (type, arg1));
9898 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9899 of the array. Loop optimizer sometimes produce this type of
9901 if (TREE_CODE (arg0) == ADDR_EXPR)
9903 tem = try_move_mult_to_index (arg0, fold_convert (sizetype, arg1));
9905 return fold_convert (type, tem);
9911 /* A + (-B) -> A - B */
9912 if (TREE_CODE (arg1) == NEGATE_EXPR)
9913 return fold_build2 (MINUS_EXPR, type,
9914 fold_convert (type, arg0),
9915 fold_convert (type, TREE_OPERAND (arg1, 0)));
9916 /* (-A) + B -> B - A */
9917 if (TREE_CODE (arg0) == NEGATE_EXPR
9918 && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
9919 return fold_build2 (MINUS_EXPR, type,
9920 fold_convert (type, arg1),
9921 fold_convert (type, TREE_OPERAND (arg0, 0)));
9923 if (INTEGRAL_TYPE_P (type))
9925 /* Convert ~A + 1 to -A. */
9926 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9927 && integer_onep (arg1))
9928 return fold_build1 (NEGATE_EXPR, type,
9929 fold_convert (type, TREE_OPERAND (arg0, 0)));
9932 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9933 && !TYPE_OVERFLOW_TRAPS (type))
9935 tree tem = TREE_OPERAND (arg0, 0);
9938 if (operand_equal_p (tem, arg1, 0))
9940 t1 = build_int_cst_type (type, -1);
9941 return omit_one_operand (type, t1, arg1);
9946 if (TREE_CODE (arg1) == BIT_NOT_EXPR
9947 && !TYPE_OVERFLOW_TRAPS (type))
9949 tree tem = TREE_OPERAND (arg1, 0);
9952 if (operand_equal_p (arg0, tem, 0))
9954 t1 = build_int_cst_type (type, -1);
9955 return omit_one_operand (type, t1, arg0);
9959 /* X + (X / CST) * -CST is X % CST. */
9960 if (TREE_CODE (arg1) == MULT_EXPR
9961 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9962 && operand_equal_p (arg0,
9963 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9965 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9966 tree cst1 = TREE_OPERAND (arg1, 1);
9967 tree sum = fold_binary (PLUS_EXPR, TREE_TYPE (cst1), cst1, cst0);
9968 if (sum && integer_zerop (sum))
9969 return fold_convert (type,
9970 fold_build2 (TRUNC_MOD_EXPR,
9971 TREE_TYPE (arg0), arg0, cst0));
9975 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
9976 same or one. Make sure type is not saturating.
9977 fold_plusminus_mult_expr will re-associate. */
9978 if ((TREE_CODE (arg0) == MULT_EXPR
9979 || TREE_CODE (arg1) == MULT_EXPR)
9980 && !TYPE_SATURATING (type)
9981 && (!FLOAT_TYPE_P (type) || flag_associative_math))
9983 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9988 if (! FLOAT_TYPE_P (type))
9990 if (integer_zerop (arg1))
9991 return non_lvalue (fold_convert (type, arg0));
9993 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
9994 with a constant, and the two constants have no bits in common,
9995 we should treat this as a BIT_IOR_EXPR since this may produce more
9997 if (TREE_CODE (arg0) == BIT_AND_EXPR
9998 && TREE_CODE (arg1) == BIT_AND_EXPR
9999 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10000 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10001 && integer_zerop (const_binop (BIT_AND_EXPR,
10002 TREE_OPERAND (arg0, 1),
10003 TREE_OPERAND (arg1, 1), 0)))
10005 code = BIT_IOR_EXPR;
10009 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10010 (plus (plus (mult) (mult)) (foo)) so that we can
10011 take advantage of the factoring cases below. */
10012 if (((TREE_CODE (arg0) == PLUS_EXPR
10013 || TREE_CODE (arg0) == MINUS_EXPR)
10014 && TREE_CODE (arg1) == MULT_EXPR)
10015 || ((TREE_CODE (arg1) == PLUS_EXPR
10016 || TREE_CODE (arg1) == MINUS_EXPR)
10017 && TREE_CODE (arg0) == MULT_EXPR))
10019 tree parg0, parg1, parg, marg;
10020 enum tree_code pcode;
10022 if (TREE_CODE (arg1) == MULT_EXPR)
10023 parg = arg0, marg = arg1;
10025 parg = arg1, marg = arg0;
10026 pcode = TREE_CODE (parg);
10027 parg0 = TREE_OPERAND (parg, 0);
10028 parg1 = TREE_OPERAND (parg, 1);
10029 STRIP_NOPS (parg0);
10030 STRIP_NOPS (parg1);
10032 if (TREE_CODE (parg0) == MULT_EXPR
10033 && TREE_CODE (parg1) != MULT_EXPR)
10034 return fold_build2 (pcode, type,
10035 fold_build2 (PLUS_EXPR, type,
10036 fold_convert (type, parg0),
10037 fold_convert (type, marg)),
10038 fold_convert (type, parg1));
10039 if (TREE_CODE (parg0) != MULT_EXPR
10040 && TREE_CODE (parg1) == MULT_EXPR)
10041 return fold_build2 (PLUS_EXPR, type,
10042 fold_convert (type, parg0),
10043 fold_build2 (pcode, type,
10044 fold_convert (type, marg),
10045 fold_convert (type,
10051 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10052 if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10053 return non_lvalue (fold_convert (type, arg0));
10055 /* Likewise if the operands are reversed. */
10056 if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10057 return non_lvalue (fold_convert (type, arg1));
10059 /* Convert X + -C into X - C. */
10060 if (TREE_CODE (arg1) == REAL_CST
10061 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10063 tem = fold_negate_const (arg1, type);
10064 if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10065 return fold_build2 (MINUS_EXPR, type,
10066 fold_convert (type, arg0),
10067 fold_convert (type, tem));
10070 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10071 to __complex__ ( x, y ). This is not the same for SNaNs or
10072 if signed zeros are involved. */
10073 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10074 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10075 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10077 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10078 tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
10079 tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
10080 bool arg0rz = false, arg0iz = false;
10081 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10082 || (arg0i && (arg0iz = real_zerop (arg0i))))
10084 tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
10085 tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
10086 if (arg0rz && arg1i && real_zerop (arg1i))
10088 tree rp = arg1r ? arg1r
10089 : build1 (REALPART_EXPR, rtype, arg1);
10090 tree ip = arg0i ? arg0i
10091 : build1 (IMAGPART_EXPR, rtype, arg0);
10092 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10094 else if (arg0iz && arg1r && real_zerop (arg1r))
10096 tree rp = arg0r ? arg0r
10097 : build1 (REALPART_EXPR, rtype, arg0);
10098 tree ip = arg1i ? arg1i
10099 : build1 (IMAGPART_EXPR, rtype, arg1);
10100 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10105 if (flag_unsafe_math_optimizations
10106 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10107 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10108 && (tem = distribute_real_division (code, type, arg0, arg1)))
10111 /* Convert x+x into x*2.0. */
10112 if (operand_equal_p (arg0, arg1, 0)
10113 && SCALAR_FLOAT_TYPE_P (type))
10114 return fold_build2 (MULT_EXPR, type, arg0,
10115 build_real (type, dconst2));
10117 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10118 We associate floats only if the user has specified
10119 -fassociative-math. */
10120 if (flag_associative_math
10121 && TREE_CODE (arg1) == PLUS_EXPR
10122 && TREE_CODE (arg0) != MULT_EXPR)
10124 tree tree10 = TREE_OPERAND (arg1, 0);
10125 tree tree11 = TREE_OPERAND (arg1, 1);
10126 if (TREE_CODE (tree11) == MULT_EXPR
10127 && TREE_CODE (tree10) == MULT_EXPR)
10130 tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
10131 return fold_build2 (PLUS_EXPR, type, tree0, tree11);
10134 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10135 We associate floats only if the user has specified
10136 -fassociative-math. */
10137 if (flag_associative_math
10138 && TREE_CODE (arg0) == PLUS_EXPR
10139 && TREE_CODE (arg1) != MULT_EXPR)
10141 tree tree00 = TREE_OPERAND (arg0, 0);
10142 tree tree01 = TREE_OPERAND (arg0, 1);
10143 if (TREE_CODE (tree01) == MULT_EXPR
10144 && TREE_CODE (tree00) == MULT_EXPR)
10147 tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
10148 return fold_build2 (PLUS_EXPR, type, tree00, tree0);
10154 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10155 is a rotate of A by C1 bits. */
10156 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10157 is a rotate of A by B bits. */
10159 enum tree_code code0, code1;
10161 code0 = TREE_CODE (arg0);
10162 code1 = TREE_CODE (arg1);
10163 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10164 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10165 && operand_equal_p (TREE_OPERAND (arg0, 0),
10166 TREE_OPERAND (arg1, 0), 0)
10167 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10168 TYPE_UNSIGNED (rtype))
10169 /* Only create rotates in complete modes. Other cases are not
10170 expanded properly. */
10171 && TYPE_PRECISION (rtype) == GET_MODE_PRECISION (TYPE_MODE (rtype)))
10173 tree tree01, tree11;
10174 enum tree_code code01, code11;
10176 tree01 = TREE_OPERAND (arg0, 1);
10177 tree11 = TREE_OPERAND (arg1, 1);
10178 STRIP_NOPS (tree01);
10179 STRIP_NOPS (tree11);
10180 code01 = TREE_CODE (tree01);
10181 code11 = TREE_CODE (tree11);
10182 if (code01 == INTEGER_CST
10183 && code11 == INTEGER_CST
10184 && TREE_INT_CST_HIGH (tree01) == 0
10185 && TREE_INT_CST_HIGH (tree11) == 0
10186 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
10187 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10188 return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
10189 code0 == LSHIFT_EXPR ? tree01 : tree11);
10190 else if (code11 == MINUS_EXPR)
10192 tree tree110, tree111;
10193 tree110 = TREE_OPERAND (tree11, 0);
10194 tree111 = TREE_OPERAND (tree11, 1);
10195 STRIP_NOPS (tree110);
10196 STRIP_NOPS (tree111);
10197 if (TREE_CODE (tree110) == INTEGER_CST
10198 && 0 == compare_tree_int (tree110,
10200 (TREE_TYPE (TREE_OPERAND
10202 && operand_equal_p (tree01, tree111, 0))
10203 return build2 ((code0 == LSHIFT_EXPR
10206 type, TREE_OPERAND (arg0, 0), tree01);
10208 else if (code01 == MINUS_EXPR)
10210 tree tree010, tree011;
10211 tree010 = TREE_OPERAND (tree01, 0);
10212 tree011 = TREE_OPERAND (tree01, 1);
10213 STRIP_NOPS (tree010);
10214 STRIP_NOPS (tree011);
10215 if (TREE_CODE (tree010) == INTEGER_CST
10216 && 0 == compare_tree_int (tree010,
10218 (TREE_TYPE (TREE_OPERAND
10220 && operand_equal_p (tree11, tree011, 0))
10221 return build2 ((code0 != LSHIFT_EXPR
10224 type, TREE_OPERAND (arg0, 0), tree11);
10230 /* In most languages, can't associate operations on floats through
10231 parentheses. Rather than remember where the parentheses were, we
10232 don't associate floats at all, unless the user has specified
10233 -fassociative-math.
10234 And, we need to make sure type is not saturating. */
10236 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10237 && !TYPE_SATURATING (type))
10239 tree var0, con0, lit0, minus_lit0;
10240 tree var1, con1, lit1, minus_lit1;
10243 /* Split both trees into variables, constants, and literals. Then
10244 associate each group together, the constants with literals,
10245 then the result with variables. This increases the chances of
10246 literals being recombined later and of generating relocatable
10247 expressions for the sum of a constant and literal. */
10248 var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10249 var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10250 code == MINUS_EXPR);
10252 /* With undefined overflow we can only associate constants
10253 with one variable. */
10254 if (((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10255 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10261 if (TREE_CODE (tmp0) == NEGATE_EXPR)
10262 tmp0 = TREE_OPERAND (tmp0, 0);
10263 if (TREE_CODE (tmp1) == NEGATE_EXPR)
10264 tmp1 = TREE_OPERAND (tmp1, 0);
10265 /* The only case we can still associate with two variables
10266 is if they are the same, modulo negation. */
10267 if (!operand_equal_p (tmp0, tmp1, 0))
10271 /* Only do something if we found more than two objects. Otherwise,
10272 nothing has changed and we risk infinite recursion. */
10274 && (2 < ((var0 != 0) + (var1 != 0)
10275 + (con0 != 0) + (con1 != 0)
10276 + (lit0 != 0) + (lit1 != 0)
10277 + (minus_lit0 != 0) + (minus_lit1 != 0))))
10279 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10280 if (code == MINUS_EXPR)
10283 var0 = associate_trees (var0, var1, code, type);
10284 con0 = associate_trees (con0, con1, code, type);
10285 lit0 = associate_trees (lit0, lit1, code, type);
10286 minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
10288 /* Preserve the MINUS_EXPR if the negative part of the literal is
10289 greater than the positive part. Otherwise, the multiplicative
10290 folding code (i.e extract_muldiv) may be fooled in case
10291 unsigned constants are subtracted, like in the following
10292 example: ((X*2 + 4) - 8U)/2. */
10293 if (minus_lit0 && lit0)
10295 if (TREE_CODE (lit0) == INTEGER_CST
10296 && TREE_CODE (minus_lit0) == INTEGER_CST
10297 && tree_int_cst_lt (lit0, minus_lit0))
10299 minus_lit0 = associate_trees (minus_lit0, lit0,
10305 lit0 = associate_trees (lit0, minus_lit0,
10313 return fold_convert (type,
10314 associate_trees (var0, minus_lit0,
10315 MINUS_EXPR, type));
10318 con0 = associate_trees (con0, minus_lit0,
10320 return fold_convert (type,
10321 associate_trees (var0, con0,
10326 con0 = associate_trees (con0, lit0, code, type);
10327 return fold_convert (type, associate_trees (var0, con0,
10335 /* Pointer simplifications for subtraction, simple reassociations. */
10336 if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10338 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10339 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10340 && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10342 tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10343 tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10344 tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10345 tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10346 return fold_build2 (PLUS_EXPR, type,
10347 fold_build2 (MINUS_EXPR, type, arg00, arg10),
10348 fold_build2 (MINUS_EXPR, type, arg01, arg11));
10350 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10351 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10353 tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10354 tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10355 tree tmp = fold_binary (MINUS_EXPR, type, arg00, fold_convert (type, arg1));
10357 return fold_build2 (PLUS_EXPR, type, tmp, arg01);
10360 /* A - (-B) -> A + B */
10361 if (TREE_CODE (arg1) == NEGATE_EXPR)
10362 return fold_build2 (PLUS_EXPR, type, op0,
10363 fold_convert (type, TREE_OPERAND (arg1, 0)));
10364 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10365 if (TREE_CODE (arg0) == NEGATE_EXPR
10366 && (FLOAT_TYPE_P (type)
10367 || INTEGRAL_TYPE_P (type))
10368 && negate_expr_p (arg1)
10369 && reorder_operands_p (arg0, arg1))
10370 return fold_build2 (MINUS_EXPR, type,
10371 fold_convert (type, negate_expr (arg1)),
10372 fold_convert (type, TREE_OPERAND (arg0, 0)));
10373 /* Convert -A - 1 to ~A. */
10374 if (INTEGRAL_TYPE_P (type)
10375 && TREE_CODE (arg0) == NEGATE_EXPR
10376 && integer_onep (arg1)
10377 && !TYPE_OVERFLOW_TRAPS (type))
10378 return fold_build1 (BIT_NOT_EXPR, type,
10379 fold_convert (type, TREE_OPERAND (arg0, 0)));
10381 /* Convert -1 - A to ~A. */
10382 if (INTEGRAL_TYPE_P (type)
10383 && integer_all_onesp (arg0))
10384 return fold_build1 (BIT_NOT_EXPR, type, op1);
10387 /* X - (X / CST) * CST is X % CST. */
10388 if (INTEGRAL_TYPE_P (type)
10389 && TREE_CODE (arg1) == MULT_EXPR
10390 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10391 && operand_equal_p (arg0,
10392 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10393 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10394 TREE_OPERAND (arg1, 1), 0))
10395 return fold_convert (type,
10396 fold_build2 (TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10397 arg0, TREE_OPERAND (arg1, 1)));
10399 if (! FLOAT_TYPE_P (type))
10401 if (integer_zerop (arg0))
10402 return negate_expr (fold_convert (type, arg1));
10403 if (integer_zerop (arg1))
10404 return non_lvalue (fold_convert (type, arg0));
10406 /* Fold A - (A & B) into ~B & A. */
10407 if (!TREE_SIDE_EFFECTS (arg0)
10408 && TREE_CODE (arg1) == BIT_AND_EXPR)
10410 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10412 tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10413 return fold_build2 (BIT_AND_EXPR, type,
10414 fold_build1 (BIT_NOT_EXPR, type, arg10),
10415 fold_convert (type, arg0));
10417 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10419 tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10420 return fold_build2 (BIT_AND_EXPR, type,
10421 fold_build1 (BIT_NOT_EXPR, type, arg11),
10422 fold_convert (type, arg0));
10426 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10427 any power of 2 minus 1. */
10428 if (TREE_CODE (arg0) == BIT_AND_EXPR
10429 && TREE_CODE (arg1) == BIT_AND_EXPR
10430 && operand_equal_p (TREE_OPERAND (arg0, 0),
10431 TREE_OPERAND (arg1, 0), 0))
10433 tree mask0 = TREE_OPERAND (arg0, 1);
10434 tree mask1 = TREE_OPERAND (arg1, 1);
10435 tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
10437 if (operand_equal_p (tem, mask1, 0))
10439 tem = fold_build2 (BIT_XOR_EXPR, type,
10440 TREE_OPERAND (arg0, 0), mask1);
10441 return fold_build2 (MINUS_EXPR, type, tem, mask1);
10446 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10447 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10448 return non_lvalue (fold_convert (type, arg0));
10450 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10451 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10452 (-ARG1 + ARG0) reduces to -ARG1. */
10453 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10454 return negate_expr (fold_convert (type, arg1));
10456 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10457 __complex__ ( x, -y ). This is not the same for SNaNs or if
10458 signed zeros are involved. */
10459 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10460 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10461 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10463 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10464 tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
10465 tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
10466 bool arg0rz = false, arg0iz = false;
10467 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10468 || (arg0i && (arg0iz = real_zerop (arg0i))))
10470 tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
10471 tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
10472 if (arg0rz && arg1i && real_zerop (arg1i))
10474 tree rp = fold_build1 (NEGATE_EXPR, rtype,
10476 : build1 (REALPART_EXPR, rtype, arg1));
10477 tree ip = arg0i ? arg0i
10478 : build1 (IMAGPART_EXPR, rtype, arg0);
10479 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10481 else if (arg0iz && arg1r && real_zerop (arg1r))
10483 tree rp = arg0r ? arg0r
10484 : build1 (REALPART_EXPR, rtype, arg0);
10485 tree ip = fold_build1 (NEGATE_EXPR, rtype,
10487 : build1 (IMAGPART_EXPR, rtype, arg1));
10488 return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10493 /* Fold &x - &x. This can happen from &x.foo - &x.
10494 This is unsafe for certain floats even in non-IEEE formats.
10495 In IEEE, it is unsafe because it does wrong for NaNs.
10496 Also note that operand_equal_p is always false if an operand
10499 if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
10500 && operand_equal_p (arg0, arg1, 0))
10501 return fold_convert (type, integer_zero_node);
10503 /* A - B -> A + (-B) if B is easily negatable. */
10504 if (negate_expr_p (arg1)
10505 && ((FLOAT_TYPE_P (type)
10506 /* Avoid this transformation if B is a positive REAL_CST. */
10507 && (TREE_CODE (arg1) != REAL_CST
10508 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10509 || INTEGRAL_TYPE_P (type)))
10510 return fold_build2 (PLUS_EXPR, type,
10511 fold_convert (type, arg0),
10512 fold_convert (type, negate_expr (arg1)));
10514 /* Try folding difference of addresses. */
10516 HOST_WIDE_INT diff;
10518 if ((TREE_CODE (arg0) == ADDR_EXPR
10519 || TREE_CODE (arg1) == ADDR_EXPR)
10520 && ptr_difference_const (arg0, arg1, &diff))
10521 return build_int_cst_type (type, diff);
10524 /* Fold &a[i] - &a[j] to i-j. */
10525 if (TREE_CODE (arg0) == ADDR_EXPR
10526 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10527 && TREE_CODE (arg1) == ADDR_EXPR
10528 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10530 tree aref0 = TREE_OPERAND (arg0, 0);
10531 tree aref1 = TREE_OPERAND (arg1, 0);
10532 if (operand_equal_p (TREE_OPERAND (aref0, 0),
10533 TREE_OPERAND (aref1, 0), 0))
10535 tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
10536 tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
10537 tree esz = array_ref_element_size (aref0);
10538 tree diff = build2 (MINUS_EXPR, type, op0, op1);
10539 return fold_build2 (MULT_EXPR, type, diff,
10540 fold_convert (type, esz));
10545 if (FLOAT_TYPE_P (type)
10546 && flag_unsafe_math_optimizations
10547 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10548 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10549 && (tem = distribute_real_division (code, type, arg0, arg1)))
10552 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
10553 same or one. Make sure type is not saturating.
10554 fold_plusminus_mult_expr will re-associate. */
10555 if ((TREE_CODE (arg0) == MULT_EXPR
10556 || TREE_CODE (arg1) == MULT_EXPR)
10557 && !TYPE_SATURATING (type)
10558 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10560 tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
10568 /* (-A) * (-B) -> A * B */
10569 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10570 return fold_build2 (MULT_EXPR, type,
10571 fold_convert (type, TREE_OPERAND (arg0, 0)),
10572 fold_convert (type, negate_expr (arg1)));
10573 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10574 return fold_build2 (MULT_EXPR, type,
10575 fold_convert (type, negate_expr (arg0)),
10576 fold_convert (type, TREE_OPERAND (arg1, 0)));
10578 if (! FLOAT_TYPE_P (type))
10580 if (integer_zerop (arg1))
10581 return omit_one_operand (type, arg1, arg0);
10582 if (integer_onep (arg1))
10583 return non_lvalue (fold_convert (type, arg0));
10584 /* Transform x * -1 into -x. Make sure to do the negation
10585 on the original operand with conversions not stripped
10586 because we can only strip non-sign-changing conversions. */
10587 if (integer_all_onesp (arg1))
10588 return fold_convert (type, negate_expr (op0));
10589 /* Transform x * -C into -x * C if x is easily negatable. */
10590 if (TREE_CODE (arg1) == INTEGER_CST
10591 && tree_int_cst_sgn (arg1) == -1
10592 && negate_expr_p (arg0)
10593 && (tem = negate_expr (arg1)) != arg1
10594 && !TREE_OVERFLOW (tem))
10595 return fold_build2 (MULT_EXPR, type,
10596 fold_convert (type, negate_expr (arg0)), tem);
10598 /* (a * (1 << b)) is (a << b) */
10599 if (TREE_CODE (arg1) == LSHIFT_EXPR
10600 && integer_onep (TREE_OPERAND (arg1, 0)))
10601 return fold_build2 (LSHIFT_EXPR, type, op0,
10602 TREE_OPERAND (arg1, 1));
10603 if (TREE_CODE (arg0) == LSHIFT_EXPR
10604 && integer_onep (TREE_OPERAND (arg0, 0)))
10605 return fold_build2 (LSHIFT_EXPR, type, op1,
10606 TREE_OPERAND (arg0, 1));
10608 /* (A + A) * C -> A * 2 * C */
10609 if (TREE_CODE (arg0) == PLUS_EXPR
10610 && TREE_CODE (arg1) == INTEGER_CST
10611 && operand_equal_p (TREE_OPERAND (arg0, 0),
10612 TREE_OPERAND (arg0, 1), 0))
10613 return fold_build2 (MULT_EXPR, type,
10614 omit_one_operand (type, TREE_OPERAND (arg0, 0),
10615 TREE_OPERAND (arg0, 1)),
10616 fold_build2 (MULT_EXPR, type,
10617 build_int_cst (type, 2) , arg1));
10619 strict_overflow_p = false;
10620 if (TREE_CODE (arg1) == INTEGER_CST
10621 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10622 &strict_overflow_p)))
10624 if (strict_overflow_p)
10625 fold_overflow_warning (("assuming signed overflow does not "
10626 "occur when simplifying "
10628 WARN_STRICT_OVERFLOW_MISC);
10629 return fold_convert (type, tem);
10632 /* Optimize z * conj(z) for integer complex numbers. */
10633 if (TREE_CODE (arg0) == CONJ_EXPR
10634 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10635 return fold_mult_zconjz (type, arg1);
10636 if (TREE_CODE (arg1) == CONJ_EXPR
10637 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10638 return fold_mult_zconjz (type, arg0);
10642 /* Maybe fold x * 0 to 0. The expressions aren't the same
10643 when x is NaN, since x * 0 is also NaN. Nor are they the
10644 same in modes with signed zeros, since multiplying a
10645 negative value by 0 gives -0, not +0. */
10646 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10647 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10648 && real_zerop (arg1))
10649 return omit_one_operand (type, arg1, arg0);
10650 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10651 Likewise for complex arithmetic with signed zeros. */
10652 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10653 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10654 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10655 && real_onep (arg1))
10656 return non_lvalue (fold_convert (type, arg0));
10658 /* Transform x * -1.0 into -x. */
10659 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10660 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10661 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10662 && real_minus_onep (arg1))
10663 return fold_convert (type, negate_expr (arg0));
10665 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10666 the result for floating point types due to rounding so it is applied
10667 only if -fassociative-math was specify. */
10668 if (flag_associative_math
10669 && TREE_CODE (arg0) == RDIV_EXPR
10670 && TREE_CODE (arg1) == REAL_CST
10671 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10673 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10676 return fold_build2 (RDIV_EXPR, type, tem,
10677 TREE_OPERAND (arg0, 1));
10680 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10681 if (operand_equal_p (arg0, arg1, 0))
10683 tree tem = fold_strip_sign_ops (arg0);
10684 if (tem != NULL_TREE)
10686 tem = fold_convert (type, tem);
10687 return fold_build2 (MULT_EXPR, type, tem, tem);
10691 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10692 This is not the same for NaNs or if signed zeros are
10694 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10695 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10696 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10697 && TREE_CODE (arg1) == COMPLEX_CST
10698 && real_zerop (TREE_REALPART (arg1)))
10700 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10701 if (real_onep (TREE_IMAGPART (arg1)))
10702 return fold_build2 (COMPLEX_EXPR, type,
10703 negate_expr (fold_build1 (IMAGPART_EXPR,
10705 fold_build1 (REALPART_EXPR, rtype, arg0));
10706 else if (real_minus_onep (TREE_IMAGPART (arg1)))
10707 return fold_build2 (COMPLEX_EXPR, type,
10708 fold_build1 (IMAGPART_EXPR, rtype, arg0),
10709 negate_expr (fold_build1 (REALPART_EXPR,
10713 /* Optimize z * conj(z) for floating point complex numbers.
10714 Guarded by flag_unsafe_math_optimizations as non-finite
10715 imaginary components don't produce scalar results. */
10716 if (flag_unsafe_math_optimizations
10717 && TREE_CODE (arg0) == CONJ_EXPR
10718 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10719 return fold_mult_zconjz (type, arg1);
10720 if (flag_unsafe_math_optimizations
10721 && TREE_CODE (arg1) == CONJ_EXPR
10722 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10723 return fold_mult_zconjz (type, arg0);
10725 if (flag_unsafe_math_optimizations)
10727 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10728 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10730 /* Optimizations of root(...)*root(...). */
10731 if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10734 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10735 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10737 /* Optimize sqrt(x)*sqrt(x) as x. */
10738 if (BUILTIN_SQRT_P (fcode0)
10739 && operand_equal_p (arg00, arg10, 0)
10740 && ! HONOR_SNANS (TYPE_MODE (type)))
10743 /* Optimize root(x)*root(y) as root(x*y). */
10744 rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10745 arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10746 return build_call_expr (rootfn, 1, arg);
10749 /* Optimize expN(x)*expN(y) as expN(x+y). */
10750 if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10752 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10753 tree arg = fold_build2 (PLUS_EXPR, type,
10754 CALL_EXPR_ARG (arg0, 0),
10755 CALL_EXPR_ARG (arg1, 0));
10756 return build_call_expr (expfn, 1, arg);
10759 /* Optimizations of pow(...)*pow(...). */
10760 if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10761 || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10762 || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10764 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10765 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10766 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10767 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10769 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
10770 if (operand_equal_p (arg01, arg11, 0))
10772 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10773 tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10774 return build_call_expr (powfn, 2, arg, arg01);
10777 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
10778 if (operand_equal_p (arg00, arg10, 0))
10780 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10781 tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
10782 return build_call_expr (powfn, 2, arg00, arg);
10786 /* Optimize tan(x)*cos(x) as sin(x). */
10787 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
10788 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
10789 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
10790 || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
10791 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
10792 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
10793 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
10794 CALL_EXPR_ARG (arg1, 0), 0))
10796 tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
10798 if (sinfn != NULL_TREE)
10799 return build_call_expr (sinfn, 1, CALL_EXPR_ARG (arg0, 0));
10802 /* Optimize x*pow(x,c) as pow(x,c+1). */
10803 if (fcode1 == BUILT_IN_POW
10804 || fcode1 == BUILT_IN_POWF
10805 || fcode1 == BUILT_IN_POWL)
10807 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10808 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10809 if (TREE_CODE (arg11) == REAL_CST
10810 && !TREE_OVERFLOW (arg11)
10811 && operand_equal_p (arg0, arg10, 0))
10813 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
10817 c = TREE_REAL_CST (arg11);
10818 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10819 arg = build_real (type, c);
10820 return build_call_expr (powfn, 2, arg0, arg);
10824 /* Optimize pow(x,c)*x as pow(x,c+1). */
10825 if (fcode0 == BUILT_IN_POW
10826 || fcode0 == BUILT_IN_POWF
10827 || fcode0 == BUILT_IN_POWL)
10829 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10830 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10831 if (TREE_CODE (arg01) == REAL_CST
10832 && !TREE_OVERFLOW (arg01)
10833 && operand_equal_p (arg1, arg00, 0))
10835 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10839 c = TREE_REAL_CST (arg01);
10840 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10841 arg = build_real (type, c);
10842 return build_call_expr (powfn, 2, arg1, arg);
10846 /* Optimize x*x as pow(x,2.0), which is expanded as x*x. */
10847 if (optimize_function_for_speed_p (cfun)
10848 && operand_equal_p (arg0, arg1, 0))
10850 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10854 tree arg = build_real (type, dconst2);
10855 return build_call_expr (powfn, 2, arg0, arg);
10864 if (integer_all_onesp (arg1))
10865 return omit_one_operand (type, arg1, arg0);
10866 if (integer_zerop (arg1))
10867 return non_lvalue (fold_convert (type, arg0));
10868 if (operand_equal_p (arg0, arg1, 0))
10869 return non_lvalue (fold_convert (type, arg0));
10871 /* ~X | X is -1. */
10872 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10873 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10875 t1 = fold_convert (type, integer_zero_node);
10876 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10877 return omit_one_operand (type, t1, arg1);
10880 /* X | ~X is -1. */
10881 if (TREE_CODE (arg1) == BIT_NOT_EXPR
10882 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10884 t1 = fold_convert (type, integer_zero_node);
10885 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10886 return omit_one_operand (type, t1, arg0);
10889 /* Canonicalize (X & C1) | C2. */
10890 if (TREE_CODE (arg0) == BIT_AND_EXPR
10891 && TREE_CODE (arg1) == INTEGER_CST
10892 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10894 unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, hi3, lo3, mlo, mhi;
10895 int width = TYPE_PRECISION (type), w;
10896 hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
10897 lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10898 hi2 = TREE_INT_CST_HIGH (arg1);
10899 lo2 = TREE_INT_CST_LOW (arg1);
10901 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
10902 if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
10903 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10905 if (width > HOST_BITS_PER_WIDE_INT)
10907 mhi = (unsigned HOST_WIDE_INT) -1
10908 >> (2 * HOST_BITS_PER_WIDE_INT - width);
10914 mlo = (unsigned HOST_WIDE_INT) -1
10915 >> (HOST_BITS_PER_WIDE_INT - width);
10918 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
10919 if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
10920 return fold_build2 (BIT_IOR_EXPR, type,
10921 TREE_OPERAND (arg0, 0), arg1);
10923 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10924 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10925 mode which allows further optimizations. */
10932 for (w = BITS_PER_UNIT;
10933 w <= width && w <= HOST_BITS_PER_WIDE_INT;
10936 unsigned HOST_WIDE_INT mask
10937 = (unsigned HOST_WIDE_INT) -1 >> (HOST_BITS_PER_WIDE_INT - w);
10938 if (((lo1 | lo2) & mask) == mask
10939 && (lo1 & ~mask) == 0 && hi1 == 0)
10946 if (hi3 != hi1 || lo3 != lo1)
10947 return fold_build2 (BIT_IOR_EXPR, type,
10948 fold_build2 (BIT_AND_EXPR, type,
10949 TREE_OPERAND (arg0, 0),
10950 build_int_cst_wide (type,
10955 /* (X & Y) | Y is (X, Y). */
10956 if (TREE_CODE (arg0) == BIT_AND_EXPR
10957 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10958 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10959 /* (X & Y) | X is (Y, X). */
10960 if (TREE_CODE (arg0) == BIT_AND_EXPR
10961 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10962 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10963 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
10964 /* X | (X & Y) is (Y, X). */
10965 if (TREE_CODE (arg1) == BIT_AND_EXPR
10966 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10967 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10968 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
10969 /* X | (Y & X) is (Y, X). */
10970 if (TREE_CODE (arg1) == BIT_AND_EXPR
10971 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10972 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10973 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
10975 t1 = distribute_bit_expr (code, type, arg0, arg1);
10976 if (t1 != NULL_TREE)
10979 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
10981 This results in more efficient code for machines without a NAND
10982 instruction. Combine will canonicalize to the first form
10983 which will allow use of NAND instructions provided by the
10984 backend if they exist. */
10985 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10986 && TREE_CODE (arg1) == BIT_NOT_EXPR)
10988 return fold_build1 (BIT_NOT_EXPR, type,
10989 build2 (BIT_AND_EXPR, type,
10990 fold_convert (type,
10991 TREE_OPERAND (arg0, 0)),
10992 fold_convert (type,
10993 TREE_OPERAND (arg1, 0))));
10996 /* See if this can be simplified into a rotate first. If that
10997 is unsuccessful continue in the association code. */
11001 if (integer_zerop (arg1))
11002 return non_lvalue (fold_convert (type, arg0));
11003 if (integer_all_onesp (arg1))
11004 return fold_build1 (BIT_NOT_EXPR, type, op0);
11005 if (operand_equal_p (arg0, arg1, 0))
11006 return omit_one_operand (type, integer_zero_node, arg0);
11008 /* ~X ^ X is -1. */
11009 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11010 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11012 t1 = fold_convert (type, integer_zero_node);
11013 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
11014 return omit_one_operand (type, t1, arg1);
11017 /* X ^ ~X is -1. */
11018 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11019 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11021 t1 = fold_convert (type, integer_zero_node);
11022 t1 = fold_unary (BIT_NOT_EXPR, type, t1);
11023 return omit_one_operand (type, t1, arg0);
11026 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11027 with a constant, and the two constants have no bits in common,
11028 we should treat this as a BIT_IOR_EXPR since this may produce more
11029 simplifications. */
11030 if (TREE_CODE (arg0) == BIT_AND_EXPR
11031 && TREE_CODE (arg1) == BIT_AND_EXPR
11032 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11033 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11034 && integer_zerop (const_binop (BIT_AND_EXPR,
11035 TREE_OPERAND (arg0, 1),
11036 TREE_OPERAND (arg1, 1), 0)))
11038 code = BIT_IOR_EXPR;
11042 /* (X | Y) ^ X -> Y & ~ X*/
11043 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11044 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11046 tree t2 = TREE_OPERAND (arg0, 1);
11047 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
11049 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11050 fold_convert (type, t1));
11054 /* (Y | X) ^ X -> Y & ~ X*/
11055 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11056 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11058 tree t2 = TREE_OPERAND (arg0, 0);
11059 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
11061 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11062 fold_convert (type, t1));
11066 /* X ^ (X | Y) -> Y & ~ X*/
11067 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11068 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11070 tree t2 = TREE_OPERAND (arg1, 1);
11071 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
11073 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11074 fold_convert (type, t1));
11078 /* X ^ (Y | X) -> Y & ~ X*/
11079 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11080 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11082 tree t2 = TREE_OPERAND (arg1, 0);
11083 t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
11085 t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
11086 fold_convert (type, t1));
11090 /* Convert ~X ^ ~Y to X ^ Y. */
11091 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11092 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11093 return fold_build2 (code, type,
11094 fold_convert (type, TREE_OPERAND (arg0, 0)),
11095 fold_convert (type, TREE_OPERAND (arg1, 0)));
11097 /* Convert ~X ^ C to X ^ ~C. */
11098 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11099 && TREE_CODE (arg1) == INTEGER_CST)
11100 return fold_build2 (code, type,
11101 fold_convert (type, TREE_OPERAND (arg0, 0)),
11102 fold_build1 (BIT_NOT_EXPR, type, arg1));
11104 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11105 if (TREE_CODE (arg0) == BIT_AND_EXPR
11106 && integer_onep (TREE_OPERAND (arg0, 1))
11107 && integer_onep (arg1))
11108 return fold_build2 (EQ_EXPR, type, arg0,
11109 build_int_cst (TREE_TYPE (arg0), 0));
11111 /* Fold (X & Y) ^ Y as ~X & Y. */
11112 if (TREE_CODE (arg0) == BIT_AND_EXPR
11113 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11115 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
11116 return fold_build2 (BIT_AND_EXPR, type,
11117 fold_build1 (BIT_NOT_EXPR, type, tem),
11118 fold_convert (type, arg1));
11120 /* Fold (X & Y) ^ X as ~Y & X. */
11121 if (TREE_CODE (arg0) == BIT_AND_EXPR
11122 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11123 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11125 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
11126 return fold_build2 (BIT_AND_EXPR, type,
11127 fold_build1 (BIT_NOT_EXPR, type, tem),
11128 fold_convert (type, arg1));
11130 /* Fold X ^ (X & Y) as X & ~Y. */
11131 if (TREE_CODE (arg1) == BIT_AND_EXPR
11132 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11134 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
11135 return fold_build2 (BIT_AND_EXPR, type,
11136 fold_convert (type, arg0),
11137 fold_build1 (BIT_NOT_EXPR, type, tem));
11139 /* Fold X ^ (Y & X) as ~Y & X. */
11140 if (TREE_CODE (arg1) == BIT_AND_EXPR
11141 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11142 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11144 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
11145 return fold_build2 (BIT_AND_EXPR, type,
11146 fold_build1 (BIT_NOT_EXPR, type, tem),
11147 fold_convert (type, arg0));
11150 /* See if this can be simplified into a rotate first. If that
11151 is unsuccessful continue in the association code. */
11155 if (integer_all_onesp (arg1))
11156 return non_lvalue (fold_convert (type, arg0));
11157 if (integer_zerop (arg1))
11158 return omit_one_operand (type, arg1, arg0);
11159 if (operand_equal_p (arg0, arg1, 0))
11160 return non_lvalue (fold_convert (type, arg0));
11162 /* ~X & X is always zero. */
11163 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11164 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11165 return omit_one_operand (type, integer_zero_node, arg1);
11167 /* X & ~X is always zero. */
11168 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11169 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11170 return omit_one_operand (type, integer_zero_node, arg0);
11172 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11173 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11174 && TREE_CODE (arg1) == INTEGER_CST
11175 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11177 tree tmp1 = fold_convert (type, arg1);
11178 tree tmp2 = fold_convert (type, TREE_OPERAND (arg0, 0));
11179 tree tmp3 = fold_convert (type, TREE_OPERAND (arg0, 1));
11180 tmp2 = fold_build2 (BIT_AND_EXPR, type, tmp2, tmp1);
11181 tmp3 = fold_build2 (BIT_AND_EXPR, type, tmp3, tmp1);
11182 return fold_convert (type,
11183 fold_build2 (BIT_IOR_EXPR, type, tmp2, tmp3));
11186 /* (X | Y) & Y is (X, Y). */
11187 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11188 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11189 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
11190 /* (X | Y) & X is (Y, X). */
11191 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11192 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11193 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11194 return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
11195 /* X & (X | Y) is (Y, X). */
11196 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11197 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11198 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11199 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
11200 /* X & (Y | X) is (Y, X). */
11201 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11202 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11203 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11204 return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
11206 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11207 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11208 && integer_onep (TREE_OPERAND (arg0, 1))
11209 && integer_onep (arg1))
11211 tem = TREE_OPERAND (arg0, 0);
11212 return fold_build2 (EQ_EXPR, type,
11213 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
11214 build_int_cst (TREE_TYPE (tem), 1)),
11215 build_int_cst (TREE_TYPE (tem), 0));
11217 /* Fold ~X & 1 as (X & 1) == 0. */
11218 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11219 && integer_onep (arg1))
11221 tem = TREE_OPERAND (arg0, 0);
11222 return fold_build2 (EQ_EXPR, type,
11223 fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
11224 build_int_cst (TREE_TYPE (tem), 1)),
11225 build_int_cst (TREE_TYPE (tem), 0));
11228 /* Fold (X ^ Y) & Y as ~X & Y. */
11229 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11230 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11232 tem = fold_convert (type, TREE_OPERAND (arg0, 0));
11233 return fold_build2 (BIT_AND_EXPR, type,
11234 fold_build1 (BIT_NOT_EXPR, type, tem),
11235 fold_convert (type, arg1));
11237 /* Fold (X ^ Y) & X as ~Y & X. */
11238 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11239 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11240 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11242 tem = fold_convert (type, TREE_OPERAND (arg0, 1));
11243 return fold_build2 (BIT_AND_EXPR, type,
11244 fold_build1 (BIT_NOT_EXPR, type, tem),
11245 fold_convert (type, arg1));
11247 /* Fold X & (X ^ Y) as X & ~Y. */
11248 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11249 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11251 tem = fold_convert (type, TREE_OPERAND (arg1, 1));
11252 return fold_build2 (BIT_AND_EXPR, type,
11253 fold_convert (type, arg0),
11254 fold_build1 (BIT_NOT_EXPR, type, tem));
11256 /* Fold X & (Y ^ X) as ~Y & X. */
11257 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11258 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11259 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11261 tem = fold_convert (type, TREE_OPERAND (arg1, 0));
11262 return fold_build2 (BIT_AND_EXPR, type,
11263 fold_build1 (BIT_NOT_EXPR, type, tem),
11264 fold_convert (type, arg0));
11267 t1 = distribute_bit_expr (code, type, arg0, arg1);
11268 if (t1 != NULL_TREE)
11270 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11271 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11272 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11275 = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11277 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
11278 && (~TREE_INT_CST_LOW (arg1)
11279 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
11280 return fold_convert (type, TREE_OPERAND (arg0, 0));
11283 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11285 This results in more efficient code for machines without a NOR
11286 instruction. Combine will canonicalize to the first form
11287 which will allow use of NOR instructions provided by the
11288 backend if they exist. */
11289 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11290 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11292 return fold_build1 (BIT_NOT_EXPR, type,
11293 build2 (BIT_IOR_EXPR, type,
11294 fold_convert (type,
11295 TREE_OPERAND (arg0, 0)),
11296 fold_convert (type,
11297 TREE_OPERAND (arg1, 0))));
11300 /* If arg0 is derived from the address of an object or function, we may
11301 be able to fold this expression using the object or function's
11303 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
11305 unsigned HOST_WIDE_INT modulus, residue;
11306 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
11308 modulus = get_pointer_modulus_and_residue (arg0, &residue,
11309 integer_onep (arg1));
11311 /* This works because modulus is a power of 2. If this weren't the
11312 case, we'd have to replace it by its greatest power-of-2
11313 divisor: modulus & -modulus. */
11315 return build_int_cst (type, residue & low);
11318 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11319 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11320 if the new mask might be further optimized. */
11321 if ((TREE_CODE (arg0) == LSHIFT_EXPR
11322 || TREE_CODE (arg0) == RSHIFT_EXPR)
11323 && host_integerp (TREE_OPERAND (arg0, 1), 1)
11324 && host_integerp (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)))
11325 && tree_low_cst (TREE_OPERAND (arg0, 1), 1)
11326 < TYPE_PRECISION (TREE_TYPE (arg0))
11327 && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11328 && tree_low_cst (TREE_OPERAND (arg0, 1), 1) > 0)
11330 unsigned int shiftc = tree_low_cst (TREE_OPERAND (arg0, 1), 1);
11331 unsigned HOST_WIDE_INT mask
11332 = tree_low_cst (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)));
11333 unsigned HOST_WIDE_INT newmask, zerobits = 0;
11334 tree shift_type = TREE_TYPE (arg0);
11336 if (TREE_CODE (arg0) == LSHIFT_EXPR)
11337 zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11338 else if (TREE_CODE (arg0) == RSHIFT_EXPR
11339 && TYPE_PRECISION (TREE_TYPE (arg0))
11340 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0))))
11342 unsigned int prec = TYPE_PRECISION (TREE_TYPE (arg0));
11343 tree arg00 = TREE_OPERAND (arg0, 0);
11344 /* See if more bits can be proven as zero because of
11346 if (TREE_CODE (arg00) == NOP_EXPR
11347 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11349 tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11350 if (TYPE_PRECISION (inner_type)
11351 == GET_MODE_BITSIZE (TYPE_MODE (inner_type))
11352 && TYPE_PRECISION (inner_type) < prec)
11354 prec = TYPE_PRECISION (inner_type);
11355 /* See if we can shorten the right shift. */
11357 shift_type = inner_type;
11360 zerobits = ~(unsigned HOST_WIDE_INT) 0;
11361 zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11362 zerobits <<= prec - shiftc;
11363 /* For arithmetic shift if sign bit could be set, zerobits
11364 can contain actually sign bits, so no transformation is
11365 possible, unless MASK masks them all away. In that
11366 case the shift needs to be converted into logical shift. */
11367 if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11368 && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11370 if ((mask & zerobits) == 0)
11371 shift_type = unsigned_type_for (TREE_TYPE (arg0));
11377 /* ((X << 16) & 0xff00) is (X, 0). */
11378 if ((mask & zerobits) == mask)
11379 return omit_one_operand (type, build_int_cst (type, 0), arg0);
11381 newmask = mask | zerobits;
11382 if (newmask != mask && (newmask & (newmask + 1)) == 0)
11386 /* Only do the transformation if NEWMASK is some integer
11388 for (prec = BITS_PER_UNIT;
11389 prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11390 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11392 if (prec < HOST_BITS_PER_WIDE_INT
11393 || newmask == ~(unsigned HOST_WIDE_INT) 0)
11395 if (shift_type != TREE_TYPE (arg0))
11397 tem = fold_build2 (TREE_CODE (arg0), shift_type,
11398 fold_convert (shift_type,
11399 TREE_OPERAND (arg0, 0)),
11400 TREE_OPERAND (arg0, 1));
11401 tem = fold_convert (type, tem);
11405 return fold_build2 (BIT_AND_EXPR, type, tem,
11406 build_int_cst_type (TREE_TYPE (op1),
11415 /* Don't touch a floating-point divide by zero unless the mode
11416 of the constant can represent infinity. */
11417 if (TREE_CODE (arg1) == REAL_CST
11418 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11419 && real_zerop (arg1))
11422 /* Optimize A / A to 1.0 if we don't care about
11423 NaNs or Infinities. Skip the transformation
11424 for non-real operands. */
11425 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11426 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11427 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11428 && operand_equal_p (arg0, arg1, 0))
11430 tree r = build_real (TREE_TYPE (arg0), dconst1);
11432 return omit_two_operands (type, r, arg0, arg1);
11435 /* The complex version of the above A / A optimization. */
11436 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11437 && operand_equal_p (arg0, arg1, 0))
11439 tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11440 if (! HONOR_NANS (TYPE_MODE (elem_type))
11441 && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11443 tree r = build_real (elem_type, dconst1);
11444 /* omit_two_operands will call fold_convert for us. */
11445 return omit_two_operands (type, r, arg0, arg1);
11449 /* (-A) / (-B) -> A / B */
11450 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11451 return fold_build2 (RDIV_EXPR, type,
11452 TREE_OPERAND (arg0, 0),
11453 negate_expr (arg1));
11454 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11455 return fold_build2 (RDIV_EXPR, type,
11456 negate_expr (arg0),
11457 TREE_OPERAND (arg1, 0));
11459 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11460 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11461 && real_onep (arg1))
11462 return non_lvalue (fold_convert (type, arg0));
11464 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11465 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11466 && real_minus_onep (arg1))
11467 return non_lvalue (fold_convert (type, negate_expr (arg0)));
11469 /* If ARG1 is a constant, we can convert this to a multiply by the
11470 reciprocal. This does not have the same rounding properties,
11471 so only do this if -freciprocal-math. We can actually
11472 always safely do it if ARG1 is a power of two, but it's hard to
11473 tell if it is or not in a portable manner. */
11474 if (TREE_CODE (arg1) == REAL_CST)
11476 if (flag_reciprocal_math
11477 && 0 != (tem = const_binop (code, build_real (type, dconst1),
11479 return fold_build2 (MULT_EXPR, type, arg0, tem);
11480 /* Find the reciprocal if optimizing and the result is exact. */
11484 r = TREE_REAL_CST (arg1);
11485 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
11487 tem = build_real (type, r);
11488 return fold_build2 (MULT_EXPR, type,
11489 fold_convert (type, arg0), tem);
11493 /* Convert A/B/C to A/(B*C). */
11494 if (flag_reciprocal_math
11495 && TREE_CODE (arg0) == RDIV_EXPR)
11496 return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11497 fold_build2 (MULT_EXPR, type,
11498 TREE_OPERAND (arg0, 1), arg1));
11500 /* Convert A/(B/C) to (A/B)*C. */
11501 if (flag_reciprocal_math
11502 && TREE_CODE (arg1) == RDIV_EXPR)
11503 return fold_build2 (MULT_EXPR, type,
11504 fold_build2 (RDIV_EXPR, type, arg0,
11505 TREE_OPERAND (arg1, 0)),
11506 TREE_OPERAND (arg1, 1));
11508 /* Convert C1/(X*C2) into (C1/C2)/X. */
11509 if (flag_reciprocal_math
11510 && TREE_CODE (arg1) == MULT_EXPR
11511 && TREE_CODE (arg0) == REAL_CST
11512 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11514 tree tem = const_binop (RDIV_EXPR, arg0,
11515 TREE_OPERAND (arg1, 1), 0);
11517 return fold_build2 (RDIV_EXPR, type, tem,
11518 TREE_OPERAND (arg1, 0));
11521 if (flag_unsafe_math_optimizations)
11523 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11524 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11526 /* Optimize sin(x)/cos(x) as tan(x). */
11527 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11528 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11529 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11530 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11531 CALL_EXPR_ARG (arg1, 0), 0))
11533 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11535 if (tanfn != NULL_TREE)
11536 return build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11539 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
11540 if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11541 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11542 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11543 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11544 CALL_EXPR_ARG (arg1, 0), 0))
11546 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11548 if (tanfn != NULL_TREE)
11550 tree tmp = build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11551 return fold_build2 (RDIV_EXPR, type,
11552 build_real (type, dconst1), tmp);
11556 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11557 NaNs or Infinities. */
11558 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11559 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11560 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11562 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11563 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11565 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11566 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11567 && operand_equal_p (arg00, arg01, 0))
11569 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11571 if (cosfn != NULL_TREE)
11572 return build_call_expr (cosfn, 1, arg00);
11576 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11577 NaNs or Infinities. */
11578 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11579 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11580 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11582 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11583 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11585 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11586 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11587 && operand_equal_p (arg00, arg01, 0))
11589 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11591 if (cosfn != NULL_TREE)
11593 tree tmp = build_call_expr (cosfn, 1, arg00);
11594 return fold_build2 (RDIV_EXPR, type,
11595 build_real (type, dconst1),
11601 /* Optimize pow(x,c)/x as pow(x,c-1). */
11602 if (fcode0 == BUILT_IN_POW
11603 || fcode0 == BUILT_IN_POWF
11604 || fcode0 == BUILT_IN_POWL)
11606 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11607 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11608 if (TREE_CODE (arg01) == REAL_CST
11609 && !TREE_OVERFLOW (arg01)
11610 && operand_equal_p (arg1, arg00, 0))
11612 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11616 c = TREE_REAL_CST (arg01);
11617 real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11618 arg = build_real (type, c);
11619 return build_call_expr (powfn, 2, arg1, arg);
11623 /* Optimize a/root(b/c) into a*root(c/b). */
11624 if (BUILTIN_ROOT_P (fcode1))
11626 tree rootarg = CALL_EXPR_ARG (arg1, 0);
11628 if (TREE_CODE (rootarg) == RDIV_EXPR)
11630 tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11631 tree b = TREE_OPERAND (rootarg, 0);
11632 tree c = TREE_OPERAND (rootarg, 1);
11634 tree tmp = fold_build2 (RDIV_EXPR, type, c, b);
11636 tmp = build_call_expr (rootfn, 1, tmp);
11637 return fold_build2 (MULT_EXPR, type, arg0, tmp);
11641 /* Optimize x/expN(y) into x*expN(-y). */
11642 if (BUILTIN_EXPONENT_P (fcode1))
11644 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11645 tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11646 arg1 = build_call_expr (expfn, 1, fold_convert (type, arg));
11647 return fold_build2 (MULT_EXPR, type, arg0, arg1);
11650 /* Optimize x/pow(y,z) into x*pow(y,-z). */
11651 if (fcode1 == BUILT_IN_POW
11652 || fcode1 == BUILT_IN_POWF
11653 || fcode1 == BUILT_IN_POWL)
11655 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11656 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11657 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11658 tree neg11 = fold_convert (type, negate_expr (arg11));
11659 arg1 = build_call_expr (powfn, 2, arg10, neg11);
11660 return fold_build2 (MULT_EXPR, type, arg0, arg1);
11665 case TRUNC_DIV_EXPR:
11666 case FLOOR_DIV_EXPR:
11667 /* Simplify A / (B << N) where A and B are positive and B is
11668 a power of 2, to A >> (N + log2(B)). */
11669 strict_overflow_p = false;
11670 if (TREE_CODE (arg1) == LSHIFT_EXPR
11671 && (TYPE_UNSIGNED (type)
11672 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11674 tree sval = TREE_OPERAND (arg1, 0);
11675 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
11677 tree sh_cnt = TREE_OPERAND (arg1, 1);
11678 unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
11680 if (strict_overflow_p)
11681 fold_overflow_warning (("assuming signed overflow does not "
11682 "occur when simplifying A / (B << N)"),
11683 WARN_STRICT_OVERFLOW_MISC);
11685 sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
11686 sh_cnt, build_int_cst (NULL_TREE, pow2));
11687 return fold_build2 (RSHIFT_EXPR, type,
11688 fold_convert (type, arg0), sh_cnt);
11692 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
11693 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
11694 if (INTEGRAL_TYPE_P (type)
11695 && TYPE_UNSIGNED (type)
11696 && code == FLOOR_DIV_EXPR)
11697 return fold_build2 (TRUNC_DIV_EXPR, type, op0, op1);
11701 case ROUND_DIV_EXPR:
11702 case CEIL_DIV_EXPR:
11703 case EXACT_DIV_EXPR:
11704 if (integer_onep (arg1))
11705 return non_lvalue (fold_convert (type, arg0));
11706 if (integer_zerop (arg1))
11708 /* X / -1 is -X. */
11709 if (!TYPE_UNSIGNED (type)
11710 && TREE_CODE (arg1) == INTEGER_CST
11711 && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11712 && TREE_INT_CST_HIGH (arg1) == -1)
11713 return fold_convert (type, negate_expr (arg0));
11715 /* Convert -A / -B to A / B when the type is signed and overflow is
11717 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11718 && TREE_CODE (arg0) == NEGATE_EXPR
11719 && negate_expr_p (arg1))
11721 if (INTEGRAL_TYPE_P (type))
11722 fold_overflow_warning (("assuming signed overflow does not occur "
11723 "when distributing negation across "
11725 WARN_STRICT_OVERFLOW_MISC);
11726 return fold_build2 (code, type,
11727 fold_convert (type, TREE_OPERAND (arg0, 0)),
11728 fold_convert (type, negate_expr (arg1)));
11730 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11731 && TREE_CODE (arg1) == NEGATE_EXPR
11732 && negate_expr_p (arg0))
11734 if (INTEGRAL_TYPE_P (type))
11735 fold_overflow_warning (("assuming signed overflow does not occur "
11736 "when distributing negation across "
11738 WARN_STRICT_OVERFLOW_MISC);
11739 return fold_build2 (code, type,
11740 fold_convert (type, negate_expr (arg0)),
11741 fold_convert (type, TREE_OPERAND (arg1, 0)));
11744 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
11745 operation, EXACT_DIV_EXPR.
11747 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
11748 At one time others generated faster code, it's not clear if they do
11749 after the last round to changes to the DIV code in expmed.c. */
11750 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
11751 && multiple_of_p (type, arg0, arg1))
11752 return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
11754 strict_overflow_p = false;
11755 if (TREE_CODE (arg1) == INTEGER_CST
11756 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11757 &strict_overflow_p)))
11759 if (strict_overflow_p)
11760 fold_overflow_warning (("assuming signed overflow does not occur "
11761 "when simplifying division"),
11762 WARN_STRICT_OVERFLOW_MISC);
11763 return fold_convert (type, tem);
11768 case CEIL_MOD_EXPR:
11769 case FLOOR_MOD_EXPR:
11770 case ROUND_MOD_EXPR:
11771 case TRUNC_MOD_EXPR:
11772 /* X % 1 is always zero, but be sure to preserve any side
11774 if (integer_onep (arg1))
11775 return omit_one_operand (type, integer_zero_node, arg0);
11777 /* X % 0, return X % 0 unchanged so that we can get the
11778 proper warnings and errors. */
11779 if (integer_zerop (arg1))
11782 /* 0 % X is always zero, but be sure to preserve any side
11783 effects in X. Place this after checking for X == 0. */
11784 if (integer_zerop (arg0))
11785 return omit_one_operand (type, integer_zero_node, arg1);
11787 /* X % -1 is zero. */
11788 if (!TYPE_UNSIGNED (type)
11789 && TREE_CODE (arg1) == INTEGER_CST
11790 && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11791 && TREE_INT_CST_HIGH (arg1) == -1)
11792 return omit_one_operand (type, integer_zero_node, arg0);
11794 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
11795 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
11796 strict_overflow_p = false;
11797 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
11798 && (TYPE_UNSIGNED (type)
11799 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11802 /* Also optimize A % (C << N) where C is a power of 2,
11803 to A & ((C << N) - 1). */
11804 if (TREE_CODE (arg1) == LSHIFT_EXPR)
11805 c = TREE_OPERAND (arg1, 0);
11807 if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
11809 tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1), arg1,
11810 build_int_cst (TREE_TYPE (arg1), 1));
11811 if (strict_overflow_p)
11812 fold_overflow_warning (("assuming signed overflow does not "
11813 "occur when simplifying "
11814 "X % (power of two)"),
11815 WARN_STRICT_OVERFLOW_MISC);
11816 return fold_build2 (BIT_AND_EXPR, type,
11817 fold_convert (type, arg0),
11818 fold_convert (type, mask));
11822 /* X % -C is the same as X % C. */
11823 if (code == TRUNC_MOD_EXPR
11824 && !TYPE_UNSIGNED (type)
11825 && TREE_CODE (arg1) == INTEGER_CST
11826 && !TREE_OVERFLOW (arg1)
11827 && TREE_INT_CST_HIGH (arg1) < 0
11828 && !TYPE_OVERFLOW_TRAPS (type)
11829 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
11830 && !sign_bit_p (arg1, arg1))
11831 return fold_build2 (code, type, fold_convert (type, arg0),
11832 fold_convert (type, negate_expr (arg1)));
11834 /* X % -Y is the same as X % Y. */
11835 if (code == TRUNC_MOD_EXPR
11836 && !TYPE_UNSIGNED (type)
11837 && TREE_CODE (arg1) == NEGATE_EXPR
11838 && !TYPE_OVERFLOW_TRAPS (type))
11839 return fold_build2 (code, type, fold_convert (type, arg0),
11840 fold_convert (type, TREE_OPERAND (arg1, 0)));
11842 if (TREE_CODE (arg1) == INTEGER_CST
11843 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11844 &strict_overflow_p)))
11846 if (strict_overflow_p)
11847 fold_overflow_warning (("assuming signed overflow does not occur "
11848 "when simplifying modulus"),
11849 WARN_STRICT_OVERFLOW_MISC);
11850 return fold_convert (type, tem);
11857 if (integer_all_onesp (arg0))
11858 return omit_one_operand (type, arg0, arg1);
11862 /* Optimize -1 >> x for arithmetic right shifts. */
11863 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
11864 && tree_expr_nonnegative_p (arg1))
11865 return omit_one_operand (type, arg0, arg1);
11866 /* ... fall through ... */
11870 if (integer_zerop (arg1))
11871 return non_lvalue (fold_convert (type, arg0));
11872 if (integer_zerop (arg0))
11873 return omit_one_operand (type, arg0, arg1);
11875 /* Since negative shift count is not well-defined,
11876 don't try to compute it in the compiler. */
11877 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
11880 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
11881 if (TREE_CODE (op0) == code && host_integerp (arg1, false)
11882 && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11883 && host_integerp (TREE_OPERAND (arg0, 1), false)
11884 && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11886 HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
11887 + TREE_INT_CST_LOW (arg1));
11889 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
11890 being well defined. */
11891 if (low >= TYPE_PRECISION (type))
11893 if (code == LROTATE_EXPR || code == RROTATE_EXPR)
11894 low = low % TYPE_PRECISION (type);
11895 else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
11896 return omit_one_operand (type, build_int_cst (type, 0),
11897 TREE_OPERAND (arg0, 0));
11899 low = TYPE_PRECISION (type) - 1;
11902 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
11903 build_int_cst (type, low));
11906 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
11907 into x & ((unsigned)-1 >> c) for unsigned types. */
11908 if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
11909 || (TYPE_UNSIGNED (type)
11910 && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
11911 && host_integerp (arg1, false)
11912 && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11913 && host_integerp (TREE_OPERAND (arg0, 1), false)
11914 && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11916 HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
11917 HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
11923 arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
11925 lshift = build_int_cst (type, -1);
11926 lshift = int_const_binop (code, lshift, arg1, 0);
11928 return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
11932 /* Rewrite an LROTATE_EXPR by a constant into an
11933 RROTATE_EXPR by a new constant. */
11934 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
11936 tree tem = build_int_cst (TREE_TYPE (arg1),
11937 TYPE_PRECISION (type));
11938 tem = const_binop (MINUS_EXPR, tem, arg1, 0);
11939 return fold_build2 (RROTATE_EXPR, type, op0, tem);
11942 /* If we have a rotate of a bit operation with the rotate count and
11943 the second operand of the bit operation both constant,
11944 permute the two operations. */
11945 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11946 && (TREE_CODE (arg0) == BIT_AND_EXPR
11947 || TREE_CODE (arg0) == BIT_IOR_EXPR
11948 || TREE_CODE (arg0) == BIT_XOR_EXPR)
11949 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11950 return fold_build2 (TREE_CODE (arg0), type,
11951 fold_build2 (code, type,
11952 TREE_OPERAND (arg0, 0), arg1),
11953 fold_build2 (code, type,
11954 TREE_OPERAND (arg0, 1), arg1));
11956 /* Two consecutive rotates adding up to the precision of the
11957 type can be ignored. */
11958 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11959 && TREE_CODE (arg0) == RROTATE_EXPR
11960 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11961 && TREE_INT_CST_HIGH (arg1) == 0
11962 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
11963 && ((TREE_INT_CST_LOW (arg1)
11964 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
11965 == (unsigned int) TYPE_PRECISION (type)))
11966 return TREE_OPERAND (arg0, 0);
11968 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
11969 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
11970 if the latter can be further optimized. */
11971 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
11972 && TREE_CODE (arg0) == BIT_AND_EXPR
11973 && TREE_CODE (arg1) == INTEGER_CST
11974 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11976 tree mask = fold_build2 (code, type,
11977 fold_convert (type, TREE_OPERAND (arg0, 1)),
11979 tree shift = fold_build2 (code, type,
11980 fold_convert (type, TREE_OPERAND (arg0, 0)),
11982 tem = fold_binary (BIT_AND_EXPR, type, shift, mask);
11990 if (operand_equal_p (arg0, arg1, 0))
11991 return omit_one_operand (type, arg0, arg1);
11992 if (INTEGRAL_TYPE_P (type)
11993 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
11994 return omit_one_operand (type, arg1, arg0);
11995 tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
12001 if (operand_equal_p (arg0, arg1, 0))
12002 return omit_one_operand (type, arg0, arg1);
12003 if (INTEGRAL_TYPE_P (type)
12004 && TYPE_MAX_VALUE (type)
12005 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12006 return omit_one_operand (type, arg1, arg0);
12007 tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
12012 case TRUTH_ANDIF_EXPR:
12013 /* Note that the operands of this must be ints
12014 and their values must be 0 or 1.
12015 ("true" is a fixed value perhaps depending on the language.) */
12016 /* If first arg is constant zero, return it. */
12017 if (integer_zerop (arg0))
12018 return fold_convert (type, arg0);
12019 case TRUTH_AND_EXPR:
12020 /* If either arg is constant true, drop it. */
12021 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12022 return non_lvalue (fold_convert (type, arg1));
12023 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12024 /* Preserve sequence points. */
12025 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12026 return non_lvalue (fold_convert (type, arg0));
12027 /* If second arg is constant zero, result is zero, but first arg
12028 must be evaluated. */
12029 if (integer_zerop (arg1))
12030 return omit_one_operand (type, arg1, arg0);
12031 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12032 case will be handled here. */
12033 if (integer_zerop (arg0))
12034 return omit_one_operand (type, arg0, arg1);
12036 /* !X && X is always false. */
12037 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12038 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12039 return omit_one_operand (type, integer_zero_node, arg1);
12040 /* X && !X is always false. */
12041 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12042 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12043 return omit_one_operand (type, integer_zero_node, arg0);
12045 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12046 means A >= Y && A != MAX, but in this case we know that
12049 if (!TREE_SIDE_EFFECTS (arg0)
12050 && !TREE_SIDE_EFFECTS (arg1))
12052 tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
12053 if (tem && !operand_equal_p (tem, arg0, 0))
12054 return fold_build2 (code, type, tem, arg1);
12056 tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
12057 if (tem && !operand_equal_p (tem, arg1, 0))
12058 return fold_build2 (code, type, arg0, tem);
12062 /* We only do these simplifications if we are optimizing. */
12066 /* Check for things like (A || B) && (A || C). We can convert this
12067 to A || (B && C). Note that either operator can be any of the four
12068 truth and/or operations and the transformation will still be
12069 valid. Also note that we only care about order for the
12070 ANDIF and ORIF operators. If B contains side effects, this
12071 might change the truth-value of A. */
12072 if (TREE_CODE (arg0) == TREE_CODE (arg1)
12073 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
12074 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
12075 || TREE_CODE (arg0) == TRUTH_AND_EXPR
12076 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
12077 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
12079 tree a00 = TREE_OPERAND (arg0, 0);
12080 tree a01 = TREE_OPERAND (arg0, 1);
12081 tree a10 = TREE_OPERAND (arg1, 0);
12082 tree a11 = TREE_OPERAND (arg1, 1);
12083 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
12084 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
12085 && (code == TRUTH_AND_EXPR
12086 || code == TRUTH_OR_EXPR));
12088 if (operand_equal_p (a00, a10, 0))
12089 return fold_build2 (TREE_CODE (arg0), type, a00,
12090 fold_build2 (code, type, a01, a11));
12091 else if (commutative && operand_equal_p (a00, a11, 0))
12092 return fold_build2 (TREE_CODE (arg0), type, a00,
12093 fold_build2 (code, type, a01, a10));
12094 else if (commutative && operand_equal_p (a01, a10, 0))
12095 return fold_build2 (TREE_CODE (arg0), type, a01,
12096 fold_build2 (code, type, a00, a11));
12098 /* This case if tricky because we must either have commutative
12099 operators or else A10 must not have side-effects. */
12101 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
12102 && operand_equal_p (a01, a11, 0))
12103 return fold_build2 (TREE_CODE (arg0), type,
12104 fold_build2 (code, type, a00, a10),
12108 /* See if we can build a range comparison. */
12109 if (0 != (tem = fold_range_test (code, type, op0, op1)))
12112 /* Check for the possibility of merging component references. If our
12113 lhs is another similar operation, try to merge its rhs with our
12114 rhs. Then try to merge our lhs and rhs. */
12115 if (TREE_CODE (arg0) == code
12116 && 0 != (tem = fold_truthop (code, type,
12117 TREE_OPERAND (arg0, 1), arg1)))
12118 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12120 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
12125 case TRUTH_ORIF_EXPR:
12126 /* Note that the operands of this must be ints
12127 and their values must be 0 or true.
12128 ("true" is a fixed value perhaps depending on the language.) */
12129 /* If first arg is constant true, return it. */
12130 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12131 return fold_convert (type, arg0);
12132 case TRUTH_OR_EXPR:
12133 /* If either arg is constant zero, drop it. */
12134 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12135 return non_lvalue (fold_convert (type, arg1));
12136 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12137 /* Preserve sequence points. */
12138 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12139 return non_lvalue (fold_convert (type, arg0));
12140 /* If second arg is constant true, result is true, but we must
12141 evaluate first arg. */
12142 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12143 return omit_one_operand (type, arg1, arg0);
12144 /* Likewise for first arg, but note this only occurs here for
12146 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12147 return omit_one_operand (type, arg0, arg1);
12149 /* !X || X is always true. */
12150 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12151 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12152 return omit_one_operand (type, integer_one_node, arg1);
12153 /* X || !X is always true. */
12154 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12155 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12156 return omit_one_operand (type, integer_one_node, arg0);
12160 case TRUTH_XOR_EXPR:
12161 /* If the second arg is constant zero, drop it. */
12162 if (integer_zerop (arg1))
12163 return non_lvalue (fold_convert (type, arg0));
12164 /* If the second arg is constant true, this is a logical inversion. */
12165 if (integer_onep (arg1))
12167 /* Only call invert_truthvalue if operand is a truth value. */
12168 if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
12169 tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
12171 tem = invert_truthvalue (arg0);
12172 return non_lvalue (fold_convert (type, tem));
12174 /* Identical arguments cancel to zero. */
12175 if (operand_equal_p (arg0, arg1, 0))
12176 return omit_one_operand (type, integer_zero_node, arg0);
12178 /* !X ^ X is always true. */
12179 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12180 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12181 return omit_one_operand (type, integer_one_node, arg1);
12183 /* X ^ !X is always true. */
12184 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12185 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12186 return omit_one_operand (type, integer_one_node, arg0);
12192 tem = fold_comparison (code, type, op0, op1);
12193 if (tem != NULL_TREE)
12196 /* bool_var != 0 becomes bool_var. */
12197 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12198 && code == NE_EXPR)
12199 return non_lvalue (fold_convert (type, arg0));
12201 /* bool_var == 1 becomes bool_var. */
12202 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12203 && code == EQ_EXPR)
12204 return non_lvalue (fold_convert (type, arg0));
12206 /* bool_var != 1 becomes !bool_var. */
12207 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12208 && code == NE_EXPR)
12209 return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
12211 /* bool_var == 0 becomes !bool_var. */
12212 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12213 && code == EQ_EXPR)
12214 return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
12216 /* If this is an equality comparison of the address of two non-weak,
12217 unaliased symbols neither of which are extern (since we do not
12218 have access to attributes for externs), then we know the result. */
12219 if (TREE_CODE (arg0) == ADDR_EXPR
12220 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12221 && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12222 && ! lookup_attribute ("alias",
12223 DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12224 && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12225 && TREE_CODE (arg1) == ADDR_EXPR
12226 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12227 && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12228 && ! lookup_attribute ("alias",
12229 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12230 && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12232 /* We know that we're looking at the address of two
12233 non-weak, unaliased, static _DECL nodes.
12235 It is both wasteful and incorrect to call operand_equal_p
12236 to compare the two ADDR_EXPR nodes. It is wasteful in that
12237 all we need to do is test pointer equality for the arguments
12238 to the two ADDR_EXPR nodes. It is incorrect to use
12239 operand_equal_p as that function is NOT equivalent to a
12240 C equality test. It can in fact return false for two
12241 objects which would test as equal using the C equality
12243 bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12244 return constant_boolean_node (equal
12245 ? code == EQ_EXPR : code != EQ_EXPR,
12249 /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
12250 a MINUS_EXPR of a constant, we can convert it into a comparison with
12251 a revised constant as long as no overflow occurs. */
12252 if (TREE_CODE (arg1) == INTEGER_CST
12253 && (TREE_CODE (arg0) == PLUS_EXPR
12254 || TREE_CODE (arg0) == MINUS_EXPR)
12255 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12256 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
12257 ? MINUS_EXPR : PLUS_EXPR,
12258 fold_convert (TREE_TYPE (arg0), arg1),
12259 TREE_OPERAND (arg0, 1), 0))
12260 && !TREE_OVERFLOW (tem))
12261 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12263 /* Similarly for a NEGATE_EXPR. */
12264 if (TREE_CODE (arg0) == NEGATE_EXPR
12265 && TREE_CODE (arg1) == INTEGER_CST
12266 && 0 != (tem = negate_expr (arg1))
12267 && TREE_CODE (tem) == INTEGER_CST
12268 && !TREE_OVERFLOW (tem))
12269 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
12271 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12272 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12273 && TREE_CODE (arg1) == INTEGER_CST
12274 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12275 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12276 fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg0),
12277 fold_convert (TREE_TYPE (arg0), arg1),
12278 TREE_OPERAND (arg0, 1)));
12280 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12281 if ((TREE_CODE (arg0) == PLUS_EXPR
12282 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12283 || TREE_CODE (arg0) == MINUS_EXPR)
12284 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12285 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12286 || POINTER_TYPE_P (TREE_TYPE (arg0))))
12288 tree val = TREE_OPERAND (arg0, 1);
12289 return omit_two_operands (type,
12290 fold_build2 (code, type,
12292 build_int_cst (TREE_TYPE (val),
12294 TREE_OPERAND (arg0, 0), arg1);
12297 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12298 if (TREE_CODE (arg0) == MINUS_EXPR
12299 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12300 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0)
12301 && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
12303 return omit_two_operands (type,
12305 ? boolean_true_node : boolean_false_node,
12306 TREE_OPERAND (arg0, 1), arg1);
12309 /* If we have X - Y == 0, we can convert that to X == Y and similarly
12310 for !=. Don't do this for ordered comparisons due to overflow. */
12311 if (TREE_CODE (arg0) == MINUS_EXPR
12312 && integer_zerop (arg1))
12313 return fold_build2 (code, type,
12314 TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
12316 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12317 if (TREE_CODE (arg0) == ABS_EXPR
12318 && (integer_zerop (arg1) || real_zerop (arg1)))
12319 return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
12321 /* If this is an EQ or NE comparison with zero and ARG0 is
12322 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12323 two operations, but the latter can be done in one less insn
12324 on machines that have only two-operand insns or on which a
12325 constant cannot be the first operand. */
12326 if (TREE_CODE (arg0) == BIT_AND_EXPR
12327 && integer_zerop (arg1))
12329 tree arg00 = TREE_OPERAND (arg0, 0);
12330 tree arg01 = TREE_OPERAND (arg0, 1);
12331 if (TREE_CODE (arg00) == LSHIFT_EXPR
12332 && integer_onep (TREE_OPERAND (arg00, 0)))
12334 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
12335 arg01, TREE_OPERAND (arg00, 1));
12336 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12337 build_int_cst (TREE_TYPE (arg0), 1));
12338 return fold_build2 (code, type,
12339 fold_convert (TREE_TYPE (arg1), tem), arg1);
12341 else if (TREE_CODE (arg01) == LSHIFT_EXPR
12342 && integer_onep (TREE_OPERAND (arg01, 0)))
12344 tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
12345 arg00, TREE_OPERAND (arg01, 1));
12346 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12347 build_int_cst (TREE_TYPE (arg0), 1));
12348 return fold_build2 (code, type,
12349 fold_convert (TREE_TYPE (arg1), tem), arg1);
12353 /* If this is an NE or EQ comparison of zero against the result of a
12354 signed MOD operation whose second operand is a power of 2, make
12355 the MOD operation unsigned since it is simpler and equivalent. */
12356 if (integer_zerop (arg1)
12357 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12358 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12359 || TREE_CODE (arg0) == CEIL_MOD_EXPR
12360 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12361 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12362 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12364 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12365 tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
12366 fold_convert (newtype,
12367 TREE_OPERAND (arg0, 0)),
12368 fold_convert (newtype,
12369 TREE_OPERAND (arg0, 1)));
12371 return fold_build2 (code, type, newmod,
12372 fold_convert (newtype, arg1));
12375 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12376 C1 is a valid shift constant, and C2 is a power of two, i.e.
12378 if (TREE_CODE (arg0) == BIT_AND_EXPR
12379 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12380 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12382 && integer_pow2p (TREE_OPERAND (arg0, 1))
12383 && integer_zerop (arg1))
12385 tree itype = TREE_TYPE (arg0);
12386 unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
12387 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12389 /* Check for a valid shift count. */
12390 if (TREE_INT_CST_HIGH (arg001) == 0
12391 && TREE_INT_CST_LOW (arg001) < prec)
12393 tree arg01 = TREE_OPERAND (arg0, 1);
12394 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12395 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12396 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12397 can be rewritten as (X & (C2 << C1)) != 0. */
12398 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12400 tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
12401 tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
12402 return fold_build2 (code, type, tem, arg1);
12404 /* Otherwise, for signed (arithmetic) shifts,
12405 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12406 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12407 else if (!TYPE_UNSIGNED (itype))
12408 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12409 arg000, build_int_cst (itype, 0));
12410 /* Otherwise, of unsigned (logical) shifts,
12411 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12412 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12414 return omit_one_operand (type,
12415 code == EQ_EXPR ? integer_one_node
12416 : integer_zero_node,
12421 /* If this is an NE comparison of zero with an AND of one, remove the
12422 comparison since the AND will give the correct value. */
12423 if (code == NE_EXPR
12424 && integer_zerop (arg1)
12425 && TREE_CODE (arg0) == BIT_AND_EXPR
12426 && integer_onep (TREE_OPERAND (arg0, 1)))
12427 return fold_convert (type, arg0);
12429 /* If we have (A & C) == C where C is a power of 2, convert this into
12430 (A & C) != 0. Similarly for NE_EXPR. */
12431 if (TREE_CODE (arg0) == BIT_AND_EXPR
12432 && integer_pow2p (TREE_OPERAND (arg0, 1))
12433 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12434 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12435 arg0, fold_convert (TREE_TYPE (arg0),
12436 integer_zero_node));
12438 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12439 bit, then fold the expression into A < 0 or A >= 0. */
12440 tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
12444 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12445 Similarly for NE_EXPR. */
12446 if (TREE_CODE (arg0) == BIT_AND_EXPR
12447 && TREE_CODE (arg1) == INTEGER_CST
12448 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12450 tree notc = fold_build1 (BIT_NOT_EXPR,
12451 TREE_TYPE (TREE_OPERAND (arg0, 1)),
12452 TREE_OPERAND (arg0, 1));
12453 tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12455 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12456 if (integer_nonzerop (dandnotc))
12457 return omit_one_operand (type, rslt, arg0);
12460 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12461 Similarly for NE_EXPR. */
12462 if (TREE_CODE (arg0) == BIT_IOR_EXPR
12463 && TREE_CODE (arg1) == INTEGER_CST
12464 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12466 tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12467 tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12468 TREE_OPERAND (arg0, 1), notd);
12469 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12470 if (integer_nonzerop (candnotd))
12471 return omit_one_operand (type, rslt, arg0);
12474 /* If this is a comparison of a field, we may be able to simplify it. */
12475 if ((TREE_CODE (arg0) == COMPONENT_REF
12476 || TREE_CODE (arg0) == BIT_FIELD_REF)
12477 /* Handle the constant case even without -O
12478 to make sure the warnings are given. */
12479 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12481 t1 = optimize_bit_field_compare (code, type, arg0, arg1);
12486 /* Optimize comparisons of strlen vs zero to a compare of the
12487 first character of the string vs zero. To wit,
12488 strlen(ptr) == 0 => *ptr == 0
12489 strlen(ptr) != 0 => *ptr != 0
12490 Other cases should reduce to one of these two (or a constant)
12491 due to the return value of strlen being unsigned. */
12492 if (TREE_CODE (arg0) == CALL_EXPR
12493 && integer_zerop (arg1))
12495 tree fndecl = get_callee_fndecl (arg0);
12498 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12499 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12500 && call_expr_nargs (arg0) == 1
12501 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12503 tree iref = build_fold_indirect_ref (CALL_EXPR_ARG (arg0, 0));
12504 return fold_build2 (code, type, iref,
12505 build_int_cst (TREE_TYPE (iref), 0));
12509 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12510 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12511 if (TREE_CODE (arg0) == RSHIFT_EXPR
12512 && integer_zerop (arg1)
12513 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12515 tree arg00 = TREE_OPERAND (arg0, 0);
12516 tree arg01 = TREE_OPERAND (arg0, 1);
12517 tree itype = TREE_TYPE (arg00);
12518 if (TREE_INT_CST_HIGH (arg01) == 0
12519 && TREE_INT_CST_LOW (arg01)
12520 == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
12522 if (TYPE_UNSIGNED (itype))
12524 itype = signed_type_for (itype);
12525 arg00 = fold_convert (itype, arg00);
12527 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12528 type, arg00, build_int_cst (itype, 0));
12532 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12533 if (integer_zerop (arg1)
12534 && TREE_CODE (arg0) == BIT_XOR_EXPR)
12535 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12536 TREE_OPERAND (arg0, 1));
12538 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12539 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12540 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12541 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12542 build_int_cst (TREE_TYPE (arg1), 0));
12543 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12544 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12545 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12546 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12547 return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
12548 build_int_cst (TREE_TYPE (arg1), 0));
12550 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
12551 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12552 && TREE_CODE (arg1) == INTEGER_CST
12553 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12554 return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12555 fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
12556 TREE_OPERAND (arg0, 1), arg1));
12558 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12559 (X & C) == 0 when C is a single bit. */
12560 if (TREE_CODE (arg0) == BIT_AND_EXPR
12561 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12562 && integer_zerop (arg1)
12563 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12565 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12566 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12567 TREE_OPERAND (arg0, 1));
12568 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12572 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12573 constant C is a power of two, i.e. a single bit. */
12574 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12575 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12576 && integer_zerop (arg1)
12577 && integer_pow2p (TREE_OPERAND (arg0, 1))
12578 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12579 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12581 tree arg00 = TREE_OPERAND (arg0, 0);
12582 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12583 arg00, build_int_cst (TREE_TYPE (arg00), 0));
12586 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12587 when is C is a power of two, i.e. a single bit. */
12588 if (TREE_CODE (arg0) == BIT_AND_EXPR
12589 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12590 && integer_zerop (arg1)
12591 && integer_pow2p (TREE_OPERAND (arg0, 1))
12592 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12593 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12595 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12596 tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
12597 arg000, TREE_OPERAND (arg0, 1));
12598 return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12599 tem, build_int_cst (TREE_TYPE (tem), 0));
12602 if (integer_zerop (arg1)
12603 && tree_expr_nonzero_p (arg0))
12605 tree res = constant_boolean_node (code==NE_EXPR, type);
12606 return omit_one_operand (type, res, arg0);
12609 /* Fold -X op -Y as X op Y, where op is eq/ne. */
12610 if (TREE_CODE (arg0) == NEGATE_EXPR
12611 && TREE_CODE (arg1) == NEGATE_EXPR)
12612 return fold_build2 (code, type,
12613 TREE_OPERAND (arg0, 0),
12614 TREE_OPERAND (arg1, 0));
12616 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
12617 if (TREE_CODE (arg0) == BIT_AND_EXPR
12618 && TREE_CODE (arg1) == BIT_AND_EXPR)
12620 tree arg00 = TREE_OPERAND (arg0, 0);
12621 tree arg01 = TREE_OPERAND (arg0, 1);
12622 tree arg10 = TREE_OPERAND (arg1, 0);
12623 tree arg11 = TREE_OPERAND (arg1, 1);
12624 tree itype = TREE_TYPE (arg0);
12626 if (operand_equal_p (arg01, arg11, 0))
12627 return fold_build2 (code, type,
12628 fold_build2 (BIT_AND_EXPR, itype,
12629 fold_build2 (BIT_XOR_EXPR, itype,
12632 build_int_cst (itype, 0));
12634 if (operand_equal_p (arg01, arg10, 0))
12635 return fold_build2 (code, type,
12636 fold_build2 (BIT_AND_EXPR, itype,
12637 fold_build2 (BIT_XOR_EXPR, itype,
12640 build_int_cst (itype, 0));
12642 if (operand_equal_p (arg00, arg11, 0))
12643 return fold_build2 (code, type,
12644 fold_build2 (BIT_AND_EXPR, itype,
12645 fold_build2 (BIT_XOR_EXPR, itype,
12648 build_int_cst (itype, 0));
12650 if (operand_equal_p (arg00, arg10, 0))
12651 return fold_build2 (code, type,
12652 fold_build2 (BIT_AND_EXPR, itype,
12653 fold_build2 (BIT_XOR_EXPR, itype,
12656 build_int_cst (itype, 0));
12659 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12660 && TREE_CODE (arg1) == BIT_XOR_EXPR)
12662 tree arg00 = TREE_OPERAND (arg0, 0);
12663 tree arg01 = TREE_OPERAND (arg0, 1);
12664 tree arg10 = TREE_OPERAND (arg1, 0);
12665 tree arg11 = TREE_OPERAND (arg1, 1);
12666 tree itype = TREE_TYPE (arg0);
12668 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12669 operand_equal_p guarantees no side-effects so we don't need
12670 to use omit_one_operand on Z. */
12671 if (operand_equal_p (arg01, arg11, 0))
12672 return fold_build2 (code, type, arg00, arg10);
12673 if (operand_equal_p (arg01, arg10, 0))
12674 return fold_build2 (code, type, arg00, arg11);
12675 if (operand_equal_p (arg00, arg11, 0))
12676 return fold_build2 (code, type, arg01, arg10);
12677 if (operand_equal_p (arg00, arg10, 0))
12678 return fold_build2 (code, type, arg01, arg11);
12680 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
12681 if (TREE_CODE (arg01) == INTEGER_CST
12682 && TREE_CODE (arg11) == INTEGER_CST)
12683 return fold_build2 (code, type,
12684 fold_build2 (BIT_XOR_EXPR, itype, arg00,
12685 fold_build2 (BIT_XOR_EXPR, itype,
12690 /* Attempt to simplify equality/inequality comparisons of complex
12691 values. Only lower the comparison if the result is known or
12692 can be simplified to a single scalar comparison. */
12693 if ((TREE_CODE (arg0) == COMPLEX_EXPR
12694 || TREE_CODE (arg0) == COMPLEX_CST)
12695 && (TREE_CODE (arg1) == COMPLEX_EXPR
12696 || TREE_CODE (arg1) == COMPLEX_CST))
12698 tree real0, imag0, real1, imag1;
12701 if (TREE_CODE (arg0) == COMPLEX_EXPR)
12703 real0 = TREE_OPERAND (arg0, 0);
12704 imag0 = TREE_OPERAND (arg0, 1);
12708 real0 = TREE_REALPART (arg0);
12709 imag0 = TREE_IMAGPART (arg0);
12712 if (TREE_CODE (arg1) == COMPLEX_EXPR)
12714 real1 = TREE_OPERAND (arg1, 0);
12715 imag1 = TREE_OPERAND (arg1, 1);
12719 real1 = TREE_REALPART (arg1);
12720 imag1 = TREE_IMAGPART (arg1);
12723 rcond = fold_binary (code, type, real0, real1);
12724 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
12726 if (integer_zerop (rcond))
12728 if (code == EQ_EXPR)
12729 return omit_two_operands (type, boolean_false_node,
12731 return fold_build2 (NE_EXPR, type, imag0, imag1);
12735 if (code == NE_EXPR)
12736 return omit_two_operands (type, boolean_true_node,
12738 return fold_build2 (EQ_EXPR, type, imag0, imag1);
12742 icond = fold_binary (code, type, imag0, imag1);
12743 if (icond && TREE_CODE (icond) == INTEGER_CST)
12745 if (integer_zerop (icond))
12747 if (code == EQ_EXPR)
12748 return omit_two_operands (type, boolean_false_node,
12750 return fold_build2 (NE_EXPR, type, real0, real1);
12754 if (code == NE_EXPR)
12755 return omit_two_operands (type, boolean_true_node,
12757 return fold_build2 (EQ_EXPR, type, real0, real1);
12768 tem = fold_comparison (code, type, op0, op1);
12769 if (tem != NULL_TREE)
12772 /* Transform comparisons of the form X +- C CMP X. */
12773 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
12774 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12775 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
12776 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
12777 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12778 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
12780 tree arg01 = TREE_OPERAND (arg0, 1);
12781 enum tree_code code0 = TREE_CODE (arg0);
12784 if (TREE_CODE (arg01) == REAL_CST)
12785 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
12787 is_positive = tree_int_cst_sgn (arg01);
12789 /* (X - c) > X becomes false. */
12790 if (code == GT_EXPR
12791 && ((code0 == MINUS_EXPR && is_positive >= 0)
12792 || (code0 == PLUS_EXPR && is_positive <= 0)))
12794 if (TREE_CODE (arg01) == INTEGER_CST
12795 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12796 fold_overflow_warning (("assuming signed overflow does not "
12797 "occur when assuming that (X - c) > X "
12798 "is always false"),
12799 WARN_STRICT_OVERFLOW_ALL);
12800 return constant_boolean_node (0, type);
12803 /* Likewise (X + c) < X becomes false. */
12804 if (code == LT_EXPR
12805 && ((code0 == PLUS_EXPR && is_positive >= 0)
12806 || (code0 == MINUS_EXPR && is_positive <= 0)))
12808 if (TREE_CODE (arg01) == INTEGER_CST
12809 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12810 fold_overflow_warning (("assuming signed overflow does not "
12811 "occur when assuming that "
12812 "(X + c) < X is always false"),
12813 WARN_STRICT_OVERFLOW_ALL);
12814 return constant_boolean_node (0, type);
12817 /* Convert (X - c) <= X to true. */
12818 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12820 && ((code0 == MINUS_EXPR && is_positive >= 0)
12821 || (code0 == PLUS_EXPR && is_positive <= 0)))
12823 if (TREE_CODE (arg01) == INTEGER_CST
12824 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12825 fold_overflow_warning (("assuming signed overflow does not "
12826 "occur when assuming that "
12827 "(X - c) <= X is always true"),
12828 WARN_STRICT_OVERFLOW_ALL);
12829 return constant_boolean_node (1, type);
12832 /* Convert (X + c) >= X to true. */
12833 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12835 && ((code0 == PLUS_EXPR && is_positive >= 0)
12836 || (code0 == MINUS_EXPR && is_positive <= 0)))
12838 if (TREE_CODE (arg01) == INTEGER_CST
12839 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12840 fold_overflow_warning (("assuming signed overflow does not "
12841 "occur when assuming that "
12842 "(X + c) >= X is always true"),
12843 WARN_STRICT_OVERFLOW_ALL);
12844 return constant_boolean_node (1, type);
12847 if (TREE_CODE (arg01) == INTEGER_CST)
12849 /* Convert X + c > X and X - c < X to true for integers. */
12850 if (code == GT_EXPR
12851 && ((code0 == PLUS_EXPR && is_positive > 0)
12852 || (code0 == MINUS_EXPR && is_positive < 0)))
12854 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12855 fold_overflow_warning (("assuming signed overflow does "
12856 "not occur when assuming that "
12857 "(X + c) > X is always true"),
12858 WARN_STRICT_OVERFLOW_ALL);
12859 return constant_boolean_node (1, type);
12862 if (code == LT_EXPR
12863 && ((code0 == MINUS_EXPR && is_positive > 0)
12864 || (code0 == PLUS_EXPR && is_positive < 0)))
12866 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12867 fold_overflow_warning (("assuming signed overflow does "
12868 "not occur when assuming that "
12869 "(X - c) < X is always true"),
12870 WARN_STRICT_OVERFLOW_ALL);
12871 return constant_boolean_node (1, type);
12874 /* Convert X + c <= X and X - c >= X to false for integers. */
12875 if (code == LE_EXPR
12876 && ((code0 == PLUS_EXPR && is_positive > 0)
12877 || (code0 == MINUS_EXPR && is_positive < 0)))
12879 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12880 fold_overflow_warning (("assuming signed overflow does "
12881 "not occur when assuming that "
12882 "(X + c) <= X is always false"),
12883 WARN_STRICT_OVERFLOW_ALL);
12884 return constant_boolean_node (0, type);
12887 if (code == GE_EXPR
12888 && ((code0 == MINUS_EXPR && is_positive > 0)
12889 || (code0 == PLUS_EXPR && is_positive < 0)))
12891 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12892 fold_overflow_warning (("assuming signed overflow does "
12893 "not occur when assuming that "
12894 "(X - c) >= X is always false"),
12895 WARN_STRICT_OVERFLOW_ALL);
12896 return constant_boolean_node (0, type);
12901 /* Comparisons with the highest or lowest possible integer of
12902 the specified precision will have known values. */
12904 tree arg1_type = TREE_TYPE (arg1);
12905 unsigned int width = TYPE_PRECISION (arg1_type);
12907 if (TREE_CODE (arg1) == INTEGER_CST
12908 && width <= 2 * HOST_BITS_PER_WIDE_INT
12909 && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
12911 HOST_WIDE_INT signed_max_hi;
12912 unsigned HOST_WIDE_INT signed_max_lo;
12913 unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
12915 if (width <= HOST_BITS_PER_WIDE_INT)
12917 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12922 if (TYPE_UNSIGNED (arg1_type))
12924 max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12930 max_lo = signed_max_lo;
12931 min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12937 width -= HOST_BITS_PER_WIDE_INT;
12938 signed_max_lo = -1;
12939 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12944 if (TYPE_UNSIGNED (arg1_type))
12946 max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12951 max_hi = signed_max_hi;
12952 min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12956 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
12957 && TREE_INT_CST_LOW (arg1) == max_lo)
12961 return omit_one_operand (type, integer_zero_node, arg0);
12964 return fold_build2 (EQ_EXPR, type, op0, op1);
12967 return omit_one_operand (type, integer_one_node, arg0);
12970 return fold_build2 (NE_EXPR, type, op0, op1);
12972 /* The GE_EXPR and LT_EXPR cases above are not normally
12973 reached because of previous transformations. */
12978 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12980 && TREE_INT_CST_LOW (arg1) == max_lo - 1)
12984 arg1 = const_binop (PLUS_EXPR, arg1,
12985 build_int_cst (TREE_TYPE (arg1), 1), 0);
12986 return fold_build2 (EQ_EXPR, type,
12987 fold_convert (TREE_TYPE (arg1), arg0),
12990 arg1 = const_binop (PLUS_EXPR, arg1,
12991 build_int_cst (TREE_TYPE (arg1), 1), 0);
12992 return fold_build2 (NE_EXPR, type,
12993 fold_convert (TREE_TYPE (arg1), arg0),
12998 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13000 && TREE_INT_CST_LOW (arg1) == min_lo)
13004 return omit_one_operand (type, integer_zero_node, arg0);
13007 return fold_build2 (EQ_EXPR, type, op0, op1);
13010 return omit_one_operand (type, integer_one_node, arg0);
13013 return fold_build2 (NE_EXPR, type, op0, op1);
13018 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13020 && TREE_INT_CST_LOW (arg1) == min_lo + 1)
13024 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
13025 return fold_build2 (NE_EXPR, type,
13026 fold_convert (TREE_TYPE (arg1), arg0),
13029 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
13030 return fold_build2 (EQ_EXPR, type,
13031 fold_convert (TREE_TYPE (arg1), arg0),
13037 else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
13038 && TREE_INT_CST_LOW (arg1) == signed_max_lo
13039 && TYPE_UNSIGNED (arg1_type)
13040 /* We will flip the signedness of the comparison operator
13041 associated with the mode of arg1, so the sign bit is
13042 specified by this mode. Check that arg1 is the signed
13043 max associated with this sign bit. */
13044 && width == GET_MODE_BITSIZE (TYPE_MODE (arg1_type))
13045 /* signed_type does not work on pointer types. */
13046 && INTEGRAL_TYPE_P (arg1_type))
13048 /* The following case also applies to X < signed_max+1
13049 and X >= signed_max+1 because previous transformations. */
13050 if (code == LE_EXPR || code == GT_EXPR)
13053 st = signed_type_for (TREE_TYPE (arg1));
13054 return fold_build2 (code == LE_EXPR ? GE_EXPR : LT_EXPR,
13055 type, fold_convert (st, arg0),
13056 build_int_cst (st, 0));
13062 /* If we are comparing an ABS_EXPR with a constant, we can
13063 convert all the cases into explicit comparisons, but they may
13064 well not be faster than doing the ABS and one comparison.
13065 But ABS (X) <= C is a range comparison, which becomes a subtraction
13066 and a comparison, and is probably faster. */
13067 if (code == LE_EXPR
13068 && TREE_CODE (arg1) == INTEGER_CST
13069 && TREE_CODE (arg0) == ABS_EXPR
13070 && ! TREE_SIDE_EFFECTS (arg0)
13071 && (0 != (tem = negate_expr (arg1)))
13072 && TREE_CODE (tem) == INTEGER_CST
13073 && !TREE_OVERFLOW (tem))
13074 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13075 build2 (GE_EXPR, type,
13076 TREE_OPERAND (arg0, 0), tem),
13077 build2 (LE_EXPR, type,
13078 TREE_OPERAND (arg0, 0), arg1));
13080 /* Convert ABS_EXPR<x> >= 0 to true. */
13081 strict_overflow_p = false;
13082 if (code == GE_EXPR
13083 && (integer_zerop (arg1)
13084 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13085 && real_zerop (arg1)))
13086 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13088 if (strict_overflow_p)
13089 fold_overflow_warning (("assuming signed overflow does not occur "
13090 "when simplifying comparison of "
13091 "absolute value and zero"),
13092 WARN_STRICT_OVERFLOW_CONDITIONAL);
13093 return omit_one_operand (type, integer_one_node, arg0);
13096 /* Convert ABS_EXPR<x> < 0 to false. */
13097 strict_overflow_p = false;
13098 if (code == LT_EXPR
13099 && (integer_zerop (arg1) || real_zerop (arg1))
13100 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13102 if (strict_overflow_p)
13103 fold_overflow_warning (("assuming signed overflow does not occur "
13104 "when simplifying comparison of "
13105 "absolute value and zero"),
13106 WARN_STRICT_OVERFLOW_CONDITIONAL);
13107 return omit_one_operand (type, integer_zero_node, arg0);
13110 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13111 and similarly for >= into !=. */
13112 if ((code == LT_EXPR || code == GE_EXPR)
13113 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13114 && TREE_CODE (arg1) == LSHIFT_EXPR
13115 && integer_onep (TREE_OPERAND (arg1, 0)))
13116 return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13117 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13118 TREE_OPERAND (arg1, 1)),
13119 build_int_cst (TREE_TYPE (arg0), 0));
13121 if ((code == LT_EXPR || code == GE_EXPR)
13122 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13123 && CONVERT_EXPR_P (arg1)
13124 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13125 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13127 build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13128 fold_convert (TREE_TYPE (arg0),
13129 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13130 TREE_OPERAND (TREE_OPERAND (arg1, 0),
13132 build_int_cst (TREE_TYPE (arg0), 0));
13136 case UNORDERED_EXPR:
13144 if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13146 t1 = fold_relational_const (code, type, arg0, arg1);
13147 if (t1 != NULL_TREE)
13151 /* If the first operand is NaN, the result is constant. */
13152 if (TREE_CODE (arg0) == REAL_CST
13153 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13154 && (code != LTGT_EXPR || ! flag_trapping_math))
13156 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13157 ? integer_zero_node
13158 : integer_one_node;
13159 return omit_one_operand (type, t1, arg1);
13162 /* If the second operand is NaN, the result is constant. */
13163 if (TREE_CODE (arg1) == REAL_CST
13164 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13165 && (code != LTGT_EXPR || ! flag_trapping_math))
13167 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13168 ? integer_zero_node
13169 : integer_one_node;
13170 return omit_one_operand (type, t1, arg0);
13173 /* Simplify unordered comparison of something with itself. */
13174 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13175 && operand_equal_p (arg0, arg1, 0))
13176 return constant_boolean_node (1, type);
13178 if (code == LTGT_EXPR
13179 && !flag_trapping_math
13180 && operand_equal_p (arg0, arg1, 0))
13181 return constant_boolean_node (0, type);
13183 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13185 tree targ0 = strip_float_extensions (arg0);
13186 tree targ1 = strip_float_extensions (arg1);
13187 tree newtype = TREE_TYPE (targ0);
13189 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13190 newtype = TREE_TYPE (targ1);
13192 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13193 return fold_build2 (code, type, fold_convert (newtype, targ0),
13194 fold_convert (newtype, targ1));
13199 case COMPOUND_EXPR:
13200 /* When pedantic, a compound expression can be neither an lvalue
13201 nor an integer constant expression. */
13202 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13204 /* Don't let (0, 0) be null pointer constant. */
13205 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13206 : fold_convert (type, arg1);
13207 return pedantic_non_lvalue (tem);
13210 if ((TREE_CODE (arg0) == REAL_CST
13211 && TREE_CODE (arg1) == REAL_CST)
13212 || (TREE_CODE (arg0) == INTEGER_CST
13213 && TREE_CODE (arg1) == INTEGER_CST))
13214 return build_complex (type, arg0, arg1);
13218 /* An ASSERT_EXPR should never be passed to fold_binary. */
13219 gcc_unreachable ();
13223 } /* switch (code) */
13226 /* Callback for walk_tree, looking for LABEL_EXPR.
13227 Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
13228 Do not check the sub-tree of GOTO_EXPR. */
13231 contains_label_1 (tree *tp,
13232 int *walk_subtrees,
13233 void *data ATTRIBUTE_UNUSED)
13235 switch (TREE_CODE (*tp))
13240 *walk_subtrees = 0;
13247 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
13248 accessible from outside the sub-tree. Returns NULL_TREE if no
13249 addressable label is found. */
13252 contains_label_p (tree st)
13254 return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
13257 /* Fold a ternary expression of code CODE and type TYPE with operands
13258 OP0, OP1, and OP2. Return the folded expression if folding is
13259 successful. Otherwise, return NULL_TREE. */
13262 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
13265 tree arg0 = NULL_TREE, arg1 = NULL_TREE;
13266 enum tree_code_class kind = TREE_CODE_CLASS (code);
13268 gcc_assert (IS_EXPR_CODE_CLASS (kind)
13269 && TREE_CODE_LENGTH (code) == 3);
13271 /* Strip any conversions that don't change the mode. This is safe
13272 for every expression, except for a comparison expression because
13273 its signedness is derived from its operands. So, in the latter
13274 case, only strip conversions that don't change the signedness.
13276 Note that this is done as an internal manipulation within the
13277 constant folder, in order to find the simplest representation of
13278 the arguments so that their form can be studied. In any cases,
13279 the appropriate type conversions should be put back in the tree
13280 that will get out of the constant folder. */
13295 case COMPONENT_REF:
13296 if (TREE_CODE (arg0) == CONSTRUCTOR
13297 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13299 unsigned HOST_WIDE_INT idx;
13301 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13308 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13309 so all simple results must be passed through pedantic_non_lvalue. */
13310 if (TREE_CODE (arg0) == INTEGER_CST)
13312 tree unused_op = integer_zerop (arg0) ? op1 : op2;
13313 tem = integer_zerop (arg0) ? op2 : op1;
13314 /* Only optimize constant conditions when the selected branch
13315 has the same type as the COND_EXPR. This avoids optimizing
13316 away "c ? x : throw", where the throw has a void type.
13317 Avoid throwing away that operand which contains label. */
13318 if ((!TREE_SIDE_EFFECTS (unused_op)
13319 || !contains_label_p (unused_op))
13320 && (! VOID_TYPE_P (TREE_TYPE (tem))
13321 || VOID_TYPE_P (type)))
13322 return pedantic_non_lvalue (tem);
13325 if (operand_equal_p (arg1, op2, 0))
13326 return pedantic_omit_one_operand (type, arg1, arg0);
13328 /* If we have A op B ? A : C, we may be able to convert this to a
13329 simpler expression, depending on the operation and the values
13330 of B and C. Signed zeros prevent all of these transformations,
13331 for reasons given above each one.
13333 Also try swapping the arguments and inverting the conditional. */
13334 if (COMPARISON_CLASS_P (arg0)
13335 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13336 arg1, TREE_OPERAND (arg0, 1))
13337 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13339 tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
13344 if (COMPARISON_CLASS_P (arg0)
13345 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13347 TREE_OPERAND (arg0, 1))
13348 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13350 tem = fold_truth_not_expr (arg0);
13351 if (tem && COMPARISON_CLASS_P (tem))
13353 tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
13359 /* If the second operand is simpler than the third, swap them
13360 since that produces better jump optimization results. */
13361 if (truth_value_p (TREE_CODE (arg0))
13362 && tree_swap_operands_p (op1, op2, false))
13364 /* See if this can be inverted. If it can't, possibly because
13365 it was a floating-point inequality comparison, don't do
13367 tem = fold_truth_not_expr (arg0);
13369 return fold_build3 (code, type, tem, op2, op1);
13372 /* Convert A ? 1 : 0 to simply A. */
13373 if (integer_onep (op1)
13374 && integer_zerop (op2)
13375 /* If we try to convert OP0 to our type, the
13376 call to fold will try to move the conversion inside
13377 a COND, which will recurse. In that case, the COND_EXPR
13378 is probably the best choice, so leave it alone. */
13379 && type == TREE_TYPE (arg0))
13380 return pedantic_non_lvalue (arg0);
13382 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13383 over COND_EXPR in cases such as floating point comparisons. */
13384 if (integer_zerop (op1)
13385 && integer_onep (op2)
13386 && truth_value_p (TREE_CODE (arg0)))
13387 return pedantic_non_lvalue (fold_convert (type,
13388 invert_truthvalue (arg0)));
13390 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13391 if (TREE_CODE (arg0) == LT_EXPR
13392 && integer_zerop (TREE_OPERAND (arg0, 1))
13393 && integer_zerop (op2)
13394 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13396 /* sign_bit_p only checks ARG1 bits within A's precision.
13397 If <sign bit of A> has wider type than A, bits outside
13398 of A's precision in <sign bit of A> need to be checked.
13399 If they are all 0, this optimization needs to be done
13400 in unsigned A's type, if they are all 1 in signed A's type,
13401 otherwise this can't be done. */
13402 if (TYPE_PRECISION (TREE_TYPE (tem))
13403 < TYPE_PRECISION (TREE_TYPE (arg1))
13404 && TYPE_PRECISION (TREE_TYPE (tem))
13405 < TYPE_PRECISION (type))
13407 unsigned HOST_WIDE_INT mask_lo;
13408 HOST_WIDE_INT mask_hi;
13409 int inner_width, outer_width;
13412 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13413 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13414 if (outer_width > TYPE_PRECISION (type))
13415 outer_width = TYPE_PRECISION (type);
13417 if (outer_width > HOST_BITS_PER_WIDE_INT)
13419 mask_hi = ((unsigned HOST_WIDE_INT) -1
13420 >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
13426 mask_lo = ((unsigned HOST_WIDE_INT) -1
13427 >> (HOST_BITS_PER_WIDE_INT - outer_width));
13429 if (inner_width > HOST_BITS_PER_WIDE_INT)
13431 mask_hi &= ~((unsigned HOST_WIDE_INT) -1
13432 >> (HOST_BITS_PER_WIDE_INT - inner_width));
13436 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
13437 >> (HOST_BITS_PER_WIDE_INT - inner_width));
13439 if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
13440 && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
13442 tem_type = signed_type_for (TREE_TYPE (tem));
13443 tem = fold_convert (tem_type, tem);
13445 else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
13446 && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
13448 tem_type = unsigned_type_for (TREE_TYPE (tem));
13449 tem = fold_convert (tem_type, tem);
13456 return fold_convert (type,
13457 fold_build2 (BIT_AND_EXPR,
13458 TREE_TYPE (tem), tem,
13459 fold_convert (TREE_TYPE (tem),
13463 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13464 already handled above. */
13465 if (TREE_CODE (arg0) == BIT_AND_EXPR
13466 && integer_onep (TREE_OPERAND (arg0, 1))
13467 && integer_zerop (op2)
13468 && integer_pow2p (arg1))
13470 tree tem = TREE_OPERAND (arg0, 0);
13472 if (TREE_CODE (tem) == RSHIFT_EXPR
13473 && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
13474 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13475 TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
13476 return fold_build2 (BIT_AND_EXPR, type,
13477 TREE_OPERAND (tem, 0), arg1);
13480 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13481 is probably obsolete because the first operand should be a
13482 truth value (that's why we have the two cases above), but let's
13483 leave it in until we can confirm this for all front-ends. */
13484 if (integer_zerop (op2)
13485 && TREE_CODE (arg0) == NE_EXPR
13486 && integer_zerop (TREE_OPERAND (arg0, 1))
13487 && integer_pow2p (arg1)
13488 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13489 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13490 arg1, OEP_ONLY_CONST))
13491 return pedantic_non_lvalue (fold_convert (type,
13492 TREE_OPERAND (arg0, 0)));
13494 /* Convert A ? B : 0 into A && B if A and B are truth values. */
13495 if (integer_zerop (op2)
13496 && truth_value_p (TREE_CODE (arg0))
13497 && truth_value_p (TREE_CODE (arg1)))
13498 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13499 fold_convert (type, arg0),
13502 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
13503 if (integer_onep (op2)
13504 && truth_value_p (TREE_CODE (arg0))
13505 && truth_value_p (TREE_CODE (arg1)))
13507 /* Only perform transformation if ARG0 is easily inverted. */
13508 tem = fold_truth_not_expr (arg0);
13510 return fold_build2 (TRUTH_ORIF_EXPR, type,
13511 fold_convert (type, tem),
13515 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
13516 if (integer_zerop (arg1)
13517 && truth_value_p (TREE_CODE (arg0))
13518 && truth_value_p (TREE_CODE (op2)))
13520 /* Only perform transformation if ARG0 is easily inverted. */
13521 tem = fold_truth_not_expr (arg0);
13523 return fold_build2 (TRUTH_ANDIF_EXPR, type,
13524 fold_convert (type, tem),
13528 /* Convert A ? 1 : B into A || B if A and B are truth values. */
13529 if (integer_onep (arg1)
13530 && truth_value_p (TREE_CODE (arg0))
13531 && truth_value_p (TREE_CODE (op2)))
13532 return fold_build2 (TRUTH_ORIF_EXPR, type,
13533 fold_convert (type, arg0),
13539 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
13540 of fold_ternary on them. */
13541 gcc_unreachable ();
13543 case BIT_FIELD_REF:
13544 if ((TREE_CODE (arg0) == VECTOR_CST
13545 || (TREE_CODE (arg0) == CONSTRUCTOR && TREE_CONSTANT (arg0)))
13546 && type == TREE_TYPE (TREE_TYPE (arg0)))
13548 unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
13549 unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
13552 && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
13553 && (idx % width) == 0
13554 && (idx = idx / width)
13555 < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
13557 tree elements = NULL_TREE;
13559 if (TREE_CODE (arg0) == VECTOR_CST)
13560 elements = TREE_VECTOR_CST_ELTS (arg0);
13563 unsigned HOST_WIDE_INT idx;
13566 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg0), idx, value)
13567 elements = tree_cons (NULL_TREE, value, elements);
13569 while (idx-- > 0 && elements)
13570 elements = TREE_CHAIN (elements);
13572 return TREE_VALUE (elements);
13574 return fold_convert (type, integer_zero_node);
13578 /* A bit-field-ref that referenced the full argument can be stripped. */
13579 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
13580 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_low_cst (arg1, 1)
13581 && integer_zerop (op2))
13582 return fold_convert (type, arg0);
13588 } /* switch (code) */
13591 /* Perform constant folding and related simplification of EXPR.
13592 The related simplifications include x*1 => x, x*0 => 0, etc.,
13593 and application of the associative law.
13594 NOP_EXPR conversions may be removed freely (as long as we
13595 are careful not to change the type of the overall expression).
13596 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
13597 but we can constant-fold them if they have constant operands. */
13599 #ifdef ENABLE_FOLD_CHECKING
13600 # define fold(x) fold_1 (x)
13601 static tree fold_1 (tree);
13607 const tree t = expr;
13608 enum tree_code code = TREE_CODE (t);
13609 enum tree_code_class kind = TREE_CODE_CLASS (code);
13612 /* Return right away if a constant. */
13613 if (kind == tcc_constant)
13616 /* CALL_EXPR-like objects with variable numbers of operands are
13617 treated specially. */
13618 if (kind == tcc_vl_exp)
13620 if (code == CALL_EXPR)
13622 tem = fold_call_expr (expr, false);
13623 return tem ? tem : expr;
13628 if (IS_EXPR_CODE_CLASS (kind))
13630 tree type = TREE_TYPE (t);
13631 tree op0, op1, op2;
13633 switch (TREE_CODE_LENGTH (code))
13636 op0 = TREE_OPERAND (t, 0);
13637 tem = fold_unary (code, type, op0);
13638 return tem ? tem : expr;
13640 op0 = TREE_OPERAND (t, 0);
13641 op1 = TREE_OPERAND (t, 1);
13642 tem = fold_binary (code, type, op0, op1);
13643 return tem ? tem : expr;
13645 op0 = TREE_OPERAND (t, 0);
13646 op1 = TREE_OPERAND (t, 1);
13647 op2 = TREE_OPERAND (t, 2);
13648 tem = fold_ternary (code, type, op0, op1, op2);
13649 return tem ? tem : expr;
13659 tree op0 = TREE_OPERAND (t, 0);
13660 tree op1 = TREE_OPERAND (t, 1);
13662 if (TREE_CODE (op1) == INTEGER_CST
13663 && TREE_CODE (op0) == CONSTRUCTOR
13664 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
13666 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (op0);
13667 unsigned HOST_WIDE_INT end = VEC_length (constructor_elt, elts);
13668 unsigned HOST_WIDE_INT begin = 0;
13670 /* Find a matching index by means of a binary search. */
13671 while (begin != end)
13673 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
13674 tree index = VEC_index (constructor_elt, elts, middle)->index;
13676 if (TREE_CODE (index) == INTEGER_CST
13677 && tree_int_cst_lt (index, op1))
13678 begin = middle + 1;
13679 else if (TREE_CODE (index) == INTEGER_CST
13680 && tree_int_cst_lt (op1, index))
13682 else if (TREE_CODE (index) == RANGE_EXPR
13683 && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
13684 begin = middle + 1;
13685 else if (TREE_CODE (index) == RANGE_EXPR
13686 && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
13689 return VEC_index (constructor_elt, elts, middle)->value;
13697 return fold (DECL_INITIAL (t));
13701 } /* switch (code) */
13704 #ifdef ENABLE_FOLD_CHECKING
13707 static void fold_checksum_tree (const_tree, struct md5_ctx *, htab_t);
13708 static void fold_check_failed (const_tree, const_tree);
13709 void print_fold_checksum (const_tree);
13711 /* When --enable-checking=fold, compute a digest of expr before
13712 and after actual fold call to see if fold did not accidentally
13713 change original expr. */
13719 struct md5_ctx ctx;
13720 unsigned char checksum_before[16], checksum_after[16];
13723 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13724 md5_init_ctx (&ctx);
13725 fold_checksum_tree (expr, &ctx, ht);
13726 md5_finish_ctx (&ctx, checksum_before);
13729 ret = fold_1 (expr);
13731 md5_init_ctx (&ctx);
13732 fold_checksum_tree (expr, &ctx, ht);
13733 md5_finish_ctx (&ctx, checksum_after);
13736 if (memcmp (checksum_before, checksum_after, 16))
13737 fold_check_failed (expr, ret);
13743 print_fold_checksum (const_tree expr)
13745 struct md5_ctx ctx;
13746 unsigned char checksum[16], cnt;
13749 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13750 md5_init_ctx (&ctx);
13751 fold_checksum_tree (expr, &ctx, ht);
13752 md5_finish_ctx (&ctx, checksum);
13754 for (cnt = 0; cnt < 16; ++cnt)
13755 fprintf (stderr, "%02x", checksum[cnt]);
13756 putc ('\n', stderr);
13760 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
13762 internal_error ("fold check: original tree changed by fold");
13766 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, htab_t ht)
13769 enum tree_code code;
13770 union tree_node buf;
13775 gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
13776 <= sizeof (struct tree_function_decl))
13777 && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
13780 slot = (const void **) htab_find_slot (ht, expr, INSERT);
13784 code = TREE_CODE (expr);
13785 if (TREE_CODE_CLASS (code) == tcc_declaration
13786 && DECL_ASSEMBLER_NAME_SET_P (expr))
13788 /* Allow DECL_ASSEMBLER_NAME to be modified. */
13789 memcpy ((char *) &buf, expr, tree_size (expr));
13790 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
13791 expr = (tree) &buf;
13793 else if (TREE_CODE_CLASS (code) == tcc_type
13794 && (TYPE_POINTER_TO (expr)
13795 || TYPE_REFERENCE_TO (expr)
13796 || TYPE_CACHED_VALUES_P (expr)
13797 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
13798 || TYPE_NEXT_VARIANT (expr)))
13800 /* Allow these fields to be modified. */
13802 memcpy ((char *) &buf, expr, tree_size (expr));
13803 expr = tmp = (tree) &buf;
13804 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
13805 TYPE_POINTER_TO (tmp) = NULL;
13806 TYPE_REFERENCE_TO (tmp) = NULL;
13807 TYPE_NEXT_VARIANT (tmp) = NULL;
13808 if (TYPE_CACHED_VALUES_P (tmp))
13810 TYPE_CACHED_VALUES_P (tmp) = 0;
13811 TYPE_CACHED_VALUES (tmp) = NULL;
13814 md5_process_bytes (expr, tree_size (expr), ctx);
13815 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
13816 if (TREE_CODE_CLASS (code) != tcc_type
13817 && TREE_CODE_CLASS (code) != tcc_declaration
13818 && code != TREE_LIST
13819 && code != SSA_NAME)
13820 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
13821 switch (TREE_CODE_CLASS (code))
13827 md5_process_bytes (TREE_STRING_POINTER (expr),
13828 TREE_STRING_LENGTH (expr), ctx);
13831 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
13832 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
13835 fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
13841 case tcc_exceptional:
13845 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
13846 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
13847 expr = TREE_CHAIN (expr);
13848 goto recursive_label;
13851 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
13852 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
13858 case tcc_expression:
13859 case tcc_reference:
13860 case tcc_comparison:
13863 case tcc_statement:
13865 len = TREE_OPERAND_LENGTH (expr);
13866 for (i = 0; i < len; ++i)
13867 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
13869 case tcc_declaration:
13870 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
13871 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
13872 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
13874 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
13875 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
13876 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
13877 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
13878 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
13880 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
13881 fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
13883 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
13885 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
13886 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
13887 fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
13891 if (TREE_CODE (expr) == ENUMERAL_TYPE)
13892 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
13893 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
13894 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
13895 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
13896 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
13897 if (INTEGRAL_TYPE_P (expr)
13898 || SCALAR_FLOAT_TYPE_P (expr))
13900 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
13901 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
13903 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
13904 if (TREE_CODE (expr) == RECORD_TYPE
13905 || TREE_CODE (expr) == UNION_TYPE
13906 || TREE_CODE (expr) == QUAL_UNION_TYPE)
13907 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
13908 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
13915 /* Helper function for outputting the checksum of a tree T. When
13916 debugging with gdb, you can "define mynext" to be "next" followed
13917 by "call debug_fold_checksum (op0)", then just trace down till the
13921 debug_fold_checksum (const_tree t)
13924 unsigned char checksum[16];
13925 struct md5_ctx ctx;
13926 htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13928 md5_init_ctx (&ctx);
13929 fold_checksum_tree (t, &ctx, ht);
13930 md5_finish_ctx (&ctx, checksum);
13933 for (i = 0; i < 16; i++)
13934 fprintf (stderr, "%d ", checksum[i]);
13936 fprintf (stderr, "\n");
13941 /* Fold a unary tree expression with code CODE of type TYPE with an
13942 operand OP0. Return a folded expression if successful. Otherwise,
13943 return a tree expression with code CODE of type TYPE with an
13947 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
13950 #ifdef ENABLE_FOLD_CHECKING
13951 unsigned char checksum_before[16], checksum_after[16];
13952 struct md5_ctx ctx;
13955 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13956 md5_init_ctx (&ctx);
13957 fold_checksum_tree (op0, &ctx, ht);
13958 md5_finish_ctx (&ctx, checksum_before);
13962 tem = fold_unary (code, type, op0);
13964 tem = build1_stat (code, type, op0 PASS_MEM_STAT);
13966 #ifdef ENABLE_FOLD_CHECKING
13967 md5_init_ctx (&ctx);
13968 fold_checksum_tree (op0, &ctx, ht);
13969 md5_finish_ctx (&ctx, checksum_after);
13972 if (memcmp (checksum_before, checksum_after, 16))
13973 fold_check_failed (op0, tem);
13978 /* Fold a binary tree expression with code CODE of type TYPE with
13979 operands OP0 and OP1. Return a folded expression if successful.
13980 Otherwise, return a tree expression with code CODE of type TYPE
13981 with operands OP0 and OP1. */
13984 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
13988 #ifdef ENABLE_FOLD_CHECKING
13989 unsigned char checksum_before_op0[16],
13990 checksum_before_op1[16],
13991 checksum_after_op0[16],
13992 checksum_after_op1[16];
13993 struct md5_ctx ctx;
13996 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13997 md5_init_ctx (&ctx);
13998 fold_checksum_tree (op0, &ctx, ht);
13999 md5_finish_ctx (&ctx, checksum_before_op0);
14002 md5_init_ctx (&ctx);
14003 fold_checksum_tree (op1, &ctx, ht);
14004 md5_finish_ctx (&ctx, checksum_before_op1);
14008 tem = fold_binary (code, type, op0, op1);
14010 tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
14012 #ifdef ENABLE_FOLD_CHECKING
14013 md5_init_ctx (&ctx);
14014 fold_checksum_tree (op0, &ctx, ht);
14015 md5_finish_ctx (&ctx, checksum_after_op0);
14018 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14019 fold_check_failed (op0, tem);
14021 md5_init_ctx (&ctx);
14022 fold_checksum_tree (op1, &ctx, ht);
14023 md5_finish_ctx (&ctx, checksum_after_op1);
14026 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14027 fold_check_failed (op1, tem);
14032 /* Fold a ternary tree expression with code CODE of type TYPE with
14033 operands OP0, OP1, and OP2. Return a folded expression if
14034 successful. Otherwise, return a tree expression with code CODE of
14035 type TYPE with operands OP0, OP1, and OP2. */
14038 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
14042 #ifdef ENABLE_FOLD_CHECKING
14043 unsigned char checksum_before_op0[16],
14044 checksum_before_op1[16],
14045 checksum_before_op2[16],
14046 checksum_after_op0[16],
14047 checksum_after_op1[16],
14048 checksum_after_op2[16];
14049 struct md5_ctx ctx;
14052 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14053 md5_init_ctx (&ctx);
14054 fold_checksum_tree (op0, &ctx, ht);
14055 md5_finish_ctx (&ctx, checksum_before_op0);
14058 md5_init_ctx (&ctx);
14059 fold_checksum_tree (op1, &ctx, ht);
14060 md5_finish_ctx (&ctx, checksum_before_op1);
14063 md5_init_ctx (&ctx);
14064 fold_checksum_tree (op2, &ctx, ht);
14065 md5_finish_ctx (&ctx, checksum_before_op2);
14069 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14070 tem = fold_ternary (code, type, op0, op1, op2);
14072 tem = build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
14074 #ifdef ENABLE_FOLD_CHECKING
14075 md5_init_ctx (&ctx);
14076 fold_checksum_tree (op0, &ctx, ht);
14077 md5_finish_ctx (&ctx, checksum_after_op0);
14080 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14081 fold_check_failed (op0, tem);
14083 md5_init_ctx (&ctx);
14084 fold_checksum_tree (op1, &ctx, ht);
14085 md5_finish_ctx (&ctx, checksum_after_op1);
14088 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14089 fold_check_failed (op1, tem);
14091 md5_init_ctx (&ctx);
14092 fold_checksum_tree (op2, &ctx, ht);
14093 md5_finish_ctx (&ctx, checksum_after_op2);
14096 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14097 fold_check_failed (op2, tem);
14102 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14103 arguments in ARGARRAY, and a null static chain.
14104 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14105 of type TYPE from the given operands as constructed by build_call_array. */
14108 fold_build_call_array (tree type, tree fn, int nargs, tree *argarray)
14111 #ifdef ENABLE_FOLD_CHECKING
14112 unsigned char checksum_before_fn[16],
14113 checksum_before_arglist[16],
14114 checksum_after_fn[16],
14115 checksum_after_arglist[16];
14116 struct md5_ctx ctx;
14120 ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14121 md5_init_ctx (&ctx);
14122 fold_checksum_tree (fn, &ctx, ht);
14123 md5_finish_ctx (&ctx, checksum_before_fn);
14126 md5_init_ctx (&ctx);
14127 for (i = 0; i < nargs; i++)
14128 fold_checksum_tree (argarray[i], &ctx, ht);
14129 md5_finish_ctx (&ctx, checksum_before_arglist);
14133 tem = fold_builtin_call_array (type, fn, nargs, argarray);
14135 #ifdef ENABLE_FOLD_CHECKING
14136 md5_init_ctx (&ctx);
14137 fold_checksum_tree (fn, &ctx, ht);
14138 md5_finish_ctx (&ctx, checksum_after_fn);
14141 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14142 fold_check_failed (fn, tem);
14144 md5_init_ctx (&ctx);
14145 for (i = 0; i < nargs; i++)
14146 fold_checksum_tree (argarray[i], &ctx, ht);
14147 md5_finish_ctx (&ctx, checksum_after_arglist);
14150 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14151 fold_check_failed (NULL_TREE, tem);
14156 /* Perform constant folding and related simplification of initializer
14157 expression EXPR. These behave identically to "fold_buildN" but ignore
14158 potential run-time traps and exceptions that fold must preserve. */
14160 #define START_FOLD_INIT \
14161 int saved_signaling_nans = flag_signaling_nans;\
14162 int saved_trapping_math = flag_trapping_math;\
14163 int saved_rounding_math = flag_rounding_math;\
14164 int saved_trapv = flag_trapv;\
14165 int saved_folding_initializer = folding_initializer;\
14166 flag_signaling_nans = 0;\
14167 flag_trapping_math = 0;\
14168 flag_rounding_math = 0;\
14170 folding_initializer = 1;
14172 #define END_FOLD_INIT \
14173 flag_signaling_nans = saved_signaling_nans;\
14174 flag_trapping_math = saved_trapping_math;\
14175 flag_rounding_math = saved_rounding_math;\
14176 flag_trapv = saved_trapv;\
14177 folding_initializer = saved_folding_initializer;
14180 fold_build1_initializer (enum tree_code code, tree type, tree op)
14185 result = fold_build1 (code, type, op);
14192 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
14197 result = fold_build2 (code, type, op0, op1);
14204 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
14210 result = fold_build3 (code, type, op0, op1, op2);
14217 fold_build_call_array_initializer (tree type, tree fn,
14218 int nargs, tree *argarray)
14223 result = fold_build_call_array (type, fn, nargs, argarray);
14229 #undef START_FOLD_INIT
14230 #undef END_FOLD_INIT
14232 /* Determine if first argument is a multiple of second argument. Return 0 if
14233 it is not, or we cannot easily determined it to be.
14235 An example of the sort of thing we care about (at this point; this routine
14236 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14237 fold cases do now) is discovering that
14239 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14245 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14247 This code also handles discovering that
14249 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14251 is a multiple of 8 so we don't have to worry about dealing with a
14252 possible remainder.
14254 Note that we *look* inside a SAVE_EXPR only to determine how it was
14255 calculated; it is not safe for fold to do much of anything else with the
14256 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14257 at run time. For example, the latter example above *cannot* be implemented
14258 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14259 evaluation time of the original SAVE_EXPR is not necessarily the same at
14260 the time the new expression is evaluated. The only optimization of this
14261 sort that would be valid is changing
14263 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14267 SAVE_EXPR (I) * SAVE_EXPR (J)
14269 (where the same SAVE_EXPR (J) is used in the original and the
14270 transformed version). */
14273 multiple_of_p (tree type, const_tree top, const_tree bottom)
14275 if (operand_equal_p (top, bottom, 0))
14278 if (TREE_CODE (type) != INTEGER_TYPE)
14281 switch (TREE_CODE (top))
14284 /* Bitwise and provides a power of two multiple. If the mask is
14285 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
14286 if (!integer_pow2p (bottom))
14291 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14292 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14296 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14297 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14300 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
14304 op1 = TREE_OPERAND (top, 1);
14305 /* const_binop may not detect overflow correctly,
14306 so check for it explicitly here. */
14307 if (TYPE_PRECISION (TREE_TYPE (size_one_node))
14308 > TREE_INT_CST_LOW (op1)
14309 && TREE_INT_CST_HIGH (op1) == 0
14310 && 0 != (t1 = fold_convert (type,
14311 const_binop (LSHIFT_EXPR,
14314 && !TREE_OVERFLOW (t1))
14315 return multiple_of_p (type, t1, bottom);
14320 /* Can't handle conversions from non-integral or wider integral type. */
14321 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
14322 || (TYPE_PRECISION (type)
14323 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
14326 /* .. fall through ... */
14329 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
14332 if (TREE_CODE (bottom) != INTEGER_CST
14333 || integer_zerop (bottom)
14334 || (TYPE_UNSIGNED (type)
14335 && (tree_int_cst_sgn (top) < 0
14336 || tree_int_cst_sgn (bottom) < 0)))
14338 return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
14346 /* Return true if CODE or TYPE is known to be non-negative. */
14349 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
14351 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
14352 && truth_value_p (code))
14353 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14354 have a signed:1 type (where the value is -1 and 0). */
14359 /* Return true if (CODE OP0) is known to be non-negative. If the return
14360 value is based on the assumption that signed overflow is undefined,
14361 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14362 *STRICT_OVERFLOW_P. */
14365 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14366 bool *strict_overflow_p)
14368 if (TYPE_UNSIGNED (type))
14374 /* We can't return 1 if flag_wrapv is set because
14375 ABS_EXPR<INT_MIN> = INT_MIN. */
14376 if (!INTEGRAL_TYPE_P (type))
14378 if (TYPE_OVERFLOW_UNDEFINED (type))
14380 *strict_overflow_p = true;
14385 case NON_LVALUE_EXPR:
14387 case FIX_TRUNC_EXPR:
14388 return tree_expr_nonnegative_warnv_p (op0,
14389 strict_overflow_p);
14393 tree inner_type = TREE_TYPE (op0);
14394 tree outer_type = type;
14396 if (TREE_CODE (outer_type) == REAL_TYPE)
14398 if (TREE_CODE (inner_type) == REAL_TYPE)
14399 return tree_expr_nonnegative_warnv_p (op0,
14400 strict_overflow_p);
14401 if (TREE_CODE (inner_type) == INTEGER_TYPE)
14403 if (TYPE_UNSIGNED (inner_type))
14405 return tree_expr_nonnegative_warnv_p (op0,
14406 strict_overflow_p);
14409 else if (TREE_CODE (outer_type) == INTEGER_TYPE)
14411 if (TREE_CODE (inner_type) == REAL_TYPE)
14412 return tree_expr_nonnegative_warnv_p (op0,
14413 strict_overflow_p);
14414 if (TREE_CODE (inner_type) == INTEGER_TYPE)
14415 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
14416 && TYPE_UNSIGNED (inner_type);
14422 return tree_simple_nonnegative_warnv_p (code, type);
14425 /* We don't know sign of `t', so be conservative and return false. */
14429 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
14430 value is based on the assumption that signed overflow is undefined,
14431 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14432 *STRICT_OVERFLOW_P. */
14435 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14436 tree op1, bool *strict_overflow_p)
14438 if (TYPE_UNSIGNED (type))
14443 case POINTER_PLUS_EXPR:
14445 if (FLOAT_TYPE_P (type))
14446 return (tree_expr_nonnegative_warnv_p (op0,
14448 && tree_expr_nonnegative_warnv_p (op1,
14449 strict_overflow_p));
14451 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14452 both unsigned and at least 2 bits shorter than the result. */
14453 if (TREE_CODE (type) == INTEGER_TYPE
14454 && TREE_CODE (op0) == NOP_EXPR
14455 && TREE_CODE (op1) == NOP_EXPR)
14457 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
14458 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
14459 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14460 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14462 unsigned int prec = MAX (TYPE_PRECISION (inner1),
14463 TYPE_PRECISION (inner2)) + 1;
14464 return prec < TYPE_PRECISION (type);
14470 if (FLOAT_TYPE_P (type))
14472 /* x * x for floating point x is always non-negative. */
14473 if (operand_equal_p (op0, op1, 0))
14475 return (tree_expr_nonnegative_warnv_p (op0,
14477 && tree_expr_nonnegative_warnv_p (op1,
14478 strict_overflow_p));
14481 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14482 both unsigned and their total bits is shorter than the result. */
14483 if (TREE_CODE (type) == INTEGER_TYPE
14484 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
14485 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
14487 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
14488 ? TREE_TYPE (TREE_OPERAND (op0, 0))
14490 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
14491 ? TREE_TYPE (TREE_OPERAND (op1, 0))
14494 bool unsigned0 = TYPE_UNSIGNED (inner0);
14495 bool unsigned1 = TYPE_UNSIGNED (inner1);
14497 if (TREE_CODE (op0) == INTEGER_CST)
14498 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
14500 if (TREE_CODE (op1) == INTEGER_CST)
14501 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
14503 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
14504 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
14506 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
14507 ? tree_int_cst_min_precision (op0, /*unsignedp=*/true)
14508 : TYPE_PRECISION (inner0);
14510 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
14511 ? tree_int_cst_min_precision (op1, /*unsignedp=*/true)
14512 : TYPE_PRECISION (inner1);
14514 return precision0 + precision1 < TYPE_PRECISION (type);
14521 return (tree_expr_nonnegative_warnv_p (op0,
14523 || tree_expr_nonnegative_warnv_p (op1,
14524 strict_overflow_p));
14530 case TRUNC_DIV_EXPR:
14531 case CEIL_DIV_EXPR:
14532 case FLOOR_DIV_EXPR:
14533 case ROUND_DIV_EXPR:
14534 return (tree_expr_nonnegative_warnv_p (op0,
14536 && tree_expr_nonnegative_warnv_p (op1,
14537 strict_overflow_p));
14539 case TRUNC_MOD_EXPR:
14540 case CEIL_MOD_EXPR:
14541 case FLOOR_MOD_EXPR:
14542 case ROUND_MOD_EXPR:
14543 return tree_expr_nonnegative_warnv_p (op0,
14544 strict_overflow_p);
14546 return tree_simple_nonnegative_warnv_p (code, type);
14549 /* We don't know sign of `t', so be conservative and return false. */
14553 /* Return true if T is known to be non-negative. If the return
14554 value is based on the assumption that signed overflow is undefined,
14555 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14556 *STRICT_OVERFLOW_P. */
14559 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14561 if (TYPE_UNSIGNED (TREE_TYPE (t)))
14564 switch (TREE_CODE (t))
14567 return tree_int_cst_sgn (t) >= 0;
14570 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
14573 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
14576 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14578 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
14579 strict_overflow_p));
14581 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14584 /* We don't know sign of `t', so be conservative and return false. */
14588 /* Return true if T is known to be non-negative. If the return
14589 value is based on the assumption that signed overflow is undefined,
14590 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14591 *STRICT_OVERFLOW_P. */
14594 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
14595 tree arg0, tree arg1, bool *strict_overflow_p)
14597 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
14598 switch (DECL_FUNCTION_CODE (fndecl))
14600 CASE_FLT_FN (BUILT_IN_ACOS):
14601 CASE_FLT_FN (BUILT_IN_ACOSH):
14602 CASE_FLT_FN (BUILT_IN_CABS):
14603 CASE_FLT_FN (BUILT_IN_COSH):
14604 CASE_FLT_FN (BUILT_IN_ERFC):
14605 CASE_FLT_FN (BUILT_IN_EXP):
14606 CASE_FLT_FN (BUILT_IN_EXP10):
14607 CASE_FLT_FN (BUILT_IN_EXP2):
14608 CASE_FLT_FN (BUILT_IN_FABS):
14609 CASE_FLT_FN (BUILT_IN_FDIM):
14610 CASE_FLT_FN (BUILT_IN_HYPOT):
14611 CASE_FLT_FN (BUILT_IN_POW10):
14612 CASE_INT_FN (BUILT_IN_FFS):
14613 CASE_INT_FN (BUILT_IN_PARITY):
14614 CASE_INT_FN (BUILT_IN_POPCOUNT):
14615 case BUILT_IN_BSWAP32:
14616 case BUILT_IN_BSWAP64:
14620 CASE_FLT_FN (BUILT_IN_SQRT):
14621 /* sqrt(-0.0) is -0.0. */
14622 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
14624 return tree_expr_nonnegative_warnv_p (arg0,
14625 strict_overflow_p);
14627 CASE_FLT_FN (BUILT_IN_ASINH):
14628 CASE_FLT_FN (BUILT_IN_ATAN):
14629 CASE_FLT_FN (BUILT_IN_ATANH):
14630 CASE_FLT_FN (BUILT_IN_CBRT):
14631 CASE_FLT_FN (BUILT_IN_CEIL):
14632 CASE_FLT_FN (BUILT_IN_ERF):
14633 CASE_FLT_FN (BUILT_IN_EXPM1):
14634 CASE_FLT_FN (BUILT_IN_FLOOR):
14635 CASE_FLT_FN (BUILT_IN_FMOD):
14636 CASE_FLT_FN (BUILT_IN_FREXP):
14637 CASE_FLT_FN (BUILT_IN_LCEIL):
14638 CASE_FLT_FN (BUILT_IN_LDEXP):
14639 CASE_FLT_FN (BUILT_IN_LFLOOR):
14640 CASE_FLT_FN (BUILT_IN_LLCEIL):
14641 CASE_FLT_FN (BUILT_IN_LLFLOOR):
14642 CASE_FLT_FN (BUILT_IN_LLRINT):
14643 CASE_FLT_FN (BUILT_IN_LLROUND):
14644 CASE_FLT_FN (BUILT_IN_LRINT):
14645 CASE_FLT_FN (BUILT_IN_LROUND):
14646 CASE_FLT_FN (BUILT_IN_MODF):
14647 CASE_FLT_FN (BUILT_IN_NEARBYINT):
14648 CASE_FLT_FN (BUILT_IN_RINT):
14649 CASE_FLT_FN (BUILT_IN_ROUND):
14650 CASE_FLT_FN (BUILT_IN_SCALB):
14651 CASE_FLT_FN (BUILT_IN_SCALBLN):
14652 CASE_FLT_FN (BUILT_IN_SCALBN):
14653 CASE_FLT_FN (BUILT_IN_SIGNBIT):
14654 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
14655 CASE_FLT_FN (BUILT_IN_SINH):
14656 CASE_FLT_FN (BUILT_IN_TANH):
14657 CASE_FLT_FN (BUILT_IN_TRUNC):
14658 /* True if the 1st argument is nonnegative. */
14659 return tree_expr_nonnegative_warnv_p (arg0,
14660 strict_overflow_p);
14662 CASE_FLT_FN (BUILT_IN_FMAX):
14663 /* True if the 1st OR 2nd arguments are nonnegative. */
14664 return (tree_expr_nonnegative_warnv_p (arg0,
14666 || (tree_expr_nonnegative_warnv_p (arg1,
14667 strict_overflow_p)));
14669 CASE_FLT_FN (BUILT_IN_FMIN):
14670 /* True if the 1st AND 2nd arguments are nonnegative. */
14671 return (tree_expr_nonnegative_warnv_p (arg0,
14673 && (tree_expr_nonnegative_warnv_p (arg1,
14674 strict_overflow_p)));
14676 CASE_FLT_FN (BUILT_IN_COPYSIGN):
14677 /* True if the 2nd argument is nonnegative. */
14678 return tree_expr_nonnegative_warnv_p (arg1,
14679 strict_overflow_p);
14681 CASE_FLT_FN (BUILT_IN_POWI):
14682 /* True if the 1st argument is nonnegative or the second
14683 argument is an even integer. */
14684 if (TREE_CODE (arg1) == INTEGER_CST
14685 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
14687 return tree_expr_nonnegative_warnv_p (arg0,
14688 strict_overflow_p);
14690 CASE_FLT_FN (BUILT_IN_POW):
14691 /* True if the 1st argument is nonnegative or the second
14692 argument is an even integer valued real. */
14693 if (TREE_CODE (arg1) == REAL_CST)
14698 c = TREE_REAL_CST (arg1);
14699 n = real_to_integer (&c);
14702 REAL_VALUE_TYPE cint;
14703 real_from_integer (&cint, VOIDmode, n,
14704 n < 0 ? -1 : 0, 0);
14705 if (real_identical (&c, &cint))
14709 return tree_expr_nonnegative_warnv_p (arg0,
14710 strict_overflow_p);
14715 return tree_simple_nonnegative_warnv_p (CALL_EXPR,
14719 /* Return true if T is known to be non-negative. If the return
14720 value is based on the assumption that signed overflow is undefined,
14721 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14722 *STRICT_OVERFLOW_P. */
14725 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14727 enum tree_code code = TREE_CODE (t);
14728 if (TYPE_UNSIGNED (TREE_TYPE (t)))
14735 tree temp = TARGET_EXPR_SLOT (t);
14736 t = TARGET_EXPR_INITIAL (t);
14738 /* If the initializer is non-void, then it's a normal expression
14739 that will be assigned to the slot. */
14740 if (!VOID_TYPE_P (t))
14741 return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
14743 /* Otherwise, the initializer sets the slot in some way. One common
14744 way is an assignment statement at the end of the initializer. */
14747 if (TREE_CODE (t) == BIND_EXPR)
14748 t = expr_last (BIND_EXPR_BODY (t));
14749 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
14750 || TREE_CODE (t) == TRY_CATCH_EXPR)
14751 t = expr_last (TREE_OPERAND (t, 0));
14752 else if (TREE_CODE (t) == STATEMENT_LIST)
14757 if (TREE_CODE (t) == MODIFY_EXPR
14758 && TREE_OPERAND (t, 0) == temp)
14759 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14760 strict_overflow_p);
14767 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
14768 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
14770 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
14771 get_callee_fndecl (t),
14774 strict_overflow_p);
14776 case COMPOUND_EXPR:
14778 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14779 strict_overflow_p);
14781 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
14782 strict_overflow_p);
14784 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14785 strict_overflow_p);
14788 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14792 /* We don't know sign of `t', so be conservative and return false. */
14796 /* Return true if T is known to be non-negative. If the return
14797 value is based on the assumption that signed overflow is undefined,
14798 set *STRICT_OVERFLOW_P to true; otherwise, don't change
14799 *STRICT_OVERFLOW_P. */
14802 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14804 enum tree_code code;
14805 if (t == error_mark_node)
14808 code = TREE_CODE (t);
14809 switch (TREE_CODE_CLASS (code))
14812 case tcc_comparison:
14813 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14815 TREE_OPERAND (t, 0),
14816 TREE_OPERAND (t, 1),
14817 strict_overflow_p);
14820 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14822 TREE_OPERAND (t, 0),
14823 strict_overflow_p);
14826 case tcc_declaration:
14827 case tcc_reference:
14828 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14836 case TRUTH_AND_EXPR:
14837 case TRUTH_OR_EXPR:
14838 case TRUTH_XOR_EXPR:
14839 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14841 TREE_OPERAND (t, 0),
14842 TREE_OPERAND (t, 1),
14843 strict_overflow_p);
14844 case TRUTH_NOT_EXPR:
14845 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14847 TREE_OPERAND (t, 0),
14848 strict_overflow_p);
14855 case WITH_SIZE_EXPR:
14859 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14862 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
14866 /* Return true if `t' is known to be non-negative. Handle warnings
14867 about undefined signed overflow. */
14870 tree_expr_nonnegative_p (tree t)
14872 bool ret, strict_overflow_p;
14874 strict_overflow_p = false;
14875 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
14876 if (strict_overflow_p)
14877 fold_overflow_warning (("assuming signed overflow does not occur when "
14878 "determining that expression is always "
14880 WARN_STRICT_OVERFLOW_MISC);
14885 /* Return true when (CODE OP0) is an address and is known to be nonzero.
14886 For floating point we further ensure that T is not denormal.
14887 Similar logic is present in nonzero_address in rtlanal.h.
14889 If the return value is based on the assumption that signed overflow
14890 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14891 change *STRICT_OVERFLOW_P. */
14894 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
14895 bool *strict_overflow_p)
14900 return tree_expr_nonzero_warnv_p (op0,
14901 strict_overflow_p);
14905 tree inner_type = TREE_TYPE (op0);
14906 tree outer_type = type;
14908 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
14909 && tree_expr_nonzero_warnv_p (op0,
14910 strict_overflow_p));
14914 case NON_LVALUE_EXPR:
14915 return tree_expr_nonzero_warnv_p (op0,
14916 strict_overflow_p);
14925 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
14926 For floating point we further ensure that T is not denormal.
14927 Similar logic is present in nonzero_address in rtlanal.h.
14929 If the return value is based on the assumption that signed overflow
14930 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14931 change *STRICT_OVERFLOW_P. */
14934 tree_binary_nonzero_warnv_p (enum tree_code code,
14937 tree op1, bool *strict_overflow_p)
14939 bool sub_strict_overflow_p;
14942 case POINTER_PLUS_EXPR:
14944 if (TYPE_OVERFLOW_UNDEFINED (type))
14946 /* With the presence of negative values it is hard
14947 to say something. */
14948 sub_strict_overflow_p = false;
14949 if (!tree_expr_nonnegative_warnv_p (op0,
14950 &sub_strict_overflow_p)
14951 || !tree_expr_nonnegative_warnv_p (op1,
14952 &sub_strict_overflow_p))
14954 /* One of operands must be positive and the other non-negative. */
14955 /* We don't set *STRICT_OVERFLOW_P here: even if this value
14956 overflows, on a twos-complement machine the sum of two
14957 nonnegative numbers can never be zero. */
14958 return (tree_expr_nonzero_warnv_p (op0,
14960 || tree_expr_nonzero_warnv_p (op1,
14961 strict_overflow_p));
14966 if (TYPE_OVERFLOW_UNDEFINED (type))
14968 if (tree_expr_nonzero_warnv_p (op0,
14970 && tree_expr_nonzero_warnv_p (op1,
14971 strict_overflow_p))
14973 *strict_overflow_p = true;
14980 sub_strict_overflow_p = false;
14981 if (tree_expr_nonzero_warnv_p (op0,
14982 &sub_strict_overflow_p)
14983 && tree_expr_nonzero_warnv_p (op1,
14984 &sub_strict_overflow_p))
14986 if (sub_strict_overflow_p)
14987 *strict_overflow_p = true;
14992 sub_strict_overflow_p = false;
14993 if (tree_expr_nonzero_warnv_p (op0,
14994 &sub_strict_overflow_p))
14996 if (sub_strict_overflow_p)
14997 *strict_overflow_p = true;
14999 /* When both operands are nonzero, then MAX must be too. */
15000 if (tree_expr_nonzero_warnv_p (op1,
15001 strict_overflow_p))
15004 /* MAX where operand 0 is positive is positive. */
15005 return tree_expr_nonnegative_warnv_p (op0,
15006 strict_overflow_p);
15008 /* MAX where operand 1 is positive is positive. */
15009 else if (tree_expr_nonzero_warnv_p (op1,
15010 &sub_strict_overflow_p)
15011 && tree_expr_nonnegative_warnv_p (op1,
15012 &sub_strict_overflow_p))
15014 if (sub_strict_overflow_p)
15015 *strict_overflow_p = true;
15021 return (tree_expr_nonzero_warnv_p (op1,
15023 || tree_expr_nonzero_warnv_p (op0,
15024 strict_overflow_p));
15033 /* Return true when T is an address and is known to be nonzero.
15034 For floating point we further ensure that T is not denormal.
15035 Similar logic is present in nonzero_address in rtlanal.h.
15037 If the return value is based on the assumption that signed overflow
15038 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15039 change *STRICT_OVERFLOW_P. */
15042 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15044 bool sub_strict_overflow_p;
15045 switch (TREE_CODE (t))
15048 return !integer_zerop (t);
15052 tree base = get_base_address (TREE_OPERAND (t, 0));
15057 /* Weak declarations may link to NULL. Other things may also be NULL
15058 so protect with -fdelete-null-pointer-checks; but not variables
15059 allocated on the stack. */
15061 && (flag_delete_null_pointer_checks
15062 || (TREE_CODE (base) == VAR_DECL && !TREE_STATIC (base))))
15063 return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
15065 /* Constants are never weak. */
15066 if (CONSTANT_CLASS_P (base))
15073 sub_strict_overflow_p = false;
15074 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15075 &sub_strict_overflow_p)
15076 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15077 &sub_strict_overflow_p))
15079 if (sub_strict_overflow_p)
15080 *strict_overflow_p = true;
15091 /* Return true when T is an address and is known to be nonzero.
15092 For floating point we further ensure that T is not denormal.
15093 Similar logic is present in nonzero_address in rtlanal.h.
15095 If the return value is based on the assumption that signed overflow
15096 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15097 change *STRICT_OVERFLOW_P. */
15100 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15102 tree type = TREE_TYPE (t);
15103 enum tree_code code;
15105 /* Doing something useful for floating point would need more work. */
15106 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
15109 code = TREE_CODE (t);
15110 switch (TREE_CODE_CLASS (code))
15113 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15114 strict_overflow_p);
15116 case tcc_comparison:
15117 return tree_binary_nonzero_warnv_p (code, type,
15118 TREE_OPERAND (t, 0),
15119 TREE_OPERAND (t, 1),
15120 strict_overflow_p);
15122 case tcc_declaration:
15123 case tcc_reference:
15124 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15132 case TRUTH_NOT_EXPR:
15133 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15134 strict_overflow_p);
15136 case TRUTH_AND_EXPR:
15137 case TRUTH_OR_EXPR:
15138 case TRUTH_XOR_EXPR:
15139 return tree_binary_nonzero_warnv_p (code, type,
15140 TREE_OPERAND (t, 0),
15141 TREE_OPERAND (t, 1),
15142 strict_overflow_p);
15149 case WITH_SIZE_EXPR:
15153 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15155 case COMPOUND_EXPR:
15158 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15159 strict_overflow_p);
15162 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
15163 strict_overflow_p);
15166 return alloca_call_p (t);
15174 /* Return true when T is an address and is known to be nonzero.
15175 Handle warnings about undefined signed overflow. */
15178 tree_expr_nonzero_p (tree t)
15180 bool ret, strict_overflow_p;
15182 strict_overflow_p = false;
15183 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
15184 if (strict_overflow_p)
15185 fold_overflow_warning (("assuming signed overflow does not occur when "
15186 "determining that expression is always "
15188 WARN_STRICT_OVERFLOW_MISC);
15192 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15193 attempt to fold the expression to a constant without modifying TYPE,
15196 If the expression could be simplified to a constant, then return
15197 the constant. If the expression would not be simplified to a
15198 constant, then return NULL_TREE. */
15201 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15203 tree tem = fold_binary (code, type, op0, op1);
15204 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15207 /* Given the components of a unary expression CODE, TYPE and OP0,
15208 attempt to fold the expression to a constant without modifying
15211 If the expression could be simplified to a constant, then return
15212 the constant. If the expression would not be simplified to a
15213 constant, then return NULL_TREE. */
15216 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15218 tree tem = fold_unary (code, type, op0);
15219 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15222 /* If EXP represents referencing an element in a constant string
15223 (either via pointer arithmetic or array indexing), return the
15224 tree representing the value accessed, otherwise return NULL. */
15227 fold_read_from_constant_string (tree exp)
15229 if ((TREE_CODE (exp) == INDIRECT_REF
15230 || TREE_CODE (exp) == ARRAY_REF)
15231 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15233 tree exp1 = TREE_OPERAND (exp, 0);
15237 if (TREE_CODE (exp) == INDIRECT_REF)
15238 string = string_constant (exp1, &index);
15241 tree low_bound = array_ref_low_bound (exp);
15242 index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
15244 /* Optimize the special-case of a zero lower bound.
15246 We convert the low_bound to sizetype to avoid some problems
15247 with constant folding. (E.g. suppose the lower bound is 1,
15248 and its mode is QI. Without the conversion,l (ARRAY
15249 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15250 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15251 if (! integer_zerop (low_bound))
15252 index = size_diffop (index, fold_convert (sizetype, low_bound));
15258 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15259 && TREE_CODE (string) == STRING_CST
15260 && TREE_CODE (index) == INTEGER_CST
15261 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15262 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15264 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15265 return build_int_cst_type (TREE_TYPE (exp),
15266 (TREE_STRING_POINTER (string)
15267 [TREE_INT_CST_LOW (index)]));
15272 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15273 an integer constant, real, or fixed-point constant.
15275 TYPE is the type of the result. */
15278 fold_negate_const (tree arg0, tree type)
15280 tree t = NULL_TREE;
15282 switch (TREE_CODE (arg0))
15286 unsigned HOST_WIDE_INT low;
15287 HOST_WIDE_INT high;
15288 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
15289 TREE_INT_CST_HIGH (arg0),
15291 t = force_fit_type_double (type, low, high, 1,
15292 (overflow | TREE_OVERFLOW (arg0))
15293 && !TYPE_UNSIGNED (type));
15298 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
15303 FIXED_VALUE_TYPE f;
15304 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15305 &(TREE_FIXED_CST (arg0)), NULL,
15306 TYPE_SATURATING (type));
15307 t = build_fixed (type, f);
15308 /* Propagate overflow flags. */
15309 if (overflow_p | TREE_OVERFLOW (arg0))
15310 TREE_OVERFLOW (t) = 1;
15315 gcc_unreachable ();
15321 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15322 an integer constant or real constant.
15324 TYPE is the type of the result. */
15327 fold_abs_const (tree arg0, tree type)
15329 tree t = NULL_TREE;
15331 switch (TREE_CODE (arg0))
15334 /* If the value is unsigned, then the absolute value is
15335 the same as the ordinary value. */
15336 if (TYPE_UNSIGNED (type))
15338 /* Similarly, if the value is non-negative. */
15339 else if (INT_CST_LT (integer_minus_one_node, arg0))
15341 /* If the value is negative, then the absolute value is
15345 unsigned HOST_WIDE_INT low;
15346 HOST_WIDE_INT high;
15347 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
15348 TREE_INT_CST_HIGH (arg0),
15350 t = force_fit_type_double (type, low, high, -1,
15351 overflow | TREE_OVERFLOW (arg0));
15356 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15357 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
15363 gcc_unreachable ();
15369 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15370 constant. TYPE is the type of the result. */
15373 fold_not_const (tree arg0, tree type)
15375 tree t = NULL_TREE;
15377 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
15379 t = force_fit_type_double (type, ~TREE_INT_CST_LOW (arg0),
15380 ~TREE_INT_CST_HIGH (arg0), 0,
15381 TREE_OVERFLOW (arg0));
15386 /* Given CODE, a relational operator, the target type, TYPE and two
15387 constant operands OP0 and OP1, return the result of the
15388 relational operation. If the result is not a compile time
15389 constant, then return NULL_TREE. */
15392 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
15394 int result, invert;
15396 /* From here on, the only cases we handle are when the result is
15397 known to be a constant. */
15399 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
15401 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
15402 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
15404 /* Handle the cases where either operand is a NaN. */
15405 if (real_isnan (c0) || real_isnan (c1))
15415 case UNORDERED_EXPR:
15429 if (flag_trapping_math)
15435 gcc_unreachable ();
15438 return constant_boolean_node (result, type);
15441 return constant_boolean_node (real_compare (code, c0, c1), type);
15444 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
15446 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
15447 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
15448 return constant_boolean_node (fixed_compare (code, c0, c1), type);
15451 /* Handle equality/inequality of complex constants. */
15452 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
15454 tree rcond = fold_relational_const (code, type,
15455 TREE_REALPART (op0),
15456 TREE_REALPART (op1));
15457 tree icond = fold_relational_const (code, type,
15458 TREE_IMAGPART (op0),
15459 TREE_IMAGPART (op1));
15460 if (code == EQ_EXPR)
15461 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
15462 else if (code == NE_EXPR)
15463 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
15468 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
15470 To compute GT, swap the arguments and do LT.
15471 To compute GE, do LT and invert the result.
15472 To compute LE, swap the arguments, do LT and invert the result.
15473 To compute NE, do EQ and invert the result.
15475 Therefore, the code below must handle only EQ and LT. */
15477 if (code == LE_EXPR || code == GT_EXPR)
15482 code = swap_tree_comparison (code);
15485 /* Note that it is safe to invert for real values here because we
15486 have already handled the one case that it matters. */
15489 if (code == NE_EXPR || code == GE_EXPR)
15492 code = invert_tree_comparison (code, false);
15495 /* Compute a result for LT or EQ if args permit;
15496 Otherwise return T. */
15497 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
15499 if (code == EQ_EXPR)
15500 result = tree_int_cst_equal (op0, op1);
15501 else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
15502 result = INT_CST_LT_UNSIGNED (op0, op1);
15504 result = INT_CST_LT (op0, op1);
15511 return constant_boolean_node (result, type);
15514 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
15515 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
15519 fold_build_cleanup_point_expr (tree type, tree expr)
15521 /* If the expression does not have side effects then we don't have to wrap
15522 it with a cleanup point expression. */
15523 if (!TREE_SIDE_EFFECTS (expr))
15526 /* If the expression is a return, check to see if the expression inside the
15527 return has no side effects or the right hand side of the modify expression
15528 inside the return. If either don't have side effects set we don't need to
15529 wrap the expression in a cleanup point expression. Note we don't check the
15530 left hand side of the modify because it should always be a return decl. */
15531 if (TREE_CODE (expr) == RETURN_EXPR)
15533 tree op = TREE_OPERAND (expr, 0);
15534 if (!op || !TREE_SIDE_EFFECTS (op))
15536 op = TREE_OPERAND (op, 1);
15537 if (!TREE_SIDE_EFFECTS (op))
15541 return build1 (CLEANUP_POINT_EXPR, type, expr);
15544 /* Given a pointer value OP0 and a type TYPE, return a simplified version
15545 of an indirection through OP0, or NULL_TREE if no simplification is
15549 fold_indirect_ref_1 (tree type, tree op0)
15555 subtype = TREE_TYPE (sub);
15556 if (!POINTER_TYPE_P (subtype))
15559 if (TREE_CODE (sub) == ADDR_EXPR)
15561 tree op = TREE_OPERAND (sub, 0);
15562 tree optype = TREE_TYPE (op);
15563 /* *&CONST_DECL -> to the value of the const decl. */
15564 if (TREE_CODE (op) == CONST_DECL)
15565 return DECL_INITIAL (op);
15566 /* *&p => p; make sure to handle *&"str"[cst] here. */
15567 if (type == optype)
15569 tree fop = fold_read_from_constant_string (op);
15575 /* *(foo *)&fooarray => fooarray[0] */
15576 else if (TREE_CODE (optype) == ARRAY_TYPE
15577 && type == TREE_TYPE (optype))
15579 tree type_domain = TYPE_DOMAIN (optype);
15580 tree min_val = size_zero_node;
15581 if (type_domain && TYPE_MIN_VALUE (type_domain))
15582 min_val = TYPE_MIN_VALUE (type_domain);
15583 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
15585 /* *(foo *)&complexfoo => __real__ complexfoo */
15586 else if (TREE_CODE (optype) == COMPLEX_TYPE
15587 && type == TREE_TYPE (optype))
15588 return fold_build1 (REALPART_EXPR, type, op);
15589 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
15590 else if (TREE_CODE (optype) == VECTOR_TYPE
15591 && type == TREE_TYPE (optype))
15593 tree part_width = TYPE_SIZE (type);
15594 tree index = bitsize_int (0);
15595 return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
15599 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
15600 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
15601 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
15603 tree op00 = TREE_OPERAND (sub, 0);
15604 tree op01 = TREE_OPERAND (sub, 1);
15608 op00type = TREE_TYPE (op00);
15609 if (TREE_CODE (op00) == ADDR_EXPR
15610 && TREE_CODE (TREE_TYPE (op00type)) == VECTOR_TYPE
15611 && type == TREE_TYPE (TREE_TYPE (op00type)))
15613 HOST_WIDE_INT offset = tree_low_cst (op01, 0);
15614 tree part_width = TYPE_SIZE (type);
15615 unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
15616 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
15617 tree index = bitsize_int (indexi);
15619 if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (op00type)))
15620 return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (op00, 0),
15621 part_width, index);
15627 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
15628 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
15629 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
15631 tree op00 = TREE_OPERAND (sub, 0);
15632 tree op01 = TREE_OPERAND (sub, 1);
15636 op00type = TREE_TYPE (op00);
15637 if (TREE_CODE (op00) == ADDR_EXPR
15638 && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
15639 && type == TREE_TYPE (TREE_TYPE (op00type)))
15641 tree size = TYPE_SIZE_UNIT (type);
15642 if (tree_int_cst_equal (size, op01))
15643 return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
15647 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
15648 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
15649 && type == TREE_TYPE (TREE_TYPE (subtype)))
15652 tree min_val = size_zero_node;
15653 sub = build_fold_indirect_ref (sub);
15654 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
15655 if (type_domain && TYPE_MIN_VALUE (type_domain))
15656 min_val = TYPE_MIN_VALUE (type_domain);
15657 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
15663 /* Builds an expression for an indirection through T, simplifying some
15667 build_fold_indirect_ref (tree t)
15669 tree type = TREE_TYPE (TREE_TYPE (t));
15670 tree sub = fold_indirect_ref_1 (type, t);
15675 return build1 (INDIRECT_REF, type, t);
15678 /* Given an INDIRECT_REF T, return either T or a simplified version. */
15681 fold_indirect_ref (tree t)
15683 tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
15691 /* Strip non-trapping, non-side-effecting tree nodes from an expression
15692 whose result is ignored. The type of the returned tree need not be
15693 the same as the original expression. */
15696 fold_ignored_result (tree t)
15698 if (!TREE_SIDE_EFFECTS (t))
15699 return integer_zero_node;
15702 switch (TREE_CODE_CLASS (TREE_CODE (t)))
15705 t = TREE_OPERAND (t, 0);
15709 case tcc_comparison:
15710 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15711 t = TREE_OPERAND (t, 0);
15712 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
15713 t = TREE_OPERAND (t, 1);
15718 case tcc_expression:
15719 switch (TREE_CODE (t))
15721 case COMPOUND_EXPR:
15722 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15724 t = TREE_OPERAND (t, 0);
15728 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
15729 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
15731 t = TREE_OPERAND (t, 0);
15744 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
15745 This can only be applied to objects of a sizetype. */
15748 round_up (tree value, int divisor)
15750 tree div = NULL_TREE;
15752 gcc_assert (divisor > 0);
15756 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
15757 have to do anything. Only do this when we are not given a const,
15758 because in that case, this check is more expensive than just
15760 if (TREE_CODE (value) != INTEGER_CST)
15762 div = build_int_cst (TREE_TYPE (value), divisor);
15764 if (multiple_of_p (TREE_TYPE (value), value, div))
15768 /* If divisor is a power of two, simplify this to bit manipulation. */
15769 if (divisor == (divisor & -divisor))
15771 if (TREE_CODE (value) == INTEGER_CST)
15773 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (value);
15774 unsigned HOST_WIDE_INT high;
15777 if ((low & (divisor - 1)) == 0)
15780 overflow_p = TREE_OVERFLOW (value);
15781 high = TREE_INT_CST_HIGH (value);
15782 low &= ~(divisor - 1);
15791 return force_fit_type_double (TREE_TYPE (value), low, high,
15798 t = build_int_cst (TREE_TYPE (value), divisor - 1);
15799 value = size_binop (PLUS_EXPR, value, t);
15800 t = build_int_cst (TREE_TYPE (value), -divisor);
15801 value = size_binop (BIT_AND_EXPR, value, t);
15807 div = build_int_cst (TREE_TYPE (value), divisor);
15808 value = size_binop (CEIL_DIV_EXPR, value, div);
15809 value = size_binop (MULT_EXPR, value, div);
15815 /* Likewise, but round down. */
15818 round_down (tree value, int divisor)
15820 tree div = NULL_TREE;
15822 gcc_assert (divisor > 0);
15826 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
15827 have to do anything. Only do this when we are not given a const,
15828 because in that case, this check is more expensive than just
15830 if (TREE_CODE (value) != INTEGER_CST)
15832 div = build_int_cst (TREE_TYPE (value), divisor);
15834 if (multiple_of_p (TREE_TYPE (value), value, div))
15838 /* If divisor is a power of two, simplify this to bit manipulation. */
15839 if (divisor == (divisor & -divisor))
15843 t = build_int_cst (TREE_TYPE (value), -divisor);
15844 value = size_binop (BIT_AND_EXPR, value, t);
15849 div = build_int_cst (TREE_TYPE (value), divisor);
15850 value = size_binop (FLOOR_DIV_EXPR, value, div);
15851 value = size_binop (MULT_EXPR, value, div);
15857 /* Returns the pointer to the base of the object addressed by EXP and
15858 extracts the information about the offset of the access, storing it
15859 to PBITPOS and POFFSET. */
15862 split_address_to_core_and_offset (tree exp,
15863 HOST_WIDE_INT *pbitpos, tree *poffset)
15866 enum machine_mode mode;
15867 int unsignedp, volatilep;
15868 HOST_WIDE_INT bitsize;
15870 if (TREE_CODE (exp) == ADDR_EXPR)
15872 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
15873 poffset, &mode, &unsignedp, &volatilep,
15875 core = build_fold_addr_expr (core);
15881 *poffset = NULL_TREE;
15887 /* Returns true if addresses of E1 and E2 differ by a constant, false
15888 otherwise. If they do, E1 - E2 is stored in *DIFF. */
15891 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
15894 HOST_WIDE_INT bitpos1, bitpos2;
15895 tree toffset1, toffset2, tdiff, type;
15897 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
15898 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
15900 if (bitpos1 % BITS_PER_UNIT != 0
15901 || bitpos2 % BITS_PER_UNIT != 0
15902 || !operand_equal_p (core1, core2, 0))
15905 if (toffset1 && toffset2)
15907 type = TREE_TYPE (toffset1);
15908 if (type != TREE_TYPE (toffset2))
15909 toffset2 = fold_convert (type, toffset2);
15911 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
15912 if (!cst_and_fits_in_hwi (tdiff))
15915 *diff = int_cst_value (tdiff);
15917 else if (toffset1 || toffset2)
15919 /* If only one of the offsets is non-constant, the difference cannot
15926 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
15930 /* Simplify the floating point expression EXP when the sign of the
15931 result is not significant. Return NULL_TREE if no simplification
15935 fold_strip_sign_ops (tree exp)
15939 switch (TREE_CODE (exp))
15943 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15944 return arg0 ? arg0 : TREE_OPERAND (exp, 0);
15948 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
15950 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15951 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15952 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
15953 return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
15954 arg0 ? arg0 : TREE_OPERAND (exp, 0),
15955 arg1 ? arg1 : TREE_OPERAND (exp, 1));
15958 case COMPOUND_EXPR:
15959 arg0 = TREE_OPERAND (exp, 0);
15960 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15962 return fold_build2 (COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
15966 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15967 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
15969 return fold_build3 (COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
15970 arg0 ? arg0 : TREE_OPERAND (exp, 1),
15971 arg1 ? arg1 : TREE_OPERAND (exp, 2));
15976 const enum built_in_function fcode = builtin_mathfn_code (exp);
15979 CASE_FLT_FN (BUILT_IN_COPYSIGN):
15980 /* Strip copysign function call, return the 1st argument. */
15981 arg0 = CALL_EXPR_ARG (exp, 0);
15982 arg1 = CALL_EXPR_ARG (exp, 1);
15983 return omit_one_operand (TREE_TYPE (exp), arg0, arg1);
15986 /* Strip sign ops from the argument of "odd" math functions. */
15987 if (negate_mathfn_p (fcode))
15989 arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
15991 return build_call_expr (get_callee_fndecl (exp), 1, arg0);