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,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
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 takes a constant and prior overflow indicator, and
43 forces the value to fit the type. It returns an overflow indicator. */
56 #include "langhooks.h"
58 static void encode
PARAMS ((HOST_WIDE_INT
*,
59 unsigned HOST_WIDE_INT
,
61 static void decode
PARAMS ((HOST_WIDE_INT
*,
62 unsigned HOST_WIDE_INT
*,
64 static tree negate_expr
PARAMS ((tree
));
65 static tree split_tree
PARAMS ((tree
, enum tree_code
, tree
*, tree
*,
67 static tree associate_trees
PARAMS ((tree
, tree
, enum tree_code
, tree
));
68 static tree int_const_binop
PARAMS ((enum tree_code
, tree
, tree
, int));
69 static tree const_binop
PARAMS ((enum tree_code
, tree
, tree
, int));
70 static hashval_t size_htab_hash
PARAMS ((const void *));
71 static int size_htab_eq
PARAMS ((const void *, const void *));
72 static tree fold_convert
PARAMS ((tree
, tree
));
73 static enum tree_code invert_tree_comparison
PARAMS ((enum tree_code
));
74 static enum tree_code swap_tree_comparison
PARAMS ((enum tree_code
));
75 static int truth_value_p
PARAMS ((enum tree_code
));
76 static int operand_equal_for_comparison_p
PARAMS ((tree
, tree
, tree
));
77 static int twoval_comparison_p
PARAMS ((tree
, tree
*, tree
*, int *));
78 static tree eval_subst
PARAMS ((tree
, tree
, tree
, tree
, tree
));
79 static tree omit_one_operand
PARAMS ((tree
, tree
, tree
));
80 static tree pedantic_omit_one_operand
PARAMS ((tree
, tree
, tree
));
81 static tree distribute_bit_expr
PARAMS ((enum tree_code
, tree
, tree
, tree
));
82 static tree make_bit_field_ref
PARAMS ((tree
, tree
, int, int, int));
83 static tree optimize_bit_field_compare
PARAMS ((enum tree_code
, tree
,
85 static tree decode_field_reference
PARAMS ((tree
, HOST_WIDE_INT
*,
87 enum machine_mode
*, int *,
88 int *, tree
*, tree
*));
89 static int all_ones_mask_p
PARAMS ((tree
, int));
90 static tree sign_bit_p
PARAMS ((tree
, tree
));
91 static int simple_operand_p
PARAMS ((tree
));
92 static tree range_binop
PARAMS ((enum tree_code
, tree
, tree
, int,
94 static tree make_range
PARAMS ((tree
, int *, tree
*, tree
*));
95 static tree build_range_check
PARAMS ((tree
, tree
, int, tree
, tree
));
96 static int merge_ranges
PARAMS ((int *, tree
*, tree
*, int, tree
, tree
,
98 static tree fold_range_test
PARAMS ((tree
));
99 static tree unextend
PARAMS ((tree
, int, int, tree
));
100 static tree fold_truthop
PARAMS ((enum tree_code
, tree
, tree
, tree
));
101 static tree optimize_minmax_comparison
PARAMS ((tree
));
102 static tree extract_muldiv
PARAMS ((tree
, tree
, enum tree_code
, tree
));
103 static tree strip_compound_expr
PARAMS ((tree
, tree
));
104 static int multiple_of_p
PARAMS ((tree
, tree
, tree
));
105 static tree constant_boolean_node
PARAMS ((int, tree
));
106 static int count_cond
PARAMS ((tree
, int));
107 static tree fold_binary_op_with_conditional_arg
108 PARAMS ((enum tree_code
, tree
, tree
, tree
, int));
109 static bool fold_real_zero_addition_p
PARAMS ((tree
, tree
, int));
111 #if defined(HOST_EBCDIC)
112 /* bit 8 is significant in EBCDIC */
113 #define CHARMASK 0xff
115 #define CHARMASK 0x7f
118 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
119 overflow. Suppose A, B and SUM have the same respective signs as A1, B1,
120 and SUM1. Then this yields nonzero if overflow occurred during the
123 Overflow occurs if A and B have the same sign, but A and SUM differ in
124 sign. Use `^' to test whether signs differ, and `< 0' to isolate the
126 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
128 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
129 We do that by representing the two-word integer in 4 words, with only
130 HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
131 number. The value of the word is LOWPART + HIGHPART * BASE. */
134 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
135 #define HIGHPART(x) \
136 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
137 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
139 /* Unpack a two-word integer into 4 words.
140 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
141 WORDS points to the array of HOST_WIDE_INTs. */
144 encode (words
, low
, hi
)
145 HOST_WIDE_INT
*words
;
146 unsigned HOST_WIDE_INT low
;
149 words
[0] = LOWPART (low
);
150 words
[1] = HIGHPART (low
);
151 words
[2] = LOWPART (hi
);
152 words
[3] = HIGHPART (hi
);
155 /* Pack an array of 4 words into a two-word integer.
156 WORDS points to the array of words.
157 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
160 decode (words
, low
, hi
)
161 HOST_WIDE_INT
*words
;
162 unsigned HOST_WIDE_INT
*low
;
165 *low
= words
[0] + words
[1] * BASE
;
166 *hi
= words
[2] + words
[3] * BASE
;
169 /* Make the integer constant T valid for its type by setting to 0 or 1 all
170 the bits in the constant that don't belong in the type.
172 Return 1 if a signed overflow occurs, 0 otherwise. If OVERFLOW is
173 nonzero, a signed overflow has already occurred in calculating T, so
176 Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
180 force_fit_type (t
, overflow
)
184 unsigned HOST_WIDE_INT low
;
188 if (TREE_CODE (t
) == REAL_CST
)
190 #ifdef CHECK_FLOAT_VALUE
191 CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t
)), TREE_REAL_CST (t
),
197 else if (TREE_CODE (t
) != INTEGER_CST
)
200 low
= TREE_INT_CST_LOW (t
);
201 high
= TREE_INT_CST_HIGH (t
);
203 if (POINTER_TYPE_P (TREE_TYPE (t
)))
206 prec
= TYPE_PRECISION (TREE_TYPE (t
));
208 /* First clear all bits that are beyond the type's precision. */
210 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
212 else if (prec
> HOST_BITS_PER_WIDE_INT
)
213 TREE_INT_CST_HIGH (t
)
214 &= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
217 TREE_INT_CST_HIGH (t
) = 0;
218 if (prec
< HOST_BITS_PER_WIDE_INT
)
219 TREE_INT_CST_LOW (t
) &= ~((unsigned HOST_WIDE_INT
) (-1) << prec
);
222 /* Unsigned types do not suffer sign extension or overflow unless they
224 if (TREE_UNSIGNED (TREE_TYPE (t
))
225 && ! (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
226 && TYPE_IS_SIZETYPE (TREE_TYPE (t
))))
229 /* If the value's sign bit is set, extend the sign. */
230 if (prec
!= 2 * HOST_BITS_PER_WIDE_INT
231 && (prec
> HOST_BITS_PER_WIDE_INT
232 ? 0 != (TREE_INT_CST_HIGH (t
)
234 << (prec
- HOST_BITS_PER_WIDE_INT
- 1)))
235 : 0 != (TREE_INT_CST_LOW (t
)
236 & ((unsigned HOST_WIDE_INT
) 1 << (prec
- 1)))))
238 /* Value is negative:
239 set to 1 all the bits that are outside this type's precision. */
240 if (prec
> HOST_BITS_PER_WIDE_INT
)
241 TREE_INT_CST_HIGH (t
)
242 |= ((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
245 TREE_INT_CST_HIGH (t
) = -1;
246 if (prec
< HOST_BITS_PER_WIDE_INT
)
247 TREE_INT_CST_LOW (t
) |= ((unsigned HOST_WIDE_INT
) (-1) << prec
);
251 /* Return nonzero if signed overflow occurred. */
253 ((overflow
| (low
^ TREE_INT_CST_LOW (t
)) | (high
^ TREE_INT_CST_HIGH (t
)))
257 /* Add two doubleword integers with doubleword result.
258 Each argument is given as two `HOST_WIDE_INT' pieces.
259 One argument is L1 and H1; the other, L2 and H2.
260 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
263 add_double (l1
, h1
, l2
, h2
, lv
, hv
)
264 unsigned HOST_WIDE_INT l1
, l2
;
265 HOST_WIDE_INT h1
, h2
;
266 unsigned HOST_WIDE_INT
*lv
;
269 unsigned HOST_WIDE_INT l
;
273 h
= h1
+ h2
+ (l
< l1
);
277 return OVERFLOW_SUM_SIGN (h1
, h2
, h
);
280 /* Negate a doubleword integer with doubleword result.
281 Return nonzero if the operation overflows, assuming it's signed.
282 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
283 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
286 neg_double (l1
, h1
, lv
, hv
)
287 unsigned HOST_WIDE_INT l1
;
289 unsigned HOST_WIDE_INT
*lv
;
296 return (*hv
& h1
) < 0;
306 /* Multiply two doubleword integers with doubleword result.
307 Return nonzero if the operation overflows, assuming it's signed.
308 Each argument is given as two `HOST_WIDE_INT' pieces.
309 One argument is L1 and H1; the other, L2 and H2.
310 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
313 mul_double (l1
, h1
, l2
, h2
, lv
, hv
)
314 unsigned HOST_WIDE_INT l1
, l2
;
315 HOST_WIDE_INT h1
, h2
;
316 unsigned HOST_WIDE_INT
*lv
;
319 HOST_WIDE_INT arg1
[4];
320 HOST_WIDE_INT arg2
[4];
321 HOST_WIDE_INT prod
[4 * 2];
322 unsigned HOST_WIDE_INT carry
;
324 unsigned HOST_WIDE_INT toplow
, neglow
;
325 HOST_WIDE_INT tophigh
, neghigh
;
327 encode (arg1
, l1
, h1
);
328 encode (arg2
, l2
, h2
);
330 memset ((char *) prod
, 0, sizeof prod
);
332 for (i
= 0; i
< 4; i
++)
335 for (j
= 0; j
< 4; j
++)
338 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
339 carry
+= arg1
[i
] * arg2
[j
];
340 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
342 prod
[k
] = LOWPART (carry
);
343 carry
= HIGHPART (carry
);
348 decode (prod
, lv
, hv
); /* This ignores prod[4] through prod[4*2-1] */
350 /* Check for overflow by calculating the top half of the answer in full;
351 it should agree with the low half's sign bit. */
352 decode (prod
+ 4, &toplow
, &tophigh
);
355 neg_double (l2
, h2
, &neglow
, &neghigh
);
356 add_double (neglow
, neghigh
, toplow
, tophigh
, &toplow
, &tophigh
);
360 neg_double (l1
, h1
, &neglow
, &neghigh
);
361 add_double (neglow
, neghigh
, toplow
, tophigh
, &toplow
, &tophigh
);
363 return (*hv
< 0 ? ~(toplow
& tophigh
) : toplow
| tophigh
) != 0;
366 /* Shift the doubleword integer in L1, H1 left by COUNT places
367 keeping only PREC bits of result.
368 Shift right if COUNT is negative.
369 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
370 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
373 lshift_double (l1
, h1
, count
, prec
, lv
, hv
, arith
)
374 unsigned HOST_WIDE_INT l1
;
375 HOST_WIDE_INT h1
, count
;
377 unsigned HOST_WIDE_INT
*lv
;
381 unsigned HOST_WIDE_INT signmask
;
385 rshift_double (l1
, h1
, -count
, prec
, lv
, hv
, arith
);
389 #ifdef SHIFT_COUNT_TRUNCATED
390 if (SHIFT_COUNT_TRUNCATED
)
394 if (count
>= 2 * HOST_BITS_PER_WIDE_INT
)
396 /* Shifting by the host word size is undefined according to the
397 ANSI standard, so we must handle this as a special case. */
401 else if (count
>= HOST_BITS_PER_WIDE_INT
)
403 *hv
= l1
<< (count
- HOST_BITS_PER_WIDE_INT
);
408 *hv
= (((unsigned HOST_WIDE_INT
) h1
<< count
)
409 | (l1
>> (HOST_BITS_PER_WIDE_INT
- count
- 1) >> 1));
413 /* Sign extend all bits that are beyond the precision. */
415 signmask
= -((prec
> HOST_BITS_PER_WIDE_INT
416 ? ((unsigned HOST_WIDE_INT
) *hv
417 >> (prec
- HOST_BITS_PER_WIDE_INT
- 1))
418 : (*lv
>> (prec
- 1))) & 1);
420 if (prec
>= 2 * HOST_BITS_PER_WIDE_INT
)
422 else if (prec
>= HOST_BITS_PER_WIDE_INT
)
424 *hv
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
425 *hv
|= signmask
<< (prec
- HOST_BITS_PER_WIDE_INT
);
430 *lv
&= ~((unsigned HOST_WIDE_INT
) (-1) << prec
);
431 *lv
|= signmask
<< prec
;
435 /* Shift the doubleword integer in L1, H1 right by COUNT places
436 keeping only PREC bits of result. COUNT must be positive.
437 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
438 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
441 rshift_double (l1
, h1
, count
, prec
, lv
, hv
, arith
)
442 unsigned HOST_WIDE_INT l1
;
443 HOST_WIDE_INT h1
, count
;
445 unsigned HOST_WIDE_INT
*lv
;
449 unsigned HOST_WIDE_INT signmask
;
452 ? -((unsigned HOST_WIDE_INT
) h1
>> (HOST_BITS_PER_WIDE_INT
- 1))
455 #ifdef SHIFT_COUNT_TRUNCATED
456 if (SHIFT_COUNT_TRUNCATED
)
460 if (count
>= 2 * HOST_BITS_PER_WIDE_INT
)
462 /* Shifting by the host word size is undefined according to the
463 ANSI standard, so we must handle this as a special case. */
467 else if (count
>= HOST_BITS_PER_WIDE_INT
)
470 *lv
= (unsigned HOST_WIDE_INT
) h1
>> (count
- HOST_BITS_PER_WIDE_INT
);
474 *hv
= (unsigned HOST_WIDE_INT
) h1
>> count
;
476 | ((unsigned HOST_WIDE_INT
) h1
<< (HOST_BITS_PER_WIDE_INT
- count
- 1) << 1));
479 /* Zero / sign extend all bits that are beyond the precision. */
481 if (count
>= (HOST_WIDE_INT
)prec
)
486 else if ((prec
- count
) >= 2 * HOST_BITS_PER_WIDE_INT
)
488 else if ((prec
- count
) >= HOST_BITS_PER_WIDE_INT
)
490 *hv
&= ~((HOST_WIDE_INT
) (-1) << (prec
- count
- HOST_BITS_PER_WIDE_INT
));
491 *hv
|= signmask
<< (prec
- count
- HOST_BITS_PER_WIDE_INT
);
496 *lv
&= ~((unsigned HOST_WIDE_INT
) (-1) << (prec
- count
));
497 *lv
|= signmask
<< (prec
- count
);
501 /* Rotate the doubleword integer in L1, H1 left by COUNT places
502 keeping only PREC bits of result.
503 Rotate right if COUNT is negative.
504 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
507 lrotate_double (l1
, h1
, count
, prec
, lv
, hv
)
508 unsigned HOST_WIDE_INT l1
;
509 HOST_WIDE_INT h1
, count
;
511 unsigned HOST_WIDE_INT
*lv
;
514 unsigned HOST_WIDE_INT s1l
, s2l
;
515 HOST_WIDE_INT s1h
, s2h
;
521 lshift_double (l1
, h1
, count
, prec
, &s1l
, &s1h
, 0);
522 rshift_double (l1
, h1
, prec
- count
, prec
, &s2l
, &s2h
, 0);
527 /* Rotate the doubleword integer in L1, H1 left by COUNT places
528 keeping only PREC bits of result. COUNT must be positive.
529 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
532 rrotate_double (l1
, h1
, count
, prec
, lv
, hv
)
533 unsigned HOST_WIDE_INT l1
;
534 HOST_WIDE_INT h1
, count
;
536 unsigned HOST_WIDE_INT
*lv
;
539 unsigned HOST_WIDE_INT s1l
, s2l
;
540 HOST_WIDE_INT s1h
, s2h
;
546 rshift_double (l1
, h1
, count
, prec
, &s1l
, &s1h
, 0);
547 lshift_double (l1
, h1
, prec
- count
, prec
, &s2l
, &s2h
, 0);
552 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
553 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
554 CODE is a tree code for a kind of division, one of
555 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
557 It controls how the quotient is rounded to an integer.
558 Return nonzero if the operation overflows.
559 UNS nonzero says do unsigned division. */
562 div_and_round_double (code
, uns
,
563 lnum_orig
, hnum_orig
, lden_orig
, hden_orig
,
564 lquo
, hquo
, lrem
, hrem
)
567 unsigned HOST_WIDE_INT lnum_orig
; /* num == numerator == dividend */
568 HOST_WIDE_INT hnum_orig
;
569 unsigned HOST_WIDE_INT lden_orig
; /* den == denominator == divisor */
570 HOST_WIDE_INT hden_orig
;
571 unsigned HOST_WIDE_INT
*lquo
, *lrem
;
572 HOST_WIDE_INT
*hquo
, *hrem
;
575 HOST_WIDE_INT num
[4 + 1]; /* extra element for scaling. */
576 HOST_WIDE_INT den
[4], quo
[4];
578 unsigned HOST_WIDE_INT work
;
579 unsigned HOST_WIDE_INT carry
= 0;
580 unsigned HOST_WIDE_INT lnum
= lnum_orig
;
581 HOST_WIDE_INT hnum
= hnum_orig
;
582 unsigned HOST_WIDE_INT lden
= lden_orig
;
583 HOST_WIDE_INT hden
= hden_orig
;
586 if (hden
== 0 && lden
== 0)
587 overflow
= 1, lden
= 1;
589 /* calculate quotient sign and convert operands to unsigned. */
595 /* (minimum integer) / (-1) is the only overflow case. */
596 if (neg_double (lnum
, hnum
, &lnum
, &hnum
)
597 && ((HOST_WIDE_INT
) lden
& hden
) == -1)
603 neg_double (lden
, hden
, &lden
, &hden
);
607 if (hnum
== 0 && hden
== 0)
608 { /* single precision */
610 /* This unsigned division rounds toward zero. */
616 { /* trivial case: dividend < divisor */
617 /* hden != 0 already checked. */
624 memset ((char *) quo
, 0, sizeof quo
);
626 memset ((char *) num
, 0, sizeof num
); /* to zero 9th element */
627 memset ((char *) den
, 0, sizeof den
);
629 encode (num
, lnum
, hnum
);
630 encode (den
, lden
, hden
);
632 /* Special code for when the divisor < BASE. */
633 if (hden
== 0 && lden
< (unsigned HOST_WIDE_INT
) BASE
)
635 /* hnum != 0 already checked. */
636 for (i
= 4 - 1; i
>= 0; i
--)
638 work
= num
[i
] + carry
* BASE
;
639 quo
[i
] = work
/ lden
;
645 /* Full double precision division,
646 with thanks to Don Knuth's "Seminumerical Algorithms". */
647 int num_hi_sig
, den_hi_sig
;
648 unsigned HOST_WIDE_INT quo_est
, scale
;
650 /* Find the highest non-zero divisor digit. */
651 for (i
= 4 - 1;; i
--)
658 /* Insure that the first digit of the divisor is at least BASE/2.
659 This is required by the quotient digit estimation algorithm. */
661 scale
= BASE
/ (den
[den_hi_sig
] + 1);
663 { /* scale divisor and dividend */
665 for (i
= 0; i
<= 4 - 1; i
++)
667 work
= (num
[i
] * scale
) + carry
;
668 num
[i
] = LOWPART (work
);
669 carry
= HIGHPART (work
);
674 for (i
= 0; i
<= 4 - 1; i
++)
676 work
= (den
[i
] * scale
) + carry
;
677 den
[i
] = LOWPART (work
);
678 carry
= HIGHPART (work
);
679 if (den
[i
] != 0) den_hi_sig
= i
;
686 for (i
= num_hi_sig
- den_hi_sig
- 1; i
>= 0; i
--)
688 /* Guess the next quotient digit, quo_est, by dividing the first
689 two remaining dividend digits by the high order quotient digit.
690 quo_est is never low and is at most 2 high. */
691 unsigned HOST_WIDE_INT tmp
;
693 num_hi_sig
= i
+ den_hi_sig
+ 1;
694 work
= num
[num_hi_sig
] * BASE
+ num
[num_hi_sig
- 1];
695 if (num
[num_hi_sig
] != den
[den_hi_sig
])
696 quo_est
= work
/ den
[den_hi_sig
];
700 /* Refine quo_est so it's usually correct, and at most one high. */
701 tmp
= work
- quo_est
* den
[den_hi_sig
];
703 && (den
[den_hi_sig
- 1] * quo_est
704 > (tmp
* BASE
+ num
[num_hi_sig
- 2])))
707 /* Try QUO_EST as the quotient digit, by multiplying the
708 divisor by QUO_EST and subtracting from the remaining dividend.
709 Keep in mind that QUO_EST is the I - 1st digit. */
712 for (j
= 0; j
<= den_hi_sig
; j
++)
714 work
= quo_est
* den
[j
] + carry
;
715 carry
= HIGHPART (work
);
716 work
= num
[i
+ j
] - LOWPART (work
);
717 num
[i
+ j
] = LOWPART (work
);
718 carry
+= HIGHPART (work
) != 0;
721 /* If quo_est was high by one, then num[i] went negative and
722 we need to correct things. */
723 if (num
[num_hi_sig
] < (HOST_WIDE_INT
) carry
)
726 carry
= 0; /* add divisor back in */
727 for (j
= 0; j
<= den_hi_sig
; j
++)
729 work
= num
[i
+ j
] + den
[j
] + carry
;
730 carry
= HIGHPART (work
);
731 num
[i
+ j
] = LOWPART (work
);
734 num
[num_hi_sig
] += carry
;
737 /* Store the quotient digit. */
742 decode (quo
, lquo
, hquo
);
745 /* if result is negative, make it so. */
747 neg_double (*lquo
, *hquo
, lquo
, hquo
);
749 /* compute trial remainder: rem = num - (quo * den) */
750 mul_double (*lquo
, *hquo
, lden_orig
, hden_orig
, lrem
, hrem
);
751 neg_double (*lrem
, *hrem
, lrem
, hrem
);
752 add_double (lnum_orig
, hnum_orig
, *lrem
, *hrem
, lrem
, hrem
);
757 case TRUNC_MOD_EXPR
: /* round toward zero */
758 case EXACT_DIV_EXPR
: /* for this one, it shouldn't matter */
762 case FLOOR_MOD_EXPR
: /* round toward negative infinity */
763 if (quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio < 0 && rem != 0 */
766 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) -1, (HOST_WIDE_INT
) -1,
774 case CEIL_MOD_EXPR
: /* round toward positive infinity */
775 if (!quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio > 0 && rem != 0 */
777 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) 1, (HOST_WIDE_INT
) 0,
785 case ROUND_MOD_EXPR
: /* round to closest integer */
787 unsigned HOST_WIDE_INT labs_rem
= *lrem
;
788 HOST_WIDE_INT habs_rem
= *hrem
;
789 unsigned HOST_WIDE_INT labs_den
= lden
, ltwice
;
790 HOST_WIDE_INT habs_den
= hden
, htwice
;
792 /* Get absolute values */
794 neg_double (*lrem
, *hrem
, &labs_rem
, &habs_rem
);
796 neg_double (lden
, hden
, &labs_den
, &habs_den
);
798 /* If (2 * abs (lrem) >= abs (lden)) */
799 mul_double ((HOST_WIDE_INT
) 2, (HOST_WIDE_INT
) 0,
800 labs_rem
, habs_rem
, <wice
, &htwice
);
802 if (((unsigned HOST_WIDE_INT
) habs_den
803 < (unsigned HOST_WIDE_INT
) htwice
)
804 || (((unsigned HOST_WIDE_INT
) habs_den
805 == (unsigned HOST_WIDE_INT
) htwice
)
806 && (labs_den
< ltwice
)))
810 add_double (*lquo
, *hquo
,
811 (HOST_WIDE_INT
) -1, (HOST_WIDE_INT
) -1, lquo
, hquo
);
814 add_double (*lquo
, *hquo
, (HOST_WIDE_INT
) 1, (HOST_WIDE_INT
) 0,
826 /* compute true remainder: rem = num - (quo * den) */
827 mul_double (*lquo
, *hquo
, lden_orig
, hden_orig
, lrem
, hrem
);
828 neg_double (*lrem
, *hrem
, lrem
, hrem
);
829 add_double (lnum_orig
, hnum_orig
, *lrem
, *hrem
, lrem
, hrem
);
833 /* Given T, an expression, return the negation of T. Allow for T to be
834 null, in which case return null. */
846 type
= TREE_TYPE (t
);
849 switch (TREE_CODE (t
))
853 if (! TREE_UNSIGNED (type
)
854 && 0 != (tem
= fold (build1 (NEGATE_EXPR
, type
, t
)))
855 && ! TREE_OVERFLOW (tem
))
860 return convert (type
, TREE_OPERAND (t
, 0));
863 /* - (A - B) -> B - A */
864 if (! FLOAT_TYPE_P (type
) || flag_unsafe_math_optimizations
)
865 return convert (type
,
866 fold (build (MINUS_EXPR
, TREE_TYPE (t
),
868 TREE_OPERAND (t
, 0))));
875 return convert (type
, fold (build1 (NEGATE_EXPR
, TREE_TYPE (t
), t
)));
878 /* Split a tree IN into a constant, literal and variable parts that could be
879 combined with CODE to make IN. "constant" means an expression with
880 TREE_CONSTANT but that isn't an actual constant. CODE must be a
881 commutative arithmetic operation. Store the constant part into *CONP,
882 the literal in *LITP and return the variable part. If a part isn't
883 present, set it to null. If the tree does not decompose in this way,
884 return the entire tree as the variable part and the other parts as null.
886 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
887 case, we negate an operand that was subtracted. Except if it is a
888 literal for which we use *MINUS_LITP instead.
890 If NEGATE_P is true, we are negating all of IN, again except a literal
891 for which we use *MINUS_LITP instead.
893 If IN is itself a literal or constant, return it as appropriate.
895 Note that we do not guarantee that any of the three values will be the
896 same type as IN, but they will have the same signedness and mode. */
899 split_tree (in
, code
, conp
, litp
, minus_litp
, negate_p
)
902 tree
*conp
, *litp
, *minus_litp
;
911 /* Strip any conversions that don't change the machine mode or signedness. */
912 STRIP_SIGN_NOPS (in
);
914 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
)
916 else if (TREE_CODE (in
) == code
917 || (! FLOAT_TYPE_P (TREE_TYPE (in
))
918 /* We can associate addition and subtraction together (even
919 though the C standard doesn't say so) for integers because
920 the value is not affected. For reals, the value might be
921 affected, so we can't. */
922 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
923 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
925 tree op0
= TREE_OPERAND (in
, 0);
926 tree op1
= TREE_OPERAND (in
, 1);
927 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
928 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
930 /* First see if either of the operands is a literal, then a constant. */
931 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
)
932 *litp
= op0
, op0
= 0;
933 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
)
934 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
936 if (op0
!= 0 && TREE_CONSTANT (op0
))
937 *conp
= op0
, op0
= 0;
938 else if (op1
!= 0 && TREE_CONSTANT (op1
))
939 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
941 /* If we haven't dealt with either operand, this is not a case we can
942 decompose. Otherwise, VAR is either of the ones remaining, if any. */
943 if (op0
!= 0 && op1
!= 0)
948 var
= op1
, neg_var_p
= neg1_p
;
950 /* Now do any needed negations. */
952 *minus_litp
= *litp
, *litp
= 0;
954 *conp
= negate_expr (*conp
);
956 var
= negate_expr (var
);
958 else if (TREE_CONSTANT (in
))
966 *minus_litp
= *litp
, *litp
= 0;
967 else if (*minus_litp
)
968 *litp
= *minus_litp
, *minus_litp
= 0;
969 *conp
= negate_expr (*conp
);
970 var
= negate_expr (var
);
976 /* Re-associate trees split by the above function. T1 and T2 are either
977 expressions to associate or null. Return the new expression, if any. If
978 we build an operation, do it in TYPE and with CODE. */
981 associate_trees (t1
, t2
, code
, type
)
991 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
992 try to fold this since we will have infinite recursion. But do
993 deal with any NEGATE_EXPRs. */
994 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
995 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
997 if (TREE_CODE (t1
) == NEGATE_EXPR
)
998 return build (MINUS_EXPR
, type
, convert (type
, t2
),
999 convert (type
, TREE_OPERAND (t1
, 0)));
1000 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
1001 return build (MINUS_EXPR
, type
, convert (type
, t1
),
1002 convert (type
, TREE_OPERAND (t2
, 0)));
1004 return build (code
, type
, convert (type
, t1
), convert (type
, t2
));
1007 return fold (build (code
, type
, convert (type
, t1
), convert (type
, t2
)));
1010 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1011 to produce a new constant.
1013 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1016 int_const_binop (code
, arg1
, arg2
, notrunc
)
1017 enum tree_code code
;
1021 unsigned HOST_WIDE_INT int1l
, int2l
;
1022 HOST_WIDE_INT int1h
, int2h
;
1023 unsigned HOST_WIDE_INT low
;
1025 unsigned HOST_WIDE_INT garbagel
;
1026 HOST_WIDE_INT garbageh
;
1028 tree type
= TREE_TYPE (arg1
);
1029 int uns
= TREE_UNSIGNED (type
);
1031 = (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (type
));
1033 int no_overflow
= 0;
1035 int1l
= TREE_INT_CST_LOW (arg1
);
1036 int1h
= TREE_INT_CST_HIGH (arg1
);
1037 int2l
= TREE_INT_CST_LOW (arg2
);
1038 int2h
= TREE_INT_CST_HIGH (arg2
);
1043 low
= int1l
| int2l
, hi
= int1h
| int2h
;
1047 low
= int1l
^ int2l
, hi
= int1h
^ int2h
;
1051 low
= int1l
& int2l
, hi
= int1h
& int2h
;
1054 case BIT_ANDTC_EXPR
:
1055 low
= int1l
& ~int2l
, hi
= int1h
& ~int2h
;
1061 /* It's unclear from the C standard whether shifts can overflow.
1062 The following code ignores overflow; perhaps a C standard
1063 interpretation ruling is needed. */
1064 lshift_double (int1l
, int1h
, int2l
, TYPE_PRECISION (type
),
1072 lrotate_double (int1l
, int1h
, int2l
, TYPE_PRECISION (type
),
1077 overflow
= add_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
1081 neg_double (int2l
, int2h
, &low
, &hi
);
1082 add_double (int1l
, int1h
, low
, hi
, &low
, &hi
);
1083 overflow
= OVERFLOW_SUM_SIGN (hi
, int2h
, int1h
);
1087 overflow
= mul_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
1090 case TRUNC_DIV_EXPR
:
1091 case FLOOR_DIV_EXPR
: case CEIL_DIV_EXPR
:
1092 case EXACT_DIV_EXPR
:
1093 /* This is a shortcut for a common special case. */
1094 if (int2h
== 0 && (HOST_WIDE_INT
) int2l
> 0
1095 && ! TREE_CONSTANT_OVERFLOW (arg1
)
1096 && ! TREE_CONSTANT_OVERFLOW (arg2
)
1097 && int1h
== 0 && (HOST_WIDE_INT
) int1l
>= 0)
1099 if (code
== CEIL_DIV_EXPR
)
1102 low
= int1l
/ int2l
, hi
= 0;
1106 /* ... fall through ... */
1108 case ROUND_DIV_EXPR
:
1109 if (int2h
== 0 && int2l
== 1)
1111 low
= int1l
, hi
= int1h
;
1114 if (int1l
== int2l
&& int1h
== int2h
1115 && ! (int1l
== 0 && int1h
== 0))
1120 overflow
= div_and_round_double (code
, uns
, int1l
, int1h
, int2l
, int2h
,
1121 &low
, &hi
, &garbagel
, &garbageh
);
1124 case TRUNC_MOD_EXPR
:
1125 case FLOOR_MOD_EXPR
: case CEIL_MOD_EXPR
:
1126 /* This is a shortcut for a common special case. */
1127 if (int2h
== 0 && (HOST_WIDE_INT
) int2l
> 0
1128 && ! TREE_CONSTANT_OVERFLOW (arg1
)
1129 && ! TREE_CONSTANT_OVERFLOW (arg2
)
1130 && int1h
== 0 && (HOST_WIDE_INT
) int1l
>= 0)
1132 if (code
== CEIL_MOD_EXPR
)
1134 low
= int1l
% int2l
, hi
= 0;
1138 /* ... fall through ... */
1140 case ROUND_MOD_EXPR
:
1141 overflow
= div_and_round_double (code
, uns
,
1142 int1l
, int1h
, int2l
, int2h
,
1143 &garbagel
, &garbageh
, &low
, &hi
);
1149 low
= (((unsigned HOST_WIDE_INT
) int1h
1150 < (unsigned HOST_WIDE_INT
) int2h
)
1151 || (((unsigned HOST_WIDE_INT
) int1h
1152 == (unsigned HOST_WIDE_INT
) int2h
)
1155 low
= (int1h
< int2h
1156 || (int1h
== int2h
&& int1l
< int2l
));
1158 if (low
== (code
== MIN_EXPR
))
1159 low
= int1l
, hi
= int1h
;
1161 low
= int2l
, hi
= int2h
;
1168 /* If this is for a sizetype, can be represented as one (signed)
1169 HOST_WIDE_INT word, and doesn't overflow, use size_int since it caches
1172 && ((hi
== 0 && (HOST_WIDE_INT
) low
>= 0)
1173 || (hi
== -1 && (HOST_WIDE_INT
) low
< 0))
1174 && overflow
== 0 && ! TREE_OVERFLOW (arg1
) && ! TREE_OVERFLOW (arg2
))
1175 return size_int_type_wide (low
, type
);
1178 t
= build_int_2 (low
, hi
);
1179 TREE_TYPE (t
) = TREE_TYPE (arg1
);
1184 ? (!uns
|| is_sizetype
) && overflow
1185 : (force_fit_type (t
, (!uns
|| is_sizetype
) && overflow
)
1187 | TREE_OVERFLOW (arg1
)
1188 | TREE_OVERFLOW (arg2
));
1190 /* If we're doing a size calculation, unsigned arithmetic does overflow.
1191 So check if force_fit_type truncated the value. */
1193 && ! TREE_OVERFLOW (t
)
1194 && (TREE_INT_CST_HIGH (t
) != hi
1195 || TREE_INT_CST_LOW (t
) != low
))
1196 TREE_OVERFLOW (t
) = 1;
1198 TREE_CONSTANT_OVERFLOW (t
) = (TREE_OVERFLOW (t
)
1199 | TREE_CONSTANT_OVERFLOW (arg1
)
1200 | TREE_CONSTANT_OVERFLOW (arg2
));
1204 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1205 constant. We assume ARG1 and ARG2 have the same data type, or at least
1206 are the same kind of constant and the same machine mode.
1208 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1211 const_binop (code
, arg1
, arg2
, notrunc
)
1212 enum tree_code code
;
1219 if (TREE_CODE (arg1
) == INTEGER_CST
)
1220 return int_const_binop (code
, arg1
, arg2
, notrunc
);
1222 if (TREE_CODE (arg1
) == REAL_CST
)
1226 REAL_VALUE_TYPE value
;
1229 d1
= TREE_REAL_CST (arg1
);
1230 d2
= TREE_REAL_CST (arg2
);
1232 /* If either operand is a NaN, just return it. Otherwise, set up
1233 for floating-point trap; we return an overflow. */
1234 if (REAL_VALUE_ISNAN (d1
))
1236 else if (REAL_VALUE_ISNAN (d2
))
1239 REAL_ARITHMETIC (value
, code
, d1
, d2
);
1241 t
= build_real (TREE_TYPE (arg1
),
1242 real_value_truncate (TYPE_MODE (TREE_TYPE (arg1
)),
1246 = (force_fit_type (t
, 0)
1247 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
));
1248 TREE_CONSTANT_OVERFLOW (t
)
1250 | TREE_CONSTANT_OVERFLOW (arg1
)
1251 | TREE_CONSTANT_OVERFLOW (arg2
);
1254 if (TREE_CODE (arg1
) == COMPLEX_CST
)
1256 tree type
= TREE_TYPE (arg1
);
1257 tree r1
= TREE_REALPART (arg1
);
1258 tree i1
= TREE_IMAGPART (arg1
);
1259 tree r2
= TREE_REALPART (arg2
);
1260 tree i2
= TREE_IMAGPART (arg2
);
1266 t
= build_complex (type
,
1267 const_binop (PLUS_EXPR
, r1
, r2
, notrunc
),
1268 const_binop (PLUS_EXPR
, i1
, i2
, notrunc
));
1272 t
= build_complex (type
,
1273 const_binop (MINUS_EXPR
, r1
, r2
, notrunc
),
1274 const_binop (MINUS_EXPR
, i1
, i2
, notrunc
));
1278 t
= build_complex (type
,
1279 const_binop (MINUS_EXPR
,
1280 const_binop (MULT_EXPR
,
1282 const_binop (MULT_EXPR
,
1285 const_binop (PLUS_EXPR
,
1286 const_binop (MULT_EXPR
,
1288 const_binop (MULT_EXPR
,
1296 = const_binop (PLUS_EXPR
,
1297 const_binop (MULT_EXPR
, r2
, r2
, notrunc
),
1298 const_binop (MULT_EXPR
, i2
, i2
, notrunc
),
1301 t
= build_complex (type
,
1303 (INTEGRAL_TYPE_P (TREE_TYPE (r1
))
1304 ? TRUNC_DIV_EXPR
: RDIV_EXPR
,
1305 const_binop (PLUS_EXPR
,
1306 const_binop (MULT_EXPR
, r1
, r2
,
1308 const_binop (MULT_EXPR
, i1
, i2
,
1311 magsquared
, notrunc
),
1313 (INTEGRAL_TYPE_P (TREE_TYPE (r1
))
1314 ? TRUNC_DIV_EXPR
: RDIV_EXPR
,
1315 const_binop (MINUS_EXPR
,
1316 const_binop (MULT_EXPR
, i1
, r2
,
1318 const_binop (MULT_EXPR
, r1
, i2
,
1321 magsquared
, notrunc
));
1333 /* These are the hash table functions for the hash table of INTEGER_CST
1334 nodes of a sizetype. */
1336 /* Return the hash code code X, an INTEGER_CST. */
1344 return (TREE_INT_CST_HIGH (t
) ^ TREE_INT_CST_LOW (t
)
1345 ^ (hashval_t
) ((long) TREE_TYPE (t
) >> 3)
1346 ^ (TREE_OVERFLOW (t
) << 20));
1349 /* Return non-zero if the value represented by *X (an INTEGER_CST tree node)
1350 is the same as that given by *Y, which is the same. */
1360 return (TREE_INT_CST_HIGH (xt
) == TREE_INT_CST_HIGH (yt
)
1361 && TREE_INT_CST_LOW (xt
) == TREE_INT_CST_LOW (yt
)
1362 && TREE_TYPE (xt
) == TREE_TYPE (yt
)
1363 && TREE_OVERFLOW (xt
) == TREE_OVERFLOW (yt
));
1366 /* Return an INTEGER_CST with value whose low-order HOST_BITS_PER_WIDE_INT
1367 bits are given by NUMBER and of the sizetype represented by KIND. */
1370 size_int_wide (number
, kind
)
1371 HOST_WIDE_INT number
;
1372 enum size_type_kind kind
;
1374 return size_int_type_wide (number
, sizetype_tab
[(int) kind
]);
1377 /* Likewise, but the desired type is specified explicitly. */
1380 size_int_type_wide (number
, type
)
1381 HOST_WIDE_INT number
;
1384 static htab_t size_htab
= 0;
1385 static tree new_const
= 0;
1390 size_htab
= htab_create (1024, size_htab_hash
, size_htab_eq
, NULL
);
1391 ggc_add_deletable_htab (size_htab
, NULL
, NULL
);
1392 new_const
= make_node (INTEGER_CST
);
1393 ggc_add_tree_root (&new_const
, 1);
1396 /* Adjust NEW_CONST to be the constant we want. If it's already in the
1397 hash table, we return the value from the hash table. Otherwise, we
1398 place that in the hash table and make a new node for the next time. */
1399 TREE_INT_CST_LOW (new_const
) = number
;
1400 TREE_INT_CST_HIGH (new_const
) = number
< 0 ? -1 : 0;
1401 TREE_TYPE (new_const
) = type
;
1402 TREE_OVERFLOW (new_const
) = TREE_CONSTANT_OVERFLOW (new_const
)
1403 = force_fit_type (new_const
, 0);
1405 slot
= htab_find_slot (size_htab
, new_const
, INSERT
);
1410 *slot
= (PTR
) new_const
;
1411 new_const
= make_node (INTEGER_CST
);
1415 return (tree
) *slot
;
1418 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1419 is a tree code. The type of the result is taken from the operands.
1420 Both must be the same type integer type and it must be a size type.
1421 If the operands are constant, so is the result. */
1424 size_binop (code
, arg0
, arg1
)
1425 enum tree_code code
;
1428 tree type
= TREE_TYPE (arg0
);
1430 if (TREE_CODE (type
) != INTEGER_TYPE
|| ! TYPE_IS_SIZETYPE (type
)
1431 || type
!= TREE_TYPE (arg1
))
1434 /* Handle the special case of two integer constants faster. */
1435 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1437 /* And some specific cases even faster than that. */
1438 if (code
== PLUS_EXPR
&& integer_zerop (arg0
))
1440 else if ((code
== MINUS_EXPR
|| code
== PLUS_EXPR
)
1441 && integer_zerop (arg1
))
1443 else if (code
== MULT_EXPR
&& integer_onep (arg0
))
1446 /* Handle general case of two integer constants. */
1447 return int_const_binop (code
, arg0
, arg1
, 0);
1450 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1451 return error_mark_node
;
1453 return fold (build (code
, type
, arg0
, arg1
));
1456 /* Given two values, either both of sizetype or both of bitsizetype,
1457 compute the difference between the two values. Return the value
1458 in signed type corresponding to the type of the operands. */
1461 size_diffop (arg0
, arg1
)
1464 tree type
= TREE_TYPE (arg0
);
1467 if (TREE_CODE (type
) != INTEGER_TYPE
|| ! TYPE_IS_SIZETYPE (type
)
1468 || type
!= TREE_TYPE (arg1
))
1471 /* If the type is already signed, just do the simple thing. */
1472 if (! TREE_UNSIGNED (type
))
1473 return size_binop (MINUS_EXPR
, arg0
, arg1
);
1475 ctype
= (type
== bitsizetype
|| type
== ubitsizetype
1476 ? sbitsizetype
: ssizetype
);
1478 /* If either operand is not a constant, do the conversions to the signed
1479 type and subtract. The hardware will do the right thing with any
1480 overflow in the subtraction. */
1481 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1482 return size_binop (MINUS_EXPR
, convert (ctype
, arg0
),
1483 convert (ctype
, arg1
));
1485 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1486 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1487 overflow) and negate (which can't either). Special-case a result
1488 of zero while we're here. */
1489 if (tree_int_cst_equal (arg0
, arg1
))
1490 return convert (ctype
, integer_zero_node
);
1491 else if (tree_int_cst_lt (arg1
, arg0
))
1492 return convert (ctype
, size_binop (MINUS_EXPR
, arg0
, arg1
));
1494 return size_binop (MINUS_EXPR
, convert (ctype
, integer_zero_node
),
1495 convert (ctype
, size_binop (MINUS_EXPR
, arg1
, arg0
)));
1499 /* Given T, a tree representing type conversion of ARG1, a constant,
1500 return a constant tree representing the result of conversion. */
1503 fold_convert (t
, arg1
)
1507 tree type
= TREE_TYPE (t
);
1510 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
))
1512 if (TREE_CODE (arg1
) == INTEGER_CST
)
1514 /* If we would build a constant wider than GCC supports,
1515 leave the conversion unfolded. */
1516 if (TYPE_PRECISION (type
) > 2 * HOST_BITS_PER_WIDE_INT
)
1519 /* If we are trying to make a sizetype for a small integer, use
1520 size_int to pick up cached types to reduce duplicate nodes. */
1521 if (TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (type
)
1522 && !TREE_CONSTANT_OVERFLOW (arg1
)
1523 && compare_tree_int (arg1
, 10000) < 0)
1524 return size_int_type_wide (TREE_INT_CST_LOW (arg1
), type
);
1526 /* Given an integer constant, make new constant with new type,
1527 appropriately sign-extended or truncated. */
1528 t
= build_int_2 (TREE_INT_CST_LOW (arg1
),
1529 TREE_INT_CST_HIGH (arg1
));
1530 TREE_TYPE (t
) = type
;
1531 /* Indicate an overflow if (1) ARG1 already overflowed,
1532 or (2) force_fit_type indicates an overflow.
1533 Tell force_fit_type that an overflow has already occurred
1534 if ARG1 is a too-large unsigned value and T is signed.
1535 But don't indicate an overflow if converting a pointer. */
1537 = ((force_fit_type (t
,
1538 (TREE_INT_CST_HIGH (arg1
) < 0
1539 && (TREE_UNSIGNED (type
)
1540 < TREE_UNSIGNED (TREE_TYPE (arg1
)))))
1541 && ! POINTER_TYPE_P (TREE_TYPE (arg1
)))
1542 || TREE_OVERFLOW (arg1
));
1543 TREE_CONSTANT_OVERFLOW (t
)
1544 = TREE_OVERFLOW (t
) | TREE_CONSTANT_OVERFLOW (arg1
);
1546 else if (TREE_CODE (arg1
) == REAL_CST
)
1548 /* Don't initialize these, use assignments.
1549 Initialized local aggregates don't work on old compilers. */
1553 tree type1
= TREE_TYPE (arg1
);
1556 x
= TREE_REAL_CST (arg1
);
1557 l
= real_value_from_int_cst (type1
, TYPE_MIN_VALUE (type
));
1559 no_upper_bound
= (TYPE_MAX_VALUE (type
) == NULL
);
1560 if (!no_upper_bound
)
1561 u
= real_value_from_int_cst (type1
, TYPE_MAX_VALUE (type
));
1563 /* See if X will be in range after truncation towards 0.
1564 To compensate for truncation, move the bounds away from 0,
1565 but reject if X exactly equals the adjusted bounds. */
1566 REAL_ARITHMETIC (l
, MINUS_EXPR
, l
, dconst1
);
1567 if (!no_upper_bound
)
1568 REAL_ARITHMETIC (u
, PLUS_EXPR
, u
, dconst1
);
1569 /* If X is a NaN, use zero instead and show we have an overflow.
1570 Otherwise, range check. */
1571 if (REAL_VALUE_ISNAN (x
))
1572 overflow
= 1, x
= dconst0
;
1573 else if (! (REAL_VALUES_LESS (l
, x
)
1575 && REAL_VALUES_LESS (x
, u
)))
1579 HOST_WIDE_INT low
, high
;
1580 REAL_VALUE_TO_INT (&low
, &high
, x
);
1581 t
= build_int_2 (low
, high
);
1583 TREE_TYPE (t
) = type
;
1585 = TREE_OVERFLOW (arg1
) | force_fit_type (t
, overflow
);
1586 TREE_CONSTANT_OVERFLOW (t
)
1587 = TREE_OVERFLOW (t
) | TREE_CONSTANT_OVERFLOW (arg1
);
1589 TREE_TYPE (t
) = type
;
1591 else if (TREE_CODE (type
) == REAL_TYPE
)
1593 if (TREE_CODE (arg1
) == INTEGER_CST
)
1594 return build_real_from_int_cst (type
, arg1
);
1595 if (TREE_CODE (arg1
) == REAL_CST
)
1597 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
)))
1600 TREE_TYPE (arg1
) = type
;
1604 t
= build_real (type
,
1605 real_value_truncate (TYPE_MODE (type
),
1606 TREE_REAL_CST (arg1
)));
1609 = TREE_OVERFLOW (arg1
) | force_fit_type (t
, 0);
1610 TREE_CONSTANT_OVERFLOW (t
)
1611 = TREE_OVERFLOW (t
) | TREE_CONSTANT_OVERFLOW (arg1
);
1615 TREE_CONSTANT (t
) = 1;
1619 /* Return an expr equal to X but certainly not valid as an lvalue. */
1627 /* These things are certainly not lvalues. */
1628 if (TREE_CODE (x
) == NON_LVALUE_EXPR
1629 || TREE_CODE (x
) == INTEGER_CST
1630 || TREE_CODE (x
) == REAL_CST
1631 || TREE_CODE (x
) == STRING_CST
1632 || TREE_CODE (x
) == ADDR_EXPR
)
1635 result
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
1636 TREE_CONSTANT (result
) = TREE_CONSTANT (x
);
1640 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
1641 Zero means allow extended lvalues. */
1643 int pedantic_lvalues
;
1645 /* When pedantic, return an expr equal to X but certainly not valid as a
1646 pedantic lvalue. Otherwise, return X. */
1649 pedantic_non_lvalue (x
)
1652 if (pedantic_lvalues
)
1653 return non_lvalue (x
);
1658 /* Given a tree comparison code, return the code that is the logical inverse
1659 of the given code. It is not safe to do this for floating-point
1660 comparisons, except for NE_EXPR and EQ_EXPR. */
1662 static enum tree_code
1663 invert_tree_comparison (code
)
1664 enum tree_code code
;
1685 /* Similar, but return the comparison that results if the operands are
1686 swapped. This is safe for floating-point. */
1688 static enum tree_code
1689 swap_tree_comparison (code
)
1690 enum tree_code code
;
1710 /* Return nonzero if CODE is a tree code that represents a truth value. */
1713 truth_value_p (code
)
1714 enum tree_code code
;
1716 return (TREE_CODE_CLASS (code
) == '<'
1717 || code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
1718 || code
== TRUTH_OR_EXPR
|| code
== TRUTH_ORIF_EXPR
1719 || code
== TRUTH_XOR_EXPR
|| code
== TRUTH_NOT_EXPR
);
1722 /* Return nonzero if two operands are necessarily equal.
1723 If ONLY_CONST is non-zero, only return non-zero for constants.
1724 This function tests whether the operands are indistinguishable;
1725 it does not test whether they are equal using C's == operation.
1726 The distinction is important for IEEE floating point, because
1727 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
1728 (2) two NaNs may be indistinguishable, but NaN!=NaN. */
1731 operand_equal_p (arg0
, arg1
, only_const
)
1735 /* If both types don't have the same signedness, then we can't consider
1736 them equal. We must check this before the STRIP_NOPS calls
1737 because they may change the signedness of the arguments. */
1738 if (TREE_UNSIGNED (TREE_TYPE (arg0
)) != TREE_UNSIGNED (TREE_TYPE (arg1
)))
1744 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
1745 /* This is needed for conversions and for COMPONENT_REF.
1746 Might as well play it safe and always test this. */
1747 || TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
1748 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
1749 || TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
)))
1752 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1753 We don't care about side effects in that case because the SAVE_EXPR
1754 takes care of that for us. In all other cases, two expressions are
1755 equal if they have no side effects. If we have two identical
1756 expressions with side effects that should be treated the same due
1757 to the only side effects being identical SAVE_EXPR's, that will
1758 be detected in the recursive calls below. */
1759 if (arg0
== arg1
&& ! only_const
1760 && (TREE_CODE (arg0
) == SAVE_EXPR
1761 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
1764 /* Next handle constant cases, those for which we can return 1 even
1765 if ONLY_CONST is set. */
1766 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
1767 switch (TREE_CODE (arg0
))
1770 return (! TREE_CONSTANT_OVERFLOW (arg0
)
1771 && ! TREE_CONSTANT_OVERFLOW (arg1
)
1772 && tree_int_cst_equal (arg0
, arg1
));
1775 return (! TREE_CONSTANT_OVERFLOW (arg0
)
1776 && ! TREE_CONSTANT_OVERFLOW (arg1
)
1777 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0
),
1778 TREE_REAL_CST (arg1
)));
1784 if (TREE_CONSTANT_OVERFLOW (arg0
)
1785 || TREE_CONSTANT_OVERFLOW (arg1
))
1788 v1
= TREE_VECTOR_CST_ELTS (arg0
);
1789 v2
= TREE_VECTOR_CST_ELTS (arg1
);
1792 if (!operand_equal_p (v1
, v2
, only_const
))
1794 v1
= TREE_CHAIN (v1
);
1795 v2
= TREE_CHAIN (v2
);
1802 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
1804 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
1808 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
1809 && ! memcmp (TREE_STRING_POINTER (arg0
),
1810 TREE_STRING_POINTER (arg1
),
1811 TREE_STRING_LENGTH (arg0
)));
1814 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
1823 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
1826 /* Two conversions are equal only if signedness and modes match. */
1827 if ((TREE_CODE (arg0
) == NOP_EXPR
|| TREE_CODE (arg0
) == CONVERT_EXPR
)
1828 && (TREE_UNSIGNED (TREE_TYPE (arg0
))
1829 != TREE_UNSIGNED (TREE_TYPE (arg1
))))
1832 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1833 TREE_OPERAND (arg1
, 0), 0);
1837 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0)
1838 && operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1),
1842 /* For commutative ops, allow the other order. */
1843 return ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
1844 || TREE_CODE (arg0
) == MIN_EXPR
|| TREE_CODE (arg0
) == MAX_EXPR
1845 || TREE_CODE (arg0
) == BIT_IOR_EXPR
1846 || TREE_CODE (arg0
) == BIT_XOR_EXPR
1847 || TREE_CODE (arg0
) == BIT_AND_EXPR
1848 || TREE_CODE (arg0
) == NE_EXPR
|| TREE_CODE (arg0
) == EQ_EXPR
)
1849 && operand_equal_p (TREE_OPERAND (arg0
, 0),
1850 TREE_OPERAND (arg1
, 1), 0)
1851 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1852 TREE_OPERAND (arg1
, 0), 0));
1855 /* If either of the pointer (or reference) expressions we are dereferencing
1856 contain a side effect, these cannot be equal. */
1857 if (TREE_SIDE_EFFECTS (arg0
)
1858 || TREE_SIDE_EFFECTS (arg1
))
1861 switch (TREE_CODE (arg0
))
1864 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1865 TREE_OPERAND (arg1
, 0), 0);
1869 case ARRAY_RANGE_REF
:
1870 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
1871 TREE_OPERAND (arg1
, 0), 0)
1872 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1873 TREE_OPERAND (arg1
, 1), 0));
1876 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
1877 TREE_OPERAND (arg1
, 0), 0)
1878 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1879 TREE_OPERAND (arg1
, 1), 0)
1880 && operand_equal_p (TREE_OPERAND (arg0
, 2),
1881 TREE_OPERAND (arg1
, 2), 0));
1887 if (TREE_CODE (arg0
) == RTL_EXPR
)
1888 return rtx_equal_p (RTL_EXPR_RTL (arg0
), RTL_EXPR_RTL (arg1
));
1896 /* Similar to operand_equal_p, but see if ARG0 might have been made by
1897 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
1899 When in doubt, return 0. */
1902 operand_equal_for_comparison_p (arg0
, arg1
, other
)
1906 int unsignedp1
, unsignedpo
;
1907 tree primarg0
, primarg1
, primother
;
1908 unsigned int correct_width
;
1910 if (operand_equal_p (arg0
, arg1
, 0))
1913 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
1914 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
1917 /* Discard any conversions that don't change the modes of ARG0 and ARG1
1918 and see if the inner values are the same. This removes any
1919 signedness comparison, which doesn't matter here. */
1920 primarg0
= arg0
, primarg1
= arg1
;
1921 STRIP_NOPS (primarg0
);
1922 STRIP_NOPS (primarg1
);
1923 if (operand_equal_p (primarg0
, primarg1
, 0))
1926 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
1927 actual comparison operand, ARG0.
1929 First throw away any conversions to wider types
1930 already present in the operands. */
1932 primarg1
= get_narrower (arg1
, &unsignedp1
);
1933 primother
= get_narrower (other
, &unsignedpo
);
1935 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
1936 if (unsignedp1
== unsignedpo
1937 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
1938 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
1940 tree type
= TREE_TYPE (arg0
);
1942 /* Make sure shorter operand is extended the right way
1943 to match the longer operand. */
1944 primarg1
= convert ((*lang_hooks
.types
.signed_or_unsigned_type
)
1945 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
1947 if (operand_equal_p (arg0
, convert (type
, primarg1
), 0))
1954 /* See if ARG is an expression that is either a comparison or is performing
1955 arithmetic on comparisons. The comparisons must only be comparing
1956 two different values, which will be stored in *CVAL1 and *CVAL2; if
1957 they are non-zero it means that some operands have already been found.
1958 No variables may be used anywhere else in the expression except in the
1959 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
1960 the expression and save_expr needs to be called with CVAL1 and CVAL2.
1962 If this is true, return 1. Otherwise, return zero. */
1965 twoval_comparison_p (arg
, cval1
, cval2
, save_p
)
1967 tree
*cval1
, *cval2
;
1970 enum tree_code code
= TREE_CODE (arg
);
1971 char class = TREE_CODE_CLASS (code
);
1973 /* We can handle some of the 'e' cases here. */
1974 if (class == 'e' && code
== TRUTH_NOT_EXPR
)
1976 else if (class == 'e'
1977 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
1978 || code
== COMPOUND_EXPR
))
1981 else if (class == 'e' && code
== SAVE_EXPR
&& SAVE_EXPR_RTL (arg
) == 0
1982 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
1984 /* If we've already found a CVAL1 or CVAL2, this expression is
1985 two complex to handle. */
1986 if (*cval1
|| *cval2
)
1996 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
1999 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
2000 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2001 cval1
, cval2
, save_p
));
2007 if (code
== COND_EXPR
)
2008 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
2009 cval1
, cval2
, save_p
)
2010 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2011 cval1
, cval2
, save_p
)
2012 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
2013 cval1
, cval2
, save_p
));
2017 /* First see if we can handle the first operand, then the second. For
2018 the second operand, we know *CVAL1 can't be zero. It must be that
2019 one side of the comparison is each of the values; test for the
2020 case where this isn't true by failing if the two operands
2023 if (operand_equal_p (TREE_OPERAND (arg
, 0),
2024 TREE_OPERAND (arg
, 1), 0))
2028 *cval1
= TREE_OPERAND (arg
, 0);
2029 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
2031 else if (*cval2
== 0)
2032 *cval2
= TREE_OPERAND (arg
, 0);
2033 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
2038 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
2040 else if (*cval2
== 0)
2041 *cval2
= TREE_OPERAND (arg
, 1);
2042 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
2054 /* ARG is a tree that is known to contain just arithmetic operations and
2055 comparisons. Evaluate the operations in the tree substituting NEW0 for
2056 any occurrence of OLD0 as an operand of a comparison and likewise for
2060 eval_subst (arg
, old0
, new0
, old1
, new1
)
2062 tree old0
, new0
, old1
, new1
;
2064 tree type
= TREE_TYPE (arg
);
2065 enum tree_code code
= TREE_CODE (arg
);
2066 char class = TREE_CODE_CLASS (code
);
2068 /* We can handle some of the 'e' cases here. */
2069 if (class == 'e' && code
== TRUTH_NOT_EXPR
)
2071 else if (class == 'e'
2072 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2078 return fold (build1 (code
, type
,
2079 eval_subst (TREE_OPERAND (arg
, 0),
2080 old0
, new0
, old1
, new1
)));
2083 return fold (build (code
, type
,
2084 eval_subst (TREE_OPERAND (arg
, 0),
2085 old0
, new0
, old1
, new1
),
2086 eval_subst (TREE_OPERAND (arg
, 1),
2087 old0
, new0
, old1
, new1
)));
2093 return eval_subst (TREE_OPERAND (arg
, 0), old0
, new0
, old1
, new1
);
2096 return eval_subst (TREE_OPERAND (arg
, 1), old0
, new0
, old1
, new1
);
2099 return fold (build (code
, type
,
2100 eval_subst (TREE_OPERAND (arg
, 0),
2101 old0
, new0
, old1
, new1
),
2102 eval_subst (TREE_OPERAND (arg
, 1),
2103 old0
, new0
, old1
, new1
),
2104 eval_subst (TREE_OPERAND (arg
, 2),
2105 old0
, new0
, old1
, new1
)));
2109 /* fall through - ??? */
2113 tree arg0
= TREE_OPERAND (arg
, 0);
2114 tree arg1
= TREE_OPERAND (arg
, 1);
2116 /* We need to check both for exact equality and tree equality. The
2117 former will be true if the operand has a side-effect. In that
2118 case, we know the operand occurred exactly once. */
2120 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
2122 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
2125 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
2127 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
2130 return fold (build (code
, type
, arg0
, arg1
));
2138 /* Return a tree for the case when the result of an expression is RESULT
2139 converted to TYPE and OMITTED was previously an operand of the expression
2140 but is now not needed (e.g., we folded OMITTED * 0).
2142 If OMITTED has side effects, we must evaluate it. Otherwise, just do
2143 the conversion of RESULT to TYPE. */
2146 omit_one_operand (type
, result
, omitted
)
2147 tree type
, result
, omitted
;
2149 tree t
= convert (type
, result
);
2151 if (TREE_SIDE_EFFECTS (omitted
))
2152 return build (COMPOUND_EXPR
, type
, omitted
, t
);
2154 return non_lvalue (t
);
2157 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
2160 pedantic_omit_one_operand (type
, result
, omitted
)
2161 tree type
, result
, omitted
;
2163 tree t
= convert (type
, result
);
2165 if (TREE_SIDE_EFFECTS (omitted
))
2166 return build (COMPOUND_EXPR
, type
, omitted
, t
);
2168 return pedantic_non_lvalue (t
);
2171 /* Return a simplified tree node for the truth-negation of ARG. This
2172 never alters ARG itself. We assume that ARG is an operation that
2173 returns a truth value (0 or 1). */
2176 invert_truthvalue (arg
)
2179 tree type
= TREE_TYPE (arg
);
2180 enum tree_code code
= TREE_CODE (arg
);
2182 if (code
== ERROR_MARK
)
2185 /* If this is a comparison, we can simply invert it, except for
2186 floating-point non-equality comparisons, in which case we just
2187 enclose a TRUTH_NOT_EXPR around what we have. */
2189 if (TREE_CODE_CLASS (code
) == '<')
2191 if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg
, 0)))
2192 && !flag_unsafe_math_optimizations
2195 return build1 (TRUTH_NOT_EXPR
, type
, arg
);
2197 return build (invert_tree_comparison (code
), type
,
2198 TREE_OPERAND (arg
, 0), TREE_OPERAND (arg
, 1));
2204 return convert (type
, build_int_2 (integer_zerop (arg
), 0));
2206 case TRUTH_AND_EXPR
:
2207 return build (TRUTH_OR_EXPR
, type
,
2208 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2209 invert_truthvalue (TREE_OPERAND (arg
, 1)));
2212 return build (TRUTH_AND_EXPR
, type
,
2213 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2214 invert_truthvalue (TREE_OPERAND (arg
, 1)));
2216 case TRUTH_XOR_EXPR
:
2217 /* Here we can invert either operand. We invert the first operand
2218 unless the second operand is a TRUTH_NOT_EXPR in which case our
2219 result is the XOR of the first operand with the inside of the
2220 negation of the second operand. */
2222 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
2223 return build (TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
2224 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
2226 return build (TRUTH_XOR_EXPR
, type
,
2227 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2228 TREE_OPERAND (arg
, 1));
2230 case TRUTH_ANDIF_EXPR
:
2231 return build (TRUTH_ORIF_EXPR
, type
,
2232 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2233 invert_truthvalue (TREE_OPERAND (arg
, 1)));
2235 case TRUTH_ORIF_EXPR
:
2236 return build (TRUTH_ANDIF_EXPR
, type
,
2237 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2238 invert_truthvalue (TREE_OPERAND (arg
, 1)));
2240 case TRUTH_NOT_EXPR
:
2241 return TREE_OPERAND (arg
, 0);
2244 return build (COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
2245 invert_truthvalue (TREE_OPERAND (arg
, 1)),
2246 invert_truthvalue (TREE_OPERAND (arg
, 2)));
2249 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg
, 0),
2250 invert_truthvalue (TREE_OPERAND (arg
, 1)));
2252 case WITH_RECORD_EXPR
:
2253 return build (WITH_RECORD_EXPR
, type
,
2254 invert_truthvalue (TREE_OPERAND (arg
, 0)),
2255 TREE_OPERAND (arg
, 1));
2257 case NON_LVALUE_EXPR
:
2258 return invert_truthvalue (TREE_OPERAND (arg
, 0));
2263 return build1 (TREE_CODE (arg
), type
,
2264 invert_truthvalue (TREE_OPERAND (arg
, 0)));
2267 if (!integer_onep (TREE_OPERAND (arg
, 1)))
2269 return build (EQ_EXPR
, type
, arg
, convert (type
, integer_zero_node
));
2272 return build1 (TRUTH_NOT_EXPR
, type
, arg
);
2274 case CLEANUP_POINT_EXPR
:
2275 return build1 (CLEANUP_POINT_EXPR
, type
,
2276 invert_truthvalue (TREE_OPERAND (arg
, 0)));
2281 if (TREE_CODE (TREE_TYPE (arg
)) != BOOLEAN_TYPE
)
2283 return build1 (TRUTH_NOT_EXPR
, type
, arg
);
2286 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2287 operands are another bit-wise operation with a common input. If so,
2288 distribute the bit operations to save an operation and possibly two if
2289 constants are involved. For example, convert
2290 (A | B) & (A | C) into A | (B & C)
2291 Further simplification will occur if B and C are constants.
2293 If this optimization cannot be done, 0 will be returned. */
2296 distribute_bit_expr (code
, type
, arg0
, arg1
)
2297 enum tree_code code
;
2304 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2305 || TREE_CODE (arg0
) == code
2306 || (TREE_CODE (arg0
) != BIT_AND_EXPR
2307 && TREE_CODE (arg0
) != BIT_IOR_EXPR
))
2310 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0))
2312 common
= TREE_OPERAND (arg0
, 0);
2313 left
= TREE_OPERAND (arg0
, 1);
2314 right
= TREE_OPERAND (arg1
, 1);
2316 else if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1), 0))
2318 common
= TREE_OPERAND (arg0
, 0);
2319 left
= TREE_OPERAND (arg0
, 1);
2320 right
= TREE_OPERAND (arg1
, 0);
2322 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 0), 0))
2324 common
= TREE_OPERAND (arg0
, 1);
2325 left
= TREE_OPERAND (arg0
, 0);
2326 right
= TREE_OPERAND (arg1
, 1);
2328 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1), 0))
2330 common
= TREE_OPERAND (arg0
, 1);
2331 left
= TREE_OPERAND (arg0
, 0);
2332 right
= TREE_OPERAND (arg1
, 0);
2337 return fold (build (TREE_CODE (arg0
), type
, common
,
2338 fold (build (code
, type
, left
, right
))));
2341 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2342 starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
2345 make_bit_field_ref (inner
, type
, bitsize
, bitpos
, unsignedp
)
2348 int bitsize
, bitpos
;
2351 tree result
= build (BIT_FIELD_REF
, type
, inner
,
2352 size_int (bitsize
), bitsize_int (bitpos
));
2354 TREE_UNSIGNED (result
) = unsignedp
;
2359 /* Optimize a bit-field compare.
2361 There are two cases: First is a compare against a constant and the
2362 second is a comparison of two items where the fields are at the same
2363 bit position relative to the start of a chunk (byte, halfword, word)
2364 large enough to contain it. In these cases we can avoid the shift
2365 implicit in bitfield extractions.
2367 For constants, we emit a compare of the shifted constant with the
2368 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2369 compared. For two fields at the same position, we do the ANDs with the
2370 similar mask and compare the result of the ANDs.
2372 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2373 COMPARE_TYPE is the type of the comparison, and LHS and RHS
2374 are the left and right operands of the comparison, respectively.
2376 If the optimization described above can be done, we return the resulting
2377 tree. Otherwise we return zero. */
2380 optimize_bit_field_compare (code
, compare_type
, lhs
, rhs
)
2381 enum tree_code code
;
2385 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
2386 tree type
= TREE_TYPE (lhs
);
2387 tree signed_type
, unsigned_type
;
2388 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
2389 enum machine_mode lmode
, rmode
, nmode
;
2390 int lunsignedp
, runsignedp
;
2391 int lvolatilep
= 0, rvolatilep
= 0;
2392 tree linner
, rinner
= NULL_TREE
;
2396 /* Get all the information about the extractions being done. If the bit size
2397 if the same as the size of the underlying object, we aren't doing an
2398 extraction at all and so can do nothing. We also don't want to
2399 do anything if the inner expression is a PLACEHOLDER_EXPR since we
2400 then will no longer be able to replace it. */
2401 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
2402 &lunsignedp
, &lvolatilep
);
2403 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
2404 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
)
2409 /* If this is not a constant, we can only do something if bit positions,
2410 sizes, and signedness are the same. */
2411 rinner
= get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
2412 &runsignedp
, &rvolatilep
);
2414 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
2415 || lunsignedp
!= runsignedp
|| offset
!= 0
2416 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
)
2420 /* See if we can find a mode to refer to this field. We should be able to,
2421 but fail if we can't. */
2422 nmode
= get_best_mode (lbitsize
, lbitpos
,
2423 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
2424 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
2425 TYPE_ALIGN (TREE_TYPE (rinner
))),
2426 word_mode
, lvolatilep
|| rvolatilep
);
2427 if (nmode
== VOIDmode
)
2430 /* Set signed and unsigned types of the precision of this mode for the
2432 signed_type
= (*lang_hooks
.types
.type_for_mode
) (nmode
, 0);
2433 unsigned_type
= (*lang_hooks
.types
.type_for_mode
) (nmode
, 1);
2435 /* Compute the bit position and size for the new reference and our offset
2436 within it. If the new reference is the same size as the original, we
2437 won't optimize anything, so return zero. */
2438 nbitsize
= GET_MODE_BITSIZE (nmode
);
2439 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
2441 if (nbitsize
== lbitsize
)
2444 if (BYTES_BIG_ENDIAN
)
2445 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
2447 /* Make the mask to be used against the extracted field. */
2448 mask
= build_int_2 (~0, ~0);
2449 TREE_TYPE (mask
) = unsigned_type
;
2450 force_fit_type (mask
, 0);
2451 mask
= convert (unsigned_type
, mask
);
2452 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
), 0);
2453 mask
= const_binop (RSHIFT_EXPR
, mask
,
2454 size_int (nbitsize
- lbitsize
- lbitpos
), 0);
2457 /* If not comparing with constant, just rework the comparison
2459 return build (code
, compare_type
,
2460 build (BIT_AND_EXPR
, unsigned_type
,
2461 make_bit_field_ref (linner
, unsigned_type
,
2462 nbitsize
, nbitpos
, 1),
2464 build (BIT_AND_EXPR
, unsigned_type
,
2465 make_bit_field_ref (rinner
, unsigned_type
,
2466 nbitsize
, nbitpos
, 1),
2469 /* Otherwise, we are handling the constant case. See if the constant is too
2470 big for the field. Warn and return a tree of for 0 (false) if so. We do
2471 this not only for its own sake, but to avoid having to test for this
2472 error case below. If we didn't, we might generate wrong code.
2474 For unsigned fields, the constant shifted right by the field length should
2475 be all zero. For signed fields, the high-order bits should agree with
2480 if (! integer_zerop (const_binop (RSHIFT_EXPR
,
2481 convert (unsigned_type
, rhs
),
2482 size_int (lbitsize
), 0)))
2484 warning ("comparison is always %d due to width of bit-field",
2486 return convert (compare_type
,
2488 ? integer_one_node
: integer_zero_node
));
2493 tree tem
= const_binop (RSHIFT_EXPR
, convert (signed_type
, rhs
),
2494 size_int (lbitsize
- 1), 0);
2495 if (! integer_zerop (tem
) && ! integer_all_onesp (tem
))
2497 warning ("comparison is always %d due to width of bit-field",
2499 return convert (compare_type
,
2501 ? integer_one_node
: integer_zero_node
));
2505 /* Single-bit compares should always be against zero. */
2506 if (lbitsize
== 1 && ! integer_zerop (rhs
))
2508 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
2509 rhs
= convert (type
, integer_zero_node
);
2512 /* Make a new bitfield reference, shift the constant over the
2513 appropriate number of bits and mask it with the computed mask
2514 (in case this was a signed field). If we changed it, make a new one. */
2515 lhs
= make_bit_field_ref (linner
, unsigned_type
, nbitsize
, nbitpos
, 1);
2518 TREE_SIDE_EFFECTS (lhs
) = 1;
2519 TREE_THIS_VOLATILE (lhs
) = 1;
2522 rhs
= fold (const_binop (BIT_AND_EXPR
,
2523 const_binop (LSHIFT_EXPR
,
2524 convert (unsigned_type
, rhs
),
2525 size_int (lbitpos
), 0),
2528 return build (code
, compare_type
,
2529 build (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
),
2533 /* Subroutine for fold_truthop: decode a field reference.
2535 If EXP is a comparison reference, we return the innermost reference.
2537 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2538 set to the starting bit number.
2540 If the innermost field can be completely contained in a mode-sized
2541 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
2543 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2544 otherwise it is not changed.
2546 *PUNSIGNEDP is set to the signedness of the field.
2548 *PMASK is set to the mask used. This is either contained in a
2549 BIT_AND_EXPR or derived from the width of the field.
2551 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
2553 Return 0 if this is not a component reference or is one that we can't
2554 do anything with. */
2557 decode_field_reference (exp
, pbitsize
, pbitpos
, pmode
, punsignedp
,
2558 pvolatilep
, pmask
, pand_mask
)
2560 HOST_WIDE_INT
*pbitsize
, *pbitpos
;
2561 enum machine_mode
*pmode
;
2562 int *punsignedp
, *pvolatilep
;
2567 tree mask
, inner
, offset
;
2569 unsigned int precision
;
2571 /* All the optimizations using this function assume integer fields.
2572 There are problems with FP fields since the type_for_size call
2573 below can fail for, e.g., XFmode. */
2574 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
2579 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
2581 and_mask
= TREE_OPERAND (exp
, 1);
2582 exp
= TREE_OPERAND (exp
, 0);
2583 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
2584 if (TREE_CODE (and_mask
) != INTEGER_CST
)
2588 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
2589 punsignedp
, pvolatilep
);
2590 if ((inner
== exp
&& and_mask
== 0)
2591 || *pbitsize
< 0 || offset
!= 0
2592 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
2595 /* Compute the mask to access the bitfield. */
2596 unsigned_type
= (*lang_hooks
.types
.type_for_size
) (*pbitsize
, 1);
2597 precision
= TYPE_PRECISION (unsigned_type
);
2599 mask
= build_int_2 (~0, ~0);
2600 TREE_TYPE (mask
) = unsigned_type
;
2601 force_fit_type (mask
, 0);
2602 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
), 0);
2603 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
), 0);
2605 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
2607 mask
= fold (build (BIT_AND_EXPR
, unsigned_type
,
2608 convert (unsigned_type
, and_mask
), mask
));
2611 *pand_mask
= and_mask
;
2615 /* Return non-zero if MASK represents a mask of SIZE ones in the low-order
2619 all_ones_mask_p (mask
, size
)
2623 tree type
= TREE_TYPE (mask
);
2624 unsigned int precision
= TYPE_PRECISION (type
);
2627 tmask
= build_int_2 (~0, ~0);
2628 TREE_TYPE (tmask
) = (*lang_hooks
.types
.signed_type
) (type
);
2629 force_fit_type (tmask
, 0);
2631 tree_int_cst_equal (mask
,
2632 const_binop (RSHIFT_EXPR
,
2633 const_binop (LSHIFT_EXPR
, tmask
,
2634 size_int (precision
- size
),
2636 size_int (precision
- size
), 0));
2639 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
2640 represents the sign bit of EXP's type. If EXP represents a sign
2641 or zero extension, also test VAL against the unextended type.
2642 The return value is the (sub)expression whose sign bit is VAL,
2643 or NULL_TREE otherwise. */
2646 sign_bit_p (exp
, val
)
2650 unsigned HOST_WIDE_INT lo
;
2655 /* Tree EXP must have a integral type. */
2656 t
= TREE_TYPE (exp
);
2657 if (! INTEGRAL_TYPE_P (t
))
2660 /* Tree VAL must be an integer constant. */
2661 if (TREE_CODE (val
) != INTEGER_CST
2662 || TREE_CONSTANT_OVERFLOW (val
))
2665 width
= TYPE_PRECISION (t
);
2666 if (width
> HOST_BITS_PER_WIDE_INT
)
2668 hi
= (unsigned HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
- 1);
2674 lo
= (unsigned HOST_WIDE_INT
) 1 << (width
- 1);
2677 if (TREE_INT_CST_HIGH (val
) == hi
&& TREE_INT_CST_LOW (val
) == lo
)
2680 /* Handle extension from a narrower type. */
2681 if (TREE_CODE (exp
) == NOP_EXPR
2682 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
2683 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
2688 /* Subroutine for fold_truthop: determine if an operand is simple enough
2689 to be evaluated unconditionally. */
2692 simple_operand_p (exp
)
2695 /* Strip any conversions that don't change the machine mode. */
2696 while ((TREE_CODE (exp
) == NOP_EXPR
2697 || TREE_CODE (exp
) == CONVERT_EXPR
)
2698 && (TYPE_MODE (TREE_TYPE (exp
))
2699 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
2700 exp
= TREE_OPERAND (exp
, 0);
2702 return (TREE_CODE_CLASS (TREE_CODE (exp
)) == 'c'
2704 && ! TREE_ADDRESSABLE (exp
)
2705 && ! TREE_THIS_VOLATILE (exp
)
2706 && ! DECL_NONLOCAL (exp
)
2707 /* Don't regard global variables as simple. They may be
2708 allocated in ways unknown to the compiler (shared memory,
2709 #pragma weak, etc). */
2710 && ! TREE_PUBLIC (exp
)
2711 && ! DECL_EXTERNAL (exp
)
2712 /* Loading a static variable is unduly expensive, but global
2713 registers aren't expensive. */
2714 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
2717 /* The following functions are subroutines to fold_range_test and allow it to
2718 try to change a logical combination of comparisons into a range test.
2721 X == 2 || X == 3 || X == 4 || X == 5
2725 (unsigned) (X - 2) <= 3
2727 We describe each set of comparisons as being either inside or outside
2728 a range, using a variable named like IN_P, and then describe the
2729 range with a lower and upper bound. If one of the bounds is omitted,
2730 it represents either the highest or lowest value of the type.
2732 In the comments below, we represent a range by two numbers in brackets
2733 preceded by a "+" to designate being inside that range, or a "-" to
2734 designate being outside that range, so the condition can be inverted by
2735 flipping the prefix. An omitted bound is represented by a "-". For
2736 example, "- [-, 10]" means being outside the range starting at the lowest
2737 possible value and ending at 10, in other words, being greater than 10.
2738 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
2741 We set up things so that the missing bounds are handled in a consistent
2742 manner so neither a missing bound nor "true" and "false" need to be
2743 handled using a special case. */
2745 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
2746 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
2747 and UPPER1_P are nonzero if the respective argument is an upper bound
2748 and zero for a lower. TYPE, if nonzero, is the type of the result; it
2749 must be specified for a comparison. ARG1 will be converted to ARG0's
2750 type if both are specified. */
2753 range_binop (code
, type
, arg0
, upper0_p
, arg1
, upper1_p
)
2754 enum tree_code code
;
2757 int upper0_p
, upper1_p
;
2763 /* If neither arg represents infinity, do the normal operation.
2764 Else, if not a comparison, return infinity. Else handle the special
2765 comparison rules. Note that most of the cases below won't occur, but
2766 are handled for consistency. */
2768 if (arg0
!= 0 && arg1
!= 0)
2770 tem
= fold (build (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
2771 arg0
, convert (TREE_TYPE (arg0
), arg1
)));
2773 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
2776 if (TREE_CODE_CLASS (code
) != '<')
2779 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
2780 for neither. In real maths, we cannot assume open ended ranges are
2781 the same. But, this is computer arithmetic, where numbers are finite.
2782 We can therefore make the transformation of any unbounded range with
2783 the value Z, Z being greater than any representable number. This permits
2784 us to treat unbounded ranges as equal. */
2785 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
2786 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
2790 result
= sgn0
== sgn1
;
2793 result
= sgn0
!= sgn1
;
2796 result
= sgn0
< sgn1
;
2799 result
= sgn0
<= sgn1
;
2802 result
= sgn0
> sgn1
;
2805 result
= sgn0
>= sgn1
;
2811 return convert (type
, result
? integer_one_node
: integer_zero_node
);
2814 /* Given EXP, a logical expression, set the range it is testing into
2815 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
2816 actually being tested. *PLOW and *PHIGH will be made of the same type
2817 as the returned expression. If EXP is not a comparison, we will most
2818 likely not be returning a useful value and range. */
2821 make_range (exp
, pin_p
, plow
, phigh
)
2826 enum tree_code code
;
2827 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, type
= NULL_TREE
;
2828 tree orig_type
= NULL_TREE
;
2830 tree low
, high
, n_low
, n_high
;
2832 /* Start with simply saying "EXP != 0" and then look at the code of EXP
2833 and see if we can refine the range. Some of the cases below may not
2834 happen, but it doesn't seem worth worrying about this. We "continue"
2835 the outer loop when we've changed something; otherwise we "break"
2836 the switch, which will "break" the while. */
2838 in_p
= 0, low
= high
= convert (TREE_TYPE (exp
), integer_zero_node
);
2842 code
= TREE_CODE (exp
);
2844 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
2846 arg0
= TREE_OPERAND (exp
, 0);
2847 if (TREE_CODE_CLASS (code
) == '<'
2848 || TREE_CODE_CLASS (code
) == '1'
2849 || TREE_CODE_CLASS (code
) == '2')
2850 type
= TREE_TYPE (arg0
);
2851 if (TREE_CODE_CLASS (code
) == '2'
2852 || TREE_CODE_CLASS (code
) == '<'
2853 || (TREE_CODE_CLASS (code
) == 'e'
2854 && TREE_CODE_LENGTH (code
) > 1))
2855 arg1
= TREE_OPERAND (exp
, 1);
2858 /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
2859 lose a cast by accident. */
2860 if (type
!= NULL_TREE
&& orig_type
== NULL_TREE
)
2865 case TRUTH_NOT_EXPR
:
2866 in_p
= ! in_p
, exp
= arg0
;
2869 case EQ_EXPR
: case NE_EXPR
:
2870 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
2871 /* We can only do something if the range is testing for zero
2872 and if the second operand is an integer constant. Note that
2873 saying something is "in" the range we make is done by
2874 complementing IN_P since it will set in the initial case of
2875 being not equal to zero; "out" is leaving it alone. */
2876 if (low
== 0 || high
== 0
2877 || ! integer_zerop (low
) || ! integer_zerop (high
)
2878 || TREE_CODE (arg1
) != INTEGER_CST
)
2883 case NE_EXPR
: /* - [c, c] */
2886 case EQ_EXPR
: /* + [c, c] */
2887 in_p
= ! in_p
, low
= high
= arg1
;
2889 case GT_EXPR
: /* - [-, c] */
2890 low
= 0, high
= arg1
;
2892 case GE_EXPR
: /* + [c, -] */
2893 in_p
= ! in_p
, low
= arg1
, high
= 0;
2895 case LT_EXPR
: /* - [c, -] */
2896 low
= arg1
, high
= 0;
2898 case LE_EXPR
: /* + [-, c] */
2899 in_p
= ! in_p
, low
= 0, high
= arg1
;
2907 /* If this is an unsigned comparison, we also know that EXP is
2908 greater than or equal to zero. We base the range tests we make
2909 on that fact, so we record it here so we can parse existing
2911 if (TREE_UNSIGNED (type
) && (low
== 0 || high
== 0))
2913 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, in_p
, low
, high
,
2914 1, convert (type
, integer_zero_node
),
2918 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
2920 /* If the high bound is missing, but we
2921 have a low bound, reverse the range so
2922 it goes from zero to the low bound minus 1. */
2923 if (high
== 0 && low
)
2926 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
2927 integer_one_node
, 0);
2928 low
= convert (type
, integer_zero_node
);
2934 /* (-x) IN [a,b] -> x in [-b, -a] */
2935 n_low
= range_binop (MINUS_EXPR
, type
,
2936 convert (type
, integer_zero_node
), 0, high
, 1);
2937 n_high
= range_binop (MINUS_EXPR
, type
,
2938 convert (type
, integer_zero_node
), 0, low
, 0);
2939 low
= n_low
, high
= n_high
;
2945 exp
= build (MINUS_EXPR
, type
, negate_expr (arg0
),
2946 convert (type
, integer_one_node
));
2949 case PLUS_EXPR
: case MINUS_EXPR
:
2950 if (TREE_CODE (arg1
) != INTEGER_CST
)
2953 /* If EXP is signed, any overflow in the computation is undefined,
2954 so we don't worry about it so long as our computations on
2955 the bounds don't overflow. For unsigned, overflow is defined
2956 and this is exactly the right thing. */
2957 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
2958 type
, low
, 0, arg1
, 0);
2959 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
2960 type
, high
, 1, arg1
, 0);
2961 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
2962 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
2965 /* Check for an unsigned range which has wrapped around the maximum
2966 value thus making n_high < n_low, and normalize it. */
2967 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
2969 low
= range_binop (PLUS_EXPR
, type
, n_high
, 0,
2970 integer_one_node
, 0);
2971 high
= range_binop (MINUS_EXPR
, type
, n_low
, 0,
2972 integer_one_node
, 0);
2974 /* If the range is of the form +/- [ x+1, x ], we won't
2975 be able to normalize it. But then, it represents the
2976 whole range or the empty set, so make it
2978 if (tree_int_cst_equal (n_low
, low
)
2979 && tree_int_cst_equal (n_high
, high
))
2985 low
= n_low
, high
= n_high
;
2990 case NOP_EXPR
: case NON_LVALUE_EXPR
: case CONVERT_EXPR
:
2991 if (TYPE_PRECISION (type
) > TYPE_PRECISION (orig_type
))
2994 if (! INTEGRAL_TYPE_P (type
)
2995 || (low
!= 0 && ! int_fits_type_p (low
, type
))
2996 || (high
!= 0 && ! int_fits_type_p (high
, type
)))
2999 n_low
= low
, n_high
= high
;
3002 n_low
= convert (type
, n_low
);
3005 n_high
= convert (type
, n_high
);
3007 /* If we're converting from an unsigned to a signed type,
3008 we will be doing the comparison as unsigned. The tests above
3009 have already verified that LOW and HIGH are both positive.
3011 So we have to make sure that the original unsigned value will
3012 be interpreted as positive. */
3013 if (TREE_UNSIGNED (type
) && ! TREE_UNSIGNED (TREE_TYPE (exp
)))
3015 tree equiv_type
= (*lang_hooks
.types
.type_for_mode
)
3016 (TYPE_MODE (type
), 1);
3019 /* A range without an upper bound is, naturally, unbounded.
3020 Since convert would have cropped a very large value, use
3021 the max value for the destination type. */
3023 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
3024 : TYPE_MAX_VALUE (type
);
3026 high_positive
= fold (build (RSHIFT_EXPR
, type
,
3027 convert (type
, high_positive
),
3028 convert (type
, integer_one_node
)));
3030 /* If the low bound is specified, "and" the range with the
3031 range for which the original unsigned value will be
3035 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
3037 1, convert (type
, integer_zero_node
),
3041 in_p
= (n_in_p
== in_p
);
3045 /* Otherwise, "or" the range with the range of the input
3046 that will be interpreted as negative. */
3047 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
3049 1, convert (type
, integer_zero_node
),
3053 in_p
= (in_p
!= n_in_p
);
3058 low
= n_low
, high
= n_high
;
3068 /* If EXP is a constant, we can evaluate whether this is true or false. */
3069 if (TREE_CODE (exp
) == INTEGER_CST
)
3071 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
3073 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
3079 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
3083 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3084 type, TYPE, return an expression to test if EXP is in (or out of, depending
3085 on IN_P) the range. */
3088 build_range_check (type
, exp
, in_p
, low
, high
)
3094 tree etype
= TREE_TYPE (exp
);
3098 && (0 != (value
= build_range_check (type
, exp
, 1, low
, high
))))
3099 return invert_truthvalue (value
);
3101 if (low
== 0 && high
== 0)
3102 return convert (type
, integer_one_node
);
3105 return fold (build (LE_EXPR
, type
, exp
, high
));
3108 return fold (build (GE_EXPR
, type
, exp
, low
));
3110 if (operand_equal_p (low
, high
, 0))
3111 return fold (build (EQ_EXPR
, type
, exp
, low
));
3113 if (integer_zerop (low
))
3115 if (! TREE_UNSIGNED (etype
))
3117 etype
= (*lang_hooks
.types
.unsigned_type
) (etype
);
3118 high
= convert (etype
, high
);
3119 exp
= convert (etype
, exp
);
3121 return build_range_check (type
, exp
, 1, 0, high
);
3124 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
3125 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
3127 unsigned HOST_WIDE_INT lo
;
3131 prec
= TYPE_PRECISION (etype
);
3132 if (prec
<= HOST_BITS_PER_WIDE_INT
)
3135 lo
= ((unsigned HOST_WIDE_INT
) 1 << (prec
- 1)) - 1;
3139 hi
= ((HOST_WIDE_INT
) 1 << (prec
- HOST_BITS_PER_WIDE_INT
- 1)) - 1;
3140 lo
= (unsigned HOST_WIDE_INT
) -1;
3143 if (TREE_INT_CST_HIGH (high
) == hi
&& TREE_INT_CST_LOW (high
) == lo
)
3145 if (TREE_UNSIGNED (etype
))
3147 etype
= (*lang_hooks
.types
.signed_type
) (etype
);
3148 exp
= convert (etype
, exp
);
3150 return fold (build (GT_EXPR
, type
, exp
,
3151 convert (etype
, integer_zero_node
)));
3155 if (0 != (value
= const_binop (MINUS_EXPR
, high
, low
, 0))
3156 && ! TREE_OVERFLOW (value
))
3157 return build_range_check (type
,
3158 fold (build (MINUS_EXPR
, etype
, exp
, low
)),
3159 1, convert (etype
, integer_zero_node
), value
);
3164 /* Given two ranges, see if we can merge them into one. Return 1 if we
3165 can, 0 if we can't. Set the output range into the specified parameters. */
3168 merge_ranges (pin_p
, plow
, phigh
, in0_p
, low0
, high0
, in1_p
, low1
, high1
)
3172 tree low0
, high0
, low1
, high1
;
3180 int lowequal
= ((low0
== 0 && low1
== 0)
3181 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
3182 low0
, 0, low1
, 0)));
3183 int highequal
= ((high0
== 0 && high1
== 0)
3184 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
3185 high0
, 1, high1
, 1)));
3187 /* Make range 0 be the range that starts first, or ends last if they
3188 start at the same value. Swap them if it isn't. */
3189 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
3192 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
3193 high1
, 1, high0
, 1))))
3195 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
3196 tem
= low0
, low0
= low1
, low1
= tem
;
3197 tem
= high0
, high0
= high1
, high1
= tem
;
3200 /* Now flag two cases, whether the ranges are disjoint or whether the
3201 second range is totally subsumed in the first. Note that the tests
3202 below are simplified by the ones above. */
3203 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
3204 high0
, 1, low1
, 0));
3205 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
3206 high1
, 1, high0
, 1));
3208 /* We now have four cases, depending on whether we are including or
3209 excluding the two ranges. */
3212 /* If they don't overlap, the result is false. If the second range
3213 is a subset it is the result. Otherwise, the range is from the start
3214 of the second to the end of the first. */
3216 in_p
= 0, low
= high
= 0;
3218 in_p
= 1, low
= low1
, high
= high1
;
3220 in_p
= 1, low
= low1
, high
= high0
;
3223 else if (in0_p
&& ! in1_p
)
3225 /* If they don't overlap, the result is the first range. If they are
3226 equal, the result is false. If the second range is a subset of the
3227 first, and the ranges begin at the same place, we go from just after
3228 the end of the first range to the end of the second. If the second
3229 range is not a subset of the first, or if it is a subset and both
3230 ranges end at the same place, the range starts at the start of the
3231 first range and ends just before the second range.
3232 Otherwise, we can't describe this as a single range. */
3234 in_p
= 1, low
= low0
, high
= high0
;
3235 else if (lowequal
&& highequal
)
3236 in_p
= 0, low
= high
= 0;
3237 else if (subset
&& lowequal
)
3239 in_p
= 1, high
= high0
;
3240 low
= range_binop (PLUS_EXPR
, NULL_TREE
, high1
, 0,
3241 integer_one_node
, 0);
3243 else if (! subset
|| highequal
)
3245 in_p
= 1, low
= low0
;
3246 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low1
, 0,
3247 integer_one_node
, 0);
3253 else if (! in0_p
&& in1_p
)
3255 /* If they don't overlap, the result is the second range. If the second
3256 is a subset of the first, the result is false. Otherwise,
3257 the range starts just after the first range and ends at the
3258 end of the second. */
3260 in_p
= 1, low
= low1
, high
= high1
;
3261 else if (subset
|| highequal
)
3262 in_p
= 0, low
= high
= 0;
3265 in_p
= 1, high
= high1
;
3266 low
= range_binop (PLUS_EXPR
, NULL_TREE
, high0
, 1,
3267 integer_one_node
, 0);
3273 /* The case where we are excluding both ranges. Here the complex case
3274 is if they don't overlap. In that case, the only time we have a
3275 range is if they are adjacent. If the second is a subset of the
3276 first, the result is the first. Otherwise, the range to exclude
3277 starts at the beginning of the first range and ends at the end of the
3281 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
3282 range_binop (PLUS_EXPR
, NULL_TREE
,
3284 integer_one_node
, 1),
3286 in_p
= 0, low
= low0
, high
= high1
;
3291 in_p
= 0, low
= low0
, high
= high0
;
3293 in_p
= 0, low
= low0
, high
= high1
;
3296 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
3300 /* EXP is some logical combination of boolean tests. See if we can
3301 merge it into some range test. Return the new tree if so. */
3304 fold_range_test (exp
)
3307 int or_op
= (TREE_CODE (exp
) == TRUTH_ORIF_EXPR
3308 || TREE_CODE (exp
) == TRUTH_OR_EXPR
);
3309 int in0_p
, in1_p
, in_p
;
3310 tree low0
, low1
, low
, high0
, high1
, high
;
3311 tree lhs
= make_range (TREE_OPERAND (exp
, 0), &in0_p
, &low0
, &high0
);
3312 tree rhs
= make_range (TREE_OPERAND (exp
, 1), &in1_p
, &low1
, &high1
);
3315 /* If this is an OR operation, invert both sides; we will invert
3316 again at the end. */
3318 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
3320 /* If both expressions are the same, if we can merge the ranges, and we
3321 can build the range test, return it or it inverted. If one of the
3322 ranges is always true or always false, consider it to be the same
3323 expression as the other. */
3324 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
3325 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
3327 && 0 != (tem
= (build_range_check (TREE_TYPE (exp
),
3329 : rhs
!= 0 ? rhs
: integer_zero_node
,
3331 return or_op
? invert_truthvalue (tem
) : tem
;
3333 /* On machines where the branch cost is expensive, if this is a
3334 short-circuited branch and the underlying object on both sides
3335 is the same, make a non-short-circuit operation. */
3336 else if (BRANCH_COST
>= 2
3337 && lhs
!= 0 && rhs
!= 0
3338 && (TREE_CODE (exp
) == TRUTH_ANDIF_EXPR
3339 || TREE_CODE (exp
) == TRUTH_ORIF_EXPR
)
3340 && operand_equal_p (lhs
, rhs
, 0))
3342 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
3343 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3344 which cases we can't do this. */
3345 if (simple_operand_p (lhs
))
3346 return build (TREE_CODE (exp
) == TRUTH_ANDIF_EXPR
3347 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
3348 TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
3349 TREE_OPERAND (exp
, 1));
3351 else if ((*lang_hooks
.decls
.global_bindings_p
) () == 0
3352 && ! contains_placeholder_p (lhs
))
3354 tree common
= save_expr (lhs
);
3356 if (0 != (lhs
= build_range_check (TREE_TYPE (exp
), common
,
3357 or_op
? ! in0_p
: in0_p
,
3359 && (0 != (rhs
= build_range_check (TREE_TYPE (exp
), common
,
3360 or_op
? ! in1_p
: in1_p
,
3362 return build (TREE_CODE (exp
) == TRUTH_ANDIF_EXPR
3363 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
3364 TREE_TYPE (exp
), lhs
, rhs
);
3371 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3372 bit value. Arrange things so the extra bits will be set to zero if and
3373 only if C is signed-extended to its full width. If MASK is nonzero,
3374 it is an INTEGER_CST that should be AND'ed with the extra bits. */
3377 unextend (c
, p
, unsignedp
, mask
)
3383 tree type
= TREE_TYPE (c
);
3384 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
3387 if (p
== modesize
|| unsignedp
)
3390 /* We work by getting just the sign bit into the low-order bit, then
3391 into the high-order bit, then sign-extend. We then XOR that value
3393 temp
= const_binop (RSHIFT_EXPR
, c
, size_int (p
- 1), 0);
3394 temp
= const_binop (BIT_AND_EXPR
, temp
, size_int (1), 0);
3396 /* We must use a signed type in order to get an arithmetic right shift.
3397 However, we must also avoid introducing accidental overflows, so that
3398 a subsequent call to integer_zerop will work. Hence we must
3399 do the type conversion here. At this point, the constant is either
3400 zero or one, and the conversion to a signed type can never overflow.
3401 We could get an overflow if this conversion is done anywhere else. */
3402 if (TREE_UNSIGNED (type
))
3403 temp
= convert ((*lang_hooks
.types
.signed_type
) (type
), temp
);
3405 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1), 0);
3406 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1), 0);
3408 temp
= const_binop (BIT_AND_EXPR
, temp
, convert (TREE_TYPE (c
), mask
), 0);
3409 /* If necessary, convert the type back to match the type of C. */
3410 if (TREE_UNSIGNED (type
))
3411 temp
= convert (type
, temp
);
3413 return convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
, 0));
3416 /* Find ways of folding logical expressions of LHS and RHS:
3417 Try to merge two comparisons to the same innermost item.
3418 Look for range tests like "ch >= '0' && ch <= '9'".
3419 Look for combinations of simple terms on machines with expensive branches
3420 and evaluate the RHS unconditionally.
3422 For example, if we have p->a == 2 && p->b == 4 and we can make an
3423 object large enough to span both A and B, we can do this with a comparison
3424 against the object ANDed with the a mask.
3426 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3427 operations to do this with one comparison.
3429 We check for both normal comparisons and the BIT_AND_EXPRs made this by
3430 function and the one above.
3432 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
3433 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3435 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3438 We return the simplified tree or 0 if no optimization is possible. */
3441 fold_truthop (code
, truth_type
, lhs
, rhs
)
3442 enum tree_code code
;
3443 tree truth_type
, lhs
, rhs
;
3445 /* If this is the "or" of two comparisons, we can do something if
3446 the comparisons are NE_EXPR. If this is the "and", we can do something
3447 if the comparisons are EQ_EXPR. I.e.,
3448 (a->b == 2 && a->c == 4) can become (a->new == NEW).
3450 WANTED_CODE is this operation code. For single bit fields, we can
3451 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3452 comparison for one-bit fields. */
3454 enum tree_code wanted_code
;
3455 enum tree_code lcode
, rcode
;
3456 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
3457 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
3458 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
3459 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
3460 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
3461 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
3462 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
3463 enum machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
3464 enum machine_mode lnmode
, rnmode
;
3465 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
3466 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
3467 tree l_const
, r_const
;
3468 tree lntype
, rntype
, result
;
3469 int first_bit
, end_bit
;
3472 /* Start by getting the comparison codes. Fail if anything is volatile.
3473 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3474 it were surrounded with a NE_EXPR. */
3476 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
3479 lcode
= TREE_CODE (lhs
);
3480 rcode
= TREE_CODE (rhs
);
3482 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
3483 lcode
= NE_EXPR
, lhs
= build (NE_EXPR
, truth_type
, lhs
, integer_zero_node
);
3485 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
3486 rcode
= NE_EXPR
, rhs
= build (NE_EXPR
, truth_type
, rhs
, integer_zero_node
);
3488 if (TREE_CODE_CLASS (lcode
) != '<' || TREE_CODE_CLASS (rcode
) != '<')
3491 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
3492 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
3494 ll_arg
= TREE_OPERAND (lhs
, 0);
3495 lr_arg
= TREE_OPERAND (lhs
, 1);
3496 rl_arg
= TREE_OPERAND (rhs
, 0);
3497 rr_arg
= TREE_OPERAND (rhs
, 1);
3499 /* If the RHS can be evaluated unconditionally and its operands are
3500 simple, it wins to evaluate the RHS unconditionally on machines
3501 with expensive branches. In this case, this isn't a comparison
3502 that can be merged. Avoid doing this if the RHS is a floating-point
3503 comparison since those can trap. */
3505 if (BRANCH_COST
>= 2
3506 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
3507 && simple_operand_p (rl_arg
)
3508 && simple_operand_p (rr_arg
))
3509 return build (code
, truth_type
, lhs
, rhs
);
3511 /* See if the comparisons can be merged. Then get all the parameters for
3514 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
3515 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
3519 ll_inner
= decode_field_reference (ll_arg
,
3520 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
3521 &ll_unsignedp
, &volatilep
, &ll_mask
,
3523 lr_inner
= decode_field_reference (lr_arg
,
3524 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
3525 &lr_unsignedp
, &volatilep
, &lr_mask
,
3527 rl_inner
= decode_field_reference (rl_arg
,
3528 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
3529 &rl_unsignedp
, &volatilep
, &rl_mask
,
3531 rr_inner
= decode_field_reference (rr_arg
,
3532 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
3533 &rr_unsignedp
, &volatilep
, &rr_mask
,
3536 /* It must be true that the inner operation on the lhs of each
3537 comparison must be the same if we are to be able to do anything.
3538 Then see if we have constants. If not, the same must be true for
3540 if (volatilep
|| ll_inner
== 0 || rl_inner
== 0
3541 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
3544 if (TREE_CODE (lr_arg
) == INTEGER_CST
3545 && TREE_CODE (rr_arg
) == INTEGER_CST
)
3546 l_const
= lr_arg
, r_const
= rr_arg
;
3547 else if (lr_inner
== 0 || rr_inner
== 0
3548 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
3551 l_const
= r_const
= 0;
3553 /* If either comparison code is not correct for our logical operation,
3554 fail. However, we can convert a one-bit comparison against zero into
3555 the opposite comparison against that bit being set in the field. */
3557 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
3558 if (lcode
!= wanted_code
)
3560 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
3562 /* Make the left operand unsigned, since we are only interested
3563 in the value of one bit. Otherwise we are doing the wrong
3572 /* This is analogous to the code for l_const above. */
3573 if (rcode
!= wanted_code
)
3575 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
3584 /* See if we can find a mode that contains both fields being compared on
3585 the left. If we can't, fail. Otherwise, update all constants and masks
3586 to be relative to a field of that size. */
3587 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
3588 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
3589 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
,
3590 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
3592 if (lnmode
== VOIDmode
)
3595 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
3596 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
3597 lntype
= (*lang_hooks
.types
.type_for_size
) (lnbitsize
, 1);
3598 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
3600 if (BYTES_BIG_ENDIAN
)
3602 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
3603 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
3606 ll_mask
= const_binop (LSHIFT_EXPR
, convert (lntype
, ll_mask
),
3607 size_int (xll_bitpos
), 0);
3608 rl_mask
= const_binop (LSHIFT_EXPR
, convert (lntype
, rl_mask
),
3609 size_int (xrl_bitpos
), 0);
3613 l_const
= convert (lntype
, l_const
);
3614 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
3615 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
), 0);
3616 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
3617 fold (build1 (BIT_NOT_EXPR
,
3621 warning ("comparison is always %d", wanted_code
== NE_EXPR
);
3623 return convert (truth_type
,
3624 wanted_code
== NE_EXPR
3625 ? integer_one_node
: integer_zero_node
);
3630 r_const
= convert (lntype
, r_const
);
3631 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
3632 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
), 0);
3633 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
3634 fold (build1 (BIT_NOT_EXPR
,
3638 warning ("comparison is always %d", wanted_code
== NE_EXPR
);
3640 return convert (truth_type
,
3641 wanted_code
== NE_EXPR
3642 ? integer_one_node
: integer_zero_node
);
3646 /* If the right sides are not constant, do the same for it. Also,
3647 disallow this optimization if a size or signedness mismatch occurs
3648 between the left and right sides. */
3651 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
3652 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
3653 /* Make sure the two fields on the right
3654 correspond to the left without being swapped. */
3655 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
3658 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
3659 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
3660 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
,
3661 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
3663 if (rnmode
== VOIDmode
)
3666 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
3667 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
3668 rntype
= (*lang_hooks
.types
.type_for_size
) (rnbitsize
, 1);
3669 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
3671 if (BYTES_BIG_ENDIAN
)
3673 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
3674 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
3677 lr_mask
= const_binop (LSHIFT_EXPR
, convert (rntype
, lr_mask
),
3678 size_int (xlr_bitpos
), 0);
3679 rr_mask
= const_binop (LSHIFT_EXPR
, convert (rntype
, rr_mask
),
3680 size_int (xrr_bitpos
), 0);
3682 /* Make a mask that corresponds to both fields being compared.
3683 Do this for both items being compared. If the operands are the
3684 same size and the bits being compared are in the same position
3685 then we can do this by masking both and comparing the masked
3687 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
, 0);
3688 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
, 0);
3689 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
3691 lhs
= make_bit_field_ref (ll_inner
, lntype
, lnbitsize
, lnbitpos
,
3692 ll_unsignedp
|| rl_unsignedp
);
3693 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
3694 lhs
= build (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
3696 rhs
= make_bit_field_ref (lr_inner
, rntype
, rnbitsize
, rnbitpos
,
3697 lr_unsignedp
|| rr_unsignedp
);
3698 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
3699 rhs
= build (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
3701 return build (wanted_code
, truth_type
, lhs
, rhs
);
3704 /* There is still another way we can do something: If both pairs of
3705 fields being compared are adjacent, we may be able to make a wider
3706 field containing them both.
3708 Note that we still must mask the lhs/rhs expressions. Furthermore,
3709 the mask must be shifted to account for the shift done by
3710 make_bit_field_ref. */
3711 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
3712 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
3713 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
3714 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
3718 lhs
= make_bit_field_ref (ll_inner
, lntype
, ll_bitsize
+ rl_bitsize
,
3719 MIN (ll_bitpos
, rl_bitpos
), ll_unsignedp
);
3720 rhs
= make_bit_field_ref (lr_inner
, rntype
, lr_bitsize
+ rr_bitsize
,
3721 MIN (lr_bitpos
, rr_bitpos
), lr_unsignedp
);
3723 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
3724 size_int (MIN (xll_bitpos
, xrl_bitpos
)), 0);
3725 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
3726 size_int (MIN (xlr_bitpos
, xrr_bitpos
)), 0);
3728 /* Convert to the smaller type before masking out unwanted bits. */
3730 if (lntype
!= rntype
)
3732 if (lnbitsize
> rnbitsize
)
3734 lhs
= convert (rntype
, lhs
);
3735 ll_mask
= convert (rntype
, ll_mask
);
3738 else if (lnbitsize
< rnbitsize
)
3740 rhs
= convert (lntype
, rhs
);
3741 lr_mask
= convert (lntype
, lr_mask
);
3746 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
3747 lhs
= build (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
3749 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
3750 rhs
= build (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
3752 return build (wanted_code
, truth_type
, lhs
, rhs
);
3758 /* Handle the case of comparisons with constants. If there is something in
3759 common between the masks, those bits of the constants must be the same.
3760 If not, the condition is always false. Test for this to avoid generating
3761 incorrect code below. */
3762 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
, 0);
3763 if (! integer_zerop (result
)
3764 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
, 0),
3765 const_binop (BIT_AND_EXPR
, result
, r_const
, 0)) != 1)
3767 if (wanted_code
== NE_EXPR
)
3769 warning ("`or' of unmatched not-equal tests is always 1");
3770 return convert (truth_type
, integer_one_node
);
3774 warning ("`and' of mutually exclusive equal-tests is always 0");
3775 return convert (truth_type
, integer_zero_node
);
3779 /* Construct the expression we will return. First get the component
3780 reference we will make. Unless the mask is all ones the width of
3781 that field, perform the mask operation. Then compare with the
3783 result
= make_bit_field_ref (ll_inner
, lntype
, lnbitsize
, lnbitpos
,
3784 ll_unsignedp
|| rl_unsignedp
);
3786 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
, 0);
3787 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
3788 result
= build (BIT_AND_EXPR
, lntype
, result
, ll_mask
);
3790 return build (wanted_code
, truth_type
, result
,
3791 const_binop (BIT_IOR_EXPR
, l_const
, r_const
, 0));
3794 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
3798 optimize_minmax_comparison (t
)
3801 tree type
= TREE_TYPE (t
);
3802 tree arg0
= TREE_OPERAND (t
, 0);
3803 enum tree_code op_code
;
3804 tree comp_const
= TREE_OPERAND (t
, 1);
3806 int consts_equal
, consts_lt
;
3809 STRIP_SIGN_NOPS (arg0
);
3811 op_code
= TREE_CODE (arg0
);
3812 minmax_const
= TREE_OPERAND (arg0
, 1);
3813 consts_equal
= tree_int_cst_equal (minmax_const
, comp_const
);
3814 consts_lt
= tree_int_cst_lt (minmax_const
, comp_const
);
3815 inner
= TREE_OPERAND (arg0
, 0);
3817 /* If something does not permit us to optimize, return the original tree. */
3818 if ((op_code
!= MIN_EXPR
&& op_code
!= MAX_EXPR
)
3819 || TREE_CODE (comp_const
) != INTEGER_CST
3820 || TREE_CONSTANT_OVERFLOW (comp_const
)
3821 || TREE_CODE (minmax_const
) != INTEGER_CST
3822 || TREE_CONSTANT_OVERFLOW (minmax_const
))
3825 /* Now handle all the various comparison codes. We only handle EQ_EXPR
3826 and GT_EXPR, doing the rest with recursive calls using logical
3828 switch (TREE_CODE (t
))
3830 case NE_EXPR
: case LT_EXPR
: case LE_EXPR
:
3832 invert_truthvalue (optimize_minmax_comparison (invert_truthvalue (t
)));
3836 fold (build (TRUTH_ORIF_EXPR
, type
,
3837 optimize_minmax_comparison
3838 (build (EQ_EXPR
, type
, arg0
, comp_const
)),
3839 optimize_minmax_comparison
3840 (build (GT_EXPR
, type
, arg0
, comp_const
))));
3843 if (op_code
== MAX_EXPR
&& consts_equal
)
3844 /* MAX (X, 0) == 0 -> X <= 0 */
3845 return fold (build (LE_EXPR
, type
, inner
, comp_const
));
3847 else if (op_code
== MAX_EXPR
&& consts_lt
)
3848 /* MAX (X, 0) == 5 -> X == 5 */
3849 return fold (build (EQ_EXPR
, type
, inner
, comp_const
));
3851 else if (op_code
== MAX_EXPR
)
3852 /* MAX (X, 0) == -1 -> false */
3853 return omit_one_operand (type
, integer_zero_node
, inner
);
3855 else if (consts_equal
)
3856 /* MIN (X, 0) == 0 -> X >= 0 */
3857 return fold (build (GE_EXPR
, type
, inner
, comp_const
));
3860 /* MIN (X, 0) == 5 -> false */
3861 return omit_one_operand (type
, integer_zero_node
, inner
);
3864 /* MIN (X, 0) == -1 -> X == -1 */
3865 return fold (build (EQ_EXPR
, type
, inner
, comp_const
));
3868 if (op_code
== MAX_EXPR
&& (consts_equal
|| consts_lt
))
3869 /* MAX (X, 0) > 0 -> X > 0
3870 MAX (X, 0) > 5 -> X > 5 */
3871 return fold (build (GT_EXPR
, type
, inner
, comp_const
));
3873 else if (op_code
== MAX_EXPR
)
3874 /* MAX (X, 0) > -1 -> true */
3875 return omit_one_operand (type
, integer_one_node
, inner
);
3877 else if (op_code
== MIN_EXPR
&& (consts_equal
|| consts_lt
))
3878 /* MIN (X, 0) > 0 -> false
3879 MIN (X, 0) > 5 -> false */
3880 return omit_one_operand (type
, integer_zero_node
, inner
);
3883 /* MIN (X, 0) > -1 -> X > -1 */
3884 return fold (build (GT_EXPR
, type
, inner
, comp_const
));
3891 /* T is an integer expression that is being multiplied, divided, or taken a
3892 modulus (CODE says which and what kind of divide or modulus) by a
3893 constant C. See if we can eliminate that operation by folding it with
3894 other operations already in T. WIDE_TYPE, if non-null, is a type that
3895 should be used for the computation if wider than our type.
3897 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
3898 (X * 2) + (Y * 4). We must, however, be assured that either the original
3899 expression would not overflow or that overflow is undefined for the type
3900 in the language in question.
3902 We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
3903 the machine has a multiply-accumulate insn or that this is part of an
3904 addressing calculation.
3906 If we return a non-null expression, it is an equivalent form of the
3907 original computation, but need not be in the original type. */
3910 extract_muldiv (t
, c
, code
, wide_type
)
3913 enum tree_code code
;
3916 tree type
= TREE_TYPE (t
);
3917 enum tree_code tcode
= TREE_CODE (t
);
3918 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
3919 > GET_MODE_SIZE (TYPE_MODE (type
)))
3920 ? wide_type
: type
);
3922 int same_p
= tcode
== code
;
3923 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
3925 /* Don't deal with constants of zero here; they confuse the code below. */
3926 if (integer_zerop (c
))
3929 if (TREE_CODE_CLASS (tcode
) == '1')
3930 op0
= TREE_OPERAND (t
, 0);
3932 if (TREE_CODE_CLASS (tcode
) == '2')
3933 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
3935 /* Note that we need not handle conditional operations here since fold
3936 already handles those cases. So just do arithmetic here. */
3940 /* For a constant, we can always simplify if we are a multiply
3941 or (for divide and modulus) if it is a multiple of our constant. */
3942 if (code
== MULT_EXPR
3943 || integer_zerop (const_binop (TRUNC_MOD_EXPR
, t
, c
, 0)))
3944 return const_binop (code
, convert (ctype
, t
), convert (ctype
, c
), 0);
3947 case CONVERT_EXPR
: case NON_LVALUE_EXPR
: case NOP_EXPR
:
3948 /* If op0 is an expression, and is unsigned, and the type is
3949 smaller than ctype, then we cannot widen the expression. */
3950 if ((TREE_CODE_CLASS (TREE_CODE (op0
)) == '<'
3951 || TREE_CODE_CLASS (TREE_CODE (op0
)) == '1'
3952 || TREE_CODE_CLASS (TREE_CODE (op0
)) == '2'
3953 || TREE_CODE_CLASS (TREE_CODE (op0
)) == 'e')
3954 && TREE_UNSIGNED (TREE_TYPE (op0
))
3955 && ! (TREE_CODE (TREE_TYPE (op0
)) == INTEGER_TYPE
3956 && TYPE_IS_SIZETYPE (TREE_TYPE (op0
)))
3957 && (GET_MODE_SIZE (TYPE_MODE (ctype
))
3958 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))))
3961 /* Pass the constant down and see if we can make a simplification. If
3962 we can, replace this expression with the inner simplification for
3963 possible later conversion to our or some other type. */
3964 if (0 != (t1
= extract_muldiv (op0
, convert (TREE_TYPE (op0
), c
), code
,
3965 code
== MULT_EXPR
? ctype
: NULL_TREE
)))
3969 case NEGATE_EXPR
: case ABS_EXPR
:
3970 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
)) != 0)
3971 return fold (build1 (tcode
, ctype
, convert (ctype
, t1
)));
3974 case MIN_EXPR
: case MAX_EXPR
:
3975 /* If widening the type changes the signedness, then we can't perform
3976 this optimization as that changes the result. */
3977 if (TREE_UNSIGNED (ctype
) != TREE_UNSIGNED (type
))
3980 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
3981 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
)) != 0
3982 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
)) != 0)
3984 if (tree_int_cst_sgn (c
) < 0)
3985 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
3987 return fold (build (tcode
, ctype
, convert (ctype
, t1
),
3988 convert (ctype
, t2
)));
3992 case WITH_RECORD_EXPR
:
3993 if ((t1
= extract_muldiv (TREE_OPERAND (t
, 0), c
, code
, wide_type
)) != 0)
3994 return build (WITH_RECORD_EXPR
, TREE_TYPE (t1
), t1
,
3995 TREE_OPERAND (t
, 1));
3999 /* If this has not been evaluated and the operand has no side effects,
4000 we can see if we can do something inside it and make a new one.
4001 Note that this test is overly conservative since we can do this
4002 if the only reason it had side effects is that it was another
4003 similar SAVE_EXPR, but that isn't worth bothering with. */
4004 if (SAVE_EXPR_RTL (t
) == 0 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0))
4005 && 0 != (t1
= extract_muldiv (TREE_OPERAND (t
, 0), c
, code
,
4008 t1
= save_expr (t1
);
4009 if (SAVE_EXPR_PERSISTENT_P (t
) && TREE_CODE (t1
) == SAVE_EXPR
)
4010 SAVE_EXPR_PERSISTENT_P (t1
) = 1;
4011 if (is_pending_size (t
))
4012 put_pending_size (t1
);
4017 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
4018 /* If the second operand is constant, this is a multiplication
4019 or floor division, by a power of two, so we can treat it that
4020 way unless the multiplier or divisor overflows. */
4021 if (TREE_CODE (op1
) == INTEGER_CST
4022 /* const_binop may not detect overflow correctly,
4023 so check for it explicitly here. */
4024 && TYPE_PRECISION (TREE_TYPE (size_one_node
)) > TREE_INT_CST_LOW (op1
)
4025 && TREE_INT_CST_HIGH (op1
) == 0
4026 && 0 != (t1
= convert (ctype
,
4027 const_binop (LSHIFT_EXPR
, size_one_node
,
4029 && ! TREE_OVERFLOW (t1
))
4030 return extract_muldiv (build (tcode
== LSHIFT_EXPR
4031 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
4032 ctype
, convert (ctype
, op0
), t1
),
4033 c
, code
, wide_type
);
4036 case PLUS_EXPR
: case MINUS_EXPR
:
4037 /* See if we can eliminate the operation on both sides. If we can, we
4038 can return a new PLUS or MINUS. If we can't, the only remaining
4039 cases where we can do anything are if the second operand is a
4041 t1
= extract_muldiv (op0
, c
, code
, wide_type
);
4042 t2
= extract_muldiv (op1
, c
, code
, wide_type
);
4043 if (t1
!= 0 && t2
!= 0
4044 && (code
== MULT_EXPR
4045 /* If not multiplication, we can only do this if either operand
4046 is divisible by c. */
4047 || multiple_of_p (ctype
, op0
, c
)
4048 || multiple_of_p (ctype
, op1
, c
)))
4049 return fold (build (tcode
, ctype
, convert (ctype
, t1
),
4050 convert (ctype
, t2
)));
4052 /* If this was a subtraction, negate OP1 and set it to be an addition.
4053 This simplifies the logic below. */
4054 if (tcode
== MINUS_EXPR
)
4055 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
4057 if (TREE_CODE (op1
) != INTEGER_CST
)
4060 /* If either OP1 or C are negative, this optimization is not safe for
4061 some of the division and remainder types while for others we need
4062 to change the code. */
4063 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
4065 if (code
== CEIL_DIV_EXPR
)
4066 code
= FLOOR_DIV_EXPR
;
4067 else if (code
== FLOOR_DIV_EXPR
)
4068 code
= CEIL_DIV_EXPR
;
4069 else if (code
!= MULT_EXPR
4070 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
4074 /* If it's a multiply or a division/modulus operation of a multiple
4075 of our constant, do the operation and verify it doesn't overflow. */
4076 if (code
== MULT_EXPR
4077 || integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
, 0)))
4079 op1
= const_binop (code
, convert (ctype
, op1
), convert (ctype
, c
), 0);
4080 if (op1
== 0 || TREE_OVERFLOW (op1
))
4086 /* If we have an unsigned type is not a sizetype, we cannot widen
4087 the operation since it will change the result if the original
4088 computation overflowed. */
4089 if (TREE_UNSIGNED (ctype
)
4090 && ! (TREE_CODE (ctype
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (ctype
))
4094 /* If we were able to eliminate our operation from the first side,
4095 apply our operation to the second side and reform the PLUS. */
4096 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
4097 return fold (build (tcode
, ctype
, convert (ctype
, t1
), op1
));
4099 /* The last case is if we are a multiply. In that case, we can
4100 apply the distributive law to commute the multiply and addition
4101 if the multiplication of the constants doesn't overflow. */
4102 if (code
== MULT_EXPR
)
4103 return fold (build (tcode
, ctype
, fold (build (code
, ctype
,
4104 convert (ctype
, op0
),
4105 convert (ctype
, c
))),
4111 /* We have a special case here if we are doing something like
4112 (C * 8) % 4 since we know that's zero. */
4113 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
4114 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
4115 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
4116 && integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
, 0)))
4117 return omit_one_operand (type
, integer_zero_node
, op0
);
4119 /* ... fall through ... */
4121 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
4122 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
4123 /* If we can extract our operation from the LHS, do so and return a
4124 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
4125 do something only if the second operand is a constant. */
4127 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
)) != 0)
4128 return fold (build (tcode
, ctype
, convert (ctype
, t1
),
4129 convert (ctype
, op1
)));
4130 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
4131 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
)) != 0)
4132 return fold (build (tcode
, ctype
, convert (ctype
, op0
),
4133 convert (ctype
, t1
)));
4134 else if (TREE_CODE (op1
) != INTEGER_CST
)
4137 /* If these are the same operation types, we can associate them
4138 assuming no overflow. */
4140 && 0 != (t1
= const_binop (MULT_EXPR
, convert (ctype
, op1
),
4141 convert (ctype
, c
), 0))
4142 && ! TREE_OVERFLOW (t1
))
4143 return fold (build (tcode
, ctype
, convert (ctype
, op0
), t1
));
4145 /* If these operations "cancel" each other, we have the main
4146 optimizations of this pass, which occur when either constant is a
4147 multiple of the other, in which case we replace this with either an
4148 operation or CODE or TCODE.
4150 If we have an unsigned type that is not a sizetype, we cannot do
4151 this since it will change the result if the original computation
4153 if ((! TREE_UNSIGNED (ctype
)
4154 || (TREE_CODE (ctype
) == INTEGER_TYPE
&& TYPE_IS_SIZETYPE (ctype
)))
4155 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
4156 || (tcode
== MULT_EXPR
4157 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
4158 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
)))
4160 if (integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
, 0)))
4161 return fold (build (tcode
, ctype
, convert (ctype
, op0
),
4163 const_binop (TRUNC_DIV_EXPR
,
4165 else if (integer_zerop (const_binop (TRUNC_MOD_EXPR
, c
, op1
, 0)))
4166 return fold (build (code
, ctype
, convert (ctype
, op0
),
4168 const_binop (TRUNC_DIV_EXPR
,
4180 /* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4181 S, a SAVE_EXPR, return the expression actually being evaluated. Note
4182 that we may sometimes modify the tree. */
4185 strip_compound_expr (t
, s
)
4189 enum tree_code code
= TREE_CODE (t
);
4191 /* See if this is the COMPOUND_EXPR we want to eliminate. */
4192 if (code
== COMPOUND_EXPR
&& TREE_CODE (TREE_OPERAND (t
, 0)) == CONVERT_EXPR
4193 && TREE_OPERAND (TREE_OPERAND (t
, 0), 0) == s
)
4194 return TREE_OPERAND (t
, 1);
4196 /* See if this is a COND_EXPR or a simple arithmetic operator. We
4197 don't bother handling any other types. */
4198 else if (code
== COND_EXPR
)
4200 TREE_OPERAND (t
, 0) = strip_compound_expr (TREE_OPERAND (t
, 0), s
);
4201 TREE_OPERAND (t
, 1) = strip_compound_expr (TREE_OPERAND (t
, 1), s
);
4202 TREE_OPERAND (t
, 2) = strip_compound_expr (TREE_OPERAND (t
, 2), s
);
4204 else if (TREE_CODE_CLASS (code
) == '1')
4205 TREE_OPERAND (t
, 0) = strip_compound_expr (TREE_OPERAND (t
, 0), s
);
4206 else if (TREE_CODE_CLASS (code
) == '<'
4207 || TREE_CODE_CLASS (code
) == '2')
4209 TREE_OPERAND (t
, 0) = strip_compound_expr (TREE_OPERAND (t
, 0), s
);
4210 TREE_OPERAND (t
, 1) = strip_compound_expr (TREE_OPERAND (t
, 1), s
);
4216 /* Return a node which has the indicated constant VALUE (either 0 or
4217 1), and is of the indicated TYPE. */
4220 constant_boolean_node (value
, type
)
4224 if (type
== integer_type_node
)
4225 return value
? integer_one_node
: integer_zero_node
;
4226 else if (TREE_CODE (type
) == BOOLEAN_TYPE
)
4227 return (*lang_hooks
.truthvalue_conversion
) (value
? integer_one_node
:
4231 tree t
= build_int_2 (value
, 0);
4233 TREE_TYPE (t
) = type
;
4238 /* Utility function for the following routine, to see how complex a nesting of
4239 COND_EXPRs can be. EXPR is the expression and LIMIT is a count beyond which
4240 we don't care (to avoid spending too much time on complex expressions.). */
4243 count_cond (expr
, lim
)
4249 if (TREE_CODE (expr
) != COND_EXPR
)
4254 ctrue
= count_cond (TREE_OPERAND (expr
, 1), lim
- 1);
4255 cfalse
= count_cond (TREE_OPERAND (expr
, 2), lim
- 1 - ctrue
);
4256 return MIN (lim
, 1 + ctrue
+ cfalse
);
4259 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
4260 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
4261 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
4262 expression, and ARG to `a'. If COND_FIRST_P is non-zero, then the
4263 COND is the first argument to CODE; otherwise (as in the example
4264 given here), it is the second argument. TYPE is the type of the
4265 original expression. */
4268 fold_binary_op_with_conditional_arg (code
, type
, cond
, arg
, cond_first_p
)
4269 enum tree_code code
;
4275 tree test
, true_value
, false_value
;
4276 tree lhs
= NULL_TREE
;
4277 tree rhs
= NULL_TREE
;
4278 /* In the end, we'll produce a COND_EXPR. Both arms of the
4279 conditional expression will be binary operations. The left-hand
4280 side of the expression to be executed if the condition is true
4281 will be pointed to by TRUE_LHS. Similarly, the right-hand side
4282 of the expression to be executed if the condition is true will be
4283 pointed to by TRUE_RHS. FALSE_LHS and FALSE_RHS are analogous --
4284 but apply to the expression to be executed if the conditional is
4290 /* These are the codes to use for the left-hand side and right-hand
4291 side of the COND_EXPR. Normally, they are the same as CODE. */
4292 enum tree_code lhs_code
= code
;
4293 enum tree_code rhs_code
= code
;
4294 /* And these are the types of the expressions. */
4295 tree lhs_type
= type
;
4296 tree rhs_type
= type
;
4300 true_rhs
= false_rhs
= &arg
;
4301 true_lhs
= &true_value
;
4302 false_lhs
= &false_value
;
4306 true_lhs
= false_lhs
= &arg
;
4307 true_rhs
= &true_value
;
4308 false_rhs
= &false_value
;
4311 if (TREE_CODE (cond
) == COND_EXPR
)
4313 test
= TREE_OPERAND (cond
, 0);
4314 true_value
= TREE_OPERAND (cond
, 1);
4315 false_value
= TREE_OPERAND (cond
, 2);
4316 /* If this operand throws an expression, then it does not make
4317 sense to try to perform a logical or arithmetic operation
4318 involving it. Instead of building `a + throw 3' for example,
4319 we simply build `a, throw 3'. */
4320 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
4322 lhs_code
= COMPOUND_EXPR
;
4324 lhs_type
= void_type_node
;
4326 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
4328 rhs_code
= COMPOUND_EXPR
;
4330 rhs_type
= void_type_node
;
4335 tree testtype
= TREE_TYPE (cond
);
4337 true_value
= convert (testtype
, integer_one_node
);
4338 false_value
= convert (testtype
, integer_zero_node
);
4341 /* If ARG is complex we want to make sure we only evaluate
4342 it once. Though this is only required if it is volatile, it
4343 might be more efficient even if it is not. However, if we
4344 succeed in folding one part to a constant, we do not need
4345 to make this SAVE_EXPR. Since we do this optimization
4346 primarily to see if we do end up with constant and this
4347 SAVE_EXPR interferes with later optimizations, suppressing
4348 it when we can is important.
4350 If we are not in a function, we can't make a SAVE_EXPR, so don't
4351 try to do so. Don't try to see if the result is a constant
4352 if an arm is a COND_EXPR since we get exponential behavior
4355 if (TREE_CODE (arg
) != SAVE_EXPR
&& ! TREE_CONSTANT (arg
)
4356 && (*lang_hooks
.decls
.global_bindings_p
) () == 0
4357 && ((TREE_CODE (arg
) != VAR_DECL
4358 && TREE_CODE (arg
) != PARM_DECL
)
4359 || TREE_SIDE_EFFECTS (arg
)))
4361 if (TREE_CODE (true_value
) != COND_EXPR
)
4362 lhs
= fold (build (lhs_code
, lhs_type
, *true_lhs
, *true_rhs
));
4364 if (TREE_CODE (false_value
) != COND_EXPR
)
4365 rhs
= fold (build (rhs_code
, rhs_type
, *false_lhs
, *false_rhs
));
4367 if ((lhs
== 0 || ! TREE_CONSTANT (lhs
))
4368 && (rhs
== 0 || !TREE_CONSTANT (rhs
)))
4369 arg
= save_expr (arg
), lhs
= rhs
= 0;
4373 lhs
= fold (build (lhs_code
, lhs_type
, *true_lhs
, *true_rhs
));
4375 rhs
= fold (build (rhs_code
, rhs_type
, *false_lhs
, *false_rhs
));
4377 test
= fold (build (COND_EXPR
, type
, test
, lhs
, rhs
));
4379 if (TREE_CODE (arg
) == SAVE_EXPR
)
4380 return build (COMPOUND_EXPR
, type
,
4381 convert (void_type_node
, arg
),
4382 strip_compound_expr (test
, arg
));
4384 return convert (type
, test
);
4388 /* Subroutine of fold() that checks for the addition of +/- 0.0.
4390 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
4391 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
4392 ADDEND is the same as X.
4394 X + 0 and X - 0 both give X when X is NaN, infinite, or non-zero
4395 and finite. The problematic cases are when X is zero, and its mode
4396 has signed zeros. In the case of rounding towards -infinity,
4397 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
4398 modes, X + 0 is not the same as X because -0 + 0 is 0. */
4401 fold_real_zero_addition_p (type
, addend
, negate
)
4405 if (!real_zerop (addend
))
4408 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
4409 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
4412 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
4413 if (TREE_CODE (addend
) == REAL_CST
4414 && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
4417 /* The mode has signed zeros, and we have to honor their sign.
4418 In this situation, there is only one case we can return true for.
4419 X - 0 is the same as X unless rounding towards -infinity is
4421 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
));
4425 /* Perform constant folding and related simplification of EXPR.
4426 The related simplifications include x*1 => x, x*0 => 0, etc.,
4427 and application of the associative law.
4428 NOP_EXPR conversions may be removed freely (as long as we
4429 are careful not to change the C type of the overall expression)
4430 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4431 but we can constant-fold them if they have constant operands. */
4438 tree t1
= NULL_TREE
;
4440 tree type
= TREE_TYPE (expr
);
4441 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
;
4442 enum tree_code code
= TREE_CODE (t
);
4443 int kind
= TREE_CODE_CLASS (code
);
4445 /* WINS will be nonzero when the switch is done
4446 if all operands are constant. */
4449 /* Don't try to process an RTL_EXPR since its operands aren't trees.
4450 Likewise for a SAVE_EXPR that's already been evaluated. */
4451 if (code
== RTL_EXPR
|| (code
== SAVE_EXPR
&& SAVE_EXPR_RTL (t
) != 0))
4454 /* Return right away if a constant. */
4458 #ifdef MAX_INTEGER_COMPUTATION_MODE
4459 check_max_integer_computation_mode (expr
);
4462 if (code
== NOP_EXPR
|| code
== FLOAT_EXPR
|| code
== CONVERT_EXPR
)
4466 /* Special case for conversion ops that can have fixed point args. */
4467 arg0
= TREE_OPERAND (t
, 0);
4469 /* Don't use STRIP_NOPS, because signedness of argument type matters. */
4471 STRIP_SIGN_NOPS (arg0
);
4473 if (arg0
!= 0 && TREE_CODE (arg0
) == COMPLEX_CST
)
4474 subop
= TREE_REALPART (arg0
);
4478 if (subop
!= 0 && TREE_CODE (subop
) != INTEGER_CST
4479 && TREE_CODE (subop
) != REAL_CST
4481 /* Note that TREE_CONSTANT isn't enough:
4482 static var addresses are constant but we can't
4483 do arithmetic on them. */
4486 else if (IS_EXPR_CODE_CLASS (kind
) || kind
== 'r')
4488 int len
= first_rtl_op (code
);
4490 for (i
= 0; i
< len
; i
++)
4492 tree op
= TREE_OPERAND (t
, i
);
4496 continue; /* Valid for CALL_EXPR, at least. */
4498 if (kind
== '<' || code
== RSHIFT_EXPR
)
4500 /* Signedness matters here. Perhaps we can refine this
4502 STRIP_SIGN_NOPS (op
);
4505 /* Strip any conversions that don't change the mode. */
4508 if (TREE_CODE (op
) == COMPLEX_CST
)
4509 subop
= TREE_REALPART (op
);
4513 if (TREE_CODE (subop
) != INTEGER_CST
4514 && TREE_CODE (subop
) != REAL_CST
)
4515 /* Note that TREE_CONSTANT isn't enough:
4516 static var addresses are constant but we can't
4517 do arithmetic on them. */
4527 /* If this is a commutative operation, and ARG0 is a constant, move it
4528 to ARG1 to reduce the number of tests below. */
4529 if ((code
== PLUS_EXPR
|| code
== MULT_EXPR
|| code
== MIN_EXPR
4530 || code
== MAX_EXPR
|| code
== BIT_IOR_EXPR
|| code
== BIT_XOR_EXPR
4531 || code
== BIT_AND_EXPR
)
4532 && (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
))
4534 tem
= arg0
; arg0
= arg1
; arg1
= tem
;
4536 tem
= TREE_OPERAND (t
, 0); TREE_OPERAND (t
, 0) = TREE_OPERAND (t
, 1);
4537 TREE_OPERAND (t
, 1) = tem
;
4540 /* Now WINS is set as described above,
4541 ARG0 is the first operand of EXPR,
4542 and ARG1 is the second operand (if it has more than one operand).
4544 First check for cases where an arithmetic operation is applied to a
4545 compound, conditional, or comparison operation. Push the arithmetic
4546 operation inside the compound or conditional to see if any folding
4547 can then be done. Convert comparison to conditional for this purpose.
4548 The also optimizes non-constant cases that used to be done in
4551 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
4552 one of the operands is a comparison and the other is a comparison, a
4553 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
4554 code below would make the expression more complex. Change it to a
4555 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
4556 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
4558 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
4559 || code
== EQ_EXPR
|| code
== NE_EXPR
)
4560 && ((truth_value_p (TREE_CODE (arg0
))
4561 && (truth_value_p (TREE_CODE (arg1
))
4562 || (TREE_CODE (arg1
) == BIT_AND_EXPR
4563 && integer_onep (TREE_OPERAND (arg1
, 1)))))
4564 || (truth_value_p (TREE_CODE (arg1
))
4565 && (truth_value_p (TREE_CODE (arg0
))
4566 || (TREE_CODE (arg0
) == BIT_AND_EXPR
4567 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
4569 t
= fold (build (code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
4570 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
4574 if (code
== EQ_EXPR
)
4575 t
= invert_truthvalue (t
);
4580 if (TREE_CODE_CLASS (code
) == '1')
4582 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
4583 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
4584 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 1))));
4585 else if (TREE_CODE (arg0
) == COND_EXPR
)
4587 t
= fold (build (COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
4588 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 1))),
4589 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 2)))));
4591 /* If this was a conversion, and all we did was to move into
4592 inside the COND_EXPR, bring it back out. But leave it if
4593 it is a conversion from integer to integer and the
4594 result precision is no wider than a word since such a
4595 conversion is cheap and may be optimized away by combine,
4596 while it couldn't if it were outside the COND_EXPR. Then return
4597 so we don't get into an infinite recursion loop taking the
4598 conversion out and then back in. */
4600 if ((code
== NOP_EXPR
|| code
== CONVERT_EXPR
4601 || code
== NON_LVALUE_EXPR
)
4602 && TREE_CODE (t
) == COND_EXPR
4603 && TREE_CODE (TREE_OPERAND (t
, 1)) == code
4604 && TREE_CODE (TREE_OPERAND (t
, 2)) == code
4605 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 1), 0))
4606 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 2), 0)))
4607 && ! (INTEGRAL_TYPE_P (TREE_TYPE (t
))
4609 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 1), 0))))
4610 && TYPE_PRECISION (TREE_TYPE (t
)) <= BITS_PER_WORD
))
4611 t
= build1 (code
, type
,
4613 TREE_TYPE (TREE_OPERAND
4614 (TREE_OPERAND (t
, 1), 0)),
4615 TREE_OPERAND (t
, 0),
4616 TREE_OPERAND (TREE_OPERAND (t
, 1), 0),
4617 TREE_OPERAND (TREE_OPERAND (t
, 2), 0)));
4620 else if (TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<')
4621 return fold (build (COND_EXPR
, type
, arg0
,
4622 fold (build1 (code
, type
, integer_one_node
)),
4623 fold (build1 (code
, type
, integer_zero_node
))));
4625 else if (TREE_CODE_CLASS (code
) == '2'
4626 || TREE_CODE_CLASS (code
) == '<')
4628 if (TREE_CODE (arg1
) == COMPOUND_EXPR
)
4629 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
4630 fold (build (code
, type
,
4631 arg0
, TREE_OPERAND (arg1
, 1))));
4632 else if ((TREE_CODE (arg1
) == COND_EXPR
4633 || (TREE_CODE_CLASS (TREE_CODE (arg1
)) == '<'
4634 && TREE_CODE_CLASS (code
) != '<'))
4635 && (TREE_CODE (arg0
) != COND_EXPR
4636 || count_cond (arg0
, 25) + count_cond (arg1
, 25) <= 25)
4637 && (! TREE_SIDE_EFFECTS (arg0
)
4638 || ((*lang_hooks
.decls
.global_bindings_p
) () == 0
4639 && ! contains_placeholder_p (arg0
))))
4641 fold_binary_op_with_conditional_arg (code
, type
, arg1
, arg0
,
4642 /*cond_first_p=*/0);
4643 else if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
4644 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
4645 fold (build (code
, type
, TREE_OPERAND (arg0
, 1), arg1
)));
4646 else if ((TREE_CODE (arg0
) == COND_EXPR
4647 || (TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<'
4648 && TREE_CODE_CLASS (code
) != '<'))
4649 && (TREE_CODE (arg1
) != COND_EXPR
4650 || count_cond (arg0
, 25) + count_cond (arg1
, 25) <= 25)
4651 && (! TREE_SIDE_EFFECTS (arg1
)
4652 || ((*lang_hooks
.decls
.global_bindings_p
) () == 0
4653 && ! contains_placeholder_p (arg1
))))
4655 fold_binary_op_with_conditional_arg (code
, type
, arg0
, arg1
,
4656 /*cond_first_p=*/1);
4658 else if (TREE_CODE_CLASS (code
) == '<'
4659 && TREE_CODE (arg0
) == COMPOUND_EXPR
)
4660 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
4661 fold (build (code
, type
, TREE_OPERAND (arg0
, 1), arg1
)));
4662 else if (TREE_CODE_CLASS (code
) == '<'
4663 && TREE_CODE (arg1
) == COMPOUND_EXPR
)
4664 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
4665 fold (build (code
, type
, arg0
, TREE_OPERAND (arg1
, 1))));
4678 return fold (DECL_INITIAL (t
));
4683 case FIX_TRUNC_EXPR
:
4684 /* Other kinds of FIX are not handled properly by fold_convert. */
4686 if (TREE_TYPE (TREE_OPERAND (t
, 0)) == TREE_TYPE (t
))
4687 return TREE_OPERAND (t
, 0);
4689 /* Handle cases of two conversions in a row. */
4690 if (TREE_CODE (TREE_OPERAND (t
, 0)) == NOP_EXPR
4691 || TREE_CODE (TREE_OPERAND (t
, 0)) == CONVERT_EXPR
)
4693 tree inside_type
= TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4694 tree inter_type
= TREE_TYPE (TREE_OPERAND (t
, 0));
4695 tree final_type
= TREE_TYPE (t
);
4696 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
4697 int inside_ptr
= POINTER_TYPE_P (inside_type
);
4698 int inside_float
= FLOAT_TYPE_P (inside_type
);
4699 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
4700 int inside_unsignedp
= TREE_UNSIGNED (inside_type
);
4701 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
4702 int inter_ptr
= POINTER_TYPE_P (inter_type
);
4703 int inter_float
= FLOAT_TYPE_P (inter_type
);
4704 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
4705 int inter_unsignedp
= TREE_UNSIGNED (inter_type
);
4706 int final_int
= INTEGRAL_TYPE_P (final_type
);
4707 int final_ptr
= POINTER_TYPE_P (final_type
);
4708 int final_float
= FLOAT_TYPE_P (final_type
);
4709 unsigned int final_prec
= TYPE_PRECISION (final_type
);
4710 int final_unsignedp
= TREE_UNSIGNED (final_type
);
4712 /* In addition to the cases of two conversions in a row
4713 handled below, if we are converting something to its own
4714 type via an object of identical or wider precision, neither
4715 conversion is needed. */
4716 if (TYPE_MAIN_VARIANT (inside_type
) == TYPE_MAIN_VARIANT (final_type
)
4717 && ((inter_int
&& final_int
) || (inter_float
&& final_float
))
4718 && inter_prec
>= final_prec
)
4719 return convert (final_type
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4721 /* Likewise, if the intermediate and final types are either both
4722 float or both integer, we don't need the middle conversion if
4723 it is wider than the final type and doesn't change the signedness
4724 (for integers). Avoid this if the final type is a pointer
4725 since then we sometimes need the inner conversion. Likewise if
4726 the outer has a precision not equal to the size of its mode. */
4727 if ((((inter_int
|| inter_ptr
) && (inside_int
|| inside_ptr
))
4728 || (inter_float
&& inside_float
))
4729 && inter_prec
>= inside_prec
4730 && (inter_float
|| inter_unsignedp
== inside_unsignedp
)
4731 && ! (final_prec
!= GET_MODE_BITSIZE (TYPE_MODE (final_type
))
4732 && TYPE_MODE (final_type
) == TYPE_MODE (inter_type
))
4734 return convert (final_type
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4736 /* If we have a sign-extension of a zero-extended value, we can
4737 replace that by a single zero-extension. */
4738 if (inside_int
&& inter_int
&& final_int
4739 && inside_prec
< inter_prec
&& inter_prec
< final_prec
4740 && inside_unsignedp
&& !inter_unsignedp
)
4741 return convert (final_type
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4743 /* Two conversions in a row are not needed unless:
4744 - some conversion is floating-point (overstrict for now), or
4745 - the intermediate type is narrower than both initial and
4747 - the intermediate type and innermost type differ in signedness,
4748 and the outermost type is wider than the intermediate, or
4749 - the initial type is a pointer type and the precisions of the
4750 intermediate and final types differ, or
4751 - the final type is a pointer type and the precisions of the
4752 initial and intermediate types differ. */
4753 if (! inside_float
&& ! inter_float
&& ! final_float
4754 && (inter_prec
> inside_prec
|| inter_prec
> final_prec
)
4755 && ! (inside_int
&& inter_int
4756 && inter_unsignedp
!= inside_unsignedp
4757 && inter_prec
< final_prec
)
4758 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
4759 == (final_unsignedp
&& final_prec
> inter_prec
))
4760 && ! (inside_ptr
&& inter_prec
!= final_prec
)
4761 && ! (final_ptr
&& inside_prec
!= inter_prec
)
4762 && ! (final_prec
!= GET_MODE_BITSIZE (TYPE_MODE (final_type
))
4763 && TYPE_MODE (final_type
) == TYPE_MODE (inter_type
))
4765 return convert (final_type
, TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4768 if (TREE_CODE (TREE_OPERAND (t
, 0)) == MODIFY_EXPR
4769 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t
, 0), 1))
4770 /* Detect assigning a bitfield. */
4771 && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)) == COMPONENT_REF
4772 && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 1))))
4774 /* Don't leave an assignment inside a conversion
4775 unless assigning a bitfield. */
4776 tree prev
= TREE_OPERAND (t
, 0);
4777 TREE_OPERAND (t
, 0) = TREE_OPERAND (prev
, 1);
4778 /* First do the assignment, then return converted constant. */
4779 t
= build (COMPOUND_EXPR
, TREE_TYPE (t
), prev
, fold (t
));
4784 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
4785 constants (if x has signed type, the sign bit cannot be set
4786 in c). This folds extension into the BIT_AND_EXPR. */
4787 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
4788 && TREE_CODE (TREE_TYPE (t
)) != BOOLEAN_TYPE
4789 && TREE_CODE (TREE_OPERAND (t
, 0)) == BIT_AND_EXPR
4790 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)) == INTEGER_CST
)
4792 tree
and = TREE_OPERAND (t
, 0);
4793 tree and0
= TREE_OPERAND (and, 0), and1
= TREE_OPERAND (and, 1);
4796 if (TREE_UNSIGNED (TREE_TYPE (and))
4797 || (TYPE_PRECISION (TREE_TYPE (t
))
4798 <= TYPE_PRECISION (TREE_TYPE (and))))
4800 else if (TYPE_PRECISION (TREE_TYPE (and1
))
4801 <= HOST_BITS_PER_WIDE_INT
4802 && host_integerp (and1
, 1))
4804 unsigned HOST_WIDE_INT cst
;
4806 cst
= tree_low_cst (and1
, 1);
4807 cst
&= (HOST_WIDE_INT
) -1
4808 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
4809 change
= (cst
== 0);
4810 #ifdef LOAD_EXTEND_OP
4812 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
4815 tree uns
= (*lang_hooks
.types
.unsigned_type
) (TREE_TYPE (and0
));
4816 and0
= convert (uns
, and0
);
4817 and1
= convert (uns
, and1
);
4822 return fold (build (BIT_AND_EXPR
, TREE_TYPE (t
),
4823 convert (TREE_TYPE (t
), and0
),
4824 convert (TREE_TYPE (t
), and1
)));
4829 TREE_CONSTANT (t
) = TREE_CONSTANT (arg0
);
4832 return fold_convert (t
, arg0
);
4834 case VIEW_CONVERT_EXPR
:
4835 if (TREE_CODE (TREE_OPERAND (t
, 0)) == VIEW_CONVERT_EXPR
)
4836 return build1 (VIEW_CONVERT_EXPR
, type
,
4837 TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
4841 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
4843 tree m
= purpose_member (arg1
, CONSTRUCTOR_ELTS (arg0
));
4850 TREE_CONSTANT (t
) = wins
;
4856 if (TREE_CODE (arg0
) == INTEGER_CST
)
4858 unsigned HOST_WIDE_INT low
;
4860 int overflow
= neg_double (TREE_INT_CST_LOW (arg0
),
4861 TREE_INT_CST_HIGH (arg0
),
4863 t
= build_int_2 (low
, high
);
4864 TREE_TYPE (t
) = type
;
4866 = (TREE_OVERFLOW (arg0
)
4867 | force_fit_type (t
, overflow
&& !TREE_UNSIGNED (type
)));
4868 TREE_CONSTANT_OVERFLOW (t
)
4869 = TREE_OVERFLOW (t
) | TREE_CONSTANT_OVERFLOW (arg0
);
4871 else if (TREE_CODE (arg0
) == REAL_CST
)
4872 t
= build_real (type
, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0
)));
4874 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
4875 return TREE_OPERAND (arg0
, 0);
4877 /* Convert - (a - b) to (b - a) for non-floating-point. */
4878 else if (TREE_CODE (arg0
) == MINUS_EXPR
4879 && (! FLOAT_TYPE_P (type
) || flag_unsafe_math_optimizations
))
4880 return build (MINUS_EXPR
, type
, TREE_OPERAND (arg0
, 1),
4881 TREE_OPERAND (arg0
, 0));
4888 if (TREE_CODE (arg0
) == INTEGER_CST
)
4890 /* If the value is unsigned, then the absolute value is
4891 the same as the ordinary value. */
4892 if (TREE_UNSIGNED (type
))
4894 /* Similarly, if the value is non-negative. */
4895 else if (INT_CST_LT (integer_minus_one_node
, arg0
))
4897 /* If the value is negative, then the absolute value is
4901 unsigned HOST_WIDE_INT low
;
4903 int overflow
= neg_double (TREE_INT_CST_LOW (arg0
),
4904 TREE_INT_CST_HIGH (arg0
),
4906 t
= build_int_2 (low
, high
);
4907 TREE_TYPE (t
) = type
;
4909 = (TREE_OVERFLOW (arg0
)
4910 | force_fit_type (t
, overflow
));
4911 TREE_CONSTANT_OVERFLOW (t
)
4912 = TREE_OVERFLOW (t
) | TREE_CONSTANT_OVERFLOW (arg0
);
4915 else if (TREE_CODE (arg0
) == REAL_CST
)
4917 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
4918 t
= build_real (type
,
4919 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0
)));
4922 else if (TREE_CODE (arg0
) == ABS_EXPR
|| TREE_CODE (arg0
) == NEGATE_EXPR
)
4923 return build1 (ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
4927 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
4928 return convert (type
, arg0
);
4929 else if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
4930 return build (COMPLEX_EXPR
, type
,
4931 TREE_OPERAND (arg0
, 0),
4932 negate_expr (TREE_OPERAND (arg0
, 1)));
4933 else if (TREE_CODE (arg0
) == COMPLEX_CST
)
4934 return build_complex (type
, TREE_REALPART (arg0
),
4935 negate_expr (TREE_IMAGPART (arg0
)));
4936 else if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
4937 return fold (build (TREE_CODE (arg0
), type
,
4938 fold (build1 (CONJ_EXPR
, type
,
4939 TREE_OPERAND (arg0
, 0))),
4940 fold (build1 (CONJ_EXPR
,
4941 type
, TREE_OPERAND (arg0
, 1)))));
4942 else if (TREE_CODE (arg0
) == CONJ_EXPR
)
4943 return TREE_OPERAND (arg0
, 0);
4949 t
= build_int_2 (~ TREE_INT_CST_LOW (arg0
),
4950 ~ TREE_INT_CST_HIGH (arg0
));
4951 TREE_TYPE (t
) = type
;
4952 force_fit_type (t
, 0);
4953 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg0
);
4954 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (arg0
);
4956 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
4957 return TREE_OPERAND (arg0
, 0);
4961 /* A + (-B) -> A - B */
4962 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
4963 return fold (build (MINUS_EXPR
, type
, arg0
, TREE_OPERAND (arg1
, 0)));
4964 /* (-A) + B -> B - A */
4965 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
4966 return fold (build (MINUS_EXPR
, type
, arg1
, TREE_OPERAND (arg0
, 0)));
4967 else if (! FLOAT_TYPE_P (type
))
4969 if (integer_zerop (arg1
))
4970 return non_lvalue (convert (type
, arg0
));
4972 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
4973 with a constant, and the two constants have no bits in common,
4974 we should treat this as a BIT_IOR_EXPR since this may produce more
4976 if (TREE_CODE (arg0
) == BIT_AND_EXPR
4977 && TREE_CODE (arg1
) == BIT_AND_EXPR
4978 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
4979 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
4980 && integer_zerop (const_binop (BIT_AND_EXPR
,
4981 TREE_OPERAND (arg0
, 1),
4982 TREE_OPERAND (arg1
, 1), 0)))
4984 code
= BIT_IOR_EXPR
;
4988 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
4989 (plus (plus (mult) (mult)) (foo)) so that we can
4990 take advantage of the factoring cases below. */
4991 if ((TREE_CODE (arg0
) == PLUS_EXPR
4992 && TREE_CODE (arg1
) == MULT_EXPR
)
4993 || (TREE_CODE (arg1
) == PLUS_EXPR
4994 && TREE_CODE (arg0
) == MULT_EXPR
))
4996 tree parg0
, parg1
, parg
, marg
;
4998 if (TREE_CODE (arg0
) == PLUS_EXPR
)
4999 parg
= arg0
, marg
= arg1
;
5001 parg
= arg1
, marg
= arg0
;
5002 parg0
= TREE_OPERAND (parg
, 0);
5003 parg1
= TREE_OPERAND (parg
, 1);
5007 if (TREE_CODE (parg0
) == MULT_EXPR
5008 && TREE_CODE (parg1
) != MULT_EXPR
)
5009 return fold (build (PLUS_EXPR
, type
,
5010 fold (build (PLUS_EXPR
, type
, parg0
, marg
)),
5012 if (TREE_CODE (parg0
) != MULT_EXPR
5013 && TREE_CODE (parg1
) == MULT_EXPR
)
5014 return fold (build (PLUS_EXPR
, type
,
5015 fold (build (PLUS_EXPR
, type
, parg1
, marg
)),
5019 if (TREE_CODE (arg0
) == MULT_EXPR
&& TREE_CODE (arg1
) == MULT_EXPR
)
5021 tree arg00
, arg01
, arg10
, arg11
;
5022 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
5024 /* (A * C) + (B * C) -> (A+B) * C.
5025 We are most concerned about the case where C is a constant,
5026 but other combinations show up during loop reduction. Since
5027 it is not difficult, try all four possibilities. */
5029 arg00
= TREE_OPERAND (arg0
, 0);
5030 arg01
= TREE_OPERAND (arg0
, 1);
5031 arg10
= TREE_OPERAND (arg1
, 0);
5032 arg11
= TREE_OPERAND (arg1
, 1);
5035 if (operand_equal_p (arg01
, arg11
, 0))
5036 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
5037 else if (operand_equal_p (arg00
, arg10
, 0))
5038 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
5039 else if (operand_equal_p (arg00
, arg11
, 0))
5040 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
5041 else if (operand_equal_p (arg01
, arg10
, 0))
5042 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
5044 /* No identical multiplicands; see if we can find a common
5045 power-of-two factor in non-power-of-two multiplies. This
5046 can help in multi-dimensional array access. */
5047 else if (TREE_CODE (arg01
) == INTEGER_CST
5048 && TREE_CODE (arg11
) == INTEGER_CST
5049 && TREE_INT_CST_HIGH (arg01
) == 0
5050 && TREE_INT_CST_HIGH (arg11
) == 0)
5052 HOST_WIDE_INT int01
, int11
, tmp
;
5053 int01
= TREE_INT_CST_LOW (arg01
);
5054 int11
= TREE_INT_CST_LOW (arg11
);
5056 /* Move min of absolute values to int11. */
5057 if ((int01
>= 0 ? int01
: -int01
)
5058 < (int11
>= 0 ? int11
: -int11
))
5060 tmp
= int01
, int01
= int11
, int11
= tmp
;
5061 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
5062 alt0
= arg01
, arg01
= arg11
, arg11
= alt0
;
5065 if (exact_log2 (int11
) > 0 && int01
% int11
== 0)
5067 alt0
= fold (build (MULT_EXPR
, type
, arg00
,
5068 build_int_2 (int01
/ int11
, 0)));
5075 return fold (build (MULT_EXPR
, type
,
5076 fold (build (PLUS_EXPR
, type
, alt0
, alt1
)),
5081 /* See if ARG1 is zero and X + ARG1 reduces to X. */
5082 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 0))
5083 return non_lvalue (convert (type
, arg0
));
5085 /* Likewise if the operands are reversed. */
5086 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
5087 return non_lvalue (convert (type
, arg1
));
5090 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
5091 is a rotate of A by C1 bits. */
5092 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
5093 is a rotate of A by B bits. */
5095 enum tree_code code0
, code1
;
5096 code0
= TREE_CODE (arg0
);
5097 code1
= TREE_CODE (arg1
);
5098 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
5099 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
5100 && operand_equal_p (TREE_OPERAND (arg0
, 0),
5101 TREE_OPERAND (arg1
, 0), 0)
5102 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
5104 tree tree01
, tree11
;
5105 enum tree_code code01
, code11
;
5107 tree01
= TREE_OPERAND (arg0
, 1);
5108 tree11
= TREE_OPERAND (arg1
, 1);
5109 STRIP_NOPS (tree01
);
5110 STRIP_NOPS (tree11
);
5111 code01
= TREE_CODE (tree01
);
5112 code11
= TREE_CODE (tree11
);
5113 if (code01
== INTEGER_CST
5114 && code11
== INTEGER_CST
5115 && TREE_INT_CST_HIGH (tree01
) == 0
5116 && TREE_INT_CST_HIGH (tree11
) == 0
5117 && ((TREE_INT_CST_LOW (tree01
) + TREE_INT_CST_LOW (tree11
))
5118 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
5119 return build (LROTATE_EXPR
, type
, TREE_OPERAND (arg0
, 0),
5120 code0
== LSHIFT_EXPR
? tree01
: tree11
);
5121 else if (code11
== MINUS_EXPR
)
5123 tree tree110
, tree111
;
5124 tree110
= TREE_OPERAND (tree11
, 0);
5125 tree111
= TREE_OPERAND (tree11
, 1);
5126 STRIP_NOPS (tree110
);
5127 STRIP_NOPS (tree111
);
5128 if (TREE_CODE (tree110
) == INTEGER_CST
5129 && 0 == compare_tree_int (tree110
,
5131 (TREE_TYPE (TREE_OPERAND
5133 && operand_equal_p (tree01
, tree111
, 0))
5134 return build ((code0
== LSHIFT_EXPR
5137 type
, TREE_OPERAND (arg0
, 0), tree01
);
5139 else if (code01
== MINUS_EXPR
)
5141 tree tree010
, tree011
;
5142 tree010
= TREE_OPERAND (tree01
, 0);
5143 tree011
= TREE_OPERAND (tree01
, 1);
5144 STRIP_NOPS (tree010
);
5145 STRIP_NOPS (tree011
);
5146 if (TREE_CODE (tree010
) == INTEGER_CST
5147 && 0 == compare_tree_int (tree010
,
5149 (TREE_TYPE (TREE_OPERAND
5151 && operand_equal_p (tree11
, tree011
, 0))
5152 return build ((code0
!= LSHIFT_EXPR
5155 type
, TREE_OPERAND (arg0
, 0), tree11
);
5161 /* In most languages, can't associate operations on floats through
5162 parentheses. Rather than remember where the parentheses were, we
5163 don't associate floats at all. It shouldn't matter much. However,
5164 associating multiplications is only very slightly inaccurate, so do
5165 that if -funsafe-math-optimizations is specified. */
5168 && (! FLOAT_TYPE_P (type
)
5169 || (flag_unsafe_math_optimizations
&& code
== MULT_EXPR
)))
5171 tree var0
, con0
, lit0
, minus_lit0
;
5172 tree var1
, con1
, lit1
, minus_lit1
;
5174 /* Split both trees into variables, constants, and literals. Then
5175 associate each group together, the constants with literals,
5176 then the result with variables. This increases the chances of
5177 literals being recombined later and of generating relocatable
5178 expressions for the sum of a constant and literal. */
5179 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
5180 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
5181 code
== MINUS_EXPR
);
5183 /* Only do something if we found more than two objects. Otherwise,
5184 nothing has changed and we risk infinite recursion. */
5185 if (2 < ((var0
!= 0) + (var1
!= 0)
5186 + (con0
!= 0) + (con1
!= 0)
5187 + (lit0
!= 0) + (lit1
!= 0)
5188 + (minus_lit0
!= 0) + (minus_lit1
!= 0)))
5190 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
5191 if (code
== MINUS_EXPR
)
5194 var0
= associate_trees (var0
, var1
, code
, type
);
5195 con0
= associate_trees (con0
, con1
, code
, type
);
5196 lit0
= associate_trees (lit0
, lit1
, code
, type
);
5197 minus_lit0
= associate_trees (minus_lit0
, minus_lit1
, code
, type
);
5199 /* Preserve the MINUS_EXPR if the negative part of the literal is
5200 greater than the positive part. Otherwise, the multiplicative
5201 folding code (i.e extract_muldiv) may be fooled in case
5202 unsigned constants are substracted, like in the following
5203 example: ((X*2 + 4) - 8U)/2. */
5204 if (minus_lit0
&& lit0
)
5206 if (tree_int_cst_lt (lit0
, minus_lit0
))
5208 minus_lit0
= associate_trees (minus_lit0
, lit0
,
5214 lit0
= associate_trees (lit0
, minus_lit0
,
5222 return convert (type
, associate_trees (var0
, minus_lit0
,
5226 con0
= associate_trees (con0
, minus_lit0
,
5228 return convert (type
, associate_trees (var0
, con0
,
5233 con0
= associate_trees (con0
, lit0
, code
, type
);
5234 return convert (type
, associate_trees (var0
, con0
, code
, type
));
5240 t1
= const_binop (code
, arg0
, arg1
, 0);
5241 if (t1
!= NULL_TREE
)
5243 /* The return value should always have
5244 the same type as the original expression. */
5245 if (TREE_TYPE (t1
) != TREE_TYPE (t
))
5246 t1
= convert (TREE_TYPE (t
), t1
);
5253 /* A - (-B) -> A + B */
5254 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
5255 return fold (build (PLUS_EXPR
, type
, arg0
, TREE_OPERAND (arg1
, 0)));
5256 /* (-A) - CST -> (-CST) - A for floating point (what about ints ?) */
5257 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& TREE_CODE (arg1
) == REAL_CST
)
5259 fold (build (MINUS_EXPR
, type
,
5260 build_real (TREE_TYPE (arg1
),
5261 REAL_VALUE_NEGATE (TREE_REAL_CST (arg1
))),
5262 TREE_OPERAND (arg0
, 0)));
5264 if (! FLOAT_TYPE_P (type
))
5266 if (! wins
&& integer_zerop (arg0
))
5267 return negate_expr (convert (type
, arg1
));
5268 if (integer_zerop (arg1
))
5269 return non_lvalue (convert (type
, arg0
));
5271 /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
5272 about the case where C is a constant, just try one of the
5273 four possibilities. */
5275 if (TREE_CODE (arg0
) == MULT_EXPR
&& TREE_CODE (arg1
) == MULT_EXPR
5276 && operand_equal_p (TREE_OPERAND (arg0
, 1),
5277 TREE_OPERAND (arg1
, 1), 0))
5278 return fold (build (MULT_EXPR
, type
,
5279 fold (build (MINUS_EXPR
, type
,
5280 TREE_OPERAND (arg0
, 0),
5281 TREE_OPERAND (arg1
, 0))),
5282 TREE_OPERAND (arg0
, 1)));
5285 /* See if ARG1 is zero and X - ARG1 reduces to X. */
5286 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
5287 return non_lvalue (convert (type
, arg0
));
5289 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
5290 ARG0 is zero and X + ARG0 reduces to X, since that would mean
5291 (-ARG1 + ARG0) reduces to -ARG1. */
5292 else if (!wins
&& fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
5293 return negate_expr (convert (type
, arg1
));
5295 /* Fold &x - &x. This can happen from &x.foo - &x.
5296 This is unsafe for certain floats even in non-IEEE formats.
5297 In IEEE, it is unsafe because it does wrong for NaNs.
5298 Also note that operand_equal_p is always false if an operand
5301 if ((! FLOAT_TYPE_P (type
) || flag_unsafe_math_optimizations
)
5302 && operand_equal_p (arg0
, arg1
, 0))
5303 return convert (type
, integer_zero_node
);
5308 /* (-A) * (-B) -> A * B */
5309 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& TREE_CODE (arg1
) == NEGATE_EXPR
)
5310 return fold (build (MULT_EXPR
, type
, TREE_OPERAND (arg0
, 0),
5311 TREE_OPERAND (arg1
, 0)));
5313 if (! FLOAT_TYPE_P (type
))
5315 if (integer_zerop (arg1
))
5316 return omit_one_operand (type
, arg1
, arg0
);
5317 if (integer_onep (arg1
))
5318 return non_lvalue (convert (type
, arg0
));
5320 /* (a * (1 << b)) is (a << b) */
5321 if (TREE_CODE (arg1
) == LSHIFT_EXPR
5322 && integer_onep (TREE_OPERAND (arg1
, 0)))
5323 return fold (build (LSHIFT_EXPR
, type
, arg0
,
5324 TREE_OPERAND (arg1
, 1)));
5325 if (TREE_CODE (arg0
) == LSHIFT_EXPR
5326 && integer_onep (TREE_OPERAND (arg0
, 0)))
5327 return fold (build (LSHIFT_EXPR
, type
, arg1
,
5328 TREE_OPERAND (arg0
, 1)));
5330 if (TREE_CODE (arg1
) == INTEGER_CST
5331 && 0 != (tem
= extract_muldiv (TREE_OPERAND (t
, 0), arg1
,
5333 return convert (type
, tem
);
5338 /* Maybe fold x * 0 to 0. The expressions aren't the same
5339 when x is NaN, since x * 0 is also NaN. Nor are they the
5340 same in modes with signed zeros, since multiplying a
5341 negative value by 0 gives -0, not +0. */
5342 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
5343 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
5344 && real_zerop (arg1
))
5345 return omit_one_operand (type
, arg1
, arg0
);
5346 /* In IEEE floating point, x*1 is not equivalent to x for snans.
5347 However, ANSI says we can drop signals,
5348 so we can do this anyway. */
5349 if (real_onep (arg1
))
5350 return non_lvalue (convert (type
, arg0
));
5352 if (! wins
&& real_twop (arg1
)
5353 && (*lang_hooks
.decls
.global_bindings_p
) () == 0
5354 && ! contains_placeholder_p (arg0
))
5356 tree arg
= save_expr (arg0
);
5357 return build (PLUS_EXPR
, type
, arg
, arg
);
5364 if (integer_all_onesp (arg1
))
5365 return omit_one_operand (type
, arg1
, arg0
);
5366 if (integer_zerop (arg1
))
5367 return non_lvalue (convert (type
, arg0
));
5368 t1
= distribute_bit_expr (code
, type
, arg0
, arg1
);
5369 if (t1
!= NULL_TREE
)
5372 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
5374 This results in more efficient code for machines without a NAND
5375 instruction. Combine will canonicalize to the first form
5376 which will allow use of NAND instructions provided by the
5377 backend if they exist. */
5378 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
5379 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
5381 return fold (build1 (BIT_NOT_EXPR
, type
,
5382 build (BIT_AND_EXPR
, type
,
5383 TREE_OPERAND (arg0
, 0),
5384 TREE_OPERAND (arg1
, 0))));
5387 /* See if this can be simplified into a rotate first. If that
5388 is unsuccessful continue in the association code. */
5392 if (integer_zerop (arg1
))
5393 return non_lvalue (convert (type
, arg0
));
5394 if (integer_all_onesp (arg1
))
5395 return fold (build1 (BIT_NOT_EXPR
, type
, arg0
));
5397 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
5398 with a constant, and the two constants have no bits in common,
5399 we should treat this as a BIT_IOR_EXPR since this may produce more
5401 if (TREE_CODE (arg0
) == BIT_AND_EXPR
5402 && TREE_CODE (arg1
) == BIT_AND_EXPR
5403 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
5404 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
5405 && integer_zerop (const_binop (BIT_AND_EXPR
,
5406 TREE_OPERAND (arg0
, 1),
5407 TREE_OPERAND (arg1
, 1), 0)))
5409 code
= BIT_IOR_EXPR
;
5413 /* See if this can be simplified into a rotate first. If that
5414 is unsuccessful continue in the association code. */
5419 if (integer_all_onesp (arg1
))
5420 return non_lvalue (convert (type
, arg0
));
5421 if (integer_zerop (arg1
))
5422 return omit_one_operand (type
, arg1
, arg0
);
5423 t1
= distribute_bit_expr (code
, type
, arg0
, arg1
);
5424 if (t1
!= NULL_TREE
)
5426 /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
5427 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
5428 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
5431 = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
5433 if (prec
< BITS_PER_WORD
&& prec
< HOST_BITS_PER_WIDE_INT
5434 && (~TREE_INT_CST_LOW (arg1
)
5435 & (((HOST_WIDE_INT
) 1 << prec
) - 1)) == 0)
5436 return build1 (NOP_EXPR
, type
, TREE_OPERAND (arg0
, 0));
5439 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
5441 This results in more efficient code for machines without a NOR
5442 instruction. Combine will canonicalize to the first form
5443 which will allow use of NOR instructions provided by the
5444 backend if they exist. */
5445 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
5446 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
5448 return fold (build1 (BIT_NOT_EXPR
, type
,
5449 build (BIT_IOR_EXPR
, type
,
5450 TREE_OPERAND (arg0
, 0),
5451 TREE_OPERAND (arg1
, 0))));
5456 case BIT_ANDTC_EXPR
:
5457 if (integer_all_onesp (arg0
))
5458 return non_lvalue (convert (type
, arg1
));
5459 if (integer_zerop (arg0
))
5460 return omit_one_operand (type
, arg0
, arg1
);
5461 if (TREE_CODE (arg1
) == INTEGER_CST
)
5463 arg1
= fold (build1 (BIT_NOT_EXPR
, type
, arg1
));
5464 code
= BIT_AND_EXPR
;
5470 /* Don't touch a floating-point divide by zero unless the mode
5471 of the constant can represent infinity. */
5472 if (TREE_CODE (arg1
) == REAL_CST
5473 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
5474 && real_zerop (arg1
))
5477 /* (-A) / (-B) -> A / B */
5478 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& TREE_CODE (arg1
) == NEGATE_EXPR
)
5479 return fold (build (RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
5480 TREE_OPERAND (arg1
, 0)));
5482 /* In IEEE floating point, x/1 is not equivalent to x for snans.
5483 However, ANSI says we can drop signals, so we can do this anyway. */
5484 if (real_onep (arg1
))
5485 return non_lvalue (convert (type
, arg0
));
5487 /* If ARG1 is a constant, we can convert this to a multiply by the
5488 reciprocal. This does not have the same rounding properties,
5489 so only do this if -funsafe-math-optimizations. We can actually
5490 always safely do it if ARG1 is a power of two, but it's hard to
5491 tell if it is or not in a portable manner. */
5492 if (TREE_CODE (arg1
) == REAL_CST
)
5494 if (flag_unsafe_math_optimizations
5495 && 0 != (tem
= const_binop (code
, build_real (type
, dconst1
),
5497 return fold (build (MULT_EXPR
, type
, arg0
, tem
));
5498 /* Find the reciprocal if optimizing and the result is exact. */
5502 r
= TREE_REAL_CST (arg1
);
5503 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0
)), &r
))
5505 tem
= build_real (type
, r
);
5506 return fold (build (MULT_EXPR
, type
, arg0
, tem
));
5510 /* Convert A/B/C to A/(B*C). */
5511 if (flag_unsafe_math_optimizations
5512 && TREE_CODE (arg0
) == RDIV_EXPR
)
5514 return fold (build (RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
5515 build (MULT_EXPR
, type
, TREE_OPERAND (arg0
, 1),
5518 /* Convert A/(B/C) to (A/B)*C. */
5519 if (flag_unsafe_math_optimizations
5520 && TREE_CODE (arg1
) == RDIV_EXPR
)
5522 return fold (build (MULT_EXPR
, type
,
5523 build (RDIV_EXPR
, type
, arg0
,
5524 TREE_OPERAND (arg1
, 0)),
5525 TREE_OPERAND (arg1
, 1)));
5529 case TRUNC_DIV_EXPR
:
5530 case ROUND_DIV_EXPR
:
5531 case FLOOR_DIV_EXPR
:
5533 case EXACT_DIV_EXPR
:
5534 if (integer_onep (arg1
))
5535 return non_lvalue (convert (type
, arg0
));
5536 if (integer_zerop (arg1
))
5539 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5540 operation, EXACT_DIV_EXPR.
5542 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5543 At one time others generated faster code, it's not clear if they do
5544 after the last round to changes to the DIV code in expmed.c. */
5545 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
5546 && multiple_of_p (type
, arg0
, arg1
))
5547 return fold (build (EXACT_DIV_EXPR
, type
, arg0
, arg1
));
5549 if (TREE_CODE (arg1
) == INTEGER_CST
5550 && 0 != (tem
= extract_muldiv (TREE_OPERAND (t
, 0), arg1
,
5552 return convert (type
, tem
);
5557 case FLOOR_MOD_EXPR
:
5558 case ROUND_MOD_EXPR
:
5559 case TRUNC_MOD_EXPR
:
5560 if (integer_onep (arg1
))
5561 return omit_one_operand (type
, integer_zero_node
, arg0
);
5562 if (integer_zerop (arg1
))
5565 if (TREE_CODE (arg1
) == INTEGER_CST
5566 && 0 != (tem
= extract_muldiv (TREE_OPERAND (t
, 0), arg1
,
5568 return convert (type
, tem
);
5576 if (integer_zerop (arg1
))
5577 return non_lvalue (convert (type
, arg0
));
5578 /* Since negative shift count is not well-defined,
5579 don't try to compute it in the compiler. */
5580 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
5582 /* Rewrite an LROTATE_EXPR by a constant into an
5583 RROTATE_EXPR by a new constant. */
5584 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
5586 TREE_SET_CODE (t
, RROTATE_EXPR
);
5587 code
= RROTATE_EXPR
;
5588 TREE_OPERAND (t
, 1) = arg1
5591 convert (TREE_TYPE (arg1
),
5592 build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type
)), 0)),
5594 if (tree_int_cst_sgn (arg1
) < 0)
5598 /* If we have a rotate of a bit operation with the rotate count and
5599 the second operand of the bit operation both constant,
5600 permute the two operations. */
5601 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
5602 && (TREE_CODE (arg0
) == BIT_AND_EXPR
5603 || TREE_CODE (arg0
) == BIT_ANDTC_EXPR
5604 || TREE_CODE (arg0
) == BIT_IOR_EXPR
5605 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
5606 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
5607 return fold (build (TREE_CODE (arg0
), type
,
5608 fold (build (code
, type
,
5609 TREE_OPERAND (arg0
, 0), arg1
)),
5610 fold (build (code
, type
,
5611 TREE_OPERAND (arg0
, 1), arg1
))));
5613 /* Two consecutive rotates adding up to the width of the mode can
5615 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
5616 && TREE_CODE (arg0
) == RROTATE_EXPR
5617 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
5618 && TREE_INT_CST_HIGH (arg1
) == 0
5619 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0
, 1)) == 0
5620 && ((TREE_INT_CST_LOW (arg1
)
5621 + TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1)))
5622 == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type
))))
5623 return TREE_OPERAND (arg0
, 0);
5628 if (operand_equal_p (arg0
, arg1
, 0))
5629 return omit_one_operand (type
, arg0
, arg1
);
5630 if (INTEGRAL_TYPE_P (type
)
5631 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), 1))
5632 return omit_one_operand (type
, arg1
, arg0
);
5636 if (operand_equal_p (arg0
, arg1
, 0))
5637 return omit_one_operand (type
, arg0
, arg1
);
5638 if (INTEGRAL_TYPE_P (type
)
5639 && TYPE_MAX_VALUE (type
)
5640 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), 1))
5641 return omit_one_operand (type
, arg1
, arg0
);
5644 case TRUTH_NOT_EXPR
:
5645 /* Note that the operand of this must be an int
5646 and its values must be 0 or 1.
5647 ("true" is a fixed value perhaps depending on the language,
5648 but we don't handle values other than 1 correctly yet.) */
5649 tem
= invert_truthvalue (arg0
);
5650 /* Avoid infinite recursion. */
5651 if (TREE_CODE (tem
) == TRUTH_NOT_EXPR
)
5653 return convert (type
, tem
);
5655 case TRUTH_ANDIF_EXPR
:
5656 /* Note that the operands of this must be ints
5657 and their values must be 0 or 1.
5658 ("true" is a fixed value perhaps depending on the language.) */
5659 /* If first arg is constant zero, return it. */
5660 if (integer_zerop (arg0
))
5661 return convert (type
, arg0
);
5662 case TRUTH_AND_EXPR
:
5663 /* If either arg is constant true, drop it. */
5664 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
5665 return non_lvalue (convert (type
, arg1
));
5666 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
5667 /* Preserve sequence points. */
5668 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
5669 return non_lvalue (convert (type
, arg0
));
5670 /* If second arg is constant zero, result is zero, but first arg
5671 must be evaluated. */
5672 if (integer_zerop (arg1
))
5673 return omit_one_operand (type
, arg1
, arg0
);
5674 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5675 case will be handled here. */
5676 if (integer_zerop (arg0
))
5677 return omit_one_operand (type
, arg0
, arg1
);
5680 /* We only do these simplifications if we are optimizing. */
5684 /* Check for things like (A || B) && (A || C). We can convert this
5685 to A || (B && C). Note that either operator can be any of the four
5686 truth and/or operations and the transformation will still be
5687 valid. Also note that we only care about order for the
5688 ANDIF and ORIF operators. If B contains side effects, this
5689 might change the truth-value of A. */
5690 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
5691 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
5692 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
5693 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
5694 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
5695 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
5697 tree a00
= TREE_OPERAND (arg0
, 0);
5698 tree a01
= TREE_OPERAND (arg0
, 1);
5699 tree a10
= TREE_OPERAND (arg1
, 0);
5700 tree a11
= TREE_OPERAND (arg1
, 1);
5701 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
5702 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
5703 && (code
== TRUTH_AND_EXPR
5704 || code
== TRUTH_OR_EXPR
));
5706 if (operand_equal_p (a00
, a10
, 0))
5707 return fold (build (TREE_CODE (arg0
), type
, a00
,
5708 fold (build (code
, type
, a01
, a11
))));
5709 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
5710 return fold (build (TREE_CODE (arg0
), type
, a00
,
5711 fold (build (code
, type
, a01
, a10
))));
5712 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
5713 return fold (build (TREE_CODE (arg0
), type
, a01
,
5714 fold (build (code
, type
, a00
, a11
))));
5716 /* This case if tricky because we must either have commutative
5717 operators or else A10 must not have side-effects. */
5719 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
5720 && operand_equal_p (a01
, a11
, 0))
5721 return fold (build (TREE_CODE (arg0
), type
,
5722 fold (build (code
, type
, a00
, a10
)),
5726 /* See if we can build a range comparison. */
5727 if (0 != (tem
= fold_range_test (t
)))
5730 /* Check for the possibility of merging component references. If our
5731 lhs is another similar operation, try to merge its rhs with our
5732 rhs. Then try to merge our lhs and rhs. */
5733 if (TREE_CODE (arg0
) == code
5734 && 0 != (tem
= fold_truthop (code
, type
,
5735 TREE_OPERAND (arg0
, 1), arg1
)))
5736 return fold (build (code
, type
, TREE_OPERAND (arg0
, 0), tem
));
5738 if ((tem
= fold_truthop (code
, type
, arg0
, arg1
)) != 0)
5743 case TRUTH_ORIF_EXPR
:
5744 /* Note that the operands of this must be ints
5745 and their values must be 0 or true.
5746 ("true" is a fixed value perhaps depending on the language.) */
5747 /* If first arg is constant true, return it. */
5748 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
5749 return convert (type
, arg0
);
5751 /* If either arg is constant zero, drop it. */
5752 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
5753 return non_lvalue (convert (type
, arg1
));
5754 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
5755 /* Preserve sequence points. */
5756 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
5757 return non_lvalue (convert (type
, arg0
));
5758 /* If second arg is constant true, result is true, but we must
5759 evaluate first arg. */
5760 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
5761 return omit_one_operand (type
, arg1
, arg0
);
5762 /* Likewise for first arg, but note this only occurs here for
5764 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
5765 return omit_one_operand (type
, arg0
, arg1
);
5768 case TRUTH_XOR_EXPR
:
5769 /* If either arg is constant zero, drop it. */
5770 if (integer_zerop (arg0
))
5771 return non_lvalue (convert (type
, arg1
));
5772 if (integer_zerop (arg1
))
5773 return non_lvalue (convert (type
, arg0
));
5774 /* If either arg is constant true, this is a logical inversion. */
5775 if (integer_onep (arg0
))
5776 return non_lvalue (convert (type
, invert_truthvalue (arg1
)));
5777 if (integer_onep (arg1
))
5778 return non_lvalue (convert (type
, invert_truthvalue (arg0
)));
5787 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
5789 /* (-a) CMP (-b) -> b CMP a */
5790 if (TREE_CODE (arg0
) == NEGATE_EXPR
5791 && TREE_CODE (arg1
) == NEGATE_EXPR
)
5792 return fold (build (code
, type
, TREE_OPERAND (arg1
, 0),
5793 TREE_OPERAND (arg0
, 0)));
5794 /* (-a) CMP CST -> a swap(CMP) (-CST) */
5795 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& TREE_CODE (arg1
) == REAL_CST
)
5798 (swap_tree_comparison (code
), type
,
5799 TREE_OPERAND (arg0
, 0),
5800 build_real (TREE_TYPE (arg1
),
5801 REAL_VALUE_NEGATE (TREE_REAL_CST (arg1
)))));
5802 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
5803 /* a CMP (-0) -> a CMP 0 */
5804 if (TREE_CODE (arg1
) == REAL_CST
5805 && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (arg1
)))
5806 return fold (build (code
, type
, arg0
,
5807 build_real (TREE_TYPE (arg1
), dconst0
)));
5810 /* If one arg is a constant integer, put it last. */
5811 if (TREE_CODE (arg0
) == INTEGER_CST
5812 && TREE_CODE (arg1
) != INTEGER_CST
)
5814 TREE_OPERAND (t
, 0) = arg1
;
5815 TREE_OPERAND (t
, 1) = arg0
;
5816 arg0
= TREE_OPERAND (t
, 0);
5817 arg1
= TREE_OPERAND (t
, 1);
5818 code
= swap_tree_comparison (code
);
5819 TREE_SET_CODE (t
, code
);
5822 /* Convert foo++ == CONST into ++foo == CONST + INCR.
5823 First, see if one arg is constant; find the constant arg
5824 and the other one. */
5826 tree constop
= 0, varop
= NULL_TREE
;
5827 int constopnum
= -1;
5829 if (TREE_CONSTANT (arg1
))
5830 constopnum
= 1, constop
= arg1
, varop
= arg0
;
5831 if (TREE_CONSTANT (arg0
))
5832 constopnum
= 0, constop
= arg0
, varop
= arg1
;
5834 if (constop
&& TREE_CODE (varop
) == POSTINCREMENT_EXPR
)
5836 /* This optimization is invalid for ordered comparisons
5837 if CONST+INCR overflows or if foo+incr might overflow.
5838 This optimization is invalid for floating point due to rounding.
5839 For pointer types we assume overflow doesn't happen. */
5840 if (POINTER_TYPE_P (TREE_TYPE (varop
))
5841 || (! FLOAT_TYPE_P (TREE_TYPE (varop
))
5842 && (code
== EQ_EXPR
|| code
== NE_EXPR
)))
5845 = fold (build (PLUS_EXPR
, TREE_TYPE (varop
),
5846 constop
, TREE_OPERAND (varop
, 1)));
5848 /* Do not overwrite the current varop to be a preincrement,
5849 create a new node so that we won't confuse our caller who
5850 might create trees and throw them away, reusing the
5851 arguments that they passed to build. This shows up in
5852 the THEN or ELSE parts of ?: being postincrements. */
5853 varop
= build (PREINCREMENT_EXPR
, TREE_TYPE (varop
),
5854 TREE_OPERAND (varop
, 0),
5855 TREE_OPERAND (varop
, 1));
5857 /* If VAROP is a reference to a bitfield, we must mask
5858 the constant by the width of the field. */
5859 if (TREE_CODE (TREE_OPERAND (varop
, 0)) == COMPONENT_REF
5860 && DECL_BIT_FIELD(TREE_OPERAND
5861 (TREE_OPERAND (varop
, 0), 1)))
5864 = TREE_INT_CST_LOW (DECL_SIZE
5866 (TREE_OPERAND (varop
, 0), 1)));
5867 tree mask
, unsigned_type
;
5868 unsigned int precision
;
5869 tree folded_compare
;
5871 /* First check whether the comparison would come out
5872 always the same. If we don't do that we would
5873 change the meaning with the masking. */
5874 if (constopnum
== 0)
5875 folded_compare
= fold (build (code
, type
, constop
,
5876 TREE_OPERAND (varop
, 0)));
5878 folded_compare
= fold (build (code
, type
,
5879 TREE_OPERAND (varop
, 0),
5881 if (integer_zerop (folded_compare
)
5882 || integer_onep (folded_compare
))
5883 return omit_one_operand (type
, folded_compare
, varop
);
5885 unsigned_type
= (*lang_hooks
.types
.type_for_size
)(size
, 1);
5886 precision
= TYPE_PRECISION (unsigned_type
);
5887 mask
= build_int_2 (~0, ~0);
5888 TREE_TYPE (mask
) = unsigned_type
;
5889 force_fit_type (mask
, 0);
5890 mask
= const_binop (RSHIFT_EXPR
, mask
,
5891 size_int (precision
- size
), 0);
5892 newconst
= fold (build (BIT_AND_EXPR
,
5893 TREE_TYPE (varop
), newconst
,
5894 convert (TREE_TYPE (varop
),
5898 t
= build (code
, type
,
5899 (constopnum
== 0) ? newconst
: varop
,
5900 (constopnum
== 1) ? newconst
: varop
);
5904 else if (constop
&& TREE_CODE (varop
) == POSTDECREMENT_EXPR
)
5906 if (POINTER_TYPE_P (TREE_TYPE (varop
))
5907 || (! FLOAT_TYPE_P (TREE_TYPE (varop
))
5908 && (code
== EQ_EXPR
|| code
== NE_EXPR
)))
5911 = fold (build (MINUS_EXPR
, TREE_TYPE (varop
),
5912 constop
, TREE_OPERAND (varop
, 1)));
5914 /* Do not overwrite the current varop to be a predecrement,
5915 create a new node so that we won't confuse our caller who
5916 might create trees and throw them away, reusing the
5917 arguments that they passed to build. This shows up in
5918 the THEN or ELSE parts of ?: being postdecrements. */
5919 varop
= build (PREDECREMENT_EXPR
, TREE_TYPE (varop
),
5920 TREE_OPERAND (varop
, 0),
5921 TREE_OPERAND (varop
, 1));
5923 if (TREE_CODE (TREE_OPERAND (varop
, 0)) == COMPONENT_REF
5924 && DECL_BIT_FIELD(TREE_OPERAND
5925 (TREE_OPERAND (varop
, 0), 1)))
5928 = TREE_INT_CST_LOW (DECL_SIZE
5930 (TREE_OPERAND (varop
, 0), 1)));
5931 tree mask
, unsigned_type
;
5932 unsigned int precision
;
5933 tree folded_compare
;
5935 if (constopnum
== 0)
5936 folded_compare
= fold (build (code
, type
, constop
,
5937 TREE_OPERAND (varop
, 0)));
5939 folded_compare
= fold (build (code
, type
,
5940 TREE_OPERAND (varop
, 0),
5942 if (integer_zerop (folded_compare
)
5943 || integer_onep (folded_compare
))
5944 return omit_one_operand (type
, folded_compare
, varop
);
5946 unsigned_type
= (*lang_hooks
.types
.type_for_size
)(size
, 1);
5947 precision
= TYPE_PRECISION (unsigned_type
);
5948 mask
= build_int_2 (~0, ~0);
5949 TREE_TYPE (mask
) = TREE_TYPE (varop
);
5950 force_fit_type (mask
, 0);
5951 mask
= const_binop (RSHIFT_EXPR
, mask
,
5952 size_int (precision
- size
), 0);
5953 newconst
= fold (build (BIT_AND_EXPR
,
5954 TREE_TYPE (varop
), newconst
,
5955 convert (TREE_TYPE (varop
),
5959 t
= build (code
, type
,
5960 (constopnum
== 0) ? newconst
: varop
,
5961 (constopnum
== 1) ? newconst
: varop
);
5967 /* Comparisons with the highest or lowest possible integer of
5968 the specified size will have known values and an unsigned
5969 <= 0x7fffffff can be simplified. */
5971 int width
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1
)));
5973 if (TREE_CODE (arg1
) == INTEGER_CST
5974 && ! TREE_CONSTANT_OVERFLOW (arg1
)
5975 && width
<= HOST_BITS_PER_WIDE_INT
5976 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
5977 || POINTER_TYPE_P (TREE_TYPE (arg1
))))
5979 if (TREE_INT_CST_HIGH (arg1
) == 0
5980 && (TREE_INT_CST_LOW (arg1
)
5981 == ((unsigned HOST_WIDE_INT
) 1 << (width
- 1)) - 1)
5982 && ! TREE_UNSIGNED (TREE_TYPE (arg1
)))
5983 switch (TREE_CODE (t
))
5986 return omit_one_operand (type
,
5987 convert (type
, integer_zero_node
),
5990 TREE_SET_CODE (t
, EQ_EXPR
);
5994 return omit_one_operand (type
,
5995 convert (type
, integer_one_node
),
5998 TREE_SET_CODE (t
, NE_EXPR
);
6005 else if (TREE_INT_CST_HIGH (arg1
) == -1
6006 && (TREE_INT_CST_LOW (arg1
)
6007 == ((unsigned HOST_WIDE_INT
) -1 << (width
- 1)))
6008 && ! TREE_UNSIGNED (TREE_TYPE (arg1
)))
6009 switch (TREE_CODE (t
))
6012 return omit_one_operand (type
,
6013 convert (type
, integer_zero_node
),
6016 TREE_SET_CODE (t
, EQ_EXPR
);
6020 return omit_one_operand (type
,
6021 convert (type
, integer_one_node
),
6024 TREE_SET_CODE (t
, NE_EXPR
);
6031 else if (TREE_INT_CST_HIGH (arg1
) == 0
6032 && (TREE_INT_CST_LOW (arg1
)
6033 == ((unsigned HOST_WIDE_INT
) 1 << (width
- 1)) - 1)
6034 && TREE_UNSIGNED (TREE_TYPE (arg1
))
6035 /* signed_type does not work on pointer types. */
6036 && INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
6038 if (TREE_CODE (t
) == LE_EXPR
|| TREE_CODE (t
) == GT_EXPR
)
6041 st0
= (*lang_hooks
.types
.signed_type
) (TREE_TYPE (arg0
));
6042 st1
= (*lang_hooks
.types
.signed_type
) (TREE_TYPE (arg1
));
6044 (build (TREE_CODE (t
) == LE_EXPR
? GE_EXPR
: LT_EXPR
,
6045 type
, convert (st0
, arg0
),
6046 convert (st1
, integer_zero_node
)));
6049 else if (TREE_INT_CST_HIGH (arg1
) == 0
6050 && (TREE_INT_CST_LOW (arg1
)
6051 == ((unsigned HOST_WIDE_INT
) 2 << (width
- 1)) - 1)
6052 && TREE_UNSIGNED (TREE_TYPE (arg1
)))
6053 switch (TREE_CODE (t
))
6056 return omit_one_operand (type
,
6057 convert (type
, integer_zero_node
),
6060 TREE_SET_CODE (t
, EQ_EXPR
);
6064 return omit_one_operand (type
,
6065 convert (type
, integer_one_node
),
6068 TREE_SET_CODE (t
, NE_EXPR
);
6077 /* Change X >= C to X > C-1 and X < C to X <= C-1 if C is positive. */
6078 if (TREE_CODE (arg1
) == INTEGER_CST
6079 && TREE_CODE (arg0
) != INTEGER_CST
6080 && tree_int_cst_sgn (arg1
) > 0)
6082 switch (TREE_CODE (t
))
6086 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
, 0);
6087 t
= build (code
, type
, TREE_OPERAND (t
, 0), arg1
);
6092 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
, 0);
6093 t
= build (code
, type
, TREE_OPERAND (t
, 0), arg1
);
6101 /* An unsigned comparison against 0 can be simplified. */
6102 if (integer_zerop (arg1
)
6103 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
6104 || POINTER_TYPE_P (TREE_TYPE (arg1
)))
6105 && TREE_UNSIGNED (TREE_TYPE (arg1
)))
6107 switch (TREE_CODE (t
))
6111 TREE_SET_CODE (t
, NE_EXPR
);
6115 TREE_SET_CODE (t
, EQ_EXPR
);
6118 return omit_one_operand (type
,
6119 convert (type
, integer_one_node
),
6122 return omit_one_operand (type
,
6123 convert (type
, integer_zero_node
),
6130 /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
6131 a MINUS_EXPR of a constant, we can convert it into a comparison with
6132 a revised constant as long as no overflow occurs. */
6133 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6134 && TREE_CODE (arg1
) == INTEGER_CST
6135 && (TREE_CODE (arg0
) == PLUS_EXPR
6136 || TREE_CODE (arg0
) == MINUS_EXPR
)
6137 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
6138 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
6139 ? MINUS_EXPR
: PLUS_EXPR
,
6140 arg1
, TREE_OPERAND (arg0
, 1), 0))
6141 && ! TREE_CONSTANT_OVERFLOW (tem
))
6142 return fold (build (code
, type
, TREE_OPERAND (arg0
, 0), tem
));
6144 /* Similarly for a NEGATE_EXPR. */
6145 else if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6146 && TREE_CODE (arg0
) == NEGATE_EXPR
6147 && TREE_CODE (arg1
) == INTEGER_CST
6148 && 0 != (tem
= negate_expr (arg1
))
6149 && TREE_CODE (tem
) == INTEGER_CST
6150 && ! TREE_CONSTANT_OVERFLOW (tem
))
6151 return fold (build (code
, type
, TREE_OPERAND (arg0
, 0), tem
));
6153 /* If we have X - Y == 0, we can convert that to X == Y and similarly
6154 for !=. Don't do this for ordered comparisons due to overflow. */
6155 else if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6156 && integer_zerop (arg1
) && TREE_CODE (arg0
) == MINUS_EXPR
)
6157 return fold (build (code
, type
,
6158 TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1)));
6160 /* If we are widening one operand of an integer comparison,
6161 see if the other operand is similarly being widened. Perhaps we
6162 can do the comparison in the narrower type. */
6163 else if (TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
6164 && TREE_CODE (arg0
) == NOP_EXPR
6165 && (tem
= get_unwidened (arg0
, NULL_TREE
)) != arg0
6166 && (t1
= get_unwidened (arg1
, TREE_TYPE (tem
))) != 0
6167 && (TREE_TYPE (t1
) == TREE_TYPE (tem
)
6168 || (TREE_CODE (t1
) == INTEGER_CST
6169 && int_fits_type_p (t1
, TREE_TYPE (tem
)))))
6170 return fold (build (code
, type
, tem
, convert (TREE_TYPE (tem
), t1
)));
6172 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
6173 constant, we can simplify it. */
6174 else if (TREE_CODE (arg1
) == INTEGER_CST
6175 && (TREE_CODE (arg0
) == MIN_EXPR
6176 || TREE_CODE (arg0
) == MAX_EXPR
)
6177 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
6178 return optimize_minmax_comparison (t
);
6180 /* If we are comparing an ABS_EXPR with a constant, we can
6181 convert all the cases into explicit comparisons, but they may
6182 well not be faster than doing the ABS and one comparison.
6183 But ABS (X) <= C is a range comparison, which becomes a subtraction
6184 and a comparison, and is probably faster. */
6185 else if (code
== LE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
6186 && TREE_CODE (arg0
) == ABS_EXPR
6187 && ! TREE_SIDE_EFFECTS (arg0
)
6188 && (0 != (tem
= negate_expr (arg1
)))
6189 && TREE_CODE (tem
) == INTEGER_CST
6190 && ! TREE_CONSTANT_OVERFLOW (tem
))
6191 return fold (build (TRUTH_ANDIF_EXPR
, type
,
6192 build (GE_EXPR
, type
, TREE_OPERAND (arg0
, 0), tem
),
6193 build (LE_EXPR
, type
,
6194 TREE_OPERAND (arg0
, 0), arg1
)));
6196 /* If this is an EQ or NE comparison with zero and ARG0 is
6197 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
6198 two operations, but the latter can be done in one less insn
6199 on machines that have only two-operand insns or on which a
6200 constant cannot be the first operand. */
6201 if (integer_zerop (arg1
) && (code
== EQ_EXPR
|| code
== NE_EXPR
)
6202 && TREE_CODE (arg0
) == BIT_AND_EXPR
)
6204 if (TREE_CODE (TREE_OPERAND (arg0
, 0)) == LSHIFT_EXPR
6205 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0)))
6207 fold (build (code
, type
,
6208 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
6210 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
6211 TREE_OPERAND (arg0
, 1),
6212 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1)),
6213 convert (TREE_TYPE (arg0
),
6216 else if (TREE_CODE (TREE_OPERAND (arg0
, 1)) == LSHIFT_EXPR
6217 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 1), 0)))
6219 fold (build (code
, type
,
6220 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
6222 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
6223 TREE_OPERAND (arg0
, 0),
6224 TREE_OPERAND (TREE_OPERAND (arg0
, 1), 1)),
6225 convert (TREE_TYPE (arg0
),
6230 /* If this is an NE or EQ comparison of zero against the result of a
6231 signed MOD operation whose second operand is a power of 2, make
6232 the MOD operation unsigned since it is simpler and equivalent. */
6233 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6234 && integer_zerop (arg1
)
6235 && ! TREE_UNSIGNED (TREE_TYPE (arg0
))
6236 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
6237 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
6238 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
6239 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
6240 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6242 tree newtype
= (*lang_hooks
.types
.unsigned_type
) (TREE_TYPE (arg0
));
6243 tree newmod
= build (TREE_CODE (arg0
), newtype
,
6244 convert (newtype
, TREE_OPERAND (arg0
, 0)),
6245 convert (newtype
, TREE_OPERAND (arg0
, 1)));
6247 return build (code
, type
, newmod
, convert (newtype
, arg1
));
6250 /* If this is an NE comparison of zero with an AND of one, remove the
6251 comparison since the AND will give the correct value. */
6252 if (code
== NE_EXPR
&& integer_zerop (arg1
)
6253 && TREE_CODE (arg0
) == BIT_AND_EXPR
6254 && integer_onep (TREE_OPERAND (arg0
, 1)))
6255 return convert (type
, arg0
);
6257 /* If we have (A & C) == C where C is a power of 2, convert this into
6258 (A & C) != 0. Similarly for NE_EXPR. */
6259 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6260 && TREE_CODE (arg0
) == BIT_AND_EXPR
6261 && integer_pow2p (TREE_OPERAND (arg0
, 1))
6262 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
6263 return fold (build (code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
6264 arg0
, integer_zero_node
));
6266 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6267 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6268 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6269 && TREE_CODE (arg0
) == BIT_AND_EXPR
6270 && integer_zerop (arg1
))
6272 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0),
6273 TREE_OPERAND (arg0
, 1));
6274 if (arg00
!= NULL_TREE
)
6276 tree stype
= (*lang_hooks
.types
.signed_type
) (TREE_TYPE (arg00
));
6277 return fold (build (code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
6278 convert (stype
, arg00
),
6279 convert (stype
, integer_zero_node
)));
6283 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
6284 and similarly for >= into !=. */
6285 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
6286 && TREE_UNSIGNED (TREE_TYPE (arg0
))
6287 && TREE_CODE (arg1
) == LSHIFT_EXPR
6288 && integer_onep (TREE_OPERAND (arg1
, 0)))
6289 return build (code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
6290 build (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
6291 TREE_OPERAND (arg1
, 1)),
6292 convert (TREE_TYPE (arg0
), integer_zero_node
));
6294 else if ((code
== LT_EXPR
|| code
== GE_EXPR
)
6295 && TREE_UNSIGNED (TREE_TYPE (arg0
))
6296 && (TREE_CODE (arg1
) == NOP_EXPR
6297 || TREE_CODE (arg1
) == CONVERT_EXPR
)
6298 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
6299 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
6301 build (code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
6302 convert (TREE_TYPE (arg0
),
6303 build (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
6304 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1))),
6305 convert (TREE_TYPE (arg0
), integer_zero_node
));
6307 /* Simplify comparison of something with itself. (For IEEE
6308 floating-point, we can only do some of these simplifications.) */
6309 if (operand_equal_p (arg0
, arg1
, 0))
6316 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
)))
6317 return constant_boolean_node (1, type
);
6319 TREE_SET_CODE (t
, code
);
6323 /* For NE, we can only do this simplification if integer. */
6324 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
6326 /* ... fall through ... */
6329 return constant_boolean_node (0, type
);
6335 /* If we are comparing an expression that just has comparisons
6336 of two integer values, arithmetic expressions of those comparisons,
6337 and constants, we can simplify it. There are only three cases
6338 to check: the two values can either be equal, the first can be
6339 greater, or the second can be greater. Fold the expression for
6340 those three values. Since each value must be 0 or 1, we have
6341 eight possibilities, each of which corresponds to the constant 0
6342 or 1 or one of the six possible comparisons.
6344 This handles common cases like (a > b) == 0 but also handles
6345 expressions like ((x > y) - (y > x)) > 0, which supposedly
6346 occur in macroized code. */
6348 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
6350 tree cval1
= 0, cval2
= 0;
6353 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
6354 /* Don't handle degenerate cases here; they should already
6355 have been handled anyway. */
6356 && cval1
!= 0 && cval2
!= 0
6357 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
6358 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
6359 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
6360 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
6361 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
6362 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
6363 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
6365 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
6366 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
6368 /* We can't just pass T to eval_subst in case cval1 or cval2
6369 was the same as ARG1. */
6372 = fold (build (code
, type
,
6373 eval_subst (arg0
, cval1
, maxval
, cval2
, minval
),
6376 = fold (build (code
, type
,
6377 eval_subst (arg0
, cval1
, maxval
, cval2
, maxval
),
6380 = fold (build (code
, type
,
6381 eval_subst (arg0
, cval1
, minval
, cval2
, maxval
),
6384 /* All three of these results should be 0 or 1. Confirm they
6385 are. Then use those values to select the proper code
6388 if ((integer_zerop (high_result
)
6389 || integer_onep (high_result
))
6390 && (integer_zerop (equal_result
)
6391 || integer_onep (equal_result
))
6392 && (integer_zerop (low_result
)
6393 || integer_onep (low_result
)))
6395 /* Make a 3-bit mask with the high-order bit being the
6396 value for `>', the next for '=', and the low for '<'. */
6397 switch ((integer_onep (high_result
) * 4)
6398 + (integer_onep (equal_result
) * 2)
6399 + integer_onep (low_result
))
6403 return omit_one_operand (type
, integer_zero_node
, arg0
);
6424 return omit_one_operand (type
, integer_one_node
, arg0
);
6427 t
= build (code
, type
, cval1
, cval2
);
6429 return save_expr (t
);
6436 /* If this is a comparison of a field, we may be able to simplify it. */
6437 if ((TREE_CODE (arg0
) == COMPONENT_REF
6438 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
6439 && (code
== EQ_EXPR
|| code
== NE_EXPR
)
6440 /* Handle the constant case even without -O
6441 to make sure the warnings are given. */
6442 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
6444 t1
= optimize_bit_field_compare (code
, type
, arg0
, arg1
);
6448 /* If this is a comparison of complex values and either or both sides
6449 are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6450 comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6451 This may prevent needless evaluations. */
6452 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6453 && TREE_CODE (TREE_TYPE (arg0
)) == COMPLEX_TYPE
6454 && (TREE_CODE (arg0
) == COMPLEX_EXPR
6455 || TREE_CODE (arg1
) == COMPLEX_EXPR
6456 || TREE_CODE (arg0
) == COMPLEX_CST
6457 || TREE_CODE (arg1
) == COMPLEX_CST
))
6459 tree subtype
= TREE_TYPE (TREE_TYPE (arg0
));
6460 tree real0
, imag0
, real1
, imag1
;
6462 arg0
= save_expr (arg0
);
6463 arg1
= save_expr (arg1
);
6464 real0
= fold (build1 (REALPART_EXPR
, subtype
, arg0
));
6465 imag0
= fold (build1 (IMAGPART_EXPR
, subtype
, arg0
));
6466 real1
= fold (build1 (REALPART_EXPR
, subtype
, arg1
));
6467 imag1
= fold (build1 (IMAGPART_EXPR
, subtype
, arg1
));
6469 return fold (build ((code
== EQ_EXPR
? TRUTH_ANDIF_EXPR
6472 fold (build (code
, type
, real0
, real1
)),
6473 fold (build (code
, type
, imag0
, imag1
))));
6476 /* Optimize comparisons of strlen vs zero to a compare of the
6477 first character of the string vs zero. To wit,
6478 strlen(ptr) == 0 => *ptr == 0
6479 strlen(ptr) != 0 => *ptr != 0
6480 Other cases should reduce to one of these two (or a constant)
6481 due to the return value of strlen being unsigned. */
6482 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
6483 && integer_zerop (arg1
)
6484 && TREE_CODE (arg0
) == CALL_EXPR
6485 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
)
6487 tree fndecl
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
6490 if (TREE_CODE (fndecl
) == FUNCTION_DECL
6491 && DECL_BUILT_IN (fndecl
)
6492 && DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_MD
6493 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
6494 && (arglist
= TREE_OPERAND (arg0
, 1))
6495 && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) == POINTER_TYPE
6496 && ! TREE_CHAIN (arglist
))
6497 return fold (build (code
, type
,
6498 build1 (INDIRECT_REF
, char_type_node
,
6499 TREE_VALUE(arglist
)),
6500 integer_zero_node
));
6503 /* From here on, the only cases we handle are when the result is
6504 known to be a constant.
6506 To compute GT, swap the arguments and do LT.
6507 To compute GE, do LT and invert the result.
6508 To compute LE, swap the arguments, do LT and invert the result.
6509 To compute NE, do EQ and invert the result.
6511 Therefore, the code below must handle only EQ and LT. */
6513 if (code
== LE_EXPR
|| code
== GT_EXPR
)
6515 tem
= arg0
, arg0
= arg1
, arg1
= tem
;
6516 code
= swap_tree_comparison (code
);
6519 /* Note that it is safe to invert for real values here because we
6520 will check below in the one case that it matters. */
6524 if (code
== NE_EXPR
|| code
== GE_EXPR
)
6527 code
= invert_tree_comparison (code
);
6530 /* Compute a result for LT or EQ if args permit;
6531 otherwise return T. */
6532 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
6534 if (code
== EQ_EXPR
)
6535 t1
= build_int_2 (tree_int_cst_equal (arg0
, arg1
), 0);
6537 t1
= build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0
))
6538 ? INT_CST_LT_UNSIGNED (arg0
, arg1
)
6539 : INT_CST_LT (arg0
, arg1
)),
6543 #if 0 /* This is no longer useful, but breaks some real code. */
6544 /* Assume a nonexplicit constant cannot equal an explicit one,
6545 since such code would be undefined anyway.
6546 Exception: on sysvr4, using #pragma weak,
6547 a label can come out as 0. */
6548 else if (TREE_CODE (arg1
) == INTEGER_CST
6549 && !integer_zerop (arg1
)
6550 && TREE_CONSTANT (arg0
)
6551 && TREE_CODE (arg0
) == ADDR_EXPR
6553 t1
= build_int_2 (0, 0);
6555 /* Two real constants can be compared explicitly. */
6556 else if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
6558 /* If either operand is a NaN, the result is false with two
6559 exceptions: First, an NE_EXPR is true on NaNs, but that case
6560 is already handled correctly since we will be inverting the
6561 result for NE_EXPR. Second, if we had inverted a LE_EXPR
6562 or a GE_EXPR into a LT_EXPR, we must return true so that it
6563 will be inverted into false. */
6565 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
6566 || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
)))
6567 t1
= build_int_2 (invert
&& code
== LT_EXPR
, 0);
6569 else if (code
== EQ_EXPR
)
6570 t1
= build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
),
6571 TREE_REAL_CST (arg1
)),
6574 t1
= build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0
),
6575 TREE_REAL_CST (arg1
)),
6579 if (t1
== NULL_TREE
)
6583 TREE_INT_CST_LOW (t1
) ^= 1;
6585 TREE_TYPE (t1
) = type
;
6586 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
6587 return (*lang_hooks
.truthvalue_conversion
) (t1
);
6591 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6592 so all simple results must be passed through pedantic_non_lvalue. */
6593 if (TREE_CODE (arg0
) == INTEGER_CST
)
6594 return pedantic_non_lvalue
6595 (TREE_OPERAND (t
, (integer_zerop (arg0
) ? 2 : 1)));
6596 else if (operand_equal_p (arg1
, TREE_OPERAND (expr
, 2), 0))
6597 return pedantic_omit_one_operand (type
, arg1
, arg0
);
6599 /* If the second operand is zero, invert the comparison and swap
6600 the second and third operands. Likewise if the second operand
6601 is constant and the third is not or if the third operand is
6602 equivalent to the first operand of the comparison. */
6604 if (integer_zerop (arg1
)
6605 || (TREE_CONSTANT (arg1
) && ! TREE_CONSTANT (TREE_OPERAND (t
, 2)))
6606 || (TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<'
6607 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
6608 TREE_OPERAND (t
, 2),
6609 TREE_OPERAND (arg0
, 1))))
6611 /* See if this can be inverted. If it can't, possibly because
6612 it was a floating-point inequality comparison, don't do
6614 tem
= invert_truthvalue (arg0
);
6616 if (TREE_CODE (tem
) != TRUTH_NOT_EXPR
)
6618 t
= build (code
, type
, tem
,
6619 TREE_OPERAND (t
, 2), TREE_OPERAND (t
, 1));
6621 /* arg1 should be the first argument of the new T. */
6622 arg1
= TREE_OPERAND (t
, 1);
6627 /* If we have A op B ? A : C, we may be able to convert this to a
6628 simpler expression, depending on the operation and the values
6629 of B and C. Signed zeros prevent all of these transformations,
6630 for reasons given above each one. */
6632 if (TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<'
6633 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
6634 arg1
, TREE_OPERAND (arg0
, 1))
6635 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
6637 tree arg2
= TREE_OPERAND (t
, 2);
6638 enum tree_code comp_code
= TREE_CODE (arg0
);
6642 /* If we have A op 0 ? A : -A, consider applying the following
6645 A == 0? A : -A same as -A
6646 A != 0? A : -A same as A
6647 A >= 0? A : -A same as abs (A)
6648 A > 0? A : -A same as abs (A)
6649 A <= 0? A : -A same as -abs (A)
6650 A < 0? A : -A same as -abs (A)
6652 None of these transformations work for modes with signed
6653 zeros. If A is +/-0, the first two transformations will
6654 change the sign of the result (from +0 to -0, or vice
6655 versa). The last four will fix the sign of the result,
6656 even though the original expressions could be positive or
6657 negative, depending on the sign of A.
6659 Note that all these transformations are correct if A is
6660 NaN, since the two alternatives (A and -A) are also NaNs. */
6661 if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0
, 1)))
6662 ? real_zerop (TREE_OPERAND (arg0
, 1))
6663 : integer_zerop (TREE_OPERAND (arg0
, 1)))
6664 && TREE_CODE (arg2
) == NEGATE_EXPR
6665 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
6673 (convert (TREE_TYPE (TREE_OPERAND (t
, 1)),
6676 return pedantic_non_lvalue (convert (type
, arg1
));
6679 if (TREE_UNSIGNED (TREE_TYPE (arg1
)))
6680 arg1
= convert ((*lang_hooks
.types
.signed_type
)
6681 (TREE_TYPE (arg1
)), arg1
);
6682 return pedantic_non_lvalue
6683 (convert (type
, fold (build1 (ABS_EXPR
,
6684 TREE_TYPE (arg1
), arg1
))));
6687 if (TREE_UNSIGNED (TREE_TYPE (arg1
)))
6688 arg1
= convert ((lang_hooks
.types
.signed_type
)
6689 (TREE_TYPE (arg1
)), arg1
);
6690 return pedantic_non_lvalue
6691 (negate_expr (convert (type
,
6692 fold (build1 (ABS_EXPR
,
6699 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
6700 A == 0 ? A : 0 is always 0 unless A is -0. Note that
6701 both transformations are correct when A is NaN: A != 0
6702 is then true, and A == 0 is false. */
6704 if (integer_zerop (TREE_OPERAND (arg0
, 1)) && integer_zerop (arg2
))
6706 if (comp_code
== NE_EXPR
)
6707 return pedantic_non_lvalue (convert (type
, arg1
));
6708 else if (comp_code
== EQ_EXPR
)
6709 return pedantic_non_lvalue (convert (type
, integer_zero_node
));
6712 /* Try some transformations of A op B ? A : B.
6714 A == B? A : B same as B
6715 A != B? A : B same as A
6716 A >= B? A : B same as max (A, B)
6717 A > B? A : B same as max (B, A)
6718 A <= B? A : B same as min (A, B)
6719 A < B? A : B same as min (B, A)
6721 As above, these transformations don't work in the presence
6722 of signed zeros. For example, if A and B are zeros of
6723 opposite sign, the first two transformations will change
6724 the sign of the result. In the last four, the original
6725 expressions give different results for (A=+0, B=-0) and
6726 (A=-0, B=+0), but the transformed expressions do not.
6728 The first two transformations are correct if either A or B
6729 is a NaN. In the first transformation, the condition will
6730 be false, and B will indeed be chosen. In the case of the
6731 second transformation, the condition A != B will be true,
6732 and A will be chosen.
6734 The conversions to max() and min() are not correct if B is
6735 a number and A is not. The conditions in the original
6736 expressions will be false, so all four give B. The min()
6737 and max() versions would give a NaN instead. */
6738 if (operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 1),
6739 arg2
, TREE_OPERAND (arg0
, 0)))
6741 tree comp_op0
= TREE_OPERAND (arg0
, 0);
6742 tree comp_op1
= TREE_OPERAND (arg0
, 1);
6743 tree comp_type
= TREE_TYPE (comp_op0
);
6745 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
6746 if (TYPE_MAIN_VARIANT (comp_type
) == TYPE_MAIN_VARIANT (type
))
6752 return pedantic_non_lvalue (convert (type
, arg2
));
6754 return pedantic_non_lvalue (convert (type
, arg1
));
6757 /* In C++ a ?: expression can be an lvalue, so put the
6758 operand which will be used if they are equal first
6759 so that we can convert this back to the
6760 corresponding COND_EXPR. */
6761 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
6762 return pedantic_non_lvalue
6763 (convert (type
, fold (build (MIN_EXPR
, comp_type
,
6764 (comp_code
== LE_EXPR
6765 ? comp_op0
: comp_op1
),
6766 (comp_code
== LE_EXPR
6767 ? comp_op1
: comp_op0
)))));
6771 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
6772 return pedantic_non_lvalue
6773 (convert (type
, fold (build (MAX_EXPR
, comp_type
,
6774 (comp_code
== GE_EXPR
6775 ? comp_op0
: comp_op1
),
6776 (comp_code
== GE_EXPR
6777 ? comp_op1
: comp_op0
)))));
6784 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6785 we might still be able to simplify this. For example,
6786 if C1 is one less or one more than C2, this might have started
6787 out as a MIN or MAX and been transformed by this function.
6788 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
6790 if (INTEGRAL_TYPE_P (type
)
6791 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
6792 && TREE_CODE (arg2
) == INTEGER_CST
)
6796 /* We can replace A with C1 in this case. */
6797 arg1
= convert (type
, TREE_OPERAND (arg0
, 1));
6798 t
= build (code
, type
, TREE_OPERAND (t
, 0), arg1
,
6799 TREE_OPERAND (t
, 2));
6803 /* If C1 is C2 + 1, this is min(A, C2). */
6804 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
), 1)
6805 && operand_equal_p (TREE_OPERAND (arg0
, 1),
6806 const_binop (PLUS_EXPR
, arg2
,
6807 integer_one_node
, 0), 1))
6808 return pedantic_non_lvalue
6809 (fold (build (MIN_EXPR
, type
, arg1
, arg2
)));
6813 /* If C1 is C2 - 1, this is min(A, C2). */
6814 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
), 1)
6815 && operand_equal_p (TREE_OPERAND (arg0
, 1),
6816 const_binop (MINUS_EXPR
, arg2
,
6817 integer_one_node
, 0), 1))
6818 return pedantic_non_lvalue
6819 (fold (build (MIN_EXPR
, type
, arg1
, arg2
)));
6823 /* If C1 is C2 - 1, this is max(A, C2). */
6824 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
), 1)
6825 && operand_equal_p (TREE_OPERAND (arg0
, 1),
6826 const_binop (MINUS_EXPR
, arg2
,
6827 integer_one_node
, 0), 1))
6828 return pedantic_non_lvalue
6829 (fold (build (MAX_EXPR
, type
, arg1
, arg2
)));
6833 /* If C1 is C2 + 1, this is max(A, C2). */
6834 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
), 1)
6835 && operand_equal_p (TREE_OPERAND (arg0
, 1),
6836 const_binop (PLUS_EXPR
, arg2
,
6837 integer_one_node
, 0), 1))
6838 return pedantic_non_lvalue
6839 (fold (build (MAX_EXPR
, type
, arg1
, arg2
)));
6848 /* If the second operand is simpler than the third, swap them
6849 since that produces better jump optimization results. */
6850 if ((TREE_CONSTANT (arg1
) || DECL_P (arg1
)
6851 || TREE_CODE (arg1
) == SAVE_EXPR
)
6852 && ! (TREE_CONSTANT (TREE_OPERAND (t
, 2))
6853 || DECL_P (TREE_OPERAND (t
, 2))
6854 || TREE_CODE (TREE_OPERAND (t
, 2)) == SAVE_EXPR
))
6856 /* See if this can be inverted. If it can't, possibly because
6857 it was a floating-point inequality comparison, don't do
6859 tem
= invert_truthvalue (arg0
);
6861 if (TREE_CODE (tem
) != TRUTH_NOT_EXPR
)
6863 t
= build (code
, type
, tem
,
6864 TREE_OPERAND (t
, 2), TREE_OPERAND (t
, 1));
6866 /* arg1 should be the first argument of the new T. */
6867 arg1
= TREE_OPERAND (t
, 1);
6872 /* Convert A ? 1 : 0 to simply A. */
6873 if (integer_onep (TREE_OPERAND (t
, 1))
6874 && integer_zerop (TREE_OPERAND (t
, 2))
6875 /* If we try to convert TREE_OPERAND (t, 0) to our type, the
6876 call to fold will try to move the conversion inside
6877 a COND, which will recurse. In that case, the COND_EXPR
6878 is probably the best choice, so leave it alone. */
6879 && type
== TREE_TYPE (arg0
))
6880 return pedantic_non_lvalue (arg0
);
6882 /* Look for expressions of the form A & 2 ? 2 : 0. The result of this
6883 operation is simply A & 2. */
6885 if (integer_zerop (TREE_OPERAND (t
, 2))
6886 && TREE_CODE (arg0
) == NE_EXPR
6887 && integer_zerop (TREE_OPERAND (arg0
, 1))
6888 && integer_pow2p (arg1
)
6889 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
6890 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
6892 return pedantic_non_lvalue (convert (type
, TREE_OPERAND (arg0
, 0)));
6897 /* When pedantic, a compound expression can be neither an lvalue
6898 nor an integer constant expression. */
6899 if (TREE_SIDE_EFFECTS (arg0
) || pedantic
)
6901 /* Don't let (0, 0) be null pointer constant. */
6902 if (integer_zerop (arg1
))
6903 return build1 (NOP_EXPR
, type
, arg1
);
6904 return convert (type
, arg1
);
6908 return build_complex (type
, arg0
, arg1
);
6912 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
6914 else if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
6915 return omit_one_operand (type
, TREE_OPERAND (arg0
, 0),
6916 TREE_OPERAND (arg0
, 1));
6917 else if (TREE_CODE (arg0
) == COMPLEX_CST
)
6918 return TREE_REALPART (arg0
);
6919 else if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
6920 return fold (build (TREE_CODE (arg0
), type
,
6921 fold (build1 (REALPART_EXPR
, type
,
6922 TREE_OPERAND (arg0
, 0))),
6923 fold (build1 (REALPART_EXPR
,
6924 type
, TREE_OPERAND (arg0
, 1)))));
6928 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
6929 return convert (type
, integer_zero_node
);
6930 else if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
6931 return omit_one_operand (type
, TREE_OPERAND (arg0
, 1),
6932 TREE_OPERAND (arg0
, 0));
6933 else if (TREE_CODE (arg0
) == COMPLEX_CST
)
6934 return TREE_IMAGPART (arg0
);
6935 else if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
6936 return fold (build (TREE_CODE (arg0
), type
,
6937 fold (build1 (IMAGPART_EXPR
, type
,
6938 TREE_OPERAND (arg0
, 0))),
6939 fold (build1 (IMAGPART_EXPR
, type
,
6940 TREE_OPERAND (arg0
, 1)))));
6943 /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6945 case CLEANUP_POINT_EXPR
:
6946 if (! has_cleanups (arg0
))
6947 return TREE_OPERAND (t
, 0);
6950 enum tree_code code0
= TREE_CODE (arg0
);
6951 int kind0
= TREE_CODE_CLASS (code0
);
6952 tree arg00
= TREE_OPERAND (arg0
, 0);
6955 if (kind0
== '1' || code0
== TRUTH_NOT_EXPR
)
6956 return fold (build1 (code0
, type
,
6957 fold (build1 (CLEANUP_POINT_EXPR
,
6958 TREE_TYPE (arg00
), arg00
))));
6960 if (kind0
== '<' || kind0
== '2'
6961 || code0
== TRUTH_ANDIF_EXPR
|| code0
== TRUTH_ORIF_EXPR
6962 || code0
== TRUTH_AND_EXPR
|| code0
== TRUTH_OR_EXPR
6963 || code0
== TRUTH_XOR_EXPR
)
6965 arg01
= TREE_OPERAND (arg0
, 1);
6967 if (TREE_CONSTANT (arg00
)
6968 || ((code0
== TRUTH_ANDIF_EXPR
|| code0
== TRUTH_ORIF_EXPR
)
6969 && ! has_cleanups (arg00
)))
6970 return fold (build (code0
, type
, arg00
,
6971 fold (build1 (CLEANUP_POINT_EXPR
,
6972 TREE_TYPE (arg01
), arg01
))));
6974 if (TREE_CONSTANT (arg01
))
6975 return fold (build (code0
, type
,
6976 fold (build1 (CLEANUP_POINT_EXPR
,
6977 TREE_TYPE (arg00
), arg00
)),
6985 /* Check for a built-in function. */
6986 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
6987 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr
, 0), 0))
6989 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (expr
, 0), 0)))
6991 tree tmp
= fold_builtin (expr
);
6999 } /* switch (code) */
7002 /* Determine if first argument is a multiple of second argument. Return 0 if
7003 it is not, or we cannot easily determined it to be.
7005 An example of the sort of thing we care about (at this point; this routine
7006 could surely be made more general, and expanded to do what the *_DIV_EXPR's
7007 fold cases do now) is discovering that
7009 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7015 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
7017 This code also handles discovering that
7019 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
7021 is a multiple of 8 so we don't have to worry about dealing with a
7024 Note that we *look* inside a SAVE_EXPR only to determine how it was
7025 calculated; it is not safe for fold to do much of anything else with the
7026 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
7027 at run time. For example, the latter example above *cannot* be implemented
7028 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
7029 evaluation time of the original SAVE_EXPR is not necessarily the same at
7030 the time the new expression is evaluated. The only optimization of this
7031 sort that would be valid is changing
7033 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
7037 SAVE_EXPR (I) * SAVE_EXPR (J)
7039 (where the same SAVE_EXPR (J) is used in the original and the
7040 transformed version). */
7043 multiple_of_p (type
, top
, bottom
)
7048 if (operand_equal_p (top
, bottom
, 0))
7051 if (TREE_CODE (type
) != INTEGER_TYPE
)
7054 switch (TREE_CODE (top
))
7057 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
7058 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
7062 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
7063 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
7066 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
7070 op1
= TREE_OPERAND (top
, 1);
7071 /* const_binop may not detect overflow correctly,
7072 so check for it explicitly here. */
7073 if (TYPE_PRECISION (TREE_TYPE (size_one_node
))
7074 > TREE_INT_CST_LOW (op1
)
7075 && TREE_INT_CST_HIGH (op1
) == 0
7076 && 0 != (t1
= convert (type
,
7077 const_binop (LSHIFT_EXPR
, size_one_node
,
7079 && ! TREE_OVERFLOW (t1
))
7080 return multiple_of_p (type
, t1
, bottom
);
7085 /* Can't handle conversions from non-integral or wider integral type. */
7086 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
7087 || (TYPE_PRECISION (type
)
7088 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
7091 /* .. fall through ... */
7094 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
7097 if (TREE_CODE (bottom
) != INTEGER_CST
7098 || (TREE_UNSIGNED (type
)
7099 && (tree_int_cst_sgn (top
) < 0
7100 || tree_int_cst_sgn (bottom
) < 0)))
7102 return integer_zerop (const_binop (TRUNC_MOD_EXPR
,
7110 /* Return true if `t' is known to be non-negative. */
7113 tree_expr_nonnegative_p (t
)
7116 switch (TREE_CODE (t
))
7122 return tree_int_cst_sgn (t
) >= 0;
7123 case TRUNC_DIV_EXPR
:
7125 case FLOOR_DIV_EXPR
:
7126 case ROUND_DIV_EXPR
:
7127 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0))
7128 && tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7129 case TRUNC_MOD_EXPR
:
7131 case FLOOR_MOD_EXPR
:
7132 case ROUND_MOD_EXPR
:
7133 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0));
7135 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 1))
7136 && tree_expr_nonnegative_p (TREE_OPERAND (t
, 2));
7138 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7140 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0))
7141 && tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7143 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0))
7144 || tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7146 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7148 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 1));
7150 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0));
7151 case NON_LVALUE_EXPR
:
7152 return tree_expr_nonnegative_p (TREE_OPERAND (t
, 0));
7154 return rtl_expr_nonnegative_p (RTL_EXPR_RTL (t
));
7157 if (truth_value_p (TREE_CODE (t
)))
7158 /* Truth values evaluate to 0 or 1, which is nonnegative. */
7161 /* We don't know sign of `t', so be conservative and return false. */
7166 /* Return true if `r' is known to be non-negative.
7167 Only handles constants at the moment. */
7170 rtl_expr_nonnegative_p (r
)
7173 switch (GET_CODE (r
))
7176 return INTVAL (r
) >= 0;
7179 if (GET_MODE (r
) == VOIDmode
)
7180 return CONST_DOUBLE_HIGH (r
) >= 0;
7188 units
= CONST_VECTOR_NUNITS (r
);
7190 for (i
= 0; i
< units
; ++i
)
7192 elt
= CONST_VECTOR_ELT (r
, i
);
7193 if (!rtl_expr_nonnegative_p (elt
))
7202 /* These are always nonnegative. */